Move ContentSettingsDetails and Pattern out of HostContentSettingsMap as separate classes.

chrome/browser/content_settings/host_content_settings_map.cc

 // Copyright (c) 2010 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/content_settings/host_content_settings_map.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/prefs/scoped_pref_update.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "googleurl/src/url_parse.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_util.h"
 #include "net/base/static_cookie_policy.h"
 
 namespace {
-// The version of the pattern format implemented. Version 1 includes the
-// following patterns:
-//   - [*.]domain.tld (matches domain.tld and all sub-domains)
-//   - host (matches an exact hostname)
-//   - a.b.c.d (matches an exact IPv4 ip)
-//   - [a:b:c:d:e:f:g:h] (matches an exact IPv6 ip)
-//   - file:///tmp/test.html (a complete URL without a host)
-// Version 2 adds a resource identifier for plugins.
-// TODO(jochen): update once this feature is no longer behind a flag.
-const int kContentSettingsPatternVersion = 1;
-
-// The format of a domain wildcard.
-const char kDomainWildcard[] = "[*.]";
-
-// The length of kDomainWildcard (without the trailing '\0')
-const size_t kDomainWildcardLength = arraysize(kDomainWildcard) - 1;
 
 // Base pref path of the prefs that contain the managed default content
 // settings values.
 const std::string kManagedSettings =
       "profile.managed_default_content_settings";
 
 // The preference keys where resource identifiers are stored for
 // ContentSettingsType values that support resource identifiers.
 const char* kResourceTypeNames[CONTENT_SETTINGS_NUM_TYPES] = {
   NULL,
@@ skipping 76 matching lines @@
 }
 
 }  // namespace
 
 
 struct HostContentSettingsMap::ExtendedContentSettings {
   ContentSettings content_settings;
   ResourceContentSettings content_settings_for_resources;
 };
 
-// static
-HostContentSettingsMap::Pattern HostContentSettingsMap::Pattern::FromURL(
-    const GURL& url) {
-  return Pattern(!url.has_host() || url.HostIsIPAddress() ?
-      net::GetHostOrSpecFromURL(url) :
-      std::string(kDomainWildcard) + url.host());
-}
-
-// static
-HostContentSettingsMap::Pattern
-    HostContentSettingsMap::Pattern::FromURLNoWildcard(const GURL& url) {
-  return Pattern(net::GetHostOrSpecFromURL(url));
-}
-
-bool HostContentSettingsMap::Pattern::IsValid() const {
-  if (pattern_.empty())
-    return false;
-
-  const std::string host(pattern_.length() > kDomainWildcardLength &&
-                         StartsWithASCII(pattern_, kDomainWildcard, false) ?
-                         pattern_.substr(kDomainWildcardLength) :
-                         pattern_);
-  url_canon::CanonHostInfo host_info;
-  return host.find('*') == std::string::npos &&
-         !net::CanonicalizeHost(host, &host_info).empty();
-}
-
-bool HostContentSettingsMap::Pattern::Matches(const GURL& url) const {
-  if (!IsValid())
-    return false;
-
-  const std::string host(net::GetHostOrSpecFromURL(url));
-  if (pattern_.length() < kDomainWildcardLength ||
-      !StartsWithASCII(pattern_, kDomainWildcard, false))
-    return pattern_ == host;
-
-  const size_t match =
-      host.rfind(pattern_.substr(kDomainWildcardLength));
-
-  return (match != std::string::npos) &&
-         (match == 0 || host[match - 1] == '.') &&
-         (match + pattern_.length() - kDomainWildcardLength == host.length());
-}
-
-std::string HostContentSettingsMap::Pattern::CanonicalizePattern() const {
-  if (!IsValid()) {
-    return "";
-  }
-
-  bool starts_with_wildcard = pattern_.length() > kDomainWildcardLength &&
-      StartsWithASCII(pattern_, kDomainWildcard, false);
-
-  const std::string host(starts_with_wildcard ?
-      pattern_.substr(kDomainWildcardLength) : pattern_);
-
-  std::string canonicalized_pattern =
-      starts_with_wildcard ? kDomainWildcard : "";
-
-  url_canon::CanonHostInfo host_info;
-  canonicalized_pattern += net::CanonicalizeHost(host, &host_info);
-
-  return canonicalized_pattern;
-}
-
 HostContentSettingsMap::HostContentSettingsMap(Profile* profile)
     : profile_(profile),
       block_third_party_cookies_(false),
       is_block_third_party_cookies_managed_(false),
       is_off_the_record_(profile_->IsOffTheRecord()),
       updating_preferences_(false) {
   PrefService* prefs = profile_->GetPrefs();
 
   MigrateObsoleteCookiePref(prefs);
 
@@ skipping 10 matching lines @@
   block_third_party_cookies_ =
       prefs->GetBoolean(prefs::kBlockThirdPartyCookies);
   is_block_third_party_cookies_managed_ =
       prefs->IsManagedPreference(prefs::kBlockThirdPartyCookies);
   block_nonsandboxed_plugins_ =
       prefs->GetBoolean(prefs::kBlockNonsandboxedPlugins);
 
   // Verify preferences version.
   if (!prefs->HasPrefPath(prefs::kContentSettingsVersion)) {
     prefs->SetInteger(prefs::kContentSettingsVersion,
-                      kContentSettingsPatternVersion);
+                      ContentSettingsPattern::kContentSettingsPatternVersion);
   }
   if (prefs->GetInteger(prefs::kContentSettingsVersion) >
-      kContentSettingsPatternVersion) {
+      ContentSettingsPattern::kContentSettingsPatternVersion) {
     LOG(ERROR) << "Unknown content settings version in preferences.";
     return;
   }
 
   // Read exceptions.
   ReadExceptions(false);
 
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(prefs::kDefaultContentSettings, this);
   pref_change_registrar_.Add(prefs::kContentSettingsPatterns, this);
