chromeos: Simplify power supply info in PowerLibrary

chrome/browser/chromeos/cros/power_library.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/power_library.h"
 
+#include <algorithm>
+
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/observer_list.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "content/browser/browser_thread.h"
 #include "third_party/cros/chromeos_power.h"
 #include "third_party/cros/chromeos_resume.h"
 
 namespace chromeos {
 
 class PowerLibraryImpl : public PowerLibrary {
  public:
   PowerLibraryImpl()
       : power_status_connection_(NULL),
-        resume_status_connection_(NULL),
-        status_(chromeos::PowerStatus()) {
+        resume_status_connection_(NULL) {
   }
 
   virtual ~PowerLibraryImpl() {
     if (power_status_connection_) {
       chromeos::DisconnectPowerStatus(power_status_connection_);
       power_status_connection_ = NULL;
     }
     if (resume_status_connection_) {
       chromeos::DisconnectResume(resume_status_connection_);
       resume_status_connection_ = NULL;
@@ skipping 10 matching lines @@
   }
 
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
-  virtual bool IsLinePowerOn() const OVERRIDE {
-    return status_.line_power_on;
-  }
-
-  virtual bool IsBatteryFullyCharged() const OVERRIDE {
-    return status_.battery_state == chromeos::BATTERY_STATE_FULLY_CHARGED;
-  }
-
-  virtual double GetBatteryPercentage() const OVERRIDE {
-    return status_.battery_percentage;
-  }
-
-  virtual bool IsBatteryPresent() const OVERRIDE {
-    return status_.battery_is_present;
-  }
-
-  virtual base::TimeDelta GetBatteryTimeToEmpty() const OVERRIDE {
-    return base::TimeDelta::FromSeconds(status_.battery_time_to_empty);
-  }
-
-  virtual base::TimeDelta GetBatteryTimeToFull() const OVERRIDE {
-    return base::TimeDelta::FromSeconds(status_.battery_time_to_full);
-  }
-
   virtual void CalculateIdleTime(CalculateIdleTimeCallback* callback) OVERRIDE {
     // TODO(sidor): Examine if it's really a good idea to use void* as a second
     // argument.
     chromeos::GetIdleTime(&GetIdleTimeCallback, callback);
   }
 
   virtual void EnableScreenLock(bool enable) OVERRIDE {
     // Make sure we run on FILE thread becuase chromeos::EnableScreenLock
     // would write power manager config file to disk.
     if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
@@ skipping 32 matching lines @@
     if (success) {
       notify->Run(time_idle_ms/1000);
     } else {
       LOG(ERROR) << "Power manager failed to calculate idle time.";
       notify->Run(-1);
     }
     delete notify;
   }
 
   static void PowerStatusChangedHandler(void* object,
-                                        const chromeos::PowerStatus& status) {
+                                        const PowerStatus& status) {
     PowerLibraryImpl* power = static_cast<PowerLibraryImpl*>(object);
     power->UpdatePowerStatus(status);
   }
 
   static void SystemResumedHandler(void* object) {
     PowerLibraryImpl* power = static_cast<PowerLibraryImpl*>(object);
     power->SystemResumed();
   }
 
-  void UpdatePowerStatus(const chromeos::PowerStatus& status) {
+  void UpdatePowerStatus(const PowerStatus& status) {
     // Make sure we run on UI thread.
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           NewRunnableMethod(
               this, &PowerLibraryImpl::UpdatePowerStatus, status));
       return;
     }
 
     DVLOG(1) << "Power lpo=" << status.line_power_on
              << " sta=" << status.battery_state
              << " per=" << status.battery_percentage
              << " tte=" << status.battery_time_to_empty
              << " ttf=" << status.battery_time_to_full;
-    status_ = status;
-    FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(this));
+    FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(status));
   }
 
   void SystemResumed() {
     // Make sure we run on the UI thread.
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           NewRunnableMethod(this, &PowerLibraryImpl::SystemResumed));
       return;
     }
 
     FOR_EACH_OBSERVER(Observer, observers_, SystemResumed());
   }
 
   ObserverList<Observer> observers_;
 
   // A reference to the power battery API, to allow callbacks when the battery
   // status changes.
   chromeos::PowerStatusConnection power_status_connection_;
 
   // A reference to the resume alerts.
   chromeos::ResumeConnection resume_status_connection_;
 
