[extension SW] Support lazy events from extension service workers.

extensions/browser/lazy_background_task_queue.cc

 // Copyright 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 "extensions/browser/lazy_background_task_queue.h"
 
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue_factory.h"
+#include "extensions/browser/lazy_context_id.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/view_type.h"
 
 namespace extensions {
 
+namespace {
+
+// Adapts a LazyBackgroundTaskQueue pending task callback to
+// LazyContextTaskQueue's callback.
+void PendingTaskAdapter(const LazyContextTaskQueue::PendingTask& original_task,
+                        ExtensionHost* host) {
+  if (!host) {
+    original_task.Run(nullptr);
+  } else {
+    original_task.Run(base::MakeUnique<LazyContextTaskQueue::ContextInfo>(
+        host->extension()->id(), host->render_process_host(),
+        kNonWorkerThreadId, host->GetURL()));
+  }
+}
+
+}  // namespace
+
 LazyBackgroundTaskQueue::LazyBackgroundTaskQueue(
     content::BrowserContext* browser_context)
     : browser_context_(browser_context), extension_registry_observer_(this) {
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_FIRST_LOAD,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
@@ skipping 21 matching lines @@
         pm->GetBackgroundHostForExtension(extension->id());
     if (!background_host || !background_host->has_loaded_once())
       return true;
     if (pm->IsBackgroundHostClosing(extension->id()))
       pm->CancelSuspend(extension);
   }
 
   return false;
 }
 
+void LazyBackgroundTaskQueue::AddPendingTaskToDispatchEvent(
+    LazyContextId* context_id,
+    const LazyContextTaskQueue::PendingTask& task) {
+  AddPendingTask(context_id->browser_context(), context_id->extension_id(),
+                 base::Bind(&PendingTaskAdapter, task));
+}
+
 void LazyBackgroundTaskQueue::AddPendingTask(
     content::BrowserContext* browser_context,
     const std::string& extension_id,
     const PendingTask& task) {
   if (ExtensionsBrowserClient::Get()->IsShuttingDown()) {
     task.Run(NULL);
     return;
   }
   PendingTasksList* tasks_list = NULL;
   PendingTasksKey key(browser_context, extension_id);
@@ skipping 106 matching lines @@
   // task queue as well.
   ExtensionsBrowserClient* browser_client = ExtensionsBrowserClient::Get();
   if (browser_client->HasOffTheRecordContext(browser_context)) {
     ProcessPendingTasks(NULL,
                         browser_client->GetOffTheRecordContext(browser_context),
                         extension);
   }
 }
 
 }  // namespace extensions