make "reload" on chrome://extensions automatically relaunch running apps

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 "base/auto_reset.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.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/prefs/pref_service.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/extensions/application_launch.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 22 matching lines @@
 //
 // ExtensionSettingsHandler
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 ExtensionSettingsHandler::ExtensionSettingsHandler()
     : extension_service_(NULL),
       management_policy_(NULL),
       ignore_notifications_(false),
       deleting_rvh_(NULL),
-      registered_for_notifications_(false) {
+      registered_for_notifications_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 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_)
     load_extension_dialog_->ListenerDestroyed();
 
   registrar_.RemoveAll();
 }
 
 ExtensionSettingsHandler::ExtensionSettingsHandler(ExtensionService* service,
                                                    ManagementPolicy* policy)
     : extension_service_(service),
       management_policy_(policy),
       ignore_notifications_(false),
       deleting_rvh_(NULL),
-      registered_for_notifications_(false) {
+      registered_for_notifications_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 // static
 void ExtensionSettingsHandler::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kExtensionsUIDeveloperMode,
                              false,
                              PrefService::SYNCABLE_PREF);
 }
 
 DictionaryValue* ExtensionSettingsHandler::CreateExtensionDetailValue(
@@ skipping 286 matching lines @@
       MaybeUpdateAfterNotification();
       break;
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED:
       deleting_rvh_ = content::Details<BackgroundContents>(details)->
           web_contents()->GetRenderViewHost();
       // Fall through.
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED:
     case chrome::NOTIFICATION_EXTENSION_HOST_CREATED:
       source_profile = content::Source<Profile>(source).ptr();
       if (!profile->IsSameProfile(source_profile))
-          return;
+        return;
       MaybeUpdateAfterNotification();
       break;
-    case chrome::NOTIFICATION_EXTENSION_LOADED:
+    case chrome::NOTIFICATION_EXTENSION_LOADED: {
+      source_profile = content::Source<Profile>(source).ptr();
+      const Extension* extension =
+          content::Details<const Extension>(details).ptr();
+      std::list<std::string>::iterator iter =
+          std::find(relaunch_app_ids_.begin(), relaunch_app_ids_.end(),
+                    extension->id());
+
+      if (profile->IsSameProfile(source_profile) &&
+          iter != relaunch_app_ids_.end()) {
+        relaunch_app_ids_.erase(iter);
+        extensions::LazyBackgroundTaskQueue* queue =
+            ExtensionSystem::Get(profile)->lazy_background_task_queue();
+        if (queue->ShouldEnqueueTask(profile, extension)) {

[Evan Stade, 2012/06/22 22:29:50]

you would expect this to work, but it doesn't, because right after this LOADED
event we get an UNLOADED for the same extension, which flushes the queue. It's
easy enough to see why this is happening, here is the stack trace:

	ExtensionSettingsHandler::LaunchApplication() [0x7f18baa07329]
	extensions::LazyBackgroundTaskQueue::ProcessPendingTasks() [0x7f18bc6c09fc]
	extensions::LazyBackgroundTaskQueue::Observe() [0x7f18bc6c0fe1]
	NotificationServiceImpl::Notify() [0x7f18bc81e5f4]
	ExtensionHost::~ExtensionHost() [0x7f18bc65d98b]
	ExtensionProcessManager::CloseBackgroundHost() [0x7f18bc6800c5]
	ExtensionProcessManager::Observe() [0x7f18bc681632]
	NotificationServiceImpl::Notify() [0x7f18bc81da94]
	ExtensionService::NotifyExtensionUnloaded() [0x7f18bc695f33]
	ExtensionService::UnloadExtension() [0x7f18bc6966e3]
	ExtensionService::InitializePermissions() [0x7f18bc697ed3]
	ExtensionService::AddExtension() [0x7f18bc699d8f]
	ExtensionService::OnExtensionInstalled() [0x7f18bc692f92]
	extensions::UnpackedInstaller::OnLoaded() [0x7f18bc6d447f]

but it's harder to see what the correct fix is. The end result is that when you
reload an unpacked extension, you get an UNLOADED, LOADED (from
EnableExtension), UNLOADED (from InitializePermissions), and then another LOADED
(from AddExtension).

+          queue->AddPendingTask(profile, extension->id(),
+              base::Bind(&ExtensionSettingsHandler::LaunchApplication,
+                         weak_factory_.GetWeakPtr()));
+        }
+      }
+
+      MaybeUpdateAfterNotification();
+      break;
+    }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED:
     case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
     case chrome::NOTIFICATION_EXTENSION_WARNING_CHANGED:
     case chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED:
     case chrome::NOTIFICATION_PREF_CHANGED:
       MaybeUpdateAfterNotification();
       break;
     default:
       NOTREACHED();
   }
 }
 
