[MD Extensions] Respond with a load error when loading unpacked fails

chrome/browser/ui/webui/extensions/extension_loader_handler.cc

 // Copyright 2014 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/browser/ui/webui/extensions/extension_loader_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 83 matching lines @@
   web_ui()->RegisterMessageCallback(
       "extensionLoaderIgnoreFailure",
       base::Bind(&ExtensionLoaderHandler::HandleIgnoreFailure,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
       "extensionLoaderDisplayFailures",
       base::Bind(&ExtensionLoaderHandler::HandleDisplayFailures,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+// static
+void ExtensionLoaderHandler::GetManifestError(
+    const std::string& error,
+    const base::FilePath& extension_path,
+    const GetManifestErrorCallback& callback) {
+  size_t line = 0u;

[Devlin, 2017/03/22 19:03:32]

Note: copy-paste.

[lazyboy, 2017/03/22 21:38:46]

Acknowledged.

+  size_t column = 0u;
+  std::string regex = base::StringPrintf("%s  Line: (\\d+), column: (\\d+), .*",
+                                         manifest_errors::kManifestParseError);
+  // If this was a JSON parse error, we can highlight the exact line with the
+  // error. Otherwise, we should still display the manifest (for consistency,
+  // reference, and so that if we ever make this really fancy and add an editor,
+  // it's ready).
+  //
+  // This regex call can fail, but if it does, we just don't highlight anything.
+  re2::RE2::FullMatch(error, regex, &line, &column);
+
+  // This will read the manifest and call AddFailure with the read manifest
+  // contents.
+  base::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE,
+      base::TaskTraits().MayBlock().WithPriority(
+          base::TaskPriority::USER_BLOCKING),
+      base::Bind(&ReadFileToString, extension_path.Append(kManifestFilename)),
+      base::Bind(callback, extension_path, error, line));
+}
+
 void ExtensionLoaderHandler::HandleRetry(const base::ListValue* args) {
   DCHECK(args->empty());
   const base::FilePath file_path = failed_paths_.back();
   failed_paths_.pop_back();
   LoadUnpackedExtension(file_path);
 }
 
 void ExtensionLoaderHandler::HandleIgnoreFailure(const base::ListValue* args) {
   DCHECK(args->empty());
   failed_paths_.pop_back();
@@ skipping 23 matching lines @@
 }
 
 void ExtensionLoaderHandler::OnLoadFailure(
     content::BrowserContext* browser_context,
     const base::FilePath& file_path,
     const std::string& error) {
   // Only show errors from our browser context.
   if (web_ui()->GetWebContents()->GetBrowserContext() != browser_context)
     return;
 
-  size_t line = 0u;
-  size_t column = 0u;
-  std::string regex =
-      base::StringPrintf("%s  Line: (\\d+), column: (\\d+), .*",
-                         manifest_errors::kManifestParseError);
-  // If this was a JSON parse error, we can highlight the exact line with the
-  // error. Otherwise, we should still display the manifest (for consistency,
-  // reference, and so that if we ever make this really fancy and add an editor,
-  // it's ready).
-  //
-  // This regex call can fail, but if it does, we just don't highlight anything.
-  re2::RE2::FullMatch(error, regex, &line, &column);
-
-  // This will read the manifest and call AddFailure with the read manifest
-  // contents.
-  base::PostTaskWithTraitsAndReplyWithResult(
-      FROM_HERE,
-      base::TaskTraits().MayBlock().WithPriority(
-          base::TaskPriority::USER_BLOCKING),
-      base::Bind(&ReadFileToString, file_path.Append(kManifestFilename)),
-      base::Bind(&ExtensionLoaderHandler::AddFailure,
-                 weak_ptr_factory_.GetWeakPtr(), file_path, error, line));
+  GetManifestError(error, file_path,
+                   base::Bind(&ExtensionLoaderHandler::AddFailure,
+                              weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ExtensionLoaderHandler::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
 
   // In the event of a page reload, we ensure that the frontend is not notified
   // until the UI finishes loading, so we set |ui_ready_| to false. This is
   // balanced in HandleDisplayFailures, which is called when the frontend is
@@ skipping 28 matching lines @@
     NotifyFrontendOfFailure();
 }
 
 void ExtensionLoaderHandler::NotifyFrontendOfFailure() {
   web_ui()->CallJavascriptFunctionUnsafe(
       "extensions.ExtensionLoader.notifyLoadFailed", failures_);
   failures_.Clear();
 }
 
 }  // namespace extensions