Move application restart and relaunch code out of ExtensionService.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2013 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/extension_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 668 matching lines @@
   installer->set_install_cause(extension_misc::INSTALL_CAUSE_UPDATE);
   installer->InstallCrx(extension_path);
 
   if (out_crx_installer)
     *out_crx_installer = installer;
 
   return true;
 }
 
 void ExtensionService::ReloadExtension(const std::string& extension_id) {
-  int events = HasShellWindows(extension_id) ? EVENT_LAUNCHED : EVENT_NONE;
-  ReloadExtensionWithEvents(extension_id, events);
-}
-
-void ExtensionService::RestartExtension(const std::string& extension_id) {
-  ReloadExtensionWithEvents(extension_id, EVENT_RESTARTED);
-}
-
-void ExtensionService::ReloadExtensionWithEvents(
-    const std::string& extension_id,
-    int events) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If the extension is already reloading, don't reload again.
   if (extension_prefs_->GetDisableReasons(extension_id) &
       Extension::DISABLE_RELOAD) {
     return;
   }
 
   base::FilePath path;
   const Extension* current_extension = GetExtensionById(extension_id, false);
@@ skipping 15 matching lines @@
         orphaned_dev_tools_[extension_id] = devtools_cookie;
     }
 
     path = current_extension->path();
     DisableExtension(extension_id, Extension::DISABLE_RELOAD);
     reloading_extensions_.insert(extension_id);
   } else {
     path = unloaded_extension_paths_[extension_id];
   }
 
-  on_load_events_[extension_id] = events;
-
   if (delayed_updates_for_idle_.Contains(extension_id)) {
     FinishDelayedInstallation(extension_id);
     return;
   }
 
   // If we're reloading a component extension, use the component extension
   // loader's reloader.
   if (component_loader_->Exists(extension_id)) {
     component_loader_->Reload(extension_id);
     return;
@@ skipping 1342 matching lines @@
     // Show the extension disabled error if a permissions increase was the
     // only reason it was disabled.
     if (extension_prefs_->GetDisableReasons(extension->id()) ==
         Extension::DISABLE_PERMISSIONS_INCREASE) {
       extensions::AddExtensionDisabledError(this, extension);
     }
   } else if (reloading) {
     // Replace the old extension with the new version.
     CHECK(!disabled_extensions_.Insert(extension));
     EnableExtension(extension->id());
-    DoPostLoadTasks(extension);
   } else {
     // All apps that are displayed in the launcher are ordered by their ordinals
     // so we must ensure they have valid ordinals.
     if (extension->RequiresSortOrdinal()) {
       if (!extension->ShouldDisplayInNewTabPage()) {
         extension_prefs_->extension_sorting()->MarkExtensionAsHidden(
             extension->id());
       }
       extension_prefs_->extension_sorting()->EnsureValidOrdinals(
           extension->id(), syncer::StringOrdinal());
     }
 
     extensions_.Insert(extension);
     SyncExtensionChangeIfNeeded(*extension);
     NotifyExtensionLoaded(extension);
-    DoPostLoadTasks(extension);
   }
   SetBeingUpgraded(extension, false);
 }
 
 void ExtensionService::AddComponentExtension(const Extension* extension) {
   const std::string old_version_string(
       extension_prefs_->GetVersionString(extension->id()));
   const Version old_version(old_version_string);
 
   if (!old_version.IsValid() || !old_version.Equals(*extension->version())) {
@@ skipping 142 matching lines @@
   for (ExtensionSet::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = *iter;
     if (!extension->is_theme() && extension->location() != Manifest::COMPONENT)
       extension_ids.insert(extension->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
-void ExtensionService::ScheduleLaunchOnLoad(const std::string& extension_id) {
-  on_load_events_[extension_id] = EVENT_LAUNCHED;
-}
-
 void ExtensionService::OnExtensionInstalled(
     const Extension* extension,
     const syncer::StringOrdinal& page_ordinal,
     bool has_requirement_errors,
     bool wait_for_idle) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const std::string& id = extension->id();
   bool initial_enable = ShouldEnableOnInstall(extension);
   const extensions::PendingExtensionInfo* pending_extension_info = NULL;
@@ skipping 591 matching lines @@
 ExtensionService::NaClModuleInfoList::iterator
     ExtensionService::FindNaClModule(const GURL& url) {
   for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }
 
-void ExtensionService::DoPostLoadTasks(const Extension* extension) {
-  std::map<std::string, int>::iterator it =
-      on_load_events_.find(extension->id());
-  if (it == on_load_events_.end())
-    return;
-
-  int events_to_fire = it->second;
-  extensions::LazyBackgroundTaskQueue* queue =
-      system_->lazy_background_task_queue();
-  if (queue->ShouldEnqueueTask(profile(), extension)) {
-    if (events_to_fire & EVENT_LAUNCHED)
-      queue->AddPendingTask(profile(), extension->id(),
-                            base::Bind(&ExtensionService::LaunchApplication));
-    if (events_to_fire & EVENT_RESTARTED) {
-      queue->AddPendingTask(profile(), extension->id(),
-                            base::Bind(&ExtensionService::RestartApplication));
-    }
-  }
-
-  on_load_events_.erase(it);
-}
-
-// static
-void ExtensionService::LaunchApplication(
-    extensions::ExtensionHost* extension_host) {
-  if (!extension_host)
-    return;
-
-#if !defined(OS_ANDROID)
-  extensions::LaunchPlatformApp(extension_host->profile(),
-                                extension_host->extension(),
-                                NULL, base::FilePath());
-#endif
-}
-
-// static
-void ExtensionService::RestartApplication(
-    extensions::ExtensionHost* extension_host) {
-  if (!extension_host)
-    return;
-
-#if !defined(OS_ANDROID)
-  extensions::RestartPlatformApp(
-      extension_host->profile(), extension_host->extension());
-#endif
-}
-
-bool ExtensionService::HasShellWindows(const std::string& extension_id) {
-  const Extension* current_extension = GetExtensionById(extension_id, false);
-  return current_extension && current_extension->is_platform_app() &&
-      !extensions::ShellWindowRegistry::Get(profile_)->
-          GetShellWindowsForApp(extension_id).empty();
-}
-
 void ExtensionService::InspectExtensionHost(
     extensions::ExtensionHost* host) {
   if (host)
     DevToolsWindow::OpenDevToolsWindow(host->render_view_host());
 }
 
 bool ExtensionService::ShouldEnableOnInstall(const Extension* extension) {
   // Extensions installed by policy can't be disabled. So even if a previous
   // installation disabled the extension, make sure it is now enabled.
   if (system_->management_policy()->MustRemainEnabled(extension, NULL))
@@ skipping 145 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }