MD Site Settings: Add five new top level categories

chrome/browser/ui/webui/options/content_settings_handler.cc

 // Copyright (c) 2012 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/content_settings_handler.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 81 matching lines @@
 
 namespace {
 
 struct ContentSettingWithExceptions {
   ContentSettingWithExceptions(bool otr, UserMetricsAction action)
       : has_otr_exceptions(otr), uma(action) {}
   bool has_otr_exceptions;
   UserMetricsAction uma;
 };
 
-struct ContentSettingsTypeNameEntry {
-  ContentSettingsType type;
-  const char* name;
-};

[Finnur, 2016/05/31 21:59:55]

This and next three deleted sections were moved to the helper.

-
 // Maps from the UI string to the object it represents (for sorting purposes).
 typedef std::multimap<std::string, const base::DictionaryValue*> SortedObjects;
 // Maps from a secondary URL to the set of objects it has permission to access.
 typedef std::map<GURL, SortedObjects> OneOriginObjects;
 // Maps from a primary URL/source pair to a OneOriginObjects. All the mappings
 // in OneOriginObjects share the given primary URL and source.
 typedef std::map<std::pair<GURL, std::string>, OneOriginObjects>
     AllOriginObjects;
 
 // The AppFilter is used in AddExceptionsGrantedByHostedApps() to choose
 // extensions which should have their extent displayed.
 typedef bool (*AppFilter)(const extensions::Extension& app,
                           content::BrowserContext* profile);
 
 const char kExceptionsLearnMoreUrl[] =
     "https://support.google.com/chrome/?p=settings_manage_exceptions";
 
 const char kAppName[] = "appName";
 const char kAppId[] = "appId";
 const char kZoom[] = "zoom";
 const char kObject[] = "object";
 const char kObjectName[] = "objectName";
 
-const ContentSettingsTypeNameEntry kContentSettingsTypeGroupNames[] = {
-  {CONTENT_SETTINGS_TYPE_COOKIES, "cookies"},
-  {CONTENT_SETTINGS_TYPE_IMAGES, "images"},
-  {CONTENT_SETTINGS_TYPE_JAVASCRIPT, "javascript"},
-  {CONTENT_SETTINGS_TYPE_PLUGINS, "plugins"},
-  {CONTENT_SETTINGS_TYPE_POPUPS, "popups"},
-  {CONTENT_SETTINGS_TYPE_GEOLOCATION, "location"},
-  {CONTENT_SETTINGS_TYPE_NOTIFICATIONS, "notifications"},
-  {CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, "auto-select-certificate"},
-  {CONTENT_SETTINGS_TYPE_FULLSCREEN, "fullscreen"},
-  {CONTENT_SETTINGS_TYPE_MOUSELOCK, "mouselock"},
-  {CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS, "register-protocol-handler"},
-  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, "media-stream-mic"},
-  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, "media-stream-camera"},
-  {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, "ppapi-broker"},
-  {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, "multiple-automatic-downloads"},
-  {CONTENT_SETTINGS_TYPE_MIDI_SYSEX, "midi-sysex"},
-  {CONTENT_SETTINGS_TYPE_PUSH_MESSAGING, "push-messaging"},
-  {CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS, "ssl-cert-decisions"},
-#if defined(OS_CHROMEOS)
-  {CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, "protectedContent"},
-#endif
-  {CONTENT_SETTINGS_TYPE_KEYGEN, "keygen"},
-  {CONTENT_SETTINGS_TYPE_BACKGROUND_SYNC, "background-sync"},
-};
-
 ChooserContextBase* GetUsbChooserContext(Profile* profile) {
   return UsbChooserContextFactory::GetForProfile(profile);
 }
 
 const ContentSettingsHandler::ChooserTypeNameEntry kChooserTypeGroupNames[] = {
     {CONTENT_SETTINGS_TYPE_USB_CHOOSER_DATA, &GetUsbChooserContext,
      "usb-devices", "name"},
 };
 
 // A pseudo content type. We use it to display data like a content setting even
@@ skipping 101 matching lines @@
             UserMetricsAction("Options_DefaultBackgroundSyncSettingChanged"))));
   }
 
   return exceptions_info_map;
 }
 
 content::BrowserContext* GetBrowserContext(content::WebUI* web_ui) {
   return web_ui->GetWebContents()->GetBrowserContext();
 }
 
