Add ProcessPowerCollector to audit power information.

chrome/browser/power/process_power_collector.cc

Index: chrome/browser/power/process_power_collector.cc
diff --git a/chrome/browser/power/process_power_collector.cc b/chrome/browser/power/process_power_collector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3322d0e5868c9cef157d008aa3e9745cbd61dfa1
--- /dev/null
+++ b/chrome/browser/power/process_power_collector.cc
@@ -0,0 +1,173 @@
+// Copyright 2014 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/power/process_power_collector.h"
+
+#include "apps/app_window.h"
+#include "apps/app_window_registry.h"
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+#include "base/process/process_handle.h"
+#include "base/process/process_metrics.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
+#include "components/power/origin_power_map.h"
+#include "components/power/origin_power_map_factory.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/web_contents.h"
+#include "url/gurl.h"
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/power/power_data_collector.h"
+#endif
+
+namespace {
+const int kSecondsPerSample = 30;
+}
+
+ProcessPowerCollector::ProcessPowerCollector()
+    : metrics_map_(new ProcessMetricsMap),
+      update_requests_(0),
+      weak_ptr_factory_(this) {
+}
+
+ProcessPowerCollector::~ProcessPowerCollector() {
+}
+
+void ProcessPowerCollector::StartUpdating() {
+  // Don't allow multiple start updates.
+  update_requests_++;

[Daniel Erat, 2014/08/15 20:22:12]

why do you need to track the number of updates? if you use a timer (see below),
you can just add a DCHECK() here that it isn't already running

[Daniel Nishi, 2014/08/18 17:38:47]

Done.

+  if (update_requests_ > 1) {
+    return;
+  }
+  DCHECK_EQ(1, update_requests_);
+
+  UpdatePowerConsumptionCallback();
+}
+
+void ProcessPowerCollector::UpdatePowerConsumptionCallback() {
+  UpdateMetricsMap();
+  RecordCpuUsageByOrigin(PopulateCpuUsageByOrigin());
+
+  // Schedule next update.
+  base::MessageLoop::current()->PostDelayedTask(

[Daniel Erat, 2014/08/15 20:22:12]

any reason not to use base::RepeatingTimer instead? you won't need the
WeakPtrFactory then.

[Daniel Nishi, 2014/08/18 17:38:47]

Done.

+      FROM_HERE,
+      base::Bind(&ProcessPowerCollector::UpdatePowerConsumptionCallback,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::TimeDelta::FromSeconds(kSecondsPerSample));
+}
+
+void ProcessPowerCollector::UpdateMetricsMap() {
+  // Update all tabs.
+  for (TabContentsIterator it; !it.done(); it.Next()) {
+    content::RenderProcessHost* render_process = it->GetRenderProcessHost();
+    // Skip incognito web contents.
+    if (render_process->GetBrowserContext()->IsOffTheRecord()) {
+      continue;
+    }
+    AddProcessToMap(render_process, it->GetLastCommittedURL().GetOrigin());
+  }
+
+  // Iterate over all profiles to find all app windows to attribute all apps.
+  ProfileManager* pm = g_browser_process->profile_manager();
+  std::vector<Profile*> open_profiles = pm->GetLoadedProfiles();
+  for (std::vector<Profile*>::const_iterator it = open_profiles.begin();
+       it != open_profiles.end();
+       ++it) {
+    const apps::AppWindowRegistry::AppWindowList& app_windows =
+        apps::AppWindowRegistry::Get(*it)->app_windows();
+    for (apps::AppWindowRegistry::AppWindowList::const_iterator itr =
+             app_windows.begin();
+         itr != app_windows.end();
+         ++itr) {
+      content::WebContents* web_contents = (*itr)->web_contents();
+
+      AddProcessToMap(web_contents->GetRenderProcessHost(),
+                      web_contents->GetLastCommittedURL().GetOrigin());
+    }
+  }
+}
+
+double ProcessPowerCollector::PopulateCpuUsageByOrigin() {
+  ProcessMetricsMap::iterator it = metrics_map_->begin();
+  double cpu_cycle = 0.0;
+  while (it != metrics_map_->end()) {
+    // If the process doesn't exist anymore, remove it.
+    if (it->second.last_cpu < 0) {
+      metrics_map_->erase(it++);
+      continue;
+    }
+    it->second.last_cpu = it->second.metrics->GetCPUUsage();
+
+    // Skip errors.
+    if (it->second.last_cpu < 0) {
+      it++;
+      continue;
+    }
+
+    cpu_cycle += it->second.last_cpu;
+    it++;
+  }
+
+  return cpu_cycle;
+}
+
+void ProcessPowerCollector::RecordCpuUsageByOrigin(double cpu_cycle) {
+#if defined(OS_CHROMEOS)
+  // Don't record data yet if no power data exists yet.
+  chromeos::PowerDataCollector* power_data_collector =

[Daniel Erat, 2014/08/15 20:22:12]

can you just observe chromeos/dbus/power_manager_client.h here for
PowerChanged()? seems more direct than adding a dependency on PowerDataCollector

[Daniel Nishi, 2014/08/18 17:38:47]

The only power event this needs access to is the most recent one. Observing for
PowerChanged() seems like it'd wake up this class for mostly power events that
wouldn't get used.

+      chromeos::PowerDataCollector::Get();
+  if (power_data_collector->power_supply_data().empty())
+    return;
+
+  chromeos::PowerDataCollector::PowerSupplySample sample =
+      power_data_collector->power_supply_data().back();
+
+  // Don't record data if plugged in.
+  if (sample.external_power) {

[Daniel Erat, 2014/08/15 20:22:12]

nit: omit curly brackets

[Daniel Nishi, 2014/08/18 17:38:48]

Done.

+    return;
+  }
+#endif

[Daniel Erat, 2014/08/15 20:22:12]

shouldn't you also be checking whether we're on battery power on other systems?

[Daniel Nishi, 2014/08/18 17:38:48]

The API for monitoring battery status on other platforms right now is currently
in development. I'm keeping my eye on content/browser/battery_status/.

[Daniel Erat, 2014/08/18 20:43:04]

what about base/power_monitor/power_monitor.h? sadly, it doesn't work on chrome
os: http://crbug.com/326534

[Daniel Nishi, 2014/08/19 19:24:20]

It's probably worth saying that the main reason we stop collecting power
information on battery power is that CrOS reports a negative discharge rate
during charging, making power attribution via discharge rate impossible. We
don't have that problem in other OSes for their heuristics, so I'm not sure if
it is worth stopping when on battery.

It looks like it'd work, though, if we wanted to go that route on those
platforms.

+
+  ProcessMetricsMap::iterator it = metrics_map_->begin();
+  while (it != metrics_map_->end()) {
+    double site_delta = it->second.last_cpu;
+#if defined(OS_CHROMEOS)
+    // Only query discharge rate if there is a battery.
+    if (sample.battery_percent > -1 && cpu_cycle > 0)
+      site_delta = site_delta * sample.battery_discharge_rate / cpu_cycle;

[Daniel Erat, 2014/08/15 20:22:12]

i don't understand this code -- what does this scaling do, and why is it only
present on chrome os?

[Daniel Nishi, 2014/08/18 17:38:47]

This attributes the actual discharge rate of the system proportionally to the
origins. We can only query the battery discharge in CrOS right now, so it's a
CrOS only heuristic.

+#endif
+
+    GURL origin = it->second.last_origin;
+    power::OriginPowerMap* origin_power_map =
+        power::OriginPowerMapFactory::GetForBrowserContext(it->second.profile);
+    DCHECK(origin_power_map);
+    origin_power_map->AddPowerForOrigin(origin, site_delta);
+
+    // Invalidate |last_cpu| for the next cycle.
+    it->second.last_cpu = -1;
+    it++;
+  }
+}
+
+void ProcessPowerCollector::AddProcessToMap(
+    const content::RenderProcessHost* rph,
+    const GURL& origin) {
+  base::ProcessHandle handle = rph->GetHandle();
+  if (metrics_map_->find(handle) == metrics_map_->end()) {
+#if defined(OS_MACOSX)
+    (*metrics_map_)[handle] = PerProcessData(
+        base::ProcessMetrics::CreateProcessMetrics(handle, NULL));
+#else
+    (*metrics_map_)[handle] =
+        PerProcessData(base::ProcessMetrics::CreateProcessMetrics(handle));
+#endif
+  }
+  (*metrics_map_)[handle].last_origin = origin;
+  (*metrics_map_)[handle].profile =
+      Profile::FromBrowserContext(rph->GetBrowserContext());
+  (*metrics_map_)[handle].last_cpu = 0;
+}