dbus: add ObjectPath type

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/stringprintf.h"
+#include "dbus/object_path.h"
 #include "third_party/protobuf/src/google/protobuf/message_lite.h"
 
 namespace {
 
 // Appends the header name and the value to |output|, if the value is
 // not empty.
 static void AppendStringHeader(const std::string& header_name,
                                const std::string& header_value,
                                std::string* output) {
   if (!header_value.empty()) {
@@ skipping 127 matching lines @@
         break;
       }
       case STRING: {
         std::string value;
         if (!reader->PopString(&value))
           return kBrokenMessage;
         output += indent + "string \"" + value + "\"\n";
         break;
       }
       case OBJECT_PATH: {
-        std::string value;
+        ObjectPath value;
         if (!reader->PopObjectPath(&value))
           return kBrokenMessage;
-        output += indent + "object_path \"" + value + "\"\n";
+        output += indent + "object_path \"" + value.value() + "\"\n";
         break;
       }
       case ARRAY: {
         MessageReader sub_reader(this);
         if (!reader->PopArray(&sub_reader))
           return kBrokenMessage;
         output += indent + "array [\n";
         output += ToStringInternal(indent + "  ", &sub_reader);
         output += indent + "]\n";
         break;
@@ skipping 43 matching lines @@
 // string \"payload\"
 // ...
 std::string Message::ToString() {
   if (!raw_message_)
     return "";
 
   // Generate headers first.
   std::string headers;
   AppendStringHeader("message_type", GetMessageTypeAsString(), &headers);
   AppendStringHeader("destination", GetDestination(), &headers);
-  AppendStringHeader("path", GetPath(), &headers);
+  AppendStringHeader("path", GetPath().value(), &headers);
   AppendStringHeader("interface", GetInterface(), &headers);
   AppendStringHeader("member", GetMember(), &headers);
   AppendStringHeader("error_name", GetErrorName(), &headers);
   AppendStringHeader("sender", GetSender(), &headers);
   AppendStringHeader("signature", GetSignature(), &headers);
   AppendUint32Header("serial", GetSerial(), &headers);
   AppendUint32Header("reply_serial", GetReplySerial(), &headers);
 
   // Generate the payload.
   MessageReader reader(this);
   return headers + "\n" + ToStringInternal("", &reader);
 }
 
 void Message::SetDestination(const std::string& destination) {
   const bool success = dbus_message_set_destination(raw_message_,
                                                     destination.c_str());
   CHECK(success) << "Unable to allocate memory";
 }
 
-void Message::SetPath(const std::string& path) {
+void Message::SetPath(const ObjectPath& path) {
   const bool success = dbus_message_set_path(raw_message_,
-                                             path.c_str());
+                                             path.value().c_str());
   CHECK(success) << "Unable to allocate memory";
 }
 
 void Message::SetInterface(const std::string& interface) {
   const bool success = dbus_message_set_interface(raw_message_,
                                                   interface.c_str());
   CHECK(success) << "Unable to allocate memory";
 }
 
 void Message::SetMember(const std::string& member) {
@@ skipping 20 matching lines @@
 
 void Message::SetReplySerial(uint32 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 : "";
 }
 
-std::string Message::GetPath() {
+ObjectPath Message::GetPath() {
   const char* path = dbus_message_get_path(raw_message_);
-  return path ? path : "";
+  return ObjectPath(path ? path : "");
 }
 
 std::string Message::GetInterface() {
   const char* interface = dbus_message_get_interface(raw_message_);
   return interface ? interface : "";
 }
 
 std::string Message::GetMember() {
   const char* member = dbus_message_get_member(raw_message_);
   return member ? member : "";
@@ skipping 180 matching lines @@
 }
 
 void MessageWriter::AppendString(const std::string& value) {
   const char* pointer = value.c_str();
   AppendBasic(DBUS_TYPE_STRING, &pointer);
   // TODO(satorux): It may make sense to return an error here, as the
   // input string can be large. If needed, we could add something like
   // bool AppendStringWithErrorChecking().
 }
 
-void MessageWriter::AppendObjectPath(const std::string& value) {
-  const char* pointer = value.c_str();
+void MessageWriter::AppendObjectPath(const ObjectPath& value) {
+  const char* pointer = value.value().c_str();
   AppendBasic(DBUS_TYPE_OBJECT_PATH, &pointer);
 }
 
 // Ideally, client shouldn't need to supply the signature string, but
 // the underlying D-Bus library requires us to supply this before
 // appending contents to array and variant. It's technically possible
 // for us to design API that doesn't require the signature but it will
 // complicate the implementation so we decided to have the signature
 // parameter. Hopefully, variants are less used in request messages from
 // client side than response message from server side, so this should
@@ skipping 75 matching lines @@
   DCHECK(!container_is_open_);
   MessageWriter array_writer(message_);
   OpenArray("s", &array_writer);
   for (size_t i = 0; i < strings.size(); ++i) {
     array_writer.AppendString(strings[i]);
   }
   CloseContainer(&array_writer);
 }
 
 void MessageWriter::AppendArrayOfObjectPaths(
-    const std::vector<std::string>& object_paths) {
+    const std::vector<ObjectPath>& object_paths) {
   DCHECK(!container_is_open_);
   MessageWriter array_writer(message_);
   OpenArray("o", &array_writer);
   for (size_t i = 0; i < object_paths.size(); ++i) {
     array_writer.AppendObjectPath(object_paths[i]);
   }
   CloseContainer(&array_writer);
 }
 
 bool MessageWriter::AppendProtoAsArrayOfBytes(
@@ skipping 44 matching lines @@
 
 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);
 }
 
-void MessageWriter::AppendVariantOfObjectPath(const std::string& value) {
-  const char* pointer = value.c_str();
+void MessageWriter::AppendVariantOfObjectPath(const ObjectPath& value) {
+  const char* pointer = value.value().c_str();
   AppendVariantOfBasic(DBUS_TYPE_OBJECT_PATH, &pointer);
 }
 
 void MessageWriter::AppendBasic(int dbus_type, const void* value) {
   DCHECK(!container_is_open_);
 
   const bool success = dbus_message_iter_append_basic(
       &raw_message_iter_, dbus_type, value);
   // dbus_message_iter_append_basic() fails only when there is not enough
   // memory. We don't return this error as there is nothing we can do when
@@ skipping 72 matching lines @@
 }
 
 bool MessageReader::PopString(std::string* value) {
   char* tmp_value = NULL;
   const bool success = PopBasic(DBUS_TYPE_STRING, &tmp_value);
   if (success)
     value->assign(tmp_value);
   return success;
 }
 
-bool MessageReader::PopObjectPath(std::string* value) {
+bool MessageReader::PopObjectPath(ObjectPath* value) {
   char* tmp_value = NULL;
   const bool success = PopBasic(DBUS_TYPE_OBJECT_PATH, &tmp_value);
   if (success)
-    value->assign(tmp_value);
+    *value = ObjectPath(tmp_value);
   return success;
 }
 
 bool MessageReader::PopArray(MessageReader* sub_reader) {
   return PopContainer(DBUS_TYPE_ARRAY, sub_reader);
 }
 
 bool MessageReader::PopStruct(MessageReader* sub_reader) {
   return PopContainer(DBUS_TYPE_STRUCT, sub_reader);
 }
@@ skipping 34 matching lines @@
   while (array_reader.HasMoreData()) {
     std::string string;
     if (!array_reader.PopString(&string))
       return false;
     strings->push_back(string);
   }
   return true;
 }
 
 bool MessageReader::PopArrayOfObjectPaths(
-    std::vector<std::string> *object_paths) {
+    std::vector<ObjectPath> *object_paths) {
   MessageReader array_reader(message_);
   if (!PopArray(&array_reader))
       return false;
   while (array_reader.HasMoreData()) {
-    std::string object_path;
+    ObjectPath object_path;
     if (!array_reader.PopObjectPath(&object_path))
       return false;
     object_paths->push_back(object_path);
   }
   return true;
 }
 
 bool MessageReader::PopArrayOfBytesAsProto(
     google::protobuf::MessageLite* protobuf) {
   DCHECK(protobuf != NULL);
@@ skipping 51 matching lines @@
 }
 
 bool MessageReader::PopVariantOfString(std::string* value) {
   char* tmp_value = NULL;
   const bool success = PopVariantOfBasic(DBUS_TYPE_STRING, &tmp_value);
   if (success)
     value->assign(tmp_value);
   return success;
 }
 
-bool MessageReader::PopVariantOfObjectPath(std::string* value) {
+bool MessageReader::PopVariantOfObjectPath(ObjectPath* value) {
   char* tmp_value = NULL;
   const bool success = PopVariantOfBasic(DBUS_TYPE_OBJECT_PATH, &tmp_value);
   if (success)
-    value->assign(tmp_value);
+    *value = ObjectPath(tmp_value);
   return success;
 }
 
 Message::DataType MessageReader::GetDataType() {
   const int dbus_type = dbus_message_iter_get_arg_type(&raw_message_iter_);
   return static_cast<Message::DataType>(dbus_type);
 }
 
 bool MessageReader::CheckDataType(int dbus_type) {
   const int actual_type = dbus_message_iter_get_arg_type(&raw_message_iter_);
@@ skipping 29 matching lines @@
 }
 
 bool MessageReader::PopVariantOfBasic(int dbus_type, void* value) {
   dbus::MessageReader variant_reader(message_);
   if (!PopVariant(&variant_reader))
     return false;
   return variant_reader.PopBasic(dbus_type, value);
 }
 
 }  // namespace dbus