[chromeos] New PowerManagerClient observer to collect power data.

chromeos/power/power_data_collector.cc

Index: chromeos/power/power_data_collector.cc
diff --git a/chromeos/power/power_data_collector.cc b/chromeos/power/power_data_collector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..116f55fc9ce2dd106062741b7ca5487ec0a6da64
--- /dev/null
+++ b/chromeos/power/power_data_collector.cc
@@ -0,0 +1,113 @@
+// 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 "base/time/time.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
+#include "chromeos/power/power_data_collector.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace chromeos {
+
+// The global PowerDataCollector instance.
+static PowerDataCollector* power_data_collector;
+
+// Sequence name for callback sequenced tasks which accumulate power supply
+// snapshots. See PowerDataCollector::PowerChanged below.
+const char kPowerSupplySnapshotSequence[] =
+    "power_data_collector__power_supply_snapshot_sequence";
+
+PowerDataCollector::PowerDataCollector(const bool testing)
+    : testing_(testing) {
+  AddRef();
+
+  if (!testing) {
+    DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(this);
+  }
+}
+
+void PowerDataCollector::Shutdown_Instance() {
+  if (!testing_) {
+    DBusThreadManager *dbus_manager = DBusThreadManager::Get();
+
+    // Destroy the power data collector before the DBusThreadManager.
+    CHECK(dbus_manager);
+
+    dbus_manager->GetPowerManagerClient()->RemoveObserver(this);
+  }
+
+  Release();
+}
+
+void PowerDataCollector::PowerChanged(
+    const power_manager::PowerSupplyProperties& prop) {
+  base::Time now = base::Time::NowFromSystemTime();

[Daniel Erat, 2013/12/11 01:06:52]

use base::TimeTicks (CLOCK_MONOTONIC), not base::Time (wall time)

[Siva Chandra, 2013/12/11 20:32:02]

Done.

+
+  PowerSupplySnapshot snapshot = {
+      now.ToInternalValue(),
+      prop.external_power() !=
+          power_manager::PowerSupplyProperties::DISCONNECTED,
+      prop.battery_percent()};
+
+  content::BrowserThread::PostBlockingPoolSequencedTask(
+      kPowerSupplySnapshotSequence,
+      FROM_HERE,
+      base::Bind(
+          &PowerDataCollector::AppendPowerSupplySnapshot, this, snapshot));
+}
+
+void PowerDataCollector::AppendPowerSupplySnapshot(
+    const PowerDataCollector::PowerSupplySnapshot& snapshot) {
+  base::AutoLock auto_lock(power_supply_lock_);
+  power_supply_.push_back(snapshot);
+}
+
+void PowerDataCollector::Initialize() {
+  // Check that power data collector is initialized only after the
+  // DBusThreadManager is initialized.
+  CHECK(DBusThreadManager::Get());
+
+  // Do no allow intializing twice.
+  CHECK(power_data_collector == NULL);
+
+  power_data_collector = new PowerDataCollector(false);
+}
+
+void PowerDataCollector::InitializeTesting() {
+  power_data_collector = new PowerDataCollector(true);
+}
+
+PowerDataCollector *PowerDataCollector::Get() {
+  CHECK(power_data_collector);
+
+  return power_data_collector;
+}
+
+void PowerDataCollector::Shutdown() {
+  // Shutdown only if initialized.
+  CHECK(power_data_collector);
+
+  power_data_collector->Shutdown_Instance();
+
+  // NULL it to protect from improper usage after shutdown.
+  power_data_collector = NULL;
+}
+
+void PowerDataCollector::LockPowerSupplyData(void) {
+  power_data_collector->power_supply_lock_.Acquire();
+}
+
+void PowerDataCollector::UnlockPowerSupplyData(void) {
+  power_data_collector->power_supply_lock_.Release();
+}
+
+std::vector<PowerDataCollector::PowerSupplySnapshot>
+&PowerDataCollector::GetPowerSupplyData() {
+  // Do not allow calling this method after shutdown or before initialization.
+  CHECK(power_data_collector);
+
+  return power_data_collector->power_supply_;
+}
+
+}  // namespace chromeos