Switch to standard integer types in dbus/.

dbus/message.h

 // 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.
 
 #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"
 #include "dbus/object_path.h"
 
 namespace google {
 namespace protobuf {
 
 class MessageLite;
 
@@ skipping 69 matching lines @@
 
   DBusMessage* raw_message() { return raw_message_; }
 
   // Sets the destination, the path, the interface, the member, etc.
   bool SetDestination(const std::string& destination);
   bool SetPath(const ObjectPath& path);
   bool SetInterface(const std::string& interface);
   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.
   // If not set, an empty string is returned.
   std::string GetDestination();
   ObjectPath GetPath();
   std::string GetInterface();
   std::string GetMember();
   std::string GetErrorName();
   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
   // if longer than a certain limit defined in the .cc file).
   std::string ToString();
 
  protected:
   // This class cannot be instantiated. Use sub classes instead.
   Message();
   virtual ~Message();
@@ skipping 135 matching lines @@
 //   writer.AppendString(str);
 //
 class CHROME_DBUS_EXPORT MessageWriter {
  public:
   // Data added with Append* will be written to |message|, which may be NULL
   // to create a sub-writer for passing to OpenArray, etc.
   explicit MessageWriter(Message* message);
   ~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);
   void AppendFileDescriptor(const FileDescriptor& value);
 
   // Opens an array. The array contents can be added to the array with
   // |sub_writer|. The client code must close the array with
   // CloseContainer(), once all contents are added.
   //
   // |signature| parameter is used to supply the D-Bus type signature of
@@ skipping 10 matching lines @@
   // Do the same for Struct and dict entry. They don't need the signature.
   void OpenStruct(MessageWriter* sub_writer);
   void OpenDictEntry(MessageWriter* sub_writer);
 
   // Close the container for a array/variant/struct/dict entry.
   void CloseContainer(MessageWriter* sub_writer);
 
   // 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
   // function.
   void AppendArrayOfStrings(const std::vector<std::string>& strings);
 
   // Appends the array of object paths. Arrays of object paths are often
   // used when exchanging object paths, hence it's worth having a
   // specialized function.
   void AppendArrayOfObjectPaths(const std::vector<ObjectPath>& object_paths);
 
   // Appends the protocol buffer as an array of bytes. The buffer is serialized
   // into an array of bytes before communication, since protocol buffers are not
   // a native dbus type. On the receiving size the array of bytes needs to be
   // read and deserialized into a protocol buffer of the correct type. There are
   // methods in MessageReader to assist in this.  Return true on succes and fail
   // when serialization is not successful.
   bool AppendProtoAsArrayOfBytes(const google::protobuf::MessageLite& protobuf);
 
   // Appends the byte wrapped in a variant data container. Variants are
   // 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);
 
  private:
   // Helper function used to implement AppendByte etc.
   void AppendBasic(int dbus_type, const void* value);
 
   // Helper function used to implement AppendVariantOfByte() etc.
   void AppendVariantOfBasic(int dbus_type, const void* value);
@@ skipping 20 matching lines @@
   // Returns true if the reader has more data to read. The function is
   // used to iterate contents in a container like:
   //
   //   while (reader.HasMoreData())
   //     reader.PopString(&value);
   bool HasMoreData();
 
   // 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);
   bool PopFileDescriptor(FileDescriptor* value);
 
   // Sets up the given message reader to read an array at the current
   // iterator position.
   // Returns true and advances the iterator on success.
   // Returns false if the data type is not an array
   bool PopArray(MessageReader* sub_reader);
   bool PopStruct(MessageReader* sub_reader);
   bool PopDictEntry(MessageReader* sub_reader);
   bool PopVariant(MessageReader* sub_reader);
 
   // Gets the array of bytes at the current iterator position.
   // Returns true and advances the iterator on success.
   //
   // Arrays of bytes are often used for exchanging binary blobs hence it's
   // worth having a specialized function.
   //
   // 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
   // success.
   //
   // Arrays of strings are often used to communicate with D-Bus
   // services like KWallet, hence it's worth having a specialized
   // function.
   bool PopArrayOfStrings(std::vector<std::string>* strings);
 
@@ skipping 14 matching lines @@
   // the wrong type of protocol buffer is passed in and the parse fails.
   bool PopArrayOfBytesAsProto(google::protobuf::MessageLite* protobuf);
 
   // Gets the byte from the variant data container at the current iterator
   // position.
   // Returns true and advances the iterator on success.
   //
   // 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);
 
   // Get the data type of the value at the current iterator
   // position. INVALID_DATA will be returned if the iterator points to the
   // end of the message.
   Message::DataType GetDataType();
 
   // Get the DBus signature of the value at the current iterator position.
@@ skipping 17 matching lines @@
 
   Message* message_;
   DBusMessageIter raw_message_iter_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageReader);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_MESSAGE_H_