[chrome/browser/local_discovery] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/local_discovery/service_discovery_client_mdns.cc

 // Copyright 2014 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_client_mdns.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "chrome/common/local_discovery/service_discovery_client_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/dns/mdns_client.h"
 #include "net/udp/datagram_server_socket.h"
 
 namespace local_discovery {
 
 using content::BrowserThread;
 
 // Base class for objects returned by ServiceDiscoveryClient implementation.
 // Handles interaction of client code on UI thread end net code on mdns thread.
 class ServiceDiscoveryClientMdns::Proxy {
  public:
   typedef base::WeakPtr<Proxy> WeakPtr;
 
   explicit Proxy(ServiceDiscoveryClientMdns* client)
       : client_(client),
         weak_ptr_factory_(this) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     client_->proxies_.AddObserver(this);
   }
 
   virtual ~Proxy() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     client_->proxies_.RemoveObserver(this);
   }
 
   // Returns true if object is not yet shutdown.
   virtual bool IsValid() = 0;
 
   // Notifies proxies that mDNS layer is going to be destroyed.
   virtual void OnMdnsDestroy() = 0;
 
   // Notifies proxies that new mDNS instance is ready.
   virtual void OnNewMdnsReady() {
     DCHECK(!client_->need_dalay_mdns_tasks_);
     if (IsValid()) {
       for (size_t i = 0; i < delayed_tasks_.size(); ++i)
         client_->mdns_runner_->PostTask(FROM_HERE, delayed_tasks_[i]);
     }
     delayed_tasks_.clear();
   }
 
   // Runs callback using this method to abort callback if instance of |Proxy|
   // is deleted.
   void RunCallback(const base::Closure& callback) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     callback.Run();
   }
 
  protected:
   void PostToMdnsThread(const base::Closure& task) {
     DCHECK(IsValid());
     // The first task on IO thread for each |mdns_| instance must be |InitMdns|.
     // |OnInterfaceListReady| could be delayed by |GetMDnsInterfacesToBind|
     // running on FILE thread, so |PostToMdnsThread| could be called to post
     // task for |mdns_| that is not initialized yet.
@@ skipping 245 matching lines @@
 };
 
 }  // namespace
 
 ServiceDiscoveryClientMdns::ServiceDiscoveryClientMdns()
     : mdns_runner_(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)),
       restart_attempts_(0),
       need_dalay_mdns_tasks_(true),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
   StartNewClient();
 }
 
 scoped_ptr<ServiceWatcher> ServiceDiscoveryClientMdns::CreateServiceWatcher(
     const std::string& service_type,
     const ServiceWatcher::UpdatedCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return scoped_ptr<ServiceWatcher>(
       new ServiceWatcherProxy(this, service_type, callback));
 }
 
 scoped_ptr<ServiceResolver> ServiceDiscoveryClientMdns::CreateServiceResolver(
     const std::string& service_name,
     const ServiceResolver::ResolveCompleteCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return scoped_ptr<ServiceResolver>(
       new ServiceResolverProxy(this, service_name, callback));
 }
 
 scoped_ptr<LocalDomainResolver>
 ServiceDiscoveryClientMdns::CreateLocalDomainResolver(
     const std::string& domain,
     net::AddressFamily address_family,
     const LocalDomainResolver::IPAddressCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return scoped_ptr<LocalDomainResolver>(
       new LocalDomainResolverProxy(this, domain, address_family, callback));
 }
 
 ServiceDiscoveryClientMdns::~ServiceDiscoveryClientMdns() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   DestroyMdns();
 }
 
 void ServiceDiscoveryClientMdns::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Only network changes resets counter.
   restart_attempts_ = 0;
   ScheduleStartNewClient();
 }
 
 void ServiceDiscoveryClientMdns::ScheduleStartNewClient() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OnBeforeMdnsDestroy();
   if (restart_attempts_ < kMaxRestartAttempts) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ServiceDiscoveryClientMdns::StartNewClient,
                    weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(
             kRestartDelayOnNetworkChangeSeconds * (1 << restart_attempts_)));
   } else {
     ReportSuccess();
   }
 }
 
 void ServiceDiscoveryClientMdns::StartNewClient() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ++restart_attempts_;
   DestroyMdns();
   mdns_.reset(net::MDnsClient::CreateDefault().release());
   client_.reset(new ServiceDiscoveryClientImpl(mdns_.get()));
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&net::GetMDnsInterfacesToBind),
       base::Bind(&ServiceDiscoveryClientMdns::OnInterfaceListReady,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ServiceDiscoveryClientMdns::OnInterfaceListReady(
     const net::InterfaceIndexFamilyList& interfaces) {
   mdns_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InitMdns,
                  base::Bind(&ServiceDiscoveryClientMdns::OnMdnsInitialized,
                             weak_ptr_factory_.GetWeakPtr()),
                  interfaces,
                  base::Unretained(mdns_.get())));
 }
 
 void ServiceDiscoveryClientMdns::OnMdnsInitialized(bool success) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!success) {
     ScheduleStartNewClient();
     return;
   }
   ReportSuccess();
 
   // Initialization is done, no need to delay tasks.
   need_dalay_mdns_tasks_ = false;
   FOR_EACH_OBSERVER(Proxy, proxies_, OnNewMdnsReady());
 }
 
 void ServiceDiscoveryClientMdns::ReportSuccess() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   UMA_HISTOGRAM_COUNTS_100("LocalDiscovery.ClientRestartAttempts",
                            restart_attempts_);
 }
 
 void ServiceDiscoveryClientMdns::OnBeforeMdnsDestroy() {
   need_dalay_mdns_tasks_ = true;
   weak_ptr_factory_.InvalidateWeakPtrs();
   FOR_EACH_OBSERVER(Proxy, proxies_, OnMdnsDestroy());
 }
 
 void ServiceDiscoveryClientMdns::DestroyMdns() {
   OnBeforeMdnsDestroy();
   // After calling |Proxy::OnMdnsDestroy| all references to client_ and mdns_
   // should be destroyed.
   if (client_)
     mdns_runner_->DeleteSoon(FROM_HERE, client_.release());
   if (mdns_)
     mdns_runner_->DeleteSoon(FROM_HERE, mdns_.release());
 }
 
 }  // namespace local_discovery