Clean content_settings_pattern_parser.* from unnecessary dependencies.

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/content_settings_provider.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/common/chrome_content_settings_client.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/content_settings_pattern.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 130 matching lines @@
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in a HostContentSettingsMap-controlled exceptions table (e.g., cookies).
 // Ownership of the pointer is passed to the caller.
 base::DictionaryValue* GetExceptionForPage(
     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());
+  content_settings::ChromeContentSettingsClient client;
+  exception->SetString(kOrigin, pattern.ToString(&client));
   exception->SetString(kEmbeddingOrigin,
                        secondary_pattern == ContentSettingsPattern::Wildcard() ?
                            std::string() :
-                           secondary_pattern.ToString());
+                           secondary_pattern.ToString(&client));
   exception->SetString(kSetting, ContentSettingToString(setting));
   exception->SetString(kSource, provider_name);
   return exception;
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in the Geolocation exceptions table. Ownership of the pointer is passed to
 // the caller.
 base::DictionaryValue* GetGeolocationExceptionForPage(
     const ContentSettingsPattern& origin,
     const ContentSettingsPattern& embedding_origin,
     ContentSetting setting) {
   base::DictionaryValue* exception = new base::DictionaryValue();
+  content_settings::ChromeContentSettingsClient client;
   exception->SetString(kSetting, ContentSettingToString(setting));
-  exception->SetString(kOrigin, origin.ToString());
-  exception->SetString(kEmbeddingOrigin, embedding_origin.ToString());
+  exception->SetString(kOrigin, origin.ToString(&client));
+  exception->SetString(kEmbeddingOrigin, embedding_origin.ToString(&client));
   return exception;
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in the desktop notifications exceptions table. Ownership of the pointer is
 // passed to the caller.
 base::DictionaryValue* GetNotificationExceptionForPage(
     const ContentSettingsPattern& pattern,
     ContentSetting setting,
     const std::string& provider_name) {
   base::DictionaryValue* exception = new base::DictionaryValue();
+  content_settings::ChromeContentSettingsClient client;
   exception->SetString(kSetting, ContentSettingToString(setting));
-  exception->SetString(kOrigin, pattern.ToString());
+  exception->SetString(kOrigin, pattern.ToString(&client));
   exception->SetString(kSource, provider_name);
   return 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() &&
@@ skipping 734 matching lines @@
     base::DictionaryValue* media_dict = NULL;
     bool result = (*media_entry)->GetAsDictionary(&media_dict);
     DCHECK(result);
 
     std::string origin;
     std::string audio_setting;
     std::string video_setting;
     media_dict->GetString(kOrigin, &origin);
     media_dict->GetString(kSetting, &audio_setting);
     media_dict->GetString(kVideoSetting, &video_setting);
+    content_settings::ChromeContentSettingsClient client;
     media_settings_.exceptions.push_back(MediaException(
-        ContentSettingsPattern::FromString(origin),
+        ContentSettingsPattern::FromString(&client, origin),
         ContentSettingFromString(audio_setting),
         ContentSettingFromString(video_setting)));
   }
   PepperFlashContentSettingsUtils::SortMediaExceptions(
       &media_settings_.exceptions);
   media_settings_.exceptions_initialized = true;
   UpdateFlashMediaLinksVisibility();
 
   base::StringValue type_string(
        ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_MEDIASTREAM));
@@ skipping 191 matching lines @@
   std::string origin;
   std::string setting;
   bool rv = args->GetString(1, &origin);
   DCHECK(rv);
   rv = args->GetString(2, &setting);
   DCHECK(rv);
   ContentSetting content_setting = ContentSettingFromString(setting);
 
   DCHECK(content_setting == CONTENT_SETTING_ALLOW ||
          content_setting == CONTENT_SETTING_BLOCK);
+  content_settings::ChromeContentSettingsClient client;
   DesktopNotificationProfileUtil::ClearSetting(profile,
-      ContentSettingsPattern::FromString(origin));
+      ContentSettingsPattern::FromString(&client, origin));
 }
 
 void ContentSettingsHandler::RemoveMediaException(const base::ListValue* args) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
   DCHECK(rv);
 
   std::string pattern;
   rv = args->GetString(2, &pattern);
   DCHECK(rv);
 
   HostContentSettingsMap* settings_map =
       mode == "normal" ? GetContentSettingsMap() :
                          GetOTRContentSettingsMap();
   if (settings_map) {
-    settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(pattern),
+    content_settings::ChromeContentSettingsClient client;
+    settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(&client,
+                                                                       pattern),
                                     ContentSettingsPattern::Wildcard(),
                                     CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                                     std::string(),
                                     NULL);
-    settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(pattern),
+    settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(&client,
+                                                                       pattern),
                                     ContentSettingsPattern::Wildcard(),
                                     CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
                                     std::string(),
                                     NULL);
   }
 }
 
 void ContentSettingsHandler::RemoveExceptionFromHostContentSettingsMap(
     const base::ListValue* args,
     ContentSettingsType type) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
   DCHECK(rv);
 
   std::string pattern;
   rv = args->GetString(2, &pattern);
   DCHECK(rv);
 
   // The fourth argument to this handler is optional.
   std::string secondary_pattern;
   if (args->GetSize() >= 4U) {
     rv = args->GetString(3, &secondary_pattern);
     DCHECK(rv);
   }
 
   HostContentSettingsMap* settings_map =
       mode == "normal" ? GetContentSettingsMap() :
                          GetOTRContentSettingsMap();
   if (settings_map) {
+    content_settings::ChromeContentSettingsClient client;
     settings_map->SetWebsiteSetting(
-        ContentSettingsPattern::FromString(pattern),
+        ContentSettingsPattern::FromString(&client, pattern),
         secondary_pattern.empty() ?
             ContentSettingsPattern::Wildcard() :
-            ContentSettingsPattern::FromString(secondary_pattern),
+            ContentSettingsPattern::FromString(&client, secondary_pattern),
         type,
         std::string(),
         NULL);
   }
 }
 
 void ContentSettingsHandler::RemoveZoomLevelException(
     const base::ListValue* args) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
@@ skipping 176 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;
-    settings_map->SetContentSetting(ContentSettingsPattern::FromString(pattern),
+    content_settings::ChromeContentSettingsClient client;
+    settings_map->SetContentSetting(ContentSettingsPattern::FromString(&client,
+                                                                       pattern),
                                     ContentSettingsPattern::Wildcard(),
                                     type,
                                     std::string(),
                                     ContentSettingFromString(setting));
   }
 }
 
 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;
   CHECK(args->GetString(2, &pattern_string));
 
+  content_settings::ChromeContentSettingsClient client;
   ContentSettingsPattern pattern =
-      ContentSettingsPattern::FromString(pattern_string);
+      ContentSettingsPattern::FromString(&client, pattern_string);
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.patternValidityCheckComplete",
       base::StringValue(type_string),
       base::StringValue(mode_string),
       base::StringValue(pattern_string),
       base::FundamentalValue(pattern.IsValid()));
 }
 
 // static
@@ skipping 111 matching lines @@
 void ContentSettingsHandler::UpdateProtectedContentExceptionsButton() {
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   // Exceptions apply only when the feature is enabled.
   bool enable_exceptions = prefs->GetBoolean(prefs::kEnableDRM);
   web_ui()->CallJavascriptFunction(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options