Garbage Collect the Storage directory on next profile start after an extension uninstall.

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 309 matching lines @@
   };
 
   // Look up an extension by ID, selecting which sets to look in:
   //  * extensions()             --> INCLUDE_ENABLED
   //  * disabled_extensions()    --> INCLUDE_DISABLED
   //  * terminated_extensions()  --> INCLUDE_TERMINATED
   //  * blacklisted_extensions() --> INCLUDE_BLACKLISTED
   const extensions::Extension* GetExtensionById(const std::string& id,
                                                 int include_mask) const;
 
+  // Returns the site of the given |extension_id|. Suitable for use with
+  // BrowserContext::GetStoragePartitionForSite()
+  GURL GetSiteForExtensionId(const std::string& extension_id);
+
   // Looks up a terminated (crashed) extension by ID.
   const extensions::Extension*
       GetTerminatedExtension(const std::string& id) const;
 
   // Looks up an extension by ID, regardless of whether it's enabled,
   // disabled, blacklisted, or terminated.
   virtual const extensions::Extension* GetInstalledExtension(
       const std::string& id) const OVERRIDE;
 
   // Updates a currently-installed extension with the contents from
@@ skipping 431 matching lines @@
   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,
-      const syncer::StringOrdinal& page_ordinal,
-      extensions::Extension::State initial_state);
+  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);
@@ skipping 43 matching lines @@
 
   // 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;
 
   // Helper to determine if updating an extensions should proceed immediately,
   // or if we should delay the update until further notice.
   bool ShouldDelayExtensionUpdate(const std::string& extension_id,
                                   bool wait_for_idle) const;
 
+  // Helper to search storage directories for extensions with isolated storage
+  // that have been orphaned by an uninstall.
+  void GarbageCollectIsolatedStorage();
+  void OnGarbageCollectIsolatedStorageFinished();
+  void OnNeedsToGarbageCollectedIsolatedStorage();
+
   // extensions::Blacklist::Observer implementation.
   virtual void OnBlacklistUpdated() OVERRIDE;
 
   // Manages the blacklisted extensions, intended as callback from
   // Blacklist::GetBlacklistedIDs.
   void ManageBlacklist(const std::set<std::string>& old_blacklisted_ids,
                        const std::set<std::string>& new_blacklisted_ids);
 
+  // Controls if installs are delayed. See comment for |installs_delayed_|.
+  void set_installs_delayed(bool value) { installs_delayed_ = value; }
+  bool installs_delayed() const { return installs_delayed_; }
+
   // The normal profile associated with this ExtensionService.
   Profile* profile_;
 
   // The ExtensionSystem for the profile above.
   extensions::ExtensionSystem* system_;
 
   // Preferences for the owning profile.
   extensions::ExtensionPrefs* extension_prefs_;
 
   // Blacklist for the owning profile.
@@ skipping 10 matching lines @@
 
   // The list of installed extensions that have been terminated.
   ExtensionSet terminated_extensions_;
 
   // The list of installed extensions that have been blacklisted. Generally
   // these shouldn't be considered as installed by the extension platform: we
   // only keep them around so that if extensions are blacklisted by mistake
   // they can easily be un-blacklisted.
   ExtensionSet blacklisted_extensions_;
 
-  // The list of extension updates that are waiting to be installed.
-  ExtensionSet pending_extension_updates_;
+  // The list of extension updates that have had their installs delayed because
+  // they are waiting for idle.
+  ExtensionSet delayed_for_idle_updates_;

[Matt Perry, 2012/12/08 01:55:33]

nit: delayed_updates_for_idle_
(otherwise it sounds like you're referring to "idle updates")

[awong, 2012/12/08 02:11:09]

Done.

+
+  // The list of extension installs delayed by |installs_delayed_|.
+  // This is a disjoint set from |delayed_for_idle_updates_|. Extensions in
+  // the |delayed_installs_| do not need to wait for idle.
+  ExtensionSet delayed_installs_;
 
   // Hold the set of pending extensions.
   extensions::PendingExtensionManager pending_extension_manager_;
 
   // The map of extension IDs to their runtime data.
   ExtensionRuntimeDataMap extension_runtime_data_;
 
   // The full path to the directory where extensions are installed.
   FilePath install_directory_;
 
@@ skipping 97 matching lines @@
   // has to wait for the external providers.  Used in
   // OnAllExternalProvidersReady() to determine if an update check is needed to
   // install pending extensions.
   bool update_once_all_providers_are_ready_;
 
   // Set when the browser is terminating. Prevents us from installing or
   // updating additional extensions and allows in-progress installations to
   // decide to abort.
   bool browser_terminating_;
 
+  // Set to true to delay all new extension installations. Acts as a lock
+  // to allow background processing of tasks such as garbage collection of
+  // on-disk state without needing to worry about race conditions caused
+  // by extension installation and reinstallation.
+  bool installs_delayed_;
+
   NaClModuleInfoList nacl_module_list_;
 
   extensions::AppSyncBundle app_sync_bundle_;
   extensions::ExtensionSyncBundle extension_sync_bundle_;
 
   extensions::ProcessMap process_map_;
 
   extensions::AppShortcutManager app_shortcut_manager_;
 
   scoped_ptr<ExtensionErrorUI> extension_error_ui_;
   // Sequenced task runner for extension related file operations.
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 
 #if defined(ENABLE_EXTENSIONS)
   scoped_ptr<extensions::ExtensionActionStorageManager>
       extension_action_storage_manager_;
 #endif
 
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_