Refactor loading out of ExtensionService.

chrome/browser/extensions/extension_service.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 35 matching lines @@
 
 class AppNotificationManager;
 class BookmarkExtensionEventRouter;
 class CrxInstaller;
 class ExtensionBrowserEventRouter;
 class ExtensionContentSettingsStore;
 class ExtensionCookiesEventRouter;
 class ExtensionDownloadsEventRouter;
 class ExtensionFileBrowserEventRouter;
 class ExtensionGlobalError;
-class HistoryExtensionEventRouter;
 class ExtensionInstallUI;
 class ExtensionManagementEventRouter;
 class ExtensionPreferenceEventRouter;
-class ExtensionServiceBackend;
 class ExtensionSyncData;
 class ExtensionToolbarModel;
 class ExtensionUpdater;
 class ExtensionWebNavigationEventRouter;
+class HistoryExtensionEventRouter;
 class GURL;
 class PendingExtensionManager;
 class Profile;
 class SyncData;
 class Version;
 
 namespace chromeos {
 class ExtensionInputMethodEventRouter;
-}  // namespace chromeos
+}
+
+namespace extensions {
+class ComponentLoader;
+class UnpackedInstaller;
+}
 
 // This is an interface class to encapsulate the dependencies that
 // various classes have on ExtensionService. This allows easy mocking.
 class ExtensionServiceInterface : public SyncableService {
  public:
   // A function that returns true if the given extension should be
   // included and false if it should be filtered out.  Identical to
   // PendingExtensionInfo::ShouldAllowInstallPredicate.
   typedef bool (*ExtensionFilter)(const Extension&);
 
@@ skipping 25 matching lines @@
   //
   // TODO(akalin): Remove this method (and others) once we refactor
   // themes sync to not use it directly.
   virtual void CheckForUpdatesSoon() = 0;
 };
 
 // Manages installed and running Chromium extensions.
 class ExtensionService
     : public ExtensionServiceInterface,
       public ExternalExtensionProviderInterface::VisitorInterface,
