Use stub impl when libcros fails to load

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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/observer_list.h"
@@ skipping 20 matching lines @@
       power_status_connection_ = NULL;
     }
     if (resume_status_connection_) {
       chromeos::DisconnectResume(resume_status_connection_);
       resume_status_connection_ = NULL;
     }
   }
 
   // Begin PowerLibrary implementation.
   virtual void Init() OVERRIDE {
-    if (CrosLibrary::Get()->EnsureLoaded()) {
-      power_status_connection_ =
-          chromeos::MonitorPowerStatus(&PowerStatusChangedHandler, this);
-      resume_status_connection_ =
-          chromeos::MonitorResume(&SystemResumedHandler, this);
-    }
+    DCHECK(CrosLibrary::Get()->libcros_loaded());
+    power_status_connection_ =
+        chromeos::MonitorPowerStatus(&PowerStatusChangedHandler, this);
+    resume_status_connection_ =
+        chromeos::MonitorResume(&SystemResumedHandler, this);
   }
 
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
@@ skipping 21 matching lines @@
     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 {
-    if (!CrosLibrary::Get()->EnsureLoaded())
-      return;
-
     // Make sure we run on FILE thread becuase chromeos::EnableScreenLock
     // would write power manager config file to disk.
     if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           NewRunnableMethod(this, &PowerLibraryImpl::EnableScreenLock, enable));
       return;
     }
 
     chromeos::EnableScreenLock(enable);
   }
 
   virtual void RequestRestart() OVERRIDE {
-    if (CrosLibrary::Get()->EnsureLoaded())
-      chromeos::RequestRestart();
+    chromeos::RequestRestart();
   }
 
   virtual void RequestShutdown() OVERRIDE {
-    if (CrosLibrary::Get()->EnsureLoaded())
-      chromeos::RequestShutdown();
+    chromeos::RequestShutdown();
   }
+
+  virtual void RequestStatusUpdate() OVERRIDE {
+    PowerInformation information;
+    chromeos::RetrievePowerInformation(&information);
+    UpdatePowerStatus(information.power_status);
+  }
+
   // End PowerLibrary implementation.
 
  private:
   static void GetIdleTimeCallback(void* object,
                                  int64_t time_idle_ms,
                                  bool success) {
     DCHECK(object);
     CalculateIdleTimeCallback* notify =
         static_cast<CalculateIdleTimeCallback*>(object);
     if (success) {
@@ skipping 61 matching lines @@
 
   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_(20),
+        battery_percentage_(80),

[satorux1, 2011/09/16 20:05:55]

This seems to be unrelated to the refactoring. What about doing this in a
separate patch?

[stevenjb, 2011/09/16 21:44:24]

Will do.

         pause_count_(0) {
-    timer_.Start(
-        FROM_HERE,
-        base::TimeDelta::FromMilliseconds(100),
-        this,
-        &PowerLibraryStubImpl::Update);
   }
 
   virtual ~PowerLibraryStubImpl() {}
 
   // Begin PowerLibrary implementation.
   virtual void Init() OVERRIDE {}
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
@@ skipping 28 matching lines @@
     if (battery_percentage_ == 100)
       return base::TimeDelta::FromSeconds(1);
     else
       return base::TimeDelta::FromHours(3) - battery_time_to_empty();
   }
 
   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 {}
+
+  virtual void RequestStatusUpdate() OVERRIDE {
+    if (!timer_.IsRunning()) {
+      timer_.Start(
+          FROM_HERE,
+          base::TimeDelta::FromMilliseconds(100),
+          this,
+          &PowerLibraryStubImpl::Update);
+    } else {
+      timer_.Stop();
+    }
+  }
+
   // End PowerLibrary implementation.
 
  private:
   void Update() {
     // We pause at 0 and 100% so that it's easier to check those conditions.
     if (pause_count_ > 1) {
       pause_count_--;
       return;
     }
 
@@ skipping 26 matching lines @@
     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);