Move URLPattern::ParseOption into a field.

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 80 matching lines @@
 
   int parsed_port = url_parse::PORT_UNSPECIFIED;
   if (!base::StringToInt(port, &parsed_port))
     return false;
   return (parsed_port >= 0) && (parsed_port < 65536);
 }
 
 }  // namespace
 
 URLPattern::URLPattern()
-    : valid_schemes_(SCHEME_NONE),
+    : parse_option_(ERROR_ON_PORTS),
+      valid_schemes_(SCHEME_NONE),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {}
 
-URLPattern::URLPattern(int valid_schemes)
-    : valid_schemes_(valid_schemes),
+URLPattern::URLPattern(URLPattern::ParseOption parse_option, int valid_schemes)
+    : parse_option_(parse_option),
+      valid_schemes_(valid_schemes),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes, const std::string& pattern)
-    : valid_schemes_(valid_schemes),
+    // Strict error checking is used, because this constructor is only
+    // appropriate when we know |pattern| is valid.
+    : parse_option_(ERROR_ON_PORTS),
+      valid_schemes_(valid_schemes),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {
-
-  // 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))
+  if (PARSE_SUCCESS != Parse(pattern))
     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) {
+URLPattern::ParseResult URLPattern::Parse(const std::string& pattern) {
   spec_.clear();
 
   // Special case pattern to match every valid URL.
   if (pattern == kAllUrlsPattern) {
     SetMatchAllURLs(true);
     return PARSE_SUCCESS;
   }
 
   // Parse out the scheme.
   size_t scheme_end_pos = pattern.find(chrome::kStandardSchemeSeparator);
@@ skipping 61 matching lines @@
     }
     host_ = JoinString(host_components, '.');
 
     path_start_pos = host_end_pos;
   }
 
   SetPath(pattern.substr(path_start_pos));
 
   size_t port_pos = host_.find(':');
   if (port_pos != std::string::npos) {
-    switch (strictness) {
+    switch (parse_option_) {
       case USE_PORTS: {
         if (!SetPort(host_.substr(port_pos + 1)))
           return PARSE_ERROR_INVALID_PORT;
         host_ = host_.substr(0, port_pos);
         break;
       }
       case ERROR_ON_PORTS: {
         return PARSE_ERROR_HAS_COLON;
       }
       case IGNORE_PORTS: {
         // Do nothing, i.e. leave the colon in the host.
       }
     }
   }
 
   // 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::SetParseOption(URLPattern::ParseOption parse_option) {
+  spec_.clear();
+  parse_option_ = parse_option;
+}
+
 void URLPattern::SetHost(const std::string& host) {
   spec_.clear();
   host_ = host;
 }
 
 void URLPattern::SetMatchAllURLs(bool val) {
   spec_.clear();
   match_all_urls_ = val;
 
   if (val) {
@@ skipping 247 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }