Add Origin Power Map to Store Battery Auditing Data.

chrome/browser/power/origin_power_map.cc

+// 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/origin_power_map.h"
+
+#include "base/memory/ref_counted.h"
+#include "base/prefs/pref_service.h"
+#include "base/prefs/scoped_user_pref_update.h"
+#include "chrome/common/pref_names.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "content/public/common/url_constants.h"
+#include "url/gurl.h"
+
+OriginPowerMap::OriginPowerMap(PrefService* prefs)
+    : total_consumed_(0), prefs_(prefs) {
+  DictionaryPrefUpdate update(prefs_, prefs::kBatteryOriginMap);

[sky, 2014/08/06 23:59:22]

Is kBatteryOriginMap effectively going to become every url I've visited? If so,
preferences isn't intended for that volume of data.

[Daniel Nishi, 2014/08/07 21:15:08]

Would replacing this with a SQLite Database be an acceptable solution?

[sky, 2014/08/07 21:47:07]

Why do you need to make this data persistent at all? Seems to me reporting data
for the current session should be useful enough.
That said, I also don't like that this code is potentially going to track all
urls I visit and never prune. You need some sort of pruning strategy in here.
Maybe tracking the active tabs with a steep fall off curve for anything that
isn't active. I also think people don't necessarily care about power useage per
url, rather per host.

[Daniel Nishi, 2014/08/07 22:43:11]

Ah, I should have specified -- it is intended to be used per-origin, not
per-URL. I'll add a DCHECK to enforce that only origin URLs come in.

I'll discuss the persistence of the data and come up with a more concrete
invalidation plan. 

+  base::DictionaryValue* old_values = update.Get();
+  for (base::DictionaryValue::Iterator i(*old_values); !i.IsAtEnd();
+       i.Advance()) {
+    double value = 0.0;
+    bool rv = i.value().GetAsDouble(&value);
+
+    if (!rv)
+      continue;
+
+    origin_map_[GURL(i.key())] = value;
+    total_consumed_ += value;
+  }
+}
+
+OriginPowerMap::~OriginPowerMap() {
+}
+
+int OriginPowerMap::GetPowerForOrigin(const GURL& origin) {
+  if (origin_map_.find(origin) == origin_map_.end())
+    return -1;
+  else if (!total_consumed_)
+    return 0;
+  return origin_map_[origin] * 100 / total_consumed_;
+}
+
+void OriginPowerMap::AddPowerForOrigin(const GURL& origin, double power) {
+  if (!origin.is_valid() || origin.SchemeIs(content::kChromeUIScheme))
+    return;
+
+  if (origin_map_.find(origin) == origin_map_.end()) {
+    origin_map_[origin] = 0;
+  }
+  origin_map_[origin] += power;
+  total_consumed_ += power;
+}
+
+scoped_ptr<OriginPowerMap::ScaledOriginMap>
+OriginPowerMap::GetScaledOriginMap() {
+  scoped_ptr<OriginPowerMap::ScaledOriginMap> percent_map(
+      new OriginPowerMap::ScaledOriginMap);
+  for (OriginMap::iterator it = origin_map_.begin(); it != origin_map_.end();
+       ++it) {
+    (*percent_map)[it->first] = (it->second / total_consumed_ * 100);
+  }
+  return percent_map.Pass();
+}
+
+void OriginPowerMap::SavePrefs() {
+  DictionaryPrefUpdate update(prefs_, prefs::kBatteryOriginMap);
+  base::DictionaryValue* origin_entries = update.Get();
+  DCHECK(origin_entries);
+
+  for (OriginMap::iterator it = origin_map_.begin(); it != origin_map_.end();
+       ++it) {
+    GURL origin = it->first;
+    origin_entries->SetDoubleWithoutPathExpansion(origin.spec(),
+                                                  origin_map_[origin]);
+  }
+}
+
+void OriginPowerMap::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterDictionaryPref(
+      prefs::kBatteryOriginMap,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}