power, arc: add ArcPowerBridge

Using new functionality in PowerPolicyController, we can take
Chrome wake locks instead of powerd wake locks, so we don't
need to route requests through PowerManagerClient or use
dbus. ArcPowerBridge keeps track of the Chrome wake locks that
ARC has taken, and releases them when the instance stops to
prevent wake lock leaks.

BUG=b:24671115
TEST=run apps that use wake locks, check logs for policy changes

Review URL: https://codereview.chromium.org/1488343002

Cr-Commit-Position: refs/heads/master@{#366657}

6 files changed, 176 insertions, 0 deletions

diff --git a/components/arc/BUILD.gn b/components/arc/BUILD.gn
index b854d60..c5e7746 100644
--- a/components/arc/BUILD.gn
+++ b/components/arc/BUILD.gn
@@ -17,6 +17,8 @@ static_library("arc") {
     "input/arc_input_bridge.h",
     "input/arc_input_bridge_impl.cc",
     "input/arc_input_bridge_impl.h",
+    "power/arc_power_bridge.cc",
+    "power/arc_power_bridge.h",
     "settings/arc_settings_bridge.cc",
     "settings/arc_settings_bridge.h",
   ]
@@ -25,6 +27,7 @@ static_library("arc") {
     "//base",
     "//base:prefs",
     "//chromeos",
+    "//chromeos:power_manager_proto",
     "//ipc:ipc",
     "//ipc/mojo:mojo",
     "//third_party/mojo/src/mojo/edk/system",
diff --git a/components/arc/arc_bridge_service.h b/components/arc/arc_bridge_service.h
index 6e8c885..12aae9d 100644
--- a/components/arc/arc_bridge_service.h
+++ b/components/arc/arc_bridge_service.h
@@ -95,6 +95,19 @@ class ArcBridgeService : public ArcBridgeHost {
     virtual ~Observer() {}
   };
 
+  // Notifies power management-related events.
+  class PowerObserver {
+   public:
+    // Called whenever ARC requests a wake lock.
+    virtual void OnAcquireDisplayWakeLock(DisplayWakeLockType type) {}
+
+    // Called whenever ARC releases a wake lock.
+    virtual void OnReleaseDisplayWakeLock(DisplayWakeLockType type) {}
+
+   protected:
+    virtual ~PowerObserver() {}
+  };
+
   ~ArcBridgeService() override;
 
   // Gets the global instance of the ARC Bridge Service. This can only be
diff --git a/components/arc/arc_service_manager.cc b/components/arc/arc_service_manager.cc
index 68f01cb1..0e18308 100644
--- a/components/arc/arc_service_manager.cc
+++ b/components/arc/arc_service_manager.cc
@@ -9,6 +9,7 @@
 #include "components/arc/arc_bridge_bootstrap.h"
 #include "components/arc/arc_bridge_service_impl.h"
 #include "components/arc/input/arc_input_bridge.h"
+#include "components/arc/power/arc_power_bridge.h"
 #include "components/arc/settings/arc_settings_bridge.h"
 
 namespace arc {
@@ -27,6 +28,7 @@ ArcServiceManager::ArcServiceManager(
       arc_settings_bridge_(std::move(settings_bridge)) {
   DCHECK(!g_arc_service_manager);
   arc_input_bridge_ = ArcInputBridge::Create(arc_bridge_service_.get());
+  arc_power_bridge_.reset(new ArcPowerBridge(arc_bridge_service_.get()));
   g_arc_service_manager = this;
 
   arc_settings_bridge_->StartObservingBridgeServiceChanges();
diff --git a/components/arc/arc_service_manager.h b/components/arc/arc_service_manager.h
index 07d6273..0bc481f 100644
--- a/components/arc/arc_service_manager.h
+++ b/components/arc/arc_service_manager.h
@@ -14,6 +14,7 @@ namespace arc {
 class ArcBridgeService;
 class ArcInputBridge;
 class ArcSettingsBridge;
+class ArcPowerBridge;
 
 // Manages creation and destruction of services that communicate with the ARC
 // instance via the ArcBridgeService.
@@ -35,6 +36,7 @@ class ArcServiceManager {
   scoped_ptr<ArcBridgeService> arc_bridge_service_;
   scoped_ptr<ArcInputBridge> arc_input_bridge_;
   scoped_ptr<ArcSettingsBridge> arc_settings_bridge_;
+  scoped_ptr<ArcPowerBridge> arc_power_bridge_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcServiceManager);
 };
diff --git a/components/arc/power/arc_power_bridge.cc b/components/arc/power/arc_power_bridge.cc
new file mode 100644
index 0000000..b918147
--- /dev/null
+++ b/components/arc/power/arc_power_bridge.cc
@@ -0,0 +1,108 @@
+// Copyright 2015 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 "components/arc/power/arc_power_bridge.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "base/logging.h"
+#include "chromeos/dbus/power_policy_controller.h"
+#include "components/arc/arc_service_manager.h"
+
+namespace arc {
+
+ArcPowerBridge::ArcPowerBridge(ArcBridgeService* arc_bridge_service)
+    : arc_bridge_service_(arc_bridge_service), binding_(this) {
+  arc_bridge_service->AddObserver(this);
+  if (arc_bridge_service->power_instance())
+    OnPowerInstanceReady();
+}
+
+ArcPowerBridge::~ArcPowerBridge() {
+  arc_bridge_service_->RemoveObserver(this);
+  ReleaseAllDisplayWakeLocks();
+}
+
+void ArcPowerBridge::OnStateChanged(ArcBridgeService::State state) {
+  if (state == ArcBridgeService::State::STOPPING)
+    ReleaseAllDisplayWakeLocks();
+}
+
+void ArcPowerBridge::OnPowerInstanceReady() {
+  PowerInstance* power_instance = arc_bridge_service_->power_instance();
+  if (!power_instance) {
+    LOG(ERROR) << "OnPowerInstanceReady called, but no power instance found";
+    return;
+  }
+
+  PowerHostPtr host;
+  binding_.Bind(mojo::GetProxy(&host));
+  power_instance->Init(std::move(host));
+}
+
+void ArcPowerBridge::OnAcquireDisplayWakeLock(
+    DisplayWakeLockType type) {
+  if (!chromeos::PowerPolicyController::IsInitialized()) {
+    LOG(WARNING) << "PowerPolicyController is not available";
+    return;
+  }
+  chromeos::PowerPolicyController* controller =
+      chromeos::PowerPolicyController::Get();
+
+  int wake_lock_id = -1;
+  switch (type) {
+    case DISPLAY_WAKE_LOCK_TYPE_BRIGHT:
+      wake_lock_id = controller->AddScreenWakeLock(
+          chromeos::PowerPolicyController::REASON_OTHER, "ARC");
+      break;
+    case DISPLAY_WAKE_LOCK_TYPE_DIM:
+      wake_lock_id = controller->AddDimWakeLock(
+          chromeos::PowerPolicyController::REASON_OTHER, "ARC");
+      break;
+    default:
+      LOG(WARNING) << "Tried to take invalid wake lock type "
+                   << static_cast<int>(type);
+      return;
+  }
+  wake_locks_.insert(std::make_pair(type, wake_lock_id));
+}
+
+void ArcPowerBridge::OnReleaseDisplayWakeLock(
+    DisplayWakeLockType type) {
+  if (!chromeos::PowerPolicyController::IsInitialized()) {
+    LOG(WARNING) << "PowerPolicyController is not available";
+    return;
+  }
+  chromeos::PowerPolicyController* controller =
+      chromeos::PowerPolicyController::Get();
+
+  // From the perspective of the PowerPolicyController, all wake locks
+  // of a given type are equivalent, so it doesn't matter which one
+  // we pass to the controller here.
+  auto it = wake_locks_.find(type);
+  if (it == wake_locks_.end()) {
+    LOG(WARNING) << "Tried to release wake lock of type "
+                 << static_cast<int>(type) << " when none were taken";
+    return;
+  }
+  controller->RemoveWakeLock(it->second);
+  wake_locks_.erase(it);
+}
+
+void ArcPowerBridge::ReleaseAllDisplayWakeLocks() {
+  if (!chromeos::PowerPolicyController::IsInitialized()) {
+    LOG(WARNING) << "PowerPolicyController is not available";
+    return;
+  }
+  chromeos::PowerPolicyController* controller =
+      chromeos::PowerPolicyController::Get();
+
+  for (const auto& it : wake_locks_) {
+    controller->RemoveWakeLock(it.second);
+  }
+  wake_locks_.clear();
+}
+
+}  // namespace arc
diff --git a/components/arc/power/arc_power_bridge.h b/components/arc/power/arc_power_bridge.h
new file mode 100644
index 0000000..77c0263
--- /dev/null
+++ b/components/arc/power/arc_power_bridge.h
@@ -0,0 +1,48 @@
+// Copyright 2015 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.
+
+#ifndef COMPONENTS_ARC_POWER_ARC_POWER_SERVICE_H_
+#define COMPONENTS_ARC_POWER_ARC_POWER_SERVICE_H_
+
+#include <map>
+
+#include "base/macros.h"
+#include "components/arc/arc_bridge_service.h"
+#include "mojo/public/cpp/bindings/binding.h"
+
+namespace arc {
+
+// ARC Power Client sets power management policy based on requests from
+// ARC instances.
+class ArcPowerBridge : public ArcBridgeService::Observer,
+                       public PowerHost {
+ public:
+  explicit ArcPowerBridge(ArcBridgeService* arc_bridge_service);
+  ~ArcPowerBridge() override;
+
+  // ArcBridgeService::Observer overrides.
+  void OnStateChanged(ArcBridgeService::State state) override;
+  void OnPowerInstanceReady() override;
+
+  // PowerHost overrides.
+  void OnAcquireDisplayWakeLock(DisplayWakeLockType type) override;
+  void OnReleaseDisplayWakeLock(DisplayWakeLockType type) override;
+
+ private:
+  void ReleaseAllDisplayWakeLocks();
+
+  ArcBridgeService* arc_bridge_service_;  // weak
+
+  mojo::Binding<PowerHost> binding_;
+
+  // Stores a mapping of type -> wake lock ID for all wake locks
+  // held by ARC.
+  std::multimap<DisplayWakeLockType, int> wake_locks_;
+
+  DISALLOW_COPY_AND_ASSIGN(ArcPowerBridge);
+};
+
+}  // namespace arc
+
+#endif  // COMPONENTS_ARC_POWER_ARC_POWER_SERVICE_H_