Use extension match pattern syntax in content settings extension API

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 356 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 =
-      (flags & STRICT_ERROR_CHECKS ? URLPattern::PARSE_STRICT
-                                   : URLPattern::PARSE_LENIENT);
+      (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 389 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;
     }
     URLPattern pattern(URLPattern::SCHEME_FILESYSTEM);
-    if (URLPattern::PARSE_SUCCESS != pattern.Parse(filter,
-                                                   URLPattern::PARSE_STRICT)) {
+    if (pattern.Parse(filter, URLPattern::ERROR_ON_PORTS) !=
+        URLPattern::PARSE_SUCCESS) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidURLPatternError, filter);
       return NULL;
     }
     result->AddPattern(pattern);
   }
 
   std::string default_icon;
   // Read the file browser action |default_icon| (optional).
   if (file_browser_handler->HasKey(keys::kPageActionDefaultIcon)) {
@@ skipping 228 matching lines @@
                        << " should not contain a port.  Removing it.";
 
           GURL::Replacements remove_port;
           remove_port.ClearPort();
           gallery_url = gallery_url.ReplaceComponents(remove_port);
         }
 
         launch_web_url_ = gallery_url.spec();
 
         URLPattern pattern(kValidWebExtentSchemes);
-        pattern.Parse(gallery_url.spec(), URLPattern::PARSE_STRICT);
+        pattern.Parse(gallery_url.spec(), URLPattern::ERROR_ON_PORTS);
         pattern.SetPath(pattern.path() + '*');
         extent_.AddPattern(pattern);
       }
     }
   }
 
   return true;
 }
 
 bool Extension::LoadLaunchContainer(const DictionaryValue* manifest,
@@ skipping 267 matching lines @@
 
 GURL Extension::GetBaseURLFromExtensionId(const std::string& extension_id) {
   return GURL(std::string(chrome::kExtensionScheme) +
               chrome::kStandardSchemeSeparator + extension_id + "/");
 }
 
 bool Extension::InitFromValue(const DictionaryValue& source, int flags,
                               std::string* error) {
   // When strict error checks are enabled, make URL pattern parsing strict.
   URLPattern::ParseOption parse_strictness =
-      (flags & STRICT_ERROR_CHECKS ? URLPattern::PARSE_STRICT
-                                   : URLPattern::PARSE_LENIENT);
+      (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
+                                   : URLPattern::IGNORE_PORTS);
 
   // Initialize permissions with an empty, default permission set.
   permission_set_.reset(new ExtensionPermissionSet());
 
   if (source.HasKey(keys::kPublicKey)) {
     std::string public_key_bytes;
     if (!source.GetString(keys::kPublicKey,
                           &public_key_) ||
         !ParsePEMKeyBytes(public_key_,
                           &public_key_bytes) ||
@@ skipping 1341 matching lines @@
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}
 
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     Reason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}