chromeos: Convert D-Bus client classes' callback arguments to const reference

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/message_loop.h"
 #include "chromeos/dbus/blocking_method_caller.h"
 #include "dbus/bus.h"
@@ skipping 24 matching lines @@
     proxy_->ConnectToSignal(
         cryptohome::kCryptohomeInterface,
         cryptohome::kSignalAsyncCallStatus,
         base::Bind(&CryptohomeClientImpl::OnAsyncCallStatus,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&CryptohomeClientImpl::OnSignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // CryptohomeClient override.
-  virtual void SetAsyncCallStatusHandler(AsyncCallStatusHandler handler)
+  virtual void SetAsyncCallStatusHandler(const AsyncCallStatusHandler& handler)
       OVERRIDE {
     async_call_status_handler_ = handler;
   }
 
   // CryptohomeClient override.
   virtual void ResetAsyncCallStatusHandler() OVERRIDE {
     async_call_status_handler_.Reset();
   }
 
   // CryptohomeClient override.
   virtual bool IsMounted(bool* is_mounted) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeIsMounted);
     return CallBoolMethodAndBlock(&method_call, is_mounted);
   }
 
   // CryptohomeClient override.
   virtual bool Unmount(bool *success) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeUnmount);
     return CallBoolMethodAndBlock(&method_call, success);
   }
 
   // CryptohomeClient override.
   virtual void AsyncCheckKey(const std::string& username,
                              const std::string& key,
-                             AsyncMethodCallback callback) OVERRIDE {
+                             const AsyncMethodCallback& callback) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeAsyncCheckKey);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     writer.AppendString(key);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncMigrateKey(const std::string& username,
                                const std::string& from_key,
                                const std::string& to_key,
-                               AsyncMethodCallback callback) OVERRIDE {
+                               const AsyncMethodCallback& callback) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeAsyncMigrateKey);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     writer.AppendString(from_key);
     writer.AppendString(to_key);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncRemove(const std::string& username,
-                           AsyncMethodCallback callback) OVERRIDE {
+                           const AsyncMethodCallback& callback) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeAsyncRemove);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual bool GetSystemSalt(std::vector<uint8>* salt) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeGetSystemSalt);
     scoped_ptr<dbus::Response> response(
         blocking_method_caller_.CallMethodAndBlock(&method_call));
     if (!response.get())
       return false;
     dbus::MessageReader reader(response.get());
     uint8* bytes = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length))
       return false;
     salt->assign(bytes, bytes + length);
     return true;
   }
 
   // CryptohomeClient override.
   virtual void AsyncMount(const std::string& username,
                           const std::string& key,
                           const bool create_if_missing,
-                          AsyncMethodCallback callback) OVERRIDE {
+                          const AsyncMethodCallback& callback) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeAsyncMount);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     writer.AppendString(key);
     writer.AppendBool(create_if_missing);
     writer.AppendBool(false);  // deprecated_replace_tracked_subdirectories
     // deprecated_tracked_subdirectories
     writer.AppendArrayOfStrings(std::vector<std::string>());
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
-  virtual void AsyncMountGuest(AsyncMethodCallback callback) OVERRIDE {
+  virtual void AsyncMountGuest(const AsyncMethodCallback& callback) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeAsyncMountGuest);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual bool TpmIsReady(bool* ready) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeTpmIsReady);
     return CallBoolMethodAndBlock(&method_call, ready);
   }
 
   // CryptohomeClient override.
-  virtual void TpmIsEnabled(BoolMethodCallback callback) OVERRIDE {
+  virtual void TpmIsEnabled(const BoolMethodCallback& callback) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call, cryptohome::kCryptohomeTpmIsEnabled);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &CryptohomeClientImpl::OnBoolMethod,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   // CryptohomeClient override.
@@ skipping 41 matching lines @@
   // CryptohomeClient override.
   virtual bool TpmClearStoredPassword() OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call,
                            cryptohome::kCryptohomeTpmClearStoredPassword);
     scoped_ptr<dbus::Response> response(
         blocking_method_caller_.CallMethodAndBlock(&method_call));
     return response.get() != NULL;
   }
 
   // CryptohomeClient override.
-  virtual void Pkcs11IsTpmTokenReady(BoolMethodCallback callback)
+  virtual void Pkcs11IsTpmTokenReady(const BoolMethodCallback& callback)
       OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call,
                            cryptohome::kCryptohomePkcs11IsTpmTokenReady);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &CryptohomeClientImpl::OnBoolMethod,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   // CryptohomeClient override.
-  virtual void Pkcs11GetTpmTokenInfo(Pkcs11GetTpmTokenInfoCallback callback)
-      OVERRIDE {
+  virtual void Pkcs11GetTpmTokenInfo(
+      const Pkcs11GetTpmTokenInfoCallback& callback) OVERRIDE {
     INITIALIZE_METHOD_CALL(method_call,
                            cryptohome::kCryptohomePkcs11GetTpmTokenInfo);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &CryptohomeClientImpl::OnPkcs11GetTpmTokenInfo,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
@@ skipping 55 matching lines @@
   // CryptohomeClient override.
   virtual bool InstallAttributesIsFirstInstall(bool* is_first_install) OVERRIDE
   {
     INITIALIZE_METHOD_CALL(
         method_call, cryptohome::kCryptohomeInstallAttributesIsFirstInstall);
     return CallBoolMethodAndBlock(&method_call, is_first_install);
   }
 
  private:
   // Handles the result of AsyncXXX methods.
-  void OnAsyncMethodCall(AsyncMethodCallback callback,
+  void OnAsyncMethodCall(const AsyncMethodCallback& callback,
                          dbus::Response* response) {
     if (!response)
       return;
     dbus::MessageReader reader(response);
     int async_id = 0;
     if (!reader.PopInt32(&async_id)) {
       LOG(ERROR) << "Invalid response: " << response->ToString();
       return;
     }
     callback.Run(async_id);
   }
 
   // Calls a method with a bool value reult and block.
   bool CallBoolMethodAndBlock(dbus::MethodCall* method_call,
                               bool* result) {
     scoped_ptr<dbus::Response> response(
         blocking_method_caller_.CallMethodAndBlock(method_call));
     if (!response.get())
       return false;
     dbus::MessageReader reader(response.get());
     return reader.PopBool(result);
   }
 
   // Handles responses for methods with a bool value result.
-  void OnBoolMethod(BoolMethodCallback callback,
+  void OnBoolMethod(const BoolMethodCallback& callback,
                     dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false);
       return;
     }
     dbus::MessageReader reader(response);
     bool result = false;
     if (!reader.PopBool(&result)) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false);
       return;
     }
     callback.Run(DBUS_METHOD_CALL_SUCCESS, result);
   }
 
   // Handles responses for Pkcs11GetTpmtTokenInfo.
-  void OnPkcs11GetTpmTokenInfo(Pkcs11GetTpmTokenInfoCallback callback,
+  void OnPkcs11GetTpmTokenInfo(const Pkcs11GetTpmTokenInfoCallback& callback,
                                dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string());
       return;
     }
     dbus::MessageReader reader(response);
     std::string label;
     std::string user_pin;
     if (!reader.PopString(&label) || !reader.PopString(&user_pin)) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string());
@@ skipping 40 matching lines @@
   CryptohomeClientStubImpl()
       : weak_ptr_factory_(this),
         async_call_id_(1),
         tpm_is_ready_counter_(0),
         locked_(false) {
   }
 
   virtual ~CryptohomeClientStubImpl() {}
 
   // CryptohomeClient override.
