[extension SW]: Support event listener registration and event dispatching.

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/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/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,
                     public EventListenerMap::Delegate,
                     public content::RenderProcessHostObserver {
  public:
   // These constants convey the state of our knowledge of whether we're in
   // a user-caused gesture as part of DispatchEvent.
   enum UserGestureState {
     USER_GESTURE_UNKNOWN = 0,
     USER_GESTURE_ENABLED = 1,
     USER_GESTURE_NOT_ENABLED = 2,
   };
 
   // The pref key for the list of event names for which an extension has
   // registered from its lazy background page.
-  static const char kRegisteredEvents[];
+  static const char kRegisteredLazyEvents[];
+  // The pref key for the list of event names for which an extension has
+  // registered from its service worker.
+  static const char kRegisteredServiceWorkerEvents[];
 
   // Observers register interest in events with a particular name and are
   // notified when a listener is added or removed. Observers are matched by
   // the base name of the event (e.g. adding an event listener for event name
   // "foo.onBar/123" will trigger observers registered for "foo.onBar").
   class Observer {
    public:
     // Called when a listener is added.
     virtual void OnListenerAdded(const EventListenerInfo& details) {}
     // Called when a listener is removed.
@@ skipping 30 matching lines @@
               ExtensionPrefs* extension_prefs);
   ~EventRouter() override;
 
   // Add or remove an extension as an event listener for |event_name|.
   //
   // 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 std::string& extension_id);
+                        const ExtensionId& extension_id);
+  void AddServiceWorkerEventListener(const std::string& event_name,
+                                     content::RenderProcessHost* process,
+                                     const ExtensionId& extension_id,
+                                     int worker_thread_id);
   void RemoveEventListener(const std::string& event_name,
                            content::RenderProcessHost* process,
-                           const std::string& extension_id);
+                           const ExtensionId& extension_id);
+  void RemoveServiceWorkerEventListener(const std::string& event_name,
+                                        content::RenderProcessHost* process,
+                                        const ExtensionId& extension_id,
+                                        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);
 
   EventListenerMap& listeners() { return listeners_; }
 
   // Registers an observer to be notified when an event listener for
   // |event_name| is added or removed. There can currently be only one observer
   // for each distinct |event_name|.
   void RegisterObserver(Observer* observer, const std::string& event_name);
 
   // Unregisters an observer from all events.
   void UnregisterObserver(Observer* observer);
 
   // Add or remove the extension as having a lazy background page that listens
   // to the event. The difference from the above methods is that these will be
   // 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 std::string& extension_id);
+                            const ExtensionId& extension_id);
   void RemoveLazyEventListener(const std::string& event_name,
-                               const std::string& extension_id);
+                               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);
+  void RemoveLazyServiceWorkerEventListener(const std::string& event_name,
+                                            const ExtensionId& extension_id,
+                                            int worker_thread_id);
 
   // 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 24 matching lines @@
   // newly installed extensions.
   void DispatchEventWithLazyListener(const std::string& extension_id,
                                      std::unique_ptr<Event> event);
 
   // Record the Event Ack from the renderer. (One less event in-flight.)
   void OnEventAck(content::BrowserContext* context,
                   const std::string& extension_id);
 
   // Returns whether or not the given extension has any registered events.
   bool HasRegisteredEvents(const ExtensionId& extension_id) const {
-    return !GetRegisteredEvents(extension_id).empty();
+    return !GetRegisteredEvents(extension_id, RegisteredEventType::kLazy)
+                .empty();
   }
 
   // Clears registered events for testing purposes.
-  void ClearRegisteredEventsForTest(const ExtensionId& extension_id) {
-    SetRegisteredEvents(extension_id, std::set<std::string>());
-  }
+  void ClearRegisteredEventsForTest(const ExtensionId& extension_id);
 
   // Reports UMA for an event dispatched to |extension| with histogram value
   // |histogram_value|. Must be called on the UI thread.
   //
   // |did_enqueue| should be true if the event was queued waiting for a process
   // to start, like an event page.
   void ReportEvent(events::HistogramValue histogram_value,
                    const Extension* extension,
                    bool did_enqueue);
 
   LazyEventDispatchUtil* lazy_event_dispatch_util() {
     return &lazy_event_dispatch_util_;
   }
 
  private:
   friend class EventRouterFilterTest;
   friend class EventRouterTest;
 
+  enum class RegisteredEventType {
+    kLazy,
+    kServiceWorker,
+  };
+
   // An identifier for an event dispatch that is used to prevent double dispatch
   // due to race conditions between the direct and lazy dispatch paths.
-  typedef std::pair<const content::BrowserContext*, std::string>
+  typedef std::tuple<const content::BrowserContext*, std::string, int>
       EventDispatchIdentifier;
 
   // TODO(gdk): Document this.
   static void DispatchExtensionMessage(
       IPC::Sender* ipc_sender,
+      int worker_thread_id,
       void* browser_context_id,
       const std::string& extension_id,
       int event_id,
       const std::string& event_name,
       base::ListValue* event_args,
       UserGestureState user_gesture,
       const extensions::EventFilteringInfo& info);
 
   // Returns or sets the list of events for which the given extension has
   // registered.
-  std::set<std::string> GetRegisteredEvents(
-      const std::string& extension_id) const;
+  std::set<std::string> GetRegisteredEvents(const std::string& extension_id,
+                                            RegisteredEventType type) const;
   void SetRegisteredEvents(const std::string& extension_id,
-                           const std::set<std::string>& events);
+                           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);
+
   // 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
   // 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);
 
   // Returns false when the event is scoped to a context and the listening
   // extension does not have access to events from that context. Also fills
   // |event_args| with the proper arguments to send, which may differ if
   // the event crosses the incognito boundary.
   bool CanDispatchEventToBrowserContext(content::BrowserContext* context,
                                         const Extension* extension,
@@ skipping 157 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_