Move application restart and relaunch code out of ExtensionService.

chrome/browser/extensions/extension_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 310 matching lines @@
   virtual bool UpdateExtension(
       const std::string& id,
       const base::FilePath& extension_path,
       const GURL& download_url,
       extensions::CrxInstaller** out_crx_installer) OVERRIDE;
 
   // Reloads the specified extension, sending the onLaunched() event to it if it
   // currently has any window showing.
   void ReloadExtension(const std::string& extension_id);
 
-  // Reloads an extension and sends it the onRestarted() event.
-  void RestartExtension(const std::string& extension_id);
-
   // Uninstalls the specified extension. Callers should only call this method
   // with extensions that exist. |external_uninstall| is a magical parameter
   // that is only used to send information to ExtensionPrefs, which external
   // callers should never set to true.
   //
   // We pass the |extension_id| by value to avoid having it deleted from under
   // us incase someone calls it with Extension::id() or another string that we
   // are going to delete in this function.
   //
   // TODO(aa): Remove |external_uninstall| -- this information should be passed
@@ skipping 68 matching lines @@
   // Adds |extension| to this ExtensionService and notifies observers that the
   // extensions have been loaded.
   virtual void AddExtension(const extensions::Extension* extension) OVERRIDE;
 
   // Check if we have preferences for the component extension and, if not or if
   // the stored version differs, install the extension (without requirements
   // checking) before calling AddExtension.
   virtual void AddComponentExtension(const extensions::Extension* extension)
       OVERRIDE;
 
-  // Launch an extension the next time it is loaded.
-  void ScheduleLaunchOnLoad(const std::string& extension_id);
-
   // Informs the service that an extension's files are in place for loading.
   //
   // Please make sure the Blacklist is checked some time before calling this
   // method.
   void OnExtensionInstalled(
       const extensions::Extension* extension,
       const syncer::StringOrdinal& page_ordinal,
       bool has_requirement_errors,
       bool wait_for_idle);
 
@@ skipping 277 matching lines @@
   void OnExtensionInstallPrefChanged();
 
   // Handles setting the extension specific values in |extension_sync_data| to
   // the current system.
   // Returns false if the changes were not completely applied and need to be
   // tried again later.
   bool ProcessExtensionSyncDataHelper(
       const extensions::ExtensionSyncData& extension_sync_data,
       syncer::ModelType type);
 
-  // Events to be fired after an extension is reloaded.
-  enum PostReloadEvents {
-    EVENT_NONE = 0,
-    EVENT_LAUNCHED = 1 << 0,
-    EVENT_RESTARTED = 1 << 1,
-  };
-
   // Adds the given extension to the list of terminated extensions if
   // it is not already there and unloads it.
   void TrackTerminatedExtension(const extensions::Extension* extension);
 
   // Removes the extension with the given id from the list of
   // terminated extensions if it is there.
   void UntrackTerminatedExtension(const std::string& id);
 
   // Update preferences for a new or updated extension; notify observers that
   // the extension is installed, e.g., to update event handlers on background
   // pages; and perform other extension install tasks before calling
   // AddExtension.
   void AddNewOrUpdatedExtension(const extensions::Extension* extension,
                                 extensions::Extension::State initial_state,
                                 const syncer::StringOrdinal& page_ordinal);
 
   // Handles sending notification that |extension| was loaded.
   void NotifyExtensionLoaded(const extensions::Extension* extension);
 
   // Handles sending notification that |extension| was unloaded.
   void NotifyExtensionUnloaded(const extensions::Extension* extension,
                                extension_misc::UnloadedExtensionReason reason);
 
   // Common helper to finish installing the given extension.
   void FinishInstallation(const extensions::Extension* extension);
 
-  // Reloads |extension_id| and then dispatches to it the PostReloadEvents
-  // indicated by |events|.
-  void ReloadExtensionWithEvents(const std::string& extension_id,
-                                int events);
-
   // Updates the |extension|'s active permission set to include only permissions
   // currently requested by the extension and all the permissions required by
   // the extension.
   void UpdateActivePermissions(const extensions::Extension* extension);
 
   // Disables the extension if the privilege level has increased
   // (e.g., due to an upgrade).
   void CheckPermissionsIncrease(const extensions::Extension* extension,
                                 bool is_upgrade);
 
-  // Returns true if the app with id |extension_id| has any shell windows open.
-  bool HasShellWindows(const std::string& extension_id);
-
   // Helper that updates the active extension list used for crash reporting.
   void UpdateActiveExtensionsInCrashReporter();
 
   // We implement some Pepper plug-ins using NaCl to take advantage of NaCl's
   // strong sandbox. Typically, these NaCl modules are stored in extensions
   // and registered here. Not all NaCl modules need to register for a MIME
   // type, just the ones that are responsible for rendering a particular MIME
   // type, like application/pdf. Note: We only register NaCl modules in the
   // browser process.
   void RegisterNaClModule(const GURL& url, const std::string& mime_type);
   void UnregisterNaClModule(const GURL& url);
 
   // Call UpdatePluginListWithNaClModules() after registering or unregistering
   // a NaCl module to see those changes reflected in the PluginList.
   void UpdatePluginListWithNaClModules();
 
   NaClModuleInfoList::iterator FindNaClModule(const GURL& url);
 
-  // Performs tasks requested to occur after |extension| loads.
-  void DoPostLoadTasks(const extensions::Extension* extension);
-
-  // Launches the platform app associated with |extension_host|.
-  static void LaunchApplication(extensions::ExtensionHost* extension_host);
-
-  // Dispatches a restart event to the platform app associated with
-  // |extension_host|.
-  static void RestartApplication(extensions::ExtensionHost* extension_host);
-
   // Helper to inspect an ExtensionHost after it has been loaded.
   void InspectExtensionHost(extensions::ExtensionHost* host);
 
   // Helper to determine whether we should initially enable an installed
   // (or upgraded) extension.
   bool ShouldEnableOnInstall(const extensions::Extension* extension);
 
   // Helper to determine if an extension is idle, and it should be safe
   // to update the extension.
   bool IsExtensionIdle(const std::string& extension_id) const;
@@ skipping 98 matching lines @@
   UnloadedExtensionPathMap unloaded_extension_paths_;
 
   // Store the ids of reloading extensions.
   std::set<std::string> reloading_extensions_;
 
   // Map of inspector cookies that are detached, waiting for an extension to be
   // reloaded.
   typedef std::map<std::string, std::string> OrphanedDevTools;
   OrphanedDevTools orphaned_dev_tools_;
 
-  // Maps extension ids to a bitmask that indicates which events should be
-  // dispatched to the extension when it is loaded.
-  std::map<std::string, int> on_load_events_;
-
   content::NotificationRegistrar registrar_;
   PrefChangeRegistrar pref_change_registrar_;
 
   // Keeps track of loading and unloading component extensions.
   scoped_ptr<extensions::ComponentLoader> component_loader_;
 
   // Keeps track of menu items added by extensions.
   extensions::MenuManager menu_manager_;
 
   // Flag to make sure event routers are only initialized once.
@@ skipping 50 matching lines @@
   ObserverList<extensions::UpdateObserver, true> update_observers_;
 
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_