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>
 
@@ skipping 26 matching lines @@
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/common/constants.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #endif
@@ skipping 113 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());
+  exception->SetString(kOrigin, pattern.ToString(extensions::kExtensionScheme));
   exception->SetString(kEmbeddingOrigin,
                        secondary_pattern == ContentSettingsPattern::Wildcard() ?
                            std::string() :
-                           secondary_pattern.ToString());
+                           secondary_pattern.ToString(
+                               extensions::kExtensionScheme));
   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();
   exception->SetString(kSetting, ContentSettingToString(setting));
-  exception->SetString(kOrigin, origin.ToString());
-  exception->SetString(kEmbeddingOrigin, embedding_origin.ToString());
+  exception->SetString(kOrigin, origin.ToString(extensions::kExtensionScheme));
+  exception->SetString(kEmbeddingOrigin,
+                       embedding_origin.ToString(extensions::kExtensionScheme));
   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();
   exception->SetString(kSetting, ContentSettingToString(setting));
-  exception->SetString(kOrigin, pattern.ToString());
+  exception->SetString(kOrigin, pattern.ToString(extensions::kExtensionScheme));
   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 735 matching lines @@
     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);
     media_settings_.exceptions.push_back(MediaException(
-        ContentSettingsPattern::FromString(origin),
+        ContentSettingsPattern::FromString(extensions::kExtensionScheme,
+                                           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 192 matching lines @@
   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);
   DesktopNotificationProfileUtil::ClearSetting(profile,
-      ContentSettingsPattern::FromString(origin));
+      ContentSettingsPattern::FromString(extensions::kExtensionScheme, 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),
-                                    ContentSettingsPattern::Wildcard(),
-                                    CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                                    std::string(),
-                                    NULL);
-    settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(pattern),
-                                    ContentSettingsPattern::Wildcard(),
-                                    CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                                    std::string(),
-                                    NULL);
+    settings_map->SetWebsiteSetting(
+        ContentSettingsPattern::FromString(extensions::kExtensionScheme,
+                                           pattern),
+        ContentSettingsPattern::Wildcard(),
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+        std::string(),
+        NULL);
+    settings_map->SetWebsiteSetting(
+        ContentSettingsPattern::FromString(extensions::kExtensionScheme,
+                                           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) {
     settings_map->SetWebsiteSetting(
-        ContentSettingsPattern::FromString(pattern),
+        ContentSettingsPattern::FromString(extensions::kExtensionScheme,
+                                           pattern),
         secondary_pattern.empty() ?
             ContentSettingsPattern::Wildcard() :
-            ContentSettingsPattern::FromString(secondary_pattern),
+            ContentSettingsPattern::FromString(extensions::kExtensionScheme,
+                                               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),
-                                    ContentSettingsPattern::Wildcard(),
-                                    type,
-                                    std::string(),
-                                    ContentSettingFromString(setting));
+    settings_map->SetContentSetting(
+        ContentSettingsPattern::FromString(extensions::kExtensionScheme,
+                                           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));
 
   ContentSettingsPattern pattern =
-      ContentSettingsPattern::FromString(pattern_string);
+      ContentSettingsPattern::FromString(extensions::kExtensionScheme,
+                                         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