ChromeOs Power Emulation Impl

chromeos/dbus/power_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/power_manager_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/timer/timer.h"
 #include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/fake_power_manager_client.h"
 #include "chromeos/dbus/power_manager/input_event.pb.h"
 #include "chromeos/dbus/power_manager/peripheral_battery_status.pb.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
 #include "chromeos/dbus/power_manager/suspend.pb.h"
 #include "components/device_event_log/device_event_log.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
@@ skipping 728 matching lines @@
   // processes.
   base::WeakPtr<RenderProcessManagerDelegate> render_process_manager_delegate_;
 
   // 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<PowerManagerClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerManagerClientImpl);
 };
 
-// The PowerManagerClient implementation used on Linux desktop,
-// which does nothing.
-class PowerManagerClientStubImpl : public PowerManagerClient {
- public:
-  PowerManagerClientStubImpl()
-      : discharging_(true),
-        battery_percentage_(40),
-        brightness_(50.0),
-        pause_count_(2),
-        cycle_count_(0),
-        num_pending_suspend_readiness_callbacks_(0),
-        weak_ptr_factory_(this) {}
-
-  ~PowerManagerClientStubImpl() override {}
-
-  int num_pending_suspend_readiness_callbacks() const {
-    return num_pending_suspend_readiness_callbacks_;
-  }
-
-  // PowerManagerClient overrides:
-  void Init(dbus::Bus* bus) override {
-    ParseCommandLineSwitch();
-    if (power_cycle_delay_ != base::TimeDelta()) {
-      update_timer_.Start(FROM_HERE,
-                          power_cycle_delay_,
-                          this,
-                          &PowerManagerClientStubImpl::UpdateStatus);
-    }
-  }
-
-  void AddObserver(Observer* observer) override {
-    observers_.AddObserver(observer);
-  }
-
-  void RemoveObserver(Observer* observer) override {
-    observers_.RemoveObserver(observer);
-  }
-
-  bool HasObserver(const Observer* observer) const override {
-    return observers_.HasObserver(observer);
-  }
-
-  void SetRenderProcessManagerDelegate(
-      base::WeakPtr<RenderProcessManagerDelegate> delegate) override {}
-
-  void DecreaseScreenBrightness(bool allow_off) override {
-    POWER_LOG(USER) << "Requested to descrease screen brightness";
-    SetBrightness(brightness_ - 5.0, true);
-  }
-
-  void IncreaseScreenBrightness() override {
-    POWER_LOG(USER) << "Requested to increase screen brightness";
-    SetBrightness(brightness_ + 5.0, true);
-  }
-
-  void SetScreenBrightnessPercent(double percent, bool gradual) override {
-    POWER_LOG(USER) << "Requested to set screen brightness to " << percent
-                    << "% " << (gradual ? "gradually" : "instantaneously");
-    SetBrightness(percent, false);
-  }
-
-  void GetScreenBrightnessPercent(
-      const GetScreenBrightnessPercentCallback& callback) override {
-    POWER_LOG(USER) << "Requested to get screen brightness";
-    callback.Run(brightness_);
-  }
-
-  void DecreaseKeyboardBrightness() override {
-    POWER_LOG(USER) << "Requested to descrease keyboard brightness";
-  }
-
-  void IncreaseKeyboardBrightness() override {
-    POWER_LOG(USER) << "Requested to increase keyboard brightness";
-  }
-
-  void RequestStatusUpdate() override {
-    POWER_LOG(USER) << "Requested status update";
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&PowerManagerClientStubImpl::UpdateStatus,
-                              weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  void RequestSuspend() override {}
-  void RequestRestart() override {}
-  void RequestShutdown() override {}
-
-  void NotifyUserActivity(power_manager::UserActivityType type) override {}
-  void NotifyVideoActivity(bool is_fullscreen) override {}
-  void SetPolicy(const power_manager::PowerManagementPolicy& policy) override {}
-  void SetIsProjecting(bool is_projecting) override {}
-  base::Closure GetSuspendReadinessCallback() override {
-    num_pending_suspend_readiness_callbacks_++;
-    return base::Bind(&PowerManagerClientStubImpl::HandleSuspendReadiness,
-                      weak_ptr_factory_.GetWeakPtr());
-  }
-  int GetNumPendingSuspendReadinessCallbacks() override {
-    return num_pending_suspend_readiness_callbacks_;
-  }
-
- private:
-  void HandleSuspendReadiness() {
-    num_pending_suspend_readiness_callbacks_--;
-  }
-
-  void UpdateStatus() {
-    if (pause_count_ > 0) {
-      pause_count_--;
-      if (pause_count_ == 2)
-        discharging_ = !discharging_;
-    } else {
-      if (discharging_)
-        battery_percentage_ -= (battery_percentage_ <= 10 ? 1 : 10);
-      else
-        battery_percentage_ += (battery_percentage_ >= 10 ? 10 : 1);
-      battery_percentage_ = std::min(std::max(battery_percentage_, 0), 100);
-      // We pause at 0 and 100% so that it's easier to check those conditions.
-      if (battery_percentage_ == 0 || battery_percentage_ == 100) {
-        pause_count_ = 4;
-        if (battery_percentage_ == 100)
-          cycle_count_ = (cycle_count_ + 1) % 3;
-      }
-    }
-
-    const int kSecondsToEmptyFullBattery = 3 * 60 * 60;  // 3 hours.
-    int64 remaining_battery_time =
-        std::max(1, battery_percentage_ * kSecondsToEmptyFullBattery / 100);
-
-    props_.Clear();
-
-    switch (cycle_count_) {
-      case 0:
-        // Say that the system is charging with AC connected and
-        // discharging without any charger connected.
-        props_.set_external_power(discharging_ ?
-            power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED :
-            power_manager::PowerSupplyProperties_ExternalPower_AC);
-        break;
-      case 1:
-        // Say that the system is both charging and discharging on USB
-        // (i.e. a low-power charger).
-        props_.set_external_power(
-            power_manager::PowerSupplyProperties_ExternalPower_USB);
-        break;
-      case 2:
-        // Say that the system is both charging and discharging on AC.
-        props_.set_external_power(
-            power_manager::PowerSupplyProperties_ExternalPower_AC);
-        break;
-      default:
-        NOTREACHED() << "Unhandled cycle " << cycle_count_;
-    }
-
-    if (battery_percentage_ == 100 && !discharging_) {
-      props_.set_battery_state(
-          power_manager::PowerSupplyProperties_BatteryState_FULL);
-    } else if (!discharging_) {
-      props_.set_battery_state(
-          power_manager::PowerSupplyProperties_BatteryState_CHARGING);
-      props_.set_battery_time_to_full_sec(std::max(static_cast<int64>(1),
-          kSecondsToEmptyFullBattery - remaining_battery_time));
-    } else {
-      props_.set_battery_state(
-          power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
-      props_.set_battery_time_to_empty_sec(remaining_battery_time);
-    }
-
-    props_.set_battery_percent(battery_percentage_);
-    props_.set_is_calculating_battery_time(pause_count_ > 1);
-
-    FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(props_));
-  }
-
-  void SetBrightness(double percent, bool user_initiated) {
-    brightness_ = std::min(std::max(0.0, percent), 100.0);
-    int brightness_level = static_cast<int>(brightness_);
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      BrightnessChanged(brightness_level, user_initiated));
-  }
-
-  void ParseCommandLineSwitch() {
-    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-    if (!command_line || !command_line->HasSwitch(switches::kPowerStub))
-      return;
-    std::string option_str =
-        command_line->GetSwitchValueASCII(switches::kPowerStub);
-    base::StringPairs string_pairs;
-    base::SplitStringIntoKeyValuePairs(option_str, '=', ',', &string_pairs);
-    for (base::StringPairs::iterator iter = string_pairs.begin();
-         iter != string_pairs.end(); ++iter) {
-      ParseOption((*iter).first, (*iter).second);
-    }
-  }
-
-  void ParseOption(const std::string& arg0, const std::string& arg1) {
-    if (arg0 == "cycle" || arg0 == "interactive") {
-      int seconds = 1;
-      if (!arg1.empty())
-        base::StringToInt(arg1, &seconds);
-      power_cycle_delay_ = base::TimeDelta::FromSeconds(seconds);
-    }
-  }
-
-  base::TimeDelta power_cycle_delay_;  // Time over which to cycle power state
-  bool discharging_;
-  int battery_percentage_;
-  double brightness_;
-  int pause_count_;
-  int cycle_count_;
-  base::ObserverList<Observer> observers_;
-  base::RepeatingTimer<PowerManagerClientStubImpl> update_timer_;
-  power_manager::PowerSupplyProperties props_;
-
-  // Number of callbacks returned by GetSuspendReadinessCallback() but not yet
-  // invoked.
-  int num_pending_suspend_readiness_callbacks_;
-
-  // 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<PowerManagerClientStubImpl> weak_ptr_factory_;
-};
-
 PowerManagerClient::PowerManagerClient() {
 }
 
 PowerManagerClient::~PowerManagerClient() {
 }
 
 // static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
-  return new PowerManagerClientStubImpl();
+  return new FakePowerManagerClient();
 }
 
 }  // namespace chromeos