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

ipc/ipc_fuzzing_tests.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 <stdint.h>
 #include <stdio.h>
+
+#include <sstream>
 #include <string>
-#include <sstream>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "ipc/ipc_test_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // IPC messages for testing ----------------------------------------------------
 
@@ skipping 13 matching lines @@
 
 // Used to generate an ID for a message that should not exist.
 IPC_MESSAGE_CONTROL0(MsgUnhandled)
 
 // -----------------------------------------------------------------------------
 
 namespace {
 
 TEST(IPCMessageIntegrity, ReadBeyondBufferStr) {
   // This was BUG 984408.
-  uint32 v1 = kuint32max - 1;
+  uint32_t v1 = kuint32max - 1;
   int v2 = 666;
   IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
   EXPECT_TRUE(m.WriteInt(v1));
   EXPECT_TRUE(m.WriteInt(v2));
 
   base::PickleIterator iter(m);
   std::string vs;
   EXPECT_FALSE(iter.ReadString(&vs));
 }
 
 TEST(IPCMessageIntegrity, ReadBeyondBufferStr16) {
   // This was BUG 984408.
-  uint32 v1 = kuint32max - 1;
+  uint32_t v1 = kuint32max - 1;
   int v2 = 777;
   IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
   EXPECT_TRUE(m.WriteInt(v1));
   EXPECT_TRUE(m.WriteInt(v2));
 
   base::PickleIterator iter(m);
   base::string16 vs;
   EXPECT_FALSE(iter.ReadString16(&vs));
 }
 
@@ skipping 29 matching lines @@
 #define MAYBE_ReadVectorTooLarge1 ReadVectorTooLarge1
 #endif
 TEST(IPCMessageIntegrity, MAYBE_ReadVectorTooLarge1) {
   // This was BUG 1006367. This is the large but positive length case. Again
   // we try to hit the non-specialized case vector<P>.
   IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
   EXPECT_TRUE(m.WriteInt(0x21000003));   // This is the count of elements.
   EXPECT_TRUE(m.WriteInt64(1));
   EXPECT_TRUE(m.WriteInt64(2));
 
-  std::vector<int64> vec;
+  std::vector<int64_t> vec;
   base::PickleIterator iter(m);
   EXPECT_FALSE(ReadParam(&m, &iter, &vec));
 }
 
 TEST(IPCMessageIntegrity, ReadVectorTooLarge2) {
   // This was BUG 1006367. This is the large but positive with an additional
   // integer overflow when computing the actual byte size. Again we try to hit
   // the non-specialized case vector<P>.
   IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
   EXPECT_TRUE(m.WriteInt(0x71000000));   // This is the count of elements.
   EXPECT_TRUE(m.WriteInt64(1));
   EXPECT_TRUE(m.WriteInt64(2));
 
-  std::vector<int64> vec;
+  std::vector<int64_t> vec;
   base::PickleIterator iter(m);
   EXPECT_FALSE(ReadParam(&m, &iter, &vec));
 }
 
 class SimpleListener : public IPC::Listener {
  public:
   SimpleListener() : other_(NULL) {
   }
   void Init(IPC::Sender* s) {
     other_ = s;
@@ skipping 34 matching lines @@
     RoundtripAckReply(FUZZER_ROUTING_ID, MsgClassIS::ID, value);
     Cleanup();
   }
 
   void OnMsgClassSIMessage(const base::string16& text, int value) {
     UseData(MsgClassSI::ID, value, text);
     RoundtripAckReply(FUZZER_ROUTING_ID, MsgClassSI::ID, value);
     Cleanup();
   }
 
-  bool RoundtripAckReply(int routing, uint32 type_id, int reply) {
+  bool RoundtripAckReply(int routing, uint32_t type_id, int reply) {
     IPC::Message* message = new IPC::Message(routing, type_id,
                                              IPC::Message::PRIORITY_NORMAL);
     message->WriteInt(reply + 1);
     message->WriteInt(reply);
     return other_->Send(message);
   }
 
   void Cleanup() {
     --message_count_;
     --pending_messages_;
     if (0 == message_count_)
       base::MessageLoop::current()->Quit();
   }
 
-  void ReplyMsgNotHandled(uint32 type_id) {
+  void ReplyMsgNotHandled(uint32_t type_id) {
     RoundtripAckReply(FUZZER_ROUTING_ID, MsgUnhandled::ID, type_id);
     Cleanup();
   }
 
   void UseData(int caller, int value, const base::string16& text) {
     std::ostringstream os;
     os << "IPC fuzzer:" << caller << " [" << value << " "
        << base::UTF16ToUTF8(text) << "]\n";
     std::string output = os.str();
     LOG(WARNING) << output;
   }
 
   int message_count_;
   int pending_messages_;
 };
 
 class FuzzerClientListener : public SimpleListener {
  public:
   FuzzerClientListener() : last_msg_(NULL) {
   }
 
   bool OnMessageReceived(const IPC::Message& msg) override {
     last_msg_ = new IPC::Message(msg);
     base::MessageLoop::current()->Quit();
     return true;
   }
 
-  bool ExpectMessage(int value, uint32 type_id) {
+  bool ExpectMessage(int value, uint32_t type_id) {
     if (!MsgHandlerInternal(type_id))
       return false;
     int msg_value1 = 0;
     int msg_value2 = 0;
     base::PickleIterator iter(*last_msg_);
     if (!iter.ReadInt(&msg_value1))
       return false;
     if (!iter.ReadInt(&msg_value2))
       return false;
     if ((msg_value2 + 1) != msg_value1)
       return false;
     if (msg_value2 != value)
       return false;
 
     delete last_msg_;
     last_msg_ = NULL;
     return true;
   }
 
-  bool ExpectMsgNotHandled(uint32 type_id) {
+  bool ExpectMsgNotHandled(uint32_t type_id) {
     return ExpectMessage(type_id, MsgUnhandled::ID);
   }
 
  private:
-  bool MsgHandlerInternal(uint32 type_id) {
+  bool MsgHandlerInternal(uint32_t type_id) {
     base::MessageLoop::current()->Run();
     if (NULL == last_msg_)
       return false;
     if (FUZZER_ROUTING_ID != last_msg_->routing_id())
       return false;
     return (type_id == last_msg_->type());
   }
 
   IPC::Message* last_msg_;
 };
@@ skipping 109 matching lines @@
   // thrown out of sync by the extra argument.
   msg = new MsgClassIS(3, base::ASCIIToUTF16("expect three"));
   sender()->Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(3, MsgClassIS::ID));
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 }  // namespace