Improve UI for unpacked extensions failing to load

chrome/browser/ui/webui/extensions/extension_settings_handler.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/ui/webui/extensions/extension_settings_handler.h"
 
 #include "apps/app_load_service.h"
 #include "apps/app_restore_service.h"
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
@@ skipping 21 matching lines @@
 #include "chrome/browser/extensions/devtools_util.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_disabled_ui.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/extensions/install_verifier.h"
-#include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/background_contents.h"
 #include "chrome/browser/ui/browser_finder.h"
-#include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/webui/extensions/extension_basic_info.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.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/user_metrics.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "extensions/browser/blacklist_state.h"
 #include "extensions/browser/extension_error.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/pref_names.h"
@@ skipping 82 matching lines @@
       deleting_rwh_id_(-1),
       deleting_rph_id_(-1),
       registered_for_notifications_(false),
       warning_service_observer_(this),
       error_console_observer_(this),
       extension_prefs_observer_(this),
       should_do_verification_check_(false) {
 }
 
 ExtensionSettingsHandler::~ExtensionSettingsHandler() {
-  // There may be pending file dialogs, we need to tell them that we've gone
-  // away so they don't try and call back to us.
-  if (load_extension_dialog_.get())
-    load_extension_dialog_->ListenerDestroyed();
 }
 
 ExtensionSettingsHandler::ExtensionSettingsHandler(ExtensionService* service,
                                                    ManagementPolicy* policy)
     : extension_service_(service),
       management_policy_(policy),
       ignore_notifications_(false),
       deleting_rvh_(NULL),
       deleting_rwh_id_(-1),
       deleting_rph_id_(-1),
@@ skipping 389 matching lines @@
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsPermissions",
       base::Bind(&ExtensionSettingsHandler::HandlePermissionsMessage,
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsShowButton",
       base::Bind(&ExtensionSettingsHandler::HandleShowButtonMessage,
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsAutoupdate",
       base::Bind(&ExtensionSettingsHandler::HandleAutoUpdateMessage,
                  AsWeakPtr()));
-  web_ui()->RegisterMessageCallback("extensionSettingsLoadUnpackedExtension",
-      base::Bind(&ExtensionSettingsHandler::HandleLoadUnpackedExtensionMessage,
-                 AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsDismissADTPromo",
       base::Bind(&ExtensionSettingsHandler::HandleDismissADTPromoMessage,
                  AsWeakPtr()));
 }
 
-void ExtensionSettingsHandler::LoadUnpackedExtension(
-    const base::FilePath& path) {
-  UnpackedInstaller::Create(extension_service_)->Load(path);
-}
-
-int ExtensionSettingsHandler::IndexOfLoadingPath(const base::FilePath& path) {
-  for (size_t i = 0; i < loading_extension_directories_.size(); ++i) {
-    if (path == loading_extension_directories_[i])
-      return i;
-  }
-  return -1;
-}
-
-void ExtensionSettingsHandler::AddLoadingPath(const base::FilePath& path) {
-  DCHECK(IndexOfLoadingPath(path) == -1);
-
-  if (loading_extension_directories_.empty()) {
-    Profile* profile = Profile::FromWebUI(web_ui());
-    registrar_.Add(this,
-                   chrome::NOTIFICATION_EXTENSION_LOAD_RETRY,
-                   content::Source<Profile>(profile));
-  }
-  loading_extension_directories_.push_back(path);
-}
-
-void ExtensionSettingsHandler::RemoveLoadingPath(const base::FilePath& path) {
-  int index = IndexOfLoadingPath(path);
-  DCHECK(index != -1);
-
-  loading_extension_directories_.erase(loading_extension_directories_.begin() +
-                                       index);
-  if (loading_extension_directories_.empty()) {
-    Profile* profile = Profile::FromWebUI(web_ui());
-    registrar_.Remove(this,
-                      chrome::NOTIFICATION_EXTENSION_LOAD_RETRY,
-                      content::Source<Profile>(profile));
-  }
-}
-
-void ExtensionSettingsHandler::FileSelected(const base::FilePath& path,
-                                            int index,
-                                            void* params) {
-  last_unpacked_directory_ = base::FilePath(path);
-  AddLoadingPath(last_unpacked_directory_);
-  LoadUnpackedExtension(path);
-}
-
-void ExtensionSettingsHandler::MultiFilesSelected(
-    const std::vector<base::FilePath>& files, void* params) {
-  NOTREACHED();
-}
-
-void ExtensionSettingsHandler::FileSelectionCanceled(void* params) {
-}
-
 void ExtensionSettingsHandler::OnErrorAdded(const ExtensionError* error) {
   MaybeUpdateAfterNotification();
 }
 
 void ExtensionSettingsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   Profile* profile = Profile::FromWebUI(web_ui());
   Profile* source_profile = NULL;
@@ skipping 19 matching lines @@
       MaybeUpdateAfterNotification();
       break;
     case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
       content::RenderWidgetHost* rwh =
           content::Source<content::RenderWidgetHost>(source).ptr();
       deleting_rwh_id_ = rwh->GetRoutingID();
       deleting_rph_id_ = rwh->GetProcess()->GetID();
       MaybeUpdateAfterNotification();
       break;
     }
