ipc: Convert int types from basictypes.h to the ones from stdint.h

ipc/ipc_channel_win.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 "ipc/ipc_channel_win.h"
 
+#include <stdint.h>
 #include <windows.h>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/process/process_handle.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 198 matching lines @@
 }
 
 bool ChannelWin::GetNonBrokeredAttachments(Message* msg) {
   return true;
 }
 
 void ChannelWin::HandleInternalMessage(const Message& msg) {
   DCHECK_EQ(msg.type(), static_cast<unsigned>(Channel::HELLO_MESSAGE_TYPE));
   // The hello message contains one parameter containing the PID.
   base::PickleIterator it(msg);
-  int32 claimed_pid;
+  int32_t claimed_pid;
   bool failed = !it.ReadInt(&claimed_pid);
 
   if (!failed && validate_client_) {
-    int32 secret;
+    int32_t secret;
     failed = it.ReadInt(&secret) ? (secret != client_secret_) : true;
   }
 
   if (failed) {
     NOTREACHED();
     Close();
     listener()->OnChannelError();
     return;
   }
 
@@ skipping 13 matching lines @@
 bool ChannelWin::IsAttachmentBrokerEndpoint() {
   return is_attachment_broker_endpoint();
 }
 
 bool ChannelWin::DidEmptyInputBuffers() {
   // We don't need to do anything here.
   return true;
 }
 
 // static
-const base::string16 ChannelWin::PipeName(
-    const std::string& channel_id, int32* secret) {
+const base::string16 ChannelWin::PipeName(const std::string& channel_id,
+                                          int32_t* secret) {
   std::string name("\\\\.\\pipe\\chrome.");
 
   // Prevent the shared secret from ending up in the pipe name.
   size_t index = channel_id.find_first_of('\\');
   if (index != std::string::npos) {
     if (secret)  // Retrieve the secret if asked for.
       base::StringToInt(channel_id.substr(index + 1), secret);
     return base::ASCIIToUTF16(name.append(channel_id.substr(0, index - 1)));
   }
 
@@ skipping 74 matching lines @@
     return false;
   }
 
   // Create the Hello message to be sent when Connect is called
   scoped_ptr<Message> m(new Message(MSG_ROUTING_NONE,
                                     HELLO_MESSAGE_TYPE,
                                     IPC::Message::PRIORITY_NORMAL));
 
   // Don't send the secret to the untrusted process, and don't send a secret
   // if the value is zero (for IPC backwards compatability).
-  int32 secret = validate_client_ ? 0 : client_secret_;
+  int32_t secret = validate_client_ ? 0 : client_secret_;
   if (!m->WriteInt(GetCurrentProcessId()) ||
       (secret && !m->WriteUInt32(secret))) {
     pipe_.Close();
     return false;
   }
 
   output_queue_.push(m.release());
   return true;
 }
 
@@ skipping 92 matching lines @@
     return true;
 
   if (!pipe_.IsValid())
     return false;
 
   // Write to pipe...
   Message* m = output_queue_.front();
   DCHECK(m->size() <= INT_MAX);
   BOOL ok = WriteFile(pipe_.Get(),
                       m->data(),
-                      static_cast<uint32>(m->size()),
+                      static_cast<uint32_t>(m->size()),
                       NULL,
                       &output_state_.context.overlapped);
   if (!ok) {
     DWORD write_error = GetLastError();
     if (write_error == ERROR_IO_PENDING) {
       output_state_.is_pending = true;
 
       DVLOG(2) << "sent pending message @" << m << " on channel @" << this
                << " with type " << m->type();
 
@@ skipping 92 matching lines @@
   int secret;
   do {  // Guarantee we get a non-zero value.
     secret = base::RandInt(0, std::numeric_limits<int>::max());
   } while (secret == 0);
 
   id.append(GenerateUniqueRandomChannelID());
   return id.append(base::StringPrintf("\\%d", secret));
 }
 
 }  // namespace IPC