ChromeOs Power Emulation Impl

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/time/time.h"
 
 namespace chromeos {
+namespace {
+
+const int kDefaultBatteryLifeSpanSec = 6 * 3600;  // 6 hours
+
+}  // namespace
 
 FakePowerManagerClient::FakePowerManagerClient()
     : num_request_restart_calls_(0),
       num_request_shutdown_calls_(0),
       num_set_policy_calls_(0),
       num_set_is_projecting_calls_(0),
       num_pending_suspend_readiness_callbacks_(0),
       is_projecting_(false) {
 }
 
 FakePowerManagerClient::~FakePowerManagerClient() {
 }
 
 void FakePowerManagerClient::Init(dbus::Bus* bus) {
+  UpdatePowerProperties(
+      50, false, power_manager::PowerSupplyProperties_BatteryState_DISCHARGING,
+      power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED);
 }
 
 void FakePowerManagerClient::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakePowerManagerClient::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool FakePowerManagerClient::HasObserver(const Observer* observer) const {
-  return false;
+  return observers_.HasObserver(observer);
 }
 
 void FakePowerManagerClient::SetRenderProcessManagerDelegate(
     base::WeakPtr<RenderProcessManagerDelegate> delegate) {
   render_process_manager_delegate_ = delegate;
 }
 
 void FakePowerManagerClient::DecreaseScreenBrightness(bool allow_off) {
 }
 
 void FakePowerManagerClient::IncreaseScreenBrightness() {
 }
 
 void FakePowerManagerClient::SetScreenBrightnessPercent(double percent,
                                                         bool gradual) {
 }

[oshima, 2015/07/06 18:47:57]

Are these going to be implemented too (in separate CLs)?

[mozartalouis, 2015/07/06 20:49:42]

These will be implemented in a separate CL, Although I'm not sure if it will be
needed. Do we want brightness features? the only reason they are here is because
power_manager_client.h defines them as pure virtual.

 
 void FakePowerManagerClient::GetScreenBrightnessPercent(
     const GetScreenBrightnessPercentCallback& callback) {
 }
 
 void FakePowerManagerClient::DecreaseKeyboardBrightness() {
 }
 
 void FakePowerManagerClient::IncreaseKeyboardBrightness() {
 }
 
 void FakePowerManagerClient::RequestStatusUpdate() {
+  NotifyObservers();
 }
 
 void FakePowerManagerClient::RequestSuspend() {
 }
 
 void FakePowerManagerClient::RequestRestart() {
   ++num_request_restart_calls_;
 }
 
 void FakePowerManagerClient::RequestShutdown() {
@@ skipping 46 matching lines @@
   FOR_EACH_OBSERVER(Observer, observers_, DarkSuspendImminent());
 }
 
 void FakePowerManagerClient::SendPowerButtonEvent(
     bool down,
     const base::TimeTicks& timestamp) {
   FOR_EACH_OBSERVER(Observer, observers_,
                     PowerButtonEventReceived(down, timestamp));
 }
 
+void FakePowerManagerClient::UpdatePowerProperties(
+    int battery_percent,
+    bool is_calculating_battery_time,
+    power_manager::PowerSupplyProperties::BatteryState battery_state,
+    power_manager::PowerSupplyProperties::ExternalPower external_power) {
+  int remaining_battery_sec =
+      battery_percent * kDefaultBatteryLifeSpanSec / 100;
+
+  // Sets the charging state based on the battery percentage to mimic real
+  // implementation.
+  if (battery_percent == 100 &&
+      (battery_state ==
+           power_manager::PowerSupplyProperties_BatteryState_CHARGING ||
+       battery_state ==
+           power_manager::PowerSupplyProperties_BatteryState_FULL)) {
+    props_.set_battery_state(
+        power_manager::PowerSupplyProperties_BatteryState_FULL);
+    props_.set_battery_time_to_full_sec(0);
+    props_.set_battery_time_to_empty_sec(0);
+  } else if (battery_state ==
+             power_manager::PowerSupplyProperties_BatteryState_CHARGING) {
+    props_.set_battery_state(
+        power_manager::PowerSupplyProperties_BatteryState_CHARGING);
+    props_.set_battery_time_to_full_sec(kDefaultBatteryLifeSpanSec -
+                                        remaining_battery_sec);
+    props_.set_battery_time_to_empty_sec(0);
+  } else {
+    props_.set_battery_state(
+        power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
+    props_.set_battery_time_to_full_sec(0);
+    props_.set_battery_time_to_empty_sec(remaining_battery_sec);
+  }

[oshima, 2015/07/06 18:47:57]

looks like it's possible to call with impossible arguments and
the method silently ignore such case. 

Can you add CHECK instead to catch such cases?


Even better, isn't it possible to derive BatteryState from battery_percent and
external power state?

[Daniel Erat, 2015/07/06 19:02:54]

no, it isn't:

- a defective battery can fail to charge even while line power is connected
- some systems can draw more power than a charger can provide (e.g. spring)
etc.

the ui handles these cases specially, so it should be possible to trigger them
using this class.

i think it might be better to make this class just directly copy the passed-in
values to the proto, though, since that allows developers to test any possible
combination of fields that powerd can send to chrome.

[oshima, 2015/07/06 19:54:59]

That's fine with me. It'd be nice to have utility factory methods/functions to
create proto for such scenarios (faulty battery, lower power charger, etc) to
avoid creating impossible state. (it'll be never charging without power source
for example).

[mozartalouis, 2015/07/06 20:49:42]

If we want those features, we can implement them in another CL possibly?
(Advanced Battery Features?)

[oshima, 2015/07/06 21:06:05]

You can add these functions/methods when you integrate with UI

[mozartalouis, 2015/07/07 01:40:06]

Acknowledged.

+
+  // Checks if the battery is in a discharging state first before setting a
+  // charger. It wouldn't make sense for the battery to be discharging on AC,
+  // but it is possible for it to be discharging on low power USB.
+  if (props_.battery_state() ==
+      power_manager::PowerSupplyProperties_BatteryState_DISCHARGING) {
+    props_.set_external_power(
+        external_power == power_manager::PowerSupplyProperties_ExternalPower_USB
+            ? power_manager::PowerSupplyProperties_ExternalPower_USB
+            : power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED);
+  } else {
+    props_.set_external_power(
+        external_power == power_manager::PowerSupplyProperties_ExternalPower_USB
+            ? power_manager::PowerSupplyProperties_ExternalPower_USB
+            : power_manager::PowerSupplyProperties_ExternalPower_AC);
+  }
+
+  props_.set_battery_percent(battery_percent);
+  props_.set_is_calculating_battery_time(is_calculating_battery_time);
+
+  NotifyObservers();
+}
+
+void FakePowerManagerClient::NotifyObservers() {
+  FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(props_));
+}
+
 void FakePowerManagerClient::HandleSuspendReadiness() {
   CHECK(num_pending_suspend_readiness_callbacks_ > 0);
 
   --num_pending_suspend_readiness_callbacks_;
 }
 
 } // namespace chromeos