chromeos: Simplify power supply info in PowerLibrary

chrome/browser/automation/testing_automation_provider_chromeos.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/automation/testing_automation_provider.h"
 
 #include "base/command_line.h"
 #include "base/i18n/time_formatting.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
@@ skipping 31 matching lines @@
 #include "policy/policy_constants.h"
 #include "views/widget/widget.h"
 
 using chromeos::CrosLibrary;
 using chromeos::NetworkLibrary;
 using chromeos::UpdateLibrary;
 using chromeos::UserManager;
 
 namespace {
 
+// Last reported power status.
+chromeos::PowerSupplyStatus power_status;
+
 bool EnsureCrosLibraryLoaded(AutomationProvider* provider,
                              IPC::Message* reply_message) {
   if (!CrosLibrary::Get()->EnsureLoaded()) {
     AutomationJSONReply(provider, reply_message).SendError(
         "Could not load cros library.");
     return false;
   }
   return true;
 }
 
@@ skipping 141 matching lines @@
       for (i = policy_map->begin(); i != policy_map->end(); i++)
         dict->Set(policy::GetPolicyName(i->first),
                   i->second->DeepCopy());
     }
   }
   return dict;
 }
 
 }  // namespace
 
+void TestingAutomationProvider::PowerChanged(
+    const chromeos::PowerSupplyStatus& status) {
+  power_status = status;
+}

[stevenjb, 2011/10/25 02:33:20]

Since this observer is only changing a local variable (i.e. we don't even need
to add an accessor to TestingAutomationProvider) it will be simple to keep the
Observer implementation here instead of in the header.

+
 void TestingAutomationProvider::GetLoginInfo(DictionaryValue* args,
                                              IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   const UserManager* user_manager = UserManager::Get();
   if (!user_manager)
     reply.SendError("No user manager!");
   const chromeos::ScreenLocker* screen_locker =
       chromeos::ScreenLocker::default_screen_locker();
@@ skipping 112 matching lines @@
   // session manager then we'll die when the session is stopped.
   reply.SendSuccess(NULL);
   screen_locker->Signout();
 }
 
 void TestingAutomationProvider::GetBatteryInfo(DictionaryValue* args,
                                                IPC::Message* reply_message) {
   if (!EnsureCrosLibraryLoaded(this, reply_message))
     return;
 
-  chromeos::PowerLibrary* power_library = CrosLibrary::Get()->GetPowerLibrary();
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   return_value->SetBoolean("battery_is_present",
-                           power_library->IsBatteryPresent());
-  return_value->SetBoolean("line_power_on", power_library->IsLinePowerOn());
-  if (power_library->IsBatteryPresent()) {
+                           power_status.battery_is_present);
+  return_value->SetBoolean("line_power_on", power_status.line_power_on);
+  if (power_status.battery_is_present) {
     return_value->SetBoolean("battery_fully_charged",
-                             power_library->IsBatteryFullyCharged());
+                             power_status.battery_is_full);
     return_value->SetDouble("battery_percentage",
-                            power_library->GetBatteryPercentage());
-    if (power_library->IsLinePowerOn()) {
-      int time = power_library->GetBatteryTimeToFull().InSeconds();
-      if (time > 0 || power_library->IsBatteryFullyCharged())
-        return_value->SetInteger("battery_time_to_full", time);
+                            power_status.battery_percentage);
+    if (power_status.line_power_on) {
+      int64 time = power_status.battery_seconds_to_full;
+      if (time > 0 || power_status.battery_is_full)
+        return_value->SetInteger("battery_seconds_to_full", time);
     } else {
-      int time = power_library->GetBatteryTimeToEmpty().InSeconds();
+      int64 time = power_status.battery_seconds_to_empty;
       if (time > 0)
-        return_value->SetInteger("battery_time_to_empty", time);
+        return_value->SetInteger("battery_seconds_to_empty", time);
     }
   }
 
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 void TestingAutomationProvider::GetNetworkInfo(DictionaryValue* args,
                                                IPC::Message* reply_message) {
   if (!EnsureCrosLibraryLoaded(this, reply_message))
     return;
@@ skipping 820 matching lines @@
 
   // Set up an observer (it will delete itself).
   take_photo_dialog->AddObserver(new PhotoCaptureObserver(
       this, reply_message));
 
   views::Widget* window = browser::CreateViewsWindow(
       browser->window()->GetNativeHandle(), take_photo_dialog);
   window->SetAlwaysOnTop(true);
   window->Show();
 }