Switch to standard integer types in chrome/browser/, part 2 of 4.

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"
 
+#include <stddef.h>
+
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
+#include "build/build_config.h"
 #include "chrome/common/local_discovery/local_discovery_messages.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
 #include "net/base/net_util.h"
 #include "net/dns/mdns_client.h"
 #include "net/socket/socket_descriptor.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_POSIX)
@@ skipping 73 matching lines @@
     DCHECK(started_);
     host_->Send(new LocalDiscoveryMsg_SetActivelyRefreshServices(
         id_, actively_refresh_services));
   }
 
   std::string GetServiceType() const override { return service_type_; }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   const std::string service_type_;
-  const uint64 id_;
+  const uint64_t id_;
   bool started_;
 };
 
 class ServiceDiscoveryHostClient::ServiceResolverProxy
     : public ServiceResolver {
  public:
   ServiceResolverProxy(ServiceDiscoveryHostClient* host,
                        const std::string& service_name,
                        const ServiceResolver::ResolveCompleteCallback& callback)
       : host_(host),
@@ skipping 14 matching lines @@
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_ResolveService(id_, service_name_));
     started_ = true;
   }
 
   std::string GetName() const override { return service_name_; }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   const std::string service_name_;
-  const uint64 id_;
+  const uint64_t id_;
   bool started_;
 };
 
 class ServiceDiscoveryHostClient::LocalDomainResolverProxy
     : public LocalDomainResolver {
  public:
   LocalDomainResolverProxy(ServiceDiscoveryHostClient* host,
                        const std::string& domain,
                        net::AddressFamily address_family,
                        const LocalDomainResolver::IPAddressCallback& callback)
@@ skipping 16 matching lines @@
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_ResolveLocalDomain(id_, domain_,
                                                          address_family_));
     started_ = true;
   }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   std::string domain_;
   net::AddressFamily address_family_;
-  const uint64 id_;
+  const uint64_t id_;
   bool started_;
 };
 
 ServiceDiscoveryHostClient::ServiceDiscoveryHostClient() : current_id_(0) {
   callback_runner_ = base::MessageLoop::current()->task_runner();
   io_runner_ = BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
 }
 
 ServiceDiscoveryHostClient::~ServiceDiscoveryHostClient() {
   DCHECK(service_watcher_callbacks_.empty());
@@ skipping 20 matching lines @@
 scoped_ptr<LocalDomainResolver>
 ServiceDiscoveryHostClient::CreateLocalDomainResolver(
     const std::string& domain,
     net::AddressFamily address_family,
     const LocalDomainResolver::IPAddressCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return scoped_ptr<LocalDomainResolver>(new LocalDomainResolverProxy(
       this, domain, address_family, callback));
 }
 
-uint64 ServiceDiscoveryHostClient::RegisterWatcherCallback(
+uint64_t ServiceDiscoveryHostClient::RegisterWatcherCallback(
     const ServiceWatcher::UpdatedCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!ContainsKey(service_watcher_callbacks_, current_id_ + 1));
   service_watcher_callbacks_[++current_id_] = callback;
   return current_id_;
 }
 
-uint64 ServiceDiscoveryHostClient::RegisterResolverCallback(
+uint64_t ServiceDiscoveryHostClient::RegisterResolverCallback(
     const ServiceResolver::ResolveCompleteCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!ContainsKey(service_resolver_callbacks_, current_id_ + 1));
   service_resolver_callbacks_[++current_id_] = callback;
   return current_id_;
 }
 
-uint64 ServiceDiscoveryHostClient::RegisterLocalDomainResolverCallback(
+uint64_t ServiceDiscoveryHostClient::RegisterLocalDomainResolverCallback(
     const LocalDomainResolver::IPAddressCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!ContainsKey(domain_resolver_callbacks_, current_id_ + 1));
   domain_resolver_callbacks_[++current_id_] = callback;
   return current_id_;
 }
 
-void ServiceDiscoveryHostClient::UnregisterWatcherCallback(uint64 id) {
+void ServiceDiscoveryHostClient::UnregisterWatcherCallback(uint64_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   service_watcher_callbacks_.erase(id);
 }
 
-void ServiceDiscoveryHostClient::UnregisterResolverCallback(uint64 id) {
+void ServiceDiscoveryHostClient::UnregisterResolverCallback(uint64_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   service_resolver_callbacks_.erase(id);
 }
 
 void ServiceDiscoveryHostClient::UnregisterLocalDomainResolverCallback(
-    uint64 id) {
+    uint64_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   domain_resolver_callbacks_.erase(id);
 }
 
 void ServiceDiscoveryHostClient::Start(
     const base::Closure& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!utility_host_);
   DCHECK(error_callback_.is_null());
   error_callback_ = error_callback;
@@ skipping 122 matching lines @@
   }
 }
 
 void ServiceDiscoveryHostClient::OnError() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!error_callback_.is_null())
     callback_runner_->PostTask(FROM_HERE, error_callback_);
 }
 
 void ServiceDiscoveryHostClient::OnWatcherCallback(
-    uint64 id,
+    uint64_t id,
     ServiceWatcher::UpdateType update,
     const std::string& service_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::RunWatcherCallback, this, id,
                  update, service_name));
 }
 
 void ServiceDiscoveryHostClient::OnResolverCallback(
-    uint64 id,
+    uint64_t id,
     ServiceResolver::RequestStatus status,
     const ServiceDescription& description) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::RunResolverCallback, this, id,
                  status, description));
 }
 
 void ServiceDiscoveryHostClient::OnLocalDomainResolverCallback(
-    uint64 id,
+    uint64_t id,
     bool success,
     const net::IPAddressNumber& ip_address_ipv4,
     const net::IPAddressNumber& ip_address_ipv6) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ServiceDiscoveryHostClient::RunLocalDomainResolverCallback,
                  this, id, success, ip_address_ipv4, ip_address_ipv6));
 }
 
 void ServiceDiscoveryHostClient::RunWatcherCallback(
-    uint64 id,
+    uint64_t id,
     ServiceWatcher::UpdateType update,
     const std::string& service_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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,
+    uint64_t id,
     ServiceResolver::RequestStatus status,
     const ServiceDescription& description) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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,
+    uint64_t id,
     bool success,
     const net::IPAddressNumber& ip_address_ipv4,
     const net::IPAddressNumber& ip_address_ipv6) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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);
 }
 
 }  // namespace local_discovery