Added logging to local discovery code

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 12 matching lines @@
   ServiceWatcherProxy(ServiceDiscoveryHostClient* host,
                       const std::string& service_type,
                       const ServiceWatcher::UpdatedCallback& callback)
       : host_(host),
         service_type_(service_type),
         id_(host_->RegisterWatcherCallback(callback)),
         started_(false) {
   }
 
   virtual ~ServiceWatcherProxy() {
+    DVLOG(1) << "~ServiceWatcherProxy with id " << id_;
     host_->UnregisterWatcherCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyWatcher(id_));
   }
 
   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_;
     DCHECK(started_);
     host_->Send(new LocalDiscoveryMsg_DiscoverServices(id_, force_update));
   }
 
   virtual std::string GetServiceType() const OVERRIDE {
     return service_type_;
   }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   const std::string service_type_;
   const uint64 id_;
   bool started_;
 };
 
 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) {
   }
 
   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_;
     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_;
     host_->UnregisterLocalDomainResolverCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyLocalDomainResolver(id_));
   }
 
   virtual void Start() OVERRIDE {
+    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_;
@@ skipping 288 matching lines @@
 void ServiceDiscoveryHostClientFactory::ReleaseClientInternal() {
   DCHECK(CalledOnValidThread());
   references_--;
   if (references_ == 0) {
     instance_->Shutdown();
     instance_ = NULL;
   }
 }
 
 }  // namespace local_discovery