Update URLPatternSet to contain a std::set instead of std::vector.

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 106 matching lines @@
 
   // Strict error checking is used, because this constructor is only
   // appropriate when we know |pattern| is valid.
   if (PARSE_SUCCESS != Parse(pattern, ERROR_ON_PORTS))
     NOTREACHED() << "URLPattern is invalid: " << pattern;
 }
 
 URLPattern::~URLPattern() {
 }
 
+bool URLPattern::operator<(const URLPattern& other) const {
+  return GetAsString() < other.GetAsString();
+}
+
+bool URLPattern::operator==(const URLPattern& other) const {
+  return GetAsString() == other.GetAsString();
+}
+
 URLPattern::ParseResult URLPattern::Parse(const std::string& pattern,
                                           ParseOption strictness) {
+  spec_.clear();
+
   // Special case pattern to match every valid URL.
   if (pattern == kAllUrlsPattern) {
     match_all_urls_ = true;
     match_subdomains_ = true;
     scheme_ = "*";
     host_.clear();
     SetPath("/*");
     return PARSE_SUCCESS;
   }
 
@@ skipping 88 matching lines @@
 
   // No other '*' can occur in the host, though. This isn't necessary, but is
   // done as a convenience to developers who might otherwise be confused and
   // think '*' works as a glob in the host.
   if (host_.find('*') != std::string::npos)
     return PARSE_ERROR_INVALID_HOST_WILDCARD;
 
   return PARSE_SUCCESS;
 }
 
+void URLPattern::SetValidSchemes(int valid_schemes) {
+  spec_.clear();
+  valid_schemes_ = valid_schemes;
+}
+
+void URLPattern::SetHost(const std::string& host) {
+  spec_.clear();
+  host_ = host;
+}
+
+void URLPattern::SetMatchAllURLs(bool val) {
+  spec_.clear();
+  match_all_urls_ = val;
+}
+
+void URLPattern::SetMatchSubdomains(bool val) {
+  spec_.clear();
+  match_subdomains_ = val;
+}
+
 bool URLPattern::SetScheme(const std::string& scheme) {
+  spec_.clear();
   scheme_ = scheme;
   if (scheme_ == "*") {
     valid_schemes_ &= (SCHEME_HTTP | SCHEME_HTTPS);
   } else if (!IsValidScheme(scheme_)) {
     return false;
   }
   return true;
 }
 
 bool URLPattern::IsValidScheme(const std::string& scheme) const {
   if (valid_schemes_ == SCHEME_ALL)
     return true;
 
   for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
     if (scheme == kValidSchemes[i] && (valid_schemes_ & kValidSchemeMasks[i]))
       return true;
   }
 
   return false;
 }
 
 void URLPattern::SetPath(const std::string& path) {
+  spec_.clear();
   path_ = path;
   path_escaped_ = path_;
   ReplaceSubstringsAfterOffset(&path_escaped_, 0, "\\", "\\\\");
   ReplaceSubstringsAfterOffset(&path_escaped_, 0, "?", "\\?");
 }
 
 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 {
   if (!MatchesScheme(test.scheme()))
     return false;
@@ skipping 67 matching lines @@
   return true;
 }
 
 bool URLPattern::MatchesPort(int port) const {
   if (port == url_parse::PORT_INVALID)
     return false;
 
   return port_ == "*" || port_ == base::IntToString(port);
 }
 
-std::string URLPattern::GetAsString() const {
-  if (match_all_urls_)
-    return kAllUrlsPattern;
+
+const std::string& URLPattern::GetAsString() const {
+  if (!spec_.empty())
+    return spec_;
+
+  if (match_all_urls_) {
+    spec_ = kAllUrlsPattern;
+    return spec_;
+  }
 
   bool standard_scheme = IsStandardScheme(scheme_);
 
   std::string spec = scheme_ +
       (standard_scheme ? chrome::kStandardSchemeSeparator : ":");
 
   if (scheme_ != chrome::kFileScheme && standard_scheme) {
     if (match_subdomains_) {
       spec += "*";
       if (!host_.empty())
         spec += ".";
     }
 
     if (!host_.empty())
       spec += host_;
 
     if (port_ != "*") {
       spec += ":";
       spec += port_;
     }
   }
 
   if (!path_.empty())
     spec += path_;
 
-  return spec;
+  spec_ = spec;
+  return spec_;
 }
 
 bool URLPattern::OverlapsWith(const URLPattern& other) const {
   if (!MatchesAnyScheme(other.GetExplicitSchemes()) &&
       !other.MatchesAnyScheme(GetExplicitSchemes())) {
     return false;
   }
 
   if (!MatchesHost(other.host()) && !other.MatchesHost(host_))
     return false;
@@ skipping 45 matching lines @@
 }
 
 std::vector<URLPattern> URLPattern::ConvertToExplicitSchemes() const {
   std::vector<std::string> explicit_schemes = GetExplicitSchemes();
   std::vector<URLPattern> result;
 
   for (std::vector<std::string>::const_iterator i = explicit_schemes.begin();
        i != explicit_schemes.end(); ++i) {
     URLPattern temp = *this;
     temp.SetScheme(*i);
-    temp.set_match_all_urls(false);
+    temp.SetMatchAllURLs(false);
     result.push_back(temp);
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }