Surface battery auditing information on the website settings option page.

chrome/browser/ui/webui/options/website_settings_handler.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/ui/webui/options/website_settings_handler.h"
 
 #include "apps/app_window_registry.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "components/power/origin_power_map.h"
+#include "components/power/origin_power_map_factory.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 #include "ui/base/text/bytes_formatting.h"
 
+using power::OriginPowerMap;
+using power::OriginPowerMapFactory;
+
 namespace {
 
 const int kHttpPort = 80;
 const int kHttpsPort = 443;
 const char kPreferencesSource[] = "preference";
 const char kStorage[] = "storage";
 const ContentSettingsType kValidTypes[] = {CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                            CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                            CONTENT_SETTINGS_TYPE_MEDIASTREAM};
 const size_t kValidTypesLength = arraysize(kValidTypes);
@@ skipping 14 matching lines @@
 
   static OptionsStringResource resources[] = {
       {"websitesOptionsPageTabTitle", IDS_WEBSITE_SETTINGS_TITLE},
       {"websitesSettingsEditPage", IDS_WEBSITE_SETTINGS_EDIT_TITLE},
       {"websitesManage", IDS_WEBSITE_SETTINGS_MANAGE},
       {"websitesSearch", IDS_WEBSITE_SETTINGS_SEARCH_ORIGINS},
       {"websitesLabelGeolocation", IDS_WEBSITE_SETTINGS_TYPE_LOCATION},
       {"websitesLabelMediaStream", IDS_WEBSITE_SETTINGS_TYPE_MEDIASTREAM},
       {"websitesLabelNotifications", IDS_WEBSITE_SETTINGS_TYPE_NOTIFICATIONS},
       {"websitesLabelStorage", IDS_WEBSITE_SETTINGS_TYPE_STORAGE},
+      {"websitesLabelBattery", IDS_WEBSITE_SETTINGS_TYPE_BATTERY},
       {"websitesLocationDescription",
        IDS_WEBSITE_SETTINGS_LOCATION_DESCRIPTION},
       {"websitesMediastreamDescription",
        IDS_WEBSITE_SETTINGS_MEDIASTREAM_DESCRIPTION},
       {"websitesNotificationsDescription",
        IDS_WEBSITE_SETTINGS_NOTIFICATIONS_DESCRIPTION},
       {"websitesButtonClear", IDS_WEBSITE_SETTINGS_STORAGE_CLEAR_BUTTON},
+      {"websitesButtonStop", IDS_WEBSITE_SETTINGS_BATTERY_STOP_BUTTON},
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterTitle(
       localized_strings, "websiteSettingsPage", IDS_WEBSITE_SETTINGS_TITLE);
 }
 
 void WebsiteSettingsHandler::InitializeHandler() {
   Profile* profile = Profile::FromWebUI(web_ui());
   HostContentSettingsMap* settings = profile->GetHostContentSettingsMap();
@@ skipping 10 matching lines @@
       "updateOriginsSearchResults",
       base::Bind(&WebsiteSettingsHandler::HandleUpdateSearchResults,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "updateLocalStorage",
       base::Bind(&WebsiteSettingsHandler::HandleUpdateLocalStorage,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
+      "updateBatteryUsage",
+      base::Bind(&WebsiteSettingsHandler::HandleUpdateBatteryUsage,
+                 base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
       "getOriginInfo",
       base::Bind(&WebsiteSettingsHandler::HandleGetOriginInfo,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "setOriginPermission",
       base::Bind(&WebsiteSettingsHandler::HandleSetOriginPermission,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
@@ skipping 232 matching lines @@
   scoped_ptr<base::Value> v(map->GetWebsiteSetting(
       last_site_, last_site_, settings_type, std::string(), &info));
   map->SetNarrowestWebsiteSetting(primary_pattern,
                                   secondary_pattern,
                                   settings_type,
                                   std::string(),
                                   setting,
                                   info);
 }
 
+void WebsiteSettingsHandler::HandleUpdateBatteryUsage(
+    const base::ListValue* args) {
+  base::DictionaryValue power_map;
+  OriginPowerMap* origins =
+      OriginPowerMapFactory::GetForBrowserContext(Profile::FromWebUI(web_ui()));
+  OriginPowerMap::PercentOriginMap percent_map = origins->GetPercentOriginMap();
+  for (std::map<GURL, int>::iterator it = percent_map.begin();
+       it != percent_map.end();
+       ++it) {
+    std::string origin = it->first.spec();
+
+    if (origin.find(last_filter_) == base::string16::npos)
+      continue;
+
+    base::DictionaryValue* origin_entry = new base::DictionaryValue();
+    origin_entry->SetWithoutPathExpansion(

[Bernhard Bauer, 2014/08/26 08:16:07]

The ...WithoutPathExpansion variant isn't necessary if you know that the key
doesn't contain periods. And there's SetInt to directly set an integer.

[Daniel Nishi, 2014/08/26 17:45:39]

Done.

+        "usage", new base::FundamentalValue(it->second));
+    origin_entry->SetWithoutPathExpansion(

[Bernhard Bauer, 2014/08/26 08:16:07]

SetString() here.

[Daniel Nishi, 2014/08/26 17:45:39]

Done.

+        "usageString",
+        new base::StringValue(l10n_util::GetStringFUTF16Int(
+            IDS_WEBSITE_SETTINGS_BATTERY_PERCENT, it->second)));
+    power_map.SetWithoutPathExpansion(origin, origin_entry);
+  }
+  web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
+                                   power_map);
+}
+
 void WebsiteSettingsHandler::HandleDeleteLocalStorage(
     const base::ListValue* args) {
   DCHECK(!last_site_.is_empty());
   DeleteLocalStorage(last_site_);
 }
 
 void WebsiteSettingsHandler::HandleStopOrigin(const base::ListValue* args) {
   DCHECK(!last_site_.is_empty());
   StopOrigin(last_site_);
 }
 
 void WebsiteSettingsHandler::GetInfoForOrigin(const GURL& site_url,
                                               bool show_page) {
   Profile* profile = Profile::FromWebUI(web_ui());
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
 
   double storage = 0.0;
   for (LocalStorageList::const_iterator it = local_storage_list_.begin();
        it != local_storage_list_.end();
        it++) {
     if (it->origin_url == site_url) {
       storage = static_cast<double>(it->size);
       break;
     }
   }
 
+  int battery = 0;
+  battery = OriginPowerMapFactory::GetForBrowserContext(
+                Profile::FromWebUI(web_ui()))->GetPowerForOrigin(site_url);

[Bernhard Bauer, 2014/08/26 08:16:08]

Indent just four spaces w/r/t the preceding line.

[Daniel Nishi, 2014/08/26 17:45:39]

Done.

+
   base::DictionaryValue* permissions = new base::DictionaryValue;
   for (size_t i = 0; i < arraysize(kValidTypes); ++i) {
     ContentSettingsType permission_type = kValidTypes[i];
 
     // Append the possible settings.
     base::ListValue* options = new base::ListValue;
     ContentSetting default_value =
         map->GetDefaultContentSetting(permission_type, NULL);
     if (default_value != CONTENT_SETTING_ALLOW &&
         default_value != CONTENT_SETTING_BLOCK) {
@@ skipping 37 matching lines @@
         "setting", content_settings::ContentSettingToString(permission));
     permission_info->SetWithoutPathExpansion("options", options);
     permission_info->SetBooleanWithoutPathExpansion(
         "editable", info.source == content_settings::SETTING_SOURCE_USER);
     permissions->SetWithoutPathExpansion(
         content_settings::GetTypeName(permission_type), permission_info);
   }
 
   base::Value* storage_used = new base::StringValue(l10n_util::GetStringFUTF16(
       IDS_WEBSITE_SETTINGS_STORAGE_USED, ui::FormatBytes(storage)));
+  base::Value* battery_used =
+      new base::StringValue(l10n_util::GetStringFUTF16Int(
+          IDS_WEBSITE_SETTINGS_BATTERY_USED, battery));
 
   web_ui()->CallJavascriptFunction("WebsiteSettingsEditor.populateOrigin",
                                    *storage_used,
+                                   *battery_used,
                                    *permissions,
                                    base::FundamentalValue(show_page));
 }
 
 void WebsiteSettingsHandler::UpdateLocalStorage() {
   base::DictionaryValue local_storage_map;
   for (LocalStorageList::const_iterator it = local_storage_list_.begin();
        it != local_storage_list_.end();
        it++) {
     std::string origin = it->origin_url.spec();
@@ skipping 54 matching lines @@
 
   // Load a new BrowsingDataLocalStorageHelper to update.
   local_storage_ = new BrowsingDataLocalStorageHelper(profile);
 
   local_storage_->StartFetching(
       base::Bind(&WebsiteSettingsHandler::OnLocalStorageFetched,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace options