Move lazy event dispatching code out of EventRouter.

extensions/browser/event_router.cc

 // 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.
 
 #include "extensions/browser/event_router.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/api_activity_monitor.h"
 #include "extensions/browser/event_router_factory.h"
+#include "extensions/browser/events/lazy_event_dispatcher.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/lazy_background_task_queue.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/manifest_handlers/background_info.h"
@@ skipping 96 matching lines @@
   }
 
   DispatchExtensionMessage(ipc_sender,
                            // TODO(lazyboy): |kNonWorkerThreadId| means these
                            // will not work for extension SW.
                            kNonWorkerThreadId, browser_context_id, extension_id,
                            event_id, event_name, event_args.get(), user_gesture,
                            info);
 }
 
+// static.
+bool EventRouter::CanDispatchEventToBrowserContext(BrowserContext* context,
+                                                   const Extension* extension,
+                                                   const Event& event) {
+  // Is this event from a different browser context than the renderer (ie, an
+  // incognito tab event sent to a normal process, or vice versa).
+  bool crosses_incognito = event.restrict_to_browser_context &&
+                           context != event.restrict_to_browser_context;
+  if (!crosses_incognito)
+    return true;
+  return ExtensionsBrowserClient::Get()->CanExtensionCrossIncognito(extension,
+                                                                    context);
+}
+
 EventRouter::EventRouter(BrowserContext* browser_context,
                          ExtensionPrefs* extension_prefs)
     : browser_context_(browser_context),
       extension_prefs_(extension_prefs),
       extension_registry_observer_(this),
       listeners_(this),
