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() {
+    VLOG(1) << "~ServiceWatcherProxy on browser process with id " << id_;
     host_->UnregisterWatcherCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyWatcher(id_));
   }
 
   virtual void Start() OVERRIDE {
+    VLOG(1) << "ServiceWatcher::Start on browser process with id " << id_;
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_StartWatcher(id_, service_type_));
     started_ = true;
   }
 
   virtual void DiscoverNewServices(bool force_update) OVERRIDE {
+    VLOG(1) << "ServiceWatcher::DiscoverNewServices on browser process 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() {
+    VLOG(1) << "~ServiceResolverProxy on browser process with id " << id_;
     host_->UnregisterResolverCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyResolver(id_));
   }
 
   virtual void StartResolving() OVERRIDE {
+    VLOG(1)
+        << "ServiceResolverProxy::StartResolving on browser process 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() {
+    VLOG(1) << "~LocalDomainResolverProxy on browser process with id "
+            << id_;
     host_->UnregisterLocalDomainResolverCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyLocalDomainResolver(id_));
   }
 
   virtual void Start() OVERRIDE {
+    VLOG(1) << "LocalDomainResolverProxy::Start on browser process with id "
+            << id_;
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_ResolveLocalDomain(id_, domain_,
                                                          address_family_));

[Vitaly Buka (NO REVIEWS), 2013/09/10 04:47:41]

All messages above have no value. It's just dumping RPC calls

[Noam Samuel, 2013/09/10 23:01:52]

If we can catch an RPC that is sent but not received, we can pinpoint a process
crash/deadlock.

     started_ = true;
   }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   std::string domain_;
   net::AddressFamily address_family_;
   const uint64 id_;
   bool started_;
 };
 
+std::string WatcherUpdateToString(ServiceWatcher::UpdateType update) {
+  switch (update) {
+    case ServiceWatcher::UPDATE_ADDED:
+      return "UPDATE_ADDED";
+    case ServiceWatcher::UPDATE_CHANGED:
+      return "UPDATE_CHANGED";
+    case ServiceWatcher::UPDATE_REMOVED:
+      return "UPDATE_REMOVED";
+    case ServiceWatcher::UPDATE_INVALIDATED:
+      return "UPDATE_INVALIDATED";
+  }
+  return "Unknown Update";
+}
+
+std::string ResolverStatusToString(ServiceResolver::RequestStatus status) {
+  switch (status) {
+    case ServiceResolver::STATUS_SUCCESS:
+      return "STATUS_SUCESS";
+    case ServiceResolver::STATUS_REQUEST_TIMEOUT:
+      return "STATUS_REQUEST_TIMEOUT";
+    case ServiceResolver::STATUS_KNOWN_NONEXISTENT:
+      return "STATUS_KNOWN_NONEXISTENT";
+  }
+  return "Unknown Status";
+}
+
+
 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());
@@ skipping 202 matching lines @@
   callback_runner_->PostTask(
       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) {
+  VLOG(1) << "RunWatcherCallback on browser process with id " << id
+          << " and watcher update " << WatcherUpdateToString(update);

[Vitaly Buka (NO REVIEWS), 2013/09/10 04:47:41]

For consistenly I'd move this logging from here to unitily process

[Noam Samuel, 2013/09/10 23:23:34]

Done.

   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);
 }
 
 void ServiceDiscoveryHostClient::RunResolverCallback(
     uint64 id,
     ServiceResolver::RequestStatus status,
     const ServiceDescription& description) {
+  VLOG(1) << "RunResolverCallback on browser process with id " << id

[Vitaly Buka (NO REVIEWS), 2013/09/10 04:47:41]

"on browser process" part is not needed

[Noam Samuel, 2013/09/10 23:23:34]

Done.

+          << " and resolver status " << ResolverStatusToString(status);
   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);
 }
 
 void ServiceDiscoveryHostClient::RunLocalDomainResolverCallback(
     uint64 id,
     bool success,
     const net::IPAddressNumber& ip_address_ipv4,
     const net::IPAddressNumber& ip_address_ipv6) {
+  VLOG(1) << "RunLocalDomainCallback on browser process with id " << id;
+
+  if (!ip_address_ipv4.empty())
+    VLOG(1) << "Local comain callback has valid ipv4 address with id " << id;
+  if (!ip_address_ipv6.empty())
+    VLOG(1) << "Local comain callback has valid ipv6 address with id " << id;
+
   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);
 }
 
 ServiceDiscoveryHostClientFactory::ServiceDiscoveryHostClientFactory()
     : instance_(NULL), references_(0) {
 }
 
@@ skipping 31 matching lines @@
 void ServiceDiscoveryHostClientFactory::ReleaseClientInternal() {
   DCHECK(CalledOnValidThread());
   references_--;
   if (references_ == 0) {
     instance_->Shutdown();
     instance_ = NULL;
   }
 }
 
 }  // namespace local_discovery