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 27 matching lines @@
 #include "chrome/browser/sync/api/sync_change.h"
 #include "chrome/browser/sync/api/syncable_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/property_bag.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class AppNotificationManager;
+class ComponentLoader;
 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 InstalledExtensionLoader;
 class GURL;
 class PendingExtensionManager;
 class Profile;
 class SyncData;
+class UnpackedInstaller;
 class Version;
 
 namespace chromeos {
 class ExtensionInputMethodEventRouter;
 }  // namespace chromeos
 
 // This is an interface class to encapsulate the dependencies that
 // various classes have on ExtensionService. This allows easy mocking.
 class ExtensionServiceInterface : public SyncableService {
  public:
@@ skipping 32 matching lines @@
   // 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 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;
-  };
-
   // 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.
   static const char* kSettingsDirectoryName;
@@ skipping 34 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 36 matching lines @@
   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_; }
 
+  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 ExtensionLoadTask can post to here.

[Aaron Boodman, 2011/10/28 22:21:58]

TODO(aa): DIEDIEDIE

   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 55 matching lines @@
   // Record a histogram using the PermissionMessage enum values for each
   // permission in |e|.
   // NOTE: If this is ever called with high frequency, the implementation may
   // need to be made more efficient.
   static void RecordPermissionMessagesHistogram(
       const Extension* e, const char* histogram);
 
   // |client| can be NULL for a silent install.
   scoped_refptr<CrxInstaller> MakeCrxInstaller(ExtensionInstallUI* client);
 
+  scoped_refptr<UnpackedInstaller> MakeUnpackedInstaller();

[Aaron Boodman, 2011/10/28 22:21:58]

It seems a little unfortunate to me to have to have these methods in here.

I'm not super familiar with WeakPtr yet, but I think that if you have ES inherit
SupportsWeakPtr, you can just do:

new InstalledExtensionLoader(extension_service_->AsWeakPtr())

at the callsite. This would be a little more nicely decoupled IMO.

[Yoyo Zhou, 2011/10/31 21:58:15]

Heh, I went back and forth on this myself. I did look into weak_ptr.h and it
works as you suggest. Originally I thought I'd have to create an object outside
the ES, and I'd have no choice but to use SupportsWeakPtr. But then I didn't.

I then found akalin's change where he added WeakPtrFactory to ES, and he wrote
this:

"Yeah, I thought of making ExtensionService inherit from base::SupportsWeakPtr
(which adds an AsWeakPtr() method) but ultimately decided against it.  The only
things that really need the weakptr are ExtensionBackend and CrxInstaller;
everything else is tied to the profile's lifetime.  It seems like an
implementation detail that the service passes itself as a weak ptr to
CrxInstaller so I thought it better to hide it behind a function."

Of course, now that we have 3, we should perhaps reassess.

[Aaron Boodman, 2011/10/31 22:33:25]

Can you try it? I'm really fired up about the idea of not having these depend on
ExtensionService long-term.

[Yoyo Zhou, 2011/11/01 21:50:57]

Got rid of these two:
1. changed ES::MakeUnpackedInstaller to UnpackedInstaller::Create
2. made InstalledLoader just a regular object (it lives only one one thread); it
looks a little odd though

If this looks ok (see ExtensionService::ReloadExtension for usage example), I'll
do the same for CrxInstaller.

+
+  scoped_refptr<InstalledExtensionLoader> MakeInstalledExtensionLoader();
+
 #if defined(UNIT_TEST)
   void TrackTerminatedExtensionForTest(const Extension* extension) {
     TrackTerminatedExtension(extension);
   }
 #endif
 
   ExtensionWarningSet* extension_warnings() {
     return &extension_warnings_;
   }
 
@@ skipping 91 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_;
@@ skipping 24 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<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_