Making structure for ContentSettings and its corresponding strings.

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 <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 168 matching lines @@
     const ContentSettingsPattern& pattern,
     const ContentSettingsPattern& secondary_pattern,
     const ContentSetting& setting,
     const std::string& provider_name) {
   base::DictionaryValue* exception = new base::DictionaryValue();
   exception->SetString(kOrigin, pattern.ToString());
   exception->SetString(kEmbeddingOrigin,
                        secondary_pattern == ContentSettingsPattern::Wildcard() ?
                            std::string() :
                            secondary_pattern.ToString());
-  exception->SetString(kSetting, ContentSettingToString(setting));
+
+  std::string setting_string;
+  bool return_value =

[Bernhard Bauer, 2015/10/07 11:38:21]

Call this variable |success| maybe? |return_value| is overly generic.

[Deepak, 2015/10/07 13:54:43]

Done.

+      content_settings::ContentSettingToString(setting, &setting_string);
+  DCHECK(return_value);
+
+  exception->SetString(kSetting, setting_string);
   exception->SetString(kSource, provider_name);
   return make_scoped_ptr(exception);
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in the Geolocation exceptions table.
 scoped_ptr<base::DictionaryValue> GetGeolocationExceptionForPage(
     const ContentSettingsPattern& origin,
     const ContentSettingsPattern& embedding_origin,
     ContentSetting setting) {
   base::DictionaryValue* exception = new base::DictionaryValue();
-  exception->SetString(kSetting, ContentSettingToString(setting));
+
+  std::string setting_string;
+  bool return_value =
+      content_settings::ContentSettingToString(setting, &setting_string);
+  DCHECK(return_value);
+
+  exception->SetString(kSetting, setting_string);
   exception->SetString(kOrigin, origin.ToString());
   exception->SetString(kEmbeddingOrigin, embedding_origin.ToString());
   return make_scoped_ptr(exception);
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in the desktop notifications exceptions table.
 scoped_ptr<base::DictionaryValue> GetNotificationExceptionForPage(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSetting setting,
     const std::string& provider_name) {
   std::string embedding_origin;
   if (secondary_pattern != ContentSettingsPattern::Wildcard())
     embedding_origin = secondary_pattern.ToString();
 
   base::DictionaryValue* exception = new base::DictionaryValue();
-  exception->SetString(kSetting, ContentSettingToString(setting));
+
+  std::string setting_string;
+  bool return_value =
+      content_settings::ContentSettingToString(setting, &setting_string);
+  DCHECK(return_value);
+
+  exception->SetString(kSetting, setting_string);
   exception->SetString(kOrigin, primary_pattern.ToString());
   exception->SetString(kEmbeddingOrigin, embedding_origin);
   exception->SetString(kSource, provider_name);
   return make_scoped_ptr(exception);
 }
 
 // Returns true whenever the |extension| is hosted and has |permission|.
 // Must have the AppFilter signature.
 template <APIPermission::ID permission>
 bool HostedAppHasPermission(const extensions::Extension& extension,
                             content::BrowserContext* /* context */) {
   return extension.is_hosted_app() &&
          extension.permissions_data()->HasAPIPermission(permission);
 }
 
 // Add an "Allow"-entry to the list of |exceptions| for a |url_pattern| from
 // the web extent of a hosted |app|.
 void AddExceptionForHostedApp(const std::string& url_pattern,
     const extensions::Extension& app, base::ListValue* exceptions) {
   base::DictionaryValue* exception = new base::DictionaryValue();
-  exception->SetString(kSetting, ContentSettingToString(CONTENT_SETTING_ALLOW));
+
+  std::string setting_string;
+  bool return_value = content_settings::ContentSettingToString(
+      CONTENT_SETTING_ALLOW, &setting_string);
+  DCHECK(return_value);
+
+  exception->SetString(kSetting, setting_string);
   exception->SetString(kOrigin, url_pattern);
   exception->SetString(kEmbeddingOrigin, url_pattern);
   exception->SetString(kSource, "HostedApp");
   exception->SetString(kAppName, app.name());
   exception->SetString(kAppId, app.id());
   exceptions->Append(exception);
 }
 
 // Asks the |profile| for hosted apps which have the |permission| set, and
 // adds their web extent and launch URL to the |exceptions| list.
@@ skipping 94 matching lines @@
     {"manageHandlers", IDS_HANDLERS_MANAGE},
     {"exceptionPatternHeader", IDS_EXCEPTIONS_PATTERN_HEADER},
     {"exceptionBehaviorHeader", IDS_EXCEPTIONS_ACTION_HEADER},
     {"exceptionZoomHeader", IDS_EXCEPTIONS_ZOOM_HEADER},
     {"embeddedOnHost", IDS_EXCEPTIONS_GEOLOCATION_EMBEDDED_ON_HOST},
     // Cookies filter.
     {"cookiesTabLabel", IDS_COOKIES_TAB_LABEL},
     {"cookiesHeader", IDS_COOKIES_HEADER},
     {"cookiesAllow", IDS_COOKIES_ALLOW_RADIO},
     {"cookiesBlock", IDS_COOKIES_BLOCK_RADIO},
-    {"cookiesSession", IDS_COOKIES_SESSION_ONLY_RADIO},
+    {"cookiesSessionOnly", IDS_COOKIES_SESSION_ONLY_RADIO},
     {"cookiesBlock3rdParty", IDS_COOKIES_BLOCK_3RDPARTY_CHKBOX},
     {"cookiesShowCookies", IDS_COOKIES_SHOW_COOKIES_BUTTON},
     {"flashStorageSettings", IDS_FLASH_STORAGE_SETTINGS},
     {"flashStorageUrl", IDS_FLASH_STORAGE_URL},
 #if defined(ENABLE_GOOGLE_NOW)
     {"googleGeolocationAccessEnable",
      IDS_GEOLOCATION_GOOGLE_ACCESS_ENABLE_CHKBOX},
 #endif
     // Image filter.
     {"imagesTabLabel", IDS_IMAGES_TAB_LABEL},
@@ skipping 101 matching lines @@
           ->Get(CONTENT_SETTINGS_TYPE_PLUGINS)
           ->default_value_pref_name());
 
   int default_value = CONTENT_SETTING_DEFAULT;
   bool success = default_pref->GetAsInteger(&default_value);
   DCHECK(success);
   DCHECK_NE(CONTENT_SETTING_DEFAULT, default_value);
 
   int plugin_ids = default_value == CONTENT_SETTING_DETECT_IMPORTANT_CONTENT ?
       IDS_PLUGIN_DETECT_RECOMMENDED_RADIO : IDS_PLUGIN_DETECT_RADIO;
-  localized_strings->SetString("pluginsDetect",
+  localized_strings->SetString("pluginsDetectImportantContent",
                                l10n_util::GetStringUTF16(plugin_ids));
 
   RegisterTitle(localized_strings, "contentSettingsPage",
                 IDS_CONTENT_SETTINGS_TITLE);
 
   // Register titles for each of the individual settings whose exception
   // dialogs will be processed by |ContentSettingsHandler|.
   RegisterTitle(localized_strings, "cookies",
                 IDS_COOKIES_TAB_LABEL);
   RegisterTitle(localized_strings, "images",
@@ skipping 220 matching lines @@
   if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
       type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
     UpdateMediaSettingsFromPrefs(type);
     if (media_settings_->forType(type).policy_disable) {
       default_setting = CONTENT_SETTING_BLOCK;
       provider_id = kPolicyProviderId;
     }
   }
 
   base::DictionaryValue filter_settings;
+
+  std::string setting_string;
+  bool return_value = content_settings::ContentSettingToString(default_setting,
+                                                               &setting_string);
+  DCHECK(return_value);
+
   filter_settings.SetString(ContentSettingsTypeToGroupName(type) + ".value",
-                            ContentSettingToString(default_setting));
+                            setting_string);
   filter_settings.SetString(
       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()));
