Switch to standard integer types in chrome/.

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 <stddef.h>
+
 #include <algorithm>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
+#include "build/build_config.h"
 #include "chrome/common/local_discovery/local_discovery_messages.h"
 #include "chrome/common/local_discovery/service_discovery_client_impl.h"
 #include "content/public/utility/utility_thread.h"
 #include "net/base/net_util.h"
 #include "net/socket/socket_descriptor.h"
 #include "net/udp/datagram_server_socket.h"
 
 namespace local_discovery {
 
 namespace {
@@ skipping 26 matching lines @@
   }
 
  private:
   net::SocketDescriptor socket_;
   DISALLOW_COPY_AND_ASSIGN(ScopedSocketFactory);
 };
 
 struct SocketInfo {
   SocketInfo(net::SocketDescriptor socket,
              net::AddressFamily address_family,
-             uint32 interface_index)
+             uint32_t interface_index)
       : socket(socket),
         address_family(address_family),
-        interface_index(interface_index) {
-  }
+        interface_index(interface_index) {}
   net::SocketDescriptor socket;
   net::AddressFamily address_family;
-  uint32 interface_index;
+  uint32_t interface_index;
 };
 
 // Returns list of sockets preallocated before.
 class PreCreatedMDnsSocketFactory : public net::MDnsSocketFactory {
  public:
   PreCreatedMDnsSocketFactory() {}
   ~PreCreatedMDnsSocketFactory() override {
     // Not empty if process exits too fast, before starting mDns code. If
     // happened, destructors may crash accessing destroyed global objects.
     // TODO This sounds memory leak, check and do better if possible
@@ skipping 182 matching lines @@
     const std::vector<LocalDiscoveryMsg_SocketInfo>& sockets) {
   for (size_t i = 0; i < sockets.size(); ++i) {
     g_local_discovery_socket_factory.Get().AddSocket(
         SocketInfo(sockets[i].descriptor.fd, sockets[i].address_family,
                    sockets[i].interface_index));
   }
 }
 #endif  // OS_POSIX
 
 void ServiceDiscoveryMessageHandler::OnStartWatcher(
-    uint64 id,
+    uint64_t id,
     const std::string& service_type) {
   PostTask(FROM_HERE,
            base::Bind(&ServiceDiscoveryMessageHandler::StartWatcher,
                       base::Unretained(this), id, service_type));
 }
 
-void ServiceDiscoveryMessageHandler::OnDiscoverServices(uint64 id,
+void ServiceDiscoveryMessageHandler::OnDiscoverServices(uint64_t id,
                                                         bool force_update) {
   PostTask(FROM_HERE,
            base::Bind(&ServiceDiscoveryMessageHandler::DiscoverServices,
                       base::Unretained(this), id, force_update));
 }
 
 void ServiceDiscoveryMessageHandler::OnSetActivelyRefreshServices(
-    uint64 id, bool actively_refresh_services) {
+    uint64_t id,
+    bool actively_refresh_services) {
   PostTask(FROM_HERE,
            base::Bind(
                &ServiceDiscoveryMessageHandler::SetActivelyRefreshServices,
                base::Unretained(this), id, actively_refresh_services));
 }
 
-void ServiceDiscoveryMessageHandler::OnDestroyWatcher(uint64 id) {
+void ServiceDiscoveryMessageHandler::OnDestroyWatcher(uint64_t id) {
   PostTask(FROM_HERE,
            base::Bind(&ServiceDiscoveryMessageHandler::DestroyWatcher,
                       base::Unretained(this), id));
 }
 
 void ServiceDiscoveryMessageHandler::OnResolveService(
-    uint64 id,
+    uint64_t id,
     const std::string& service_name) {
   PostTask(FROM_HERE,
            base::Bind(&ServiceDiscoveryMessageHandler::ResolveService,
                       base::Unretained(this), id, service_name));
 }
 
-void ServiceDiscoveryMessageHandler::OnDestroyResolver(uint64 id) {
+void ServiceDiscoveryMessageHandler::OnDestroyResolver(uint64_t id) {
   PostTask(FROM_HERE,
            base::Bind(&ServiceDiscoveryMessageHandler::DestroyResolver,
                       base::Unretained(this), id));
 }
 
 void ServiceDiscoveryMessageHandler::OnResolveLocalDomain(
-    uint64 id, const std::string& domain,
+    uint64_t id,
+    const std::string& domain,
     net::AddressFamily address_family) {
     PostTask(FROM_HERE,
            base::Bind(&ServiceDiscoveryMessageHandler::ResolveLocalDomain,
                       base::Unretained(this), id, domain, address_family));
 }
 
-void ServiceDiscoveryMessageHandler::OnDestroyLocalDomainResolver(uint64 id) {
+void ServiceDiscoveryMessageHandler::OnDestroyLocalDomainResolver(uint64_t id) {
   PostTask(FROM_HERE,
            base::Bind(
                &ServiceDiscoveryMessageHandler::DestroyLocalDomainResolver,
                base::Unretained(this), id));
 }
 
 void ServiceDiscoveryMessageHandler::StartWatcher(
-    uint64 id,
+    uint64_t id,
     const std::string& service_type) {
   VLOG(1) << "StartWatcher, id=" << id << ", type=" << service_type;
   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,
+void ServiceDiscoveryMessageHandler::DiscoverServices(uint64_t id,
                                                       bool force_update) {
   VLOG(1) << "DiscoverServices, id=" << id;
   if (!service_discovery_client_)
     return;
   DCHECK(ContainsKey(service_watchers_, id));
   service_watchers_[id]->DiscoverNewServices(force_update);
 }
 
 void ServiceDiscoveryMessageHandler::SetActivelyRefreshServices(
-    uint64 id,
+    uint64_t id,
     bool actively_refresh_services) {
   VLOG(1) << "ActivelyRefreshServices, id=" << id;
   if (!service_discovery_client_)
     return;
   DCHECK(ContainsKey(service_watchers_, id));
   service_watchers_[id]->SetActivelyRefreshServices(actively_refresh_services);
 }
 
-void ServiceDiscoveryMessageHandler::DestroyWatcher(uint64 id) {
+void ServiceDiscoveryMessageHandler::DestroyWatcher(uint64_t id) {
   VLOG(1) << "DestoryWatcher, id=" << id;
   if (!service_discovery_client_)
     return;
   service_watchers_.erase(id);
 }
 
 void ServiceDiscoveryMessageHandler::ResolveService(
-    uint64 id,
+    uint64_t id,
     const std::string& service_name) {
   VLOG(1) << "ResolveService, id=" << id << ", name=" << service_name;
   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) {
+void ServiceDiscoveryMessageHandler::DestroyResolver(uint64_t id) {
   VLOG(1) << "DestroyResolver, id=" << id;
   if (!service_discovery_client_)
     return;
   service_resolvers_.erase(id);
 }
 
 void ServiceDiscoveryMessageHandler::ResolveLocalDomain(
-    uint64 id,
+    uint64_t id,
     const std::string& domain,
     net::AddressFamily address_family) {
   VLOG(1) << "ResolveLocalDomain, id=" << id << ", domain=" << domain;
   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) {
+void ServiceDiscoveryMessageHandler::DestroyLocalDomainResolver(uint64_t id) {
   VLOG(1) << "DestroyLocalDomainResolver, id=" << id;
   if (!service_discovery_client_)
     return;
   local_domain_resolvers_.erase(id);
 }
 
 void ServiceDiscoveryMessageHandler::ShutdownLocalDiscovery() {
   if (!discovery_task_runner_.get())
     return;
 
@@ skipping 10 matching lines @@
 void ServiceDiscoveryMessageHandler::ShutdownOnIOThread() {
   VLOG(1) << "ShutdownLocalDiscovery";
   service_watchers_.clear();
   service_resolvers_.clear();
   local_domain_resolvers_.clear();
   service_discovery_client_.reset();
   mdns_client_.reset();
 }
 
 void ServiceDiscoveryMessageHandler::OnServiceUpdated(
-    uint64 id,
+    uint64_t id,
     ServiceWatcher::UpdateType update,
     const std::string& name) {
   VLOG(1) << "OnServiceUpdated, id=" << id
           << ", status=" << WatcherUpdateToString(update) << ", name=" << name;
   DCHECK(service_discovery_client_);
 
   Send(new LocalDiscoveryHostMsg_WatcherCallback(id, update, name));
 }
 
 void ServiceDiscoveryMessageHandler::OnServiceResolved(
-    uint64 id,
+    uint64_t id,
     ServiceResolver::RequestStatus status,
     const ServiceDescription& description) {
   VLOG(1) << "OnServiceResolved, id=" << id
           << ", status=" << ResolverStatusToString(status)
           << ", name=" << description.service_name;
 
   DCHECK(service_discovery_client_);
   Send(new LocalDiscoveryHostMsg_ResolverCallback(id, status, description));
 }
 
 void ServiceDiscoveryMessageHandler::OnLocalDomainResolved(
-    uint64 id,
+    uint64_t id,
     bool success,
     const net::IPAddressNumber& address_ipv4,
     const net::IPAddressNumber& address_ipv6) {
   VLOG(1) << "OnLocalDomainResolved, id=" << id
           << ", IPv4=" << (address_ipv4.empty() ? "" :
                            net::IPAddressToString(address_ipv4))
           << ", IPv6=" << (address_ipv6.empty() ? "" :
                            net::IPAddressToString(address_ipv6));
 
   DCHECK(service_discovery_client_);
   Send(new LocalDiscoveryHostMsg_LocalDomainResolverCallback(
           id, success, address_ipv4, address_ipv6));
 }
 
 void ServiceDiscoveryMessageHandler::Send(IPC::Message* msg) {
   utility_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(&SendHostMessageOnUtilityThread,
                                             msg));
 }
 
 }  // namespace local_discovery