Remove ExtensionService Garbage-Collecting methods.

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 34 matching lines @@
 class CommandLine;
 class SequencedTaskRunner;
 class Version;
 }
 
 namespace extensions {
 class BrowserEventRouter;
 class ComponentLoader;
 class CrxInstaller;
 class ExtensionActionStorageManager;
+class ExtensionGarbageCollector;
 class ExtensionRegistry;
 class ExtensionSystem;
 class ExtensionUpdater;
 class PendingExtensionManager;
 class RendererStartupHelper;
 class UpdateObserver;
 }  // namespace extensions
 
 using extensions::ExtensionIdSet;
 
@@ skipping 222 matching lines @@
   // Remove the specified component extension.
   virtual void RemoveComponentExtension(const std::string& extension_id)
       OVERRIDE;
 
   // Unload all extensions. Does not send notifications.
   void UnloadAllExtensionsForTest();
 
   // Reloads all extensions. Does not notify that extensions are ready.
   void ReloadExtensionsForTest();
 
-  // Scan the extension directory and clean up the cruft.
-  void GarbageCollectExtensions();
-
   // Returns true if |url| should get extension api bindings and be permitted
   // to make api calls. Note that this is independent of what extension
   // permissions the given extension has been granted.
   bool ExtensionBindingsAllowed(const GURL& url);
 
   // Called when the initial extensions load has completed.
   virtual void OnLoadedInstalledExtensions();
 
   // Adds |extension| to this ExtensionService and notifies observers that the
   // extensions have been loaded.
@@ skipping 192 matching lines @@
 
   // Marks alertable extensions as acknowledged, after the user presses the
   // accept button.
   void HandleExtensionAlertAccept();
 
   // content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // Postpone installations so that we don't have to worry about race
+  // conditions.
+  void OnGarbageCollectIsolatedStorageStart();
+
+  // Restart any extension installs which were delayed for isolated storage
+  // garbage collection.
+  void OnGarbageCollectIsolatedStorageFinished();
+
   // 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 extensions::Extension* e, const char* histogram);
 
 #if defined(UNIT_TEST)
   void TrackTerminatedExtensionForTest(const extensions::Extension* extension) {
     TrackTerminatedExtension(extension);
   }
 
   void FinishInstallationForTest(const extensions::Extension* extension) {
     FinishInstallation(extension);
   }
 #endif
 
   base::WeakPtr<ExtensionService> AsWeakPtr() { return base::AsWeakPtr(this); }
 
+  extensions::ExtensionGarbageCollector* garbage_collector() {
+    return garbage_collector_.get();
+  }
+
   bool browser_terminating() const { return browser_terminating_; }
 
   // For testing.
   void set_browser_terminating_for_test(bool value) {
     browser_terminating_ = value;
   }
 
   // By default ExtensionService will wait with installing an updated extension
   // until the extension is idle. Tests might not like this behavior, so you can
   // disable it with this method.
   void set_install_updates_when_idle_for_test(bool value) {
     install_updates_when_idle_ = value;
   }
 
   // Set a callback to be called when all external providers are ready and their
   // extensions have been installed.
   void set_external_updates_finished_callback_for_test(
       const base::Closure& callback) {
     external_updates_finished_callback_ = callback;
   }
 
   // Adds/Removes update observers.
   void AddUpdateObserver(extensions::UpdateObserver* observer);
   void RemoveUpdateObserver(extensions::UpdateObserver* observer);
 
-#if defined(OS_CHROMEOS)
-  void disable_garbage_collection() {
-    disable_garbage_collection_ = true;
-  }
-  void enable_garbage_collection() {
-    disable_garbage_collection_ = false;
-  }
-#endif
-
  private:
   // Populates greylist_.
   void LoadGreylistFromPrefs();
 
   // Signals *ready_ and sends a notification to the listeners.
   void SetReadyAndNotifyListeners();
 
   // Return true if the sync type of |extension| matches |type|.
   void OnExtensionInstallPrefChanged();
 
@@ skipping 41 matching lines @@
 
   // Helper to determine whether we should initially enable an installed
   // (or upgraded) extension.
   bool ShouldEnableOnInstall(const extensions::Extension* extension);
 
   // 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();
-
   // extensions::Blacklist::Observer implementation.
   virtual void OnBlacklistUpdated() OVERRIDE;
 
   // Manages the blacklisted extensions, intended as callback from
   // Blacklist::GetBlacklistedIDs.
   void ManageBlacklist(
       const extensions::Blacklist::BlacklistStateMap& blacklisted_ids);
 
   // Add extensions in |blocked| to blacklisted_extensions, remove extensions
   // that are neither in |blocked|, nor in |unchanged|.
   void UpdateBlockedExtensions(const ExtensionIdSet& blocked,
                                const ExtensionIdSet& unchanged);
 
   void UpdateGreylistedExtensions(
       const ExtensionIdSet& greylist,
       const ExtensionIdSet& unchanged,
       const extensions::Blacklist::BlacklistStateMap& state_map);
 
-  // Controls if installs are delayed. See comment for
-  // |installs_delayed_for_gc_|.
-  void set_installs_delayed_for_gc(bool value) {
-    installs_delayed_for_gc_ = value;
-  }
-  bool installs_delayed_for_gc() const { return installs_delayed_for_gc_; }
-
   // Used only by test code.
   void UnloadAllExtensionsInternal();
 
   // The normal profile associated with this ExtensionService.
   Profile* profile_;
 
   // The ExtensionSystem for the profile above.
   extensions::ExtensionSystem* system_;
 
   // Preferences for the owning profile.
@@ skipping 109 matching lines @@
   // 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
   scoped_ptr<extensions::ManagementPolicy::Provider>
       shared_module_policy_provider_;
 
+  // The ExtensionGarbageCollector to clean up all the garbage that leaks into
+  // the extensions directory.
+  scoped_ptr<extensions::ExtensionGarbageCollector> garbage_collector_;
+
   ObserverList<extensions::UpdateObserver, true> update_observers_;
 
-#if defined(OS_CHROMEOS)
-  // TODO(rkc): HACK alert - this is only in place to allow the
-  // kiosk_mode_screensaver to prevent its extension from getting garbage
-  // collected. Remove this once KioskModeScreensaver is removed.
-  // See crbug.com/280363
-  bool disable_garbage_collection_;
-#endif
-
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest, SetUnsetBlacklistInPrefs);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            BlacklistedExtensionWillNotInstall);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            UnloadBlacklistedExtensionPolicy);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            WillNotLoadBlacklistedExtensionsFromDirectory);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            BlacklistedInPrefsFromStartup);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            GreylistedExtensionDisabled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            GreylistDontEnableManuallyDisabled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            GreylistUnknownDontChange);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_