Add NetworkManager to PeerConnectionFactoryDependencies

Bug: webrtc:7447
Change-Id: I5abe1c4a15b52e9f15bb3ccbf1919c88000c9828
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/266361
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37284}

api/peer_connection_interface.h

@@ -1433,6 +1433,9 @@ struct RTC_EXPORT PeerConnectionFactoryDependencies final {
   // This will only be used if CreatePeerConnection is called without a
   // `port_allocator`, causing the default allocator and network manager to be
   // used.
+  std::unique_ptr<rtc::NetworkManager> network_manager;
+  // This will only be used if CreatePeerConnection is called without a
+  // `port_allocator`, and the above `network_manager' is null.
   std::unique_ptr<rtc::NetworkMonitorFactory> network_monitor_factory;
   std::unique_ptr<NetEqFactory> neteq_factory;
   std::unique_ptr<SctpTransportFactoryInterface> sctp_factory;

pc/connection_context.cc

@@ -102,12 +102,16 @@ ConnectionContext::ConnectionContext(
       media_engine_(std::move(dependencies->media_engine)),
       network_monitor_factory_(
           std::move(dependencies->network_monitor_factory)),
+      default_network_manager_(std::move(dependencies->network_manager)),
       call_factory_(std::move(dependencies->call_factory)),
       sctp_factory_(
           MaybeCreateSctpFactory(std::move(dependencies->sctp_factory),
                                  network_thread(),
                                  *trials_.get())) {
   RTC_DCHECK_RUN_ON(signaling_thread_);
+  RTC_DCHECK(!(default_network_manager_ && network_monitor_factory_))
+      << "You can't set both network_manager and network_monitor_factory.";
+
   signaling_thread_->AllowInvokesToThread(worker_thread());
   signaling_thread_->AllowInvokesToThread(network_thread_);
   worker_thread_->AllowInvokesToThread(network_thread_);
@@ -141,11 +145,12 @@ ConnectionContext::ConnectionContext(
       socket_factory = network_thread()->socketserver();
     }
   }
-  // If network_monitor_factory_ is non-null, it will be used to create a
-  // network monitor while on the network thread.
-  default_network_manager_ = std::make_unique<rtc::BasicNetworkManager>(
-      network_monitor_factory_.get(), socket_factory, &field_trials());
-
+  if (!default_network_manager_) {
+    // If network_monitor_factory_ is non-null, it will be used to create a
+    // network monitor while on the network thread.
+    default_network_manager_ = std::make_unique<rtc::BasicNetworkManager>(
+        network_monitor_factory_.get(), socket_factory, &field_trials());
+  }
   default_socket_factory_ =
       std::make_unique<rtc::BasicPacketSocketFactory>(socket_factory);
 

pc/connection_context.h

@@ -37,7 +37,6 @@ class ChannelManager;
 }
 
 namespace rtc {
-class BasicNetworkManager;
 class BasicPacketSocketFactory;
 class UniqueRandomIdGenerator;
 }  // namespace rtc
@@ -88,7 +87,7 @@ class ConnectionContext final
   const FieldTrialsView& field_trials() const { return *trials_.get(); }
 
   // Accessors only used from the PeerConnectionFactory class
-  rtc::BasicNetworkManager* default_network_manager() {
+  rtc::NetworkManager* default_network_manager() {
     RTC_DCHECK_RUN_ON(signaling_thread_);
     return default_network_manager_.get();
   }
@@ -136,7 +135,7 @@ class ConnectionContext final
   rtc::UniqueRandomIdGenerator ssrc_generator_;
   std::unique_ptr<rtc::NetworkMonitorFactory> const network_monitor_factory_
       RTC_GUARDED_BY(signaling_thread_);
-  std::unique_ptr<rtc::BasicNetworkManager> default_network_manager_
+  std::unique_ptr<rtc::NetworkManager> default_network_manager_
       RTC_GUARDED_BY(signaling_thread_);
   std::unique_ptr<webrtc::CallFactoryInterface> const call_factory_
       RTC_GUARDED_BY(worker_thread());

pc/peer_connection_factory_unittest.cc

@@ -34,6 +34,7 @@
 #include "rtc_base/rtc_certificate_generator.h"
 #include "rtc_base/socket_address.h"
 #include "rtc_base/time_utils.h"
+#include "test/gmock.h"
 #include "test/gtest.h"
 
 #ifdef WEBRTC_ANDROID
@@ -51,6 +52,10 @@ using webrtc::PeerConnectionObserver;
 using webrtc::VideoTrackInterface;
 using webrtc::VideoTrackSourceInterface;
 
+using ::testing::AtLeast;
+using ::testing::InvokeWithoutArgs;
+using ::testing::NiceMock;
+
 namespace {
 
 static const char kStunIceServer[] = "stun:stun.l.google.com:19302";
@@ -93,6 +98,20 @@ class NullPeerConnectionObserver : public PeerConnectionObserver {
   }
 };
 
+class MockNetworkManager : public rtc::NetworkManager {
+ public:
+  MOCK_METHOD(void, StartUpdating, (), (override));
+  MOCK_METHOD(void, StopUpdating, (), (override));
+  MOCK_METHOD(std::vector<const rtc::Network*>,
+              GetNetworks,
+              (),
+              (const override));
+  MOCK_METHOD(std::vector<const rtc::Network*>,
+              GetAnyAddressNetworks,
+              (),
+              (override));
+};
+
 }  // namespace
 
 class PeerConnectionFactoryTest : public ::testing::Test {
@@ -492,3 +511,28 @@ TEST_F(PeerConnectionFactoryTest, LocalRendering) {
   EXPECT_EQ(3, local_renderer.num_rendered_frames());
   EXPECT_FALSE(local_renderer.black_frame());
 }
+
+TEST(PeerConnectionFactoryDependenciesTest, UsesNetworkManager) {
+  constexpr int64_t kWaitTimeoutMs = 10000;
+  auto mock_network_manager = std::make_unique<NiceMock<MockNetworkManager>>();
+
+  rtc::Event called;
+  EXPECT_CALL(*mock_network_manager, StartUpdating())
+      .Times(AtLeast(1))
+      .WillRepeatedly(InvokeWithoutArgs([&] { called.Set(); }));
+
+  webrtc::PeerConnectionFactoryDependencies pcf_dependencies;
+  pcf_dependencies.network_manager = std::move(mock_network_manager);
+
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf =
+      CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
+
+  PeerConnectionInterface::RTCConfiguration config;
+  config.ice_candidate_pool_size = 2;
+  NullPeerConnectionObserver observer;
+  auto pc = pcf->CreatePeerConnectionOrError(
+      config, webrtc::PeerConnectionDependencies(&observer));
+  ASSERT_TRUE(pc.ok());
+
+  called.Wait(kWaitTimeoutMs);
+}