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

extensions/browser/event_listener_map.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/event_listener_map.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/common/constants.h"
 #include "ipc/ipc_message.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 using base::DictionaryValue;
 
 namespace extensions {
 
 typedef EventFilter::MatcherID MatcherID;
 
 // static
 std::unique_ptr<EventListener> EventListener::ForExtension(
     const std::string& event_name,
     const std::string& extension_id,
     content::RenderProcessHost* process,
     std::unique_ptr<base::DictionaryValue> filter) {
   return base::WrapUnique(new EventListener(event_name, extension_id, GURL(),
-                                            process, std::move(filter)));
+                                            process, kNonWorkerThreadId,
+                                            std::move(filter)));
 }
 
 // static
 std::unique_ptr<EventListener> EventListener::ForURL(
     const std::string& event_name,
     const GURL& listener_url,
     content::RenderProcessHost* process,
     std::unique_ptr<base::DictionaryValue> filter) {
   // Use only the origin to identify the event listener, e.g. chrome://settings
   // for chrome://settings/accounts, to avoid multiple events being triggered
   // for the same process. See crbug.com/536858 for details. // TODO(devlin): If
   // we dispatched events to processes more intelligently this could be avoided.
-  return base::WrapUnique(new EventListener(event_name, "",
-                                            url::Origin(listener_url).GetURL(),
-                                            process, std::move(filter)));
+  return base::WrapUnique(
+      new EventListener(event_name, "", url::Origin(listener_url).GetURL(),

[Devlin, 2017/06/01 04:54:49]

while we're here, prefer std::string()

[lazyboy, 2017/06/01 23:33:29]

Done.

+                        process, kNonWorkerThreadId, std::move(filter)));
+}
+
+std::unique_ptr<EventListener> EventListener::ForExtensionServiceWorker(
+    const std::string& event_name,
+    const std::string& extension_id,
+    content::RenderProcessHost* process,
+    int worker_thread_id,
+    std::unique_ptr<base::DictionaryValue> filter) {
+  return base::WrapUnique(new EventListener(event_name, extension_id, GURL(),
+                                            process, worker_thread_id,
+                                            std::move(filter)));
 }
 
 EventListener::~EventListener() {}
 
 bool EventListener::Equals(const EventListener* other) const {
   // We don't check matcher_id equality because we want a listener with a
   // filter that hasn't been added to EventFilter to match one that is
   // equivalent but has.
   return event_name_ == other->event_name_ &&
          extension_id_ == other->extension_id_ &&
          listener_url_ == other->listener_url_ && process_ == other->process_ &&
+         worker_thread_id_ == other->worker_thread_id_ &&
          ((!!filter_.get()) == (!!other->filter_.get())) &&
          (!filter_.get() || filter_->Equals(other->filter_.get()));
 }
 
 std::unique_ptr<EventListener> EventListener::Copy() const {
   std::unique_ptr<DictionaryValue> filter_copy;
   if (filter_)
     filter_copy = filter_->CreateDeepCopy();
-  return base::WrapUnique(new EventListener(event_name_, extension_id_,
-                                            listener_url_, process_,
-                                            std::move(filter_copy)));
+  return base::WrapUnique(
+      new EventListener(event_name_, extension_id_, listener_url_, process_,
+                        worker_thread_id_, std::move(filter_copy)));
 }
 
 bool EventListener::IsLazy() const {
   return !process_;
 }
 
+bool EventListener::IsForServiceWorker() const {
+  return worker_thread_id_ != kNonWorkerThreadId;
+}
+
 void EventListener::MakeLazy() {
+  DCHECK_NE(worker_thread_id_, kNonWorkerThreadId);
   process_ = nullptr;
 }
 
 content::BrowserContext* EventListener::GetBrowserContext() const {
   return process_ ? process_->GetBrowserContext() : nullptr;
 }
 
 EventListener::EventListener(const std::string& event_name,
                              const std::string& extension_id,
                              const GURL& listener_url,
                              content::RenderProcessHost* process,
+                             int worker_thread_id,
                              std::unique_ptr<DictionaryValue> filter)
     : event_name_(event_name),
       extension_id_(extension_id),
       listener_url_(listener_url),
       process_(process),
+      worker_thread_id_(worker_thread_id),
       filter_(std::move(filter)),
       matcher_id_(-1) {}
 
 EventListenerMap::EventListenerMap(Delegate* delegate)
     : delegate_(delegate) {
 }
 
 EventListenerMap::~EventListenerMap() {}
 
 bool EventListenerMap::AddListener(std::unique_ptr<EventListener> listener) {
@@ skipping 64 matching lines @@
 
   for (const auto& listener_to_search : it->second) {
     if (listener_to_search->Equals(listener))
       return true;
   }
   return false;
 }
 
 bool EventListenerMap::HasProcessListener(
     content::RenderProcessHost* process,
+    int worker_thread_id,
     const std::string& extension_id) const {
   for (const auto& it : listeners_) {
     for (const auto& listener : it.second) {
       if (listener->process() == process &&
-          listener->extension_id() == extension_id)
+          listener->extension_id() == extension_id &&
+          listener->worker_thread_id() == worker_thread_id) {
         return true;
+      }
     }
   }
   return false;
 }
 
 void EventListenerMap::RemoveListenersForExtension(
     const std::string& extension_id) {
   for (auto& it : listeners_) {
     auto& listener_map = it.second;
     for (ListenerList::iterator it2 = listener_map.begin();
@@ skipping 24 matching lines @@
     const DictionaryValue& filtered) {
   for (DictionaryValue::Iterator it(filtered); !it.IsAtEnd(); it.Advance()) {
     // We skip entries if they are malformed.
     const base::ListValue* filter_list = nullptr;
     if (!it.value().GetAsList(&filter_list))
       continue;
     for (size_t i = 0; i < filter_list->GetSize(); i++) {
       const DictionaryValue* filter = nullptr;
       if (!filter_list->GetDictionary(i, &filter))
         continue;
+      // Currently this is only used for lazy background page events.
+      // TODO(lazyboy): Add extension SW lazy events.
       AddListener(
           EventListener::ForExtension(it.key(), extension_id, nullptr,
                                       base::WrapUnique(filter->DeepCopy())));
     }
   }
 }
 
 std::set<const EventListener*> EventListenerMap::GetEventListeners(
     const Event& event) {
   std::set<const EventListener*> interested_listeners;
@@ skipping 40 matching lines @@
     return;
   event_filter_.RemoveEventMatcher(listener->matcher_id());
   CHECK_EQ(1u, listeners_by_matcher_id_.erase(listener->matcher_id()));
 }
 
 bool EventListenerMap::IsFilteredEvent(const Event& event) const {
   return base::ContainsKey(filtered_events_, event.event_name);
 }
 
 }  // namespace extensions