Make base::PowerMonitor work on Chrome OS.

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/callback.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
+#include "base/power_monitor/power_monitor_device_source.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/power_manager/input_event.pb.h"
 #include "chromeos/dbus/power_manager/peripheral_battery_status.pb.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
@@ skipping 369 matching lines @@
 
     FOR_EACH_OBSERVER(Observer, observers_,
                       PeripheralBatteryStatusReceived(path, name, level));
   }
 
   void PowerSupplyPollReceived(dbus::Signal* signal) {
     VLOG(1) << "Received power supply poll signal.";
     dbus::MessageReader reader(signal);
     power_manager::PowerSupplyProperties protobuf;
     if (reader.PopArrayOfBytesAsProto(&protobuf)) {
-      FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(protobuf));
+      HandlePowerSupplyProperties(protobuf);
     } else {
       LOG(ERROR) << "Unable to decode "
                  << power_manager::kPowerSupplyPollSignal << "signal";
     }
   }
 
   void OnGetPowerSupplyPropertiesMethod(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Error calling "
                  << power_manager::kGetPowerSupplyPropertiesMethod;
       return;
     }
 
     dbus::MessageReader reader(response);
     power_manager::PowerSupplyProperties protobuf;
     if (reader.PopArrayOfBytesAsProto(&protobuf)) {
-      FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(protobuf));
+      HandlePowerSupplyProperties(protobuf);
     } else {
       LOG(ERROR) << "Unable to decode "
                  << power_manager::kGetPowerSupplyPropertiesMethod
                  << " response";
     }
   }
 
   void OnGetScreenBrightnessPercent(
       const GetScreenBrightnessPercentCallback& callback,
       dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Error calling "
                  << power_manager::kGetScreenBrightnessPercentMethod;
       return;
     }
     dbus::MessageReader reader(response);
     double percent = 0.0;
     if (!reader.PopDouble(&percent))
       LOG(ERROR) << "Error reading response from powerd: "
                  << response->ToString();
     callback.Run(percent);
   }
 
+  void HandlePowerSupplyProperties(
+      const power_manager::PowerSupplyProperties& proto) {
+    FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(proto));
+    const bool on_battery = proto.external_power() ==
+        power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED;
+    base::PowerMonitorDeviceSource::SetPowerSource(on_battery);
+  }
+
   void HandleRegisterSuspendDelayReply(bool dark_suspend,
                                        const std::string& method_name,
                                        dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Error calling " << method_name;
       return;
     }
 
     dbus::MessageReader reader(response);
     power_manager::RegisterSuspendDelayReply protobuf;
@@ skipping 43 matching lines @@
     }
 
     pending_suspend_id_ = proto.suspend_id();
     suspend_is_pending_ = true;
     suspending_from_dark_resume_ = in_dark_resume;
     num_pending_suspend_readiness_callbacks_ = 0;
     if (suspending_from_dark_resume_)
       FOR_EACH_OBSERVER(Observer, observers_, DarkSuspendImminent());
     else
       FOR_EACH_OBSERVER(Observer, observers_, SuspendImminent());
+    base::PowerMonitorDeviceSource::HandleSystemSuspending();
     MaybeReportSuspendReadiness();
   }
 
   void SuspendDoneReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::SuspendDone proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
       LOG(ERROR) << "Unable to decode protocol buffer from "
                  << power_manager::kSuspendDoneSignal << " signal";
       return;
     }
 
     const base::TimeDelta duration =
         base::TimeDelta::FromInternalValue(proto.suspend_duration());
     VLOG(1) << "Got " << power_manager::kSuspendDoneSignal << " signal:"
             << " suspend_id=" << proto.suspend_id()
             << " duration=" << duration.InSeconds() << " sec";
     FOR_EACH_OBSERVER(
         PowerManagerClient::Observer, observers_, SuspendDone(duration));
+    base::PowerMonitorDeviceSource::HandleSystemResumed();
   }
 
   void IdleActionImminentReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::IdleActionImminent proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
       LOG(ERROR) << "Unable to decode protocol buffer from "
                  << power_manager::kIdleActionImminentSignal << " signal";
       return;
     }
@@ skipping 420 matching lines @@
 // 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