Send content settings based on the URL to the renderer instead of just the host.

chrome/browser/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/host_content_settings_map.h"
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/pref_service.h"
@@ skipping 10 matching lines @@
 #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)
 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;
 
-// Returns the host part of an URL, or the spec, if no host is present.
-std::string HostFromURL(const GURL& url) {
-  return url.has_host() ? net::TrimEndingDot(url.host()) : url.spec();
-}
 }  // namespace
 
 // static
 HostContentSettingsMap::Pattern HostContentSettingsMap::Pattern::FromURL(
     const GURL& url) {
   return Pattern(!url.has_host() || url.HostIsIPAddress() ?
-                 HostFromURL(url) : std::string(kDomainWildcard) + url.host());
+      net::GetHostOrSpecFromURL(url) :
+      std::string(kDomainWildcard) + url.host());
 }
 
 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(HostFromURL(url));
+  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());
@@ skipping 140 matching lines @@
   return GetContentSettings(url).settings[content_type];
 }
 
 ContentSettings HostContentSettingsMap::GetContentSettings(
     const GURL& url) const {
   if (ShouldAllowAllContent(url))
       return ContentSettings(CONTENT_SETTING_ALLOW);
 
   AutoLock auto_lock(lock_);
 
-  const std::string host(HostFromURL(url));
+  const std::string host(net::GetHostOrSpecFromURL(url));
 
   // Check for exact matches first.
   HostContentSettings::const_iterator i(host_content_settings_.find(host));
   if (i != host_content_settings_.end()) {
     ContentSettings output = i->second;
     for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
       if (output.settings[j] == CONTENT_SETTING_DEFAULT)
         output.settings[j] = default_content_settings_.settings[j];
     }
     return output;
@@ skipping 364 matching lines @@
   if (!is_off_the_record_) {
     PrefService* prefs = profile_->GetPrefs();
     prefs->RemovePrefObserver(prefs::kDefaultContentSettings, this);
     prefs->RemovePrefObserver(prefs::kContentSettingsPatterns, this);
     prefs->RemovePrefObserver(prefs::kBlockThirdPartyCookies, this);
   }
   notification_registrar_.Remove(this, NotificationType::PROFILE_DESTROYED,
                                  NotificationService::AllSources());
   profile_ = NULL;
 }