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 <algorithm>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/time/time.h"
 
 namespace chromeos {
+namespace {
+
+const int kDefaultBatteryEmptySec = 6 * 3600;  // 6 hours

[Daniel Erat, 2015/06/29 19:34:18]

please give this a better name and add a comment describing what it represents.
it looks like it's the amount of time that the battery takes to fully charge
starting at 0% or fully discharge starting at 100%, right? maybe something like
kBatteryLifetimeSec?

[mozartalouis, 2015/06/29 20:06:01]

Done.

+
+}  // 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) {
+  UpdateBatteryPercentage(50);
+  UpdateIsCalculatingBatteryTime(false);
+  UpdateExternalPower(
+      power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED);
+  UpdateBatteryState(
+      power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
 }
 
 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) {
 }
 
 void FakePowerManagerClient::GetScreenBrightnessPercent(
     const GetScreenBrightnessPercentCallback& callback) {
 }
 
 void FakePowerManagerClient::DecreaseKeyboardBrightness() {
 }
 
 void FakePowerManagerClient::IncreaseKeyboardBrightness() {
 }
 
 void FakePowerManagerClient::RequestStatusUpdate() {
+  UpdateObserver();
 }
 
 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::UpdateBatteryPercentage(int percentage) {
+  props_.set_battery_percent(percentage);
+  UpdateObserver();
+}
+
+void FakePowerManagerClient::UpdateExternalPower(
+    power_manager::PowerSupplyProperties::ExternalPower power_source) {
+  switch (power_source) {

[Daniel Erat, 2015/06/29 19:34:18]

why do you need this switch statement? can't you just do:

  props_.set_external_power(power_source);

?

[mozartalouis, 2015/06/29 20:06:01]

It was there before just in case we wanted to do fool proofing. example, if the
power is disconnected, then we should change the charging state to discharging.
I wasn't sure if it was necessary so i just left it like this for now.

+    case power_manager::PowerSupplyProperties_ExternalPower_USB:
+      // Say that the system is charging on USB if charging is enabled
+      // (i.e. a low-power charger).
+      props_.set_external_power(
+          power_manager::PowerSupplyProperties_ExternalPower_USB);
+      break;
+    case power_manager::PowerSupplyProperties_ExternalPower_AC:
+      // Say that the system is charging on AC if charging is enabled.
+      props_.set_external_power(
+          power_manager::PowerSupplyProperties_ExternalPower_AC);
+      break;
+    case power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED:
+      // Say discharging without any charger connected.
+      props_.set_external_power(
+          power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED);
+      break;
+    default:
+      NOTREACHED() << "Unhandled power source " << power_source;
+  }
+  UpdateObserver();
+}
+
+void FakePowerManagerClient::UpdateBatteryState(
+    power_manager::PowerSupplyProperties::BatteryState state) {
+  props_.set_battery_state(state);
+
+  int64 remaining_battery_time = std::max(

[Daniel Erat, 2015/06/29 19:34:18]

please either rename to "remaining_battery_sec" or use base::TimeDelta.

it also seems unlikely that you need int64 here rather than int -- 2 ** 31
seconds is ~68 years, i think:
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Integer_Types

[mozartalouis, 2015/06/29 20:06:01]

Done.

+      1, (int)props_.battery_percent() * kDefaultBatteryEmptySec / 100);

[Daniel Erat, 2015/06/29 19:34:18]

use static_cast<> rather than a c-style cast:
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Casting

[mozartalouis, 2015/06/29 20:06:01]

Done.

+
+  if (props_.battery_percent() == 100 &&
+      props_.battery_state() ==
+          power_manager::PowerSupplyProperties_BatteryState_CHARGING) {
+    props_.set_battery_state(
+        power_manager::PowerSupplyProperties_BatteryState_FULL);

[Daniel Erat, 2015/06/29 19:34:18]

you should also set battery_time_to_empty_sec and battery_time_to_full_sec to 0
here as well, per the comments in power_supply_properties.proto

[mozartalouis, 2015/06/29 20:06:01]

Done.

+  } else if (props_.battery_state() ==
+             power_manager::PowerSupplyProperties_BatteryState_CHARGING) {
+    props_.set_battery_state(
+        power_manager::PowerSupplyProperties_BatteryState_CHARGING);
+    props_.set_battery_time_to_full_sec(
+        std::max(static_cast<int64>(1),
+                 kDefaultBatteryEmptySec - remaining_battery_time));

[Daniel Erat, 2015/06/29 19:34:18]

set battery_time_to_empty_sec to 0

[mozartalouis, 2015/06/29 20:06:01]

Done.

+  } else {
+    props_.set_battery_state(
+        power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
+    props_.set_battery_time_to_empty_sec(remaining_battery_time);

[Daniel Erat, 2015/06/29 19:34:18]

set battery_time_to_full_sec to 0

[mozartalouis, 2015/06/29 20:06:01]

Done.

+  }
+  UpdateObserver();
+}
+
+void FakePowerManagerClient::UpdateIsCalculatingBatteryTime(
+    bool is_calculating) {
+  props_.set_is_calculating_battery_time(is_calculating);
+  UpdateObserver();
+}
+
+void FakePowerManagerClient::UpdateObserver() {

[Daniel Erat, 2015/06/29 19:34:18]

maybe rename this to NotifyObservers()? (there can be more than one observer,
and they're being notified, not updated.)

[mozartalouis, 2015/06/29 20:06:01]

Done.

+  FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(props_));
+}
+
 void FakePowerManagerClient::HandleSuspendReadiness() {
   CHECK(num_pending_suspend_readiness_callbacks_ > 0);
 
   --num_pending_suspend_readiness_callbacks_;
 }
 
 } // namespace chromeos