[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 27 matching lines @@
 #include "chrome/common/extensions/api/developer_private.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
+#include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_error.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/notification_types.h"
@@ skipping 691 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));
   }
 
+  // If this call came from the web ui, we record it.

[not at google - send to devlin, 2015/03/03 22:22:10]

Why only from the web UI?
- if it's because we're specifically looking for some kind of UI metric, then
it'd be better to expose content::RecordComputedAction to WebUI and call it from
there.
- if it's to track how many times users try to load an unpacked extension, we
should always record it.

That said I've heard that Actions are expensive, and we don't appear to use it
(it doesn't appear in actions.xml), so let's just delete it entirely.

[Devlin, 2015/03/04 17:29:12]

Was gonna ask about this. Happy to remove.

+  if (!extension())
+    content::RecordComputedAction("Options_LoadUnpackedExtension");
+
+  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