Move free disk space check to session_manager.

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 18 matching lines @@
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
+// TODO(hidehiko): Share the constant between Chrome and ChromeOS.
+constexpr char kArcLowDiskError[] =
+    "org.chromium.SessionManagerInterface.LowFreeDisk";
+
 // Returns a location for |file| that is specific to the given |cryptohome_id|.
 // These paths will be relative to DIR_USER_POLICY_KEYS, and can be used only
 // to store stub files.
 base::FilePath GetUserFilePath(const cryptohome::Identification& cryptohome_id,
                                const char* file) {
   base::FilePath keys_path;
   if (!PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &keys_path))
     return base::FilePath();
   const std::string sanitized =
       CryptohomeClient::GetStubSanitizedUsername(cryptohome_id);
@@ skipping 254 matching lines @@
         login_manager::kSessionManagerCheckArcAvailability);
 
     session_manager_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnCheckArcAvailability,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void StartArcInstance(const cryptohome::Identification& cryptohome_id,
                         bool disable_boot_completed_broadcast,
-                        const ArcCallback& callback) override {
+                        const StartArcInstanceCallback& callback) override {
     dbus::MethodCall method_call(
         login_manager::kSessionManagerInterface,
         login_manager::kSessionManagerStartArcInstance);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(cryptohome_id.id());
     writer.AppendBool(disable_boot_completed_broadcast);
-    session_manager_proxy_->CallMethod(
+    session_manager_proxy_->CallMethodWithErrorCallback(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&SessionManagerClientImpl::OnArcMethod,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   login_manager::kSessionManagerStartArcInstance, callback));
+        base::Bind(&SessionManagerClientImpl::OnStartArcInstanceSucceeded,
+                   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));
@@ skipping 380 matching lines @@
     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() == kArcLowDiskError
+                       ? StartArcInstanceResult::LOW_FREE_DISK_SPACE
+                       : StartArcInstanceResult::UNKNOWN_ERROR);
+  }
+
   dbus::ObjectProxy* session_manager_proxy_;
   std::unique_ptr<BlockingMethodCaller> blocking_method_caller_;
   base::ObserverList<Observer> observers_;
 
   // Most recent screen-lock state received from session_manager.
   bool screen_is_locked_;
 
   // 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_;
@@ skipping 156 matching lines @@
     if (!callback.is_null())
       callback.Run(state_keys);
   }
 
   void CheckArcAvailability(const ArcCallback& callback) override {
     callback.Run(false);
   }
 
   void StartArcInstance(const cryptohome::Identification& cryptohome_id,
                         bool disable_boot_completed_broadcast,
-                        const ArcCallback& callback) override {
-    callback.Run(false);
+                        const StartArcInstanceCallback& callback) override {
+    callback.Run(StartArcInstanceResult::UNKNOWN_ERROR);
   }
 
   void PrioritizeArcInstance(const ArcCallback& callback) override {
     callback.Run(false);
   }
 
   void EmitArcBooted() override {}
 
   void StopArcInstance(const ArcCallback& callback) override {
     callback.Run(false);
@@ skipping 26 matching lines @@
 
 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