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

chromeos/dbus/session_manager_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/session_manager_client.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/string_util.h"
 #include "dbus/bus.h"
@@ skipping 116 matching lines @@
     dbus::MessageWriter writer(&method_call);
     writer.AppendString("");  // Unique ID is deprecated
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnStopSession,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // SessionManagerClient override.
-  virtual void RetrieveDevicePolicy(RetrievePolicyCallback callback) OVERRIDE {
+  virtual void RetrieveDevicePolicy(
+      const RetrievePolicyCallback& callback) OVERRIDE {
     CallRetrievePolicy(login_manager::kSessionManagerRetrievePolicy,
                        callback);
   }
 
   // SessionManagerClient override.
-  virtual void RetrieveUserPolicy(RetrievePolicyCallback callback) OVERRIDE {
+  virtual void RetrieveUserPolicy(
+      const RetrievePolicyCallback& callback) OVERRIDE {
     CallRetrievePolicy(login_manager::kSessionManagerRetrieveUserPolicy,
                        callback);
   }
 
   // SessionManagerClient override.
   virtual void StoreDevicePolicy(const std::string& policy_blob,
-                                 StorePolicyCallback callback) OVERRIDE {
+                                 const StorePolicyCallback& callback) OVERRIDE {
     CallStorePolicy(login_manager::kSessionManagerStorePolicy,
                     policy_blob, callback);
   }
 
   // SessionManagerClient override.
   virtual void StoreUserPolicy(const std::string& policy_blob,
-                               StorePolicyCallback callback) OVERRIDE {
+                               const StorePolicyCallback& callback) OVERRIDE {
     CallStorePolicy(login_manager::kSessionManagerStoreUserPolicy,
                     policy_blob, callback);
   }
 
  private:
   // Helper for Retrieve{User,Device}Policy.
   virtual void CallRetrievePolicy(const std::string& method_name,
-                                  RetrievePolicyCallback callback) {
+                                  const RetrievePolicyCallback& callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnRetrievePolicy,
                    weak_ptr_factory_.GetWeakPtr(),
                    method_name,
                    callback));
   }
 
   // Helper for Store{User,Device}Policy.
   virtual void CallStorePolicy(const std::string& method_name,
                                const std::string& policy_blob,
-                               StorePolicyCallback callback) {
+                               const StorePolicyCallback& callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     dbus::MessageWriter writer(&method_call);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
         reinterpret_cast<const uint8*>(policy_blob.data()), policy_blob.size());
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnStorePolicy,
@@ skipping 40 matching lines @@
   // Called when kSessionManagerStopSession method is complete.
   void OnStopSession(dbus::Response* response) {
     LOG_IF(ERROR, !response)
         << "Failed to call "
         << login_manager::kSessionManagerStopSession;
   }
 
   // Called when kSessionManagerRetrievePolicy or
   // kSessionManagerRetrieveUserPolicy  method is complete.
   void OnRetrievePolicy(const std::string& method_name,
-                        RetrievePolicyCallback callback,
+                        const RetrievePolicyCallback& callback,
                         dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to call " << method_name;
       callback.Run("");
       return;
     }
     dbus::MessageReader reader(response);
     uint8* values = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&values, &length)) {
       LOG(ERROR) << "Invalid response: " << response->ToString();
       callback.Run("");
       return;
     }
     // static_cast does not work due to signedness.
     std::string serialized_proto(reinterpret_cast<char*>(values), length);
     callback.Run(serialized_proto);
   }
 
   // Called when kSessionManagerStorePolicy or kSessionManagerStoreUserPolicy
   // method is complete.
   void OnStorePolicy(const std::string& method_name,
-                     StorePolicyCallback callback,
+                     const StorePolicyCallback& callback,
                      dbus::Response* response) {
     bool success = false;
     if (!response) {
       LOG(ERROR) << "Failed to call " << method_name;
     } else {
       dbus::MessageReader reader(response);
       if (!reader.PopBool(&success))
         LOG(ERROR) << "Invalid response: " << response->ToString();
     }
     callback.Run(success);
@@ skipping 42 matching lines @@
 class SessionManagerClientStubImpl : public SessionManagerClient {
   // SessionManagerClient overrides.
   virtual void AddObserver(Observer* observer) OVERRIDE {}
   virtual void RemoveObserver(Observer* observer) OVERRIDE {}
   virtual void EmitLoginPromptReady() OVERRIDE {}
   virtual void EmitLoginPromptVisible() OVERRIDE {}
   virtual void RestartJob(int pid, const std::string& command_line) OVERRIDE {}
   virtual void RestartEntd() OVERRIDE {}
   virtual void StartSession(const std::string& user_email) OVERRIDE {}
   virtual void StopSession() OVERRIDE {}
-  virtual void RetrieveDevicePolicy(RetrievePolicyCallback callback) OVERRIDE {
+  virtual void RetrieveDevicePolicy(
+      const RetrievePolicyCallback& callback) OVERRIDE {
     callback.Run("");
   }
-  virtual void RetrieveUserPolicy(RetrievePolicyCallback callback) OVERRIDE {
+  virtual void RetrieveUserPolicy(
+      const RetrievePolicyCallback& callback) OVERRIDE {
     callback.Run("");
   }
   virtual void StoreDevicePolicy(const std::string& policy_blob,
-                                 StorePolicyCallback callback) OVERRIDE {
+                                 const StorePolicyCallback& callback) OVERRIDE {
     callback.Run(true);
   }
   virtual void StoreUserPolicy(const std::string& policy_blob,
-                               StorePolicyCallback callback) OVERRIDE {
+                               const StorePolicyCallback& callback) OVERRIDE {
     callback.Run(true);
   }
 };
 
 SessionManagerClient::SessionManagerClient() {
 }
 
 SessionManagerClient::~SessionManagerClient() {
 }
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos