Add a global on/off switch for content settings and expose a toggle on the Website Settings options…

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 57 matching lines @@
   DCHECK(localized_strings);
 
   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},
       {"websitesLabelLocation", IDS_WEBSITE_SETTINGS_TYPE_LOCATION},
       {"websitesLabelMediaStream", IDS_WEBSITE_SETTINGS_TYPE_MEDIASTREAM},
       {"websitesLabelNotifications", IDS_WEBSITE_SETTINGS_TYPE_NOTIFICATIONS},
+      {"websitesLabelOn", IDS_WEBSITE_SETTINGS_CONTENT_SETTING_ENABLED},
       {"websitesLabelStorage", IDS_WEBSITE_SETTINGS_TYPE_STORAGE},
       {"websitesLabelBattery", IDS_WEBSITE_SETTINGS_TYPE_BATTERY},
       {"websitesCookiesDescription", IDS_WEBSITE_SETTINGS_COOKIES_DESCRIPTION},
       {"websitesLocationDescription",
        IDS_WEBSITE_SETTINGS_LOCATION_DESCRIPTION},
       {"websitesMediaStreamDescription",
        IDS_WEBSITE_SETTINGS_MEDIASTREAM_DESCRIPTION},
       {"websitesNotificationsDescription",
        IDS_WEBSITE_SETTINGS_NOTIFICATIONS_DESCRIPTION},
       {"websitesDownloadsDescription",
@@ skipping 75 matching lines @@
 
   web_ui()->RegisterMessageCallback(
       "updateDefaultSetting",
       base::Bind(&WebsiteSettingsHandler::HandleUpdateDefaultSetting,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "setDefaultContentSetting",
       base::Bind(&WebsiteSettingsHandler::HandleSetDefaultSetting,
                  base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      "setGlobalEnabled",
+      base::Bind(&WebsiteSettingsHandler::HandleSetGlobalToggle,
+                 base::Unretained(this)));
 }
 
 // content_settings::Observer implementation.
 void WebsiteSettingsHandler::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     std::string resource_identifier) {
   Update();
 }
@@ skipping 109 matching lines @@
          origin_url.IntPort() == kHttpPort) ||
         (origin_url.SchemeIs(url::kHttpsScheme) &&
          origin_url.IntPort() == kHttpsPort)) {
       url::Replacements<char> replacements;
       replacements.ClearPort();
       origin = origin_url.ReplaceComponents(replacements).spec();
     }
 
     // Mediastream isn't set unless both mic and camera are set to the same.
     if (last_setting == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC) {
-      ContentSetting cam_setting =
-          settings->GetContentSetting(origin_url,
-                                      origin_url,
-                                      CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                                      std::string());
+      ContentSetting cam_setting = settings->GetContentSettingWithoutOverride(
+          origin_url,
+          origin_url,
+          CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+          std::string());
       if (it->setting != cam_setting)
         continue;
     }
 
     if (origin.find(last_filter_) == base::string16::npos)
       continue;
 
     base::Time last_usage = settings->GetLastUsageByPattern(
         it->primary_pattern, it->secondary_pattern, last_setting);
 
     base::DictionaryValue* origin_entry = new base::DictionaryValue();
     origin_entry->SetDoubleWithoutPathExpansion("usage",
                                                 last_usage.ToDoubleT());
     base::string16 usage_string;
     if (last_usage.ToDoubleT()) {
       usage_string = ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_ELAPSED,
                                             ui::TimeFormat::LENGTH_SHORT,
                                             base::Time::Now() - last_usage);
     }
     origin_entry->SetStringWithoutPathExpansion("usageString", usage_string);
     origin_entry->SetStringWithoutPathExpansion("readableName",
                                                 GetReadableName(origin_url));
 
     if (it->setting == CONTENT_SETTING_BLOCK)
       blocked_origins.SetWithoutPathExpansion(origin, origin_entry);
     else
       allowed_origins.SetWithoutPathExpansion(origin, origin_entry);
   }
 
+  bool is_globally_allowed = settings->GetContentSettingOverride(last_setting);
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
                                    allowed_origins,
