Added support for file URI path wildcards in content settings

chrome/common/content_settings_pattern.cc

 // Copyright (c) 2011 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/common/content_settings_pattern.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_split.h"
@@ skipping 112 matching lines @@
 
 BuilderInterface* ContentSettingsPattern::Builder::WithSchemeWildcard() {
   parts_.scheme = "";
   parts_.is_scheme_wildcard = true;
   return this;
 }
 
 BuilderInterface* ContentSettingsPattern::Builder::WithPath(
     const std::string& path) {
   parts_.path = path;
+  parts_.is_path_wildcard = false;
+  return this;
+}
+
+BuilderInterface* ContentSettingsPattern::Builder::WithPathWildcard() {
+  parts_.path = "";
+  parts_.is_path_wildcard = true;
   return this;
 }
 
 BuilderInterface* ContentSettingsPattern::Builder::Invalid() {
   is_valid_ = false;
   return this;
 }
 
 ContentSettingsPattern ContentSettingsPattern::Builder::Build() {
   if (!is_valid_)
     return ContentSettingsPattern();
   if (!Canonicalize(&parts_))
     return ContentSettingsPattern();
   if (use_legacy_validate_) {
     is_valid_ = LegacyValidate(parts_);
   } else {
     is_valid_ = Validate(parts_);
   }
   return ContentSettingsPattern(parts_, is_valid_);
 }
 
 // static
 bool ContentSettingsPattern::Builder::Canonicalize(PatternParts* parts) {
   // Canonicalize the scheme part.
   const std::string scheme(StringToLowerASCII(parts->scheme));
   parts->scheme = scheme;
 
-  if (parts->scheme == std::string(chrome::kFileScheme)) {
-    GURL url(std::string(chrome::kFileScheme) +
-             std::string(chrome::kStandardSchemeSeparator) + parts->path);
-    parts->path = url.path();
+  if (parts->scheme == std::string(chrome::kFileScheme) &&
+      !parts->is_path_wildcard) {
+      GURL url(std::string(chrome::kFileScheme) +
+               std::string(chrome::kStandardSchemeSeparator) + parts->path);
+      parts->path = url.path();
   }
 
   // Canonicalize the host part.
   const std::string host(parts->host);
   url_canon::CanonHostInfo host_info;
   std::string canonicalized_host(net::CanonicalizeHost(host, &host_info));
   if (host_info.IsIPAddress() && parts->has_domain_wildcard)
     return false;
   canonicalized_host = net::TrimEndingDot(canonicalized_host);
 
   parts->host = "";
   if ((host.find('*') == std::string::npos) &&
       !canonicalized_host.empty()) {
     // Valid host.
     parts->host += canonicalized_host;
   }
   return true;
 }
 
 // static
 bool ContentSettingsPattern::Builder::Validate(const PatternParts& parts) {
   // Sanity checks first: {scheme, port} wildcards imply empty {scheme, port}.
   if ((parts.is_scheme_wildcard && !parts.scheme.empty()) ||
       (parts.is_port_wildcard && !parts.port.empty())) {
     NOTREACHED();
     return false;
   }
 
   // file:// URL patterns have an empty host and port.
-  if (parts.scheme == std::string(chrome::kFileScheme))
-    return parts.host.empty() &&
-           parts.port.empty() &&
-           !parts.path.empty() &&
-           parts.path != std::string("/") &&
-           parts.path.find("*") == std::string::npos;
+  if (parts.scheme == std::string(chrome::kFileScheme)) {
+    if (parts.has_domain_wildcard || !parts.host.empty() || !parts.port.empty())
+      return false;
+    if (parts.is_path_wildcard)
+      return parts.path.empty();
+    return (!parts.path.empty() &&
+            parts.path != "/" &&
+            parts.path.find("*") == std::string::npos);
+  }

[Francois, 2012/01/18 15:34:45]

Please note that my new CL (Patch Set 4) removes the rejection of "/".

[Francois, 2012/01/19 08:43:07]

Added back in Patch Set 5.

 
   // If the pattern is for an extension URL test if it is valid.
   if (parts.scheme == std::string(chrome::kExtensionScheme) &&
       !parts.host.empty() &&
       !parts.has_domain_wildcard &&
       parts.port.empty() &&
       !parts.is_port_wildcard) {
     return true;
   }
 
@@ skipping 51 matching lines @@
   }
   return true;
 }
 
 // ////////////////////////////////////////////////////////////////////////////
 // ContentSettingsPattern::PatternParts
 //
 ContentSettingsPattern::PatternParts::PatternParts()
         : is_scheme_wildcard(false),
           has_domain_wildcard(false),
-          is_port_wildcard(false) {}
+          is_port_wildcard(false),
+          is_path_wildcard(false) {}
 
 ContentSettingsPattern::PatternParts::~PatternParts() {}
 
 // ////////////////////////////////////////////////////////////////////////////
 // ContentSettingsPattern
 //
 
 // The version of the pattern format implemented. Version 1 includes the
 // following patterns:
 //   - [*.]domain.tld (matches domain.tld and all sub-domains)
@@ skipping 16 matching lines @@
   return new Builder(validate);
 }
 
 // static
 ContentSettingsPattern ContentSettingsPattern::FromURL(
     const GURL& url) {
   scoped_ptr<ContentSettingsPattern::BuilderInterface> builder(
       ContentSettingsPattern::CreateBuilder(false));
 
   if (url.SchemeIsFile()) {
     builder->WithScheme(url.scheme())->WithPath(url.path());

[markusheintz_, 2012/01/17 09:52:58]

Please replace 319 with:

if (url.path().empty()) {
  builder->WithPath(url.path());
} else {
  builder->WithPathWildcard();
}

[Francois, 2012/01/18 15:34:45]

Done, but I also set the scheme, which I hope is correct.

[markusheintz_, 2012/01/18 19:45:24]

Yes this is absolutely correct. I actually meant it the way to implemented it
:).  

[Francois, 2012/01/19 08:43:07]

I also had to change it so that it sets the wildcard only if url.path() == "/"
(because GURL("file:///").path() == "/"), and the path, otherwise. It now reads:

    if (url.path() == "/") {
      builder->WithPathWildcard();
    } else {
      builder->WithPath(url.path());
    }

   } else {
     // Please keep the order of the ifs below as URLs with an IP as host can
     // also have a "http" scheme.
     if (url.HostIsIPAddress()) {
       builder->WithScheme(url.scheme())->WithHost(url.host());
     } else if (url.SchemeIs(chrome::kHttpScheme)) {
       builder->WithSchemeWildcard()->WithDomainWildcard()->WithHost(url.host());
     } else if (url.SchemeIs(chrome::kHttpsScheme)) {
       builder->WithScheme(url.scheme())->WithDomainWildcard()->WithHost(
           url.host());
@@ skipping 46 matching lines @@
   scoped_ptr<ContentSettingsPattern::BuilderInterface> builder(
       ContentSettingsPattern::CreateBuilder(true));
   content_settings::PatternParser::Parse(pattern_spec, builder.get());
   return builder->Build();
 }
 
 // static
 ContentSettingsPattern ContentSettingsPattern::Wildcard() {
   scoped_ptr<ContentSettingsPattern::BuilderInterface> builder(
       ContentSettingsPattern::CreateBuilder(true));
-  builder->WithSchemeWildcard()->WithDomainWildcard()->WithPortWildcard();
+  builder->WithSchemeWildcard()->WithDomainWildcard()->WithPortWildcard()->
+           WithPathWildcard();
   return builder->Build();
 }
 
 ContentSettingsPattern::ContentSettingsPattern()
   : is_valid_(false) {
 }
 
 ContentSettingsPattern::ContentSettingsPattern(
     const PatternParts& parts,
     bool valid)
@@ skipping 18 matching lines @@
   if (!is_valid_)
     return false;
 
   // Match the scheme part.
   const std::string scheme(url.scheme());
   if (!parts_.is_scheme_wildcard &&
       parts_.scheme != scheme) {
     return false;
   }
 
-  // File URLs have no host. For file URLs check if the url path matches the
-  // path in the pattern.
-  // TODO(markusheintz): This should change in the future. There should be only
-  // one setting for all file URLs. So the path should be ignored.
-  if (!parts_.is_scheme_wildcard &&
-      scheme == std::string(chrome::kFileScheme)) {
-    if (parts_.path == std::string(url.path()))
-      return true;
-    return false;
-  }
+  // File URLs have no host. Matches if the pattern has the path wildcard set,
+  // or if the path in the URL is identical to the one in the pattern.
+  if (!parts_.is_scheme_wildcard && scheme == chrome::kFileScheme)
+    return parts_.is_path_wildcard || parts_.path == std::string(url.path());
 
   // Match the host part.
   const std::string host(net::TrimEndingDot(url.host()));
   if (!parts_.has_domain_wildcard) {
     if (parts_.host != host)
       return false;
   } else {
     if (!IsSubDomainOrEqual(host, parts_.host))
       return false;
   }
@@ skipping 197 matching lines @@
   if (!parts.is_port_wildcard && other_parts.is_port_wildcard)
     return ContentSettingsPattern::PREDECESSOR;
 
   int result = parts.port.compare(other_parts.port);
   if (result == 0)
     return ContentSettingsPattern::IDENTITY;
   if (result > 0)
     return ContentSettingsPattern::DISJOINT_ORDER_PRE;
   return ContentSettingsPattern::DISJOINT_ORDER_POST;
 }