Add a GetSignature() method to dbus::MessageReader.

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"
@@ skipping 24 matching lines @@
 // nonzero.
 void AppendUint32Header(const std::string& header_name,
                         uint32 header_value,
                         std::string* output) {
   if (header_value != 0) {
     *output += (header_name + ": " + base::StringPrintf("%u", header_value) +
                 "\n");
   }
 }
 
+struct DBusFreeDeleter {
+  inline void operator()(void* ptr) const {
+    dbus_free(ptr);
+  }
+};
+
 }  // namespace
 
 namespace dbus {
 
 bool IsDBusTypeUnixFdSupported() {
   int major = 0, minor = 0, micro = 0;
   dbus_get_version(&major, &minor, &micro);
   return major >= 1 && minor >= 4;
 }
 
@@ skipping 200 matching lines @@
 
   // Generate headers first.
   std::string headers;
   AppendStringHeader("message_type", GetMessageTypeAsString(), &headers);
   AppendStringHeader("destination", GetDestination(), &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);
+  AppendStringHeader("signature", GetDataSignature(), &headers);
   AppendUint32Header("serial", GetSerial(), &headers);
   AppendUint32Header("reply_serial", GetReplySerial(), &headers);
 
   // Generate the payload.
   MessageReader reader(this);
   return headers + "\n" + ToStringInternal(std::string(), &reader);
 }
 
 bool Message::SetDestination(const std::string& destination) {
   return dbus_message_set_destination(raw_message_, destination.c_str());
@@ skipping 50 matching lines @@
 std::string Message::GetErrorName() {
   const char* error_name = dbus_message_get_error_name(raw_message_);
   return error_name ? error_name : "";
 }
 
 std::string Message::GetSender() {
   const char* sender = dbus_message_get_sender(raw_message_);
   return sender ? sender : "";
 }
 
-std::string Message::GetSignature() {
+std::string Message::GetDataSignature() {
   const char* signature = dbus_message_get_signature(raw_message_);
   return signature ? signature : "";
 }
 
 uint32 Message::GetSerial() {
   return dbus_message_get_serial(raw_message_);
 }
 
 uint32 Message::GetReplySerial() {
   return dbus_message_get_reply_serial(raw_message_);
@@ skipping 581 matching lines @@
   if (success)
     *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);
 }
 
+std::string MessageReader::GetDataSignature() {
+  scoped_ptr<char, DBusFreeDeleter> signature(
+      dbus_message_iter_get_signature(&raw_message_iter_));

[satorux1, 2014/08/25 05:33:27]

I understand the intention, but I guess calling dbus_free() is simpler. In fact,
it's not obvious if "scoped_ptr<char" is correct or "scoped_ptr<char*" is
correct here.

string signature;
char* raw_signature = dbus_message_iter_get_signature(...);
if (raw_signature) {
   signature = raw_signature;
   dbus_free(raw_signature);
}
return signature;

[Ben Chan, 2014/08/25 05:43:07]

Done.

+  return signature ? signature.get() : "";
+}
+
 bool MessageReader::CheckDataType(int dbus_type) {
   const int actual_type = dbus_message_iter_get_arg_type(&raw_message_iter_);
   if (actual_type != dbus_type) {
     VLOG(1) << "Type " << dbus_type  << " is expected but got "
             << actual_type;
     return false;
   }
   return true;
 }
 
@@ skipping 34 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