@@ skipping 12 matching lines @@
   pref_change_registrar_.Add(prefs::kManagedDefaultPluginsSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultPopupsSetting, this);
   notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
                               Source<Profile>(profile_));
 }
 
 // static
 void HostContentSettingsMap::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kDefaultContentSettings);
   prefs->RegisterIntegerPref(prefs::kContentSettingsVersion,
-                             kContentSettingsPatternVersion);
+      ContentSettingsPattern::kContentSettingsPatternVersion);
   prefs->RegisterDictionaryPref(prefs::kContentSettingsPatterns);
   prefs->RegisterBooleanPref(prefs::kBlockThirdPartyCookies, false);
   prefs->RegisterBooleanPref(prefs::kBlockNonsandboxedPlugins, false);
   prefs->RegisterIntegerPref(prefs::kContentSettingsWindowLastTabIndex, 0);
 
   // Preferences for default content setting policies. A policy is not set of
   // the corresponding preferences below is set to CONTENT_SETTING_DEFAULT.
   prefs->RegisterIntegerPref(prefs::kManagedDefaultCookiesSetting,
       CONTENT_SETTING_DEFAULT);
   prefs->RegisterIntegerPref(prefs::kManagedDefaultImagesSetting,
@@ skipping 75 matching lines @@
   // regular ones.
   i = off_the_record_settings_.find(host);
   if (i != off_the_record_settings_.end() &&
       i->second.content_settings_for_resources.find(requested_setting) !=
       i->second.content_settings_for_resources.end()) {
     return i->second.content_settings_for_resources.find(
         requested_setting)->second;
   }
 
   // Match patterns starting with the most concrete pattern match.
-  for (std::string key = std::string(kDomainWildcard) + host; ; ) {
+  for (std::string key =
+       std::string(ContentSettingsPattern::kDomainWildcard) + host; ; ) {
     HostContentSettings::const_iterator i(off_the_record_settings_.find(key));
     if (i != off_the_record_settings_.end() &&
         i->second.content_settings_for_resources.find(requested_setting) !=
         i->second.content_settings_for_resources.end()) {
       return i->second.content_settings_for_resources.find(
           requested_setting)->second;
     }
 
     i = host_content_settings_.find(key);
     if (i != host_content_settings_.end() &&
         i->second.content_settings_for_resources.find(requested_setting) !=
         i->second.content_settings_for_resources.end()) {
       return i->second.content_settings_for_resources.find(
           requested_setting)->second;
     }
 
-    const size_t next_dot = key.find('.', kDomainWildcardLength);
+    const size_t next_dot =
+        key.find('.', ContentSettingsPattern::kDomainWildcardLength);
     if (next_dot == std::string::npos)
       break;
-    key.erase(kDomainWildcardLength, next_dot - kDomainWildcardLength + 1);
+    key.erase(ContentSettingsPattern::kDomainWildcardLength,
+              next_dot - ContentSettingsPattern::kDomainWildcardLength + 1);
   }
 
   return CONTENT_SETTING_DEFAULT;
 }
 
 ContentSettings HostContentSettingsMap::GetContentSettings(
     const GURL& url) const {
   ContentSettings output = GetNonDefaultContentSettings(url);
 
   AutoLock auto_lock(lock_);
@@ skipping 39 matching lines @@
   // match. The additional off-the-record exceptions always overwrite the
   // regular ones.
   i = off_the_record_settings_.find(host);
   if (i != off_the_record_settings_.end()) {
     for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
       if (i->second.content_settings.settings[j] != CONTENT_SETTING_DEFAULT)
         output.settings[j] = i->second.content_settings.settings[j];
   }
 
   // Match patterns starting with the most concrete pattern match.
-  for (std::string key = std::string(kDomainWildcard) + host; ; ) {
+  for (std::string key =
+       std::string(ContentSettingsPattern::kDomainWildcard) + host; ; ) {
     HostContentSettings::const_iterator i(off_the_record_settings_.find(key));
     if (i != off_the_record_settings_.end()) {
       for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
         if (output.settings[j] == CONTENT_SETTING_DEFAULT)
           output.settings[j] = i->second.content_settings.settings[j];
       }
     }
     i = host_content_settings_.find(key);
     if (i != host_content_settings_.end()) {
       for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
         if (output.settings[j] == CONTENT_SETTING_DEFAULT)
           output.settings[j] = i->second.content_settings.settings[j];
       }
     }
-    const size_t next_dot = key.find('.', kDomainWildcardLength);
+    const size_t next_dot =
+        key.find('.', ContentSettingsPattern::kDomainWildcardLength);
     if (next_dot == std::string::npos)
       break;
-    key.erase(kDomainWildcardLength, next_dot - kDomainWildcardLength + 1);
+    key.erase(ContentSettingsPattern::kDomainWildcardLength,
+              next_dot - ContentSettingsPattern::kDomainWildcardLength + 1);
   }
 
   return output;
 }
 
 void HostContentSettingsMap::GetSettingsForOneType(
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     SettingsForOneType* settings) const {
   DCHECK(RequiresResourceIdentifier(content_type) !=
@@ skipping 16 matching lines @@
         setting = i->second.content_settings_for_resources.find(
             requested_setting)->second;
       else
         setting = CONTENT_SETTING_DEFAULT;
     } else {
      setting = i->second.content_settings.settings[content_type];
     }
     if (setting != CONTENT_SETTING_DEFAULT) {
       // Use of push_back() relies on the map iterator traversing in order of
       // ascending keys.
-      settings->push_back(std::make_pair(Pattern(i->first), setting));
+      settings->push_back(
+          std::make_pair(ContentSettingsPattern(i->first), setting));
     }
   }
 }
 
 void HostContentSettingsMap::SetDefaultContentSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_PLUGINS ||
