chromeos: Add PowerManagerClient::GetSwitchStates().

chromeos/dbus/fake_power_manager_client.cc

 // Copyright (c) 2013 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/fake_power_manager_client.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 
 namespace chromeos {
 
 namespace {
 // Minimum power for a USB power source to be classified as AC.
 constexpr double kUsbMinAcWatts = 24;
 }
 
-FakePowerManagerClient::FakePowerManagerClient()
-    : num_request_restart_calls_(0),
-      num_request_shutdown_calls_(0),
-      num_set_policy_calls_(0),
-      num_set_is_projecting_calls_(0),
-      num_set_backlights_forced_off_calls_(0),
-      num_pending_suspend_readiness_callbacks_(0),
-      is_projecting_(false),
-      backlights_forced_off_(false),
-      weak_ptr_factory_(this) {}
+FakePowerManagerClient::FakePowerManagerClient() : weak_ptr_factory_(this) {}
 
-FakePowerManagerClient::~FakePowerManagerClient() {
-}
+FakePowerManagerClient::~FakePowerManagerClient() = default;
 
 void FakePowerManagerClient::Init(dbus::Bus* bus) {
   props_.set_battery_percent(50);
   props_.set_is_calculating_battery_time(false);
   props_.set_battery_state(
       power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
   props_.set_external_power(
       power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED);
   props_.set_battery_time_to_full_sec(0);
   props_.set_battery_time_to_empty_sec(18000);
 }
 
 void FakePowerManagerClient::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakePowerManagerClient::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool FakePowerManagerClient::HasObserver(const Observer* observer) const {
   return observers_.HasObserver(observer);
 }
 
 void FakePowerManagerClient::SetRenderProcessManagerDelegate(
     base::WeakPtr<RenderProcessManagerDelegate> delegate) {
   render_process_manager_delegate_ = delegate;
 }
 
-void FakePowerManagerClient::DecreaseScreenBrightness(bool allow_off) {
-}
+void FakePowerManagerClient::DecreaseScreenBrightness(bool allow_off) {}
 
-void FakePowerManagerClient::IncreaseScreenBrightness() {
-}
+void FakePowerManagerClient::IncreaseScreenBrightness() {}
 
 void FakePowerManagerClient::SetScreenBrightnessPercent(double percent,
-                                                        bool gradual) {
-}
+                                                        bool gradual) {}
 
 void FakePowerManagerClient::GetScreenBrightnessPercent(
-    const GetScreenBrightnessPercentCallback& callback) {
-}
+    const GetScreenBrightnessPercentCallback& callback) {}
 
-void FakePowerManagerClient::DecreaseKeyboardBrightness() {
-}
+void FakePowerManagerClient::DecreaseKeyboardBrightness() {}
 
-void FakePowerManagerClient::IncreaseKeyboardBrightness() {
-}
+void FakePowerManagerClient::IncreaseKeyboardBrightness() {}
 
 void FakePowerManagerClient::RequestStatusUpdate() {
   // RequestStatusUpdate() calls and notifies the observers
   // asynchronously on a real device. On the fake implementation, we call
   // observers in a posted task to emulate the same behavior.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&FakePowerManagerClient::NotifyObservers,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
-void FakePowerManagerClient::RequestSuspend() {
-}
+void FakePowerManagerClient::RequestSuspend() {}
 
 void FakePowerManagerClient::RequestRestart() {
   ++num_request_restart_calls_;
 }
 
 void FakePowerManagerClient::RequestShutdown() {
   ++num_request_shutdown_calls_;
 }
 
 void FakePowerManagerClient::NotifyUserActivity(
-    power_manager::UserActivityType type) {
-}
+    power_manager::UserActivityType type) {}
 
 void FakePowerManagerClient::NotifyVideoActivity(bool is_fullscreen) {
   video_activity_reports_.push_back(is_fullscreen);
 }
 
 void FakePowerManagerClient::SetPolicy(
     const power_manager::PowerManagementPolicy& policy) {
   policy_ = policy;
   ++num_set_policy_calls_;
 }
@@ skipping 24 matching lines @@
   backlights_forced_off_ = forced_off;
   ++num_set_backlights_forced_off_calls_;
 }
 
 void FakePowerManagerClient::GetBacklightsForcedOff(
     const GetBacklightsForcedOffCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, backlights_forced_off_));
 }
 
+void FakePowerManagerClient::GetSwitchStates(
+    const GetSwitchStatesCallback& callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(callback, lid_state_, tablet_mode_));
+}
+
 base::Closure FakePowerManagerClient::GetSuspendReadinessCallback() {
   ++num_pending_suspend_readiness_callbacks_;
 
   return base::Bind(&FakePowerManagerClient::HandleSuspendReadiness,
                     base::Unretained(this));
 }
 
 int FakePowerManagerClient::GetNumPendingSuspendReadinessCallbacks() {
   return num_pending_suspend_readiness_callbacks_;
 }
@@ skipping 49 matching lines @@
     observer.PowerChanged(props_);
 }
 
 void FakePowerManagerClient::HandleSuspendReadiness() {
   CHECK(num_pending_suspend_readiness_callbacks_ > 0);
 
   --num_pending_suspend_readiness_callbacks_;
 }
 
 }  // namespace chromeos