Coverity fixlet.

chrome/common/extensions/extension.cc

 // Copyright (c) 2012 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 <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 354 matching lines @@
                     << " 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::ParseResult result = pattern.Parse(new_url.spec());
+    DCHECK_EQ(result, URLPattern::PARSE_SUCCESS);
     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 1217 matching lines @@
     return false;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string relative_path;
     if (!list_value->GetString(i, &relative_path)) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidWebAccessibleResource, base::IntToString(i));
       return false;
     }
     URLPattern pattern(URLPattern::SCHEME_EXTENSION);
-    pattern.Parse(extension_url_.spec());
+    if (pattern.Parse(extension_url_.spec()) != URLPattern::PARSE_SUCCESS) {
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidURLPatternError, extension_url_.spec());
+      return false;
+    }
     while (relative_path[0] == '/')
       relative_path = relative_path.substr(1, relative_path.length() - 1);
     pattern.SetPath(pattern.path() + relative_path);
     web_accessible_resources_.AddPattern(pattern);
   }
 
   return true;
 }
 
 bool Extension::LoadSandboxedPages(string16* error) {
   if (!manifest_->HasPath(keys::kSandboxedPages))
     return true;
 
   ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kSandboxedPages, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesList);
     return false;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string relative_path;
     if (!list_value->GetString(i, &relative_path)) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidSandboxedPage, base::IntToString(i));
       return false;
     }
     URLPattern pattern(URLPattern::SCHEME_EXTENSION);
-    pattern.Parse(extension_url_.spec());
+    if (pattern.Parse(extension_url_.spec()) != URLPattern::PARSE_SUCCESS) {
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidURLPatternError, extension_url_.spec());
+      return false;
+    }
     while (relative_path[0] == '/')
       relative_path = relative_path.substr(1, relative_path.length() - 1);
     pattern.SetPath(pattern.path() + relative_path);
     sandboxed_pages_.AddPattern(pattern);
   }
 
   if (manifest_->HasPath(keys::kSandboxedPagesCSP)) {
     if (!manifest_->GetString(
         keys::kSandboxedPagesCSP, &sandboxed_pages_content_security_policy_)) {
       *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesCSP);
@@ skipping 900 matching lines @@
         !overrides->GetStringWithoutPathExpansion(*iter, &val)) {
       *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
       return false;
     }
     // Replace the entry with a fully qualified chrome-extension:// URL.
     chrome_url_overrides_[page] = GetResourceURL(val);
 
     // For component extensions, add override URL to extent patterns.
     if (is_packaged_app() && location() == COMPONENT) {
       URLPattern pattern(URLPattern::SCHEME_CHROMEUI);
-      pattern.Parse(base::StringPrintf(kOverrideExtentUrlPatternFormat,
-                                       page.c_str()));
+      std::string url = base::StringPrintf(kOverrideExtentUrlPatternFormat,
+                                           page.c_str());
+      if (pattern.Parse(url) != URLPattern::PARSE_SUCCESS) {
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+            errors::kInvalidURLPatternError, url);
+        return false;
+      }
       extent_.AddPattern(pattern);
     }
   }
 
   // An extension may override at most one page.
   if (overrides->size() > 1) {
     *error = ASCIIToUTF16(errors::kMultipleOverrides);
     return false;
   }
 
@@ skipping 512 matching lines @@
     return false;
 
   // Validate minimum Chrome version. We don't need to store this, since the
   // extension is not valid if it is incorrect
   if (!CheckMinimumChromeVersion(error))
     return false;
 
   if (!LoadRequiredFeatures(error))
     return false;
 
-  // We don't ned to validate because InitExtensionID already did that.
+  // We don't need to validate because InitExtensionID already did that.
   manifest_->GetString(keys::kPublicKey, &public_key_);
 
   extension_url_ = Extension::GetBaseURLFromExtensionId(id());
 
   // 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() && !LoadAppFeatures(error))
     return false;
 
@@ skipping 764 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions