extensions: Abstract out install delay strategy

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 <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/extension_management.h"
+#include "chrome/browser/extensions/install_gate.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/crx_file_info.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/external_provider_interface.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest.h"
 #include "sync/api/string_ordinal.h"
 
 #if !defined(ENABLE_EXTENSIONS)
@@ skipping 303 matching lines @@
   void MaybeFinishDelayedInstallations();
 
   // ExtensionHost of background page calls this method right after its render
   // view has been created.
   void DidCreateRenderViewForBackgroundPage(extensions::ExtensionHost* host);
 
   // Changes sequenced task runner for crx installation tasks to |task_runner|.
   void SetFileTaskRunnerForTesting(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner);
 
-  // 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* extension, const char* histogram);
 
   // Unloads the given extension and mark the extension as terminated. This
   // doesn't notify the user that the extension was terminated, if such a
   // notification is desired the calling code is responsible for doing that.
   void TerminateExtension(const std::string& extension_id);
 
   // Register self and content settings API with the specified map.
   void RegisterContentSettings(
       HostContentSettingsMap* host_content_settings_map);
 
   // Adds/Removes update observers.
   void AddUpdateObserver(extensions::UpdateObserver* observer);
   void RemoveUpdateObserver(extensions::UpdateObserver* observer);
 
+  // Register/unregister an InstallGate with the service.
+  void RegisterInstallGate(extensions::ExtensionPrefs::DelayReason reason,
+                           extensions::InstallGate* install_delayer);
+  void UnregisterInstallGate(extensions::InstallGate* install_delayer);
+
   //////////////////////////////////////////////////////////////////////////////
   // Simple Accessors
 
   // Returns a WeakPtr to the ExtensionService.
   base::WeakPtr<ExtensionService> AsWeakPtr() { return base::AsWeakPtr(this); }
 
   // Returns profile_ as a BrowserContext.
   content::BrowserContext* GetBrowserContext() const;
 
   bool extensions_enabled() const { return extensions_enabled_; }
@@ skipping 56 matching lines @@
 
   void FinishInstallationForTest(const extensions::Extension* extension) {
     FinishInstallation(extension);
   }
 #endif
 
   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;
   }
 
  private:
   // Reloads the specified extension, sending the onLaunched() event to it if it
   // currently has any window showing. |be_noisy| determines whether noisy
@@ skipping 81 matching lines @@
   void UpdateActiveExtensionsInCrashReporter();
 
   // Helper to get the disable reasons for an installed (or upgraded) extension.
   // A return value of Extension::DISABLE_NONE indicates that we should enable
   // this extension initially.
   int GetDisableReasonsOnInstalled(const extensions::Extension* extension);
 
   // Helper method to determine if an extension can be blocked.
   bool CanBlockExtension(const extensions::Extension* extension) 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 install_immediately) const;
+  // Helper to determine if installing an extensions should proceed immediately,
+  // or if we should delay the install until further notice, or if the install
+  // should be aborted. A pending install is delayed or aborted when any of the
+  // delayers say so and only proceeds when all delayers return INSTALL.
+  // |extension| is the extension to be installed. |install_immediately| is the
+  // install flag set with the install. |reason| is the reason associated with
+  // the install delayer that wants to defer or abort the install.
+  extensions::InstallGate::Action ShouldDelayExtensionInstall(
+      const extensions::Extension* extension,
+      bool install_immediately,
+      extensions::ExtensionPrefs::DelayReason* reason) const;
 
   // Manages the blacklisted extensions, intended as callback from
   // Blacklist::GetBlacklistedIDs.
   void ManageBlacklist(
       const extensions::Blacklist::BlacklistStateMap& blacklisted_ids);
 
   // Add extensions in |blacklisted| to blacklisted_extensions, remove
   // extensions that are neither in |blacklisted|, nor in |unchanged|.
   void UpdateBlacklistedExtensions(
       const extensions::ExtensionIdSet& to_blacklist,
@@ skipping 52 matching lines @@
 
   // The full path to the directory where extensions are installed.
   base::FilePath install_directory_;
 
   // Whether or not extensions are enabled.
   bool extensions_enabled_ = true;
 
   // Whether to notify users when they attempt to install an extension.
   bool show_extensions_prompts_ = true;
 
-  // Whether to delay installing of extension updates until the extension is
-  // idle.
-  bool install_updates_when_idle_ = true;
-
   // Signaled when all extensions are loaded.
   extensions::OneShotEvent* const ready_;
 
   // Our extension updater, if updates are turned on.
   std::unique_ptr<extensions::ExtensionUpdater> updater_;
 
   // Map unloaded extensions' ids to their paths. When a temporarily loaded
   // extension is unloaded, we lose the information about it and don't have
   // any in the extension preferences file.
   using UnloadedExtensionPathMap = std::map<std::string, base::FilePath>;
@@ skipping 25 matching lines @@
   // A callback to be called when all external providers are ready and their
   // extensions have been installed. Normally this is a null callback, but
   // is used in external provider related tests.
   base::Closure external_updates_finished_callback_;
 
   // 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_ = false;
 
-  // Set to true to delay all new extension installations. Acts as a lock to
-  // allow background processing of garbage collection of on-disk state without
-  // needing to worry about race conditions caused by extension installation and
-  // reinstallation.
-  bool installs_delayed_for_gc_ = false;
-
   // Set to true if this is the first time this ExtensionService has run.
   // Used for specially handling external extensions that are installed the
   // first time.
   bool is_first_run_ = false;
 
   // Set to true if extensions are all to be blocked.
   bool block_extensions_ = false;
 
   // Store the ids of reloading extensions. We use this to re-enable extensions
   // which were disabled for a reload.
@@ skipping 18 matching lines @@
       extension_action_storage_manager_;
 
   // The SharedModuleService used to check for import dependencies.
   std::unique_ptr<extensions::SharedModuleService> shared_module_service_;
 
   base::ObserverList<extensions::UpdateObserver, true> update_observers_;
 
   // Migrates app data when upgrading a legacy packaged app to a platform app
   std::unique_ptr<extensions::AppDataMigrator> app_data_migrator_;
 
+  using InstallGateRegistry = std::map<extensions::ExtensionPrefs::DelayReason,
+                                       extensions::InstallGate*>;
+  InstallGateRegistry install_delayer_registry_;
+
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            DestroyingProfileClearsExtensions);
   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, ReloadBlacklistedExtension);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest, BlacklistedInPrefsFromStartup);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            GreylistedExtensionDisabled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            GreylistDontEnableManuallyDisabled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            GreylistUnknownDontChange);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            ManagementPolicyProhibitsEnableOnInstalled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            BlockAndUnblockBlacklistedExtension);
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_