-  // The latest power status.
-  chromeos::PowerStatus status_;
-
   DISALLOW_COPY_AND_ASSIGN(PowerLibraryImpl);
 };
 
 // The stub implementation runs the battery up and down, pausing at the
 // fully charged and fully depleted states.
 class PowerLibraryStubImpl : public PowerLibrary {
  public:
   PowerLibraryStubImpl()
       : discharging_(true),
         battery_percentage_(80),
         pause_count_(0) {
   }
 
   virtual ~PowerLibraryStubImpl() {}
 
   // Begin PowerLibrary implementation.
   virtual void Init() OVERRIDE {}
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
-  virtual bool IsLinePowerOn() const OVERRIDE {
-    return !discharging_;
-  }
-
-  virtual bool IsBatteryFullyCharged() const OVERRIDE {
-    return battery_percentage_ == 100;
-  }
-
-  virtual double GetBatteryPercentage() const OVERRIDE {
-    return battery_percentage_;
-  }
-
-  virtual bool IsBatteryPresent() const OVERRIDE {
-    return true;
-  }
-
-  virtual base::TimeDelta GetBatteryTimeToEmpty() const OVERRIDE {
-    if (battery_percentage_ == 0)
-      return base::TimeDelta::FromSeconds(1);
-    else
-      return (base::TimeDelta::FromHours(3) * battery_percentage_) / 100;
-  }
-
-  virtual base::TimeDelta GetBatteryTimeToFull() const OVERRIDE {
-    if (battery_percentage_ == 100)
-      return base::TimeDelta::FromSeconds(1);
-    else
-      return base::TimeDelta::FromHours(3) - GetBatteryTimeToEmpty();
-  }
-
   virtual void CalculateIdleTime(CalculateIdleTimeCallback* callback) OVERRIDE {
     callback->Run(0);
     delete callback;
   }
 
   virtual void EnableScreenLock(bool enable) OVERRIDE {}
 
   virtual void RequestRestart() OVERRIDE {}
 
   virtual void RequestShutdown() OVERRIDE {}
@@ skipping 23 matching lines @@
     if (battery_percentage_ == 0 || battery_percentage_ == 100) {
       if (pause_count_) {
         pause_count_ = 0;
         discharging_ = !discharging_;
       } else {
         pause_count_ = 20;
         return;
       }
     }
     battery_percentage_ += (discharging_ ? -1 : 1);
-    FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(this));
+
+    PowerStatus status;
+    status.line_power_on = !discharging_;
+    status.battery_is_present = true;
+    status.battery_percentage = battery_percentage_;
+    status.battery_time_to_empty = std::max(1, battery_percentage_ * 180 / 100);
+    status.battery_time_to_full = std::max(1LL,
+                                           180 - status.battery_time_to_empty);

[stevenjb, 2011/10/18 23:08:23]

It seems like PowerStatus should just store percentage_ and have accessors for
TimeToEmpty and TimeToFull (or a single setter that sets all three).

[satorux1, 2011/10/19 21:16:55]

This is a stub implementation.

PowerStatus data comes from power_manager, so we probably don't need to compute
them in Chrome.

+
+    FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(status));
   }
 
   bool discharging_;
   int battery_percentage_;
   int pause_count_;
   ObserverList<Observer> observers_;
   base::RepeatingTimer<PowerLibraryStubImpl> timer_;
 };
 
 // static
 PowerLibrary* PowerLibrary::GetImpl(bool stub) {
   PowerLibrary* impl;
   if (stub)
     impl = new PowerLibraryStubImpl();
   else
     impl = new PowerLibraryImpl();
   impl->Init();
   return impl;
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::PowerLibraryImpl);