[Extensions] Extensively expand EventListenerMap/EventRouter tests for workers.

This CL primarily expands EventListenerMap tests to account for
service workers. It does so by parameterizing EventListenerMapTest
with service worker / non-service worker param.

Bug: None
Change-Id: I11a657d1b5d9293d73c1c6546e81bede36319ee8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2247548
Commit-Queue: Istiaque Ahmed <lazyboy@chromium.org>
Reviewed-by: David Bertoni <dbertoni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#779195}

extensions/browser/event_listener_map_unittest.cc

@@ -29,6 +29,19 @@ const char kEvent1Name[] = "event1";
 const char kEvent2Name[] = "event2";
 const char kURL[] = "https://google.com/some/url";
 
+// Returns appropriate worker version id for tests.
+int64_t GetWorkerVersionId(bool lazy) {
+  static constexpr int64_t kDummyServiceWorkerVersionId = 199;
+  return lazy ? blink::mojom::kInvalidServiceWorkerVersionId
+              : kDummyServiceWorkerVersionId;
+}
+
+// Returns appropriate worker thread id for tests.
+int GetWorkerThreadId(bool lazy) {
+  static constexpr int kDummyServiceWorkerThreadId = 99;
+  return lazy ? kMainThreadId : kDummyServiceWorkerThreadId;
+}
+
 using EventListenerConstructor =
     base::RepeatingCallback<std::unique_ptr<EventListener>(
         const std::string& /* event_name */,
@@ -89,10 +102,16 @@ class EventListenerMapTest : public ExtensionsTest {
   std::unique_ptr<EventListener> CreateLazyListener(
       const std::string& event_name,
       const ExtensionId& extension_id,
-      const std::string& host_suffix,
+      std::unique_ptr<base::DictionaryValue> filter,
       bool is_for_service_worker) {
+    if (is_for_service_worker) {
+      return EventListener::ForExtensionServiceWorker(
+          event_name, extension_id, nullptr,
+          Extension::GetBaseURLFromExtensionId(extension_id),
+          GetWorkerVersionId(true), GetWorkerThreadId(true), std::move(filter));
+    }
     return EventListener::ForExtension(event_name, extension_id, nullptr,
-                                       CreateHostSuffixFilter(host_suffix));
+                                       std::move(filter));
   }
 
  protected:
@@ -109,6 +128,11 @@ class EventListenerMapTest : public ExtensionsTest {
   content::RenderProcessHost* process_;
 };
 
+// Parameterized version of test to run with |is_for_service_worker|.
+class EventListenerMapWithContextTest
+    : public EventListenerMapTest,
+      public testing::WithParamInterface<bool /* is_for_service_worker */> {};
+
 std::unique_ptr<EventListener> CreateEventListenerForExtension(
     const std::string& extension_id,
     const std::string& event_name,
@@ -127,6 +151,17 @@ std::unique_ptr<EventListener> CreateEventListenerForURL(
                                std::move(filter));
 }
 
+std::unique_ptr<EventListener> CreateEventListenerForExtensionServiceWorker(
+    const std::string& extension_id,
+    const std::string& event_name,
+    content::RenderProcessHost* process,
+    std::unique_ptr<base::DictionaryValue> filter) {
+  return EventListener::ForExtensionServiceWorker(
+      event_name, extension_id, process,
+      Extension::GetBaseURLFromExtensionId(extension_id),
+      GetWorkerVersionId(false), GetWorkerThreadId(false), std::move(filter));
+}
+
 void EventListenerMapTest::TestUnfilteredEventsGoToAllListeners(
     const EventListenerConstructor& constructor) {
   listeners_->AddListener(constructor.Run(
@@ -145,31 +180,76 @@ TEST_F(EventListenerMapTest, UnfilteredEventsGoToAllListenersForURLs) {
       base::BindRepeating(&CreateEventListenerForURL, GURL(kURL)));
 }
 
+TEST_F(EventListenerMapTest,
+       UnfilteredEventsGoToAllListenersForExtensionServiceWorkers) {
+  TestUnfilteredEventsGoToAllListeners(base::BindRepeating(
+      &CreateEventListenerForExtensionServiceWorker, kExt1Id));
+}
+
 TEST_F(EventListenerMapTest, FilteredEventsGoToAllMatchingListeners) {
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, std::make_unique<DictionaryValue>()));
+  auto create_filter = [&](const std::string& filter_str) {
+    return CreateHostSuffixFilter(filter_str);
+  };
+  auto create_empty_filter = []() {
+    return std::make_unique<base::DictionaryValue>();
+  };
+
+  for (bool is_for_service_worker : {false, true}) {
+    listeners_->AddListener(CreateLazyListener(kEvent1Name, kExt1Id,
+                                               create_filter("google.com"),
+                                               is_for_service_worker));
+    listeners_->AddListener(CreateLazyListener(
+        kEvent1Name, kExt1Id, create_empty_filter(), is_for_service_worker));
+  }
 
   std::unique_ptr<Event> event(CreateNamedEvent(kEvent1Name));
   event->filter_info.url = GURL("http://www.google.com");
   std::set<const EventListener*> targets(listeners_->GetEventListeners(*event));
-  ASSERT_EQ(2u, targets.size());
+  ASSERT_EQ(4u, targets.size());
 }
 
-TEST_F(EventListenerMapTest, FilteredEventsOnlyGoToMatchingListeners) {
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("yahoo.com")));
+TEST_P(EventListenerMapWithContextTest,
+       FilteredEventsOnlyGoToMatchingListeners) {
+  const bool is_for_service_worker = GetParam();
+  struct TestCase {
+    const std::string filter_host_suffix;
+    const std::string url_of_event;
+  } kTestCases[] = {
+      {"google.com", "http://www.google.com"},
+      {"yahoo.com", "http://www.yahoo.com"},
+  };
+  for (const TestCase& test_case : kTestCases) {
+    listeners_->AddListener(
+        CreateLazyListener(kEvent1Name, kExt1Id,
+                           CreateHostSuffixFilter(test_case.filter_host_suffix),
+                           is_for_service_worker));
+  }
 
-  std::unique_ptr<Event> event(CreateNamedEvent(kEvent1Name));
-  event->filter_info.url = GURL("http://www.google.com");
-  std::set<const EventListener*> targets(listeners_->GetEventListeners(*event));
-  ASSERT_EQ(1u, targets.size());
-  std::unique_ptr<EventListener> listener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
-  ASSERT_TRUE((*targets.begin())->Equals(listener.get()));
+  // Matching filters.
+  for (const TestCase& test_case : kTestCases) {
+    SCOPED_TRACE(base::StringPrintf("host_suffix = %s, url = %s",
+                                    test_case.filter_host_suffix.c_str(),
+                                    test_case.url_of_event.c_str()));
+    std::unique_ptr<Event> event(
+        CreateEvent(kEvent1Name, GURL(test_case.url_of_event)));
+    std::set<const EventListener*> targets(
+        listeners_->GetEventListeners(*event));
+    ASSERT_EQ(1u, targets.size());
+    EXPECT_TRUE(
+        CreateLazyListener(kEvent1Name, kExt1Id,
+                           CreateHostSuffixFilter(test_case.filter_host_suffix),
+                           is_for_service_worker)
+            ->Equals(*targets.begin()));
+  }
+
+  // Non-matching filter.
+  {
+    std::unique_ptr<Event> event(
+        CreateEvent(kEvent1Name, GURL("http://does_not_match.com")));
+    std::set<const EventListener*> targets(
+        listeners_->GetEventListeners(*event));
+    EXPECT_TRUE(targets.empty());
+  }
 }
 
 TEST_F(EventListenerMapTest, LazyAndUnlazyListenersGetReturned) {
@@ -210,6 +290,11 @@ TEST_F(EventListenerMapTest, TestRemovingByProcessForURL) {
       base::BindRepeating(&CreateEventListenerForURL, GURL(kURL)));
 }
 
