Misc refactoring of SessionManagerClient.

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 133 matching lines @@
   } else {
     LOG(ERROR) << "Invalid method_name: " << method_name;
   }
 }
 
 }  // namespace
 
 // The SessionManagerClient implementation used in production.
 class SessionManagerClientImpl : public SessionManagerClient {
  public:
-  SessionManagerClientImpl()
-      : session_manager_proxy_(NULL),
-        screen_is_locked_(false),
-        weak_ptr_factory_(this) {}
+  SessionManagerClientImpl() : weak_ptr_factory_(this) {}
 
-  ~SessionManagerClientImpl() override {}
+  ~SessionManagerClientImpl() override = default;
 
   // SessionManagerClient overrides:
   void SetStubDelegate(StubDelegate* delegate) override {
     // Do nothing; this isn't a stub implementation.
   }
 
   void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
   }
 
@@ skipping 28 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void StartSession(const cryptohome::Identification& cryptohome_id) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerStartSession);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(cryptohome_id.id());
     writer.AppendString("");  // Unique ID is deprecated
     session_manager_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&SessionManagerClientImpl::OnStartSession,
-                   weak_ptr_factory_.GetWeakPtr()));
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   void StopSession() override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerStopSession);
     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()));
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   void StartDeviceWipe() override {
-    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
-                                 login_manager::kSessionManagerStartDeviceWipe);
-    session_manager_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&SessionManagerClientImpl::OnDeviceWipe,
-                   weak_ptr_factory_.GetWeakPtr()));
+    SimpleMethodCallToSessionManager(
+        login_manager::kSessionManagerStartDeviceWipe);
   }
 
   void RequestLockScreen() override {
     SimpleMethodCallToSessionManager(login_manager::kSessionManagerLockScreen);
   }
 
   void NotifyLockScreenShown() override {
     SimpleMethodCallToSessionManager(
         login_manager::kSessionManagerHandleLockScreenShown);
   }
@@ skipping 96 matching lines @@
   void StoreDevicePolicy(const std::string& policy_blob,
                          const StorePolicyCallback& callback) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerStorePolicy);
     dbus::MessageWriter writer(&method_call);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
         reinterpret_cast<const uint8_t*>(policy_blob.data()),
         policy_blob.size());
     session_manager_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&SessionManagerClientImpl::OnStorePolicy,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   login_manager::kSessionManagerStorePolicy,
-                   callback));
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&SessionManagerClientImpl::OnNoOutputParamResponse,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void StorePolicyForUser(const cryptohome::Identification& cryptohome_id,
                           const std::string& policy_blob,
                           const StorePolicyCallback& callback) override {
     CallStorePolicyByUsername(login_manager::kSessionManagerStorePolicyForUser,
                               cryptohome_id.id(), policy_blob, callback);
   }
 
   void StoreDeviceLocalAccountPolicy(
@@ skipping 67 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(), callback),
         base::Bind(&SessionManagerClientImpl::OnStartArcInstanceFailed,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void StopArcInstance(const ArcCallback& callback) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerStopArcInstance);
     session_manager_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&SessionManagerClientImpl::OnArcMethod,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   login_manager::kSessionManagerStopArcInstance, callback));
+        base::Bind(&SessionManagerClientImpl::OnNoOutputParamResponse,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void SetArcCpuRestriction(
       login_manager::ContainerCpuRestrictionState restriction_state,
       const ArcCallback& callback) override {
     dbus::MethodCall method_call(
         login_manager::kSessionManagerInterface,
         login_manager::kSessionManagerSetArcCpuRestriction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint32(restriction_state);
     session_manager_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&SessionManagerClientImpl::OnArcMethod,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   login_manager::kSessionManagerSetArcCpuRestriction,
-                   callback));
+        base::Bind(&SessionManagerClientImpl::OnNoOutputParamResponse,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void EmitArcBooted(const cryptohome::Identification& cryptohome_id,
                      const ArcCallback& callback) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerEmitArcBooted);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(cryptohome_id.id());
     session_manager_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&SessionManagerClientImpl::OnArcMethod,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   login_manager::kSessionManagerEmitArcBooted, callback));
