Support requesting subsets of host permissions using the permissions API.

extensions/common/url_pattern.h

 // 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.
 #ifndef EXTENSIONS_COMMON_URL_PATTERN_H_
 #define EXTENSIONS_COMMON_URL_PATTERN_H_
 
 #include <functional>
 #include <string>
 #include <vector>
 
@@ skipping 131 matching lines @@
   // of the outer "filesystem:" part.
   bool MatchesScheme(const std::string& test) const;
 
   // Returns true if |test| matches our host.
   bool MatchesHost(const std::string& test) const;
   bool MatchesHost(const GURL& test) const;
 
   // Returns true if |test| matches our path.
   bool MatchesPath(const std::string& test) const;
 
-  // Returns true if |port| matches our port.
-  bool MatchesPort(int port) const;
-
   // Sets the port. Returns false if the port is invalid.
   bool SetPort(const std::string& port);
   const std::string& port() const { return port_; }
 
   // Returns a string representing this instance.
   const std::string& GetAsString() const;
 
-  // Determine whether there is a URL that would match this instance and another
-  // instance. This method is symmetrical: Calling other.OverlapsWith(this)
-  // would result in the same answer.
+  // Determines whether there is a URL that would match this instance and
+  // another instance. This method is symmetrical: Calling
+  // other.OverlapsWith(this) would result in the same answer.
   bool OverlapsWith(const URLPattern& other) const;
 
-  // Convert this URLPattern into an equivalent set of URLPatterns that don't
+  // Returns true if this pattern matches all possible URLs that |other| can
+  // match. For example, http://*.google.com encompasses http://www.google.com.
+  bool Encompasses(const URLPattern& other) const;

[Matt Perry, 2013/02/12 19:07:17]

rename to Contains?

[Yoyo Zhou, 2013/02/12 19:45:04]

I thought about this as well, but you'd also want to rename the Encompasses on
URLPatternSet, so you have both

URLPatternSet::Contains(URLPatternSet)
and
URLPatternSet::Contains(URLPattern)

Not sure if this is more or less clear.

[Matt Perry, 2013/02/12 19:50:00]

Seems better to have Contains and ContainsPattern, then. Encompasses is a
synonym for Contains, so using it doesn't make things clearer.

[Yoyo Zhou, 2013/02/12 19:53:56]

Right. You do the dual meaning of containment - this set set-contains a pattern
that pattern-contains foo pattern - but I think that's understandable.

[not at google - send to devlin, 2013/02/12 19:56:20]

Contains seemed wrong to me, since it's not a container - I had IsSuperset for a
while but that seemed equally wrong - and like this confusing conversation is
unfolding, one of the reasons I didn't go with Contains is the confusion with
URLPattern vs URLPatternSet.

I'll just make it Contains.

+
+  // Converts this URLPattern into an equivalent set of URLPatterns that don't
   // use a wildcard in the scheme component. If this URLPattern doesn't use a
   // wildcard scheme, then the returned set will contain one element that is
   // equivalent to this instance.
   std::vector<URLPattern> ConvertToExplicitSchemes() const;
 
   static bool EffectiveHostCompare(const URLPattern& a, const URLPattern& b) {
     if (a.match_all_urls_ && b.match_all_urls_)
       return false;
     return a.host_.compare(b.host_) < 0;
   };
 
   // Used for origin comparisons in a std::set.
   class EffectiveHostCompareFunctor {
    public:
     bool operator()(const URLPattern& a, const URLPattern& b) const {
       return EffectiveHostCompare(a, b);
     };
   };
 
   // Get an error string for a ParseResult.
   static const char* GetParseResultString(URLPattern::ParseResult parse_result);
 
  private:
   // Returns true if any of the |schemes| items matches our scheme.
   bool MatchesAnyScheme(const std::vector<std::string>& schemes) const;
 
+  // Returns true if all of the |schemes| items matches our scheme.
+  bool MatchesAllSchemes(const std::vector<std::string>& schemes) const;
+
   bool MatchesSecurityOriginHelper(const GURL& test) const;
 
+  // Returns true if our port matches the |port| pattern (it may be "*").
+  bool MatchesPortPattern(const std::string& port) const;
+
   // If the URLPattern contains a wildcard scheme, returns a list of
   // equivalent literal schemes, otherwise returns the current scheme.
   std::vector<std::string> GetExplicitSchemes() const;
 
   // A bitmask containing the schemes which are considered valid for this
   // pattern. Parse() uses this to decide whether a pattern contains a valid
   // scheme. MatchesScheme uses this to decide whether a wildcard scheme_
   // matches a given test scheme.
   int valid_schemes_;
 
@@ skipping 20 matching lines @@
   // The path with "?" and "\" characters escaped for use with the
   // MatchPattern() function.
   std::string path_escaped_;
 
   // A string representing this URLPattern.
   mutable std::string spec_;
 };
 
 typedef std::vector<URLPattern> URLPatternList;
 
+std::ostream& operator<<(std::ostream& out, const URLPattern& pattern);
+
 #endif  // EXTENSIONS_COMMON_URL_PATTERN_H_