-  virtual void SetAsyncCallStatusHandler(AsyncCallStatusHandler handler)
+  virtual void SetAsyncCallStatusHandler(const AsyncCallStatusHandler& handler)
       OVERRIDE {
     async_call_status_handler_ = handler;
   }
 
   // CryptohomeClient override.
   virtual void ResetAsyncCallStatusHandler() OVERRIDE {
     async_call_status_handler_.Reset();
   }
 
   // CryptohomeClient override.
   virtual bool IsMounted(bool* is_mounted) OVERRIDE {
     *is_mounted = true;
     return true;
   }
 
   // CryptohomeClient override.
   virtual bool Unmount(bool* success) OVERRIDE {
     *success = true;
     return true;
   }
 
   // CryptohomeClient override.
   virtual void AsyncCheckKey(const std::string& username,
                              const std::string& key,
-                             AsyncMethodCallback callback) OVERRIDE {
+                             const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback);
   }
 
   // CryptohomeClient override.
   virtual void AsyncMigrateKey(const std::string& username,
                                const std::string& from_key,
                                const std::string& to_key,
-                               AsyncMethodCallback callback) OVERRIDE {
+                               const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback);
   }
 
   // CryptohomeClient override.
   virtual void AsyncRemove(const std::string& username,
-                           AsyncMethodCallback callback) OVERRIDE {
+                           const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback);
   }
 
   // CryptohomeClient override.
   virtual bool GetSystemSalt(std::vector<uint8>* salt) OVERRIDE {
     const char kStubSystemSalt[] = "stub_system_salt";
     salt->assign(kStubSystemSalt,
                  kStubSystemSalt + arraysize(kStubSystemSalt));
     return true;
   }
 
   // CryptohomeClient override.
   virtual void AsyncMount(const std::string& username,
                           const std::string& key,
                           const bool create_if_missing,
-                          AsyncMethodCallback callback) OVERRIDE {
+                          const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback);
   }
 
   // CryptohomeClient override.
-  virtual void AsyncMountGuest(AsyncMethodCallback callback) OVERRIDE {
+  virtual void AsyncMountGuest(const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback);
   }
 
   // CryptohomeClient override.
   virtual bool TpmIsReady(bool* ready) OVERRIDE {
     *ready = (tpm_is_ready_counter_++ > 20);
     return true;
   }
 
   // CryptohomeClient override.
-  virtual void TpmIsEnabled(BoolMethodCallback callback) OVERRIDE {
+  virtual void TpmIsEnabled(const BoolMethodCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual bool CallTpmIsEnabledAndBlock(bool* enabled) OVERRIDE {
     *enabled = true;
     return true;
   }
 
@@ skipping 16 matching lines @@
     return true;
   }
 
   // CryptohomeClient override.
   virtual bool TpmCanAttemptOwnership() OVERRIDE { return true; }
 
   // CryptohomeClient override.
   virtual bool TpmClearStoredPassword() OVERRIDE { return true; }
 
   // CryptohomeClient override.
-  virtual void Pkcs11IsTpmTokenReady(BoolMethodCallback callback) OVERRIDE {
+  virtual void Pkcs11IsTpmTokenReady(
+      const BoolMethodCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual void Pkcs11GetTpmTokenInfo(
-      Pkcs11GetTpmTokenInfoCallback callback) OVERRIDE {
+      const Pkcs11GetTpmTokenInfoCallback& callback) OVERRIDE {
     const char kStubLabel[] = "Stub TPM Token";
     const char kStubUserPin[] = "012345";
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, kStubLabel,
                               kStubUserPin));
   }
 
   // CryptohomeClient override.
   virtual bool InstallAttributesGet(const std::string& name,
                                     std::vector<uint8>* value,
@@ skipping 38 matching lines @@
 
   // CryptohomeClient override.
   virtual bool InstallAttributesIsFirstInstall(bool* is_first_install) OVERRIDE
   {
     *is_first_install = !locked_;
     return true;
   }
 
  private:
   // Posts tasks which return fake results to the UI thread.
-  void ReturnAsyncMethodResult(AsyncMethodCallback callback) {
+  void ReturnAsyncMethodResult(const AsyncMethodCallback& callback) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&CryptohomeClientStubImpl::ReturnAsyncMethodResultInternal,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   // This method is used to implement ReturnAsyncMethodResult.
-  void ReturnAsyncMethodResultInternal(AsyncMethodCallback callback) {
+  void ReturnAsyncMethodResultInternal(const AsyncMethodCallback& callback) {
     callback.Run(async_call_id_);
     if (!async_call_status_handler_.is_null()) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(async_call_status_handler_,
                      async_call_id_,
                      true,
                      cryptohome::MOUNT_ERROR_NONE));
     }
     ++async_call_id_;
@@ skipping 21 matching lines @@
 // static
 CryptohomeClient* CryptohomeClient::Create(DBusClientImplementationType type,
                                            dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new CryptohomeClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new CryptohomeClientStubImpl();
 }
 
 }  // namespace chromeos