arc: Notify concierge to suspend/resume vm

This should be landed after http://crrev.com/c/2016802 which adds the concierge Suspend/Resume D-Bus methods.

Bug: b:140083246
Test: Suspend/resume DUT, previously playing YouTube video is paused on resume

Change-Id: I075e9e8c72698118f28aa9b798a733a89eb1ea4c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2016766Reviewed-by: Ryo Hashimoto <hashimoto@chromium.org>
Reviewed-by: Hidehiko Abe <hidehiko@chromium.org>
Commit-Queue: Alex Lau <alexlau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#742964}

chrome/browser/chromeos/arc/session/arc_service_launcher.cc

@@ -49,6 +49,7 @@
 #include "chrome/browser/chromeos/arc/user_session/arc_user_session_service.h"
 #include "chrome/browser/chromeos/arc/video/gpu_arc_video_service_host.h"
 #include "chrome/browser/chromeos/arc/wallpaper/arc_wallpaper_service.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_usb_host_permission_manager.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
@@ -208,7 +209,8 @@ void ArcServiceLauncher::OnPrimaryUserProfilePrepared(Profile* profile) {
   ArcOemCryptoBridge::GetForBrowserContext(profile);
   ArcPipBridge::GetForBrowserContext(profile);
   ArcPolicyBridge::GetForBrowserContext(profile);
-  ArcPowerBridge::GetForBrowserContext(profile);
+  ArcPowerBridge::GetForBrowserContext(profile)->SetUserIdHash(
+      chromeos::ProfileHelper::GetUserIdHashFromProfile(profile));
   ArcPrintService::GetForBrowserContext(profile);
   ArcPrintSpoolerBridge::GetForBrowserContext(profile);
   ArcProcessService::GetForBrowserContext(profile);

chromeos/dbus/concierge_client.cc

@@ -149,6 +149,18 @@ class ConciergeClientImpl : public ConciergeClient {
     CallMethod(concierge::kStopVmMethod, request, std::move(callback));
   }
 
+  void SuspendVm(
+      const concierge::SuspendVmRequest& request,
+      DBusMethodCallback<concierge::SuspendVmResponse> callback) override {
+    CallMethod(concierge::kSuspendVmMethod, request, std::move(callback));
+  }
+
+  void ResumeVm(
+      const concierge::ResumeVmRequest& request,
+      DBusMethodCallback<concierge::ResumeVmResponse> callback) override {
+    CallMethod(concierge::kResumeVmMethod, request, std::move(callback));
+  }
+
   void GetVmInfo(
       const concierge::GetVmInfoRequest& request,
       DBusMethodCallback<concierge::GetVmInfoResponse> callback) override {

chromeos/dbus/concierge_client.h

@@ -162,6 +162,18 @@ class COMPONENT_EXPORT(CHROMEOS_DBUS) ConciergeClient : public DBusClient {
       const vm_tools::concierge::StopVmRequest& request,
       DBusMethodCallback<vm_tools::concierge::StopVmResponse> callback) = 0;
 
+  // Suspends the named Termina VM if it is running.
+  // |callback| is called after the method call finishes.
+  virtual void SuspendVm(
+      const vm_tools::concierge::SuspendVmRequest& request,
+      DBusMethodCallback<vm_tools::concierge::SuspendVmResponse> callback) = 0;
+
+  // Resumes the named Termina VM if it is running.
+  // |callback| is called after the method call finishes.
+  virtual void ResumeVm(
+      const vm_tools::concierge::ResumeVmRequest& request,
+      DBusMethodCallback<vm_tools::concierge::ResumeVmResponse> callback) = 0;
+
   // Get VM Info.
   // |callback| is called after the method call finishes.
   virtual void GetVmInfo(

chromeos/dbus/fake_concierge_client.cc

@@ -179,6 +179,20 @@ void FakeConciergeClient::StopVm(
       FROM_HERE, base::BindOnce(std::move(callback), stop_vm_response_));
 }
 
+void FakeConciergeClient::SuspendVm(
+    const vm_tools::concierge::SuspendVmRequest& request,
+    DBusMethodCallback<vm_tools::concierge::SuspendVmResponse> callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), suspend_vm_response_));
+}
+
+void FakeConciergeClient::ResumeVm(
+    const vm_tools::concierge::ResumeVmRequest& request,
+    DBusMethodCallback<vm_tools::concierge::ResumeVmResponse> callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), resume_vm_response_));
+}
+
 void FakeConciergeClient::GetVmInfo(
     const vm_tools::concierge::GetVmInfoRequest& request,
     DBusMethodCallback<vm_tools::concierge::GetVmInfoResponse> callback) {
@@ -289,6 +303,12 @@ void FakeConciergeClient::InitializeProtoResponses() {
   stop_vm_response_.emplace();
   stop_vm_response_->set_success(true);
 
+  suspend_vm_response_.emplace();
+  suspend_vm_response_->set_success(true);
+
+  resume_vm_response_.emplace();
+  resume_vm_response_->set_success(true);
+
   get_vm_info_response_.emplace();
   get_vm_info_response_->set_success(true);
   get_vm_info_response_->mutable_vm_info()->set_seneschal_server_handle(1);

chromeos/dbus/fake_concierge_client.h

@@ -70,6 +70,12 @@ class COMPONENT_EXPORT(CHROMEOS_DBUS) FakeConciergeClient
   void StopVm(const vm_tools::concierge::StopVmRequest& request,
               DBusMethodCallback<vm_tools::concierge::StopVmResponse> callback)
       override;
+  void SuspendVm(const vm_tools::concierge::SuspendVmRequest& request,
+                 DBusMethodCallback<vm_tools::concierge::SuspendVmResponse>
+                     callback) override;
+  void ResumeVm(const vm_tools::concierge::ResumeVmRequest& request,
+                DBusMethodCallback<vm_tools::concierge::ResumeVmResponse>
+                    callback) override;
   void GetVmInfo(const vm_tools::concierge::GetVmInfoRequest& request,
                  DBusMethodCallback<vm_tools::concierge::GetVmInfoResponse>
                      callback) override;
@@ -281,6 +287,8 @@ class COMPONENT_EXPORT(CHROMEOS_DBUS) FakeConciergeClient
       list_vm_disks_response_;
   base::Optional<vm_tools::concierge::StartVmResponse> start_vm_response_;
   base::Optional<vm_tools::concierge::StopVmResponse> stop_vm_response_;
+  base::Optional<vm_tools::concierge::SuspendVmResponse> suspend_vm_response_;
+  base::Optional<vm_tools::concierge::ResumeVmResponse> resume_vm_response_;
   base::Optional<vm_tools::concierge::GetVmInfoResponse> get_vm_info_response_;
   base::Optional<vm_tools::concierge::GetVmEnterpriseReportingInfoResponse>
       get_vm_enterprise_reporting_info_response_;

components/arc/power/arc_power_bridge.cc

@@ -17,6 +17,7 @@
 #include "chromeos/dbus/power_manager/backlight.pb.h"
 #include "components/arc/arc_browser_context_keyed_service_factory_base.h"
 #include "components/arc/arc_service_manager.h"
+#include "components/arc/arc_util.h"
 #include "components/arc/session/arc_bridge_service.h"
 #include "content/public/browser/device_service.h"
 #include "mojo/public/cpp/bindings/remote.h"
@@ -133,6 +134,10 @@ ArcPowerBridge::~ArcPowerBridge() {
   arc_bridge_service_->power()->SetHost(nullptr);
 }
 
+void ArcPowerBridge::SetUserIdHash(const std::string& user_id_hash) {
+  user_id_hash_ = user_id_hash;
+}
+
 bool ArcPowerBridge::TriggerNotifyBrightnessTimerForTesting() {
   if (!notify_brightness_timer_.IsRunning())
     return false;
@@ -172,19 +177,66 @@ void ArcPowerBridge::SuspendImminent(
 
   auto token = base::UnguessableToken::Create();
   chromeos::PowerManagerClient::Get()->BlockSuspend(token, "ArcPowerBridge");
-  power_instance->Suspend(base::BindOnce(
-      [](base::UnguessableToken token) {
-        chromeos::PowerManagerClient::Get()->UnblockSuspend(token);
-      },
-      token));
+  power_instance->Suspend(base::BindOnce(&ArcPowerBridge::OnAndroidSuspendReady,
+                                         weak_ptr_factory_.GetWeakPtr(),
+                                         token));
+}
+
+void ArcPowerBridge::OnAndroidSuspendReady(base::UnguessableToken token) {
+  if (arc::IsArcVmEnabled()) {
+    vm_tools::concierge::SuspendVmRequest request;
+    request.set_name(kArcVmName);
+    request.set_owner_id(user_id_hash_);
+    chromeos::DBusThreadManager::Get()->GetConciergeClient()->SuspendVm(
+        request, base::BindOnce(&ArcPowerBridge::OnConciergeSuspendVmResponse,
+                                weak_ptr_factory_.GetWeakPtr(), token));
+    return;
+  }
+
+  chromeos::PowerManagerClient::Get()->UnblockSuspend(token);
+}
+
+void ArcPowerBridge::OnConciergeSuspendVmResponse(
+    base::UnguessableToken token,
+    base::Optional<vm_tools::concierge::SuspendVmResponse> reply) {
+  if (!reply.has_value())
+    LOG(ERROR) << "Failed to suspend arcvm, no reply received.";
+  else if (!reply.value().success())
+    LOG(ERROR) << "Failed to suspend arcvm: " << reply.value().failure_reason();
+  chromeos::PowerManagerClient::Get()->UnblockSuspend(token);
 }
 
 void ArcPowerBridge::SuspendDone(const base::TimeDelta& sleep_duration) {
+  if (arc::IsArcVmEnabled()) {
+    vm_tools::concierge::ResumeVmRequest request;
+    request.set_name(kArcVmName);
+    request.set_owner_id(user_id_hash_);
+    chromeos::DBusThreadManager::Get()->GetConciergeClient()->ResumeVm(
+        request, base::BindOnce(&ArcPowerBridge::OnConciergeResumeVmResponse,
+                                weak_ptr_factory_.GetWeakPtr()));
+    return;
+  }
+  DispatchAndroidResume();
+}
+
+void ArcPowerBridge::OnConciergeResumeVmResponse(
+    base::Optional<vm_tools::concierge::ResumeVmResponse> reply) {
+  if (!reply.has_value()) {
+    LOG(ERROR) << "Failed to resume arcvm, no reply received.";
+    return;
+  }
+  if (!reply.value().success()) {
+    LOG(ERROR) << "Failed to resume arcvm: " << reply.value().failure_reason();
+    return;
+  }
+  DispatchAndroidResume();
+}
+
+void ArcPowerBridge::DispatchAndroidResume() {
   mojom::PowerInstance* power_instance =
       ARC_GET_INSTANCE_FOR_METHOD(arc_bridge_service_->power(), Resume);
   if (!power_instance)
     return;
-
   power_instance->Resume();
 }
 

components/arc/power/arc_power_bridge.h

@@ -7,10 +7,12 @@
 
 #include <map>
 #include <memory>
+#include <string>
 
 #include "base/macros.h"
 #include "base/optional.h"
 #include "base/timer/timer.h"
+#include "chromeos/dbus/concierge_client.h"
 #include "chromeos/dbus/power/power_manager_client.h"
 #include "components/arc/mojom/power.mojom.h"
 #include "components/arc/session/connection_observer.h"
@@ -44,6 +46,8 @@ class ArcPowerBridge : public KeyedService,
                  ArcBridgeService* bridge_service);
   ~ArcPowerBridge() override;
 
+  void SetUserIdHash(const std::string& user_id_hash);
+
   // If |notify_brightness_timer_| is set, runs it and returns true. Returns
   // false otherwise.
   bool TriggerNotifyBrightnessTimerForTesting() WARN_UNUSED_RESULT;
@@ -86,10 +90,30 @@ class ArcPowerBridge : public KeyedService,
   // Called on PowerManagerClient::GetScreenBrightnessPercent() completion.
   void OnGetScreenBrightnessPercent(base::Optional<double> percent);
 
+  // Called by Android when ready to suspend.
+  void OnAndroidSuspendReady(base::UnguessableToken token);
+
+  // Called by ConciergeClient when a response has been receive for the
+  // SuspendVm D-Bus call.
+  void OnConciergeSuspendVmResponse(
+      base::UnguessableToken token,
+      base::Optional<vm_tools::concierge::SuspendVmResponse> reply);
+
+  // Called by ConciergeClient when a response has been receive for the
+  // ResumeVm D-Bus call.
+  void OnConciergeResumeVmResponse(
+      base::Optional<vm_tools::concierge::ResumeVmResponse> reply);
+
+  // Sends a PowerInstance::UpdateScreenBrightnessSettings mojo call to Android.
   void UpdateAndroidScreenBrightness(double percent);
 
+  // Sends a PowerInstance::Resume mojo call to Android.
+  void DispatchAndroidResume();
+
   ArcBridgeService* const arc_bridge_service_;  // Owned by ArcServiceManager.
 
+  std::string user_id_hash_;
+
   mojo::Remote<device::mojom::WakeLockProvider> wake_lock_provider_;
 
   // Used to track Android wake lock requests and acquire and release device