-ContentSettingsType ContentSettingsTypeFromGroupName(const std::string& name) {
-  for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
-    if (name == kContentSettingsTypeGroupNames[i].name)
-      return kContentSettingsTypeGroupNames[i].type;
-  }
-
-  NOTREACHED() << name << " is not a recognized content settings type.";
-  return CONTENT_SETTINGS_TYPE_DEFAULT;
-}
-
 const ContentSettingsHandler::ChooserTypeNameEntry* ChooserTypeFromGroupName(
     const std::string& name) {
   for (const auto& chooser_type : kChooserTypeGroupNames) {
     if (chooser_type.name == name)
       return &chooser_type;
   }
   return nullptr;
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
@@ skipping 568 matching lines @@
       provider_id = site_settings::kPolicyProviderId;
     }
   }
 
   base::DictionaryValue filter_settings;
 
   std::string setting_string =
       content_settings::ContentSettingToString(default_setting);
   DCHECK(!setting_string.empty());
 
-  filter_settings.SetString(ContentSettingsTypeToGroupName(type) + ".value",
-                            setting_string);
   filter_settings.SetString(
-      ContentSettingsTypeToGroupName(type) + ".managedBy", provider_id);
+      site_settings::ContentSettingsTypeToGroupName(type) + ".value",
+      setting_string);
+  filter_settings.SetString(
+      site_settings::ContentSettingsTypeToGroupName(type) + ".managedBy",
+      provider_id);
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.setContentFilterSettingsValue", filter_settings);
 }
 
 void ContentSettingsHandler::UpdateMediaSettingsFromPrefs(
     ContentSettingsType type) {
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
   std::string policy_pref = (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)
@@ skipping 111 matching lines @@
          ++j) {
       // Skip the non-embedded setting which we already added above.
       if (j == parent)
         continue;
 
       exceptions.Append(GetGeolocationExceptionForPage(
           primary_pattern, j->first, j->second));
     }
   }
 
-  base::StringValue type_string(
-      ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_GEOLOCATION));
+  base::StringValue type_string(site_settings::ContentSettingsTypeToGroupName(
+      CONTENT_SETTINGS_TYPE_GEOLOCATION));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
                                    type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_GEOLOCATION);
 }
 
 void ContentSettingsHandler::UpdateNotificationExceptionsView() {
   Profile* profile = Profile::FromWebUI(web_ui());
@@ skipping 18 matching lines @@
       continue;
     }
 
     exceptions.Append(
         GetNotificationExceptionForPage(i->primary_pattern,
                                         i->secondary_pattern,
                                         i->setting,
                                         i->source));
   }
 
