Filtered events.

chrome/browser/extensions/event_listener_map_unittest.cc

Index: chrome/browser/extensions/event_listener_map_unittest.cc
diff --git a/chrome/browser/extensions/event_listener_map_unittest.cc b/chrome/browser/extensions/event_listener_map_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e8e9f7c50935b2d9a6fbddded406cb63348dec9b
--- /dev/null
+++ b/chrome/browser/extensions/event_listener_map_unittest.cc
@@ -0,0 +1,239 @@
+// 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 "testing/gtest/include/gtest/gtest.h"
+
+#include "chrome/browser/extensions/event_listener_map.h"
+#include "chrome/browser/extensions/extension_event_router.h"
+#include "content/public/test/mock_render_process_host.h"
+
+class EventListenerMapUnittest : public testing::Test {
+ public:
+  EventListenerMapUnittest()
+    : listeners_(new EventListenerMap),
+      process_(new content::MockRenderProcessHost(NULL)) {
+  }
+
+  scoped_ptr<DictionaryValue> HostSuffixFilter(const std::string& suffix) {
+    scoped_ptr<DictionaryValue> filter(new DictionaryValue);
+    scoped_ptr<ListValue> filter_list(new ListValue);
+    scoped_ptr<DictionaryValue> filter_dict(new DictionaryValue);
+
+    filter_dict->Set("hostSuffix", new StringValue(suffix));
+
+    filter_list->Append(filter_dict.release());
+    filter->Set("url", filter_list.release());
+    return filter.Pass();
+  }
+
+  scoped_ptr<ExtensionEvent> GetNamedEvent(const std::string event_name) {
+    scoped_ptr<ExtensionEvent> result(new ExtensionEvent(event_name, "", GURL(),
+        NULL, "", ExtensionEventRouter::USER_GESTURE_UNKNOWN,
+        EventFilteringInfo()));
+    return result.Pass();
+  }
+
+ protected:
+  scoped_ptr<EventListenerMap> listeners_;
+  scoped_ptr<content::MockRenderProcessHost> process_;
+};
+
+TEST_F(EventListenerMapUnittest, UnfilteredEventsGoToAllListeners) {
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, scoped_ptr<DictionaryValue>())));
+
+  scoped_ptr<ExtensionEvent> event(GetNamedEvent("event"));
+  scoped_ptr<std::set<const EventListener*> > targets(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(1u, targets->size());
+}
+
+TEST_F(EventListenerMapUnittest, FilteredEventsGoToAllMatchingListeners) {
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("google.com"))));
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, scoped_ptr<DictionaryValue>(new DictionaryValue))));
+
+  scoped_ptr<ExtensionEvent> event(GetNamedEvent("event"));
+  event->info.SetURL(GURL("http://www.google.com"));
+  scoped_ptr<std::set<const EventListener*> > targets(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(2u, targets->size());
+}
+
+TEST_F(EventListenerMapUnittest, FilteredEventsOnlyGoToMatchingListeners) {
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("google.com"))));
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("yahoo.com"))));
+
+  scoped_ptr<ExtensionEvent> event(GetNamedEvent("event"));
+  event->info.SetURL(GURL("http://www.google.com"));
+  scoped_ptr<std::set<const EventListener*> > targets(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(1u, targets->size());
+}
+
+TEST_F(EventListenerMapUnittest, LazyAndUnlazyListenersGetReturned) {
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("google.com"))));
+
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", process_.get(), HostSuffixFilter("google.com"))));
+
+  scoped_ptr<ExtensionEvent> event(GetNamedEvent("event"));
+  event->info.SetURL(GURL("http://www.google.com"));
+  scoped_ptr<std::set<const EventListener*> > targets(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(2u, targets->size());
+}
+
+TEST_F(EventListenerMapUnittest, TestRemovingByProcess) {
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("google.com"))));
+
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", process_.get(), HostSuffixFilter("google.com"))));
+
+  listeners_->RemoveListenersForProcess(process_.get());
+
+  scoped_ptr<ExtensionEvent> event(GetNamedEvent("event"));
+  event->info.SetURL(GURL("http://www.google.com"));
+  scoped_ptr<std::set<const EventListener*> > targets(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(1u, targets->size());
+}
+
+TEST_F(EventListenerMapUnittest, TestRemovingByListener) {
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("google.com"))));
+
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", process_.get(), HostSuffixFilter("google.com"))));
+
+  listeners_->RemoveListener(scoped_ptr<EventListener>(new EventListener(
+      "event", "1", process_.get(), HostSuffixFilter("google.com"))));
+
+  scoped_ptr<ExtensionEvent> event(GetNamedEvent("event"));
+  event->info.SetURL(GURL("http://www.google.com"));
+  scoped_ptr<std::set<const EventListener*> > targets(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(1u, targets->size());
+}
+
+TEST_F(EventListenerMapUnittest, TestLazyDoubleAddIsUndoneByRemove) {
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("google.com"))));
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("google.com"))));
+
+  listeners_->RemoveListener(scoped_ptr<EventListener>(new EventListener(
+      "event", "1", NULL, HostSuffixFilter("google.com"))));
+
+  scoped_ptr<ExtensionEvent> event(GetNamedEvent("event"));
+  event->info.SetURL(GURL("http://www.google.com"));
+  scoped_ptr<std::set<const EventListener*> > targets(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(0u, targets->size());
+}
+
+TEST_F(EventListenerMapUnittest, HostSuffixFilterEquality) {
+  scoped_ptr<DictionaryValue> filter1(HostSuffixFilter("google.com"));
+  scoped_ptr<DictionaryValue> filter2(HostSuffixFilter("google.com"));
+  ASSERT_TRUE(filter1->Equals(filter2.get()));
+}
+
+TEST_F(EventListenerMapUnittest, RemoveLazyListenersFor) {
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event",
+      "1", NULL, HostSuffixFilter("google.com"))));
+  listeners_->AddListener(scoped_ptr<EventListener>(new EventListener("event2",
+      "1", NULL, HostSuffixFilter("google.com"))));
+
+  listeners_->RemoveLazyListenersFor("1");
+
+  scoped_ptr<ExtensionEvent> event(GetNamedEvent("event"));
+  event->info.SetURL(GURL("http://www.google.com"));
+  scoped_ptr<std::set<const EventListener*> > targets(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(0u, targets->size());
+
+  event->event_name = "event2";
+  scoped_ptr<std::set<const EventListener*> > targets2(
+      listeners_->GetEventTargets(*event));
+  ASSERT_EQ(0u, targets2->size());
+}
+
+TEST_F(EventListenerMapUnittest, AddExistingFilteredListener) {
+  bool first_new = listeners_->AddListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", NULL, HostSuffixFilter("google.com"))));
+  bool second_new = listeners_->AddListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", NULL, HostSuffixFilter("google.com"))));
+
+  ASSERT_TRUE(first_new);
+  ASSERT_FALSE(second_new);
+}
+
+TEST_F(EventListenerMapUnittest, AddExistingUnfilteredListener) {
+  bool first_add = listeners_->AddListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", NULL, scoped_ptr<DictionaryValue>())));
+  bool second_add = listeners_->AddListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", NULL, scoped_ptr<DictionaryValue>())));
+
+  bool first_remove = listeners_->RemoveListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", NULL, scoped_ptr<DictionaryValue>())));
+  bool second_remove = listeners_->RemoveListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", NULL, scoped_ptr<DictionaryValue>())));
+
+  ASSERT_TRUE(first_add);
+  ASSERT_FALSE(second_add);
+  ASSERT_TRUE(first_remove);
+  ASSERT_FALSE(second_remove);
+}
+
+TEST_F(EventListenerMapUnittest, RemovingRouters) {
+  listeners_->AddListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", process_.get(),
+                        scoped_ptr<DictionaryValue>())));
+  std::vector<linked_ptr<EventListener> > removed =
+      listeners_->RemoveListenersForProcess(process_.get());
+
+  scoped_ptr<EventListener> listener(new EventListener("event", "1",
+      process_.get(), scoped_ptr<DictionaryValue>()));
+  ASSERT_EQ(1u, removed.size());
+  ASSERT_TRUE(removed[0]->Equals(listener.get()));
+}
+
+TEST_F(EventListenerMapUnittest, AnyListenersForEvent) {
+  ASSERT_FALSE(listeners_->AnyListenersForEvent("event"));
+
+  listeners_->AddListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", process_.get(),
+                        scoped_ptr<DictionaryValue>())));
+
+  ASSERT_FALSE(listeners_->AnyListenersForEvent("event2"));
+  ASSERT_TRUE(listeners_->AnyListenersForEvent("event"));
+  listeners_->RemoveListenersForProcess(process_.get());
+  ASSERT_FALSE(listeners_->AnyListenersForEvent("event"));
+}
+
+TEST_F(EventListenerMapUnittest, AnyListenersForExtension) {
+  ASSERT_FALSE(listeners_->AnyListenersForExtension("1", "event"));
+
+  // Non-lazy listener.
+  listeners_->AddListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", process_.get(),
+                        scoped_ptr<DictionaryValue>())));
+  // Lazy listener.
+  listeners_->AddListener(scoped_ptr<EventListener>(
+      new EventListener("event", "1", NULL,
+                        scoped_ptr<DictionaryValue>())));
+
+  ASSERT_FALSE(listeners_->AnyListenersForExtension("1", "event2"));
+  ASSERT_TRUE(listeners_->AnyListenersForExtension("1", "event"));
+  ASSERT_FALSE(listeners_->AnyListenersForExtension("2", "event"));
+  listeners_->RemoveListenersForProcess(process_.get());
+  ASSERT_TRUE(listeners_->AnyListenersForExtension("1", "event"));
+  listeners_->RemoveLazyListenersFor("1");
+  ASSERT_FALSE(listeners_->AnyListenersForExtension("1", "event"));
+}