+        base::Bind(&SessionManagerClientImpl::OnNoOutputParamResponse,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void GetArcStartTime(const GetArcStartTimeCallback& callback) override {
     dbus::MethodCall method_call(
         login_manager::kSessionManagerInterface,
         login_manager::kSessionManagerGetArcStartTimeTicks);
 
     session_manager_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnGetArcStartTime,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void RemoveArcData(const cryptohome::Identification& cryptohome_id,
                      const ArcCallback& callback) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerRemoveArcData);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(cryptohome_id.id());
     session_manager_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&SessionManagerClientImpl::OnArcMethod,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   login_manager::kSessionManagerRemoveArcData, callback));
+        base::Bind(&SessionManagerClientImpl::OnNoOutputParamResponse,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
  protected:
   void Init(dbus::Bus* bus) override {
     session_manager_proxy_ = bus->GetObjectProxy(
         login_manager::kSessionManagerServiceName,
         dbus::ObjectPath(login_manager::kSessionManagerServicePath));
     blocking_method_caller_.reset(
         new BlockingMethodCaller(bus, session_manager_proxy_));
 
@@ skipping 40 matching lines @@
   // response.
   void SimpleMethodCallToSessionManager(const std::string& method_name) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
+  // Calls given callback (if non-null), with the |success| boolean
+  // representing the dbus call was successful or not.
+  void OnNoOutputParamResponse(
+      const base::Callback<void(bool success)>& callback,
+      dbus::Response* response) {
+    if (!callback.is_null())
+      callback.Run(response != nullptr);
+  }
+
   // Helper for RetrieveDeviceLocalAccountPolicy and RetrievePolicyForUser.
   void CallRetrievePolicyByUsername(const std::string& method_name,
                                     const std::string& account_id,
                                     const RetrievePolicyCallback& callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(account_id);
     session_manager_proxy_->CallMethodWithErrorCallback(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
@@ skipping 36 matching lines @@
                                  const StorePolicyCallback& callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(account_id);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
         reinterpret_cast<const uint8_t*>(policy_blob.data()),
         policy_blob.size());
     session_manager_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(
-            &SessionManagerClientImpl::OnStorePolicy,
-            weak_ptr_factory_.GetWeakPtr(),
-            method_name,
-            callback));
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&SessionManagerClientImpl::OnNoOutputParamResponse,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   // Called when kSessionManagerRestartJob method is complete.
   void OnRestartJob(const VoidDBusMethodCallback& callback,
                     dbus::Response* response) {
     LOG_IF(ERROR, !response)
         << "Failed to call "
         << login_manager::kSessionManagerRestartJob;
     callback.Run(response ? DBUS_METHOD_CALL_SUCCESS
                           : DBUS_METHOD_CALL_FAILURE);
   }
 
-  // Called when kSessionManagerStartSession method is complete.
-  void OnStartSession(dbus::Response* response) {
-    LOG_IF(ERROR, !response)
-        << "Failed to call "
-        << login_manager::kSessionManagerStartSession;
-  }
-
-  // Called when kSessionManagerStopSession method is complete.
-  void OnStopSession(dbus::Response* response) {
-    LOG_IF(ERROR, !response)
-        << "Failed to call "
-        << login_manager::kSessionManagerStopSession;
-  }
-
-  // Called when kSessionManagerStopSession method is complete.
-  void OnDeviceWipe(dbus::Response* response) {
-    LOG_IF(ERROR, !response)
-        << "Failed to call "
-        << login_manager::kSessionManagerStartDeviceWipe;
-  }
-
   // Called when kSessionManagerRetrieveActiveSessions method is complete.
   void OnRetrieveActiveSessions(const std::string& method_name,
                                 const ActiveSessionsCallback& callback,
                                 dbus::Response* response) {
     ActiveSessionsMap sessions;
     bool success = false;
     if (!response) {
-      LOG(ERROR) << "Failed to call " << method_name;
       callback.Run(sessions, success);
       return;
     }
 
     dbus::MessageReader reader(response);
-    dbus::MessageReader array_reader(NULL);
+    dbus::MessageReader array_reader(nullptr);
 
     if (!reader.PopArray(&array_reader)) {
       LOG(ERROR) << method_name << " response is incorrect: "
                  << response->ToString();
     } else {
       while (array_reader.HasMoreData()) {
-        dbus::MessageReader dict_entry_reader(NULL);
+        dbus::MessageReader dict_entry_reader(nullptr);
         std::string key;
         std::string value;
         if (!array_reader.PopDictEntry(&dict_entry_reader) ||
             !dict_entry_reader.PopString(&key) ||
             !dict_entry_reader.PopString(&value)) {
           LOG(ERROR) << method_name << " response is incorrect: "
                      << response->ToString();
         } else {
           sessions[cryptohome::Identification::FromString(key)] = value;
         }
       }
       success = true;
     }
     callback.Run(sessions, success);
   }
 
   void ExtractString(const std::string& method_name,
                      dbus::Response* response,
                      std::string* extracted) {
     if (!response) {
       LOG(ERROR) << "Failed to call " << method_name;
       return;
     }
     dbus::MessageReader reader(response);
-    const uint8_t* values = NULL;
+    const uint8_t* values = nullptr;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&values, &length)) {
       LOG(ERROR) << "Invalid response: " << response->ToString();
       return;
     }
     // static_cast does not work due to signedness.
     extracted->assign(reinterpret_cast<const char*>(values), length);
   }
 
   // Called when kSessionManagerRetrievePolicy or
@@ skipping 13 matching lines @@
   void OnRetrievePolicyError(const std::string& method_name,
                              const RetrievePolicyCallback& callback,
                              dbus::ErrorResponse* response) {
     RetrievePolicyResponseType response_type =
         GetResponseTypeBasedOnError(response->GetErrorName());
     callback.Run(std::string(), response_type);
 
     LogPolicyResponseUma(method_name, response_type);
   }
 
-  // Called when kSessionManagerStorePolicy or kSessionManagerStorePolicyForUser
-  // method is complete.
-  void OnStorePolicy(const std::string& method_name,
-                     const StorePolicyCallback& callback,
-                     dbus::Response* response) {
-    bool success = response != nullptr;
-    LOG_IF(ERROR, !success) << "Failed to call " << method_name;
-    callback.Run(success);
-  }
-
   // Called when the owner key set signal is received.
   void OwnerKeySetReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     std::string result_string;
     if (!reader.PopString(&result_string)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
     const bool success = base::StartsWith(result_string, "success",
                                           base::CompareCase::INSENSITIVE_ASCII);
@@ skipping 42 matching lines @@
   void SignalConnected(const std::string& interface_name,
                        const std::string& signal_name,
                        bool success) {
     LOG_IF(ERROR, !success) << "Failed to connect to " << signal_name;
   }
 
   // Called when kSessionManagerGetServerBackedStateKeys method is complete.
   void OnGetServerBackedStateKeys(const StateKeysCallback& callback,
                                   dbus::Response* response) {
     std::vector<std::string> state_keys;
-    if (!response) {
-      LOG(ERROR) << "Failed to call "
-                 << login_manager::kSessionManagerGetServerBackedStateKeys;
-    } else {
+    if (response) {
       dbus::MessageReader reader(response);
-      dbus::MessageReader array_reader(NULL);
+      dbus::MessageReader array_reader(nullptr);
 
       if (!reader.PopArray(&array_reader)) {
         LOG(ERROR) << "Bad response: " << response->ToString();
       } else {
         while (array_reader.HasMoreData()) {
-          const uint8_t* data = NULL;
+          const uint8_t* data = nullptr;
           size_t size = 0;
           if (!array_reader.PopArrayOfBytes(&data, &size)) {
             LOG(ERROR) << "Bad response: " << response->ToString();
             state_keys.clear();
             break;
           }
-          state_keys.push_back(
-              std::string(reinterpret_cast<const char*>(data), size));
+          state_keys.emplace_back(reinterpret_cast<const char*>(data), size);
         }
       }
     }
 
     if (!callback.is_null())
       callback.Run(state_keys);
   }
 
   // Called when kSessionManagerCheckArcAvailability method is complete.
   void OnCheckArcAvailability(const ArcCallback& callback,
                               dbus::Response* response) {
     bool available = false;
-    if (!response) {
-      LOG(ERROR) << "Failed to call "
-                 << login_manager::kSessionManagerCheckArcAvailability;
-    } else {
+    if (response) {
       dbus::MessageReader reader(response);
       if (!reader.PopBool(&available))
         LOG(ERROR) << "Invalid response: " << response->ToString();
     }
     if (!callback.is_null())
       callback.Run(available);
   }
 
   void OnGetArcStartTime(const GetArcStartTimeCallback& callback,
                          dbus::Response* response) {
     bool success = false;
     base::TimeTicks arc_start_time;
-    if (!response) {
-      LOG(ERROR) << "Failed to call "
-                 << login_manager::kSessionManagerGetArcStartTimeTicks;
-    } else {
+    if (response) {
       dbus::MessageReader reader(response);
       int64_t ticks = 0;
       if (reader.PopInt64(&ticks)) {
         success = true;
         arc_start_time = base::TimeTicks::FromInternalValue(ticks);
       } else {
         LOG(ERROR) << "Invalid response: " << response->ToString();
       }
     }
     callback.Run(success, arc_start_time);
   }
 
-  // Called when kSessionManagerStartArcInstance or
-  // kSessionManagerStopArcInstance methods complete.
-  void OnArcMethod(const std::string& method_name,
-                   const ArcCallback& callback,
-                   dbus::Response* response) {
-    bool success = false;
-    if (!response) {
-      LOG(ERROR) << "Failed to call " << method_name;
-    } else {
-      success = true;
-    }
-
-    if (!callback.is_null())
-      callback.Run(success);
-  }
-
   void OnStartArcInstanceSucceeded(const StartArcInstanceCallback& callback,
                                    dbus::Response* response) {
     if (!callback.is_null())
       callback.Run(StartArcInstanceResult::SUCCESS);
   }
 
   void OnStartArcInstanceFailed(const StartArcInstanceCallback& callback,
                                 dbus::ErrorResponse* response) {
     LOG(ERROR) << "Failed to call StartArcInstance: "
                << (response ? response->ToString() : "(null)");
     if (!callback.is_null()) {
       callback.Run(response && response->GetErrorName() ==
                                    login_manager::dbus_error::kLowFreeDisk
                        ? StartArcInstanceResult::LOW_FREE_DISK_SPACE
                        : StartArcInstanceResult::UNKNOWN_ERROR);
     }
   }
 
-  dbus::ObjectProxy* session_manager_proxy_;
+  dbus::ObjectProxy* session_manager_proxy_ = nullptr;
   std::unique_ptr<BlockingMethodCaller> blocking_method_caller_;
   base::ObserverList<Observer> observers_;
 
   // Most recent screen-lock state received from session_manager.
-  bool screen_is_locked_;
+  bool screen_is_locked_ = false;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<SessionManagerClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionManagerClientImpl);
 };
 
 // The SessionManagerClient implementation used on Linux desktop,
 // which does nothing.
 class SessionManagerClientStubImpl : public SessionManagerClient {
  public:
-  SessionManagerClientStubImpl() : delegate_(NULL), screen_is_locked_(false) {}
-  ~SessionManagerClientStubImpl() override {}
+  SessionManagerClientStubImpl() = default;
+  ~SessionManagerClientStubImpl() override = default;
 
   // SessionManagerClient overrides
   void Init(dbus::Bus* bus) override {}
   void SetStubDelegate(StubDelegate* delegate) override {
     delegate_ = delegate;
   }
   void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
   }
   void RemoveObserver(Observer* observer) override {
@@ skipping 199 matching lines @@
 
   void RemoveArcData(const cryptohome::Identification& cryptohome_id,
                      const ArcCallback& callback) override {
     if (callback.is_null())
       return;
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, false));
   }
 
  private:
-  StubDelegate* delegate_;  // Weak pointer; may be NULL.
+  StubDelegate* delegate_ = nullptr;  // Weak pointer; may be nullptr.
   base::ObserverList<Observer> observers_;
   std::string device_policy_;
-  bool screen_is_locked_;
+  bool screen_is_locked_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(SessionManagerClientStubImpl);
 };
 
 SessionManagerClient::SessionManagerClient() {
 }
 
 SessionManagerClient::~SessionManagerClient() {
 }
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl();
   DCHECK_EQ(FAKE_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos