Added support for file URI path wildcards in content settings

chrome/common/content_settings_pattern_parser.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/common/content_settings_pattern_parser.h"
 
 #include "base/string_util.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/net_util.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
@@ skipping 23 matching lines @@
 const char* PatternParser::kDomainWildcard = "[*.]";
 
 const size_t PatternParser::kDomainWildcardLength = 4;
 
 const char* PatternParser::kSchemeWildcard = "*";
 
 const char* PatternParser::kHostWildcard = "*";
 
 const char* PatternParser::kPortWildcard = "*";
 
+const char* PatternParser::kPathWildcard = "*";
+
 // static
 void PatternParser::Parse(const std::string& pattern_spec,
                           ContentSettingsPattern::BuilderInterface* builder) {
   if (pattern_spec == "*") {
     builder->WithSchemeWildcard();
     builder->WithDomainWildcard();
     builder->WithPortWildcard();
     return;
   }
 
@@ skipping 107 matching lines @@
       for (size_t i = 0; i < port.size(); ++i) {
         if (!IsAsciiDigit(port[i])) {
           builder->Invalid();
           return;
         }
       }
       // TODO(markusheintz): Check port range.
       builder->WithPort(port);
     }
   } else {
-    if (scheme != std::string(chrome::kExtensionScheme))
+    if (scheme != std::string(chrome::kExtensionScheme) &&
+        scheme != std::string(chrome::kFileScheme))
       builder->WithPortWildcard();
   }
 
   if (path_component.IsNonEmpty()) {
-    builder->WithPath(pattern_spec.substr(path_component.start,
-                                          path_component.len));
+    const std::string path = pattern_spec.substr(path_component.start,
+                                                 path_component.len);
+    if (path.substr(1) == kPathWildcard)
+      builder->WithPathWildcard();
+    else
+      builder->WithPath(path);
   }
 }
 
 // static
 std::string PatternParser::ToString(
     const ContentSettingsPattern::PatternParts& parts) {
   // Return the most compact form to support legacy code and legacy pattern
   // strings.
   if (parts.is_scheme_wildcard &&
       parts.has_domain_wildcard &&
       parts.host.empty() &&
       parts.is_port_wildcard)
     return "*";
 
   std::string str = "";
   if (!parts.is_scheme_wildcard)
     str += parts.scheme + chrome::kStandardSchemeSeparator;
 
-  if (parts.scheme == std::string(chrome::kFileScheme))
-    return str + parts.path;
+  if (parts.scheme == chrome::kFileScheme) {
+    if (parts.is_path_wildcard)
+      return str + kUrlPathSeparator + kPathWildcard;
+    else
+      return str + parts.path;
+  }
 
   if (parts.has_domain_wildcard) {
     if (parts.host.empty())
       str += kHostWildcard;
     else
       str += kDomainWildcard;
   }
   str += parts.host;
 
   if (parts.scheme == std::string(chrome::kExtensionScheme)) {
     str += parts.path.empty() ? std::string(kUrlPathSeparator) : parts.path;
     return str;
   }
 
   if (!parts.is_port_wildcard) {
     str += std::string(kUrlPortSeparator) + parts.port;
   }
 
   return str;
 }
 
 }  // namespace content_settings