Created multi-process-friendly PowerMonitor interface.

content/common/power_monitor_broadcast_source.cc

Index: content/common/power_monitor_broadcast_source.cc
diff --git a/content/common/power_monitor_broadcast_source.cc b/content/common/power_monitor_broadcast_source.cc
new file mode 100644
index 0000000000000000000000000000000000000000..730d8907281827472844132530f3d84c9cad7db8
--- /dev/null
+++ b/content/common/power_monitor_broadcast_source.cc
@@ -0,0 +1,80 @@
+// Copyright (c) 2013 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 "content/common/power_monitor_broadcast_source.h"
+
+#include "content/common/power_monitor_messages.h"
+
+namespace content {
+
+PowerMonitorBroadcastSource::PowerMonitorBroadcastSource()
+  : last_reported_battery_power_state_(false),
+  weak_factory_(this) {
+    message_filter_ = new PowerMessageFilter(weak_factory_.GetWeakPtr());
+}
+
+PowerMonitorBroadcastSource::~PowerMonitorBroadcastSource() {
+}
+
+// MessageFilters are owned by the Channel they are added to, so this class does
+// not need to retain a reference.
+IPC::ChannelProxy::MessageFilter*
+PowerMonitorBroadcastSource::MessageFilter() {
+  return message_filter_.get();
+}
+
+bool PowerMonitorBroadcastSource::IsOnBatteryPowerImpl() {
+  return last_reported_battery_power_state_;
+}
+
+void PowerMonitorBroadcastSource::OnPowerStateChange(bool on_battery_power) {
+  last_reported_battery_power_state_ = on_battery_power;
+  ProcessPowerEvent(PowerMonitorSource::POWER_STATE_EVENT);
+}
+
+void PowerMonitorBroadcastSource::OnSuspend() {
+  ProcessPowerEvent(PowerMonitorSource::SUSPEND_EVENT);
+}
+
+void PowerMonitorBroadcastSource::OnResume() {
+  ProcessPowerEvent(PowerMonitorSource::RESUME_EVENT);
+}
+
+PowerMonitorBroadcastSource::PowerMessageFilter::PowerMessageFilter(
+    base::WeakPtr<PowerMonitorBroadcastSource> source) : source_(source) {
+}
+
+PowerMonitorBroadcastSource::PowerMessageFilter::~PowerMessageFilter() {
+}
+
+bool PowerMonitorBroadcastSource::PowerMessageFilter::OnMessageReceived(
+    const IPC::Message& message) {
+  bool msg_is_ok = false;
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_EX(PowerMessageFilter, message, msg_is_ok)
+    IPC_MESSAGE_HANDLER(PowerMonitorMsg_PowerStateChange, OnPowerStateChange)
+    IPC_MESSAGE_HANDLER(PowerMonitorMsg_Suspend, OnSuspend)
+    IPC_MESSAGE_HANDLER(PowerMonitorMsg_Resume, OnResume)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP_EX()
+  return handled && msg_is_ok;
+}
+
+void PowerMonitorBroadcastSource::PowerMessageFilter::OnPowerStateChange(
+    bool on_battery_power) {
+  if (source_.get())

[piman, 2013/07/12 21:09:58]

The weak reference gets destructed on the main thread, whereas this runs on the
IO thread, making it unsafe.

More generally, what is the expected threading behavior of the various classes?
- can you document that? Are PowerMonitor and PowerMonitorSource meant to be
thread-safe? What makes it so? Can you document that?

+    source_->OnPowerStateChange(on_battery_power);
+}
+
+void PowerMonitorBroadcastSource::PowerMessageFilter::OnSuspend() {
+  if (source_.get())
+    source_->OnSuspend();
+}
+
+void PowerMonitorBroadcastSource::PowerMessageFilter::OnResume() {
+  if (source_.get())
+    source_->OnResume();
+}
+
+}  // namespace content