Allow extensions on chrome:// URLs, when flag is set and permission is explicitly requested

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 82 matching lines @@
   // Initializes this instance by parsing the provided string. Returns
   // URLPattern::PARSE_SUCCESS on success, or an error code otherwise. On
   // failure, this instance will have some intermediate values and is in an
   // invalid state.
   ParseResult Parse(const std::string& pattern_str);
 
   // Gets the bitmask of valid schemes.
   int valid_schemes() const { return valid_schemes_; }
   void SetValidSchemes(int valid_schemes);
 
+  int allowed_schemes() const { return allowed_schemes_; }
+  void SetAllowedSchemes(int allowed_schemes);
+
   // Gets the host the pattern matches. This can be an empty string if the
   // pattern matches all hosts (the input was <scheme>://*/<whatever>).
   const std::string& host() const { return host_; }
   void SetHost(const std::string& host);
 
   // Gets whether to match subdomains of host().
   bool match_subdomains() const { return match_subdomains_; }
   void SetMatchSubdomains(bool val);
 
   // Gets the path the pattern matches with the leading slash. This can have
@@ skipping 10 matching lines @@
   // property). Returns false on failure (if the scheme is not valid).
   bool SetScheme(const std::string& scheme);
   // Note: You should use MatchesScheme() instead of this getter unless you
   // absolutely need the exact scheme. This is exposed for testing.
   const std::string& scheme() const { return scheme_; }
 
   // Returns true if the specified scheme can be used in this URL pattern, and
   // false otherwise. Uses valid_schemes_ to determine validity.
   bool IsValidScheme(const std::string& scheme) const;
 
+  // Returns true if the specified scheme is allowed by this URL pattern, and
+  // false otherwise. Uses allowed_schemes_ to determine status.
+  bool IsAllowedScheme(const std::string& scheme) const;
+
   // Returns true if this instance matches the specified URL.
   bool MatchesURL(const GURL& test) const;
 
   // Returns true if this instance matches the specified security origin.
   bool MatchesSecurityOrigin(const GURL& test) const;
 
   // Returns true if |test| matches our scheme.
   // Note that if test is "filesystem", this may fail whereas MatchesURL
   // may succeed.  MatchesURL is smart enough to look at the inner_url instead
   // of the outer "filesystem:" part.
@@ skipping 38 matching lines @@
   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);
 
+  // Checks whether the bit is set for the given scheme in the given scheme mask
+  static bool IsSchemeBitSet(const std::string& scheme, const int mask);
+
  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_
+  // scheme.
+  int valid_schemes_;
+
+  // A bitmask containing the schemes which return a positive match for this
+  // pattern. MatchesScheme uses this to decide whether a wildcard scheme_
   // matches a given test scheme.
-  int valid_schemes_;
+  int allowed_schemes_;
 
   // True if this is a special-case "<all_urls>" pattern.
   bool match_all_urls_;
 
   // The scheme for the pattern.
   std::string scheme_;
 
   // The host without any leading "*" components.
   std::string host_;
 
@@ skipping 12 matching lines @@
   // MatchPattern() function.
   std::string path_escaped_;
 
   // A string representing this URLPattern.
   mutable std::string spec_;
 };
 
 typedef std::vector<URLPattern> URLPatternList;
 
 #endif  // EXTENSIONS_COMMON_URL_PATTERN_H_