Switch to standard integer types in dbus/.

dbus/property_unittest.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 "dbus/property.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "dbus/bus.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/test_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace dbus {
 
 // The property test exerises the asynchronous APIs in PropertySet and
 // Property<>.
 class PropertyTest : public testing::Test {
  public:
   PropertyTest() {}
 
   struct Properties : public PropertySet {
     Property<std::string> name;
-    Property<int16> version;
+    Property<int16_t> version;
     Property<std::vector<std::string> > methods;
     Property<std::vector<ObjectPath> > objects;
-    Property<std::vector<uint8> > bytes;
+    Property<std::vector<uint8_t>> bytes;
 
     Properties(ObjectProxy* object_proxy,
                PropertyChangedCallback property_changed_callback)
         : PropertySet(object_proxy,
                       "org.chromium.TestInterface",
                       property_changed_callback) {
       RegisterProperty("Name", &name);
       RegisterProperty("Version", &version);
       RegisterProperty("Methods", &methods);
       RegisterProperty("Objects", &objects);
@@ skipping 134 matching lines @@
   ASSERT_EQ(4U, methods.size());
   EXPECT_EQ("Echo", methods[0]);
   EXPECT_EQ("SlowEcho", methods[1]);
   EXPECT_EQ("AsyncEcho", methods[2]);
   EXPECT_EQ("BrokenMethod", methods[3]);
 
   std::vector<ObjectPath> objects = properties_->objects.value();
   ASSERT_EQ(1U, objects.size());
   EXPECT_EQ(ObjectPath("/TestObjectPath"), objects[0]);
 
-  std::vector<uint8> bytes = properties_->bytes.value();
+  std::vector<uint8_t> bytes = properties_->bytes.value();
   ASSERT_EQ(4U, bytes.size());
   EXPECT_EQ('T', bytes[0]);
   EXPECT_EQ('e', bytes[1]);
   EXPECT_EQ('s', bytes[2]);
   EXPECT_EQ('t', bytes[3]);
 }
 
 TEST_F(PropertyTest, UpdatedValues) {
   WaitForGetAll();
 
@@ skipping 43 matching lines @@
   EXPECT_EQ(ObjectPath("/TestObjectPath"), objects[0]);
 
   // Update the value of the "Bytes" property, this value should not change
   // and should not grow to contain duplicate entries.
   properties_->bytes.Get(base::Bind(&PropertyTest::PropertyCallback,
                                     base::Unretained(this),
                                    "Bytes"));
   WaitForCallback("Bytes");
   WaitForUpdates(1);
 
-  std::vector<uint8> bytes = properties_->bytes.value();
+  std::vector<uint8_t> bytes = properties_->bytes.value();
   ASSERT_EQ(4U, bytes.size());
   EXPECT_EQ('T', bytes[0]);
   EXPECT_EQ('e', bytes[1]);
   EXPECT_EQ('s', bytes[2]);
   EXPECT_EQ('t', bytes[3]);
 }
 
 TEST_F(PropertyTest, Get) {
   WaitForGetAll();
 
@@ skipping 106 matching lines @@
 
 TEST(PropertyTestStatic, ReadWriteNetAddressArray) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   MessageWriter variant_writer(NULL);
   MessageWriter variant_array_writer(NULL);
   MessageWriter struct_entry_writer(NULL);
 
   writer.OpenVariant("a(ayq)", &variant_writer);
   variant_writer.OpenArray("(ayq)", &variant_array_writer);
-  uint8 ip_bytes[] = {0x54, 0x65, 0x73, 0x74, 0x30};
-  for (uint16 i = 0; i < 5; ++i) {
+  uint8_t ip_bytes[] = {0x54, 0x65, 0x73, 0x74, 0x30};
+  for (uint16_t i = 0; i < 5; ++i) {
     variant_array_writer.OpenStruct(&struct_entry_writer);
     ip_bytes[4] = 0x30 + i;
     struct_entry_writer.AppendArrayOfBytes(ip_bytes, arraysize(ip_bytes));
     struct_entry_writer.AppendUint16(i);
     variant_array_writer.CloseContainer(&struct_entry_writer);
   }
   variant_writer.CloseContainer(&variant_array_writer);
   writer.CloseContainer(&variant_writer);
 
   MessageReader reader(message.get());
-  Property<std::vector<std::pair<std::vector<uint8>, uint16>>> ip_list;
+  Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>> ip_list;
   EXPECT_TRUE(ip_list.PopValueFromReader(&reader));
 
   ASSERT_EQ(5U, ip_list.value().size());
   size_t item_index = 0;
   for (auto& item : ip_list.value()) {
     ASSERT_EQ(5U, item.first.size());
     ip_bytes[4] = 0x30 + item_index;
     EXPECT_EQ(0, memcmp(ip_bytes, item.first.data(), 5U));
     EXPECT_EQ(item_index, item.second);
     ++item_index;
   }
 }
 
 TEST(PropertyTestStatic, SerializeNetAddressArray) {
-  std::vector<std::pair<std::vector<uint8>, uint16>> test_list;
+  std::vector<std::pair<std::vector<uint8_t>, uint16_t>> test_list;
 
-  uint8 ip_bytes[] = {0x54, 0x65, 0x73, 0x74, 0x30};
-  for (uint16 i = 0; i < 5; ++i) {
+  uint8_t ip_bytes[] = {0x54, 0x65, 0x73, 0x74, 0x30};
+  for (uint16_t i = 0; i < 5; ++i) {
     ip_bytes[4] = 0x30 + i;
-    std::vector<uint8> bytes(ip_bytes, ip_bytes + arraysize(ip_bytes));
+    std::vector<uint8_t> bytes(ip_bytes, ip_bytes + arraysize(ip_bytes));
     test_list.push_back(make_pair(bytes, 16));
   }
 
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
 
-  Property<std::vector<std::pair<std::vector<uint8>, uint16>>> ip_list;
+  Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>> ip_list;
   ip_list.ReplaceSetValueForTesting(test_list);
   ip_list.AppendSetValueToWriter(&writer);
 
   MessageReader reader(message.get());
   EXPECT_TRUE(ip_list.PopValueFromReader(&reader));
   EXPECT_EQ(test_list, ip_list.value());
 }
 
 }  // namespace dbus