Revert 121920 - dbus: add ObjectPath type

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_
 #pragma once
 
 #include <string>
 #include <vector>
 #include <dbus/dbus.h>
 
 #include "base/basictypes.h"
-#include "dbus/object_path.h"
 
 namespace google {
 namespace protobuf {
 
 class MessageLite;
 
 }  // namespace protobuf
 }  // namespace google
 
 
@@ skipping 49 matching lines @@
   MessageType GetMessageType();
 
   // Returns the type of the message as string like "MESSAGE_METHOD_CALL"
   // for instance.
   std::string GetMessageTypeAsString();
 
   DBusMessage* raw_message() { return raw_message_; }
 
   // Sets the destination, the path, the interface, the member, etc.
   void SetDestination(const std::string& destination);
-  void SetPath(const ObjectPath& path);
+  void SetPath(const std::string& path);
   void SetInterface(const std::string& interface);
   void SetMember(const std::string& member);
   void SetErrorName(const std::string& error_name);
   void SetSender(const std::string& sender);
   void SetSerial(uint32 serial);
   void SetReplySerial(uint32 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 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();
 
   // Returns the string representation of this message. Useful for
@@ skipping 152 matching lines @@
   void AppendByte(uint8 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 AppendDouble(double value);
   void AppendString(const std::string& value);
-  void AppendObjectPath(const ObjectPath& value);
+  void AppendObjectPath(const std::string& 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
   // the array contents. For instance, if you want an array of strings,
   // then you pass "s" as the signature.
   //
   // See the spec for details about the type signatures.
@@ skipping 16 matching lines @@
   void AppendArrayOfBytes(const uint8* 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);
+  void AppendArrayOfObjectPaths(const std::vector<std::string>& 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 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 AppendVariantOfDouble(double value);
   void AppendVariantOfString(const std::string& value);
-  void AppendVariantOfObjectPath(const ObjectPath& value);
+  void AppendVariantOfObjectPath(const std::string& 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);
 
   Message* message_;
   DBusMessageIter raw_message_iter_;
@@ skipping 27 matching lines @@
   bool PopByte(uint8* 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 PopDouble(double* value);
   bool PopString(std::string* value);
-  bool PopObjectPath(ObjectPath* value);
+  bool PopObjectPath(std::string* 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);
 
@@ skipping 14 matching lines @@
   // services like KWallet, hence it's worth having a specialized
   // function.
   bool PopArrayOfStrings(std::vector<std::string>* strings);
 
   // Gets the array of object paths at the current iterator position.
   // Returns true and advances the iterator on success.
   //
   // Arrays of object paths are often used to communicate with D-Bus
   // services like NetworkManager, hence it's worth having a specialized
   // function.
-  bool PopArrayOfObjectPaths(std::vector<ObjectPath>* object_paths);
+  bool PopArrayOfObjectPaths(std::vector<std::string>* object_paths);
 
   // Gets the array of bytes at the current iterator position. It then parses
   // this binary blob into the protocol buffer supplied.
   // Returns true and advances the iterator on success. On failure returns false
   // and emits an error message on the source of the failure. The two most
   // common errors come from the iterator not currently being at a byte array or
   // 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 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 PopVariantOfDouble(double* value);
   bool PopVariantOfString(std::string* value);
-  bool PopVariantOfObjectPath(ObjectPath* value);
+  bool PopVariantOfObjectPath(std::string* 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();
 
  private:
   // Returns true if the data type at the current iterator position
   // matches the given D-Bus type, such as DBUS_TYPE_BYTE.
   bool CheckDataType(int dbus_type);
 
   // Helper function used to implement PopByte() etc.
   bool PopBasic(int dbus_type, void *value);
 
   // Helper function used to implement PopArray() etc.
   bool PopContainer(int dbus_type, MessageReader* sub_reader);
 
   // Helper function used to implement PopVariantOfByte() etc.
   bool PopVariantOfBasic(int dbus_type, void* value);
 
   Message* message_;
   DBusMessageIter raw_message_iter_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageReader);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_MESSAGE_H_