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

components/nacl/loader/nacl_ipc_adapter_unittest.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 "components/nacl/loader/nacl_ipc_adapter.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "ipc/ipc_test_sink.h"
 #include "native_client/src/public/nacl_desc_custom.h"
 #include "native_client/src/trusted/service_runtime/include/sys/fcntl.h"
 #include "ppapi/c/ppb_file_io.h"
@@ skipping 49 matching lines @@
   // In real life the adapter needs to take ownership so the channel can be
   // destroyed on the right thread.
   IPC::TestSink* sink_;
 };
 
 }  // namespace
 
 // Tests a simple message getting rewritten sent from native code to NaCl.
 TEST_F(NaClIPCAdapterTest, SimpleReceiveRewriting) {
   int routing_id = 0x89898989;
-  uint32 type = 0x55555555;
+  uint32_t type = 0x55555555;
   IPC::Message input(routing_id, type, IPC::Message::PRIORITY_NORMAL);
-  uint32 flags = input.flags();
+  uint32_t flags = input.flags();
 
   int value = 0x12345678;
   input.WriteInt(value);
   adapter_->OnMessageReceived(input);
 
   // Buffer just need to be big enough for our message with one int.
   const int kBufSize = 64;
   char buf[kBufSize];
 
   int bytes_read = BlockingReceive(buf, kBufSize);
@@ skipping 11 matching lines @@
 
   // Validate the payload.
   EXPECT_EQ(value,
             *reinterpret_cast<const int*>(&buf[
                 sizeof(NaClIPCAdapter::NaClMessageHeader)]));
 }
 
 // Tests a simple message getting rewritten sent from NaCl to native code.
 TEST_F(NaClIPCAdapterTest, SendRewriting) {
   int routing_id = 0x89898989;
-  uint32 type = 0x55555555;
+  uint32_t type = 0x55555555;
   int value = 0x12345678;
 
   // Send a message with one int inside it.
   const int buf_size = sizeof(NaClIPCAdapter::NaClMessageHeader) + sizeof(int);
   char buf[buf_size] = {0};
 
   NaClIPCAdapter::NaClMessageHeader* header =
       reinterpret_cast<NaClIPCAdapter::NaClMessageHeader*>(buf);
   header->payload_size = sizeof(int);
   header->routing = routing_id;
@@ skipping 45 matching lines @@
   ASSERT_EQ(1u, sink_->message_count());
   msg = sink_->GetMessageAt(0);
   EXPECT_EQ(sizeof(int), msg->payload_size());
   EXPECT_EQ(header->routing, msg->routing_id());
   EXPECT_EQ(header->type, msg->type());
 }
 
 // Tests when a buffer is too small to receive the entire message.
 TEST_F(NaClIPCAdapterTest, PartialReceive) {
   int routing_id_1 = 0x89898989;
-  uint32 type_1 = 0x55555555;
+  uint32_t type_1 = 0x55555555;
   IPC::Message input_1(routing_id_1, type_1, IPC::Message::PRIORITY_NORMAL);
   int value_1 = 0x12121212;
   input_1.WriteInt(value_1);
   adapter_->OnMessageReceived(input_1);
 
   int routing_id_2 = 0x90909090;
-  uint32 type_2 = 0x66666666;
+  uint32_t type_2 = 0x66666666;
   IPC::Message input_2(routing_id_2, type_2, IPC::Message::PRIORITY_NORMAL);
   int value_2 = 0x23232323;
   input_2.WriteInt(value_2);
   adapter_->OnMessageReceived(input_2);
 
   const int kBufSize = 64;
   char buf[kBufSize];
 
   // Read part of the first message.
   int bytes_requested = 7;
@@ skipping 22 matching lines @@
   EXPECT_EQ(sizeof(int), output_header->payload_size);
   EXPECT_EQ(routing_id_2, output_header->routing);
   EXPECT_EQ(type_2, output_header->type);
 }
 
 // Tests sending messages that are too large. We test sends that are too
 // small implicitly here and in the success case because in that case it
 // succeeds and buffers the data.
 TEST_F(NaClIPCAdapterTest, SendOverflow) {
   int routing_id = 0x89898989;
-  uint32 type = 0x55555555;
+  uint32_t type = 0x55555555;
   int value = 0x12345678;
 
   // Make a message with one int inside it. Reserve some extra space so
   // we can test what happens when we send too much data.
   const int buf_size = sizeof(NaClIPCAdapter::NaClMessageHeader) + sizeof(int);
   const int big_buf_size = buf_size + 4;
   char buf[big_buf_size] = {0};
 
   NaClIPCAdapter::NaClMessageHeader* header =
       reinterpret_cast<NaClIPCAdapter::NaClMessageHeader*>(buf);
@@ skipping 110 matching lines @@
   EXPECT_EQ(NACL_ABI_O_RDONLY,
       TranslatePepperFileReadWriteOpenFlagsForTesting(
           PP_FILEOPENFLAG_CREATE));
   EXPECT_EQ(NACL_ABI_O_RDONLY,
       TranslatePepperFileReadWriteOpenFlagsForTesting(
           PP_FILEOPENFLAG_TRUNCATE));
   EXPECT_EQ(NACL_ABI_O_RDONLY,
       TranslatePepperFileReadWriteOpenFlagsForTesting(
           PP_FILEOPENFLAG_EXCLUSIVE));
 }