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

components/nacl/browser/nacl_process_host.cc

 // Copyright (c) 2012 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 "components/nacl/browser/nacl_process_host.h"
 
+#include <string.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/process_iterator.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 100 matching lines @@
 // Allocates |size| bytes of address space in the given process at a
 // randomised address.
 void* AllocateAddressSpaceASLR(base::ProcessHandle process, size_t size) {
   char* addr;
   size_t avail_size;
   FindAddressSpace(process, &addr, &avail_size);
   if (avail_size < size)
     return NULL;
   size_t offset = base::RandGenerator(avail_size - size);
   const int kPageSize = 0x10000;
-  void* request_addr =
-      reinterpret_cast<void*>(reinterpret_cast<uint64>(addr + offset)
-                              & ~(kPageSize - 1));
+  void* request_addr = reinterpret_cast<void*>(
+      reinterpret_cast<uint64_t>(addr + offset) & ~(kPageSize - 1));
   return VirtualAllocEx(process, request_addr, size,
                         MEM_RESERVE, PAGE_NOACCESS);
 }
 
 namespace {
 
 bool RunningOnWOW64() {
   return (base::win::OSInfo::GetInstance()->wow64_status() ==
           base::win::OSInfo::WOW64_ENABLED);
 }
@@ skipping 125 matching lines @@
   IPC::ChannelHandle handle_;
 };
 
 NaClProcessHost::NaClProcessHost(
     const GURL& manifest_url,
     base::File nexe_file,
     const NaClFileToken& nexe_token,
     const std::vector<NaClResourcePrefetchResult>& prefetched_resource_files,
     ppapi::PpapiPermissions permissions,
     int render_view_id,
-    uint32 permission_bits,
+    uint32_t permission_bits,
     bool uses_nonsfi_mode,
     bool off_the_record,
     NaClAppProcessType process_type,
     const base::FilePath& profile_directory)
     : manifest_url_(manifest_url),
       nexe_file_(nexe_file.Pass()),
       nexe_token_(nexe_token),
       prefetched_resource_files_(prefetched_resource_files),
       permissions_(permissions),
 #if defined(OS_WIN)
@@ skipping 224 matching lines @@
   // Create a shared memory region that the renderer and plugin share for
   // reporting crash information.
   crash_info_shmem_.CreateAnonymous(kNaClCrashInfoShmemSize);
 
   // Launch the process
   if (!LaunchSelLdr()) {
     delete this;
   }
 }
 
-void NaClProcessHost::OnChannelConnected(int32 peer_pid) {
+void NaClProcessHost::OnChannelConnected(int32_t peer_pid) {
   if (!base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kNaClGdb).empty()) {
     LaunchNaClGdb();
   }
 }
 
 #if defined(OS_WIN)
 void NaClProcessHost::OnProcessLaunchedByBroker(base::ProcessHandle handle) {
   process_launched_by_broker_ = true;
   process_->SetHandle(handle);
@@ skipping 279 matching lines @@
 
 #if defined(OS_POSIX)
 // TCP port we chose for NaCl debug stub. It can be any other number.
 static const uint16_t kInitialDebugStubPort = 4014;
 
 net::SocketDescriptor NaClProcessHost::GetDebugStubSocketHandle() {
   // We always try to allocate the default port first. If this fails, we then
   // allocate any available port.
   // On success, if the test system has register a handler
   // (GdbDebugStubPortListener), we fire a notification.
-  uint16 port = kInitialDebugStubPort;
+  uint16_t port = kInitialDebugStubPort;
   net::SocketDescriptor s =
       net::CreatePlatformSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (s != net::kInvalidSocket) {
     // Allow rapid reuse.
     static const int kOn = 1;
     setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &kOn, sizeof(kOn));
 
     sockaddr_in addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin_family = AF_INET;
@@ skipping 388 matching lines @@
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   *result = nacl_browser->QueryKnownToValidate(signature, off_the_record_);
 }
 
 void NaClProcessHost::OnSetKnownToValidate(const std::string& signature) {
   CHECK(!uses_nonsfi_mode_);
   NaClBrowser::GetInstance()->SetKnownToValidate(
       signature, off_the_record_);
 }
 
-void NaClProcessHost::OnResolveFileToken(uint64 file_token_lo,
-                                         uint64 file_token_hi) {
+void NaClProcessHost::OnResolveFileToken(uint64_t file_token_lo,
+                                         uint64_t file_token_hi) {
   // Was the file registered?
   //
   // Note that the file path cache is of bounded size, and old entries can get
   // evicted.  If a large number of NaCl modules are being launched at once,
   // resolving the file_token may fail because the path cache was thrashed
   // while the file_token was in flight.  In this case the query fails, and we
   // need to fall back to the slower path.
   //
   // However: each NaCl process will consume 2-3 entries as it starts up, this
   // means that eviction will not happen unless you start up 33+ NaCl processes
@@ skipping 126 matching lines @@
     NaClStartDebugExceptionHandlerThread(
         process.Pass(), info, base::ThreadTaskRunnerHandle::Get(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl