Move URLPattern::ParseOption into a field.

chrome/common/extensions/extension.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/extension.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 265 matching lines @@
       DLOG(WARNING) << "Override URL passed for " << name()
                     << " should not contain a port.  Removing it.";
 
       GURL::Replacements remove_port;
       remove_port.ClearPort();
       new_url = new_url.ReplaceComponents(remove_port);
     }
 
     launch_web_url_ = new_url.spec();
 
-    URLPattern pattern(kValidWebExtentSchemes);
-    pattern.Parse(new_url.spec(), URLPattern::ERROR_ON_PORTS);
+    URLPattern pattern(URLPattern::ERROR_ON_PORTS, kValidWebExtentSchemes);
+    pattern.Parse(new_url.spec());
     pattern.SetPath(pattern.path() + '*');
     extent_.AddPattern(pattern);
   }
 }
 
 FilePath Extension::MaybeNormalizePath(const FilePath& path) {
 #if defined(OS_WIN)
   // Normalize any drive letter to upper-case. We do this for consistency with
   // net_utils::FilePathToFileURL(), which does the same thing, to make string
   // comparisons simpler.
@@ skipping 82 matching lines @@
 }
 
 // Helper method that loads a UserScript object from a dictionary in the
 // content_script list of the manifest.
 bool Extension::LoadUserScriptHelper(const DictionaryValue* content_script,
                                      int definition_index,
                                      int flags,
                                      std::string* error,
                                      UserScript* result) {
   // When strict error checks are enabled, make URL pattern parsing strict.
-  URLPattern::ParseOption parse_strictness =
+  URLPattern::ParseOption parse_option =
       (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
                                    : URLPattern::IGNORE_PORTS);
 
   // run_at
   if (content_script->HasKey(keys::kRunAt)) {
     std::string run_location;
     if (!content_script->GetString(keys::kRunAt, &run_location)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidRunAt,
           base::IntToString(definition_index));
       return false;
@@ skipping 40 matching lines @@
     std::string match_str;
     if (!matches->GetString(j, &match_str)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidMatch,
           base::IntToString(definition_index),
           base::IntToString(j),
           errors::kExpectString);
       return false;
     }
 
-    URLPattern pattern(UserScript::kValidUserScriptSchemes);
+    URLPattern pattern(parse_option, UserScript::kValidUserScriptSchemes);
     if (CanExecuteScriptEverywhere())
       pattern.SetValidSchemes(URLPattern::SCHEME_ALL);
 
-    URLPattern::ParseResult parse_result = pattern.Parse(match_str,
-                                                         parse_strictness);
+    URLPattern::ParseResult parse_result = pattern.Parse(match_str);
     if (parse_result != URLPattern::PARSE_SUCCESS) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidMatch,
           base::IntToString(definition_index),
           base::IntToString(j),
           URLPattern::GetParseResultString(parse_result));
       return false;
     }
 
     if (pattern.MatchesScheme(chrome::kFileScheme) &&
@@ skipping 21 matching lines @@
       std::string match_str;
       if (!exclude_matches->GetString(j, &match_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidExcludeMatch,
             base::IntToString(definition_index),
             base::IntToString(j),
             errors::kExpectString);
         return false;
       }
 
-      URLPattern pattern(UserScript::kValidUserScriptSchemes);
+      URLPattern pattern(parse_option, UserScript::kValidUserScriptSchemes);
       if (CanExecuteScriptEverywhere())
         pattern.SetValidSchemes(URLPattern::SCHEME_ALL);
-      URLPattern::ParseResult parse_result = pattern.Parse(match_str,
-                                                           parse_strictness);
+      URLPattern::ParseResult parse_result = pattern.Parse(match_str);
       if (parse_result != URLPattern::PARSE_SUCCESS) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidExcludeMatch,
             base::IntToString(definition_index), base::IntToString(j),
             URLPattern::GetParseResultString(parse_result));
         return false;
       }
 
       result->add_exclude_url_pattern(pattern);
     }
@@ skipping 279 matching lines @@
     return NULL;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string filter;
     if (!list_value->GetString(i, &filter)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidFileFilterValue, base::IntToString(i));
       return NULL;
     }
     StringToLowerASCII(&filter);
