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

ipc/mojo/ipc_message_pipe_reader.cc

 // Copyright 2014 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/mojo/ipc_message_pipe_reader.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "ipc/mojo/async_handle_waiter.h"
 #include "ipc/mojo/ipc_channel_mojo.h"
 
 namespace IPC {
@@ skipping 53 matching lines @@
   TRACE_EVENT_WITH_FLOW0(TRACE_DISABLED_BY_DEFAULT("ipc.flow"),
                          "MessagePipeReader::Send",
                          message->flags(),
                          TRACE_EVENT_FLAG_FLOW_OUT);
   std::vector<MojoHandle> handles;
   MojoResult result = MOJO_RESULT_OK;
   result = ChannelMojo::ReadFromMessageAttachmentSet(message.get(), &handles);
   if (result == MOJO_RESULT_OK) {
     result = MojoWriteMessage(handle(),
                               message->data(),
-                              static_cast<uint32>(message->size()),
+                              static_cast<uint32_t>(message->size()),
                               handles.empty() ? nullptr : &handles[0],
-                              static_cast<uint32>(handles.size()),
+                              static_cast<uint32_t>(handles.size()),
                               MOJO_WRITE_MESSAGE_FLAG_NONE);
   }
 
   if (result != MOJO_RESULT_OK) {
     std::for_each(handles.begin(), handles.end(), &MojoClose);
     // We cannot call CloseWithError() here as Send() is protected by
     // ChannelMojo's lock and CloseWithError() could re-enter ChannelMojo. We
     // cannot call CloseWithError() also because Send() can be called from
     // non-UI thread while OnPipeError() expects to be called on IO thread.
     CloseWithErrorLater(result);
     return false;
   }
 
   return true;
 }
 
 void MessagePipeReader::OnMessageReceived() {
   Message message(data_buffer().empty() ? "" : &data_buffer()[0],
-                  static_cast<uint32>(data_buffer().size()));
+                  static_cast<uint32_t>(data_buffer().size()));
 
   std::vector<MojoHandle> handle_buffer;
   TakeHandleBuffer(&handle_buffer);
   MojoResult write_result =
       ChannelMojo::WriteToMessageAttachmentSet(handle_buffer, &message);
   if (write_result != MOJO_RESULT_OK) {
     CloseWithError(write_result);
     return;
   }
 
@@ skipping 122 matching lines @@
 
 void MessagePipeReader::DelayedDeleter::operator()(
     MessagePipeReader* ptr) const {
   ptr->Close();
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(&DeleteNow, ptr));
 }
 
 }  // namespace internal
 }  // namespace IPC