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"
@@ skipping 754 matching lines @@
   // 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()

[mozartalouis, 2015/06/24 00:50:18]

Not sure if we should keep this class any longer since the emulator will take
car of all things power. maybe keep it for first initialization purposes? 

-      : discharging_(true),
-        battery_percentage_(40),
-        brightness_(50.0),
-        pause_count_(2),
-        cycle_count_(0),
+      : brightness_(50.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:
@@ skipping 75 matching lines @@
   int GetNumPendingSuspendReadinessCallbacks() override {
     return num_pending_suspend_readiness_callbacks_;
   }
 
  private:
   void HandleSuspendReadiness() {
     num_pending_suspend_readiness_callbacks_--;
   }
 
   void UpdateStatus() {
-    if (pause_count_ > 0) {

[mozartalouis, 2015/06/24 00:50:18]

Removed the current implementation of changing the battery life and all others
because this would conflict with the emulator. Example. Set the emulator to
100%, then click tray, the tray will show you 90%.

-      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);
+    props_.set_external_power(
+        power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED);
+    props_.set_battery_state(
+        power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
+    props_.set_battery_time_to_empty_sec(kSecondsToEmptyFullBattery);
+    props_.set_battery_percent(50);
+    props_.set_is_calculating_battery_time(false);
 
     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));
   }
@@ skipping 15 matching lines @@
   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();
 }
 
 }  // namespace chromeos