Use WebCore's built in support for user styles

chrome/common/extensions/url_pattern.cc

 // 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.
 
 #include "chrome/common/extensions/url_pattern.h"
 
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "chrome/common/url_constants.h"
 
@@ skipping 58 matching lines @@
   size_t host_start_pos = scheme_end_pos +
       strlen(chrome::kStandardSchemeSeparator);
   if (host_start_pos >= pattern.length())
     return false;
 
   // Parse out the host and path.
   size_t path_start_pos = 0;
 
   // File URLs are special because they have no host. There are other schemes
   // with the same structure, but we don't support them (yet).
-  if (scheme_ == "file") {
+  if (scheme_ == chrome::kFileScheme) {
     path_start_pos = host_start_pos;
   } else {
     size_t host_end_pos = pattern.find(kPathSeparator, host_start_pos);
     if (host_end_pos == std::string::npos)
       return false;
 
     host_ = pattern.substr(host_start_pos, host_end_pos - host_start_pos);
 
     // The first component can optionally be '*' to match all subdomains.
     std::vector<std::string> host_components;
@@ skipping 109 matching lines @@
 
   return true;
 }
 
 std::string URLPattern::GetAsString() const {
   if (match_all_urls_)
     return kAllUrlsPattern;
 
   std::string spec = scheme_ + chrome::kStandardSchemeSeparator;
 
-  if (match_subdomains_) {
-    spec += "*";
+  if (scheme_ != chrome::kFileScheme) {
+    if (match_subdomains_) {
+      spec += "*";
+      if (!host_.empty())
+        spec += ".";
+    }
+
     if (!host_.empty())
-      spec += ".";
+      spec += host_;
   }
 
-  if (!host_.empty())
-    spec += host_;
-
   if (!path_.empty())
     spec += path_;
 
   return spec;
 }
 
 bool URLPattern::OverlapsWith(const URLPattern& other) const {
   if (!MatchesScheme(other.scheme_) && !other.MatchesScheme(scheme_))
     return false;
 
   if (!MatchesHost(other.host()) && !other.MatchesHost(host_))
     return false;
 
   // We currently only use OverlapsWith() for the patterns inside
   // ExtensionExtent. In those cases, we know that the path will have only a
   // single wildcard at the end. This makes figuring out overlap much easier. It
   // seems like there is probably a computer-sciency way to solve the general
   // case, but we don't need that yet.
   DCHECK(path_.find('*') == path_.size() - 1);
   DCHECK(other.path().find('*') == other.path().size() - 1);
 
   if (!MatchesPath(other.path().substr(0, other.path().size() - 1)) &&
       !other.MatchesPath(path_.substr(0, path_.size() - 1)))
     return false;
 
   return true;
 }
+
+std::vector<URLPattern> URLPattern::ConvertToExplicitSchemes() const {
+  std::vector<URLPattern> result;
+
+  if (scheme_ != "*" && !match_all_urls_) {
+    result.push_back(*this);
+    return result;
+  }
+
+  for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
+    if (MatchesScheme(kValidSchemes[i])) {
+      URLPattern temp = *this;
+      temp.SetScheme(kValidSchemes[i]);
+      temp.set_match_all_urls(false);
+      result.push_back(temp);
+    }
+  }
+
+  return result;
+}