-    URLPattern pattern(URLPattern::SCHEME_FILESYSTEM);
-    if (pattern.Parse(filter, URLPattern::ERROR_ON_PORTS) !=
-        URLPattern::PARSE_SUCCESS) {
+    URLPattern pattern(URLPattern::ERROR_ON_PORTS,
+                       URLPattern::SCHEME_FILESYSTEM);
+    if (pattern.Parse(filter) != URLPattern::PARSE_SUCCESS) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidURLPatternError, filter);
       return NULL;
     }
     std::string path = pattern.path();
     bool allowed = path == "*" || path == "*.*" ||
         (path.compare(0, 2, "*.") == 0 &&
          path.find_first_of('*', 2) == std::string::npos);
     if (!allowed) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
@@ skipping 62 matching lines @@
   }
 
   return result.release();
 }
 
 bool Extension::LoadExtent(const extensions::Manifest* manifest,
                            const char* key,
                            URLPatternSet* extent,
                            const char* list_error,
                            const char* value_error,
-                           URLPattern::ParseOption parse_strictness,
+                           URLPattern::ParseOption parse_option,
                            std::string* error) {
   Value* temp = NULL;
   if (!manifest->Get(key, &temp))
     return true;
 
   if (temp->GetType() != Value::TYPE_LIST) {
     *error = list_error;
     return false;
   }
 
   ListValue* pattern_list = static_cast<ListValue*>(temp);
   for (size_t i = 0; i < pattern_list->GetSize(); ++i) {
     std::string pattern_string;
     if (!pattern_list->GetString(i, &pattern_string)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(value_error,
                                                        base::UintToString(i),
                                                        errors::kExpectString);
       return false;
     }
 
-    URLPattern pattern(kValidWebExtentSchemes);
-    URLPattern::ParseResult parse_result = pattern.Parse(pattern_string,
-                                                         parse_strictness);
+    URLPattern pattern(parse_option, kValidWebExtentSchemes);
+    URLPattern::ParseResult parse_result = pattern.Parse(pattern_string);
     if (parse_result == URLPattern::PARSE_ERROR_EMPTY_PATH) {
       pattern_string += "/";
-      parse_result = pattern.Parse(pattern_string, parse_strictness);
+      parse_result = pattern.Parse(pattern_string);
     }
 
     if (parse_result != URLPattern::PARSE_SUCCESS) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           value_error,
           base::UintToString(i),
           URLPattern::GetParseResultString(parse_result));
       return false;
     }
 
@@ skipping 65 matching lines @@
     launch_local_path_ = launch_path;
   } else if (manifest->Get(keys::kLaunchWebURL, &temp)) {
     std::string launch_url;
     if (!temp->GetAsString(&launch_url)) {
       *error = errors::kInvalidLaunchWebURL;
       return false;
     }
 
     // Ensure the launch URL is a valid absolute URL and web extent scheme.
     GURL url(launch_url);
-    URLPattern pattern(kValidWebExtentSchemes);
+    URLPattern pattern(URLPattern::ERROR_ON_PORTS, kValidWebExtentSchemes);
     if (!url.is_valid() || !pattern.SetScheme(url.scheme())) {
       *error = errors::kInvalidLaunchWebURL;
       return false;
     }
 
     launch_web_url_ = launch_url;
   } else if (is_app()) {
     *error = errors::kLaunchURLRequired;
     return false;
   }
 
   // If there is no extent, we default the extent based on the launch URL.
   if (web_extent().is_empty() && !launch_web_url().empty()) {
     GURL launch_url(launch_web_url());
-    URLPattern pattern(kValidWebExtentSchemes);
+    URLPattern pattern(URLPattern::ERROR_ON_PORTS, kValidWebExtentSchemes);
     if (!pattern.SetScheme("*")) {
       *error = errors::kInvalidLaunchWebURL;
       return false;
     }
     pattern.SetHost(launch_url.host());
     pattern.SetPath("/*");
     extent_.AddPattern(pattern);
   }
 
   // In order for the --apps-gallery-url switch to work with the gallery
