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 250 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 on utility process 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 on utility process 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 on utility process 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 on utility process 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 on utility process with id " << id;

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

no need utility "process part"

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

Done.

   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 on utility process 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 on utility process with id " << id;
   if (!service_discovery_client_)
     return;
   local_domain_resolvers_.erase(id);
 }
 
 void ServiceDiscoveryMessageHandler::ShutdownLocalDiscovery() {
+  VLOG(1) << "ShutdownLocalDiscovery on utility process";
   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 on utility process with id " << id;
   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 on utility process with id " << id;
   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 on utility process 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