-  base::StringValue type_string(
-      ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
+  base::StringValue type_string(site_settings::ContentSettingsTypeToGroupName(
+      CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
                                    type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 }
 
 void ContentSettingsHandler::CompareMediaExceptionsWithFlash(
     ContentSettingsType type) {
@@ skipping 137 matching lines @@
   base::StringValue type_string(kZoomContentType);
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
                                    type_string, zoom_levels_exceptions);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   base::ListValue exceptions;
   site_settings::GetExceptionsFromHostContentSettingsMap(
       GetContentSettingsMap(), type, web_ui(), &exceptions);
-  base::StringValue type_string(ContentSettingsTypeToGroupName(type));
+  base::StringValue type_string(
+      site_settings::ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", type_string,
                                    exceptions);
 
   UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
 
   // TODO(koz): The default for fullscreen is always 'ask'.
   // http://crbug.com/104683
   if (type == CONTENT_SETTINGS_TYPE_FULLSCREEN)
     return;
 
 #if defined(OS_CHROMEOS)
   // Also the default for protected contents is managed in another place.
   if (type == CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER)
     return;
 #endif
 
   // The default may also have changed (we won't get a separate notification).
   // If it hasn't changed, this call will be harmless.
   UpdateSettingDefaultFromModel(type);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromOTRHostContentSettingsMap(
     ContentSettingsType type) {
   const HostContentSettingsMap* otr_settings_map = GetOTRContentSettingsMap();
   if (!otr_settings_map)
     return;
   base::ListValue exceptions;
   site_settings::GetExceptionsFromHostContentSettingsMap(
       otr_settings_map, type, web_ui(), &exceptions);
-  base::StringValue type_string(ContentSettingsTypeToGroupName(type));
+  base::StringValue type_string(
+      site_settings::ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunction("ContentSettings.setOTRExceptions",
                                    type_string, exceptions);
 }
 
 void ContentSettingsHandler::GetChooserExceptionsFromProfile(
     bool incognito,
     const ChooserTypeNameEntry& chooser_type,
     base::ListValue* exceptions) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (incognito) {
@@ skipping 192 matching lines @@
         args->GetString(1, &setting))) {
     NOTREACHED();
     return;
   }
 
   ContentSetting default_setting;
   bool result =
       content_settings::ContentSettingFromString(setting, &default_setting);
   DCHECK(result);
 
-  ContentSettingsType content_type = ContentSettingsTypeFromGroupName(group);
+  ContentSettingsType content_type =
+      site_settings::ContentSettingsTypeFromGroupName(group);
   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 =
@@ skipping 18 matching lines @@
     return;
   }
 
   const ChooserTypeNameEntry* chooser_type =
       ChooserTypeFromGroupName(type_string);
   if (chooser_type) {
     RemoveChooserException(chooser_type, args);
     return;
   }
 
-  ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
+  ContentSettingsType type =
+      site_settings::ContentSettingsTypeFromGroupName(type_string);
   RemoveExceptionFromHostContentSettingsMap(args, type);
 
   WebSiteSettingsUmaUtil::LogPermissionChange(
       type, ContentSetting::CONTENT_SETTING_DEFAULT);
 }
 
 void ContentSettingsHandler::SetException(const base::ListValue* args) {
   std::string type_string;
   CHECK(args->GetString(0, &type_string));
   std::string mode;
   CHECK(args->GetString(1, &mode));
   std::string pattern;
   CHECK(args->GetString(2, &pattern));
   std::string setting;
   CHECK(args->GetString(3, &setting));
 
-  ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
+  ContentSettingsType type =
+      site_settings::ContentSettingsTypeFromGroupName(type_string);
 
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
       type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
       type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
     NOTREACHED();
   } else {
     HostContentSettingsMap* settings_map =
         mode == "normal" ? GetContentSettingsMap() :
                            GetOTRContentSettingsMap();
 
@@ skipping 27 matching lines @@
       ContentSettingsPattern::FromString(pattern_string);
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.patternValidityCheckComplete",
       base::StringValue(type_string),
       base::StringValue(mode_string),
       base::StringValue(pattern_string),
       base::FundamentalValue(pattern.IsValid()));
 }
 
-// static
-std::string ContentSettingsHandler::ContentSettingsTypeToGroupName(
-    ContentSettingsType type) {
-  for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
-    if (type == kContentSettingsTypeGroupNames[i].type)
-      return kContentSettingsTypeGroupNames[i].name;
-  }
-
-  NOTREACHED();
-  return std::string();
-}
-
 HostContentSettingsMap* ContentSettingsHandler::GetContentSettingsMap() {
   return HostContentSettingsMapFactory::GetForProfile(
       Profile::FromWebUI(web_ui()));
 }
 
 ProtocolHandlerRegistry* ContentSettingsHandler::GetProtocolHandlerRegistry() {
   return ProtocolHandlerRegistryFactory::GetForBrowserContext(
       GetBrowserContext(web_ui()));
 }
 
@@ skipping 105 matching lines @@
     ShowFlashMediaLink(EXCEPTIONS, type, true);
   }
 }
 
 void ContentSettingsHandler::UpdateMediaDeviceDropdownVisibility(
     ContentSettingsType type) {
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.setDevicesMenuVisibility",
-      base::StringValue(ContentSettingsTypeToGroupName(type)),
+      base::StringValue(site_settings::ContentSettingsTypeToGroupName(type)),
       base::FundamentalValue(!settings.policy_disable));
 }
 
 void ContentSettingsHandler::UpdateProtectedContentExceptionsButton() {
 #if defined(OS_CHROMEOS)
   // Guests cannot modify exceptions. UIAccountTweaks will disabled the button.
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest())
     return;
 #endif
 
   // Exceptions apply only when the feature is enabled.
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   bool enable_exceptions = prefs->GetBoolean(prefs::kEnableDRM);
   web_ui()->CallJavascriptFunction(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options