-    case chrome::NOTIFICATION_EXTENSION_LOAD_RETRY: {
-      std::pair<bool, const base::FilePath&>* retry_and_path =
-          content::Details<std::pair<bool, const base::FilePath&> >(details)
-              .ptr();
-      HandleLoadRetryMessage(retry_and_path->first, retry_and_path->second);
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
-      const base::FilePath& path =
-          content::Details<const Extension>(details).ptr()->path();
-      if (IndexOfLoadingPath(path) != -1)
-        RemoveLoadingPath(path);
-      // Fall through.
-    }
+    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
     case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED:
     case chrome::NOTIFICATION_EXTENSION_UNINSTALLED:
     case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
     case chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED:
       MaybeUpdateAfterNotification();
       break;
     case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED:
        // This notification is sent when the extension host destruction begins,
        // not when it finishes. We use PostTask to delay the update until after
        // the destruction finishes.
        base::MessageLoop::current()->PostTask(
            FROM_HERE,
            base::Bind(&ExtensionSettingsHandler::MaybeUpdateAfterNotification,
                       AsWeakPtr()));
        break;
     default:
       NOTREACHED();
   }
 }
 
 void ExtensionSettingsHandler::OnExtensionDisableReasonsChanged(
-    const std::string& extension_id,
-    int disable_reasons) {
+    const std::string& extension_id, int disable_reasons) {
   MaybeUpdateAfterNotification();
 }
 
 void ExtensionSettingsHandler::ExtensionUninstallAccepted() {
   DCHECK(!extension_id_prompting_.empty());
 
   bool was_terminated = false;
 
   // The extension can be uninstalled in another window while the UI was
   // showing. Do nothing in that case.
@@ skipping 48 matching lines @@
   const ExtensionSet* extensions = extension_service_->extensions();
   std::vector<const Extension*> unpacked_extensions;
   for (ExtensionSet::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if (Manifest::IsUnpackedLocation((*extension)->location()))
       unpacked_extensions.push_back(extension->get());
   }
 
   for (std::vector<const Extension*>::iterator iter =
        unpacked_extensions.begin(); iter != unpacked_extensions.end(); ++iter) {
-    AddLoadingPath((*iter)->path());
     extension_service_->ReloadExtension((*iter)->id());
   }
 }
 
 void ExtensionSettingsHandler::HandleRequestExtensionsData(
     const base::ListValue* args) {
   base::DictionaryValue results;
 
   Profile* profile = Profile::FromWebUI(web_ui());
 
@@ skipping 133 matching lines @@
       extension_service_->GetExtensionById(extension_id, false);
   OpenApplication(AppLaunchParams(extension_service_->profile(), extension,
                                   extensions::LAUNCH_CONTAINER_WINDOW,
                                   NEW_WINDOW));
 }
 
 void ExtensionSettingsHandler::HandleReloadMessage(
     const base::ListValue* args) {
   std::string extension_id = base::UTF16ToUTF8(ExtractStringValue(args));
   CHECK(!extension_id.empty());
-  const Extension* extension =
-      extension_service_->GetInstalledExtension(extension_id);
-  if (extension)
-    AddLoadingPath(extension->path());
   extension_service_->ReloadExtension(extension_id);
 }
 
 void ExtensionSettingsHandler::HandleEnableMessage(
     const base::ListValue* args) {
   CHECK_EQ(2U, args->GetSize());
   std::string extension_id, enable_str;
   CHECK(args->GetString(0, &extension_id));
   CHECK(args->GetString(1, &enable_str));
 
@@ skipping 173 matching lines @@
 void ExtensionSettingsHandler::HandleAutoUpdateMessage(
     const base::ListValue* args) {
   ExtensionUpdater* updater = extension_service_->updater();
   if (updater) {
     ExtensionUpdater::CheckParams params;
     params.install_immediately = true;
     updater->CheckNow(params);
   }
 }
 
-void ExtensionSettingsHandler::HandleLoadUnpackedExtensionMessage(
-    const base::ListValue* args) {
-  DCHECK(args->empty());
-
-  base::string16 select_title =
-      l10n_util::GetStringUTF16(IDS_EXTENSION_LOAD_FROM_DIRECTORY);
-
-  const int kFileTypeIndex = 0;  // No file type information to index.
-  const ui::SelectFileDialog::Type kSelectType =
-      ui::SelectFileDialog::SELECT_FOLDER;
-  load_extension_dialog_ = ui::SelectFileDialog::Create(
-      this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
-  load_extension_dialog_->SelectFile(
-      kSelectType,
-      select_title,
-      last_unpacked_directory_,
-      NULL,
-      kFileTypeIndex,
-      base::FilePath::StringType(),
-      web_ui()->GetWebContents()->GetView()->GetTopLevelNativeWindow(),
-      NULL);
-
-  content::RecordComputedAction("Options_LoadUnpackedExtension");
-}
-
 void ExtensionSettingsHandler::HandleDismissADTPromoMessage(
     const base::ListValue* args) {
   DCHECK(args->empty());
   Profile::FromWebUI(web_ui())->GetPrefs()->SetBoolean(
       prefs::kExtensionsUIDismissedADTPromo, true);
 }
 
 void ExtensionSettingsHandler::ShowAlert(const std::string& message) {
   base::ListValue arguments;
   arguments.Append(base::Value::CreateStringValue(message));
@@ skipping 200 matching lines @@
 }
 
 void ExtensionSettingsHandler::OnRequirementsChecked(
     std::string extension_id,
     std::vector<std::string> requirement_errors) {
   if (requirement_errors.empty()) {
     extension_service_->EnableExtension(extension_id);
   } else {
     ExtensionErrorReporter::GetInstance()->ReportError(
         base::UTF8ToUTF16(JoinString(requirement_errors, ' ')),
-        true,   // Be noisy.
-        NULL);  // Caller expects no response.
+        true);  // Be noisy.
   }
   requirements_checker_.reset();
 }
 
-void ExtensionSettingsHandler::HandleLoadRetryMessage(
-    bool retry,
-    const base::FilePath& path) {
-  if (IndexOfLoadingPath(path) == -1)
-    return;  // Not an extension we're tracking.
-  if (retry)
-    LoadUnpackedExtension(path);
-  else
-    RemoveLoadingPath(path);
-}
-
 }  // namespace extensions