Ignore paths when matching patterns for extensions.

chrome/common/extensions/url_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/extensions/url_pattern.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 289 matching lines @@
 
 bool URLPattern::SetPort(const std::string& port) {
   spec_.clear();
   if (IsValidPortForScheme(scheme_, port)) {
     port_ = port;
     return true;
   }
   return false;
 }
 
-bool URLPattern::MatchesURL(const GURL &test) const {
+bool URLPattern::MatchesURL(const GURL& test) const {
   if (!MatchesScheme(test.scheme()))

[Aaron Boodman, 2011/10/31 23:57:11]

Can't testing the scheme and match_all_urls_ also go into
MatchesSecurityOriginHelper?

[dcheng, 2011/11/01 18:18:02]

It won't have quite the same meaning if I move it in there. I would need to
return a trivalue from the helper with the following meanings:
1. True, and no further checks needed.
2. True, but make sure the path matches too.
3. False, doesn't match.

[Aaron Boodman, 2011/11/01 19:20:57]

Sorry, I still don't see it. Coffee has not kicked in yet. Why doesn't the
following work:

bool MatchesURL(const GURL& test)
  return MatchesSecurityOrigin(test) &&
         MatchesPath(test.PathForRequest())

bool MatchesSecurityOrigin(const GURL& origin) {
  if (!MatchesScheme(test.scheme())
    return false

  if (match_all_urls_)
    return true

  if (scheme_ != chrome::kFileScheme && !MatchesHost(test))
    return false

  if (!MatchesPort(test.EffectiveIntPort())
    return false

  return true

     return false;
 
   if (match_all_urls_)
     return true;
 
-  // Ignore hostname if scheme is file://.
-  if (scheme_ != chrome::kFileScheme && !MatchesHost(test))
+  return MatchesSecurityOriginHelper(test) &&
+         MatchesPath(test.PathForRequest());
+}
+
+bool URLPattern::MatchesSecurityOrigin(const GURL& test) const {
+  if (!MatchesScheme(test.scheme()))
     return false;
 
-  if (!MatchesPath(test.PathForRequest()))
-    return false;
+  if (match_all_urls_)
+    return true;
 
-  if (!MatchesPort(test.EffectiveIntPort()))
-    return false;
-
-  return true;
+  return MatchesSecurityOriginHelper(test);
 }
 
 bool URLPattern::MatchesScheme(const std::string& test) const {
   if (!IsValidScheme(test))
     return false;
 
   return scheme_ == "*" || test == scheme_;
 }
 
 bool URLPattern::MatchesHost(const std::string& host) const {
@@ skipping 118 matching lines @@
     const std::vector<std::string>& schemes) const {
   for (std::vector<std::string>::const_iterator i = schemes.begin();
        i != schemes.end(); ++i) {
     if (MatchesScheme(*i))
       return true;
   }
 
   return false;
 }
 
+bool URLPattern::MatchesSecurityOriginHelper(const GURL& test) const {
+  // Ignore hostname if scheme is file://.
+  if (scheme_ != chrome::kFileScheme && !MatchesHost(test))
+    return false;
+
+  if (!MatchesPort(test.EffectiveIntPort()))
+    return false;
+
+  return true;
+}
+
 std::vector<std::string> URLPattern::GetExplicitSchemes() const {
   std::vector<std::string> result;
 
   if (scheme_ != "*" && !match_all_urls_ && IsValidScheme(scheme_)) {
     result.push_back(scheme_);
     return result;
   }
 
   for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
     if (MatchesScheme(kValidSchemes[i])) {
@@ skipping 17 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }