Show alert failure for reloading unpacked extensions with bad manifest

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 "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 13 matching lines @@
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/file_highlighter.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "grit/generated_resources.h"
 #include "third_party/re2/re2/re2.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/shell_dialogs/select_file_dialog.h"
 
+#include "base/debug/stack_trace.h"
+
+class ExtensionErrorReporter;
+class ExtensionErrorReporterObserver;
+
 namespace extensions {
 
 namespace {
 
 // Read a file to a string and return.
 std::string ReadFileToString(const base::FilePath& path) {
   std::string data;
   // This call can fail, but it doesn't matter for our purposes. If it fails,
   // we simply return an empty string for the manifest, and ignore it.
   base::ReadFileToString(path, &data);
@@ skipping 80 matching lines @@
 }
 
 void ExtensionLoaderHandler::FileHelper::MultiFilesSelected(
       const std::vector<base::FilePath>& files, void* params) {
   NOTREACHED();
 }
 
 ExtensionLoaderHandler::ExtensionLoaderHandler(Profile* profile)
     : profile_(profile),
       file_helper_(new FileHelper(this)),
-      weak_ptr_factory_(this) {
+      weak_ptr_factory_(this),
+      extension_error_reporter_observer_(this) {
   DCHECK(profile_);
+  DLOG(ERROR) << "--------------Constructor";
+  extension_error_reporter_observer_.Add(ExtensionErrorReporter::GetInstance());
 }
 
 ExtensionLoaderHandler::~ExtensionLoaderHandler() {
 }
 
 void ExtensionLoaderHandler::GetLocalizedValues(
     content::WebUIDataSource* source) {
   source->AddString(
       "extensionLoadErrorHeading",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_LOAD_ERROR_HEADING));
@@ skipping 29 matching lines @@
 
 void ExtensionLoaderHandler::HandleRetry(const base::ListValue* args) {
   DCHECK(args->empty());
   LoadUnpackedExtensionImpl(failed_path_);
 }
 
 void ExtensionLoaderHandler::LoadUnpackedExtensionImpl(
     const base::FilePath& file_path) {
   scoped_refptr<UnpackedInstaller> installer = UnpackedInstaller::Create(
       ExtensionSystem::Get(profile_)->extension_service());
-  installer->set_on_failure_callback(
-      base::Bind(&ExtensionLoaderHandler::OnLoadFailure,
-                 weak_ptr_factory_.GetWeakPtr()));
+  //  installer->set_on_failure_callback(
+  //      base::Bind(&ExtensionLoaderHandler::OnLoadFailure,
+  //                 weak_ptr_factory_.GetWeakPtr()));
 
   // We do our own error handling, so we don't want a load failure to trigger
   // a dialog.
   installer->set_be_noisy_on_failure(false);
 
+  DLOG(ERROR) << "----------LoadUnpackedExtensionImpl";
   installer->Load(file_path);
 }
 
 void ExtensionLoaderHandler::OnLoadFailure(const base::FilePath& file_path,
                                            const std::string& error) {
+  DLOG(ERROR) << "-------OnLoadFailure";
   failed_path_ = file_path;
   size_t line = 0u;
   size_t column = 0u;
   std::string regex =
       base::StringPrintf("%s  Line: (\\d+), column: (\\d+), Syntax error.",
                          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 NotifyFrontendOfFailure with the read
   // manifest contents.
   base::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&ReadFileToString, file_path.Append(kManifestFilename)),
       base::Bind(&ExtensionLoaderHandler::NotifyFrontendOfFailure,
                  weak_ptr_factory_.GetWeakPtr(),
                  file_path,
                  error,
                  line));
+  /*

[gpdavis, 2014/06/18 23:53:16]

Replacing the PostTaskAndReplyWithResult with this commented section results in
an error:

"Function marked as IO-only was called from a thread that disallows IO!  If this
thread really should be allowed to make IO calls, adjust the call to
base::ThreadRestrictions::SetIOAllowed() in this thread's startup."

+     const std::string& manifest =
+     ReadFileToString(file_path.Append(kManifestFilename));
+     ExtensionLoaderHandler::NotifyFrontendOfFailure(file_path, error, line,
+     manifest);
+  */
 }
 
 void ExtensionLoaderHandler::NotifyFrontendOfFailure(
     const base::FilePath& file_path,
     const std::string& error,
     size_t line_number,
     const std::string& manifest) {
   base::StringValue file_value(file_path.LossyDisplayName());
   base::StringValue error_value(base::UTF8ToUTF16(error));
 
   base::DictionaryValue manifest_value;
   SourceHighlighter highlighter(manifest, line_number);
   // If the line number is 0, this highlights no regions, but still adds the
   // full manifest.
   highlighter.SetHighlightedRegions(&manifest_value);
 
+  DLOG(ERROR) << "-NotifyFrontendOfFailure";
+  base::debug::StackTrace trace;
+  LOG(WARNING) << "My trace is: " << trace.ToString();
+
   web_ui()->CallJavascriptFunction(
       "extensions.ExtensionLoader.notifyLoadFailed",
       file_value,
       error_value,
       manifest_value);
 }
 
 }  // namespace extensions