diff --git a/dbus/bus.cc b/dbus/bus.cc
index 3a4fe21..554ccb8 100644
--- a/dbus/bus.cc
+++ b/dbus/bus.cc
@@ -4,6 +4,8 @@
 
 #include "dbus/bus.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ -678,7 +680,7 @@
   CHECK(success) << "Unable to allocate memory";
 }
 
-void Bus::Send(DBusMessage* request, uint32* serial) {
+void Bus::Send(DBusMessage* request, uint32_t* serial) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
diff --git a/dbus/bus.h b/dbus/bus.h
index 27d149c..e5e0b1c 100644
--- a/dbus/bus.h
+++ b/dbus/bus.h
@@ -6,6 +6,7 @@
 #define DBUS_BUS_H_
 
 #include <dbus/dbus.h>
+#include <stdint.h>
 
 #include <map>
 #include <set>
@@ -14,6 +15,7 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
@@ -462,7 +464,7 @@
   // be stored in |serial|.
   //
   // BLOCKING CALL.
-  virtual void Send(DBusMessage* request, uint32* serial);
+  virtual void Send(DBusMessage* request, uint32_t* serial);
 
   // Adds the message filter function. |filter_function| will be called
   // when incoming messages are received.
diff --git a/dbus/bus_unittest.cc b/dbus/bus_unittest.cc
index 27d9bb2..250717e 100644
--- a/dbus/bus_unittest.cc
+++ b/dbus/bus_unittest.cc
@@ -5,6 +5,7 @@
 #include "dbus/bus.h"
 
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
diff --git a/dbus/dbus_statistics.cc b/dbus/dbus_statistics.cc
index 9abec65..e6eb5a2 100644
--- a/dbus/dbus_statistics.cc
+++ b/dbus/dbus_statistics.cc
@@ -7,6 +7,7 @@
 #include <set>
 
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
diff --git a/dbus/dbus_statistics_unittest.cc b/dbus/dbus_statistics_unittest.cc
index 6260a63..e39b9b5 100644
--- a/dbus/dbus_statistics_unittest.cc
+++ b/dbus/dbus_statistics_unittest.cc
@@ -4,8 +4,8 @@
 
 #include "dbus/dbus_statistics.h"
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace dbus {
diff --git a/dbus/end_to_end_async_unittest.cc b/dbus/end_to_end_async_unittest.cc
index 3854721..121c660 100644
--- a/dbus/end_to_end_async_unittest.cc
+++ b/dbus/end_to_end_async_unittest.cc
@@ -2,11 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
diff --git a/dbus/exported_object.cc b/dbus/exported_object.cc
index 669b871..3054c35 100644
--- a/dbus/exported_object.cc
+++ b/dbus/exported_object.cc
@@ -4,6 +4,8 @@
 
 #include "dbus/exported_object.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ -148,7 +150,7 @@
 
 void ExportedObject::SendSignalInternal(base::TimeTicks start_time,
                                         DBusMessage* signal_message) {
-  uint32 serial = 0;
+  uint32_t serial = 0;
   bus_->Send(signal_message, &serial);
   dbus_message_unref(signal_message);
   // Record time spent to send the the signal. This is not accurate as the
diff --git a/dbus/file_descriptor.h b/dbus/file_descriptor.h
index 41f7b4e..b4f95cb 100644
--- a/dbus/file_descriptor.h
+++ b/dbus/file_descriptor.h
@@ -5,7 +5,6 @@
 #ifndef DBUS_FILE_DESCRIPTOR_H_
 #define DBUS_FILE_DESCRIPTOR_H_
 
-#include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/move.h"
 #include "dbus/dbus_export.h"
diff --git a/dbus/message.cc b/dbus/message.cc
index 0bf76d4..2de3861 100644
--- a/dbus/message.cc
+++ b/dbus/message.cc
@@ -6,7 +6,6 @@
 
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
@@ -36,7 +35,7 @@
 // Appends the header name and the value to |output|, if the value is
 // nonzero.
 void AppendUint32Header(const std::string& header_name,
-                        uint32 header_value,
+                        uint32_t header_value,
                         std::string* output) {
   if (header_value != 0) {
     *output += (header_name + ": " + base::UintToString(header_value) + "\n");
@@ -99,7 +98,7 @@
     const DataType type = reader->GetDataType();
     switch (type) {
       case BYTE: {
-        uint8 value = 0;
+        uint8_t value = 0;
         if (!reader->PopByte(&value))
           return kBrokenMessage;
         output += indent + "byte " + base::UintToString(value) + "\n";
@@ -113,45 +112,45 @@
         break;
       }
       case INT16: {
-        int16 value = 0;
+        int16_t value = 0;
         if (!reader->PopInt16(&value))
           return kBrokenMessage;
-        output += indent + "int16 " + base::IntToString(value) + "\n";
+        output += indent + "int16_t " + base::IntToString(value) + "\n";
         break;
       }
       case UINT16: {
-        uint16 value = 0;
+        uint16_t value = 0;
         if (!reader->PopUint16(&value))
           return kBrokenMessage;
-        output += indent + "uint16 " + base::UintToString(value) + "\n";
+        output += indent + "uint16_t " + base::UintToString(value) + "\n";
         break;
       }
       case INT32: {
-        int32 value = 0;
+        int32_t value = 0;
         if (!reader->PopInt32(&value))
           return kBrokenMessage;
-        output += indent + "int32 " + base::IntToString(value) + "\n";
+        output += indent + "int32_t " + base::IntToString(value) + "\n";
         break;
       }
       case UINT32: {
-        uint32 value = 0;
+        uint32_t value = 0;
         if (!reader->PopUint32(&value))
           return kBrokenMessage;
-        output += indent + "uint32 " + base::UintToString(value) + "\n";
+        output += indent + "uint32_t " + base::UintToString(value) + "\n";
         break;
       }
       case INT64: {
-        int64 value = 0;
+        int64_t value = 0;
         if (!reader->PopInt64(&value))
           return kBrokenMessage;
-        output += (indent + "int64 " + base::Int64ToString(value) + "\n");
+        output += (indent + "int64_t " + base::Int64ToString(value) + "\n");
         break;
       }
       case UINT64: {
-        uint64 value = 0;
+        uint64_t value = 0;
         if (!reader->PopUint64(&value))
           return kBrokenMessage;
-        output += (indent + "uint64 " + base::Uint64ToString(value) + "\n");
+        output += (indent + "uint64_t " + base::Uint64ToString(value) + "\n");
         break;
       }
       case DOUBLE: {
@@ -294,11 +293,11 @@
   return dbus_message_set_sender(raw_message_, sender.c_str());
 }
 
-void Message::SetSerial(uint32 serial) {
+void Message::SetSerial(uint32_t serial) {
   dbus_message_set_serial(raw_message_, serial);
 }
 
-void Message::SetReplySerial(uint32 reply_serial) {
+void Message::SetReplySerial(uint32_t reply_serial) {
   dbus_message_set_reply_serial(raw_message_, reply_serial);
 }
 
@@ -337,11 +336,11 @@
   return signature ? signature : "";
 }
 
-uint32 Message::GetSerial() {
+uint32_t Message::GetSerial() {
   return dbus_message_get_serial(raw_message_);
 }
 
-uint32 Message::GetReplySerial() {
+uint32_t Message::GetReplySerial() {
   return dbus_message_get_reply_serial(raw_message_);
 }
 
@@ -462,7 +461,7 @@
 MessageWriter::~MessageWriter() {
 }
 
-void MessageWriter::AppendByte(uint8 value) {
+void MessageWriter::AppendByte(uint8_t value) {
   AppendBasic(DBUS_TYPE_BYTE, &value);
 }
 
@@ -476,27 +475,27 @@
   AppendBasic(DBUS_TYPE_BOOLEAN, &dbus_value);
 }
 
-void MessageWriter::AppendInt16(int16 value) {
+void MessageWriter::AppendInt16(int16_t value) {
   AppendBasic(DBUS_TYPE_INT16, &value);
 }
 
-void MessageWriter::AppendUint16(uint16 value) {
+void MessageWriter::AppendUint16(uint16_t value) {
   AppendBasic(DBUS_TYPE_UINT16, &value);
 }
 
-void MessageWriter::AppendInt32(int32 value) {
+void MessageWriter::AppendInt32(int32_t value) {
   AppendBasic(DBUS_TYPE_INT32, &value);
 }
 
-void MessageWriter::AppendUint32(uint32 value) {
+void MessageWriter::AppendUint32(uint32_t value) {
   AppendBasic(DBUS_TYPE_UINT32, &value);
 }
 
-void MessageWriter::AppendInt64(int64 value) {
+void MessageWriter::AppendInt64(int64_t value) {
   AppendBasic(DBUS_TYPE_INT64, &value);
 }
 
-void MessageWriter::AppendUint64(uint64 value) {
+void MessageWriter::AppendUint64(uint64_t value) {
   AppendBasic(DBUS_TYPE_UINT64, &value);
 }
 
@@ -587,7 +586,7 @@
   container_is_open_ = false;
 }
 
-void MessageWriter::AppendArrayOfBytes(const uint8* values, size_t length) {
+void MessageWriter::AppendArrayOfBytes(const uint8_t* values, size_t length) {
   DCHECK(!container_is_open_);
   MessageWriter array_writer(message_);
   OpenArray("y", &array_writer);
@@ -629,12 +628,12 @@
     LOG(ERROR) << "Unable to serialize supplied protocol buffer";
     return false;
   }
-  AppendArrayOfBytes(reinterpret_cast<const uint8*>(serialized_proto.data()),
+  AppendArrayOfBytes(reinterpret_cast<const uint8_t*>(serialized_proto.data()),
                      serialized_proto.size());
   return true;
 }
 
-void MessageWriter::AppendVariantOfByte(uint8 value) {
+void MessageWriter::AppendVariantOfByte(uint8_t value) {
   AppendVariantOfBasic(DBUS_TYPE_BYTE, &value);
 }
 
@@ -644,27 +643,27 @@
   AppendVariantOfBasic(DBUS_TYPE_BOOLEAN, &dbus_value);
 }
 
-void MessageWriter::AppendVariantOfInt16(int16 value) {
+void MessageWriter::AppendVariantOfInt16(int16_t value) {
   AppendVariantOfBasic(DBUS_TYPE_INT16, &value);
 }
 
-void MessageWriter::AppendVariantOfUint16(uint16 value) {
+void MessageWriter::AppendVariantOfUint16(uint16_t value) {
   AppendVariantOfBasic(DBUS_TYPE_UINT16, &value);
 }
 
-void MessageWriter::AppendVariantOfInt32(int32 value) {
+void MessageWriter::AppendVariantOfInt32(int32_t value) {
   AppendVariantOfBasic(DBUS_TYPE_INT32, &value);
 }
 
-void MessageWriter::AppendVariantOfUint32(uint32 value) {
+void MessageWriter::AppendVariantOfUint32(uint32_t value) {
   AppendVariantOfBasic(DBUS_TYPE_UINT32, &value);
 }
 
-void MessageWriter::AppendVariantOfInt64(int64 value) {
+void MessageWriter::AppendVariantOfInt64(int64_t value) {
   AppendVariantOfBasic(DBUS_TYPE_INT64, &value);
 }
 
-void MessageWriter::AppendVariantOfUint64(uint64 value) {
+void MessageWriter::AppendVariantOfUint64(uint64_t value) {
   AppendVariantOfBasic(DBUS_TYPE_UINT64, &value);
 }
 
@@ -733,7 +732,7 @@
   return dbus_type != DBUS_TYPE_INVALID;
 }
 
-bool MessageReader::PopByte(uint8* value) {
+bool MessageReader::PopByte(uint8_t* value) {
   return PopBasic(DBUS_TYPE_BYTE, value);
 }
 
@@ -747,27 +746,27 @@
   return success;
 }
 
-bool MessageReader::PopInt16(int16* value) {
+bool MessageReader::PopInt16(int16_t* value) {
   return PopBasic(DBUS_TYPE_INT16, value);
 }
 
-bool MessageReader::PopUint16(uint16* value) {
+bool MessageReader::PopUint16(uint16_t* value) {
   return PopBasic(DBUS_TYPE_UINT16, value);
 }
 
-bool MessageReader::PopInt32(int32* value) {
+bool MessageReader::PopInt32(int32_t* value) {
   return PopBasic(DBUS_TYPE_INT32, value);
 }
 
-bool MessageReader::PopUint32(uint32* value) {
+bool MessageReader::PopUint32(uint32_t* value) {
   return PopBasic(DBUS_TYPE_UINT32, value);
 }
 
-bool MessageReader::PopInt64(int64* value) {
+bool MessageReader::PopInt64(int64_t* value) {
   return PopBasic(DBUS_TYPE_INT64, value);
 }
 
-bool MessageReader::PopUint64(uint64* value) {
+bool MessageReader::PopUint64(uint64_t* value) {
   return PopBasic(DBUS_TYPE_UINT64, value);
 }
 
@@ -807,7 +806,7 @@
   return PopContainer(DBUS_TYPE_VARIANT, sub_reader);
 }
 
-bool MessageReader::PopArrayOfBytes(const uint8** bytes, size_t* length) {
+bool MessageReader::PopArrayOfBytes(const uint8_t** bytes, size_t* length) {
   MessageReader array_reader(message_);
   if (!PopArray(&array_reader))
       return false;
@@ -862,8 +861,8 @@
   DCHECK(protobuf != NULL);
   const char* serialized_buf = NULL;
   size_t buf_size = 0;
-  if (!PopArrayOfBytes(
-          reinterpret_cast<const uint8**>(&serialized_buf), &buf_size)) {
+  if (!PopArrayOfBytes(reinterpret_cast<const uint8_t**>(&serialized_buf),
+                       &buf_size)) {
     LOG(ERROR) << "Error reading array of bytes";
     return false;
   }
@@ -874,7 +873,7 @@
   return true;
 }
 
-bool MessageReader::PopVariantOfByte(uint8* value) {
+bool MessageReader::PopVariantOfByte(uint8_t* value) {
   return PopVariantOfBasic(DBUS_TYPE_BYTE, value);
 }
 
@@ -886,27 +885,27 @@
   return success;
 }
 
-bool MessageReader::PopVariantOfInt16(int16* value) {
+bool MessageReader::PopVariantOfInt16(int16_t* value) {
   return PopVariantOfBasic(DBUS_TYPE_INT16, value);
 }
 
-bool MessageReader::PopVariantOfUint16(uint16* value) {
+bool MessageReader::PopVariantOfUint16(uint16_t* value) {
   return PopVariantOfBasic(DBUS_TYPE_UINT16, value);
 }
 
-bool MessageReader::PopVariantOfInt32(int32* value) {
+bool MessageReader::PopVariantOfInt32(int32_t* value) {
   return PopVariantOfBasic(DBUS_TYPE_INT32, value);
 }
 
-bool MessageReader::PopVariantOfUint32(uint32* value) {
+bool MessageReader::PopVariantOfUint32(uint32_t* value) {
   return PopVariantOfBasic(DBUS_TYPE_UINT32, value);
 }
 
-bool MessageReader::PopVariantOfInt64(int64* value) {
+bool MessageReader::PopVariantOfInt64(int64_t* value) {
   return PopVariantOfBasic(DBUS_TYPE_INT64, value);
 }
 
-bool MessageReader::PopVariantOfUint64(uint64* value) {
+bool MessageReader::PopVariantOfUint64(uint64_t* value) {
   return PopVariantOfBasic(DBUS_TYPE_UINT64, value);
 }
 
diff --git a/dbus/message.h b/dbus/message.h
index 780e6c5..7dffe0e 100644
--- a/dbus/message.h
+++ b/dbus/message.h
@@ -5,11 +5,13 @@
 #ifndef DBUS_MESSAGE_H_
 #define DBUS_MESSAGE_H_
 
+#include <dbus/dbus.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <string>
 #include <vector>
-#include <dbus/dbus.h>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "dbus/dbus_export.h"
 #include "dbus/file_descriptor.h"
@@ -99,8 +101,8 @@
   bool SetMember(const std::string& member);
   bool SetErrorName(const std::string& error_name);
   bool SetSender(const std::string& sender);
-  void SetSerial(uint32 serial);
-  void SetReplySerial(uint32 reply_serial);
+  void SetSerial(uint32_t serial);
+  void SetReplySerial(uint32_t reply_serial);
   // SetSignature() does not exist as we cannot do it.
 
   // Gets the destination, the path, the interface, the member, etc.
@@ -113,8 +115,8 @@
   std::string GetSender();
   std::string GetSignature();
   // Gets the serial and reply serial numbers. Returns 0 if not set.
-  uint32 GetSerial();
-  uint32 GetReplySerial();
+  uint32_t GetSerial();
+  uint32_t GetReplySerial();
 
   // Returns the string representation of this message. Useful for
   // debugging. The output is truncated as needed (ex. strings are truncated
@@ -270,14 +272,14 @@
   ~MessageWriter();
 
   // Appends a byte to the message.
-  void AppendByte(uint8 value);
+  void AppendByte(uint8_t value);
   void AppendBool(bool value);
-  void AppendInt16(int16 value);
-  void AppendUint16(uint16 value);
-  void AppendInt32(int32 value);
-  void AppendUint32(uint32 value);
-  void AppendInt64(int64 value);
-  void AppendUint64(uint64 value);
+  void AppendInt16(int16_t value);
+  void AppendUint16(uint16_t value);
+  void AppendInt32(int32_t value);
+  void AppendUint32(uint32_t value);
+  void AppendInt64(int64_t value);
+  void AppendUint64(uint64_t value);
   void AppendDouble(double value);
   void AppendString(const std::string& value);
   void AppendObjectPath(const ObjectPath& value);
@@ -308,7 +310,7 @@
   // Appends the array of bytes. Arrays of bytes are often used for
   // exchanging binary blobs hence it's worth having a specialized
   // function.
-  void AppendArrayOfBytes(const uint8* values, size_t length);
+  void AppendArrayOfBytes(const uint8_t* values, size_t length);
 
   // Appends the array of strings. Arrays of strings are often used for
   // exchanging lists of names hence it's worth having a specialized
@@ -332,14 +334,14 @@
   // widely used in D-Bus services so it's worth having a specialized
   // function. For instance, The third parameter of
   // "org.freedesktop.DBus.Properties.Set" is a variant.
-  void AppendVariantOfByte(uint8 value);
+  void AppendVariantOfByte(uint8_t value);
   void AppendVariantOfBool(bool value);
-  void AppendVariantOfInt16(int16 value);
-  void AppendVariantOfUint16(uint16 value);
-  void AppendVariantOfInt32(int32 value);
-  void AppendVariantOfUint32(uint32 value);
-  void AppendVariantOfInt64(int64 value);
-  void AppendVariantOfUint64(uint64 value);
+  void AppendVariantOfInt16(int16_t value);
+  void AppendVariantOfUint16(uint16_t value);
+  void AppendVariantOfInt32(int32_t value);
+  void AppendVariantOfUint32(uint32_t value);
+  void AppendVariantOfInt64(int64_t value);
+  void AppendVariantOfUint64(uint64_t value);
   void AppendVariantOfDouble(double value);
   void AppendVariantOfString(const std::string& value);
   void AppendVariantOfObjectPath(const ObjectPath& value);
@@ -380,14 +382,14 @@
   // Gets the byte at the current iterator position.
   // Returns true and advances the iterator on success.
   // Returns false if the data type is not a byte.
-  bool PopByte(uint8* value);
+  bool PopByte(uint8_t* value);
   bool PopBool(bool* value);
-  bool PopInt16(int16* value);
-  bool PopUint16(uint16* value);
-  bool PopInt32(int32* value);
-  bool PopUint32(uint32* value);
-  bool PopInt64(int64* value);
-  bool PopUint64(uint64* value);
+  bool PopInt16(int16_t* value);
+  bool PopUint16(uint16_t* value);
+  bool PopInt32(int32_t* value);
+  bool PopUint32(uint32_t* value);
+  bool PopInt64(int64_t* value);
+  bool PopUint64(uint64_t* value);
   bool PopDouble(double* value);
   bool PopString(std::string* value);
   bool PopObjectPath(ObjectPath* value);
@@ -411,7 +413,7 @@
   // Ownership of the memory pointed to by |bytes| remains with the
   // MessageReader; |bytes| must be copied if the contents will be referenced
   // after the MessageReader is destroyed.
-  bool PopArrayOfBytes(const uint8** bytes, size_t* length);
+  bool PopArrayOfBytes(const uint8_t** bytes, size_t* length);
 
   // Gets the array of strings at the current iterator position. |strings| is
   // cleared before being modified. Returns true and advances the iterator on
@@ -446,14 +448,14 @@
   // Variants are widely used in D-Bus services so it's worth having a
   // specialized function. For instance, The return value type of
   // "org.freedesktop.DBus.Properties.Get" is a variant.
-  bool PopVariantOfByte(uint8* value);
+  bool PopVariantOfByte(uint8_t* value);
   bool PopVariantOfBool(bool* value);
-  bool PopVariantOfInt16(int16* value);
-  bool PopVariantOfUint16(uint16* value);
-  bool PopVariantOfInt32(int32* value);
-  bool PopVariantOfUint32(uint32* value);
-  bool PopVariantOfInt64(int64* value);
-  bool PopVariantOfUint64(uint64* value);
+  bool PopVariantOfInt16(int16_t* value);
+  bool PopVariantOfUint16(uint16_t* value);
+  bool PopVariantOfInt32(int32_t* value);
+  bool PopVariantOfUint32(uint32_t* value);
+  bool PopVariantOfInt64(int64_t* value);
+  bool PopVariantOfUint64(uint64_t* value);
   bool PopVariantOfDouble(double* value);
   bool PopVariantOfString(std::string* value);
   bool PopVariantOfObjectPath(ObjectPath* value);
diff --git a/dbus/message_unittest.cc b/dbus/message_unittest.cc
index 2c13d08..efe5400 100644
--- a/dbus/message_unittest.cc
+++ b/dbus/message_unittest.cc
@@ -4,9 +4,9 @@
 
 #include "dbus/message.h"
 
+#include <stddef.h>
 #include <stdint.h>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
@@ -32,7 +32,7 @@
   // Should fail as the type is not bool here.
   ASSERT_FALSE(reader.PopBool(&bool_value));
 
-  uint8 byte_value = 0;
+  uint8_t byte_value = 0;
   ASSERT_TRUE(reader.PopByte(&byte_value));
   EXPECT_EQ(123, byte_value);  // Should match with the input.
   ASSERT_FALSE(reader.HasMoreData());  // Should not have more data to read.
@@ -59,14 +59,14 @@
   writer.AppendString("string");
   writer.AppendObjectPath(ObjectPath("/object/path"));
 
-  uint8 byte_value = 0;
+  uint8_t byte_value = 0;
   bool bool_value = false;
-  int16 int16_value = 0;
-  uint16 uint16_value = 0;
-  int32 int32_value = 0;
-  uint32 uint32_value = 0;
-  int64 int64_value = 0;
-  uint64 uint64_value = 0;
+  int16_t int16_value = 0;
+  uint16_t uint16_value = 0;
+  int32_t int32_value = 0;
+  uint32_t uint32_value = 0;
+  int64_t int64_value = 0;
+  uint64_t uint64_value = 0;
   double double_value = 0;
   std::string string_value;
   ObjectPath object_path_value;
@@ -174,14 +174,14 @@
   writer.AppendVariantOfString("string");
   writer.AppendVariantOfObjectPath(ObjectPath("/object/path"));
 
-  uint8 byte_value = 0;
+  uint8_t byte_value = 0;
   bool bool_value = false;
-  int16 int16_value = 0;
-  uint16 uint16_value = 0;
-  int32 int32_value = 0;
-  uint32 uint32_value = 0;
-  int64 int64_value = 0;
-  uint64 uint64_value = 0;
+  int16_t int16_value = 0;
+  uint16_t uint16_value = 0;
+  int32_t int32_value = 0;
+  uint32_t uint32_value = 0;
+  int64_t int64_value = 0;
+  uint64_t uint64_value = 0;
   double double_value = 0;
   std::string string_value;
   ObjectPath object_path_value;
@@ -230,14 +230,14 @@
 TEST(MessageTest, ArrayOfBytes) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
-  std::vector<uint8> bytes;
+  std::vector<uint8_t> bytes;
   bytes.push_back(1);
   bytes.push_back(2);
   bytes.push_back(3);
   writer.AppendArrayOfBytes(bytes.data(), bytes.size());
 
   MessageReader reader(message.get());
-  const uint8* output_bytes = NULL;
+  const uint8_t* output_bytes = NULL;
   size_t length = 0;
   ASSERT_EQ("ay", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
@@ -251,11 +251,11 @@
 TEST(MessageTest, ArrayOfBytes_Empty) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
-  std::vector<uint8> bytes;
+  std::vector<uint8_t> bytes;
   writer.AppendArrayOfBytes(bytes.data(), bytes.size());
 
   MessageReader reader(message.get());
-  const uint8* output_bytes = NULL;
+  const uint8_t* output_bytes = NULL;
   size_t length = 0;
   ASSERT_EQ("ay", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
@@ -376,7 +376,7 @@
       // The second value in the array.
       {
         MessageWriter variant_writer(NULL);
-        // Open a variant of a struct that contains a string and an int32.
+        // Open a variant of a struct that contains a string and an int32_t.
         array_writer.OpenVariant("(si)", &variant_writer);
         {
           MessageWriter struct_writer(NULL);
@@ -391,14 +391,14 @@
       // The third value in the array.
       {
         MessageWriter variant_writer(NULL);
-        // Open a variant of an array of string-to-int64 dict entries.
+        // Open a variant of an array of string-to-int64_t dict entries.
         array_writer.OpenVariant("a{sx}", &variant_writer);
         {
-          // Opens an array of string-to-int64 dict entries.
+          // Opens an array of string-to-int64_t dict entries.
           MessageWriter dict_array_writer(NULL);
           variant_writer.OpenArray("{sx}", &dict_array_writer);
           {
-            // Opens a string-to-int64 dict entries.
+            // Opens a string-to-int64_t dict entries.
             MessageWriter dict_entry_writer(NULL);
             dict_array_writer.OpenDictEntry(&dict_entry_writer);
             dict_entry_writer.AppendString("foo");
@@ -413,23 +413,24 @@
     writer.CloseContainer(&array_writer);
   }
   // What we have created looks like this:
-  EXPECT_EQ("message_type: MESSAGE_METHOD_RETURN\n"
-            "signature: av\n"
-            "\n"
-            "array [\n"
-            "  variant     bool true\n"
-            "  variant     struct {\n"
-            "      string \"string\"\n"
-            "      int32 123\n"
-            "    }\n"
-            "  variant     array [\n"
-            "      dict entry {\n"
-            "        string \"foo\"\n"
-            "        int64 1234567890123456789\n"
-            "      }\n"
-            "    ]\n"
-            "]\n",
-            message->ToString());
+  EXPECT_EQ(
+      "message_type: MESSAGE_METHOD_RETURN\n"
+      "signature: av\n"
+      "\n"
+      "array [\n"
+      "  variant     bool true\n"
+      "  variant     struct {\n"
+      "      string \"string\"\n"
+      "      int32_t 123\n"
+      "    }\n"
+      "  variant     array [\n"
+      "      dict entry {\n"
+      "        string \"foo\"\n"
+      "        int64_t 1234567890123456789\n"
+      "      }\n"
+      "    ]\n"
+      "]\n",
+      message->ToString());
 
   MessageReader reader(message.get());
   ASSERT_EQ("av", reader.GetDataSignature());
@@ -453,7 +454,7 @@
       std::string string_value;
       ASSERT_TRUE(struct_reader.PopString(&string_value));
       EXPECT_EQ("string", string_value);
-      int32 int32_value = 0;
+      int32_t int32_value = 0;
       ASSERT_TRUE(struct_reader.PopInt32(&int32_value));
       EXPECT_EQ(123, int32_value);
       ASSERT_FALSE(struct_reader.HasMoreData());
@@ -475,7 +476,7 @@
         std::string string_value;
         ASSERT_TRUE(dict_entry_reader.PopString(&string_value));
         EXPECT_EQ("foo", string_value);
-        int64 int64_value = 0;
+        int64_t int64_value = 0;
         ASSERT_TRUE(dict_entry_reader.PopInt64(&int64_value));
         EXPECT_EQ(INT64_C(1234567890123456789), int64_value);
       }
@@ -557,7 +558,7 @@
 }
 
 TEST(MessageTest, Response_FromMethodCall) {
-  const uint32 kSerial = 123;
+  const uint32_t kSerial = 123;
   MethodCall method_call("com.example.Interface", "SomeMethod");
   method_call.SetSerial(kSerial);
 
@@ -570,7 +571,7 @@
 }
 
 TEST(MessageTest, ErrorResponse_FromMethodCall) {
-  const uint32 kSerial = 123;
+  const uint32_t kSerial = 123;
 const char kErrorMessage[] = "error message";
 
   MethodCall method_call("com.example.Interface", "SomeMethod");
diff --git a/dbus/mock_bus.h b/dbus/mock_bus.h
index 6000067..40b090b 100644
--- a/dbus/mock_bus.h
+++ b/dbus/mock_bus.h
@@ -5,6 +5,8 @@
 #ifndef DBUS_MOCK_BUS_H_
 #define DBUS_MOCK_BUS_H_
 
+#include <stdint.h>
+
 #include "dbus/bus.h"
 #include "dbus/object_path.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -45,8 +47,7 @@
   MOCK_METHOD3(SendWithReply, void(DBusMessage* request,
                                    DBusPendingCall** pending_call,
                                    int timeout_ms));
-  MOCK_METHOD2(Send, void(DBusMessage* request,
-                          uint32* serial));
+  MOCK_METHOD2(Send, void(DBusMessage* request, uint32_t* serial));
   MOCK_METHOD2(AddFilter, void(DBusHandleMessageFunction handle_message,
                                void* user_data));
   MOCK_METHOD2(RemoveFilter, void(DBusHandleMessageFunction handle_message,
diff --git a/dbus/object_manager.cc b/dbus/object_manager.cc
index 3f253fa..9215d84 100644
--- a/dbus/object_manager.cc
+++ b/dbus/object_manager.cc
@@ -4,6 +4,8 @@
 
 #include "dbus/object_manager.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
diff --git a/dbus/object_manager.h b/dbus/object_manager.h
index 23a88cd..266b53e 100644
--- a/dbus/object_manager.h
+++ b/dbus/object_manager.h
@@ -5,8 +5,11 @@
 #ifndef DBUS_OBJECT_MANAGER_H_
 #define DBUS_OBJECT_MANAGER_H_
 
+#include <stdint.h>
+
 #include <map>
 
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "dbus/object_path.h"
@@ -36,7 +39,7 @@
 //    public:
 //     struct Properties : public dbus::PropertySet {
 //       dbus::Property<std::string> name;
-//       dbus::Property<uint16> version;
+//       dbus::Property<uint16_t> version;
 //       dbus::Property<dbus::ObjectPath> parent;
 //       dbus::Property<std::vector<std::string> > children;
 //
diff --git a/dbus/object_manager_unittest.cc b/dbus/object_manager_unittest.cc
index 34f7ac4..fa83034 100644
--- a/dbus/object_manager_unittest.cc
+++ b/dbus/object_manager_unittest.cc
@@ -4,10 +4,12 @@
 
 #include "dbus/object_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ -33,7 +35,7 @@
 
   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;
 
diff --git a/dbus/object_proxy.cc b/dbus/object_proxy.cc
index 441dc75..fc7d199 100644
--- a/dbus/object_proxy.cc
+++ b/dbus/object_proxy.cc
@@ -4,6 +4,8 @@
 
 #include "dbus/bus.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
diff --git a/dbus/object_proxy.h b/dbus/object_proxy.h
index 9f32821..edb97a5 100644
--- a/dbus/object_proxy.h
+++ b/dbus/object_proxy.h
@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
diff --git a/dbus/property.cc b/dbus/property.cc
index 234036c..66af866 100644
--- a/dbus/property.cc
+++ b/dbus/property.cc
@@ -4,7 +4,8 @@
 
 #include "dbus/property.h"
 
-#include "base/basictypes.h"
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/logging.h"
 
@@ -302,16 +303,16 @@
 //
 
 template <>
-Property<uint8>::Property() : value_(0) {
-}
+Property<uint8_t>::Property()
+    : value_(0) {}
 
 template <>
-bool Property<uint8>::PopValueFromReader(MessageReader* reader) {
+bool Property<uint8_t>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfByte(&value_);
 }
 
 template <>
-void Property<uint8>::AppendSetValueToWriter(MessageWriter* writer) {
+void Property<uint8_t>::AppendSetValueToWriter(MessageWriter* writer) {
   writer->AppendVariantOfByte(set_value_);
 }
 
@@ -334,110 +335,110 @@
 }
 
 //
-// Property<int16> specialization.
+// Property<int16_t> specialization.
 //
 
 template <>
-Property<int16>::Property() : value_(0) {
-}
+Property<int16_t>::Property()
+    : value_(0) {}
 
 template <>
-bool Property<int16>::PopValueFromReader(MessageReader* reader) {
+bool Property<int16_t>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfInt16(&value_);
 }
 
 template <>
-void Property<int16>::AppendSetValueToWriter(MessageWriter* writer) {
+void Property<int16_t>::AppendSetValueToWriter(MessageWriter* writer) {
   writer->AppendVariantOfInt16(set_value_);
 }
 
 //
-// Property<uint16> specialization.
+// Property<uint16_t> specialization.
 //
 
 template <>
-Property<uint16>::Property() : value_(0) {
-}
+Property<uint16_t>::Property()
+    : value_(0) {}
 
 template <>
-bool Property<uint16>::PopValueFromReader(MessageReader* reader) {
+bool Property<uint16_t>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfUint16(&value_);
 }
 
 template <>
-void Property<uint16>::AppendSetValueToWriter(MessageWriter* writer) {
+void Property<uint16_t>::AppendSetValueToWriter(MessageWriter* writer) {
   writer->AppendVariantOfUint16(set_value_);
 }
 
 //
-// Property<int32> specialization.
+// Property<int32_t> specialization.
 //
 
 template <>
-Property<int32>::Property() : value_(0) {
-}
+Property<int32_t>::Property()
+    : value_(0) {}
 
 template <>
-bool Property<int32>::PopValueFromReader(MessageReader* reader) {
+bool Property<int32_t>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfInt32(&value_);
 }
 
 template <>
-void Property<int32>::AppendSetValueToWriter(MessageWriter* writer) {
+void Property<int32_t>::AppendSetValueToWriter(MessageWriter* writer) {
   writer->AppendVariantOfInt32(set_value_);
 }
 
 //
-// Property<uint32> specialization.
+// Property<uint32_t> specialization.
 //
 
 template <>
-Property<uint32>::Property() : value_(0) {
-}
+Property<uint32_t>::Property()
+    : value_(0) {}
 
 template <>
-bool Property<uint32>::PopValueFromReader(MessageReader* reader) {
+bool Property<uint32_t>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfUint32(&value_);
 }
 
 template <>
-void Property<uint32>::AppendSetValueToWriter(MessageWriter* writer) {
+void Property<uint32_t>::AppendSetValueToWriter(MessageWriter* writer) {
   writer->AppendVariantOfUint32(set_value_);
 }
 
 //
-// Property<int64> specialization.
+// Property<int64_t> specialization.
 //
 
 template <>
-Property<int64>::Property() : value_(0), set_value_(0) {
-}
+Property<int64_t>::Property()
+    : value_(0), set_value_(0) {}
 
 template <>
-bool Property<int64>::PopValueFromReader(MessageReader* reader) {
+bool Property<int64_t>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfInt64(&value_);
 }
 
 template <>
-void Property<int64>::AppendSetValueToWriter(MessageWriter* writer) {
+void Property<int64_t>::AppendSetValueToWriter(MessageWriter* writer) {
   writer->AppendVariantOfInt64(set_value_);
 }
 
 //
-// Property<uint64> specialization.
+// Property<uint64_t> specialization.
 //
 
 template <>
-Property<uint64>::Property() : value_(0) {
-}
+Property<uint64_t>::Property()
+    : value_(0) {}
 
 template <>
-bool Property<uint64>::PopValueFromReader(MessageReader* reader) {
+bool Property<uint64_t>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfUint64(&value_);
 }
 
 template <>
-void Property<uint64>::AppendSetValueToWriter(MessageWriter* writer) {
+void Property<uint64_t>::AppendSetValueToWriter(MessageWriter* writer) {
   writer->AppendVariantOfUint64(set_value_);
 }
 
@@ -536,17 +537,17 @@
 }
 
 //
-// Property<std::vector<uint8> > specialization.
+// Property<std::vector<uint8_t> > specialization.
 //
 
 template <>
-bool Property<std::vector<uint8> >::PopValueFromReader(MessageReader* reader) {
+bool Property<std::vector<uint8_t>>::PopValueFromReader(MessageReader* reader) {
   MessageReader variant_reader(NULL);
   if (!reader->PopVariant(&variant_reader))
     return false;
 
   value_.clear();
-  const uint8* bytes = NULL;
+  const uint8_t* bytes = NULL;
   size_t length = 0;
   if (!variant_reader.PopArrayOfBytes(&bytes, &length))
     return false;
@@ -555,7 +556,7 @@
 }
 
 template <>
-void Property<std::vector<uint8> >::AppendSetValueToWriter(
+void Property<std::vector<uint8_t>>::AppendSetValueToWriter(
     MessageWriter* writer) {
   MessageWriter variant_writer(NULL);
   writer->OpenVariant("ay", &variant_writer);
@@ -629,7 +630,7 @@
       return false;
 
     std::pair<std::vector<uint8_t>, uint16_t> entry;
-    const uint8* bytes = NULL;
+    const uint8_t* bytes = NULL;
     size_t length = 0;
     if (!struct_reader.PopArrayOfBytes(&bytes, &length))
       return false;
@@ -660,20 +661,20 @@
   writer->CloseContainer(&variant_writer);
 }
 
-template class Property<uint8>;
+template class Property<uint8_t>;
 template class Property<bool>;
-template class Property<int16>;
-template class Property<uint16>;
-template class Property<int32>;
-template class Property<uint32>;
-template class Property<int64>;
-template class Property<uint64>;
+template class Property<int16_t>;
+template class Property<uint16_t>;
+template class Property<int32_t>;
+template class Property<uint32_t>;
+template class Property<int64_t>;
+template class Property<uint64_t>;
 template class Property<double>;
 template class Property<std::string>;
 template class Property<ObjectPath>;
 template class Property<std::vector<std::string> >;
 template class Property<std::vector<ObjectPath> >;
-template class Property<std::vector<uint8> >;
+template class Property<std::vector<uint8_t>>;
 template class Property<std::map<std::string, std::string>>;
 template class Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>;
 
diff --git a/dbus/property.h b/dbus/property.h
index e379f8a..efbad22 100644
--- a/dbus/property.h
+++ b/dbus/property.h
@@ -5,14 +5,16 @@
 #ifndef DBUS_PROPERTY_H_
 #define DBUS_PROPERTY_H_
 
+#include <stdint.h>
+
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/macros.h"
 #include "dbus/dbus_export.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
@@ -36,7 +38,7 @@
 //    public:
 //     struct Properties : public dbus::PropertySet {
 //       dbus::Property<std::string> name;
-//       dbus::Property<uint16> version;
+//       dbus::Property<uint16_t> version;
 //       dbus::Property<dbus::ObjectPath> parent;
 //       dbus::Property<std::vector<std::string> > children;
 //
@@ -457,14 +459,14 @@
 #pragma GCC diagnostic ignored "-Wattributes"
 
 template <>
-CHROME_DBUS_EXPORT Property<uint8>::Property();
+CHROME_DBUS_EXPORT Property<uint8_t>::Property();
 template <>
-CHROME_DBUS_EXPORT bool Property<uint8>::PopValueFromReader(
+CHROME_DBUS_EXPORT bool Property<uint8_t>::PopValueFromReader(
     MessageReader* reader);
 template <>
-CHROME_DBUS_EXPORT void Property<uint8>::AppendSetValueToWriter(
+CHROME_DBUS_EXPORT void Property<uint8_t>::AppendSetValueToWriter(
     MessageWriter* writer);
-extern template class CHROME_DBUS_EXPORT Property<uint8>;
+extern template class CHROME_DBUS_EXPORT Property<uint8_t>;
 
 template <>
 CHROME_DBUS_EXPORT Property<bool>::Property();
@@ -477,64 +479,64 @@
 extern template class CHROME_DBUS_EXPORT Property<bool>;
 
 template <>
-CHROME_DBUS_EXPORT Property<int16>::Property();
+CHROME_DBUS_EXPORT Property<int16_t>::Property();
 template <>
-CHROME_DBUS_EXPORT bool Property<int16>::PopValueFromReader(
+CHROME_DBUS_EXPORT bool Property<int16_t>::PopValueFromReader(
     MessageReader* reader);
 template <>
-CHROME_DBUS_EXPORT void Property<int16>::AppendSetValueToWriter(
+CHROME_DBUS_EXPORT void Property<int16_t>::AppendSetValueToWriter(
     MessageWriter* writer);
-extern template class CHROME_DBUS_EXPORT Property<int16>;
+extern template class CHROME_DBUS_EXPORT Property<int16_t>;
 
 template <>
-CHROME_DBUS_EXPORT Property<uint16>::Property();
+CHROME_DBUS_EXPORT Property<uint16_t>::Property();
 template <>
-CHROME_DBUS_EXPORT bool Property<uint16>::PopValueFromReader(
+CHROME_DBUS_EXPORT bool Property<uint16_t>::PopValueFromReader(
     MessageReader* reader);
 template <>
-CHROME_DBUS_EXPORT void Property<uint16>::AppendSetValueToWriter(
+CHROME_DBUS_EXPORT void Property<uint16_t>::AppendSetValueToWriter(
     MessageWriter* writer);
-extern template class CHROME_DBUS_EXPORT Property<uint16>;
+extern template class CHROME_DBUS_EXPORT Property<uint16_t>;
 
 template <>
-CHROME_DBUS_EXPORT Property<int32>::Property();
+CHROME_DBUS_EXPORT Property<int32_t>::Property();
 template <>
-CHROME_DBUS_EXPORT bool Property<int32>::PopValueFromReader(
+CHROME_DBUS_EXPORT bool Property<int32_t>::PopValueFromReader(
     MessageReader* reader);
 template <>
-CHROME_DBUS_EXPORT void Property<int32>::AppendSetValueToWriter(
+CHROME_DBUS_EXPORT void Property<int32_t>::AppendSetValueToWriter(
     MessageWriter* writer);
-extern template class CHROME_DBUS_EXPORT Property<int32>;
+extern template class CHROME_DBUS_EXPORT Property<int32_t>;
 
 template <>
-CHROME_DBUS_EXPORT Property<uint32>::Property();
+CHROME_DBUS_EXPORT Property<uint32_t>::Property();
 template <>
-CHROME_DBUS_EXPORT bool Property<uint32>::PopValueFromReader(
+CHROME_DBUS_EXPORT bool Property<uint32_t>::PopValueFromReader(
     MessageReader* reader);
 template <>
-CHROME_DBUS_EXPORT void Property<uint32>::AppendSetValueToWriter(
+CHROME_DBUS_EXPORT void Property<uint32_t>::AppendSetValueToWriter(
     MessageWriter* writer);
-extern template class CHROME_DBUS_EXPORT Property<uint32>;
+extern template class CHROME_DBUS_EXPORT Property<uint32_t>;
 
 template <>
-CHROME_DBUS_EXPORT Property<int64>::Property();
+CHROME_DBUS_EXPORT Property<int64_t>::Property();
 template <>
-CHROME_DBUS_EXPORT bool Property<int64>::PopValueFromReader(
+CHROME_DBUS_EXPORT bool Property<int64_t>::PopValueFromReader(
     MessageReader* reader);
 template <>
-CHROME_DBUS_EXPORT void Property<int64>::AppendSetValueToWriter(
+CHROME_DBUS_EXPORT void Property<int64_t>::AppendSetValueToWriter(
     MessageWriter* writer);
-extern template class CHROME_DBUS_EXPORT Property<int64>;
+extern template class CHROME_DBUS_EXPORT Property<int64_t>;
 
 template <>
-CHROME_DBUS_EXPORT Property<uint64>::Property();
+CHROME_DBUS_EXPORT Property<uint64_t>::Property();
 template <>
-CHROME_DBUS_EXPORT bool Property<uint64>::PopValueFromReader(
+CHROME_DBUS_EXPORT bool Property<uint64_t>::PopValueFromReader(
     MessageReader* reader);
 template <>
-CHROME_DBUS_EXPORT void Property<uint64>::AppendSetValueToWriter(
+CHROME_DBUS_EXPORT void Property<uint64_t>::AppendSetValueToWriter(
     MessageWriter* writer);
-extern template class CHROME_DBUS_EXPORT Property<uint64>;
+extern template class CHROME_DBUS_EXPORT Property<uint64_t>;
 
 template <>
 CHROME_DBUS_EXPORT Property<double>::Property();
@@ -579,12 +581,12 @@
 extern template class CHROME_DBUS_EXPORT Property<std::vector<ObjectPath>>;
 
 template <>
-CHROME_DBUS_EXPORT bool Property<std::vector<uint8>>::PopValueFromReader(
+CHROME_DBUS_EXPORT bool Property<std::vector<uint8_t>>::PopValueFromReader(
     MessageReader* reader);
 template <>
-CHROME_DBUS_EXPORT void Property<std::vector<uint8>>::AppendSetValueToWriter(
+CHROME_DBUS_EXPORT void Property<std::vector<uint8_t>>::AppendSetValueToWriter(
     MessageWriter* writer);
-extern template class CHROME_DBUS_EXPORT Property<std::vector<uint8>>;
+extern template class CHROME_DBUS_EXPORT Property<std::vector<uint8_t>>;
 
 template <>
 CHROME_DBUS_EXPORT bool
diff --git a/dbus/property_unittest.cc b/dbus/property_unittest.cc
index 59faa22..b6bbb18 100644
--- a/dbus/property_unittest.cc
+++ b/dbus/property_unittest.cc
@@ -4,12 +4,15 @@
 
 #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"
@@ -31,10 +34,10 @@
 
   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)
@@ -189,7 +192,7 @@
   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]);
@@ -253,7 +256,7 @@
   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]);
@@ -380,8 +383,8 @@
 
   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));
@@ -392,7 +395,7 @@
   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());
@@ -407,19 +410,19 @@
 }
 
 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);
 
diff --git a/dbus/string_util.cc b/dbus/string_util.cc
index 16e483a..7f71015 100644
--- a/dbus/string_util.cc
+++ b/dbus/string_util.cc
@@ -4,6 +4,8 @@
 
 #include "dbus/string_util.h"
 
+#include <stddef.h>
+
 #include "base/strings/string_util.h"
 
 namespace dbus {
diff --git a/dbus/values_util.cc b/dbus/values_util.cc
index c162878..e932312 100644
--- a/dbus/values_util.cc
+++ b/dbus/values_util.cc
@@ -94,7 +94,7 @@
       // Do nothing.
       break;
     case Message::BYTE: {
-      uint8 value = 0;
+      uint8_t value = 0;
       if (reader->PopByte(&value))
         result = new base::FundamentalValue(value);
       break;
@@ -106,31 +106,31 @@
       break;
     }
     case Message::INT16: {
-      int16 value = 0;
+      int16_t value = 0;
       if (reader->PopInt16(&value))
         result = new base::FundamentalValue(value);
       break;
     }
     case Message::UINT16: {
-      uint16 value = 0;
+      uint16_t value = 0;
       if (reader->PopUint16(&value))
         result = new base::FundamentalValue(value);
       break;
     }
     case Message::INT32: {
-      int32 value = 0;
+      int32_t value = 0;
       if (reader->PopInt32(&value))
         result = new base::FundamentalValue(value);
       break;
     }
     case Message::UINT32: {
-      uint32 value = 0;
+      uint32_t value = 0;
       if (reader->PopUint32(&value))
         result = new base::FundamentalValue(static_cast<double>(value));
       break;
     }
     case Message::INT64: {
-      int64 value = 0;
+      int64_t value = 0;
       if (reader->PopInt64(&value)) {
         DLOG_IF(WARNING, !IsExactlyRepresentableByDouble(value)) <<
             value << " is not exactly representable by double";
@@ -139,7 +139,7 @@
       break;
     }
     case Message::UINT64: {
-      uint64 value = 0;
+      uint64_t value = 0;
       if (reader->PopUint64(&value)) {
         DLOG_IF(WARNING, !IsExactlyRepresentableByDouble(value)) <<
             value << " is not exactly representable by double";
diff --git a/dbus/values_util.h b/dbus/values_util.h
index 9ece9b9..b6f4ff3 100644
--- a/dbus/values_util.h
+++ b/dbus/values_util.h
@@ -5,6 +5,8 @@
 #ifndef DBUS_VALUES_UTIL_H_
 #define DBUS_VALUES_UTIL_H_
 
+#include <stdint.h>
+
 #include "dbus/dbus_export.h"
 
 namespace base {
@@ -18,8 +20,8 @@
 
 // Pops a value from |reader| as a base::Value.
 // Returns NULL if an error occurs.
-// Note: Integer values larger than int32 (including uint32) are converted to
-// double.  Non-string diciontary keys are converted to strings.
+// Note: Integer values larger than int32_t (including uint32_t) are converted
+// to double.  Non-string dictionary keys are converted to strings.
 CHROME_DBUS_EXPORT base::Value* PopDataAsValue(MessageReader* reader);
 
 // Appends a basic type value to |writer|. Basic types are BOOLEAN, INTEGER,
diff --git a/dbus/values_util_unittest.cc b/dbus/values_util_unittest.cc
index 6abc56a..b2f1404 100644
--- a/dbus/values_util_unittest.cc
+++ b/dbus/values_util_unittest.cc
@@ -4,10 +4,14 @@
 
 #include "dbus/values_util.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <cmath>
 #include <vector>
 
 #include "base/json/json_writer.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "dbus/message.h"
@@ -19,21 +23,21 @@
   scoped_ptr<Response> response(Response::CreateEmpty());
   // Append basic type values.
   MessageWriter writer(response.get());
-  const uint8 kByteValue = 42;
+  const uint8_t kByteValue = 42;
   writer.AppendByte(kByteValue);
   const bool kBoolValue = true;
   writer.AppendBool(kBoolValue);
-  const int16 kInt16Value = -43;
+  const int16_t kInt16Value = -43;
   writer.AppendInt16(kInt16Value);
-  const uint16 kUint16Value = 44;
+  const uint16_t kUint16Value = 44;
   writer.AppendUint16(kUint16Value);
-  const int32 kInt32Value = -45;
+  const int32_t kInt32Value = -45;
   writer.AppendInt32(kInt32Value);
-  const uint32 kUint32Value = 46;
+  const uint32_t kUint32Value = 46;
   writer.AppendUint32(kUint32Value);
-  const int64 kInt64Value = -47;
+  const int64_t kInt64Value = -47;
   writer.AppendInt64(kInt64Value);
-  const uint64 kUint64Value = 48;
+  const uint64_t kUint64Value = 48;
   writer.AppendUint64(kUint64Value);
   const double kDoubleValue = 4.9;
   writer.AppendDouble(kDoubleValue);
@@ -57,34 +61,34 @@
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kBoolValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
-  // Pop an int16.
+  // Pop an int16_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kInt16Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
-  // Pop a uint16.
+  // Pop a uint16_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kUint16Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
-  // Pop an int32.
+  // Pop an int32_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kInt32Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
-  // Pop a uint32.
+  // Pop a uint32_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kUint32Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
-  // Pop an int64.
+  // Pop an int64_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kInt64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
-  // Pop a uint64.
+  // Pop a uint64_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
@@ -118,7 +122,7 @@
   MessageWriter writer(response.get());
   const bool kBoolValue = true;
   writer.AppendVariantOfBool(kBoolValue);
-  const int32 kInt32Value = -45;
+  const int32_t kInt32Value = -45;
   writer.AppendVariantOfInt32(kInt32Value);
   const double kDoubleValue = 4.9;
   writer.AppendVariantOfDouble(kDoubleValue);
@@ -133,7 +137,7 @@
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kBoolValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
-  // Pop an int32.
+  // Pop an int32_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kInt32Value));
@@ -156,39 +160,39 @@
   scoped_ptr<Response> response(Response::CreateEmpty());
   // Append large integers.
   MessageWriter writer(response.get());
-  const int64 kInt64Value = -123456789012345689LL;
+  const int64_t kInt64Value = -123456789012345689LL;
   writer.AppendInt64(kInt64Value);
-  const uint64 kUint64Value = 9876543210987654321ULL;
+  const uint64_t kUint64Value = 9876543210987654321ULL;
   writer.AppendUint64(kUint64Value);
 
   MessageReader reader(response.get());
   scoped_ptr<base::Value> value;
   scoped_ptr<base::Value> expected_value;
   double double_value = 0;
-  // Pop an int64.
+  // Pop an int64_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kInt64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   ASSERT_TRUE(value->GetAsDouble(&double_value));
-  EXPECT_NE(kInt64Value, static_cast<int64>(double_value));
-  // Pop a uint64.
+  EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value));
+  // Pop a uint64_t.
   value.reset(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kUint64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   ASSERT_TRUE(value->GetAsDouble(&double_value));
-  EXPECT_NE(kUint64Value, static_cast<uint64>(double_value));
+  EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value));
 }
 
 TEST(ValuesUtilTest, PopIntArray) {
   scoped_ptr<Response> response(Response::CreateEmpty());
-  // Append an int32 array.
+  // Append an int32_t array.
   MessageWriter writer(response.get());
   MessageWriter sub_writer(NULL);
-  std::vector<int32> data;
+  std::vector<int32_t> data;
   data.push_back(0);
   data.push_back(1);
   data.push_back(2);
@@ -202,7 +206,7 @@
   for (size_t i = 0; i != data.size(); ++i)
     list_value->Append(new base::FundamentalValue(data[i]));
 
-  // Pop an int32 array.
+  // Pop an int32_t array.
   MessageReader reader(response.get());
   scoped_ptr<base::Value> value(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
@@ -240,7 +244,7 @@
   writer.OpenStruct(&sub_writer);
   const bool kBoolValue = true;
   sub_writer.AppendBool(kBoolValue);
-  const int32 kInt32Value = -123;
+  const int32_t kInt32Value = -123;
   sub_writer.AppendInt32(kInt32Value);
   const double kDoubleValue = 1.23;
   sub_writer.AppendDouble(kDoubleValue);
@@ -278,7 +282,7 @@
   sub_writer.OpenDictEntry(&entry_writer);
   const std::string kKey2 = "two";
   entry_writer.AppendString(kKey2);
-  const int32 kInt32Value = -45;
+  const int32_t kInt32Value = -45;
   entry_writer.AppendVariantOfInt32(kInt32Value);
   sub_writer.CloseContainer(&entry_writer);
   sub_writer.OpenDictEntry(&entry_writer);
@@ -325,7 +329,7 @@
   sub_writer.OpenDictEntry(&entry_writer);
   const std::string kKey2 = ".example";  // String starting with a dot.
   entry_writer.AppendString(kKey2);
-  const int32 kInt32Value = -45;
+  const int32_t kInt32Value = -45;
   entry_writer.AppendVariantOfInt32(kInt32Value);
   sub_writer.CloseContainer(&entry_writer);
   sub_writer.OpenDictEntry(&entry_writer);
@@ -354,8 +358,8 @@
 
 TEST(ValuesUtilTest, PopDoubleToIntDictionary) {
   // Create test data.
-  const int32 kValues[] = {0, 1, 1, 2, 3, 5, 8, 13, 21};
-  const std::vector<int32> values(kValues, kValues + arraysize(kValues));
+  const int32_t kValues[] = {0, 1, 1, 2, 3, 5, 8, 13, 21};
+  const std::vector<int32_t> values(kValues, kValues + arraysize(kValues));
   std::vector<double> keys(values.size());
   for (size_t i = 0; i != values.size(); ++i)
     keys[i] = std::sqrt(values[i]);
@@ -515,7 +519,7 @@
   const std::string kKey6 = "six";
 
   const bool kBoolValue = true;
-  const int32 kInt32Value = -45;
+  const int32_t kInt32Value = -45;
   const double kDoubleValue = 4.9;
   const std::string kStringValue = "fifty";
 
@@ -562,7 +566,7 @@
   const std::string kKey6 = "six";
 
   const bool kBoolValue = true;
-  const int32 kInt32Value = -45;
+  const int32_t kInt32Value = -45;
   const double kDoubleValue = 4.9;
   const std::string kStringValue = "fifty";
 
@@ -605,7 +609,7 @@
   const std::string kKey2 = "two";
 
   const bool kBoolValue = true;
-  const int32 kInt32Value = -45;
+  const int32_t kInt32Value = -45;
   const double kDoubleValue = 4.9;
   const std::string kStringValue = "fifty";
 
@@ -648,7 +652,7 @@
   const std::string kKey2 = "two";
 
   const bool kBoolValue = true;
-  const int32 kInt32Value = -45;
+  const int32_t kInt32Value = -45;
   const double kDoubleValue = 4.9;
   const std::string kStringValue = "fifty";