Added cache flush on network change to ServiceDiscoveryHostClient

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"
 
 #include "chrome/common/local_discovery/local_discovery_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
 
 namespace local_discovery {
 
 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),
-        id_(host_->RegisterWatcherCallback(callback)),
-        started_(false) {
+        id_(host_->RegisterWatcherProxy(this)),
+        started_(false),
+        callback_(callback) {
   }
 
   virtual ~ServiceWatcherProxy() {
-    host_->UnregisterWatcherCallback(id_);
+    host_->UnregisterWatcherProxy(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyWatcher(id_));
   }
 
   virtual void Start() OVERRIDE {
     DCHECK(!started_);
-    host_->Send(new LocalDiscoveryMsg_StartWatcher(id_, service_type_));
+    SendStartMessage();
     started_ = true;
   }
 
   virtual void DiscoverNewServices(bool force_update) OVERRIDE {
     DCHECK(started_);
     host_->Send(new LocalDiscoveryMsg_DiscoverServices(id_, force_update));
   }
 
   virtual std::string GetServiceType() const OVERRIDE {
     return service_type_;
   }
 
+  void RestartIfNecessary() {
+    if (started_) {
+      SendStartMessage();
+      callback_.Run(ServiceWatcher::UPDATE_CACHE_FLUSHED, "");
+    }
+  }
+
+  ServiceWatcher::UpdatedCallback callback() { return callback_; }
+
  private:
+  void SendStartMessage() {
+    host_->Send(new LocalDiscoveryMsg_StartWatcher(id_, service_type_));
+  }
+
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   const std::string service_type_;
   const uint64 id_;
   bool started_;
+  ServiceWatcher::UpdatedCallback callback_;
 };
 
 class ServiceDiscoveryHostClient::ServiceResolverProxy
     : public ServiceResolver {
  public:
   ServiceResolverProxy(ServiceDiscoveryHostClient* host,
                        const std::string& service_name,
                        const ServiceResolver::ResolveCompleteCallback& callback)
       : host_(host),
         service_name_(service_name),
-        id_(host->RegisterResolverCallback(callback)),
-        started_(false) {
+        id_(host->RegisterResolverProxy(this)),
+        started_(false),
+        finished_(false),
+        callback_(callback) {
   }
 
   virtual ~ServiceResolverProxy() {
-    host_->UnregisterResolverCallback(id_);
+    host_->UnregisterResolverProxy(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyResolver(id_));
   }
 
   virtual void StartResolving() OVERRIDE {
     DCHECK(!started_);
-    host_->Send(new LocalDiscoveryMsg_ResolveService(id_, service_name_));
+    SendStartMessage();
     started_ = true;
   }
 
   virtual std::string GetName() const OVERRIDE {
     return service_name_;
   }
 
+  void Finish() {
+    finished_ = true;
+  }
+
+  void RestartIfNecessary() {
+    if (started_) {
+      if (finished_) {
+        started_ = false;
+      } else {
+        SendStartMessage();
+      }
+    }
+  }
+
+  ServiceResolver::ResolveCompleteCallback callback() { return callback_; }
+
  private:
+  void SendStartMessage() {
+    host_->Send(new LocalDiscoveryMsg_ResolveService(id_, service_name_));
+  }
+
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   const std::string service_name_;
   const uint64 id_;
   bool started_;
+  bool finished_;
+  ServiceResolver::ResolveCompleteCallback callback_;
 };
 
 class ServiceDiscoveryHostClient::LocalDomainResolverProxy
     : public LocalDomainResolver {
  public:
   LocalDomainResolverProxy(ServiceDiscoveryHostClient* host,
                        const std::string& domain,
                        net::AddressFamily address_family,
                        const LocalDomainResolver::IPAddressCallback& callback)
       : host_(host),
         domain_(domain),
         address_family_(address_family),
-        id_(host->RegisterLocalDomainResolverCallback(callback)),
-        started_(false) {
+        id_(host->RegisterLocalDomainResolverProxy(this)),
+        started_(false),
+        callback_(callback) {
   }
 
   virtual ~LocalDomainResolverProxy() {
-    host_->UnregisterLocalDomainResolverCallback(id_);
+    host_->UnregisterLocalDomainResolverProxy(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyLocalDomainResolver(id_));
   }
 
   virtual void Start() OVERRIDE {
     DCHECK(!started_);
-    host_->Send(new LocalDiscoveryMsg_ResolveLocalDomain(id_, domain_,
-                                                         address_family_));
+    SendStartMessage();
     started_ = true;
   }
 
+  void Finish() {
+    finished_ = true;
+  }
+
+  void RestartIfNecessary() {
+    if (started_) {
+      if (finished_) {
+        started_ = false;
+      } else {
+        SendStartMessage();
+      }
+    }
+  }
+
+  LocalDomainResolver::IPAddressCallback callback() { return callback_; }
+
  private:
+  void SendStartMessage() {
+    host_->Send(new LocalDiscoveryMsg_ResolveLocalDomain(id_, domain_,
+                                                         address_family_));
+  }
+
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   std::string domain_;
   net::AddressFamily address_family_;
   const uint64 id_;
   bool started_;
+  bool finished_;
+  LocalDomainResolver::IPAddressCallback callback_;
 };
 
 ServiceDiscoveryHostClient::ServiceDiscoveryHostClient() : current_id_(0) {
   callback_runner_ = base::MessageLoop::current()->message_loop_proxy();
 }
 
 ServiceDiscoveryHostClient::~ServiceDiscoveryHostClient() {
   // The ServiceDiscoveryHostClient may be destroyed from the IO thread or the
   // owning thread.
   DetachFromThread();
-  DCHECK(service_watcher_callbacks_.empty());
-  DCHECK(service_resolver_callbacks_.empty());
-  DCHECK(domain_resolver_callbacks_.empty());
+  DCHECK(service_watcher_proxies_.empty());
+  DCHECK(service_resolver_proxies_.empty());
+  DCHECK(domain_resolver_proxies_.empty());
 }
 
 scoped_ptr<ServiceWatcher> ServiceDiscoveryHostClient::CreateServiceWatcher(
     const std::string& service_type,
     const ServiceWatcher::UpdatedCallback& callback) {
   DCHECK(CalledOnValidThread());
   return scoped_ptr<ServiceWatcher>(
       new ServiceWatcherProxy(this, service_type, callback));
 }
 
 scoped_ptr<ServiceResolver> ServiceDiscoveryHostClient::CreateServiceResolver(
     const std::string& service_name,
     const ServiceResolver::ResolveCompleteCallback& callback) {
   DCHECK(CalledOnValidThread());
   return scoped_ptr<ServiceResolver>(
       new ServiceResolverProxy(this, service_name, callback));
 }
 
 scoped_ptr<LocalDomainResolver>
 ServiceDiscoveryHostClient::CreateLocalDomainResolver(
     const std::string& domain,
     net::AddressFamily address_family,
     const LocalDomainResolver::IPAddressCallback& callback) {
   DCHECK(CalledOnValidThread());
   return scoped_ptr<LocalDomainResolver>(new LocalDomainResolverProxy(
       this, domain, address_family, callback));
 }
 
-uint64 ServiceDiscoveryHostClient::RegisterWatcherCallback(
-    const ServiceWatcher::UpdatedCallback& callback) {
+uint64 ServiceDiscoveryHostClient::RegisterWatcherProxy(
+    ServiceWatcherProxy* proxy) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!ContainsKey(service_watcher_callbacks_, current_id_ + 1));
-  service_watcher_callbacks_[++current_id_] = callback;
+  DCHECK(!ContainsKey(service_watcher_proxies_, current_id_ + 1));
+  service_watcher_proxies_[++current_id_] = proxy;
   return current_id_;
 }
 
-uint64 ServiceDiscoveryHostClient::RegisterResolverCallback(
-    const ServiceResolver::ResolveCompleteCallback& callback) {
+uint64 ServiceDiscoveryHostClient::RegisterResolverProxy(
+    ServiceResolverProxy* proxy) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!ContainsKey(service_resolver_callbacks_, current_id_ + 1));
-  service_resolver_callbacks_[++current_id_] = callback;
+  DCHECK(!ContainsKey(service_resolver_proxies_, current_id_ + 1));
+  service_resolver_proxies_[++current_id_] = proxy;
   return current_id_;
 }
 
-uint64 ServiceDiscoveryHostClient::RegisterLocalDomainResolverCallback(
-    const LocalDomainResolver::IPAddressCallback& callback) {
+uint64 ServiceDiscoveryHostClient::RegisterLocalDomainResolverProxy(
+    LocalDomainResolverProxy* proxy) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!ContainsKey(domain_resolver_callbacks_, current_id_ + 1));
-  domain_resolver_callbacks_[++current_id_] = callback;
+  DCHECK(!ContainsKey(domain_resolver_proxies_, current_id_ + 1));
+  domain_resolver_proxies_[++current_id_] = proxy;
   return current_id_;
 }
 
-void ServiceDiscoveryHostClient::UnregisterWatcherCallback(uint64 id) {
+void ServiceDiscoveryHostClient::UnregisterWatcherProxy(uint64 id) {
   DCHECK(CalledOnValidThread());
-  DCHECK(ContainsKey(service_watcher_callbacks_, id));
-  service_watcher_callbacks_.erase(id);
+  DCHECK(ContainsKey(service_watcher_proxies_, id));
+  service_watcher_proxies_.erase(id);
 }
 
-void ServiceDiscoveryHostClient::UnregisterResolverCallback(uint64 id) {
+void ServiceDiscoveryHostClient::UnregisterResolverProxy(uint64 id) {
   DCHECK(CalledOnValidThread());
-  DCHECK(ContainsKey(service_resolver_callbacks_, id));
-  service_resolver_callbacks_.erase(id);
+  DCHECK(ContainsKey(service_resolver_proxies_, id));
+  service_resolver_proxies_.erase(id);
 }
 
-void ServiceDiscoveryHostClient::UnregisterLocalDomainResolverCallback(
+void ServiceDiscoveryHostClient::UnregisterLocalDomainResolverProxy(
     uint64 id) {
   DCHECK(CalledOnValidThread());
-  DCHECK(ContainsKey(domain_resolver_callbacks_, id));
-  domain_resolver_callbacks_.erase(id);
+  DCHECK(ContainsKey(domain_resolver_proxies_, id));
+  domain_resolver_proxies_.erase(id);
 }
 
 void ServiceDiscoveryHostClient::Start() {
   DCHECK(CalledOnValidThread());
+  net::NetworkChangeNotifier::AddIPAddressObserver(this);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::StartOnIOThread, this));
 }
 
 void ServiceDiscoveryHostClient::Shutdown() {
   DCHECK(CalledOnValidThread());
+  net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
   BrowserThread::PostTask(
       BrowserThread::IO,
       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();
   if (utility_host_) {
     utility_host_->EnableZygote();
     utility_host_->EnableMDns();
     utility_host_->StartBatchMode();
   }
 }
 
 void ServiceDiscoveryHostClient::ShutdownOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (utility_host_) {
     utility_host_->Send(new LocalDiscoveryMsg_ShutdownLocalDiscovery);
     utility_host_->EndBatchMode();
   }
 }
 
+void ServiceDiscoveryHostClient::RestartOnIOThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  ShutdownOnIOThread();
+  StartOnIOThread();
+}
+
 void ServiceDiscoveryHostClient::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
   BrowserThread::PostTask(
       BrowserThread::IO,
       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() {
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ServiceDiscoveryHostClient::RestartOnIOThread, this));
+
+  for (WatcherProxies::iterator i = service_watcher_proxies_.begin();
+       i != service_watcher_proxies_.end();
+       i++) {
+    i->second->RestartIfNecessary();
+  }
+
+  for (ResolverProxies::iterator i = service_resolver_proxies_.begin();
+       i != service_resolver_proxies_.end();
+       i++) {
+    i->second->RestartIfNecessary();
+  }
+
+  for (ResolverProxies::iterator i = service_resolver_proxies_.begin();
+       i != service_resolver_proxies_.end();
+       i++) {
+    i->second->RestartIfNecessary();
+  }
+}
+
 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)
     IPC_MESSAGE_HANDLER(LocalDiscoveryHostMsg_LocalDomainResolverCallback,
                         OnLocalDomainResolverCallback)
