Fixed formating and added io_runner_.

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
 
@@ skipping 26 matching lines @@
   }
 
   virtual void Start() OVERRIDE {
     DVLOG(1) << "ServiceWatcher::Start with id " << id_;
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_StartWatcher(id_, service_type_));
     started_ = true;
   }
 
   virtual void DiscoverNewServices(bool force_update) OVERRIDE {
-    DVLOG(1) << "ServiceWatcher::DiscoverNewServices with id "
-            << id_;
+    DVLOG(1) << "ServiceWatcher::DiscoverNewServices with id " << id_;
     DCHECK(started_);
     host_->Send(new LocalDiscoveryMsg_DiscoverServices(id_, force_update));
   }
 
   virtual std::string GetServiceType() const OVERRIDE {
     return service_type_;
   }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
@@ skipping 15 matching lines @@
   }
 
   virtual ~ServiceResolverProxy() {
     DVLOG(1) << "~ServiceResolverProxy with id " << id_;
     host_->UnregisterResolverCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyResolver(id_));
   }
 
   virtual void StartResolving() OVERRIDE {
-    DVLOG(1)
-        << "ServiceResolverProxy::StartResolving with id "
-        << id_;
+    DVLOG(1) << "ServiceResolverProxy::StartResolving with id " << id_;
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_ResolveService(id_, service_name_));
     started_ = true;
   }
 
   virtual std::string GetName() const OVERRIDE {
     return service_name_;
   }
 
  private:
@@ skipping 11 matching lines @@
                        net::AddressFamily address_family,
                        const LocalDomainResolver::IPAddressCallback& callback)
       : host_(host),
         domain_(domain),
         address_family_(address_family),
         id_(host->RegisterLocalDomainResolverCallback(callback)),
         started_(false) {
   }
 
   virtual ~LocalDomainResolverProxy() {
-    DVLOG(1) << "~LocalDomainResolverProxy with id "
-            << id_;
+    DVLOG(1) << "~LocalDomainResolverProxy with id " << id_;
     host_->UnregisterLocalDomainResolverCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyLocalDomainResolver(id_));
   }
 
   virtual void Start() OVERRIDE {
-    DVLOG(1) << "LocalDomainResolverProxy::Start with id "
-            << id_;
+    DVLOG(1) << "LocalDomainResolverProxy::Start with id " << id_;
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_ResolveLocalDomain(id_, domain_,
                                                          address_family_));
     started_ = true;
   }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   std::string domain_;
   net::AddressFamily address_family_;
   const uint64 id_;
   bool started_;
 };
 
 ServiceDiscoveryHostClient::ServiceDiscoveryHostClient() : current_id_(0) {
   callback_runner_ = base::MessageLoop::current()->message_loop_proxy();
+  io_runner_ = BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
 }
 
 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());
 }
@@ skipping 60 matching lines @@
 
 void ServiceDiscoveryHostClient::UnregisterLocalDomainResolverCallback(
     uint64 id) {
   DCHECK(CalledOnValidThread());
   domain_resolver_callbacks_.erase(id);
 }
 
 void ServiceDiscoveryHostClient::Start() {
   DCHECK(CalledOnValidThread());
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
-  BrowserThread::PostTask(
-      BrowserThread::IO,
+  io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::StartOnIOThread, this));
 }
 
 void ServiceDiscoveryHostClient::Shutdown() {
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
   DCHECK(CalledOnValidThread());
-  BrowserThread::PostTask(
-      BrowserThread::IO,
+  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();
   if (utility_host_) {
     utility_host_->EnableZygote();
@@ skipping 27 matching lines @@
 
 void ServiceDiscoveryHostClient::RestartOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   ShutdownOnIOThread();
   StartOnIOThread();
 }
 
 void ServiceDiscoveryHostClient::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
-  BrowserThread::PostTask(
-      BrowserThread::IO,
+  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() {
-  BrowserThread::PostTask(
-      BrowserThread::IO,
+  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, "");
@@ skipping 119 matching lines @@
 void ServiceDiscoveryHostClientFactory::ReleaseClientInternal() {
   DCHECK(CalledOnValidThread());
   references_--;
   if (references_ == 0) {
     instance_->Shutdown();
     instance_ = NULL;
   }
 }
 
 }  // namespace local_discovery