extensions: Abstract out install delay strategy

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2013 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.
 
 #include "chrome/browser/extensions/extension_service.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 52 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
-#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/external_install_info.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/browser/runtime_data.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/browser/update_observer.h"
 #include "extensions/browser/updater/extension_cache.h"
 #include "extensions/browser/updater/extension_downloader.h"
@@ skipping 1679 matching lines @@
   }
 
   const Extension::State initial_state =
       disable_reasons == Extension::DISABLE_NONE ? Extension::ENABLED
                                                  : Extension::DISABLED;
   if (initial_state == Extension::ENABLED)
     extension_prefs_->SetExtensionEnabled(id);
   else
     extension_prefs_->SetExtensionDisabled(id, disable_reasons);
 
-  if (ShouldDelayExtensionUpdate(
-          id,
-          !!(install_flags & extensions::kInstallFlagInstallImmediately))) {
-    extension_prefs_->SetDelayedInstallInfo(
-        extension,
-        initial_state,
-        install_flags,
-        extensions::ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
-        page_ordinal,
-        install_parameter);
+  extensions::ExtensionPrefs::DelayReason delay_reason;
+  extensions::InstallGate::Action action = ShouldDelayExtensionInstall(
+      extension, !!(install_flags & extensions::kInstallFlagInstallImmediately),
+      &delay_reason);
+  switch (action) {
+    case extensions::InstallGate::INSTALL:
+      AddNewOrUpdatedExtension(extension, initial_state, install_flags,
+                               page_ordinal, install_parameter);
+      return;
+    case extensions::InstallGate::DELAY:
+      extension_prefs_->SetDelayedInstallInfo(extension, initial_state,
+                                              install_flags, delay_reason,
+                                              page_ordinal, install_parameter);
 
-    // Transfer ownership of |extension|.
-    delayed_installs_.Insert(extension);
+      // Transfer ownership of |extension|.
+      delayed_installs_.Insert(extension);
 
-    // Notify observers that app update is available.
-    FOR_EACH_OBSERVER(extensions::UpdateObserver, update_observers_,
-                      OnAppUpdateAvailable(extension));
-    return;
+      if (delay_reason ==
+          extensions::ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE) {
+        // Notify observers that app update is available.
+        FOR_EACH_OBSERVER(extensions::UpdateObserver, update_observers_,
+                          OnAppUpdateAvailable(extension));
+      }
+      return;
+    case extensions::InstallGate::ABORT:
+      // Do nothing to abort the install. One such case is the shared module
+      // service gets IMPORT_STATUS_UNRECOVERABLE status for the pending
+      // install.
+      return;
   }
 
-  extensions::SharedModuleService::ImportStatus status =
-      shared_module_service_->SatisfyImports(extension);
-  if (installs_delayed_for_gc_) {
-    extension_prefs_->SetDelayedInstallInfo(
-        extension,
-        initial_state,
-        install_flags,
-        extensions::ExtensionPrefs::DELAY_REASON_GC,
-        page_ordinal,
-        install_parameter);
-    delayed_installs_.Insert(extension);
-  } else if (status != SharedModuleService::IMPORT_STATUS_OK) {
-    if (status == SharedModuleService::IMPORT_STATUS_UNSATISFIED) {
-      extension_prefs_->SetDelayedInstallInfo(
-          extension,
-          initial_state,
-          install_flags,
-          extensions::ExtensionPrefs::DELAY_REASON_WAIT_FOR_IMPORTS,
-          page_ordinal,
-          install_parameter);
-      delayed_installs_.Insert(extension);
-    }
-  } else {
-    AddNewOrUpdatedExtension(extension,
-                             initial_state,
-                             install_flags,
-                             page_ordinal,
-                             install_parameter);
-  }
+  NOTREACHED() << "Unknown action for delayed install: " << action;
 }
 
 void ExtensionService::OnExtensionManagementSettingsChanged() {
   error_controller_->ShowErrorIfNeeded();
 
   // Revokes blocked permissions from active_permissions for all extensions.
   extensions::ExtensionManagement* settings =
       extensions::ExtensionManagementFactory::GetForBrowserContext(profile());
   CHECK(settings);
   std::unique_ptr<ExtensionSet> all_extensions(
@@ skipping 30 matching lines @@
                                    AsWeakPtr(), base::RetainedRef(extension)));
     return;
   }
 
   FinishInstallation(extension);
 }
 
 void ExtensionService::MaybeFinishDelayedInstallation(
     const std::string& extension_id) {
   // Check if the extension already got installed.
-  if (!delayed_installs_.Contains(extension_id))
-    return;
-  extensions::ExtensionPrefs::DelayReason reason =
-      extension_prefs_->GetDelayedInstallReason(extension_id);
-
-  // Check if the extension is idle. DELAY_REASON_NONE is used for older
-  // preferences files that will not have set this field but it was previously
-  // only used for idle updates.
-  if ((reason == extensions::ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE ||
-       reason == extensions::ExtensionPrefs::DELAY_REASON_NONE) &&
-       is_ready() && !extensions::util::IsExtensionIdle(extension_id, profile_))
+  const Extension* extension = delayed_installs_.GetByID(extension_id);
+  if (!extension)
     return;
 
-  const Extension* extension = delayed_installs_.GetByID(extension_id);
-  if (reason == extensions::ExtensionPrefs::DELAY_REASON_WAIT_FOR_IMPORTS) {
-    extensions::SharedModuleService::ImportStatus status =
-        shared_module_service_->SatisfyImports(extension);
-    if (status != SharedModuleService::IMPORT_STATUS_OK) {
-      if (status == SharedModuleService::IMPORT_STATUS_UNRECOVERABLE) {
-        delayed_installs_.Remove(extension_id);
-        // Make sure no version of the extension is actually installed, (i.e.,
-        // that this delayed install was not an update).
-        CHECK(!extension_prefs_->GetInstalledExtensionInfo(extension_id).get());
-        extension_prefs_->DeleteExtensionPrefs(extension_id);
-      }
+  extensions::ExtensionPrefs::DelayReason reason;
+  const extensions::InstallGate::Action action = ShouldDelayExtensionInstall(
+      extension, false /* install_immediately*/, &reason);
+  switch (action) {
+    case extensions::InstallGate::INSTALL:
+      break;
+    case extensions::InstallGate::DELAY:
+      // Bail out and continue to delay the install.
       return;
-    }
+    case extensions::InstallGate::ABORT:
+      delayed_installs_.Remove(extension_id);
+      // Make sure no version of the extension is actually installed, (i.e.,
+      // that this delayed install was not an update).
+      CHECK(!extension_prefs_->GetInstalledExtensionInfo(extension_id).get());
+      extension_prefs_->DeleteExtensionPrefs(extension_id);
+      return;
   }
 
   FinishDelayedInstallation(extension_id);
 }
 
 void ExtensionService::FinishDelayedInstallation(
     const std::string& extension_id) {
   scoped_refptr<const Extension> extension(
       GetPendingExtensionUpdate(extension_id));
   CHECK(extension.get());
@@ skipping 330 matching lines @@
 }
 
 // Helper method to determine if an extension can be blocked.
 bool ExtensionService::CanBlockExtension(const Extension* extension) const {
   DCHECK(extension);
   return extension->location() != Manifest::COMPONENT &&
          extension->location() != Manifest::EXTERNAL_COMPONENT &&
          !system_->management_policy()->MustRemainEnabled(extension, nullptr);
 }
 
-bool ExtensionService::ShouldDelayExtensionUpdate(
-    const std::string& extension_id,
-    bool install_immediately) const {
-  const char kOnUpdateAvailableEvent[] = "runtime.onUpdateAvailable";
+extensions::InstallGate::Action ExtensionService::ShouldDelayExtensionInstall(
+    const extensions::Extension* extension,
+    bool install_immediately,
+    extensions::ExtensionPrefs::DelayReason* reason) const {
+  for (const auto& entry : install_delayer_registry_) {
+    extensions::InstallGate* const delayer = entry.second;
+    extensions::InstallGate::Action action =
+        delayer->ShouldDelay(extension, install_immediately);
+    if (action != extensions::InstallGate::INSTALL) {
+      *reason = entry.first;
+      return action;
+    }
+  }
 
-  // If delayed updates are globally disabled, or just for this extension,
-  // don't delay.
-  if (!install_updates_when_idle_ || install_immediately)
-    return false;
-
-  const Extension* old = GetInstalledExtension(extension_id);
-  // If there is no old extension, this is not an update, so don't delay.
-  if (!old)
-    return false;
-
-  if (extensions::BackgroundInfo::HasPersistentBackgroundPage(old)) {
-    // Delay installation if the extension listens for the onUpdateAvailable
-    // event.
-    return extensions::EventRouter::Get(profile_)
-        ->ExtensionHasEventListener(extension_id, kOnUpdateAvailableEvent);
-  } else {
-    // Delay installation if the extension is not idle.
-    return !extensions::util::IsExtensionIdle(extension_id, profile_);
-  }
-}
-
-void ExtensionService::OnGarbageCollectIsolatedStorageStart() {
-  DCHECK(!installs_delayed_for_gc_);
-  installs_delayed_for_gc_ = true;
-}
-
-void ExtensionService::OnGarbageCollectIsolatedStorageFinished() {
-  DCHECK(installs_delayed_for_gc_);
-  installs_delayed_for_gc_ = false;
-  MaybeFinishDelayedInstallations();
+  return extensions::InstallGate::INSTALL;
 }
 
 void ExtensionService::MaybeFinishDelayedInstallations() {
   std::vector<std::string> to_be_installed;
   for (const auto& extension : delayed_installs_) {
     to_be_installed.push_back(extension->id());
   }
   for (const auto& extension_id : to_be_installed) {
     MaybeFinishDelayedInstallation(extension_id);
   }
@@ skipping 137 matching lines @@
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }
 
+void ExtensionService::RegisterInstallGate(
+    extensions::ExtensionPrefs::DelayReason reason,
+    extensions::InstallGate* install_delayer) {
+  DCHECK(install_delayer_registry_.end() ==
+         install_delayer_registry_.find(reason));
+  install_delayer_registry_[reason] = install_delayer;
+}
+
+void ExtensionService::UnregisterInstallGate(
+    extensions::InstallGate* install_delayer) {
+  for (auto it = install_delayer_registry_.begin();
+       it != install_delayer_registry_.end(); ++it) {
+    if (it->second == install_delayer) {
+      install_delayer_registry_.erase(it);
+      return;
+    }
+  }
+}
+
 // Used only by test code.
 void ExtensionService::UnloadAllExtensionsInternal() {
   profile_->GetExtensionSpecialStoragePolicy()->RevokeRightsForAllExtensions();
 
   registry_->ClearAll();
   system_->runtime_data()->ClearAll();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
   // or uninstalled.
 }
 
 void ExtensionService::OnProfileDestructionStarted() {
   ExtensionIdSet ids_to_unload = registry_->enabled_extensions().GetIDs();
   for (ExtensionIdSet::iterator it = ids_to_unload.begin();
        it != ids_to_unload.end();
        ++it) {
     UnloadExtension(*it, UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN);
   }
 }