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);
+        // For platform apps, there's not a really good way to know when the
+        // background page has started up and is ready to receive the
+        // onLaunched event, so we just wait half a second.

[Evan Stade, 2012/06/22 05:17:51]

suggestions for improvement welcome.

[Aaron Boodman, 2012/06/22 05:35:02]

LazyBackgroundTaskQueue ?

[Evan Stade, 2012/06/22 19:39:51]

awesome

+        MessageLoop::current()->PostDelayedTask(
+            FROM_HERE,
+            base::Bind(&ExtensionSettingsHandler::LaunchApplication,
+                       weak_factory_.GetWeakPtr(),
+                       extension->id()),
+            base::TimeDelta::FromMilliseconds(500));
+      }
+
+      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(
+    const std::string& extension_id) {
+  const Extension* extension =
+      extension_service_->GetExtensionById(extension_id, false);
+  if (!extension)
+    return;
+
+  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 open render
+  // views), then mark it for relaunch later.

[Evan Stade, 2012/06/22 05:17:51]

this is kind of a hokey definition of "running", but it seems to do the trick
most of the time. You could imagine a platform app that does something which
doesn't create render views when you launch it, in which case this wouldn't be
able to determine that the app had been launched and needs relaunching.

[Aaron Boodman, 2012/06/22 05:35:02]

I think if there are no running render views, the app is by definition not
running.

You could also just check if there is any process for this extension. That would
be about the same.

[Evan Stade, 2012/06/22 19:39:51]

I don't want to count background pages.

[Aaron Boodman, 2012/06/22 20:30:54]

I'm surprised that the event page is not returned here. An EventPage is a
WebContents that contains a RVH. It seems like it should be returned, and is
probably a bug that will eventually be fixed if it isn't.

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

oh, it does. I was confused because the background page was inactive at the
time.

+  if (extension->is_platform_app() &&
+      !profile->GetExtensionProcessManager()->
+          GetRenderViewHostsForExtension(extension->id()).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());
 }