[Extensions] Make chrome://extensions use developerPrivate for unpacked loading

chrome/browser/extensions/api/developer_private/developer_private_api.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/browser/extensions/api/developer_private/developer_private_api.h"
 
 #include "apps/app_load_service.h"
 #include "apps/saved_files_service.h"
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 738 matching lines @@
     ~DeveloperPrivateAllowIncognitoFunction() {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateReloadFunction::Run() {
   scoped_ptr<Reload::Params> params(Reload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Extension* extension = GetExtensionById(params->extension_id);
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
-  bool fail_quietly = params->options && params->options->fail_quietly;
+  bool fail_quietly = params->options &&
+                      params->options->fail_quietly &&
+                      *params->options->fail_quietly;
 
   ExtensionService* service = GetExtensionService(browser_context());
   if (fail_quietly)
     service->ReloadExtensionWithQuietFailure(params->extension_id);
   else
     service->ReloadExtension(params->extension_id);
 
   // TODO(devlin): We shouldn't return until the extension has finished trying
   // to reload (and then we could also return the error).
   return RespondNow(NoArguments());
@@ skipping 94 matching lines @@
     return false;
   }
 
   DevToolsWindow::OpenDevToolsWindow(
       content::WebContents::FromRenderViewHost(host));
   return true;
 }
 
 DeveloperPrivateInspectFunction::~DeveloperPrivateInspectFunction() {}
 
+DeveloperPrivateLoadUnpackedFunction::DeveloperPrivateLoadUnpackedFunction()
+    : fail_quietly_(false) {
+}
+
 ExtensionFunction::ResponseAction DeveloperPrivateLoadUnpackedFunction::Run() {
+  scoped_ptr<developer_private::LoadUnpacked::Params> params(
+      developer_private::LoadUnpacked::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+
   if (!ShowPicker(
            ui::SelectFileDialog::SELECT_FOLDER,
            l10n_util::GetStringUTF16(IDS_EXTENSION_LOAD_FROM_DIRECTORY),
            ui::SelectFileDialog::FileTypeInfo(),
            0 /* file_type_index */)) {
     return RespondNow(Error(kCouldNotShowSelectFileDialogError));
   }
 
+  fail_quietly_ = params->options &&
+                  params->options->fail_quietly &&
+                  *params->options->fail_quietly;
+
   AddRef();  // Balanced in FileSelected / FileSelectionCanceled.
   return RespondLater();
 }
 
 void DeveloperPrivateLoadUnpackedFunction::FileSelected(
     const base::FilePath& path) {
-  UnpackedInstaller::Create(GetExtensionService(browser_context()))->Load(path);
+  scoped_refptr<UnpackedInstaller> installer(
+      UnpackedInstaller::Create(GetExtensionService(browser_context())));
+  installer->set_be_noisy_on_failure(!fail_quietly_);
+  installer->set_completion_callback(
+      base::Bind(&DeveloperPrivateLoadUnpackedFunction::OnLoadComplete, this));
+  installer->Load(path);
+
   DeveloperPrivateAPI::Get(browser_context())->SetLastUnpackedDirectory(path);
-  // TODO(devlin): Shouldn't we wait until the extension is loaded?
-  Respond(NoArguments());
+
   Release();  // Balanced in Run().
 }
 
 void DeveloperPrivateLoadUnpackedFunction::FileSelectionCanceled() {
   // This isn't really an error, but we should keep it like this for
   // backward compatability.
   Respond(Error(kFileSelectionCanceled));
   Release();  // Balanced in Run().
 }
 
+void DeveloperPrivateLoadUnpackedFunction::OnLoadComplete(
+    const Extension* extension,
+    const base::FilePath& file_path,
+    const std::string& error) {
+  Respond(extension ? NoArguments() : Error(error));
+}
+
 bool DeveloperPrivateChooseEntryFunction::ShowPicker(
     ui::SelectFileDialog::Type picker_type,
     const base::string16& select_title,
     const ui::SelectFileDialog::FileTypeInfo& info,
     int file_type_index) {
   content::WebContents* web_contents = GetSenderWebContents();
   if (!web_contents)
     return false;
 
   // The entry picker will hold a reference to this function instance,
@@ skipping 431 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0u, &dict));
 
   error_ui_util::HandleOpenDevTools(dict);
 
   return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions