Use WebCore's built in support for user styles

chrome/common/extensions/url_pattern.h

 // Copyright (c) 2006-2009 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 CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 #define CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 
 #include <string>
+#include <vector>
 
 #include "googleurl/src/gurl.h"
 
 // A pattern that can be used to match URLs. A URLPattern is a very restricted
 // subset of URL syntax:
 //
 // <url-pattern> := <scheme>://<host><path> | '<all_urls>'
 // <scheme> := '*' | 'http' | 'https' | 'file' | 'ftp' | 'chrome'
 // <host> := '*' | '*.' <anychar except '/' and '*'>+
 // <path> := '/' <any chars>
@@ skipping 93 matching lines @@
   void set_match_subdomains(bool val) { match_subdomains_ = val; }
 
   // Gets the path the pattern matches with the leading slash. This can have
   // embedded asterisks which are interpreted using glob rules.
   const std::string& path() const { return path_; }
   void set_path(const std::string& path) {
     path_ = path;
     path_escaped_ = "";
   }
 
+  // Returns true if this pattern matches all urls.
+  bool match_all_urls() const { return match_all_urls_; }
+  void set_match_all_urls(bool val) { match_all_urls_ = val; }
+
   // Initializes this instance by parsing the provided string. On failure, the
   // instance will have some intermediate values and is in an invalid state.
   bool Parse(const std::string& pattern_str);
 
   // Sets the scheme for pattern matches. This can be a single '*' if the
   // pattern matches all valid schemes (as defined by the valid_schemes_
   // 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.
@@ skipping 17 matching lines @@
   bool MatchesPath(const std::string& test) const;
 
   // Returns a string representing this instance.
   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.
   bool OverlapsWith(const URLPattern& other) const;
 
+  // Conver 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;
+
  private:
   // 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_;
 
   // True if this is a special-case "<all_urls>" pattern.
   bool match_all_urls_;
 
@@ skipping 11 matching lines @@
   // everything after the scheme in the case of file:// URLs.
   std::string path_;
 
   // The path with "?" and "\" characters escaped for use with the
   // MatchPatternASCII() function. This is populated lazily, the first time it
   // is needed.
   mutable std::string path_escaped_;
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_