Extract RuntimeEventRouter from extensions Runtime API

extensions/browser/api/runtime/runtime_event_router.cc

+// Copyright 2014 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 "extensions/browser/api/runtime/runtime_event_router.h"
+
+#include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
+#include "base/version.h"
+#include "content/public/browser/browser_context.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/extensions_browser_client.h"
+#include "extensions/browser/lazy_background_task_queue.h"
+#include "extensions/common/manifest_handlers/background_info.h"
+
+using content::BrowserContext;
+
+namespace extensions {
+
+namespace runtime = api::runtime;
+
+namespace {
+
+const char kInstallReason[] = "reason";
+const char kInstallReasonChromeUpdate[] = "chrome_update";
+const char kInstallReasonUpdate[] = "update";
+const char kInstallReasonInstall[] = "install";
+const char kInstallPreviousVersion[] = "previousVersion";
+
+// Dispatches the onStartup event. May do so by posting a task if the extension
+// background page has not yet loaded.
+void DispatchOnStartupEventImpl(BrowserContext* browser_context,
+                                const std::string& extension_id,
+                                bool first_call,
+                                ExtensionHost* host) {
+  // A NULL host from the LazyBackgroundTaskQueue means the page failed to
+  // load. Give up.
+  if (!host && !first_call)
+    return;
+
+  // Don't send onStartup events to incognito browser contexts.
+  if (browser_context->IsOffTheRecord())
+    return;
+
+  if (ExtensionsBrowserClient::Get()->IsShuttingDown() ||
+      !ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
+    return;
+  ExtensionSystem* system = ExtensionSystem::Get(browser_context);
+  if (!system)
+    return;
+
+  // If this is a persistent background page, we want to wait for it to load
+  // (it might not be ready, since this is startup). But only enqueue once.
+  // If it fails to load the first time, don't bother trying again.
+  const Extension* extension =
+      ExtensionRegistry::Get(browser_context)
+          ->GetExtensionById(extension_id, ExtensionRegistry::ENABLED);
+  LazyBackgroundTaskQueue* queue = system->lazy_background_task_queue();
+  if (extension && BackgroundInfo::HasPersistentBackgroundPage(extension) &&
+      first_call && queue->ShouldEnqueueTask(browser_context, extension)) {
+    queue->AddPendingTask(
+        browser_context,
+        extension_id,
+        base::Bind(
+            &DispatchOnStartupEventImpl, browser_context, extension_id, false));
+    return;
+  }
+
+  scoped_ptr<base::ListValue> event_args(new base::ListValue());
+  scoped_ptr<Event> event(
+      new Event(runtime::OnStartup::kEventName, event_args.Pass()));
+  system->event_router()->DispatchEventToExtension(extension_id, event.Pass());
+}
+
+}  // namespace
+
+// static
+void RuntimeEventRouter::DispatchOnStartupEvent(
+    BrowserContext* context,
+    const std::string& extension_id) {
+  DispatchOnStartupEventImpl(context, extension_id, true, NULL);
+}
+
+// static
+void RuntimeEventRouter::DispatchOnInstalledEvent(
+    BrowserContext* context,
+    const std::string& extension_id,
+    const base::Version& old_version,
+    bool chrome_updated) {
+  if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
+    return;
+  ExtensionSystem* system = ExtensionSystem::Get(context);
+  if (!system)
+    return;
+
+  scoped_ptr<base::ListValue> event_args(new base::ListValue());
+  base::DictionaryValue* info = new base::DictionaryValue();
+  event_args->Append(info);
+  if (old_version.IsValid()) {
+    info->SetString(kInstallReason, kInstallReasonUpdate);
+    info->SetString(kInstallPreviousVersion, old_version.GetString());
+  } else if (chrome_updated) {
+    info->SetString(kInstallReason, kInstallReasonChromeUpdate);
+  } else {
+    info->SetString(kInstallReason, kInstallReasonInstall);
+  }
+  DCHECK(system->event_router());
+  scoped_ptr<Event> event(
+      new Event(runtime::OnInstalled::kEventName, event_args.Pass()));
+  system->event_router()->DispatchEventWithLazyListener(extension_id,
+                                                        event.Pass());
+}
+
+// static
+void RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
+    BrowserContext* context,
+    const std::string& extension_id,
+    const base::DictionaryValue* manifest) {
+  ExtensionSystem* system = ExtensionSystem::Get(context);
+  if (!system)
+    return;
+
+  scoped_ptr<base::ListValue> args(new base::ListValue);
+  args->Append(manifest->DeepCopy());
+  DCHECK(system->event_router());
+  scoped_ptr<Event> event(
+      new Event(runtime::OnUpdateAvailable::kEventName, args.Pass()));
+  system->event_router()->DispatchEventToExtension(extension_id, event.Pass());
+}
+
+// static
+void RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(
+    BrowserContext* context) {
+  ExtensionSystem* system = ExtensionSystem::Get(context);
+  if (!system)
+    return;
+
+  scoped_ptr<base::ListValue> args(new base::ListValue);
+  DCHECK(system->event_router());
+  scoped_ptr<Event> event(
+      new Event(runtime::OnBrowserUpdateAvailable::kEventName, args.Pass()));
+  system->event_router()->BroadcastEvent(event.Pass());
+}
+
+// static
+void RuntimeEventRouter::DispatchOnRestartRequiredEvent(
+    BrowserContext* context,
+    const std::string& app_id,
+    api::runtime::OnRestartRequired::Reason reason) {
+  ExtensionSystem* system = ExtensionSystem::Get(context);
+  if (!system)
+    return;
+
+  scoped_ptr<Event> event(
+      new Event(runtime::OnRestartRequired::kEventName,
+                api::runtime::OnRestartRequired::Create(reason)));
+
+  DCHECK(system->event_router());
+  system->event_router()->DispatchEventToExtension(app_id, event.Pass());
+}
+
+}  // namespace extensions