@@ skipping 359 matching lines @@
 bool Extension::InitFromValue(extensions::Manifest* manifest, int flags,
                               std::string* error) {
   DCHECK(error);
   base::AutoLock auto_lock(runtime_data_lock_);
   manifest_.reset(manifest);
 
   if (!manifest->ValidateManifest(error))
     return false;
 
   // When strict error checks are enabled, make URL pattern parsing strict.
-  URLPattern::ParseOption parse_strictness =
+  URLPattern::ParseOption parse_option =
       (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
                                    : URLPattern::IGNORE_PORTS);
 
   // Initialize permissions with an empty, default permission set.
   runtime_data_.SetActivePermissions(new ExtensionPermissionSet());
   optional_permission_set_ = new ExtensionPermissionSet();
   required_permission_set_ = new ExtensionPermissionSet();
 
   if (manifest->HasKey(keys::kManifestVersion)) {
     int manifest_version = 0;
@@ skipping 67 matching lines @@
   base::i18n::AdjustStringForLocaleDirection(&localized_name);
   name_ = UTF16ToUTF8(localized_name);
 
   // Load App settings. LoadExtent at least has to be done before
   // ParsePermissions(), because the valid permissions depend on what type of
   // package this is.
   if (is_app() &&
       (!LoadExtent(manifest_.get(), keys::kWebURLs,
                    &extent_,
                    errors::kInvalidWebURLs, errors::kInvalidWebURL,
-                   parse_strictness, error) ||
+                   parse_option, error) ||
        !LoadLaunchURL(manifest_.get(), error) ||
        !LoadLaunchContainer(manifest_.get(), error))) {
     return false;
   }
 
   if (is_platform_app()) {
     if (launch_container() != extension_misc::LAUNCH_SHELL) {
       *error = errors::kInvalidLaunchContainerForPlatform;
       return false;
     }
@@ skipping 1024 matching lines @@
 }
 
 bool Extension::ParsePermissions(const extensions::Manifest* source,
                                  const char* key,
                                  int flags,
                                  std::string* error,
                                  ExtensionAPIPermissionSet* api_permissions,
                                  URLPatternSet* host_permissions) {
   if (source->HasKey(key)) {
     // When strict error checks are enabled, make URL pattern parsing strict.
-    URLPattern::ParseOption parse_strictness =
+    URLPattern::ParseOption parse_option =
         (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
                                      : URLPattern::IGNORE_PORTS);
     ListValue* permissions = NULL;
     if (!source->GetList(key, &permissions)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidPermissions, "");
       return false;
     }
 
     for (size_t i = 0; i < permissions->GetSize(); ++i) {
       std::string permission_str;
       if (!permissions->GetString(i, &permission_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidPermission, base::IntToString(i));
         return false;
       }
 
       ExtensionAPIPermission* permission =
           ExtensionPermissionsInfo::GetInstance()->GetByName(permission_str);
 
       if (permission != NULL) {
         if (CanSpecifyAPIPermission(permission, error))
           api_permissions->insert(permission->id());
         if (!error->empty())
           return false;
         continue;
       }
 
       // Check if it's a host pattern permission.
-      URLPattern pattern = URLPattern(CanExecuteScriptEverywhere() ?
-          URLPattern::SCHEME_ALL : kValidHostPermissionSchemes);
+      const int kAllowedSchemes = CanExecuteScriptEverywhere() ?
+          URLPattern::SCHEME_ALL : kValidHostPermissionSchemes;
 
-      URLPattern::ParseResult parse_result = pattern.Parse(permission_str,
-                                                           parse_strictness);
+      URLPattern pattern = URLPattern(parse_option, kAllowedSchemes);
+      URLPattern::ParseResult parse_result = pattern.Parse(permission_str);
       if (parse_result == URLPattern::PARSE_SUCCESS) {
         if (!CanSpecifyHostPermission(pattern, *api_permissions)) {
           *error = ExtensionErrorUtils::FormatErrorMessage(
               errors::kInvalidPermissionScheme, base::IntToString(i));
           return false;
         }
 
         // The path component is not used for host permissions, so we force it
         // to match all paths.
         pattern.SetPath("/*");
@@ skipping 327 matching lines @@
 }
 
 bool Extension::OverlapsWithOrigin(const GURL& origin) const {
   if (url() == origin)
     return true;
 
   if (web_extent().is_empty())
     return false;
 
   // Note: patterns and extents ignore port numbers.
-  URLPattern origin_only_pattern(kValidWebExtentSchemes);
+  URLPattern origin_only_pattern(URLPattern::ERROR_ON_PORTS,
+                                 kValidWebExtentSchemes);
   if (!origin_only_pattern.SetScheme(origin.scheme()))
     return false;
   origin_only_pattern.SetHost(origin.host());
   origin_only_pattern.SetPath("/*");
 
   URLPatternSet origin_only_pattern_list;
   origin_only_pattern_list.AddPattern(origin_only_pattern);
 
   return web_extent().OverlapsWith(origin_only_pattern_list);
 }
@@ skipping 79 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}