Replace OnIPAddressChanged with OnNetworkChanged.

chrome/browser/local_discovery/service_discovery_host_client.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/local_discovery/service_discovery_host_client.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #endif  // OS_POSIX
 
 #include "chrome/common/local_discovery/local_discovery_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
 #include "net/socket/socket_descriptor.h"
 
 namespace local_discovery {
 
+namespace {
+
+void LogInterfaces() {
+  net::NetworkInterfaceList list;
+  net::GetNetworkList(&list);
+  std::string log;
+  for (net::NetworkInterfaceList::iterator it = list.begin(); it != list.end();
+       ++it) {
+    log += " " + net::IPAddressToString(it->address);
+  }
+  VLOG(1) << "Local addresses:" << log;
+}
+
+}  // namespace
+
 using content::BrowserThread;
 using content::UtilityProcessHost;
 
 class ServiceDiscoveryHostClient::ServiceWatcherProxy : public ServiceWatcher {
  public:
   ServiceWatcherProxy(ServiceDiscoveryHostClient* host,
                       const std::string& service_type,
                       const ServiceWatcher::UpdatedCallback& callback)
       : host_(host),
         service_type_(service_type),
@@ skipping 181 matching lines @@
 }
 
 void ServiceDiscoveryHostClient::UnregisterLocalDomainResolverCallback(
     uint64 id) {
   DCHECK(CalledOnValidThread());
   domain_resolver_callbacks_.erase(id);
 }
 
 void ServiceDiscoveryHostClient::Start() {
   DCHECK(CalledOnValidThread());
-  net::NetworkChangeNotifier::AddIPAddressObserver(this);
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::StartOnIOThread, this));
 }
 
 void ServiceDiscoveryHostClient::Shutdown() {
-  net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
+  net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   DCHECK(CalledOnValidThread());
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::ShutdownOnIOThread, this));
 }
 
 void ServiceDiscoveryHostClient::StartOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   utility_host_ = UtilityProcessHost::Create(
       this, base::MessageLoopProxy::current().get())->AsWeakPtr();
@@ skipping 20 matching lines @@
 }
 
 void ServiceDiscoveryHostClient::ShutdownOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (utility_host_) {
     utility_host_->Send(new LocalDiscoveryMsg_ShutdownLocalDiscovery);
     utility_host_->EndBatchMode();
   }
 }
 
+void ServiceDiscoveryHostClient::Restart() {
+  DCHECK(CalledOnValidThread());
+
+  VLOG(1) << "ServiceDiscoveryHostClient::Restart";
+  LogInterfaces();
+
+  io_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&ServiceDiscoveryHostClient::RestartOnIOThread, this));
+
+  WatcherCallbacks service_watcher_callbacks;
+  service_watcher_callbacks_.swap(service_watcher_callbacks);
+
+  for (WatcherCallbacks::iterator i = service_watcher_callbacks.begin();
+       i != service_watcher_callbacks.end(); i++) {
+    if (!i->second.is_null()) {
+      i->second.Run(ServiceWatcher::UPDATE_INVALIDATED, "");
+    }
+  }
+}
+
 void ServiceDiscoveryHostClient::RestartOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   ShutdownOnIOThread();
   StartOnIOThread();
 }
 
 void ServiceDiscoveryHostClient::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::SendOnIOThread, this, msg));
 }
 
 void ServiceDiscoveryHostClient::SendOnIOThread(IPC::Message* msg) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (utility_host_)
     utility_host_->Send(msg);
 }
 
-void ServiceDiscoveryHostClient::OnIPAddressChanged() {
-  io_runner_->PostTask(
+void ServiceDiscoveryHostClient::OnNetworkChanged(
+    net::NetworkChangeNotifier::ConnectionType type) {
+  VLOG(1) << "ServiceDiscoveryHostClient::OnNetworkChanged";
+  LogInterfaces();
+  callback_runner_->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&ServiceDiscoveryHostClient::RestartOnIOThread, this));
-
-  WatcherCallbacks service_watcher_callbacks;
-  service_watcher_callbacks_.swap(service_watcher_callbacks);
-
-  for (WatcherCallbacks::iterator i = service_watcher_callbacks.begin();
-       i != service_watcher_callbacks.end(); i++) {
-    if (!i->second.is_null()) {
-      i->second.Run(ServiceWatcher::UPDATE_INVALIDATED, "");
-    }
-  }
+      base::Bind(&ServiceDiscoveryHostClient::Restart, this),
+      base::TimeDelta::FromSeconds(10));
 }
 
 bool ServiceDiscoveryHostClient::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceDiscoveryHostClient, message)
     IPC_MESSAGE_HANDLER(LocalDiscoveryHostMsg_WatcherCallback,
                         OnWatcherCallback)
     IPC_MESSAGE_HANDLER(LocalDiscoveryHostMsg_ResolverCallback,
                         OnResolverCallback)
@@ skipping 107 matching lines @@
 void ServiceDiscoveryHostClientFactory::ReleaseClientInternal() {
   DCHECK(CalledOnValidThread());
   references_--;
   if (references_ == 0) {
     instance_->Shutdown();
     instance_ = NULL;
   }
 }
 
 }  // namespace local_discovery