+      public base::SupportsWeakPtr<ExtensionService>,
       public content::NotificationObserver {
  public:
-  // Information about a registered component extension.
-  struct ComponentExtensionInfo {
-    ComponentExtensionInfo(const std::string& manifest,
-                           const FilePath& root_directory)
-        : manifest(manifest),
-          root_directory(root_directory) {
-    }
-
-    bool Equals(const ComponentExtensionInfo& other) const;
-
-    // The extension's manifest. This is required for component extensions so
-    // that ExtensionService doesn't need to go to disk to load them.
-    std::string manifest;
-
-    // Directory where the extension is stored.
-    FilePath root_directory;
-  };
+  using base::SupportsWeakPtr<ExtensionService>::AsWeakPtr;
 
   // The name of the directory inside the profile where extensions are
   // installed to.
   static const char* kInstallDirectoryName;
 
   // If auto-updates are turned on, default to running every 5 hours.
   static const int kDefaultUpdateFrequencySeconds = 60 * 60 * 5;
 
   // The name of the directory inside the profile where per-extension settings
   // are stored.
@@ skipping 35 matching lines @@
   virtual ~ExtensionService();
 
   // Gets the list of currently installed extensions.
   virtual const ExtensionList* extensions() const OVERRIDE;
   const ExtensionList* disabled_extensions() const;
   const ExtensionList* terminated_extensions() const;
 
   // Gets the object managing the set of pending extensions.
   virtual PendingExtensionManager* pending_extension_manager() OVERRIDE;
 
-  // Registers an extension to be loaded as a component extension.
-  void register_component_extension(const ComponentExtensionInfo& info) {
-    component_extension_manifests_.push_back(info);
-  }
-
-  // Unregisters a component extension from the list of extensions to be loaded
-  void UnregisterComponentExtension(const ComponentExtensionInfo& info);
-
   const FilePath& install_directory() const { return install_directory_; }
 
   AppsPromo* apps_promo() { return &apps_promo_; }
 
   // Whether this extension can run in an incognito window.
   virtual bool IsIncognitoEnabled(const std::string& extension_id) const;
   virtual void SetIsIncognitoEnabled(const std::string& extension_id,
                                      bool enabled);
 
   // Returns true if the given extension can see events and data from another
@@ skipping 97 matching lines @@
 
   // Updates the |extension|'s granted permissions lists to include all
   // permissions in the |extension|'s manifest and re-enables the
   // extension.
   void GrantPermissionsAndEnableExtension(const Extension* extension);
 
   // Sets the |extension|'s active permissions to |permissions|.
   void UpdateActivePermissions(const Extension* extension,
                                const ExtensionPermissionSet* permissions);
 
-  // Loads the extension from the directory |extension_path|.
-  void LoadExtension(const FilePath& extension_path);
-
-  // Loads the extension from the directory |extension_path|.
-  // This version of this method is intended for testing only.
-  void LoadExtension(const FilePath& extension_path, bool prompt_for_plugins);
-
-  // Same as above, but for use with command line switch --load-extension=path.
-  void LoadExtensionFromCommandLine(const FilePath& extension_path);
-
-  // Loads any component extensions.
-  void LoadComponentExtensions();
-
-  // Loads particular component extension.
-  const Extension* LoadComponentExtension(const ComponentExtensionInfo& info);
-
-  // Unloads particular component extension.
-  void UnloadComponentExtension(const ComponentExtensionInfo& info);
-
-  // Loads all known extensions (used by startup and testing code).
-  void LoadAllExtensions();
-
   // Check for updates (or potentially new extensions from external providers)
   void CheckForExternalUpdates();
 
   // Unload the specified extension.
   void UnloadExtension(const std::string& extension_id,
                        extension_misc::UnloadedExtensionReason reason);
 
   // Unload all extensions. This is currently only called on shutdown, and
   // does not send notifications.
   void UnloadAllExtensions();
@@ skipping 34 matching lines @@
   const SkBitmap& GetOmniboxPopupIcon(const std::string& extension_id);
 
   // Called when the initial extensions load has completed.
   virtual void OnLoadedInstalledExtensions();
 
   // Adds |extension| to this ExtensionService and notifies observers than an
   // extension has been loaded.  Called by the backend after an extension has
   // been loaded from a file and installed.
   void AddExtension(const Extension* extension);
 
-  // Called by the backend when an unpacked extension has been loaded.
-  void OnLoadSingleExtension(const Extension* extension,
-                             bool prompt_for_plugins);
-
   // Called by the backend when an extension has been installed.
   void OnExtensionInstalled(
       const Extension* extension, bool from_webstore, int page_index);
 
   // Initializes the |extension|'s active permission set and disables the
   // extension if the privilege level has increased (e.g., due to an upgrade).
   void InitializePermissions(const Extension* extension);
 
   // Go through each extensions in pref, unload blacklisted extensions
   // and update the blacklist state in pref.
@@ skipping 33 matching lines @@
 
   // TODO(skerner): Change to const ExtensionPrefs& extension_prefs() const,
   // ExtensionPrefs* mutable_extension_prefs().
   ExtensionPrefs* extension_prefs();
 
   ExtensionSettingsFrontend* extension_settings_frontend();
 
   ExtensionContentSettingsStore* GetExtensionContentSettingsStore();
 
   // Whether the extension service is ready.
-  // TODO(skerner): Get rid of this method.  crbug.com/63756
   bool is_ready() { return ready_; }
 
+  extensions::ComponentLoader* component_loader() {
+    return component_loader_.get();
+  }
+
   // Note that this may return NULL if autoupdate is not turned on.
   ExtensionUpdater* updater();
 
   ExtensionToolbarModel* toolbar_model() { return &toolbar_model_; }
 
   ExtensionsQuotaService* quota_service() { return &quota_service_; }
 
   ExtensionMenuManager* menu_manager() { return &menu_manager_; }
 
   AppNotificationManager* app_notification_manager() {
@@ skipping 11 matching lines @@
 #if defined(OS_CHROMEOS)
   ExtensionFileBrowserEventRouter* file_browser_event_router() {
     return file_browser_event_router_.get();
   }
   chromeos::ExtensionInputMethodEventRouter* input_method_event_router() {
     return input_method_event_router_.get();
   }
 #endif
 
   // Notify the frontend that there was an error loading an extension.
-  // This method is public because ExtensionServiceBackend can post to here.
+  // This method is public because UnpackedInstaller and InstalledLoader
+  // can post to here.
+  // TODO(aa): Remove this. It doesn't do enough to be worth the dependency
+  // of these classes on ExtensionService.
   void ReportExtensionLoadError(const FilePath& extension_path,
                                 const std::string& error,
                                 bool be_noisy);
 
   // ExtensionHost of background page calls this method right after its render
   // view has been created.
   void DidCreateRenderViewForBackgroundPage(ExtensionHost* host);
 
   // For the extension in |version_path| with |id|, check to see if it's an
   // externally managed extension.  If so, uninstall it.
@@ skipping 166 matching lines @@
   // Handles sending notification that |extension| was loaded.
   void NotifyExtensionLoaded(const Extension* extension);
 
   // Handles sending notification that |extension| was unloaded.
   void NotifyExtensionUnloaded(const Extension* extension,
                                extension_misc::UnloadedExtensionReason reason);
 
   // Helper that updates the active extension list used for crash reporting.
   void UpdateActiveExtensionsInCrashReporter();
 
-  // Helper method. Loads extension from prefs.
-  void LoadInstalledExtension(const ExtensionInfo& info, bool write_to_prefs);
-
   // 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);
 
-  // Returns the flags that should be used with Extension::Create() for an
-  // extension that is already installed.
-  int GetExtensionCreateFlagsForInstalledExtension(
-      const ExtensionInfo* info);
-
-  base::WeakPtrFactory<ExtensionService> weak_ptr_factory_;
-
   // The profile this ExtensionService is part of.
   Profile* profile_;
 
   // Preferences for the owning profile (weak reference).
   ExtensionPrefs* extension_prefs_;
 
   // Settings for the owning profile.
   ExtensionSettingsFrontend extension_settings_frontend_;
 
   // The current list of installed extensions.
@@ skipping 22 matching lines @@
 
   // The full path to the directory where extensions are installed.
   FilePath install_directory_;
 
   // Whether or not extensions are enabled.
   bool extensions_enabled_;
 
   // Whether to notify users when they attempt to install an extension.
   bool show_extensions_prompts_;
 
-  // The backend that will do IO on behalf of this instance.
-  scoped_refptr<ExtensionServiceBackend> backend_;
+  // For loading and unloading component extensions.
+  scoped_ptr<extensions::ComponentLoader> component_loader_;
 
   // Used by dispatchers to limit API quota for individual extensions.
   ExtensionsQuotaService quota_service_;
 
   // Record that Init() has been called, and chrome::EXTENSIONS_READY
   // has fired.
   bool ready_;
 
   // Our extension updater, if updates are turned on.
   scoped_ptr<ExtensionUpdater> updater_;
@@ skipping 27 matching lines @@
   // Keeps track of app notifications.
   scoped_refptr<AppNotificationManager> app_notification_manager_;
 
   // Keeps track of extension permissions.
   ExtensionPermissionsManager permissions_manager_;
 
   // Keeps track of favicon-sized omnibox icons for extensions.
   ExtensionIconManager omnibox_icon_manager_;
   ExtensionIconManager omnibox_popup_icon_manager_;
 
-  // List of registered component extensions (see Extension::Location).
-  typedef std::vector<ComponentExtensionInfo> RegisteredComponentExtensions;
-  RegisteredComponentExtensions component_extension_manifests_;
-
   // Manages the promotion of the web store.
   AppsPromo apps_promo_;
 
   // Flag to make sure event routers are only initialized once.
   bool event_routers_initialized_;
 
   scoped_ptr<ExtensionDownloadsEventRouter> downloads_event_router_;
 
   scoped_ptr<HistoryExtensionEventRouter> history_event_router_;
 
@@ skipping 34 matching lines @@
   ExtensionWarningSet extension_warnings_;
 
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_