chromeos: Make dbus::MessageReader memory ownership explicit

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 789 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(uint8** bytes, size_t* length) {
+bool MessageReader::PopArrayOfBytes(const uint8** 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))
     return false;
   int int_length = 0;
   dbus_message_iter_get_fixed_array(&array_reader.raw_message_iter_,
                                     bytes,
                                     &int_length);
   *length = static_cast<int>(int_length);
   return true;
 }
 
 bool MessageReader::PopArrayOfStrings(
     std::vector<std::string> *strings) {
+  strings->clear();
   MessageReader array_reader(message_);
   if (!PopArray(&array_reader))
-      return false;
+    return false;
   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<ObjectPath> *object_paths) {
+  object_paths->clear();
   MessageReader array_reader(message_);
   if (!PopArray(&array_reader))
-      return false;
+    return false;
   while (array_reader.HasMoreData()) {
     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);
-  char* serialized_buf = NULL;
+  const char* serialized_buf = NULL;
   size_t buf_size = 0;
-  if (!PopArrayOfBytes(reinterpret_cast<uint8**>(&serialized_buf), &buf_size)) {
+  if (!PopArrayOfBytes(
+          reinterpret_cast<const uint8**>(&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;
 }
 
@@ skipping 105 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