chromeos: Make dbus::MessageReader memory ownership explicit

chromeos/dbus/cryptohome_client.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 "chromeos/dbus/cryptohome_client.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 339 matching lines @@
                                     bool* successful) OVERRIDE {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeInstallAttributesGet);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(name);
     scoped_ptr<dbus::Response> response(
         blocking_method_caller_->CallMethodAndBlock(&method_call));
     if (!response.get())
       return false;
     dbus::MessageReader reader(response.get());
-    uint8* bytes = NULL;
+    const uint8* bytes = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length) ||
         !reader.PopBool(successful))
       return false;
     value->assign(bytes, bytes + length);
     return true;
   }
 
   // CryptohomeClient override.
   virtual bool InstallAttributesSet(const std::string& name,
@@ skipping 359 matching lines @@
   }
 
   // Handles the result of GetSystemSalt().
   void OnGetSystemSalt(const GetSystemSaltCallback& callback,
                        dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, std::vector<uint8>());
       return;
     }
     dbus::MessageReader reader(response);
-    uint8* bytes = NULL;
+    const uint8* bytes = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, std::vector<uint8>());
       return;
     }
     callback.Run(DBUS_METHOD_CALL_SUCCESS,
                  std::vector<uint8>(bytes, bytes + length));
   }
 
   // Calls a method without result values.
@@ skipping 69 matching lines @@
   }
 
   // Handles responses for methods with a bool result and data.
   void OnDataMethod(const DataMethodCallback& callback,
                     dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false, std::string());
       return;
     }
     dbus::MessageReader reader(response);
-    uint8* data_buffer = NULL;
+    const uint8* data_buffer = NULL;
     size_t data_length = 0;
     bool result = false;
     if (!reader.PopArrayOfBytes(&data_buffer, &data_length) ||
         !reader.PopBool(&result)) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false, std::string());
       return;
     }
-    std::string data(reinterpret_cast<char*>(data_buffer), data_length);
+    std::string data(reinterpret_cast<const char*>(data_buffer), data_length);
     callback.Run(DBUS_METHOD_CALL_SUCCESS, result, data);
   }
 
   // Handles responses for Pkcs11GetTpmTokenInfo.
   void OnPkcs11GetTpmTokenInfo(const Pkcs11GetTpmTokenInfoCallback& callback,
                                dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string(), -1);
       return;
     }
@@ skipping 44 matching lines @@
     }
     if (!async_call_status_handler_.is_null())
       async_call_status_handler_.Run(async_id, return_status, return_code);
   }
 
   // Handles AsyncCallStatusWithData signal.
   void OnAsyncCallStatusWithData(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     int async_id = 0;
     bool return_status = false;
-    uint8* return_data_buffer = NULL;
+    const uint8* return_data_buffer = NULL;
     size_t return_data_length = 0;
     if (!reader.PopInt32(&async_id) ||
         !reader.PopBool(&return_status) ||
         !reader.PopArrayOfBytes(&return_data_buffer, &return_data_length)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
     if (!async_call_status_data_handler_.is_null()) {
-      std::string return_data(reinterpret_cast<char*>(return_data_buffer),
+      std::string return_data(reinterpret_cast<const char*>(return_data_buffer),
                               return_data_length);
       async_call_status_data_handler_.Run(async_id, return_status, return_data);
     }
   }
 
   // Handles the result of signal connection setup.
   void OnSignalConnected(const std::string& interface,
                          const std::string& signal,
                          bool succeeded) {
     LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " " <<
@@ skipping 26 matching lines @@
   return new CryptohomeClientImpl();
 }
 
 // static
 std::string CryptohomeClient::GetStubSanitizedUsername(
     const std::string& username) {
   return username + kUserIdStubHashSuffix;
 }
 
 }  // namespace chromeos