Added logging to local discovery code

chrome/browser/local_discovery/service_discovery_host_client.cc

Index: chrome/browser/local_discovery/service_discovery_host_client.cc
diff --git a/chrome/browser/local_discovery/service_discovery_host_client.cc b/chrome/browser/local_discovery/service_discovery_host_client.cc
index 6e4ac3a8e29d6fb7f0a59b85baf5b7644168b3a7..6a76fb26cc94f7c7b673a453083e776d3ca40ccf 100644
--- a/chrome/browser/local_discovery/service_discovery_host_client.cc
+++ b/chrome/browser/local_discovery/service_discovery_host_client.cc
@@ -30,18 +30,22 @@ class ServiceDiscoveryHostClient::ServiceWatcherProxy : public ServiceWatcher {
   }
 
   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));
   }
@@ -70,12 +74,16 @@ class ServiceDiscoveryHostClient::ServiceResolverProxy
   }
 
   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;
@@ -107,12 +115,16 @@ class ServiceDiscoveryHostClient::LocalDomainResolverProxy
   }
 
   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.

@@ -127,6 +139,33 @@ class ServiceDiscoveryHostClient::LocalDomainResolverProxy
   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();
 }
@@ -349,6 +388,8 @@ 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())
@@ -359,6 +400,8 @@ 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())
@@ -370,6 +413,13 @@ void ServiceDiscoveryHostClient::RunLocalDomainResolverCallback(
     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())