@@ skipping 182 matching lines @@
        entry != exceptions.end(); ++entry) {
     base::DictionaryValue* dict = nullptr;
     bool valid_dict = (*entry)->GetAsDictionary(&dict);
     DCHECK(valid_dict);
 
     std::string origin;
     std::string setting;
     dict->GetString(kOrigin, &origin);
     dict->GetString(kSetting, &setting);
 
+    ContentSetting setting_type = CONTENT_SETTING_DEFAULT;
+    bool result =
+        content_settings::ContentSettingFromString(setting, &setting_type);
+    DCHECK(result);
+
     settings.exceptions.push_back(MediaException(
         ContentSettingsPattern::FromString(origin),
-        ContentSettingFromString(setting)));
+        setting_type));
   }
 
   PepperFlashContentSettingsUtils::SortMediaExceptions(
       &settings.exceptions);
 
   settings.exceptions_initialized = true;
   UpdateFlashMediaLinksVisibility(type);
 }
 
 void ContentSettingsHandler::UpdateMIDISysExExceptionsView() {
@@ skipping 75 matching lines @@
       }
       case content::HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST:
         // These are not stored in preferences and get cleared on next browser
         // start. Therefore, we don't care for them.
         continue;
       case content::HostZoomMap::PAGE_SCALE_IS_ONE_CHANGED:
         continue;
       case content::HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM:
         NOTREACHED();
     }
