[Extensions] Make URLPattern::ParseResult an enum class

Migrate URLPattern::ParseResult to an enum class (rather than just a
plain ol' enum) in order to make statements like this fail to compile:
  EXPECT_TRUE(pattern.Parse(...));
 or
  if (pattern.Parse(...))

Compiler failures are much easier to catch for methods that have semi-
ambiguous return results.

TBR=bradnelson@chromium.org (mechanical change in chrome/browser/nacl_host/nacl_browser_delegate_impl.cc)
Bug: None

Change-Id: I52496ae09d6ae6f683ec6a57767957f6ba8ea796
Reviewed-on: https://chromium-review.googlesource.com/1205999
Commit-Queue: Devlin <rdevlin.cronin@chromium.org>
Reviewed-by: Istiaque Ahmed <lazyboy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#588919}

chrome/browser/extensions/api/content_settings/content_settings_helpers.cc

@@ -41,7 +41,7 @@ ContentSettingsPattern ParseExtensionPattern(const std::string& pattern_str,
       URLPattern::SCHEME_FILE;
   URLPattern url_pattern(kAllowedSchemes);
   URLPattern::ParseResult result = url_pattern.Parse(pattern_str);
-  if (result != URLPattern::PARSE_SUCCESS) {
+  if (result != URLPattern::ParseResult::kSuccess) {
     *error = URLPattern::GetParseResultString(result);
     return ContentSettingsPattern();
   } else {

chrome/browser/extensions/api/developer_private/developer_private_api.cc

@@ -275,7 +275,7 @@ base::Optional<URLPattern> ParseRuntimePermissionsPattern(
                                                  URLPattern::SCHEME_FILE;
 
   URLPattern pattern(kValidRuntimePermissionSchemes);
-  if (pattern.Parse(pattern_str) != URLPattern::PARSE_SUCCESS)
+  if (pattern.Parse(pattern_str) != URLPattern::ParseResult::kSuccess)
     return base::nullopt;
 
   // We don't allow adding paths for permissions, because they aren't meaningful

chrome/browser/extensions/api/messaging/native_messaging_host_manifest.cc

@@ -119,7 +119,7 @@ bool NativeMessagingHostManifest::Parse(base::DictionaryValue* dictionary,
 
     URLPattern pattern(URLPattern::SCHEME_EXTENSION);
     URLPattern::ParseResult result = pattern.Parse(pattern_string);
-    if (result != URLPattern::PARSE_SUCCESS) {
+    if (result != URLPattern::ParseResult::kSuccess) {
       *error_message = "Failed to parse pattern \"" + pattern_string +
           "\": " + URLPattern::GetParseResultString(result);
       return false;

chrome/browser/extensions/api/permissions/permissions_api_helpers.cc

@@ -134,7 +134,7 @@ std::unique_ptr<const PermissionSet> UnpackPermissionSet(
         allowed_schemes &= ~URLPattern::SCHEME_FILE;
       URLPattern origin(allowed_schemes);
       URLPattern::ParseResult parse_result = origin.Parse(*it);
-      if (URLPattern::PARSE_SUCCESS != parse_result) {
+      if (URLPattern::ParseResult::kSuccess != parse_result) {
         *error = ErrorUtils::FormatErrorMessage(
             kInvalidOrigin,
             *it,

chrome/browser/extensions/extension_management.cc

@@ -365,7 +365,7 @@ void ExtensionManagement::Refresh() {
       std::string url_pattern;
       if (it->GetAsString(&url_pattern)) {
         URLPattern entry(URLPattern::SCHEME_ALL);
-        if (entry.Parse(url_pattern) == URLPattern::PARSE_SUCCESS) {
+        if (entry.Parse(url_pattern) == URLPattern::ParseResult::kSuccess) {
           global_settings_->install_sources.AddPattern(entry);
         } else {
           LOG(WARNING) << "Invalid URL pattern in for preference "

chrome/browser/extensions/extension_management_internal.cc

@@ -137,7 +137,7 @@ bool IndividualSettings::Parse(const base::DictionaryValue* dict,
           unparsed_str.append("/*");
         URLPattern::ParseResult parse_result = pattern.Parse(
             unparsed_str, URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD);
-        if (parse_result != URLPattern::PARSE_SUCCESS) {
+        if (parse_result != URLPattern::ParseResult::kSuccess) {
           LOG(WARNING) << kMalformedPreferenceWarning;
           LOG(WARNING) << "Invalid URL pattern '" + unparsed_str +
                               "' for attribute " + key;

chrome/browser/extensions/policy_handlers.cc

@@ -194,7 +194,8 @@ bool ExtensionURLPatternListPolicyHandler::CheckPolicySettings(
     }
 
     URLPattern pattern(URLPattern::SCHEME_ALL);
-    if (pattern.Parse(url_pattern_string) != URLPattern::PARSE_SUCCESS) {
+    if (pattern.Parse(url_pattern_string) !=
+        URLPattern::ParseResult::kSuccess) {
       errors->AddError(policy_name(),
                        entry - list_value->begin(),
                        IDS_POLICY_VALUE_FORMAT_ERROR);
@@ -309,12 +310,12 @@ bool ExtensionSettingsPolicyHandler::CheckPolicySettings(
           // These keys don't support paths due to how we track the initiator
           // of a webRequest and cookie security policy. We expect a valid
           // pattern to return a PARSE_ERROR_EMPTY_PATH.
-          if (parse_result == URLPattern::PARSE_ERROR_EMPTY_PATH) {
+          if (parse_result == URLPattern::ParseResult::kEmptyPath) {
             // Add a wildcard path to the URL as it should match any path.
             parse_result =
                 pattern.Parse(unparsed_url + "/*",
                               URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD);
-          } else if (parse_result == URLPattern::PARSE_SUCCESS) {
+          } else if (parse_result == URLPattern::ParseResult::kSuccess) {
             // The user supplied a path, notify them that this is not supported.
             if (!pattern.match_all_urls()) {
               errors->AddError(
@@ -326,7 +327,7 @@ bool ExtensionSettingsPolicyHandler::CheckPolicySettings(
               return false;
             }
           }
-          if (parse_result != URLPattern::PARSE_SUCCESS) {
+          if (parse_result != URLPattern::ParseResult::kSuccess) {
             errors->AddError(policy_name(), it.key(),
                              "Invalid URL pattern '" + unparsed_url +
                                  "' for attribute " + key);

chrome/browser/extensions/webstore_inline_installer.cc

@@ -305,9 +305,9 @@ bool WebstoreInlineInstaller::IsRequestorURLInVerifiedSite(
   URLPattern verified_site_pattern(valid_schemes);
   URLPattern::ParseResult parse_result =
       verified_site_pattern.Parse(verified_site_pattern_spec);
-  if (parse_result != URLPattern::PARSE_SUCCESS) {
-    DLOG(WARNING) << "Could not parse " << verified_site_pattern_spec <<
-        " as URL pattern " << parse_result;
+  if (parse_result != URLPattern::ParseResult::kSuccess) {
+    DLOG(WARNING) << "Failed to parse '" << verified_site_pattern_spec
+                  << "': " << URLPattern::GetParseResultString(parse_result);
     return false;
   }
   verified_site_pattern.SetScheme("*");

chrome/browser/nacl_host/nacl_browser_delegate_impl.cc

@@ -125,7 +125,7 @@ void NaClBrowserDelegateImpl::SetDebugPatterns(
     // since they can be dangerous in the context of chrome extension
     // permissions, but they are okay here, for NaCl GDB avoidance.
     URLPattern pattern(URLPattern::SCHEME_ALL);
-    if (pattern.Parse(pattern_str) == URLPattern::PARSE_SUCCESS) {
+    if (pattern.Parse(pattern_str) == URLPattern::ParseResult::kSuccess) {
       // If URL pattern has scheme equal to *, Parse method resets valid
       // schemes mask to http and https only, so we need to reset it after
       // Parse to re-include chrome-extension and chrome schema.

chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc

@@ -214,7 +214,7 @@ std::unique_ptr<FileBrowserHandler> LoadFileBrowserHandler(
       // wildcards in URLPattern, so transform to what will match correctly.
       filter.replace(0, 11, "chrome-extension://*/");
       URLPattern pattern(URLPattern::SCHEME_EXTENSION);
-      if (pattern.Parse(filter) != URLPattern::PARSE_SUCCESS) {
+      if (pattern.Parse(filter) != URLPattern::ParseResult::kSuccess) {
         *error = extensions::ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidURLPatternError, filter);
         return nullptr;

chrome/common/extensions/api/url_handlers/url_handlers_parser.cc

@@ -137,7 +137,7 @@ bool ParseUrlHandler(const std::string& handler_id,
     // URL patterns claimed here belong to the app's author verified sites.
     URLPattern pattern(URLPattern::SCHEME_HTTP |
                        URLPattern::SCHEME_HTTPS);
-    if (pattern.Parse(str_pattern) != URLPattern::PARSE_SUCCESS) {
+    if (pattern.Parse(str_pattern) != URLPattern::ParseResult::kSuccess) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           merrors::kInvalidURLHandlerPatternElement, handler_id);
       return false;

chrome/common/extensions/chrome_manifest_url_handlers.cc

@@ -129,7 +129,7 @@ bool URLOverridesHandler::Parse(Extension* extension, base::string16* error) {
       URLPattern pattern(URLPattern::SCHEME_CHROMEUI);
       std::string url =
           base::StringPrintf(kOverrideExtentUrlPatternFormat, page.c_str());
-      if (pattern.Parse(url) != URLPattern::PARSE_SUCCESS) {
+      if (pattern.Parse(url) != URLPattern::ParseResult::kSuccess) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidURLPatternError, url);
         return false;

chrome/common/extensions/manifest_handlers/app_launch_info.cc

@@ -289,7 +289,7 @@ void AppLaunchInfo::OverrideLaunchURL(Extension* extension,
 
   URLPattern pattern(Extension::kValidWebExtentSchemes);
   URLPattern::ParseResult result = pattern.Parse(override_url.spec());
-  DCHECK_EQ(result, URLPattern::PARSE_SUCCESS);
+  DCHECK_EQ(result, URLPattern::ParseResult::kSuccess);
   pattern.SetPath(pattern.path() + '*');
   extension->AddWebExtentPattern(pattern);
 }

chrome/common/extensions/manifest_handlers/automation_unittest.cc

@@ -79,10 +79,9 @@ TEST_F(AutomationManifestTest, Matches) {
   scoped_refptr<Extension> extension = LoadAndExpectWarning(
       "automation_matches.json",
       ErrorUtils::FormatErrorMessage(
-          automation_errors::kErrorInvalidMatch,
-          "www.badpattern.com",
+          automation_errors::kErrorInvalidMatch, "www.badpattern.com",
           URLPattern::GetParseResultString(
-              URLPattern::PARSE_ERROR_MISSING_SCHEME_SEPARATOR)));
+              URLPattern::ParseResult::kMissingSchemeSeparator)));
   ASSERT_TRUE(extension.get());
 
   EXPECT_TRUE(VerifyOnePermissionMessage(
@@ -150,10 +149,9 @@ TEST_F(AutomationManifestTest, NoValidMatches) {
   EXPECT_EQ("", error);
   EXPECT_EQ(2u, extension->install_warnings().size());
   EXPECT_EQ(ErrorUtils::FormatErrorMessage(
-                automation_errors::kErrorInvalidMatch,
-                "www.badpattern.com",
+                automation_errors::kErrorInvalidMatch, "www.badpattern.com",
                 URLPattern::GetParseResultString(
-                    URLPattern::PARSE_ERROR_MISSING_SCHEME_SEPARATOR)),
+                    URLPattern::ParseResult::kMissingSchemeSeparator)),
             extension->install_warnings()[0].message);
   EXPECT_EQ(automation_errors::kErrorNoMatchesProvided,
             extension->install_warnings()[1].message);

chrome/common/extensions/manifest_handlers/content_scripts_manifest_unittest.cc

@@ -26,22 +26,19 @@ class ContentScriptsManifestTest : public ChromeManifestTest {
 
 TEST_F(ContentScriptsManifestTest, MatchPattern) {
   Testcase testcases[] = {
-    // chrome:// urls are not allowed.
-    Testcase("content_script_chrome_url_invalid.json",
-             ErrorUtils::FormatErrorMessage(
-                 errors::kInvalidMatch,
-                 base::IntToString(0),
-                 base::IntToString(0),
-                 URLPattern::GetParseResultString(
-                     URLPattern::PARSE_ERROR_INVALID_SCHEME))),
+      // chrome:// urls are not allowed.
+      Testcase(
+          "content_script_chrome_url_invalid.json",
+          ErrorUtils::FormatErrorMessage(
+              errors::kInvalidMatch, base::IntToString(0), base::IntToString(0),
+              URLPattern::GetParseResultString(
+                  URLPattern::ParseResult::kInvalidScheme))),
 
-    // Match paterns must be strings.
-    Testcase("content_script_match_pattern_not_string.json",
-             ErrorUtils::FormatErrorMessage(errors::kInvalidMatch,
-                                            base::IntToString(0),
-                                            base::IntToString(0),
-                                            errors::kExpectString))
-  };
+      // Match paterns must be strings.
+      Testcase("content_script_match_pattern_not_string.json",
+               ErrorUtils::FormatErrorMessage(
+                   errors::kInvalidMatch, base::IntToString(0),
+                   base::IntToString(0), errors::kExpectString))};
   RunTestcases(testcases, arraysize(testcases),
                EXPECT_TYPE_ERROR);
 

chrome/common/extensions/manifest_tests/extension_manifests_web_unittest.cc

@@ -18,34 +18,28 @@ namespace errors = extensions::manifest_errors;
 
 TEST_F(ChromeManifestTest, AppWebUrls) {
   Testcase testcases[] = {
-    Testcase("web_urls_wrong_type.json", errors::kInvalidWebURLs),
-    Testcase("web_urls_invalid_1.json",
-             ErrorUtils::FormatErrorMessage(
-                 errors::kInvalidWebURL,
-                 base::IntToString(0),
-                 errors::kExpectString)),
-    Testcase("web_urls_invalid_2.json",
-             ErrorUtils::FormatErrorMessage(
-                 errors::kInvalidWebURL,
-                 base::IntToString(0),
-                 URLPattern::GetParseResultString(
-                 URLPattern::PARSE_ERROR_MISSING_SCHEME_SEPARATOR))),
-    Testcase("web_urls_invalid_3.json",
-             ErrorUtils::FormatErrorMessage(
-                 errors::kInvalidWebURL,
-                 base::IntToString(0),
-                 errors::kNoWildCardsInPaths)),
-    Testcase("web_urls_invalid_4.json",
-             ErrorUtils::FormatErrorMessage(
-                 errors::kInvalidWebURL,
-                 base::IntToString(0),
-                 errors::kCannotClaimAllURLsInExtent)),
-    Testcase("web_urls_invalid_5.json",
-             ErrorUtils::FormatErrorMessage(
-                 errors::kInvalidWebURL,
-                 base::IntToString(1),
-                 errors::kCannotClaimAllHostsInExtent))
-  };
+      Testcase("web_urls_wrong_type.json", errors::kInvalidWebURLs),
+      Testcase("web_urls_invalid_1.json",
+               ErrorUtils::FormatErrorMessage(errors::kInvalidWebURL,
+                                              base::IntToString(0),
+                                              errors::kExpectString)),
+      Testcase("web_urls_invalid_2.json",
+               ErrorUtils::FormatErrorMessage(
+                   errors::kInvalidWebURL, base::IntToString(0),
+                   URLPattern::GetParseResultString(
+                       URLPattern::ParseResult::kMissingSchemeSeparator))),
+      Testcase("web_urls_invalid_3.json",
+               ErrorUtils::FormatErrorMessage(errors::kInvalidWebURL,
+                                              base::IntToString(0),
+                                              errors::kNoWildCardsInPaths)),
+      Testcase("web_urls_invalid_4.json",
+               ErrorUtils::FormatErrorMessage(
+                   errors::kInvalidWebURL, base::IntToString(0),
+                   errors::kCannotClaimAllURLsInExtent)),
+      Testcase("web_urls_invalid_5.json",
+               ErrorUtils::FormatErrorMessage(
+                   errors::kInvalidWebURL, base::IntToString(1),
+                   errors::kCannotClaimAllHostsInExtent))};
   RunTestcases(testcases, arraysize(testcases),
                EXPECT_TYPE_ERROR);
 

extensions/browser/api/guest_view/web_view/web_view_internal_api.cc

@@ -150,7 +150,7 @@ std::unique_ptr<extensions::UserScript> ParseContentScript(
                        extension->id(), extension->location());
   for (const std::string& match : script_value.matches) {
     URLPattern pattern(UserScript::ValidUserScriptSchemes(allowed_everywhere));
-    if (pattern.Parse(match) != URLPattern::PARSE_SUCCESS) {
+    if (pattern.Parse(match) != URLPattern::ParseResult::kSuccess) {
       *error = errors::kInvalidMatches;
       return std::unique_ptr<extensions::UserScript>();
     }
@@ -165,7 +165,7 @@ std::unique_ptr<extensions::UserScript> ParseContentScript(
       URLPattern pattern(
           UserScript::ValidUserScriptSchemes(allowed_everywhere));
 
-      if (pattern.Parse(exclude_match) != URLPattern::PARSE_SUCCESS) {
+      if (pattern.Parse(exclude_match) != URLPattern::ParseResult::kSuccess) {
         *error = errors::kInvalidExcludeMatches;
         return std::unique_ptr<extensions::UserScript>();
       }

extensions/browser/api/web_request/web_request_api.cc

@@ -798,7 +798,7 @@ bool ExtensionWebRequestEventRouter::RequestFilter::InitFromValue(
                            URLPattern::SCHEME_EXTENSION |
                            URLPattern::SCHEME_WS | URLPattern::SCHEME_WSS);
         if (!urls_value->GetString(i, &url) ||
-            pattern.Parse(url) != URLPattern::PARSE_SUCCESS) {
+            pattern.Parse(url) != URLPattern::ParseResult::kSuccess) {
           *error = ErrorUtils::FormatErrorMessage(
               keys::kInvalidRequestFilterUrl, url);
           return false;

extensions/browser/user_script_loader.cc

@@ -122,12 +122,12 @@ bool UserScriptLoader::ParseMetadataHeader(const base::StringPiece& script_text,
         script->set_description(value);
       } else if (GetDeclarationValue(line, kMatchDeclaration, &value)) {
         URLPattern pattern(UserScript::ValidUserScriptSchemes());
-        if (URLPattern::PARSE_SUCCESS != pattern.Parse(value))
+        if (URLPattern::ParseResult::kSuccess != pattern.Parse(value))
           return false;
         script->add_url_pattern(pattern);
       } else if (GetDeclarationValue(line, kExcludeMatchDeclaration, &value)) {
         URLPattern exclude(UserScript::ValidUserScriptSchemes());
-        if (URLPattern::PARSE_SUCCESS != exclude.Parse(value))
+        if (URLPattern::ParseResult::kSuccess != exclude.Parse(value))
           return false;
         script->add_exclude_url_pattern(exclude);
       } else if (GetDeclarationValue(line, kRunAtDeclaration, &value)) {

extensions/common/extension.cc

@@ -673,12 +673,12 @@ bool Extension::LoadExtent(const char* key,
 
     URLPattern pattern(kValidWebExtentSchemes);
     URLPattern::ParseResult parse_result = pattern.Parse(pattern_string);
-    if (parse_result == URLPattern::PARSE_ERROR_EMPTY_PATH) {
+    if (parse_result == URLPattern::ParseResult::kEmptyPath) {
       pattern_string += "/";
       parse_result = pattern.Parse(pattern_string);
     }
 
-    if (parse_result != URLPattern::PARSE_SUCCESS) {
+    if (parse_result != URLPattern::ParseResult::kSuccess) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           value_error, base::NumberToString(i),
           URLPattern::GetParseResultString(parse_result));

extensions/common/extension_messages.cc

@@ -140,7 +140,7 @@ bool ParamTraits<URLPattern>::Read(const base::Pickle* m,
   URLPattern::ParseResult result =
       p->Parse(spec, URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD);
   p->SetValidSchemes(valid_schemes);
-  return URLPattern::PARSE_SUCCESS == result;
+  return URLPattern::ParseResult::kSuccess == result;
 }
 
 void ParamTraits<URLPattern>::Log(const param_type& p, std::string* l) {

extensions/common/manifest_handlers/automation.cc

@@ -253,7 +253,7 @@ std::unique_ptr<AutomationInfo> AutomationInfo::FromValue(
                            ~URLPattern::SCHEME_CHROMEUI);
         URLPattern::ParseResult parse_result = pattern.Parse(*it);
 
-        if (parse_result != URLPattern::PARSE_SUCCESS) {
+        if (parse_result != URLPattern::ParseResult::kSuccess) {
           install_warnings->push_back(
               InstallWarning(ErrorUtils::FormatErrorMessage(
                   automation_errors::kErrorInvalidMatch, *it,

extensions/common/manifest_handlers/content_scripts_handler.cc

@@ -159,7 +159,7 @@ std::unique_ptr<UserScript> LoadUserScriptFromDictionary(
     URLPattern pattern(valid_schemes);
 
     URLPattern::ParseResult parse_result = pattern.Parse(match_str);
-    if (parse_result != URLPattern::PARSE_SUCCESS) {
+    if (parse_result != URLPattern::ParseResult::kSuccess) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidMatch, base::IntToString(definition_index),
           base::NumberToString(j),
@@ -212,7 +212,7 @@ std::unique_ptr<UserScript> LoadUserScriptFromDictionary(
       URLPattern pattern(valid_schemes);
 
       URLPattern::ParseResult parse_result = pattern.Parse(match_str);
-      if (parse_result != URLPattern::PARSE_SUCCESS) {
+      if (parse_result != URLPattern::ParseResult::kSuccess) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidExcludeMatch, base::IntToString(definition_index),
             base::NumberToString(j),

extensions/common/manifest_handlers/externally_connectable.cc

@@ -117,7 +117,7 @@ std::unique_ptr<ExternallyConnectableInfo> ExternallyConnectableInfo::FromValue(
       // Safe to use SCHEME_ALL here; externally_connectable gives a page ->
       // extension communication path, not the other way.
       URLPattern pattern(URLPattern::SCHEME_ALL);
-      if (pattern.Parse(*it) != URLPattern::PARSE_SUCCESS) {
+      if (pattern.Parse(*it) != URLPattern::ParseResult::kSuccess) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             externally_connectable_errors::kErrorInvalidMatchPattern, *it);
         return std::unique_ptr<ExternallyConnectableInfo>();

extensions/common/manifest_handlers/permissions_parser.cc

@@ -187,7 +187,7 @@ bool ParseHelper(Extension* extension,
     // Check if it's a host pattern permission.
     URLPattern pattern = URLPattern(kAllowedSchemes);
     URLPattern::ParseResult parse_result = pattern.Parse(permission_str);
-    if (parse_result == URLPattern::PARSE_SUCCESS) {
+    if (parse_result == URLPattern::ParseResult::kSuccess) {
       // The path component is not used for host permissions, so we force it
       // to match all paths.
       pattern.SetPath("/*");

extensions/common/manifest_handlers/sandboxed_page_info.cc

@@ -82,7 +82,8 @@ bool SandboxedPageHandler::Parse(Extension* extension, base::string16* error) {
       return false;
     }
     URLPattern pattern(URLPattern::SCHEME_EXTENSION);
-    if (pattern.Parse(extension->url().spec()) != URLPattern::PARSE_SUCCESS) {
+    if (pattern.Parse(extension->url().spec()) !=
+        URLPattern::ParseResult::kSuccess) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidURLPatternError, extension->url().spec());
       return false;