Add a dropdown to change the default content setting to the Website Settings 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 "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"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/grit/generated_resources.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/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/constants.h"
 #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"
 
+#if defined(OS_CHROMEOS)
+#include "components/user_manager/user_manager.h"
+#endif
+
+using base::UserMetricsAction;
 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";
@@ skipping 111 matching lines @@
 
   web_ui()->RegisterMessageCallback(
       "deleteLocalStorage",
       base::Bind(&WebsiteSettingsHandler::HandleDeleteLocalStorage,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "stopOrigin",
       base::Bind(&WebsiteSettingsHandler::HandleStopOrigin,
                  base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      "updateDefaultSetting",
+      base::Bind(&WebsiteSettingsHandler::HandleUpdateDefaultSetting,
+                 base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      "setDefaultContentSetting",
+      base::Bind(&WebsiteSettingsHandler::HandleSetDefaultSetting,
+                 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 48 matching lines @@
   std::string site;
   bool rv = args->GetString(0, &site);
   DCHECK(rv);
 
   GURL last_site(site);
   if (!last_site.is_valid())
     return;
 
   last_site_ = last_site;
   base::StringValue site_value(site);
-  web_ui()->CallJavascriptFunction("WebsiteSettingsManager.showEditPage",
+  web_ui()->CallJavascriptFunction("WebsiteSettingsEditor.showEditPage",
                                    site_value);
 }
 
 void WebsiteSettingsHandler::OnLocalStorageFetched(const std::list<
     BrowsingDataLocalStorageHelper::LocalStorageInfo>& storage) {
   local_storage_list_ = storage;
   Update();
   GetInfoForOrigin(last_site_, false);
 }
 
@@ skipping 179 matching lines @@
     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_);
 }
 
+// TODO(dhnishi): Remove default settings duplication from the
+//                WebsiteSettingsHandler and the ContentSettingsHandler.
+void WebsiteSettingsHandler::HandleUpdateDefaultSetting(
+    const base::ListValue* args) {
+  ContentSettingsType last_setting;
+  content_settings::GetTypeFromName(last_setting_, &last_setting);
+
+  base::DictionaryValue filter_settings;
+  std::string provider_id;
+  filter_settings.SetString(
+      "value", GetSettingDefaultFromModel(last_setting, &provider_id));
+  filter_settings.SetString("managedBy", provider_id);
+
+  web_ui()->CallJavascriptFunction("WebsiteSettingsManager.updateDefault",
+                                   filter_settings);
+}
+
+void WebsiteSettingsHandler::HandleSetDefaultSetting(
+    const base::ListValue* args) {
+  DCHECK_EQ(1U, args->GetSize());
+  std::string setting;
+  if (!args->GetString(0, &setting)) {
+    NOTREACHED();
+    return;
+  }
+  ContentSetting new_default =
+      content_settings::ContentSettingFromString(setting);
+
+  ContentSettingsType last_setting;
+  content_settings::GetTypeFromName(last_setting_, &last_setting);
+  Profile* profile = Profile::FromWebUI(web_ui());
+
+#if defined(OS_CHROMEOS)
+  // ChromeOS special case : in Guest mode settings are opened in Incognito
+  // mode, so we need original profile to actually modify settings.
+  if (user_manager::UserManager::Get()->IsLoggedInAsGuest())
+    profile = profile->GetOriginalProfile();
+#endif
+
+  HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
+  map->SetDefaultContentSetting(last_setting, new_default);
+
+  switch (last_setting) {
+    case CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultMultipleAutomaticDLSettingChange"));
+      break;
+    case CONTENT_SETTINGS_TYPE_COOKIES:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultCookieSettingChanged"));
+      break;
+    case CONTENT_SETTINGS_TYPE_GEOLOCATION:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultGeolocationSettingChanged"));
+      break;
+    case CONTENT_SETTINGS_TYPE_IMAGES:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultImagesSettingChanged"));
+      break;
+    case CONTENT_SETTINGS_TYPE_JAVASCRIPT:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultJavaScriptSettingChanged"));
+      break;
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultMediaStreamMicSettingChanged"));
+      break;
+    case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultNotificationsSettingChanged"));
+      break;
+    case CONTENT_SETTINGS_TYPE_PLUGINS:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultPluginsSettingChanged"));
+      break;
+    case CONTENT_SETTINGS_TYPE_POPUPS:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultPopupsSettingChanged"));
+      break;
+    default:
+      NOTREACHED();
+      return;
+  }
+}
+
 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 121 matching lines @@
         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);
 }
 
+std::string WebsiteSettingsHandler::GetSettingDefaultFromModel(
+    ContentSettingsType type,
+    std::string* provider_id) {
+  Profile* profile = Profile::FromWebUI(web_ui());
+  ContentSetting default_setting =
+      profile->GetHostContentSettingsMap()->GetDefaultContentSetting(
+          type, provider_id);
+
+  return content_settings::ContentSettingToString(default_setting);
+}
+
 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