-    exception->SetString(kSetting,
-                         ContentSettingToString(CONTENT_SETTING_DEFAULT));
+
+    std::string setting_string;
+    bool return_value = content_settings::ContentSettingToString(
+        CONTENT_SETTING_DEFAULT, &setting_string);
+    DCHECK(return_value);
+
+    exception->SetString(kSetting, setting_string);
 
     // Calculate the zoom percent from the factor. Round up to the nearest whole
     // number.
     int zoom_percent = static_cast<int>(
         content::ZoomLevelToZoomFactor(i->zoom_level) * 100 + 0.5);
     exception->SetString(
         kZoom,
         l10n_util::GetStringFUTF16(IDS_ZOOM_PERCENT,
                                    base::IntToString16(zoom_percent)));
     exception->SetString(kSource, kPreferencesSource);
@@ skipping 282 matching lines @@
 
 void ContentSettingsHandler::SetContentFilter(const base::ListValue* args) {
   DCHECK_EQ(2U, args->GetSize());
   std::string group, setting;
   if (!(args->GetString(0, &group) &&
         args->GetString(1, &setting))) {
     NOTREACHED();
     return;
   }
 
-  ContentSetting default_setting = ContentSettingFromString(setting);
+  ContentSetting default_setting = CONTENT_SETTING_DEFAULT;
+  bool result =
+      content_settings::ContentSettingFromString(setting, &default_setting);
+  DCHECK(result);
+
   ContentSettingsType content_type = 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
 
@@ skipping 102 matching lines @@
     NOTREACHED();
   } else {
     HostContentSettingsMap* settings_map =
         mode == "normal" ? GetContentSettingsMap() :
                            GetOTRContentSettingsMap();
 
     // The settings map could be null if the mode was OTR but the OTR profile
     // got destroyed before we received this message.
     if (!settings_map)
       return;
+
+    ContentSetting setting_type = CONTENT_SETTING_DEFAULT;
+    bool result =
+        content_settings::ContentSettingFromString(setting, &setting_type);
+    DCHECK(result);
+
     settings_map->SetContentSetting(ContentSettingsPattern::FromString(pattern),
                                     ContentSettingsPattern::Wildcard(),
                                     type,
                                     std::string(),
-                                    ContentSettingFromString(setting));
+                                    setting_type);
   }
 }
 
 void ContentSettingsHandler::CheckExceptionPatternValidity(
     const base::ListValue* args) {
   std::string type_string;
   CHECK(args->GetString(0, &type_string));
   std::string mode_string;
   CHECK(args->GetString(1, &mode_string));
   std::string pattern_string;
@@ skipping 160 matching lines @@
 
   // 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