@@ skipping 34 matching lines @@
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::RunLocalDomainResolverCallback,
                  this, id, success, ip_address_ipv4, ip_address_ipv6));
 }
 
 void ServiceDiscoveryHostClient::RunWatcherCallback(
     uint64 id,
     ServiceWatcher::UpdateType update,
     const std::string& service_name) {
   DCHECK(CalledOnValidThread());
-  WatcherCallbacks::iterator it = service_watcher_callbacks_.find(id);
-  if (it != service_watcher_callbacks_.end() && !it->second.is_null())
-    it->second.Run(update, service_name);
+  WatcherProxies::iterator it = service_watcher_proxies_.find(id);
+  if (it != service_watcher_proxies_.end() && !it->second->callback().is_null())
+    it->second->callback().Run(update, service_name);
 }
 
 void ServiceDiscoveryHostClient::RunResolverCallback(
     uint64 id,
     ServiceResolver::RequestStatus status,
     const ServiceDescription& description) {
   DCHECK(CalledOnValidThread());
-  ResolverCallbacks::iterator it = service_resolver_callbacks_.find(id);
-  if (it != service_resolver_callbacks_.end() && !it->second.is_null())
-    it->second.Run(status, description);
+  ResolverProxies::iterator it = service_resolver_proxies_.find(id);
+  if (it != service_resolver_proxies_.end()
+      && !it->second->callback().is_null())
+    it->second->callback().Run(status, description);
 }
 
 void ServiceDiscoveryHostClient::RunLocalDomainResolverCallback(
     uint64 id,
     bool success,
     const net::IPAddressNumber& ip_address_ipv4,
     const net::IPAddressNumber& ip_address_ipv6) {
   DCHECK(CalledOnValidThread());
-  DomainResolverCallbacks::iterator it = domain_resolver_callbacks_.find(id);
-  if (it != domain_resolver_callbacks_.end() && !it->second.is_null())
-    it->second.Run(success, ip_address_ipv4, ip_address_ipv6);
+  DomainResolverProxies::iterator it = domain_resolver_proxies_.find(id);
+  if (it != domain_resolver_proxies_.end()
+      && !it->second->callback().is_null())
+    it->second->callback().Run(success, ip_address_ipv4, ip_address_ipv6);
 }
 
 ServiceDiscoveryHostClientFactory::ServiceDiscoveryHostClientFactory()
     : instance_(NULL), references_(0) {
 }
 
 ServiceDiscoveryHostClientFactory::~ServiceDiscoveryHostClientFactory() {
 }
 
 // static
@@ skipping 27 matching lines @@
 void ServiceDiscoveryHostClientFactory::ReleaseClientInternal() {
   DCHECK(CalledOnValidThread());
   references_--;
   if (references_ == 0) {
     instance_->Shutdown();
     instance_ = NULL;
   }
 }
 
 }  // namespace local_discovery