Create network change notifier.

webrtc/base/network.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.
  */
 
@@ skipping 30 matching lines @@
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/win32.h"
 #include <Iphlpapi.h>
 #endif
 
 #include <stdio.h>
 
 #include <algorithm>
 
 #include "webrtc/base/logging.h"
+#include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socket.h"  // includes something that makes windows happy
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 namespace {
 
 // Turning on IPv6 could make many IPv6 interfaces available for connectivity
@@ skipping 261 matching lines @@
 
 BasicNetworkManager::BasicNetworkManager()
     : thread_(NULL), sent_first_update_(false), start_count_(0),
       network_ignore_mask_(kDefaultNetworkIgnoreMask),
       ignore_non_default_routes_(false) {
 }
 
 BasicNetworkManager::~BasicNetworkManager() {
 }
 
+void BasicNetworkManager::OnNetworksChanged() {
+  LOG(LS_VERBOSE) << "Network change was observed at the network manager";
+  UpdateNetworksOnce();
+}
+
 #if defined(__native_client__)
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
                                          NetworkList* networks) const {
   ASSERT(false);
   LOG(LS_WARNING) << "BasicNetworkManager doesn't work on NaCl yet";
   return false;
 }
 
 #elif defined(WEBRTC_POSIX)
@@ skipping 314 matching lines @@
 void BasicNetworkManager::StartUpdating() {
   thread_ = Thread::Current();
   if (start_count_) {
     // If network interfaces are already discovered and signal is sent,
     // we should trigger network signal immediately for the new clients
     // to start allocating ports.
     if (sent_first_update_)
       thread_->Post(this, kSignalNetworksMessage);
   } else {
     thread_->Post(this, kUpdateNetworksMessage);
+    StartNetworkMonitor();
   }
   ++start_count_;
 }
 
 void BasicNetworkManager::StopUpdating() {
   ASSERT(Thread::Current() == thread_);
   if (!start_count_)
     return;
 
   --start_count_;
   if (!start_count_) {
     thread_->Clear(this);
     sent_first_update_ = false;
+    StopNetworkMonitor();
   }
 }
 
+void BasicNetworkManager::StartNetworkMonitor() {
+  NetworkMonitorFactory* factory = NetworkMonitorFactory::GetFactory();
+  if (factory == nullptr) {
+    return;
+  }
+  network_monitor_.reset(factory->CreateNetworkMonitor());
+  if (!network_monitor_) {
+    return;
+  }
+  network_monitor_->SignalNetworksChanged.connect(
+      this, &BasicNetworkManager::OnNetworksChanged);
+  network_monitor_->Start();
+}
+
+void BasicNetworkManager::StopNetworkMonitor() {
+  if (!network_monitor_) {
+    return;
+  }
+  network_monitor_->Stop();
+  network_monitor_.reset();
+}
+
 void BasicNetworkManager::OnMessage(Message* msg) {
   switch (msg->message_id) {
-    case kUpdateNetworksMessage:  {
-      DoUpdateNetworks();
+    case kUpdateNetworksMessage: {
+      UpdateNetworksContinually();
       break;
     }
     case kSignalNetworksMessage:  {
       SignalNetworksChanged();
       break;
     }
     default:
       ASSERT(false);
   }
 }
 
-void BasicNetworkManager::DoUpdateNetworks() {
+void BasicNetworkManager::UpdateNetworksOnce() {
   if (!start_count_)
     return;
 
   ASSERT(Thread::Current() == thread_);
 
   NetworkList list;
   if (!CreateNetworks(false, &list)) {
     SignalError();
   } else {
     bool changed;
     MergeNetworkList(list, &changed);
     if (changed || !sent_first_update_) {
       SignalNetworksChanged();
       sent_first_update_ = true;
     }
   }
+}
 
+void BasicNetworkManager::UpdateNetworksContinually() {
+  UpdateNetworksOnce();
   thread_->PostDelayed(kNetworksUpdateIntervalMs, this, kUpdateNetworksMessage);
 }
 
 void BasicNetworkManager::DumpNetworks(bool include_ignored) {
   NetworkList list;
   CreateNetworks(include_ignored, &list);
   LOG(LS_INFO) << "NetworkManager detected " << list.size() << " networks:";
   for (const Network* network : list) {
     if (!network->ignored() || include_ignored) {
       LOG(LS_INFO) << network->ToString() << ": "
@@ skipping 87 matching lines @@
   std::stringstream ss;
   // Print out the first space-terminated token of the network desc, plus
   // the IP address.
   ss << "Net[" << description_.substr(0, description_.find(' '))
      << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
      << ":" << AdapterTypeToString(type_) << "]";
   return ss.str();
 }
 
 }  // namespace rtc