Switch to standard integer types in dbus/.

dbus/message.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/message.h"
 
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "dbus/object_path.h"
 
 #if defined(USE_SYSTEM_PROTOBUF)
 #include <google/protobuf/message_lite.h>
 #else
 #include "third_party/protobuf/src/google/protobuf/message_lite.h"
 #endif
 
 namespace {
 
 // Appends the header name and the value to |output|, if the value is
 // not empty.
 void AppendStringHeader(const std::string& header_name,
                         const std::string& header_value,
                         std::string* output) {
   if (!header_value.empty()) {
     *output += header_name + ": " + header_value + "\n";
   }
 }
 
 // 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");
   }
 }
 
 }  // namespace
 
 namespace dbus {
 
@@ skipping 42 matching lines @@
 }
 
 std::string Message::ToStringInternal(const std::string& indent,
                                       MessageReader* reader) {
   const char* kBrokenMessage = "[broken message]";
   std::string output;
   while (reader->HasMoreData()) {
     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";
         break;
       }
       case BOOL: {
         bool value = false;
         if (!reader->PopBool(&value))
           return kBrokenMessage;
         output += indent + "bool " + (value ? "true" : "false") + "\n";
         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: {
         double value = 0;
         if (!reader->PopDouble(&value))
           return kBrokenMessage;
         output += indent + "double " + base::DoubleToString(value) + "\n";
         break;
       }
       case STRING: {
@@ skipping 122 matching lines @@
 }
 
 bool Message::SetErrorName(const std::string& error_name) {
   return dbus_message_set_error_name(raw_message_, error_name.c_str());
 }
 
 bool Message::SetSender(const std::string& sender) {
   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);
 }
 
 std::string Message::GetDestination() {
   const char* destination = dbus_message_get_destination(raw_message_);
   return destination ? destination : "";
 }
 
 ObjectPath Message::GetPath() {
   const char* path = dbus_message_get_path(raw_message_);
@@ skipping 18 matching lines @@
 std::string Message::GetSender() {
   const char* sender = dbus_message_get_sender(raw_message_);
   return sender ? sender : "";
 }
 
 std::string Message::GetSignature() {
   const char* signature = dbus_message_get_signature(raw_message_);
   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_);
 }
 
 //
 // MethodCall implementation.
 //
 
 MethodCall::MethodCall(const std::string& interface_name,
                        const std::string& method_name)
     : Message() {
@@ skipping 100 matching lines @@
     : message_(message),
       container_is_open_(false) {
   memset(&raw_message_iter_, 0, sizeof(raw_message_iter_));
   if (message)
     dbus_message_iter_init_append(message_->raw_message(), &raw_message_iter_);
 }
 
 MessageWriter::~MessageWriter() {
 }
 
-void MessageWriter::AppendByte(uint8 value) {
+void MessageWriter::AppendByte(uint8_t value) {
   AppendBasic(DBUS_TYPE_BYTE, &value);
 }
 
 void MessageWriter::AppendBool(bool value) {
   // The size of dbus_bool_t and the size of bool are different. The
   // former is always 4 per dbus-types.h, whereas the latter is usually 1.
   // dbus_message_iter_append_basic() used in AppendBasic() expects four
   // bytes for DBUS_TYPE_BOOLEAN, so we must pass a dbus_bool_t, instead
   // of a bool, to AppendBasic().
   dbus_bool_t dbus_value = value;
   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);
 }
 
 void MessageWriter::AppendDouble(double value) {
   AppendBasic(DBUS_TYPE_DOUBLE, &value);
 }
 
 void MessageWriter::AppendString(const std::string& value) {
   // D-Bus Specification (0.19) says a string "must be valid UTF-8".
   CHECK(base::IsStringUTF8(value));
@@ skipping 70 matching lines @@
 
 void MessageWriter::CloseContainer(MessageWriter* writer) {
   DCHECK(container_is_open_);
 
   const bool success = dbus_message_iter_close_container(
       &raw_message_iter_, &writer->raw_message_iter_);
   CHECK(success) << "Unable to allocate memory";
   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);
   const bool success = dbus_message_iter_append_fixed_array(
       &(array_writer.raw_message_iter_),
       DBUS_TYPE_BYTE,
       &values,
       static_cast<int>(length));
   CHECK(success) << "Unable to allocate memory";
   CloseContainer(&array_writer);
@@ skipping 21 matching lines @@
   CloseContainer(&array_writer);
 }
 
 bool MessageWriter::AppendProtoAsArrayOfBytes(
     const google::protobuf::MessageLite& protobuf) {
   std::string serialized_proto;
   if (!protobuf.SerializeToString(&serialized_proto)) {
     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);
 }
 
 void MessageWriter::AppendVariantOfBool(bool value) {
   // See the comment at MessageWriter::AppendBool().
   dbus_bool_t dbus_value = value;
   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);
 }
 
 void MessageWriter::AppendVariantOfDouble(double value) {
   AppendVariantOfBasic(DBUS_TYPE_DOUBLE, &value);
 }
 
 void MessageWriter::AppendVariantOfString(const std::string& value) {
   const char* pointer = value.c_str();
   AppendVariantOfBasic(DBUS_TYPE_STRING, &pointer);
@@ skipping 48 matching lines @@
 
 
 MessageReader::~MessageReader() {
 }
 
 bool MessageReader::HasMoreData() {
   const int dbus_type = dbus_message_iter_get_arg_type(&raw_message_iter_);
   return dbus_type != DBUS_TYPE_INVALID;
 }
 
-bool MessageReader::PopByte(uint8* value) {
+bool MessageReader::PopByte(uint8_t* value) {
   return PopBasic(DBUS_TYPE_BYTE, value);
 }
 
 bool MessageReader::PopBool(bool* value) {
   // Like MessageWriter::AppendBool(), we should copy |value| to
   // dbus_bool_t, as dbus_message_iter_get_basic() used in PopBasic()
   // expects four bytes for DBUS_TYPE_BOOLEAN.
   dbus_bool_t dbus_value = FALSE;
   const bool success = PopBasic(DBUS_TYPE_BOOLEAN, &dbus_value);
   *value = static_cast<bool>(dbus_value);
   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);
 }
 
 bool MessageReader::PopDouble(double* value) {
   return PopBasic(DBUS_TYPE_DOUBLE, value);
 }
 
 bool MessageReader::PopString(std::string* value) {
   char* tmp_value = NULL;
   const bool success = PopBasic(DBUS_TYPE_STRING, &tmp_value);
@@ skipping 19 matching lines @@
 }
 
 bool MessageReader::PopDictEntry(MessageReader* sub_reader) {
   return PopContainer(DBUS_TYPE_DICT_ENTRY, sub_reader);
 }
 
 bool MessageReader::PopVariant(MessageReader* sub_reader) {
   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;
   // An empty array is allowed.
   if (!array_reader.HasMoreData()) {
     *length = 0;
     *bytes = NULL;
     return true;
   }
   if (!array_reader.CheckDataType(DBUS_TYPE_BYTE))
@@ skipping 34 matching lines @@
     object_paths->push_back(object_path);
   }
   return true;
 }
 
 bool MessageReader::PopArrayOfBytesAsProto(
     google::protobuf::MessageLite* protobuf) {
   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;
   }
   if (!protobuf->ParseFromArray(serialized_buf, buf_size)) {
     LOG(ERROR) << "Failed to parse protocol buffer from array";
     return false;
   }
   return true;
 }
 
-bool MessageReader::PopVariantOfByte(uint8* value) {
+bool MessageReader::PopVariantOfByte(uint8_t* value) {
   return PopVariantOfBasic(DBUS_TYPE_BYTE, value);
 }
 
 bool MessageReader::PopVariantOfBool(bool* value) {
   // See the comment at MessageReader::PopBool().
   dbus_bool_t dbus_value = FALSE;
   const bool success = PopVariantOfBasic(DBUS_TYPE_BOOLEAN, &dbus_value);
   *value = static_cast<bool>(dbus_value);
   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);
 }
 
 bool MessageReader::PopVariantOfDouble(double* value) {
   return PopVariantOfBasic(DBUS_TYPE_DOUBLE, value);
 }
 
 bool MessageReader::PopVariantOfString(std::string* value) {
   char* tmp_value = NULL;
   const bool success = PopVariantOfBasic(DBUS_TYPE_STRING, &tmp_value);
@@ skipping 72 matching lines @@
   const bool success = PopBasic(DBUS_TYPE_UNIX_FD, &fd);
   if (!success)
     return false;
 
   value->PutValue(fd);
   // NB: the caller must check validity before using the value
   return true;
 }
 
 }  // namespace dbus