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

chrome/common/extensions/url_pattern.h

 // 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.
 #ifndef CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 #define CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 #pragma once
 
 #include <functional>
 #include <string>
 #include <vector>
@@ skipping 114 matching lines @@
 
   // Construct an URLPattern with the given set of allowable schemes. See
   // valid_schemes_ for more info.
   explicit URLPattern(int valid_schemes);
 
   // Convenience to construct a URLPattern from a string. The string is expected
   // to be a valid pattern. If the string is not known ahead of time, use
   // Parse() instead, which returns success or failure.
   URLPattern(int valid_schemes, const std::string& pattern);
 
-#if defined(_MSC_VER) && _MSC_VER >= 1600
   // Note: don't use this directly. This exists so URLPattern can be used
-  // with STL containers.  Starting with Visual Studio 2010, we can't have this
-  // method private and use "friend class std::vector<URLPattern>;" as we used
-  // to do.
+  // with STL containers.
   URLPattern();
-#endif
+  ~URLPattern();
 
-  ~URLPattern();
+  bool operator<(const URLPattern& other) const;
+  bool operator==(const URLPattern& other) const;
+
+  // 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.  Adding error checks to URLPattern::Parse() can cause
+  // patterns in installed extensions to fail.  If an installed extension
+  // uses a pattern that was valid but fails a new error check, the
+  // extension will fail to load when chrome is auto-updated.  To avoid
+  // this, new parse checks are enabled only when |strictness| is
+  // OPTION_STRICT.  OPTION_STRICT should be used when loading in developer
+  // mode, or when an extension's patterns are controlled by chrome (such
+  // as component extensions).
+  ParseResult Parse(const std::string& pattern_str,
+                    ParseOption strictness);
 
   // Gets the bitmask of valid schemes.
   int valid_schemes() const { return valid_schemes_; }
-  void set_valid_schemes(int valid_schemes) { valid_schemes_ = valid_schemes; }
+  void SetValidSchemes(int valid_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 set_host(const std::string& host) { host_ = host; }
+  void SetHost(const std::string& host);
 
   // Gets whether to match subdomains of host().
   bool match_subdomains() const { return match_subdomains_; }
-  void set_match_subdomains(bool val) { match_subdomains_ = val; }
+  void SetMatchSubdomains(bool 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 SetPath(const std::string& path);
 
   // 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. 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.  Adding error checks to URLPattern::Parse() can cause
-  // patterns in installed extensions to fail.  If an installed extension
-  // uses a pattern that was valid but fails a new error check, the
-  // extension will fail to load when chrome is auto-updated.  To avoid
-  // this, new parse checks are enabled only when |strictness| is
-  // OPTION_STRICT.  OPTION_STRICT should be used when loading in developer
-  // mode, or when an extension's patterns are controlled by chrome (such
-  // as component extensions).
-  ParseResult Parse(const std::string& pattern_str,
-                    ParseOption strictness);
+  void SetMatchAllURLs(bool val);
 
   // 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.
   const std::string& scheme() const { return scheme_; }
 
   // Returns true if the specified scheme can be used in this URL pattern, and
@@ skipping 14 matching lines @@
   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.
-  std::string GetAsString() const;
+  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.
   bool OverlapsWith(const URLPattern& other) const;
 
   // Convert 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.
@@ skipping 10 matching lines @@
    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:
-#if !(defined(_MSC_VER) && _MSC_VER >= 1600)
-  friend class std::vector<URLPattern>;
-
-  // Note: don't use this directly. This exists so URLPattern can be used
-  // with STL containers.
-  URLPattern();
-#endif
-
   // Returns true if any of the |schemes| items matches our scheme.
   bool MatchesAnyScheme(const std::vector<std::string>& schemes) 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_
@@ skipping 17 matching lines @@
   // the |USE_PORTS| option.
   std::string port_;
 
   // The path to match. This is everything after the host of the URL, or
   // everything after the scheme in the case of file:// URLs.
   std::string path_;
 
   // 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;
 
 #endif  // CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_