Update the Website Settings page when the power consumption is updated.

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 "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 14 matching lines @@
 #include "extensions/common/extension.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 char kBattery[] = "battery";
 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,
     CONTENT_SETTINGS_TYPE_COOKIES};
 const size_t kValidTypesLength = arraysize(kValidTypes);
+
 }  // namespace
 
 namespace options {
 
 WebsiteSettingsHandler::WebsiteSettingsHandler()
-    : observer_(this), weak_ptr_factory_(this) {
+    : observer_(this),
+      weak_ptr_factory_(this) {
 }
 
 WebsiteSettingsHandler::~WebsiteSettingsHandler() {
 }
 
 void WebsiteSettingsHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
   static OptionsStringResource resources[] = {
@@ skipping 19 matching lines @@
 
   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();
   observer_.Add(settings);
+
+  power::OriginPowerMap* origin_power_map =
+      power::OriginPowerMapFactory::GetForBrowserContext(profile);
+  // OriginPowerMap may not be available in tests.
+  if (origin_power_map) {
+    subscription_ = origin_power_map->AddPowerConsumptionUpdatedCallback(
+        base::Bind(&WebsiteSettingsHandler::Update, base::Unretained(this)));
+  }
 }
 
 void WebsiteSettingsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "updateOrigins",
       base::Bind(&WebsiteSettingsHandler::HandleUpdateOrigins,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "updateOriginsSearchResults",
@@ skipping 110 matching lines @@
     BrowsingDataLocalStorageHelper::LocalStorageInfo>& storage) {
   local_storage_list_ = storage;
   Update();
   GetInfoForOrigin(last_site_, false);
 }
 
 void WebsiteSettingsHandler::Update() {
   DCHECK(!last_setting_.empty());
   if (last_setting_ == kStorage)
     UpdateLocalStorage();
+  else if (last_setting_ == kBattery)
+    UpdateBatteryUsage();
   else
     UpdateOrigins();
 }
 
 void WebsiteSettingsHandler::UpdateOrigins() {
   Profile* profile = Profile::FromWebUI(web_ui());
   HostContentSettingsMap* settings = profile->GetHostContentSettingsMap();
 
   ContentSettingsForOneType all_settings;
   ContentSettingsType last_setting;
@@ skipping 141 matching lines @@
   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->SetInteger("usage", it->second);
-    origin_entry->SetString(
-        "usageString",
-        l10n_util::GetStringFUTF16Int(IDS_WEBSITE_SETTINGS_BATTERY_PERCENT,
-                                      it->second));
-    origin_entry->SetStringWithoutPathExpansion(
-        "readableName", GetReadableName(it->first));
-    power_map.SetWithoutPathExpansion(origin, origin_entry);
-  }
-  web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
-                                   power_map);
+  last_setting_ = kBattery;
+  UpdateBatteryUsage();
 }
 
 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());
@@ skipping 107 matching lines @@
     origin_entry->SetWithoutPathExpansion(
         "usageString", new base::StringValue(ui::FormatBytes(it->size)));
     origin_entry->SetStringWithoutPathExpansion(
         "readableName", GetReadableName(it->origin_url));
     local_storage_map.SetWithoutPathExpansion(origin, origin_entry);
   }
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
                                    local_storage_map);
 }
 
+void WebsiteSettingsHandler::UpdateBatteryUsage() {
+  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->SetInteger("usage", it->second);
+    origin_entry->SetString(
+        "usageString",
+        l10n_util::GetStringFUTF16Int(IDS_WEBSITE_SETTINGS_BATTERY_PERCENT,
+                                      it->second));
+    origin_entry->SetStringWithoutPathExpansion("readableName",
+                                                GetReadableName(it->first));
+    power_map.SetWithoutPathExpansion(origin, origin_entry);
+  }
+  web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
+                                   power_map);
+}
+
 void WebsiteSettingsHandler::StopOrigin(const GURL& site_url) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (site_url.SchemeIs(extensions::kExtensionScheme)) {
     const extensions::Extension* extension =
         extensions::ExtensionRegistry::Get(profile)
             ->enabled_extensions()
             .GetHostedAppByURL(site_url);
     if (extension) {
       extensions::AppWindowRegistry::Get(profile)
           ->CloseAllAppWindowsForApp(extension->id());
@@ skipping 47 matching lines @@
     // If extension is NULL, it was removed and we cannot look up its name.
     if (!extension)
       return site_url.spec();
 
     return extension->name();
   }
   return site_url.spec();
 }
 
 }  // namespace options