Added logging to local discovery code

chrome/utility/local_discovery/service_discovery_message_handler.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/utility/local_discovery/service_discovery_message_handler.h"
 
 #include <algorithm>
 
 #include "base/lazy_instance.h"
 #include "chrome/common/local_discovery/local_discovery_messages.h"
@@ skipping 112 matching lines @@
 }
 
 void SendLocalDomainResolved(uint64 id, bool success,
                              const net::IPAddressNumber& address_ipv4,
                              const net::IPAddressNumber& address_ipv6) {
   content::UtilityThread::Get()->Send(
       new LocalDiscoveryHostMsg_LocalDomainResolverCallback(
           id, success, address_ipv4, address_ipv6));
 }
 
+
+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";
+}
+
 }  // namespace
 
 ServiceDiscoveryMessageHandler::ServiceDiscoveryMessageHandler() {
 }
 
 ServiceDiscoveryMessageHandler::~ServiceDiscoveryMessageHandler() {
   DCHECK(!discovery_thread_);
 }
 
 void ServiceDiscoveryMessageHandler::PreSandboxStartup() {
@@ skipping 118 matching lines @@
 void ServiceDiscoveryMessageHandler::OnDestroyLocalDomainResolver(uint64 id) {
   PostTask(FROM_HERE,
            base::Bind(
                &ServiceDiscoveryMessageHandler::DestroyLocalDomainResolver,
                base::Unretained(this), id));
 }
 
 void ServiceDiscoveryMessageHandler::StartWatcher(
     uint64 id,
     const std::string& service_type) {
+  VLOG(1) << "StartWatcher with id " << id;
   if (!service_discovery_client_)
     return;
   DCHECK(!ContainsKey(service_watchers_, id));
   scoped_ptr<ServiceWatcher> watcher(
       service_discovery_client_->CreateServiceWatcher(
           service_type,
           base::Bind(&ServiceDiscoveryMessageHandler::OnServiceUpdated,
                      base::Unretained(this), id)));
   watcher->Start();
   service_watchers_[id].reset(watcher.release());
 }
 
 void ServiceDiscoveryMessageHandler::DiscoverServices(uint64 id,
                                                       bool force_update) {
+  VLOG(1) << "DiscoverServices with id " << id;
   if (!service_discovery_client_)
     return;
   DCHECK(ContainsKey(service_watchers_, id));
   service_watchers_[id]->DiscoverNewServices(force_update);
 }
 
 void ServiceDiscoveryMessageHandler::DestroyWatcher(uint64 id) {
+  VLOG(1) << "DestoryWatcher with id " << id;
   if (!service_discovery_client_)
     return;
   service_watchers_.erase(id);
 }
 
 void ServiceDiscoveryMessageHandler::ResolveService(
     uint64 id,
     const std::string& service_name) {
+  VLOG(1) << "ResolveService with id " << id;
   if (!service_discovery_client_)
     return;
   DCHECK(!ContainsKey(service_resolvers_, id));
   scoped_ptr<ServiceResolver> resolver(
       service_discovery_client_->CreateServiceResolver(
           service_name,
           base::Bind(&ServiceDiscoveryMessageHandler::OnServiceResolved,
                      base::Unretained(this), id)));
   resolver->StartResolving();
   service_resolvers_[id].reset(resolver.release());
 }
 
 void ServiceDiscoveryMessageHandler::DestroyResolver(uint64 id) {
+  VLOG(1) << "DestroyResolver with id " << id;
   if (!service_discovery_client_)
     return;
   service_resolvers_.erase(id);
 }
 
 void ServiceDiscoveryMessageHandler::ResolveLocalDomain(
     uint64 id,
     const std::string& domain,
     net::AddressFamily address_family) {
+  VLOG(1) << "ResolveLocalDomain with id " << id;
   if (!service_discovery_client_)
     return;
   DCHECK(!ContainsKey(local_domain_resolvers_, id));
   scoped_ptr<LocalDomainResolver> resolver(
       service_discovery_client_->CreateLocalDomainResolver(
           domain, address_family,
           base::Bind(&ServiceDiscoveryMessageHandler::OnLocalDomainResolved,
                      base::Unretained(this), id)));
   resolver->Start();
   local_domain_resolvers_[id].reset(resolver.release());
 }
 
 void ServiceDiscoveryMessageHandler::DestroyLocalDomainResolver(uint64 id) {
+  VLOG(1) << "DestroyLocalDomainResolver with id " << id;
   if (!service_discovery_client_)
     return;
   local_domain_resolvers_.erase(id);
 }
 
 void ServiceDiscoveryMessageHandler::ShutdownLocalDiscovery() {
+  VLOG(1) << "ShutdownLocalDiscovery";
   discovery_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ServiceDiscoveryMessageHandler::ShutdownOnIOThread,
                  base::Unretained(this)));
 
   // This will wait for message loop to drain, so ShutdownOnIOThread will
   // definitely be called.
   discovery_thread_.reset();
 }
 
 void ServiceDiscoveryMessageHandler::ShutdownOnIOThread() {
   service_watchers_.clear();
   service_resolvers_.clear();
   local_domain_resolvers_.clear();
 
   service_discovery_client_.reset();
   mdns_client_.reset();
 }
 
 void ServiceDiscoveryMessageHandler::OnServiceUpdated(
     uint64 id,
     ServiceWatcher::UpdateType update,
     const std::string& name) {
+  VLOG(1) << "OnServiceUpdated with id " << id
+          << WatcherUpdateToString(update);
   DCHECK(service_discovery_client_);
   utility_task_runner_->PostTask(FROM_HERE,
       base::Bind(&SendServiceUpdated, id, update, name));
 }
 
 void ServiceDiscoveryMessageHandler::OnServiceResolved(
     uint64 id,
     ServiceResolver::RequestStatus status,
     const ServiceDescription& description) {
+  VLOG(1) << "OnServiceResolved with id " << id << " and status "
+          << ResolverStatusToString(status);
+
   DCHECK(service_discovery_client_);
   utility_task_runner_->PostTask(FROM_HERE,
       base::Bind(&SendServiceResolved, id, status, description));
 }
 
 void ServiceDiscoveryMessageHandler::OnLocalDomainResolved(
     uint64 id,
     bool success,
     const net::IPAddressNumber& address_ipv4,
     const net::IPAddressNumber& address_ipv6) {
+  VLOG(1) << "OnLocalDomainResolved with id " << id;
+
+  if (!address_ipv4.empty())
+    VLOG(1) << "Local comain callback has valid ipv4 address with id " << id;
+  if (!address_ipv6.empty())
+    VLOG(1) << "Local comain callback has valid ipv6 address with id " << id;
+
   DCHECK(service_discovery_client_);
   utility_task_runner_->PostTask(FROM_HERE, base::Bind(&SendLocalDomainResolved,
                                                        id, success,
                                                        address_ipv4,
                                                        address_ipv6));
 }
 
 
 }  // namespace local_discovery