@@ skipping 23 matching lines @@
       default_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
                                                               NULL);
     } else {
       default_content_settings_.settings[content_type] = setting;
       default_settings_dictionary->SetWithoutPathExpansion(
           dictionary_path, Value::CreateIntegerValue(setting));
     }
   }
   updating_preferences_ = false;
 
-  NotifyObservers(ContentSettingsDetails(Pattern(), content_type, ""));
+  NotifyObservers(
+      ContentSettingsDetails(ContentSettingsPattern(), content_type, ""));
 }
 
 void HostContentSettingsMap::SetContentSetting(
-    const Pattern& original_pattern,
+    const ContentSettingsPattern& original_pattern,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     ContentSetting setting) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_NE(RequiresResourceIdentifier(content_type),
             resource_identifier.empty());
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_PLUGINS ||
          setting != CONTENT_SETTING_ASK ||
          CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableClickToPlay));
 
-  const Pattern pattern(original_pattern.CanonicalizePattern());
+  const ContentSettingsPattern pattern(original_pattern.CanonicalizePattern());
 
   bool early_exit = false;
   std::string pattern_str(pattern.AsString());
   PrefService* prefs = NULL;
   DictionaryValue* all_settings_dictionary = NULL;
   HostContentSettings* map_to_modify = &off_the_record_settings_;
   if (!is_off_the_record_) {
     prefs = profile_->GetPrefs();
     all_settings_dictionary =
       prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
@@ skipping 78 matching lines @@
   NotifyObservers(ContentSettingsDetails(pattern, content_type, ""));
 }
 
 void HostContentSettingsMap::AddExceptionForURL(
     const GURL& url,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     ContentSetting setting) {
   // Make sure there is no entry that would override the pattern we are about
   // to insert for exactly this URL.
-  SetContentSetting(Pattern::FromURLNoWildcard(url),
+  SetContentSetting(ContentSettingsPattern::FromURLNoWildcard(url),
                     content_type,
                     resource_identifier,
                     CONTENT_SETTING_DEFAULT);
-  SetContentSetting(Pattern::FromURL(url),
+  SetContentSetting(ContentSettingsPattern::FromURL(url),
                     content_type,
                     resource_identifier,
                     setting);
 }
 
 void HostContentSettingsMap::ClearSettingsForOneType(
     ContentSettingsType content_type) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
 
   PrefService* prefs = NULL;
@@ skipping 38 matching lines @@
         ++i;
       }
     }
   }
 
   updating_preferences_ = true;
   if (!is_off_the_record_)
     ScopedPrefUpdate update(prefs, prefs::kContentSettingsPatterns);
   updating_preferences_ = false;
 
