Pass the RtcEventLog instance to ICE via JsepTransportController.
This CL fixes a bug that the RtcEventLog owned by PeerConnection was not
passed to P2PTransportChannel after JsepTransportController was
introduced to deprecate the legacy TransportController.
Bug: webrtc:9337
Change-Id: I406cd9c0761dfe67f969aa99c6141e1ab38249d5
Reviewed-on: https://webrtc-review.googlesource.com/79964
Commit-Queue: Qingsi Wang <qingsi@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23572}diff --git a/logging/BUILD.gn b/logging/BUILD.gn
index 4d91b69..ae38399 100644
--- a/logging/BUILD.gn
+++ b/logging/BUILD.gn
@@ -232,6 +232,23 @@
}
}
+rtc_source_set("fake_rtc_event_log") {
+ testonly = true
+ sources = [
+ "rtc_event_log/fake_rtc_event_log.cc",
+ "rtc_event_log/fake_rtc_event_log.h",
+ "rtc_event_log/fake_rtc_event_log_factory.cc",
+ "rtc_event_log/fake_rtc_event_log_factory.h",
+ ]
+
+ deps = [
+ ":ice_log",
+ ":rtc_event_log_api",
+ "../rtc_base:checks",
+ "../rtc_base:rtc_base",
+ ]
+}
+
if (rtc_enable_protobuf) {
proto_library("rtc_event_log_proto") {
sources = [
diff --git a/logging/rtc_event_log/fake_rtc_event_log.cc b/logging/rtc_event_log/fake_rtc_event_log.cc
new file mode 100644
index 0000000..55f4b58
--- /dev/null
+++ b/logging/rtc_event_log/fake_rtc_event_log.cc
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "logging/rtc_event_log/fake_rtc_event_log.h"
+
+#include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h"
+#include "rtc_base/bind.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/logging.h"
+
+namespace webrtc {
+
+FakeRtcEventLog::FakeRtcEventLog(rtc::Thread* thread) : thread_(thread) {
+ RTC_DCHECK(thread_);
+}
+FakeRtcEventLog::~FakeRtcEventLog() = default;
+
+bool FakeRtcEventLog::StartLogging(std::unique_ptr<RtcEventLogOutput> output,
+ int64_t output_period_ms) {
+ return true;
+}
+
+void FakeRtcEventLog::StopLogging() {
+ invoker_.Flush(thread_);
+}
+
+void FakeRtcEventLog::Log(std::unique_ptr<RtcEvent> event) {
+ RtcEvent::Type rtc_event_type = event->GetType();
+ invoker_.AsyncInvoke<void>(
+ RTC_FROM_HERE, thread_,
+ rtc::Bind(&FakeRtcEventLog::IncrementEventCount, this, rtc_event_type));
+}
+
+} // namespace webrtc
diff --git a/logging/rtc_event_log/fake_rtc_event_log.h b/logging/rtc_event_log/fake_rtc_event_log.h
new file mode 100644
index 0000000..c5ea08a
--- /dev/null
+++ b/logging/rtc_event_log/fake_rtc_event_log.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef LOGGING_RTC_EVENT_LOG_FAKE_RTC_EVENT_LOG_H_
+#define LOGGING_RTC_EVENT_LOG_FAKE_RTC_EVENT_LOG_H_
+
+#include <map>
+#include <memory>
+
+#include "logging/rtc_event_log/events/rtc_event.h"
+#include "logging/rtc_event_log/rtc_event_log.h"
+#include "rtc_base/asyncinvoker.h"
+#include "rtc_base/thread.h"
+
+namespace webrtc {
+
+class FakeRtcEventLog : public RtcEventLog {
+ public:
+ explicit FakeRtcEventLog(rtc::Thread* thread);
+ ~FakeRtcEventLog() override;
+ bool StartLogging(std::unique_ptr<RtcEventLogOutput> output,
+ int64_t output_period_ms) override;
+ void StopLogging() override;
+ void Log(std::unique_ptr<RtcEvent> event) override;
+ int GetEventCount(RtcEvent::Type event_type) { return count_[event_type]; }
+
+ private:
+ void IncrementEventCount(RtcEvent::Type event_type) { ++count_[event_type]; }
+ std::map<RtcEvent::Type, int> count_;
+ rtc::Thread* thread_;
+ rtc::AsyncInvoker invoker_;
+};
+
+} // namespace webrtc
+
+#endif // LOGGING_RTC_EVENT_LOG_FAKE_RTC_EVENT_LOG_H_
diff --git a/logging/rtc_event_log/fake_rtc_event_log_factory.cc b/logging/rtc_event_log/fake_rtc_event_log_factory.cc
new file mode 100644
index 0000000..b3f638c
--- /dev/null
+++ b/logging/rtc_event_log/fake_rtc_event_log_factory.cc
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "logging/rtc_event_log/fake_rtc_event_log_factory.h"
+
+#include <utility>
+
+#include "logging/rtc_event_log/rtc_event_log.h"
+
+namespace webrtc {
+
+std::unique_ptr<RtcEventLog> FakeRtcEventLogFactory::CreateRtcEventLog(
+ RtcEventLog::EncodingType encoding_type) {
+ std::unique_ptr<RtcEventLog> fake_event_log(new FakeRtcEventLog(thread()));
+ last_log_created_ = fake_event_log.get();
+ return fake_event_log;
+}
+
+std::unique_ptr<RtcEventLog> FakeRtcEventLogFactory::CreateRtcEventLog(
+ RtcEventLog::EncodingType encoding_type,
+ std::unique_ptr<rtc::TaskQueue> task_queue) {
+ std::unique_ptr<RtcEventLog> fake_event_log(new FakeRtcEventLog(thread()));
+ last_log_created_ = fake_event_log.get();
+ return fake_event_log;
+}
+
+} // namespace webrtc
diff --git a/logging/rtc_event_log/fake_rtc_event_log_factory.h b/logging/rtc_event_log/fake_rtc_event_log_factory.h
new file mode 100644
index 0000000..1160e54
--- /dev/null
+++ b/logging/rtc_event_log/fake_rtc_event_log_factory.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef LOGGING_RTC_EVENT_LOG_FAKE_RTC_EVENT_LOG_FACTORY_H_
+#define LOGGING_RTC_EVENT_LOG_FAKE_RTC_EVENT_LOG_FACTORY_H_
+
+#include <memory>
+
+#include "logging/rtc_event_log/fake_rtc_event_log.h"
+#include "logging/rtc_event_log/rtc_event_log_factory_interface.h"
+#include "rtc_base/thread.h"
+
+namespace webrtc {
+
+class FakeRtcEventLogFactory : public RtcEventLogFactoryInterface {
+ public:
+ explicit FakeRtcEventLogFactory(rtc::Thread* thread) : thread_(thread) {}
+ ~FakeRtcEventLogFactory() override {}
+
+ std::unique_ptr<RtcEventLog> CreateRtcEventLog(
+ RtcEventLog::EncodingType encoding_type) override;
+
+ std::unique_ptr<RtcEventLog> CreateRtcEventLog(
+ RtcEventLog::EncodingType encoding_type,
+ std::unique_ptr<rtc::TaskQueue> task_queue) override;
+
+ webrtc::RtcEventLog* last_log_created() { return last_log_created_; }
+ rtc::Thread* thread() { return thread_; }
+
+ private:
+ webrtc::RtcEventLog* last_log_created_;
+ rtc::Thread* thread_;
+};
+
+} // namespace webrtc
+
+#endif // LOGGING_RTC_EVENT_LOG_FAKE_RTC_EVENT_LOG_FACTORY_H_
diff --git a/pc/BUILD.gn b/pc/BUILD.gn
index e0b701d..a7a7c56 100644
--- a/pc/BUILD.gn
+++ b/pc/BUILD.gn
@@ -74,6 +74,7 @@
"../call:rtp_interfaces",
"../call:rtp_receiver",
"../common_video:common_video",
+ "../logging:rtc_event_log_api",
"../media:rtc_data",
"../media:rtc_h264_profile_id",
"../media:rtc_media_base",
@@ -485,6 +486,7 @@
"../api:libjingle_peerconnection_api",
"../api:mock_rtp",
"../api/units:time_delta",
+ "../logging:fake_rtc_event_log",
"../rtc_base:checks",
"../rtc_base:stringutils",
"../test:fileutils",
diff --git a/pc/jseptransportcontroller.cc b/pc/jseptransportcontroller.cc
index d05339e..2d3eeb9 100644
--- a/pc/jseptransportcontroller.cc
+++ b/pc/jseptransportcontroller.cc
@@ -394,7 +394,7 @@
std::move(ice), config_.crypto_options);
} else {
auto ice = rtc::MakeUnique<cricket::P2PTransportChannel>(
- transport_name, component, port_allocator_);
+ transport_name, component, port_allocator_, config_.event_log);
dtls = rtc::MakeUnique<cricket::DtlsTransport>(std::move(ice),
config_.crypto_options);
}
diff --git a/pc/jseptransportcontroller.h b/pc/jseptransportcontroller.h
index ebe105b..dee05fa 100644
--- a/pc/jseptransportcontroller.h
+++ b/pc/jseptransportcontroller.h
@@ -19,6 +19,7 @@
#include "api/candidate.h"
#include "api/peerconnectioninterface.h"
+#include "logging/rtc_event_log/rtc_event_log.h"
#include "media/sctp/sctptransportinternal.h"
#include "p2p/base/dtlstransport.h"
#include "p2p/base/p2ptransportchannel.h"
@@ -77,6 +78,7 @@
// Used to inject the ICE/DTLS transports created externally.
cricket::TransportFactoryInterface* external_transport_factory = nullptr;
Observer* transport_observer = nullptr;
+ RtcEventLog* event_log = nullptr;
};
// The ICE related events are signaled on the |signaling_thread|.
@@ -317,7 +319,7 @@
rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
rtc::AsyncInvoker invoker_;
- webrtc::MetricsObserverInterface* metrics_observer_ = nullptr;
+ MetricsObserverInterface* metrics_observer_ = nullptr;
RTC_DISALLOW_COPY_AND_ASSIGN(JsepTransportController);
};
diff --git a/pc/peerconnection.cc b/pc/peerconnection.cc
index 0a984a7..093e72d 100644
--- a/pc/peerconnection.cc
+++ b/pc/peerconnection.cc
@@ -934,6 +934,7 @@
config.rtcp_mux_policy = configuration.rtcp_mux_policy;
config.crypto_options = options.crypto_options;
config.transport_observer = this;
+ config.event_log = event_log_.get();
#if defined(ENABLE_EXTERNAL_AUTH)
config.enable_external_auth = true;
#endif
diff --git a/pc/peerconnection_integrationtest.cc b/pc/peerconnection_integrationtest.cc
index ecd84d1..186da00 100644
--- a/pc/peerconnection_integrationtest.cc
+++ b/pc/peerconnection_integrationtest.cc
@@ -33,7 +33,12 @@
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
#include "api/video_codecs/sdp_video_format.h"
+#include "call/call.h"
+#include "logging/rtc_event_log/fake_rtc_event_log_factory.h"
+#include "logging/rtc_event_log/rtc_event_log_factory_interface.h"
#include "media/engine/fakewebrtcvideoengine.h"
+#include "media/engine/webrtcmediaengine.h"
+#include "modules/audio_processing/include/audio_processing.h"
#include "p2p/base/p2pconstants.h"
#include "p2p/base/portinterface.h"
#include "p2p/base/teststunserver.h"
@@ -239,7 +244,7 @@
webrtc::PeerConnectionDependencies dependencies(nullptr);
dependencies.cert_generator = std::move(cert_generator);
if (!client->Init(nullptr, nullptr, nullptr, std::move(dependencies),
- network_thread, worker_thread)) {
+ network_thread, worker_thread, nullptr)) {
delete client;
return nullptr;
}
@@ -555,6 +560,10 @@
}
cricket::PortAllocator* port_allocator() const { return port_allocator_; }
+ webrtc::FakeRtcEventLogFactory* event_log_factory() const {
+ return event_log_factory_;
+ }
+
private:
explicit PeerConnectionWrapper(const std::string& debug_name)
: debug_name_(debug_name) {}
@@ -564,7 +573,8 @@
const PeerConnectionInterface::RTCConfiguration* config,
webrtc::PeerConnectionDependencies dependencies,
rtc::Thread* network_thread,
- rtc::Thread* worker_thread) {
+ rtc::Thread* worker_thread,
+ std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory) {
// There's an error in this test code if Init ends up being called twice.
RTC_DCHECK(!peer_connection_);
RTC_DCHECK(!peer_connection_factory_);
@@ -580,15 +590,31 @@
return false;
}
rtc::Thread* const signaling_thread = rtc::Thread::Current();
- peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
- network_thread, worker_thread, signaling_thread,
- rtc::scoped_refptr<webrtc::AudioDeviceModule>(
- fake_audio_capture_module_),
- webrtc::CreateBuiltinAudioEncoderFactory(),
- webrtc::CreateBuiltinAudioDecoderFactory(),
- webrtc::CreateBuiltinVideoEncoderFactory(),
- webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
- nullptr /* audio_processing */);
+
+ webrtc::PeerConnectionFactoryDependencies pc_factory_dependencies;
+ pc_factory_dependencies.network_thread = network_thread;
+ pc_factory_dependencies.worker_thread = worker_thread;
+ pc_factory_dependencies.signaling_thread = signaling_thread;
+ pc_factory_dependencies.media_engine =
+ cricket::WebRtcMediaEngineFactory::Create(
+ rtc::scoped_refptr<webrtc::AudioDeviceModule>(
+ fake_audio_capture_module_),
+ webrtc::CreateBuiltinAudioEncoderFactory(),
+ webrtc::CreateBuiltinAudioDecoderFactory(),
+ webrtc::CreateBuiltinVideoEncoderFactory(),
+ webrtc::CreateBuiltinVideoDecoderFactory(), nullptr,
+ webrtc::AudioProcessingBuilder().Create());
+ pc_factory_dependencies.call_factory = webrtc::CreateCallFactory();
+ if (event_log_factory) {
+ event_log_factory_ = event_log_factory.get();
+ pc_factory_dependencies.event_log_factory = std::move(event_log_factory);
+ } else {
+ pc_factory_dependencies.event_log_factory =
+ webrtc::CreateRtcEventLogFactory();
+ }
+ peer_connection_factory_ = webrtc::CreateModularPeerConnectionFactory(
+ std::move(pc_factory_dependencies));
+
if (!peer_connection_factory_) {
return false;
}
@@ -952,6 +978,8 @@
std::vector<PeerConnectionInterface::IceGatheringState>
ice_gathering_state_history_;
+ webrtc::FakeRtcEventLogFactory* event_log_factory_;
+
rtc::AsyncInvoker invoker_;
friend class PeerConnectionIntegrationBaseTest;
@@ -1114,12 +1142,15 @@
webrtc::PeerConnectionInterface::kIceConnectionCompleted);
}
+ // When |event_log_factory| is null, the default implementation of the event
+ // log factory will be used.
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnectionWrapper(
const std::string& debug_name,
const MediaConstraintsInterface* constraints,
const PeerConnectionFactory::Options* options,
const RTCConfiguration* config,
- webrtc::PeerConnectionDependencies dependencies) {
+ webrtc::PeerConnectionDependencies dependencies,
+ std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory) {
RTCConfiguration modified_config;
if (config) {
modified_config = *config;
@@ -1134,12 +1165,26 @@
if (!client->Init(constraints, options, &modified_config,
std::move(dependencies), network_thread_.get(),
- worker_thread_.get())) {
+ worker_thread_.get(), std::move(event_log_factory))) {
return nullptr;
}
return client;
}
+ std::unique_ptr<PeerConnectionWrapper>
+ CreatePeerConnectionWrapperWithFakeRtcEventLog(
+ const std::string& debug_name,
+ const MediaConstraintsInterface* constraints,
+ const PeerConnectionFactory::Options* options,
+ const RTCConfiguration* config,
+ webrtc::PeerConnectionDependencies dependencies) {
+ std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory(
+ new webrtc::FakeRtcEventLogFactory(rtc::Thread::Current()));
+ return CreatePeerConnectionWrapper(debug_name, constraints, options, config,
+ std::move(dependencies),
+ std::move(event_log_factory));
+ }
+
bool CreatePeerConnectionWrappers() {
return CreatePeerConnectionWrappersWithConfig(
PeerConnectionInterface::RTCConfiguration(),
@@ -1158,11 +1203,11 @@
sdp_semantics_ = caller_semantics;
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, nullptr, nullptr,
- webrtc::PeerConnectionDependencies(nullptr));
+ webrtc::PeerConnectionDependencies(nullptr), nullptr);
sdp_semantics_ = callee_semantics;
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, nullptr, nullptr,
- webrtc::PeerConnectionDependencies(nullptr));
+ webrtc::PeerConnectionDependencies(nullptr), nullptr);
sdp_semantics_ = original_semantics;
return caller_ && callee_;
}
@@ -1172,10 +1217,10 @@
MediaConstraintsInterface* callee_constraints) {
caller_ = CreatePeerConnectionWrapper(
"Caller", caller_constraints, nullptr, nullptr,
- webrtc::PeerConnectionDependencies(nullptr));
+ webrtc::PeerConnectionDependencies(nullptr), nullptr);
callee_ = CreatePeerConnectionWrapper(
"Callee", callee_constraints, nullptr, nullptr,
- webrtc::PeerConnectionDependencies(nullptr));
+ webrtc::PeerConnectionDependencies(nullptr), nullptr);
return caller_ && callee_;
}
@@ -1185,10 +1230,10 @@
const PeerConnectionInterface::RTCConfiguration& callee_config) {
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, nullptr, &caller_config,
- webrtc::PeerConnectionDependencies(nullptr));
+ webrtc::PeerConnectionDependencies(nullptr), nullptr);
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, nullptr, &callee_config,
- webrtc::PeerConnectionDependencies(nullptr));
+ webrtc::PeerConnectionDependencies(nullptr), nullptr);
return caller_ && callee_;
}
@@ -1199,10 +1244,10 @@
webrtc::PeerConnectionDependencies callee_dependencies) {
caller_ =
CreatePeerConnectionWrapper("Caller", nullptr, nullptr, &caller_config,
- std::move(caller_dependencies));
+ std::move(caller_dependencies), nullptr);
callee_ =
CreatePeerConnectionWrapper("Callee", nullptr, nullptr, &callee_config,
- std::move(callee_dependencies));
+ std::move(callee_dependencies), nullptr);
return caller_ && callee_;
}
@@ -1211,9 +1256,20 @@
const PeerConnectionFactory::Options& callee_options) {
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, &caller_options, nullptr,
- webrtc::PeerConnectionDependencies(nullptr));
+ webrtc::PeerConnectionDependencies(nullptr), nullptr);
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, &callee_options, nullptr,
+ webrtc::PeerConnectionDependencies(nullptr), nullptr);
+ return caller_ && callee_;
+ }
+
+ bool CreatePeerConnectionWrappersWithFakeRtcEventLog() {
+ PeerConnectionInterface::RTCConfiguration default_config;
+ caller_ = CreatePeerConnectionWrapperWithFakeRtcEventLog(
+ "Caller", nullptr, nullptr, &default_config,
+ webrtc::PeerConnectionDependencies(nullptr));
+ callee_ = CreatePeerConnectionWrapperWithFakeRtcEventLog(
+ "Callee", nullptr, nullptr, &default_config,
webrtc::PeerConnectionDependencies(nullptr));
return caller_ && callee_;
}
@@ -1227,7 +1283,7 @@
webrtc::PeerConnectionDependencies dependencies(nullptr);
dependencies.cert_generator = std::move(cert_generator);
return CreatePeerConnectionWrapper("New Peer", nullptr, nullptr, nullptr,
- std::move(dependencies));
+ std::move(dependencies), nullptr);
}
// Once called, SDP blobs and ICE candidates will be automatically signaled
@@ -4354,6 +4410,39 @@
}
#endif // HAVE_SCTP
+TEST_P(PeerConnectionIntegrationTest,
+ IceEventsGeneratedAndLoggedInRtcEventLog) {
+ ASSERT_TRUE(CreatePeerConnectionWrappersWithFakeRtcEventLog());
+ ConnectFakeSignaling();
+ PeerConnectionInterface::RTCOfferAnswerOptions options;
+ options.offer_to_receive_audio = 1;
+ caller()->SetOfferAnswerOptions(options);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(DtlsConnected(), kDefaultTimeout);
+ ASSERT_NE(nullptr, caller()->event_log_factory());
+ ASSERT_NE(nullptr, callee()->event_log_factory());
+ webrtc::FakeRtcEventLog* caller_event_log =
+ static_cast<webrtc::FakeRtcEventLog*>(
+ caller()->event_log_factory()->last_log_created());
+ webrtc::FakeRtcEventLog* callee_event_log =
+ static_cast<webrtc::FakeRtcEventLog*>(
+ callee()->event_log_factory()->last_log_created());
+ ASSERT_NE(nullptr, caller_event_log);
+ ASSERT_NE(nullptr, callee_event_log);
+ int caller_ice_config_count = caller_event_log->GetEventCount(
+ webrtc::RtcEvent::Type::IceCandidatePairConfig);
+ int caller_ice_event_count = caller_event_log->GetEventCount(
+ webrtc::RtcEvent::Type::IceCandidatePairEvent);
+ int callee_ice_config_count = callee_event_log->GetEventCount(
+ webrtc::RtcEvent::Type::IceCandidatePairConfig);
+ int callee_ice_event_count = callee_event_log->GetEventCount(
+ webrtc::RtcEvent::Type::IceCandidatePairEvent);
+ EXPECT_LT(0, caller_ice_config_count);
+ EXPECT_LT(0, caller_ice_event_count);
+ EXPECT_LT(0, callee_ice_config_count);
+ EXPECT_LT(0, callee_ice_event_count);
+}
+
INSTANTIATE_TEST_CASE_P(PeerConnectionIntegrationTest,
PeerConnectionIntegrationTest,
Values(SdpSemantics::kPlanB,
