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

extensions/browser/event_router.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 #define EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/values.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "extensions/browser/event_listener_map.h"
 #include "extensions/browser/events/lazy_event_dispatch_util.h"
 #include "extensions/browser/extension_event_histogram_value.h"
 #include "extensions/browser/extension_registry_observer.h"
+#include "extensions/browser/lazy_context_task_queue.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/event_filtering_info.h"
 #include "ipc/ipc_sender.h"
 #include "url/gurl.h"
 
 class GURL;
 
 namespace content {
 class BrowserContext;
 class RenderProcessHost;
 }
 
 namespace extensions {
 class Extension;
-class ExtensionHost;
 class ExtensionPrefs;
 class ExtensionRegistry;
 
 struct Event;
 struct EventListenerInfo;
 
 // TODO(lazyboy): Document how extension events work, including how listeners
 // are registered and how listeners are tracked in renderer and browser process.
 class EventRouter : public KeyedService,
                     public ExtensionRegistryObserver,
@@ skipping 67 matching lines @@
   //
   // Note that multiple extensions can share a process due to process
   // collapsing. Also, a single extension can have 2 processes if it is a split
   // mode extension.
   void AddEventListener(const std::string& event_name,
                         content::RenderProcessHost* process,
                         const ExtensionId& extension_id);
   void AddServiceWorkerEventListener(const std::string& event_name,
                                      content::RenderProcessHost* process,
                                      const ExtensionId& extension_id,
+                                     const GURL& service_worker_scope,
                                      int worker_thread_id);
   void RemoveEventListener(const std::string& event_name,
                            content::RenderProcessHost* process,
                            const ExtensionId& extension_id);
   void RemoveServiceWorkerEventListener(const std::string& event_name,
                                         content::RenderProcessHost* process,
                                         const ExtensionId& extension_id,
+                                        const GURL& service_worker_scope,
                                         int worker_thread_id);
 
   // Add or remove a URL as an event listener for |event_name|.
   void AddEventListenerForURL(const std::string& event_name,
                               content::RenderProcessHost* process,
                               const GURL& listener_url);
   void RemoveEventListenerForURL(const std::string& event_name,
                                  content::RenderProcessHost* process,
                                  const GURL& listener_url);
 
@@ skipping 12 matching lines @@
   // remembered even after the process goes away. We use this list to decide
   // which extension pages to load when dispatching an event.
   void AddLazyEventListener(const std::string& event_name,
                             const ExtensionId& extension_id);
   void RemoveLazyEventListener(const std::string& event_name,
                                const ExtensionId& extension_id);
   // Similar to Add/RemoveLazyEventListener, but applies to extension service
   // workers.
   void AddLazyServiceWorkerEventListener(const std::string& event_name,
                                          const ExtensionId& extension_id,
-                                         int worker_thread_id);
+                                         const GURL& service_worker_scope);
   void RemoveLazyServiceWorkerEventListener(const std::string& event_name,
                                             const ExtensionId& extension_id,
-                                            int worker_thread_id);
+                                            const GURL& service_worker_scope);
 
   // If |add_lazy_listener| is true also add the lazy version of this listener.
   void AddFilteredEventListener(const std::string& event_name,
                                 content::RenderProcessHost* process,
                                 const std::string& extension_id,
                                 const base::DictionaryValue& filter,
                                 bool add_lazy_listener);
 
   // If |remove_lazy_listener| is true also remove the lazy version of this
   // listener.
@@ skipping 85 matching lines @@
                            const std::set<std::string>& events,
                            RegisteredEventType type);
 
   // ExtensionRegistryObserver implementation.
   void OnExtensionLoaded(content::BrowserContext* browser_context,
                          const Extension* extension) override;
   void OnExtensionUnloaded(content::BrowserContext* browser_context,
                            const Extension* extension,
                            UnloadedExtensionReason reason) override;
 
-  void AddLazyEventListenerImpl(const std::string& event_name,
-                                const ExtensionId& extension_id,
-                                int worker_thread_id);
-  void RemoveLazyEventListenerImpl(const std::string& event_name,
-                                   const ExtensionId& extension_id,
-                                   int worker_thread_id);
+  void AddLazyEventListenerImpl(std::unique_ptr<EventListener> listener,
+                                RegisteredEventType type);
+  void RemoveLazyEventListenerImpl(std::unique_ptr<EventListener> listener,
+                                   RegisteredEventType type);
 
   // Shared by all event dispatch methods. If |restrict_to_extension_id| is
   // empty, the event is broadcast.  An event that just came off the pending
   // list may not be delayed again.
   void DispatchEventImpl(const std::string& restrict_to_extension_id,
                          const linked_ptr<Event>& event);
 
-  // Ensures that all lazy background pages that are interested in the given

[Devlin, 2017/06/16 02:34:42]

These are gone now, right?  Can you rebase?

[lazyboy, 2017/06/16 18:48:05]

Yes, Done. (The CQ was taking long time to submit the other CL)

-  // event are loaded, and queues the event if the page is not ready yet.
-  // Inserts an EventDispatchIdentifier into |already_dispatched| for each lazy
-  // event dispatch that is queued.
-  void DispatchLazyEvent(const std::string& extension_id,
-                         const linked_ptr<Event>& event,
-                         std::set<EventDispatchIdentifier>* already_dispatched,
-                         const base::DictionaryValue* listener_filter);
-
   // Dispatches the event to the specified extension or URL running in
   // |process|.
   void 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);
 
-  // Possibly loads given extension's background page in preparation to
-  // dispatch an event.  Returns true if the event was queued for subsequent
-  // dispatch, false otherwise.
-  bool MaybeLoadLazyBackgroundPageToDispatchEvent(
-      content::BrowserContext* context,
-      const Extension* extension,
-      const linked_ptr<Event>& event,
-      const base::DictionaryValue* listener_filter);
-
   // Adds a filter to an event.
   void AddFilterToEvent(const std::string& event_name,
                         const std::string& extension_id,
                         const base::DictionaryValue* filter);
 
   // Removes a filter from an event.
   void RemoveFilterFromEvent(const std::string& event_name,
                              const std::string& extension_id,
                              const base::DictionaryValue* filter);
 
@@ skipping 10 matching lines @@
                                const std::string& event_name);
 
   // static
   static void DoDispatchEventToSenderBookkeepingOnUI(
       void* browser_context_id,
       const std::string& extension_id,
       int event_id,
       events::HistogramValue histogram_value,
       const std::string& event_name);
 
-  void DispatchPendingEvent(const linked_ptr<Event>& event,
-                            ExtensionHost* host);
+  void DispatchPendingEvent(
+      const linked_ptr<Event>& event,
+      std::unique_ptr<LazyContextTaskQueue::ContextInfo> params);
 
   // Implementation of EventListenerMap::Delegate.
   void OnListenerAdded(const EventListener* listener) override;
   void OnListenerRemoved(const EventListener* listener) override;
 
   // RenderProcessHostObserver implementation.
   void RenderProcessExited(content::RenderProcessHost* host,
                            base::TerminationStatus status,
                            int exit_code) override;
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
@@ skipping 106 matching lines @@
   const std::string event_name;
 
   const std::string extension_id;
   const GURL listener_url;
   content::BrowserContext* const browser_context;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_ROUTER_H_