+void ExtensionSettingsHandler::LaunchApplication(
+    ExtensionHost* extension_host) {
+  if (!extension_host)
+    return;
+
+  const Extension* extension = extension_host->extension();
+  extension_misc::LaunchContainer launch_container =
+      extension_service_->extension_prefs()->GetLaunchContainer(
+          extension, ExtensionPrefs::LAUNCH_REGULAR);
+
+  application_launch::OpenApplication(
+      extension_service_->profile(), extension, launch_container, GURL(),
+      NEW_BACKGROUND_TAB, NULL);
+}
+
 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.
   const Extension* extension =
       extension_service_->GetExtensionById(extension_id_prompting_, true);
   if (!extension) {
@@ skipping 23 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 ((*extension)->location() == Extension::LOAD)
       unpacked_extensions.push_back(*extension);
   }
 
   for (std::vector<const Extension*>::iterator iter =
        unpacked_extensions.begin(); iter != unpacked_extensions.end(); ++iter) {
-    extension_service_->ReloadExtension((*iter)->id());
+    ReloadExtension(*iter);
   }
 }
 
+void ExtensionSettingsHandler::ReloadExtension(const Extension* extension) {
+  Profile* profile = Profile::FromWebUI(web_ui());
+  // If the extension is a platform app, and is "running" (i.e. has at least one
+  // open render view), then mark it for relaunch later.
+  if (extension->is_platform_app() &&
+      !profile->GetExtensionProcessManager()->
+          GetRenderViewHostsWithTypeForExtension(
+              extension->id(), chrome::VIEW_TYPE_APP_SHELL).empty()) {
+    relaunch_app_ids_.push_back(extension->id());
+  }
+  extension_service_->ReloadExtension(extension->id());
+}
+
 void ExtensionSettingsHandler::HandleRequestExtensionsData(
     const ListValue* args) {
   DictionaryValue results;
 
   // Add the extensions to the results structure.
   ListValue *extensions_list = new ListValue();
 
   ExtensionWarningSet* warnings = extension_service_->extension_warnings();
 
   const ExtensionSet* extensions = extension_service_->extensions();
@@ skipping 102 matching lines @@
     // This can happen if the host has gone away since the page was displayed.
     return;
   }
 
   DevToolsWindow::OpenDevToolsWindow(host);
 }
 
 void ExtensionSettingsHandler::HandleReloadMessage(const ListValue* args) {
   std::string extension_id = UTF16ToUTF8(ExtractStringValue(args));
   CHECK(!extension_id.empty());
-  extension_service_->ReloadExtension(extension_id);
+
+  const Extension* extension =
+      extension_service_->GetExtensionById(extension_id, false);
+  ReloadExtension(extension);
 }
 
 void ExtensionSettingsHandler::HandleEnableMessage(const 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));
 
   const Extension* extension =
       extension_service_->GetInstalledExtension(extension_id);
@@ skipping 259 matching lines @@
   return extension_uninstall_dialog_.get();
 #else
   return NULL;
 #endif  // !defined(OS_ANDROID)
 }
 
 void ExtensionSettingsHandler::InspectExtensionHost(ExtensionHost* host) {
   if (host)
     DevToolsWindow::OpenDevToolsWindow(host->render_view_host());
 }