-                                   blocked_origins);
+                                   blocked_origins,
+                                   base::FundamentalValue(is_globally_allowed));
 }
 
 void WebsiteSettingsHandler::HandleGetOriginInfo(const base::ListValue* args) {
   std::string url;
   bool rv = args->GetString(0, &url);
   DCHECK(rv);
   GURL origin(url);
 
   if (!origin.is_valid())
     return;
@@ skipping 55 matching lines @@
     case CONTENT_SETTINGS_TYPE_POPUPS:
       primary_pattern = ContentSettingsPattern::FromURLNoWildcard(last_site_);
       secondary_pattern = ContentSettingsPattern::FromURLNoWildcard(last_site_);
       break;
     default:
       NOTREACHED() << "Content settings type not yet supported.";
       return;
   }
 
   content_settings::SettingInfo info;
-  scoped_ptr<base::Value> v(map->GetWebsiteSetting(
+  scoped_ptr<base::Value> v(map->GetWebsiteSettingWithoutOverride(
       last_site_, last_site_, settings_type, std::string(), &info));
   map->SetNarrowestWebsiteSetting(primary_pattern,
                                   secondary_pattern,
                                   settings_type,
                                   std::string(),
                                   setting,
                                   info);
 }
 
 void WebsiteSettingsHandler::HandleUpdateBatteryUsage(
@@ skipping 91 matching lines @@
     case CONTENT_SETTINGS_TYPE_POPUPS:
       content::RecordAction(
           UserMetricsAction("Options_DefaultPopupsSettingChanged"));
       break;
     default:
       NOTREACHED();
       return;
   }
 }
 
+void WebsiteSettingsHandler::HandleSetGlobalToggle(
+    const base::ListValue* args) {
+  DCHECK_EQ(1U, args->GetSize());
+  bool is_enabled;
+  bool rv = args->GetBoolean(0, &is_enabled);
+  DCHECK(rv);
+
+  ContentSettingsType last_setting;
+  rv = content_settings::GetTypeFromName(last_setting_, &last_setting);
+  DCHECK(rv);
+
+  Profile* profile = Profile::FromWebUI(web_ui());
+  HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
+  map->SetContentSettingOverride(last_setting, is_enabled);
+}
+
 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) {
@@ skipping 24 matching lines @@
     options->AppendString(
         content_settings::ContentSettingToString(CONTENT_SETTING_BLOCK));
     if (permission_type == CONTENT_SETTINGS_TYPE_COOKIES) {
       options->AppendString(content_settings::ContentSettingToString(
           CONTENT_SETTING_SESSION_ONLY));
     }
 
     ContentSetting permission;
     content_settings::SettingInfo info;
     if (permission_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) {
-      scoped_ptr<base::Value> mic_value(
-          map->GetWebsiteSetting(site_url,
-                                 site_url,
-                                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                                 std::string(),
-                                 &info));
+      scoped_ptr<base::Value> mic_value(map->GetWebsiteSettingWithoutOverride(
+          site_url,
+          site_url,
+          CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+          std::string(),
+          &info));
       ContentSetting mic_setting =
           content_settings::ValueToContentSetting(mic_value.get());
-      ContentSetting cam_setting =
-          map->GetContentSetting(site_url,
-                                 site_url,
-                                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                                 std::string());
+      ContentSetting cam_setting = map->GetContentSettingWithoutOverride(
+          site_url,
+          site_url,
+          CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+          std::string());
 
       if (mic_setting != cam_setting)
         permission = CONTENT_SETTING_ASK;
       else
         permission = mic_setting;
     } else {
-      scoped_ptr<base::Value> v(map->GetWebsiteSetting(
+      scoped_ptr<base::Value> v(map->GetWebsiteSettingWithoutOverride(
           site_url, site_url, permission_type, std::string(), &info));
       permission = content_settings::ValueToContentSetting(v.get());
     }
 
     base::DictionaryValue* permission_info = new base::DictionaryValue;
     permission_info->SetStringWithoutPathExpansion(
         "setting", content_settings::ContentSettingToString(permission));
     permission_info->SetWithoutPathExpansion("options", options);
     permission_info->SetBooleanWithoutPathExpansion(
         "editable", info.source == content_settings::SETTING_SOURCE_USER);
@@ skipping 135 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