+TEST_F(EventListenerMapTest, TestRemovingByProcessForExtensionServiceWorker) {
+  TestRemovingByProcess(base::BindRepeating(
+      &CreateEventListenerForExtensionServiceWorker, kExt1Id));
+}
+
 void EventListenerMapTest::TestRemovingByListener(
     const EventListenerConstructor& constructor) {
   listeners_->AddListener(constructor.Run(
@@ -237,14 +322,23 @@ TEST_F(EventListenerMapTest, TestRemovingByListenerForURL) {
       base::BindRepeating(&CreateEventListenerForURL, GURL(kURL)));
 }
 
-TEST_F(EventListenerMapTest, TestLazyDoubleAddIsUndoneByRemove) {
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
+TEST_F(EventListenerMapTest, TestRemovingByListenerForExtensionServiceWorker) {
+  TestRemovingByListener(base::BindRepeating(
+      &CreateEventListenerForExtensionServiceWorker, kExt1Id));
+}
 
-  std::unique_ptr<EventListener> listener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
+TEST_P(EventListenerMapWithContextTest, TestLazyDoubleAddIsUndoneByRemove) {
+  const bool is_for_service_worker = GetParam();
+  listeners_->AddListener(CreateLazyListener(
+      kEvent1Name, kExt1Id, CreateHostSuffixFilter("google.com"),
+      is_for_service_worker));
+  listeners_->AddListener(CreateLazyListener(
+      kEvent1Name, kExt1Id, CreateHostSuffixFilter("google.com"),
+      is_for_service_worker));
+
+  std::unique_ptr<EventListener> listener = CreateLazyListener(
+      kEvent1Name, kExt1Id, CreateHostSuffixFilter("google.com"),
+      is_for_service_worker);
   listeners_->RemoveListener(listener.get());
 
   std::unique_ptr<Event> event(CreateNamedEvent(kEvent1Name));
@@ -262,10 +356,14 @@ TEST_F(EventListenerMapTest, HostSuffixFilterEquality) {
 }
 
 TEST_F(EventListenerMapTest, RemoveListenersForExtension) {
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent2Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
+  for (bool is_for_service_worker : {false, true}) {
+    listeners_->AddListener(CreateLazyListener(
+        kEvent1Name, kExt1Id, CreateHostSuffixFilter("google.com"),
+        is_for_service_worker));
+    listeners_->AddListener(CreateLazyListener(
+        kEvent2Name, kExt1Id, CreateHostSuffixFilter("google.com"),
+        is_for_service_worker));
+  }
 
   listeners_->RemoveListenersForExtension(kExt1Id);
 
@@ -281,11 +379,15 @@ TEST_F(EventListenerMapTest, RemoveListenersForExtension) {
   ASSERT_EQ(0u, targets.size());
 }
 
-TEST_F(EventListenerMapTest, AddExistingFilteredListener) {
-  bool first_new = listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
-  bool second_new = listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com")));
+TEST_P(EventListenerMapWithContextTest, AddExistingFilteredListener) {
+  const bool is_for_service_worker = GetParam();
+
+  bool first_new = listeners_->AddListener(CreateLazyListener(
+      kEvent1Name, kExt1Id, CreateHostSuffixFilter("google.com"),
+      is_for_service_worker));
+  bool second_new = listeners_->AddListener(CreateLazyListener(
+      kEvent1Name, kExt1Id, CreateHostSuffixFilter("google.com"),
+      is_for_service_worker));
 
   ASSERT_TRUE(first_new);
   ASSERT_FALSE(second_new);
@@ -319,11 +421,20 @@ TEST_F(EventListenerMapTest, AddExistingUnfilteredListenerForURLs) {
       base::BindRepeating(&CreateEventListenerForURL, GURL(kURL)));
 }
 
+TEST_F(EventListenerMapTest,
+       AddExistingUnfilteredListenerForExtensionServiceWorker) {
+  TestAddExistingUnfilteredListener(base::BindRepeating(
+      &CreateEventListenerForExtensionServiceWorker, kExt1Id));
+}
+
 TEST_F(EventListenerMapTest, RemovingRouters) {
   listeners_->AddListener(EventListener::ForExtension(
       kEvent1Name, kExt1Id, process_, std::unique_ptr<DictionaryValue>()));
   listeners_->AddListener(EventListener::ForURL(
       kEvent1Name, GURL(kURL), process_, std::unique_ptr<DictionaryValue>()));
+  listeners_->AddListener(CreateEventListenerForExtensionServiceWorker(
+      kExt1Id, kEvent1Name, process_,
+      std::unique_ptr<base::DictionaryValue>()));
   listeners_->RemoveListenersForProcess(process_);
   ASSERT_FALSE(listeners_->HasListenerForEvent(kEvent1Name));
 }
@@ -351,23 +462,41 @@ TEST_F(EventListenerMapTest, HasListenerForEventForURL) {
       base::BindRepeating(&CreateEventListenerForURL, GURL(kURL)));
 }
 
+TEST_F(EventListenerMapTest, HasListenerForEventForExtensionServiceWorker) {
+  TestHasListenerForEvent(base::BindRepeating(
+      &CreateEventListenerForExtensionServiceWorker, kExt1Id));
+}
+
 TEST_F(EventListenerMapTest, HasListenerForExtension) {
   ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name));
 
-  // Non-lazy listener.
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, process_, std::unique_ptr<DictionaryValue>()));
-  // Lazy listener.
-  listeners_->AddListener(EventListener::ForExtension(
-      kEvent1Name, kExt1Id, nullptr, std::unique_ptr<DictionaryValue>()));
+  auto create_event_listener = [&](bool is_for_service_worker, bool lazy) {
+    auto filter = std::unique_ptr<base::DictionaryValue>();
+    if (is_for_service_worker) {
+      return EventListener::ForExtensionServiceWorker(
+          kEvent1Name, kExt1Id, lazy ? nullptr : process_,
+          Extension::GetBaseURLFromExtensionId(kExt1Id),
+          GetWorkerVersionId(lazy), GetWorkerThreadId(lazy), std::move(filter));
+    }
+    return EventListener::ForExtension(
+        kEvent1Name, kExt1Id, lazy ? nullptr : process_, std::move(filter));
+  };
 
-  ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent2Name));
-  ASSERT_TRUE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name));
-  ASSERT_FALSE(listeners_->HasListenerForExtension(kExt2Id, kEvent1Name));
-  listeners_->RemoveListenersForProcess(process_);
-  ASSERT_TRUE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name));
-  listeners_->RemoveListenersForExtension(kExt1Id);
-  ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name));
+  for (bool is_for_service_worker : {false, true}) {
+    // Non-lazy listener.
+    listeners_->AddListener(
+        create_event_listener(is_for_service_worker, false));
+    // Lazy listener.
+    listeners_->AddListener(create_event_listener(is_for_service_worker, true));
+
+    ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent2Name));
+    ASSERT_TRUE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name));
+    ASSERT_FALSE(listeners_->HasListenerForExtension(kExt2Id, kEvent1Name));
+    listeners_->RemoveListenersForProcess(process_);
+    ASSERT_TRUE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name));
+    listeners_->RemoveListenersForExtension(kExt1Id);
+    ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name));
+  }
 }
 
 TEST_F(EventListenerMapTest, AddLazyListenersFromPreferences) {
@@ -398,10 +527,11 @@ TEST_F(EventListenerMapTest, AddLazyListenersFromPreferences) {
     std::set<const EventListener*> targets(
         listeners_->GetEventListeners(*event));
     ASSERT_EQ(1u, targets.size());
-    EXPECT_TRUE(CreateLazyListener(kEvent1Name, kExt1Id,
-                                   test_case.filter_host_suffix,
-                                   is_for_service_worker)
-                    ->Equals(*targets.begin()));
+    EXPECT_TRUE(
+        CreateLazyListener(kEvent1Name, kExt1Id,
+                           CreateHostSuffixFilter(test_case.filter_host_suffix),
+                           is_for_service_worker)
+            ->Equals(*targets.begin()));
   }
 
   // Non-matching filter.
@@ -420,6 +550,7 @@ TEST_F(EventListenerMapTest, CorruptedExtensionPrefsShouldntCrash) {
   filtered_listeners.Set(kEvent1Name, CreateHostSuffixFilter("google.com"));
 
   listeners_->LoadFilteredLazyListeners(kExt1Id, false, filtered_listeners);
+  listeners_->LoadFilteredLazyListeners(kExt1Id, true, filtered_listeners);
 
   std::unique_ptr<Event> event(
       CreateEvent(kEvent1Name, GURL("http://www.google.com")));
@@ -427,6 +558,13 @@ TEST_F(EventListenerMapTest, CorruptedExtensionPrefsShouldntCrash) {
   ASSERT_EQ(0u, targets.size());
 }
 
+INSTANTIATE_TEST_SUITE_P(NonServiceWorker,
+                         EventListenerMapWithContextTest,
+                         testing::Values(false));
+INSTANTIATE_TEST_SUITE_P(ServiceWorker,
+                         EventListenerMapWithContextTest,
+                         testing::Values(true));
+
 }  // namespace
 
 }  // namespace extensions

extensions/browser/event_router_unittest.cc

@@ -91,6 +91,19 @@ std::unique_ptr<EventListener> CreateEventListenerForURL(
                                std::move(filter));
 }
 
+std::unique_ptr<EventListener> CreateEventListenerForExtensionServiceWorker(
+    const std::string& extension_id,
+    int64_t service_worker_version_id,
+    int worker_thread_id,
+    const std::string& event_name,
+    content::RenderProcessHost* process,
+    std::unique_ptr<base::DictionaryValue> filter) {
+  return EventListener::ForExtensionServiceWorker(
+      event_name, extension_id, process,
+      Extension::GetBaseURLFromExtensionId(extension_id),
+      service_worker_version_id, worker_thread_id, std::move(filter));
+}
+
 // Creates an extension.  If |component| is true, it is created as a component
 // extension.  If |persistent| is true, it is created with a persistent
 // background page; otherwise it is created with an event page.
@@ -314,6 +327,13 @@ TEST_F(EventRouterTest, EventRouterObserverForURLs) {
       &CreateEventListenerForURL, GURL("http://google.com/path")));
 }
 
+TEST_F(EventRouterTest, EventRouterObserverForServiceWorkers) {
+  RunEventRouterObserverTest(base::BindRepeating(
+      &CreateEventListenerForExtensionServiceWorker, "extension_id",
+      // Dummy version_id and thread_id.
+      99, 199));
+}
+
 TEST_F(EventRouterTest, TestReportEvent) {
   EventRouter router(browser_context(), nullptr);
   scoped_refptr<const Extension> normal = ExtensionBuilder("Test").Build();