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/message_loop/message_loop.h"
 #include "base/time/time.h"
+#include "components/device_event_log/device_event_log.h"
 
 namespace chromeos {
+namespace {
+
+const int kDefaultBatteryLifeSpanSec = 6 * 3600;  // 6 hours

[Daniel Erat, 2015/07/15 19:05:46]

you don't really need this anymore

[mozartalouis, 2015/07/15 21:26:38]

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) {
+      is_projecting_(false),
+      weak_ptr_factory_(this) {
 }
 
 FakePowerManagerClient::~FakePowerManagerClient() {
 }
 
 void FakePowerManagerClient::Init(dbus::Bus* bus) {
+  int remaining_battery_sec = 50 * kDefaultBatteryLifeSpanSec / 100;

[Daniel Erat, 2015/07/15 19:05:46]

why compute this? seems like you can just do something like:

  props_.set_battery_time_to_empty_sec(1800);

below.

[mozartalouis, 2015/07/15 21:26:38]

Done.

+  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(remaining_battery_sec);
+  NotifyObservers();
 }
 
 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() {
+  POWER_LOG(USER) << "Requested status update";

[oshima, 2015/07/15 18:46:50]

do you need this log?

[Daniel Erat, 2015/07/15 19:05:46]

i don't think so either. these exist to debug what's going on on a real system;
it doesn't seem to make sense here.

[mozartalouis, 2015/07/15 21:26:38]

Done.

[mozartalouis, 2015/07/15 21:26:38]

No. it was for my own debugging purposed. forgot to remove

+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FakePowerManagerClient::NotifyObservers,
+                            weak_ptr_factory_.GetWeakPtr()));

[oshima, 2015/07/15 18:46:50]

Can you add comments why this has to be done in posted task?

I probably know why but explanation why you needed this would make code review
much smoother.

Also there is new API for this. Please use

ThreadTaskRunnerHandle

instead.

[mozartalouis, 2015/07/15 21:26:38]

Done.

 }
-

[oshima, 2015/07/15 18:46:50]

keep new line

 void FakePowerManagerClient::RequestSuspend() {
 }
 
 void FakePowerManagerClient::RequestRestart() {
   ++num_request_restart_calls_;
 }
 
 void FakePowerManagerClient::RequestShutdown() {
   ++num_request_shutdown_calls_;
 }
@@ skipping 44 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(
+    const power_manager::PowerSupplyProperties& power_props) {
+  props_ = power_props;
+  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