Switch to standard integer types in remoting/host/.

remoting/host/native_messaging/native_messaging_reader_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 "remoting/host/native_messaging/native_messaging_reader.h"
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "remoting/host/setup/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
@@ skipping 50 matching lines @@
       base::Bind(&NativeMessagingReaderTest::OnMessage, base::Unretained(this)),
       run_loop_.QuitClosure());
   run_loop_.Run();
 }
 
 void NativeMessagingReaderTest::OnMessage(scoped_ptr<base::Value> message) {
   message_ = message.Pass();
 }
 
 void NativeMessagingReaderTest::WriteMessage(const std::string& message) {
-  uint32 length = message.length();
+  uint32_t length = message.length();
   WriteData(reinterpret_cast<char*>(&length), 4);
   WriteData(message.data(), length);
 }
 
 void NativeMessagingReaderTest::WriteData(const char* data, int length) {
   int written = write_file_.WriteAtCurrentPos(data, length);
   ASSERT_EQ(length, written);
 }
 
 TEST_F(NativeMessagingReaderTest, GoodMessage) {
   WriteMessage("{\"foo\": 42}");
   Run();
   EXPECT_TRUE(message_);
   base::DictionaryValue* message_dict;
   EXPECT_TRUE(message_->GetAsDictionary(&message_dict));
   int result;
   EXPECT_TRUE(message_dict->GetInteger("foo", &result));
   EXPECT_EQ(42, result);
 }
 
 TEST_F(NativeMessagingReaderTest, InvalidLength) {
-  uint32 length = 0xffffffff;
+  uint32_t length = 0xffffffff;
   WriteData(reinterpret_cast<char*>(&length), 4);
   Run();
   EXPECT_FALSE(message_);
 }
 
 TEST_F(NativeMessagingReaderTest, EmptyFile) {
   Run();
   EXPECT_FALSE(message_);
 }
 
 TEST_F(NativeMessagingReaderTest, ShortHeader) {
   // Write only 3 bytes - the message length header is supposed to be 4 bytes.
   WriteData("xxx", 3);
   Run();
   EXPECT_FALSE(message_);
 }
 
 TEST_F(NativeMessagingReaderTest, EmptyBody) {
-  uint32 length = 1;
+  uint32_t length = 1;
   WriteData(reinterpret_cast<char*>(&length), 4);
   Run();
   EXPECT_FALSE(message_);
 }
 
 TEST_F(NativeMessagingReaderTest, ShortBody) {
-  uint32 length = 2;
+  uint32_t length = 2;
   WriteData(reinterpret_cast<char*>(&length), 4);
 
   // Only write 1 byte, where the header indicates there should be 2 bytes.
   WriteData("x", 1);
   Run();
   EXPECT_FALSE(message_);
 }
 
 TEST_F(NativeMessagingReaderTest, InvalidJSON) {
   std::string text = "{";
   WriteMessage(text);
   Run();
   EXPECT_FALSE(message_);
 }
 
 TEST_F(NativeMessagingReaderTest, SecondMessage) {
   WriteMessage("{}");
   WriteMessage("{\"foo\": 42}");
   Run();
   EXPECT_TRUE(message_);
   base::DictionaryValue* message_dict;
   EXPECT_TRUE(message_->GetAsDictionary(&message_dict));
   int result;
   EXPECT_TRUE(message_dict->GetInteger("foo", &result));
   EXPECT_EQ(42, result);
 }
 
 }  // namespace remoting