Additional logging in OSX mDns for investigation of attached bug.

chrome/browser/local_discovery/service_discovery_client_mac.mm

 // 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_client_mac.h"
 
 #import <Foundation/Foundation.h>
 #import <arpa/inet.h>
 #import <net/if_dl.h>
 
@@ skipping 65 matching lines @@
 
   return !domain->empty() &&
          !type->empty() &&
          (!is_service_name || !instance->empty());
 }
 
 void ParseTxtRecord(NSData* record, std::vector<std::string>* output) {
   if (record == nil || [record length] <= 1)
     return;
 
-  const uint8* record_bytes = reinterpret_cast<const uint8*>([record bytes]);
-  const uint8* const record_end = record_bytes + [record length];
+  VLOG(1) << "ParseTxtRecord: " << [record length];
+
+  const char* record_bytes = reinterpret_cast<const char*>([record bytes]);
+  const char* const record_end = record_bytes + [record length];
   // TODO(justinlin): More strict bounds checking.
   while (record_bytes < record_end) {
     uint8 size = *record_bytes++;
     if (size <= 0)
       continue;
 
     if (record_bytes + size <= record_end) {
+      VLOG(1) << "TxtRecord: "
+              << std::string(record_bytes, static_cast<size_t>(size));
       output->push_back(
           [[[NSString alloc] initWithBytes:record_bytes
                              length:size
                              encoding:NSUTF8StringEncoding] UTF8String]);
     }
     record_bytes += size;
   }
 }
 
 }  // namespace
 
 ServiceDiscoveryClientMac::ServiceDiscoveryClientMac() {}
 ServiceDiscoveryClientMac::~ServiceDiscoveryClientMac() {}
 
 scoped_ptr<ServiceWatcher> ServiceDiscoveryClientMac::CreateServiceWatcher(
     const std::string& service_type,
     const ServiceWatcher::UpdatedCallback& callback) {
+  VLOG(1) << "CreateServiceWatcher: " << service_type;
   return scoped_ptr<ServiceWatcher>(new ServiceWatcherImplMac(service_type,
                                                               callback));
 }
 
 scoped_ptr<ServiceResolver> ServiceDiscoveryClientMac::CreateServiceResolver(
     const std::string& service_name,
     const ServiceResolver::ResolveCompleteCallback& callback) {
+  VLOG(1) << "CreateServiceResolver: " << service_name;
   return scoped_ptr<ServiceResolver>(new ServiceResolverImplMac(service_name,
                                                                 callback));
 }
 
 scoped_ptr<LocalDomainResolver>
 ServiceDiscoveryClientMac::CreateLocalDomainResolver(
     const std::string& domain,
     net::AddressFamily address_family,
     const LocalDomainResolver::IPAddressCallback& callback) {
   NOTIMPLEMENTED();  // TODO(justinlin): Implement.
+  VLOG(1) << "CreateLocalDomainResolver: " << domain;
   return scoped_ptr<LocalDomainResolver>();
 }
 
 ServiceWatcherImplMac::ServiceWatcherImplMac(
     const std::string& service_type,
     const ServiceWatcher::UpdatedCallback& callback)
     : service_type_(service_type), callback_(callback), started_(false) {}
 
 ServiceWatcherImplMac::~ServiceWatcherImplMac() {}
 
 void ServiceWatcherImplMac::Start() {
   DCHECK(!started_);
+  VLOG(1) << "ServiceWatcherImplMac::Start";
   delegate_.reset([[NetServiceBrowserDelegate alloc]
                         initWithServiceWatcher:this]);
   browser_.reset([[NSNetServiceBrowser alloc] init]);
   [browser_ setDelegate:delegate_];
   started_ = true;
 }
 
 // TODO(justinlin): Implement flushing DNS cache to respect parameter.
 void ServiceWatcherImplMac::DiscoverNewServices(bool force_update) {
   DCHECK(started_);
-
+  VLOG(1) << "ServiceWatcherImplMac::DiscoverNewServices";
   std::string instance;
   std::string type;
   std::string domain;
 
   if (!ExtractServiceInfo(service_type_, false, &instance, &type, &domain))
     return;
 
   DCHECK(instance.empty());
   DVLOG(1) << "Listening for service type '" << type
            << "' on domain '" << domain << "'";
 
   [browser_ searchForServicesOfType:[NSString stringWithUTF8String:type.c_str()]
             inDomain:[NSString stringWithUTF8String:domain.c_str()]];
 }
 
 void ServiceWatcherImplMac::SetActivelyRefreshServices(
     bool actively_refresh_services) {
   DCHECK(started_);
+  VLOG(1) << "ServiceWatcherImplMac::SetActivelyRefreshServices";
   // TODO(noamsml): Implement this method.
 }
 
 std::string ServiceWatcherImplMac::GetServiceType() const {
   return service_type_;
 }
 
 void ServiceWatcherImplMac::OnServicesUpdate(ServiceWatcher::UpdateType update,
                                              const std::string& service) {
+  VLOG(1) << "ServiceWatcherImplMac::OnServicesUpdate: "
+          << service + "." + service_type_;
   callback_.Run(update, service + "." + service_type_);
 }
 
 ServiceResolverImplMac::ServiceResolverImplMac(
     const std::string& service_name,
     const ServiceResolver::ResolveCompleteCallback& callback)
     : service_name_(service_name), callback_(callback), has_resolved_(false) {
   std::string instance;
   std::string type;
   std::string domain;
 
   if (ExtractServiceInfo(service_name, true, &instance, &type, &domain)) {
+    VLOG(1) << "ServiceResolverImplMac::ServiceResolverImplMac: Success";
     delegate_.reset([[NetServiceDelegate alloc] initWithServiceResolver:this]);
     service_.reset(
         [[NSNetService alloc]
             initWithDomain:[[NSString alloc] initWithUTF8String:domain.c_str()]
             type:[[NSString alloc] initWithUTF8String:type.c_str()]
             name:[[NSString alloc] initWithUTF8String:instance.c_str()]]);
     [service_ setDelegate:delegate_];
   }
+  VLOG(1) << "ServiceResolverImplMac::ServiceResolverImplMac: "
+          << service_name
+          << ", instance: " << instance
+          << ", type: " << type
+          << ", domain: " << domain;
 }
 
 ServiceResolverImplMac::~ServiceResolverImplMac() {}
 
 void ServiceResolverImplMac::StartResolving() {
   if (!service_.get())
     return;
 
-  DVLOG(1) << "Resolving service " << service_name_;
+  VLOG(1) << "Resolving service " << service_name_;
   [service_ resolveWithTimeout:kResolveTimeout];
 }
 
 std::string ServiceResolverImplMac::GetName() const {
   return service_name_;
 }
 
 void ServiceResolverImplMac::OnResolveUpdate(RequestStatus status) {
+  VLOG(1) << "ServiceResolverImplMac::OnResolveUpdate: " << service_name_
+          << ", " << status;
   if (status == STATUS_SUCCESS) {
     service_description_.service_name = service_name_;
 
     for (NSData* address in [service_ addresses]) {
       const void* bytes = [address bytes];
       // TODO(justinlin): Handle IPv6 addresses?
       if (static_cast<const sockaddr*>(bytes)->sa_family == AF_INET) {
         const sockaddr_in* sock = static_cast<const sockaddr_in*>(bytes);
         char addr[INET_ADDRSTRLEN];
         inet_ntop(AF_INET, &sock->sin_addr, addr, INET_ADDRSTRLEN);
@@ skipping 83 matching lines @@
       local_discovery::ServiceResolver::STATUS_SUCCESS);
 }
 
 - (void)netService:(NSNetService *)sender
         didNotResolve:(NSDictionary *)errorDict {
   serviceResolverImpl_->OnResolveUpdate(
       local_discovery::ServiceResolver::STATUS_REQUEST_TIMEOUT);
 }
 
 @end