-      lazy_event_dispatch_util_(browser_context_) {
+      lazy_event_dispatch_util_(browser_context_),
+      weak_factory_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 }
 
 EventRouter::~EventRouter() {
   for (auto* process : observed_process_set_)
     process->RemoveObserver(this);
 }
 
 void EventRouter::AddEventListener(const std::string& event_name,
                                    content::RenderProcessHost* process,
@@ skipping 264 matching lines @@
 
 void EventRouter::DispatchEventImpl(const std::string& restrict_to_extension_id,
                                     const linked_ptr<Event>& event) {
   // We don't expect to get events from a completely different browser context.
   DCHECK(!event->restrict_to_browser_context ||
          ExtensionsBrowserClient::Get()->IsSameContext(
              browser_context_, event->restrict_to_browser_context));
   std::set<const EventListener*> listeners(
       listeners_.GetEventListeners(*event));
 
-  std::set<EventDispatchIdentifier> already_dispatched;
+  LazyEventDispatcher lazy_event_dispatcher(
+      browser_context_, event,
+      base::Bind(&EventRouter::DispatchPendingEvent,
+                 weak_factory_.GetWeakPtr()));
 
   // We dispatch events for lazy background pages first because attempting to do
   // so will cause those that are being suspended to cancel that suspension.
   // As canceling a suspension entails sending an event to the affected
   // background page, and as that event needs to be delivered before we dispatch
   // the event we are dispatching here, we dispatch to the lazy listeners here
   // first.
   for (const EventListener* listener : listeners) {
-    if (restrict_to_extension_id.empty() ||
-        restrict_to_extension_id == listener->extension_id()) {
-      // TODO(lazyboy): Support lazy listeners for extension SW events.
-      if (listener->IsLazy() && !listener->IsForServiceWorker()) {
-        DispatchLazyEvent(listener->extension_id(), event, &already_dispatched,
-                          listener->filter());
-      }
+    if (!restrict_to_extension_id.empty() &&
+        restrict_to_extension_id != listener->extension_id()) {
+      continue;
+    }
+    // TODO(lazyboy): Support lazy listeners for extension SW events.
+    if (listener->IsLazy() && !listener->IsForServiceWorker()) {
+      lazy_event_dispatcher.DispatchToEventPage(listener->extension_id(),
+                                                listener->filter());
     }
   }
 
   for (const EventListener* listener : listeners) {
-    if (restrict_to_extension_id.empty() ||
-        restrict_to_extension_id == listener->extension_id()) {
-      if (listener->process()) {
-        EventDispatchIdentifier dispatch_id(listener->GetBrowserContext(),
-                                            listener->extension_id(),
-                                            listener->worker_thread_id());
-        if (!base::ContainsKey(already_dispatched, dispatch_id)) {
-          DispatchEventToProcess(listener->extension_id(),
-                                 listener->listener_url(), listener->process(),
-                                 listener->worker_thread_id(), event,
-                                 listener->filter(), false /* did_enqueue */);
-        }
-      }
+    if (!restrict_to_extension_id.empty() &&
+        restrict_to_extension_id != listener->extension_id()) {
+      continue;
     }
+    if (!listener->process())
+      continue;
+    if (lazy_event_dispatcher.HasAlreadyDispatched(
+            listener->process()->GetBrowserContext(), listener)) {
+      continue;
+    }
+    DispatchEventToProcess(listener->extension_id(), listener->listener_url(),
+                           listener->process(), listener->worker_thread_id(),
+                           event, listener->filter(), false /* did_enqueue */);
   }
 }
 
-void EventRouter::DispatchLazyEvent(
-    const std::string& extension_id,
-    const linked_ptr<Event>& event,
-    std::set<EventDispatchIdentifier>* already_dispatched,
-    const base::DictionaryValue* listener_filter) {
-  // Check both the original and the incognito browser context to see if we
-  // should load a lazy bg page to handle the event. The latter case
-  // occurs in the case of split-mode extensions.
-  const Extension* extension =
-      ExtensionRegistry::Get(browser_context_)->enabled_extensions().GetByID(
-          extension_id);
-  if (!extension)
-    return;
-
-  if (MaybeLoadLazyBackgroundPageToDispatchEvent(browser_context_, extension,
-                                                 event, listener_filter)) {
-    already_dispatched->insert(
-        std::make_tuple(browser_context_, extension_id, kNonWorkerThreadId));
-  }
-
-  ExtensionsBrowserClient* browser_client = ExtensionsBrowserClient::Get();
-  if (browser_client->HasOffTheRecordContext(browser_context_) &&
-      IncognitoInfo::IsSplitMode(extension)) {
-    BrowserContext* incognito_context =
-        browser_client->GetOffTheRecordContext(browser_context_);
-    if (MaybeLoadLazyBackgroundPageToDispatchEvent(incognito_context, extension,
-                                                   event, listener_filter)) {
-      already_dispatched->insert(
-          std::make_tuple(incognito_context, extension_id, kNonWorkerThreadId));
-    }
-  }
-}
-
 void EventRouter::DispatchEventToProcess(
     const std::string& extension_id,
     const GURL& listener_url,
     content::RenderProcessHost* process,
     int worker_thread_id,
     const linked_ptr<Event>& event,
     const base::DictionaryValue* listener_filter,
     bool did_enqueue) {
   BrowserContext* listener_context = process->GetBrowserContext();
   ProcessMap* process_map = ProcessMap::Get(listener_context);
@@ skipping 18 matching lines @@
     // to access that URL.
     if (!event->event_url.is_empty() &&
         event->event_url.host() != extension->id() &&  // event for self is ok
         !extension->permissions_data()
              ->active_permissions()
              .HasEffectiveAccessToURL(event->event_url)) {
       return;
     }
     // Secondly, if the event is for incognito mode, the Extension must be
     // enabled in incognito mode.
-    if (!CanDispatchEventToBrowserContext(listener_context, extension, event)) {
+    if (!CanDispatchEventToBrowserContext(listener_context, extension,
+                                          *event)) {
       return;
     }
   }
 
   Feature::Context target_context =
       process_map->GetMostLikelyContextType(extension, process->GetID());
 
   // We shouldn't be dispatching an event to a webpage, since all such events
   // (e.g.  messaging) don't go through EventRouter.
   DCHECK_NE(Feature::WEB_PAGE_CONTEXT, target_context)
@@ skipping 25 matching lines @@
                            event->event_args.get(), event->user_gesture,
                            event->filter_info);
 
   if (extension) {
     ReportEvent(event->histogram_value, extension, did_enqueue);
     IncrementInFlightEvents(listener_context, extension, event_id,
                             event->event_name);
   }
 }
 
-bool EventRouter::CanDispatchEventToBrowserContext(
-    BrowserContext* context,
-    const Extension* extension,
-    const linked_ptr<Event>& event) {
-  // Is this event from a different browser context than the renderer (ie, an
-  // incognito tab event sent to a normal process, or vice versa).
-  bool cross_incognito = event->restrict_to_browser_context &&
-                         context != event->restrict_to_browser_context;
-  if (!cross_incognito)
-    return true;
-  return ExtensionsBrowserClient::Get()->CanExtensionCrossIncognito(
-      extension, context);
-}
-
-bool EventRouter::MaybeLoadLazyBackgroundPageToDispatchEvent(
-    BrowserContext* context,
-    const Extension* extension,
-    const linked_ptr<Event>& event,
-    const base::DictionaryValue* listener_filter) {
-  if (!CanDispatchEventToBrowserContext(context, extension, event))
-    return false;
-
-  LazyBackgroundTaskQueue* queue = LazyBackgroundTaskQueue::Get(context);
-  if (!queue->ShouldEnqueueTask(context, extension))
-    return false;
-
-  linked_ptr<Event> dispatched_event(event);
-
-  // If there's a dispatch callback, call it now (rather than dispatch time)
-  // to avoid lifetime issues. Use a separate copy of the event args, so they
-  // last until the event is dispatched.
-  if (!event->will_dispatch_callback.is_null()) {
-    dispatched_event.reset(event->DeepCopy());
-    if (!dispatched_event->will_dispatch_callback.Run(
-            context, extension, dispatched_event.get(), listener_filter)) {
-      // The event has been canceled.
-      return true;
-    }
-    // Ensure we don't call it again at dispatch time.
-    dispatched_event->will_dispatch_callback.Reset();
-  }
-
-  queue->AddPendingTask(context, extension->id(),
-                        base::Bind(&EventRouter::DispatchPendingEvent,
-                                   base::Unretained(this), dispatched_event));
-  return true;
-}
-
 // static
 void EventRouter::DoDispatchEventToSenderBookkeepingOnUI(
     void* browser_context_id,
     const std::string& extension_id,
     int event_id,
     events::HistogramValue histogram_value,
     const std::string& event_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserContext* browser_context =
       reinterpret_cast<BrowserContext*>(browser_context_id);
@@ skipping 261 matching lines @@
                                      const std::string& extension_id,
                                      const GURL& listener_url,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
       listener_url(listener_url),
       browser_context(browser_context) {
 }
 
 }  // namespace extensions