-  NotifyObservers(ContentSettingsDetails(Pattern(), content_type, ""));
+  NotifyObservers(
+      ContentSettingsDetails(ContentSettingsPattern(), content_type, ""));
 }
 
 bool HostContentSettingsMap::RequiresResourceIdentifier(
     ContentSettingsType content_type) const {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableResourceContentSettings)) {
     return kRequiresResourceIdentifier[content_type];
   } else {
     return false;
   }
@@ skipping 77 matching lines @@
     PrefService* prefs = profile_->GetPrefs();
     updating_preferences_ = true;
     prefs->ClearPref(prefs::kDefaultContentSettings);
     prefs->ClearPref(prefs::kContentSettingsPatterns);
     // If the block third party cookies preference is managed we still must
     // clear it in order to restore the default value for later when the
     // preference is not managed anymore.
     prefs->ClearPref(prefs::kBlockThirdPartyCookies);
     prefs->ClearPref(prefs::kBlockNonsandboxedPlugins);
     updating_preferences_ = false;
-    NotifyObservers(
-        ContentSettingsDetails(Pattern(), CONTENT_SETTINGS_TYPE_DEFAULT, ""));
+    NotifyObservers(ContentSettingsDetails(ContentSettingsPattern(),
+                                           CONTENT_SETTINGS_TYPE_DEFAULT,
+                                           ""));
   }
 }
 
 void HostContentSettingsMap::Observe(NotificationType type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (NotificationType::PREF_CHANGED == type) {
     if (updating_preferences_)
@@ skipping 34 matching lines @@
     } else if (prefs::kManagedDefaultPopupsSetting == *name) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_POPUPS,
                                   profile_->GetPrefs(),
                                   &managed_default_content_settings_);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     if (!is_off_the_record_) {
-      NotifyObservers(
-          ContentSettingsDetails(Pattern(), CONTENT_SETTINGS_TYPE_DEFAULT, ""));
+      NotifyObservers(ContentSettingsDetails(ContentSettingsPattern(),
+                                             CONTENT_SETTINGS_TYPE_DEFAULT,
+                                             ""));
     }
   } else if (NotificationType::PROFILE_DESTROYED == type) {
     UnregisterObservers();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 HostContentSettingsMap::~HostContentSettingsMap() {
   UnregisterObservers();
@@ skipping 143 matching lines @@
     host_content_settings_.clear();
 
   // Careful: The returned value could be NULL if the pref has never been set.
   if (all_settings_dictionary != NULL) {
     // Convert all Unicode patterns into punycode form, then read.
     CanonicalizeContentSettingsExceptions(all_settings_dictionary);
 
     for (DictionaryValue::key_iterator i(all_settings_dictionary->begin_keys());
          i != all_settings_dictionary->end_keys(); ++i) {
       const std::string& pattern(*i);
-      if (!Pattern(pattern).IsValid())
+      if (!ContentSettingsPattern(pattern).IsValid())
         LOG(WARNING) << "Invalid pattern stored in content settings";
       DictionaryValue* pattern_settings_dictionary = NULL;
       bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
           pattern, &pattern_settings_dictionary);
       DCHECK(found);
       ContentSettings settings;
       GetSettingsFromDictionary(pattern_settings_dictionary, &settings);
       host_content_settings_[pattern].content_settings = settings;
       GetResourceSettingsFromDictionary(
           pattern_settings_dictionary,
@@ skipping 37 matching lines @@
 }
 
 void HostContentSettingsMap::MigrateObsoletePopupsPref(PrefService* prefs) {
   if (prefs->HasPrefPath(prefs::kPopupWhitelistedHosts)) {
     const ListValue* whitelist_pref =
         prefs->GetList(prefs::kPopupWhitelistedHosts);
     for (ListValue::const_iterator i(whitelist_pref->begin());
          i != whitelist_pref->end(); ++i) {
       std::string host;
       (*i)->GetAsString(&host);
-      SetContentSetting(Pattern(host), CONTENT_SETTINGS_TYPE_POPUPS, "",
+      SetContentSetting(ContentSettingsPattern(host),
+                        CONTENT_SETTINGS_TYPE_POPUPS,
+                        "",
                         CONTENT_SETTING_ALLOW);
     }
     prefs->ClearPref(prefs::kPopupWhitelistedHosts);
   }
 }
 
 void HostContentSettingsMap::MigrateObsoletePerhostPref(PrefService* prefs) {
   if (prefs->HasPrefPath(prefs::kPerHostContentSettings)) {
     const DictionaryValue* all_settings_dictionary =
         prefs->GetDictionary(prefs::kPerHostContentSettings);
     for (DictionaryValue::key_iterator i(all_settings_dictionary->begin_keys());
          i != all_settings_dictionary->end_keys(); ++i) {
       const std::string& host(*i);
-      Pattern pattern(std::string(kDomainWildcard) + host);
+      ContentSettingsPattern pattern(
+          std::string(ContentSettingsPattern::kDomainWildcard) + host);
       DictionaryValue* host_settings_dictionary = NULL;
       bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
           host, &host_settings_dictionary);
       DCHECK(found);
       ContentSettings settings;
       GetSettingsFromDictionary(host_settings_dictionary, &settings);
       for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
         if (settings.settings[j] != CONTENT_SETTING_DEFAULT &&
             !RequiresResourceIdentifier(ContentSettingsType(j)))
           SetContentSetting(
               pattern, ContentSettingsType(j), "", settings.settings[j]);
       }
     }
     prefs->ClearPref(prefs::kPerHostContentSettings);
   }
 }
 
 void HostContentSettingsMap::CanonicalizeContentSettingsExceptions(
     DictionaryValue* all_settings_dictionary) {
   DCHECK(all_settings_dictionary);
 
   std::vector<std::string> remove_items;
   std::vector<std::pair<std::string, std::string> > move_items;
   for (DictionaryValue::key_iterator i(all_settings_dictionary->begin_keys());
        i != all_settings_dictionary->end_keys(); ++i) {
     const std::string& pattern(*i);
     const std::string canonicalized_pattern =
-        Pattern(pattern).CanonicalizePattern();
+        ContentSettingsPattern(pattern).CanonicalizePattern();
 
     if (canonicalized_pattern.empty() || canonicalized_pattern == pattern)
       continue;
 
     // Clear old pattern if prefs already have canonicalized pattern.
     DictionaryValue* new_pattern_settings_dictionary = NULL;
     if (all_settings_dictionary->GetDictionaryWithoutPathExpansion(
             canonicalized_pattern, &new_pattern_settings_dictionary)) {
       remove_items.push_back(pattern);
       continue;
@@ skipping 12 matching lines @@
   }
 
   for (size_t i = 0; i < move_items.size(); ++i) {
     Value* pattern_settings_dictionary = NULL;
     all_settings_dictionary->RemoveWithoutPathExpansion(
         move_items[i].first, &pattern_settings_dictionary);
     all_settings_dictionary->SetWithoutPathExpansion(
         move_items[i].second, pattern_settings_dictionary);
   }
 }