extensions: Abstract out install delay strategy

chrome/browser/extensions/update_install_delayer.cc

Index: chrome/browser/extensions/update_install_delayer.cc
diff --git a/chrome/browser/extensions/update_install_delayer.cc b/chrome/browser/extensions/update_install_delayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..947b12d4829d5ff1d916f2779cdb629fafcb801e
--- /dev/null
+++ b/chrome/browser/extensions/update_install_delayer.cc
@@ -0,0 +1,48 @@
+// Copyright 2016 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/update_install_delayer.h"
+
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_util.h"
+#include "chrome/browser/profiles/profile.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/manifest_handlers/background_info.h"
+
+namespace extensions {
+
+UpdateInstallDelayer::UpdateInstallDelayer(ExtensionService* service)
+    : service_(service) {}
+
+InstallDelayer::Action UpdateInstallDelayer::GetDelayedInstallAction(
+    const Extension* extension,
+    bool install_immediately) {
+  if (install_immediately || !service_->is_ready())

[asargent_no_longer_on_chrome, 2016/04/16 00:20:22]

It's unintuitive that we'd return INSTALL if service_->is_ready() returns false
- I would expect this to be DELAY or ABORT instead. Can you include a comment
here explaining why we do it this way?

Alternatively, maybe the ExtensionService::is_ready check shouldn't really be
here, but rather should be called inside ExtensionService wherever this method
is called?

[xiyuan, 2016/04/18 20:44:30]

Added a comment to explain. The update is blocked because the old version of the
extension is not idle. When ExtensionService is not ready (i.e. during
initialization), the old version is definitely idle and we allow the
installation to proceed to take the opportunity to switch to the new version.
This is the existing behavior.[1]

Checking it on ExtensionService's call site is not good because this logic is
specific to the update. The delay logic for shared module (and incoming kiosk
platform check) does not (and should not) consider the
ExtensionService::is_ready condition.

[1]:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ext...

+    return INSTALL;
+
+  const Extension* old = service_->GetInstalledExtension(extension->id());
+  // If there is no old extension, this is not an update, so don't delay.
+  if (!old)
+    return INSTALL;
+
+  if (extensions::BackgroundInfo::HasPersistentBackgroundPage(old)) {
+    const char kOnUpdateAvailableEvent[] = "runtime.onUpdateAvailable";
+    // Delay installation if the extension listens for the onUpdateAvailable
+    // event.
+    return extensions::EventRouter::Get(service_->profile())
+                   ->ExtensionHasEventListener(extension->id(),
+                                               kOnUpdateAvailableEvent)
+               ? DELAY
+               : INSTALL;
+  } else {
+    // Delay installation if the extension is not idle.
+    return !extensions::util::IsExtensionIdle(extension->id(),
+                                              service_->profile())
+               ? DELAY
+               : INSTALL;
+  }
+}
+
+}  // namespace extensions