Create network change notifier.

webrtc/base/network_unittest.cc

 /*
  *  Copyright 2004 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 "webrtc/base/network.h"
 
+#include "webrtc/base/networkmonitor.h"
 #include <vector>
 #if defined(WEBRTC_POSIX)
 #include <sys/types.h>
 #if !defined(WEBRTC_ANDROID)
 #include <ifaddrs.h>
 #else
 #include "webrtc/base/ifaddrs-android.h"
 #endif
 #endif
 #include "webrtc/base/gunit.h"
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/logging.h"  // For LOG_GLE
 #endif
 
 namespace rtc {
 
+class FakeNetworkMonitor : public NetworkMonitor {
+ public:
+  void StartMonitoring() override {}
+  void StopMonitoring() override {}
+};
+
+class FakeNetworkMonitorFactory : public NetworkMonitorFactory {
+ public:
+  NetworkMonitor* CreateNetworkMonitor() { return new FakeNetworkMonitor(); }
+  static FakeNetworkMonitorFactory* CreateFactory() {
+    FakeNetworkMonitorFactory* factory = new FakeNetworkMonitorFactory();
+    NetworkMonitorFactory::SetFactory(factory);
+    return factory;
+  }
+};
+
 class NetworkTest : public testing::Test, public sigslot::has_slots<>  {
  public:
   NetworkTest() : callback_called_(false) {}
 
   void OnNetworksChanged() {
     callback_called_ = true;
   }
 
   NetworkManager::Stats MergeNetworkList(
       BasicNetworkManager& network_manager,
       const NetworkManager::NetworkList& list,
       bool* changed) {
     NetworkManager::Stats stats;
     network_manager.MergeNetworkList(list, changed, &stats);
     return stats;
   }
 
   bool IsIgnoredNetwork(BasicNetworkManager& network_manager,
                         const Network& network) {
     return network_manager.IsIgnoredNetwork(network);
   }
 
   NetworkManager::NetworkList GetNetworks(
       const BasicNetworkManager& network_manager, bool include_ignored) {
     NetworkManager::NetworkList list;
     network_manager.CreateNetworks(include_ignored, &list);
     return list;
   }
 
+  NetworkMonitor* GetNetworkMonitor(BasicNetworkManager& network_manager) {
+    return network_manager.network_monitor_.get();
+  }
+
 #if defined(WEBRTC_POSIX)
   // Separated from CreateNetworks for tests.
   static void CallConvertIfAddrs(const BasicNetworkManager& network_manager,
                                  struct ifaddrs* interfaces,
                                  bool include_ignored,
                                  NetworkManager::NetworkList* networks) {
     network_manager.ConvertIfAddrs(interfaces, include_ignored, networks);
   }
 #endif  // defined(WEBRTC_POSIX)
 
@@ skipping 715 matching lines @@
   ipv6_network.AddIP(ip);
   EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
 
   // Add global dynamic temporary one.
   ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c6";
   ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_TEMPORARY, &ip));
   ipv6_network.AddIP(ip);
   EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
 }
 
+TEST_F(NetworkTest, TestNetworkMonitoring) {
+  BasicNetworkManager manager;
+  manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
+                                        &NetworkTest::OnNetworksChanged);
+  FakeNetworkMonitorFactory::CreateFactory();
+  manager.StartUpdating();
+  NetworkMonitor* network_monitor = GetNetworkMonitor(manager);
+  Thread::Current()->ProcessMessages(0);
+  EXPECT_TRUE(callback_called_);
+  callback_called_ = false;
+
+  // Network manager is started, so the callback is called when the network
+  // monitor fires the network-change event.
+  network_monitor->OnNetworksChanged();
+  Thread::Current()->ProcessMessages(0);
+  EXPECT_TRUE(callback_called_);
+
+  // Network manager is stopped; the network monitor is removed.
+  manager.StopUpdating();
+  EXPECT_TRUE(GetNetworkMonitor(manager) == nullptr);
+
+  NetworkMonitorFactory::SetFactory(nullptr);
+}
+
 }  // namespace rtc