extensions/browser/event_router_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/event_router.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/values.h"
  13 #include "content/public/browser/notification_service.h"
  14 #include "extensions/browser/event_listener_map.h"
  15 #include "extensions/browser/extensions_test.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace extensions {
  19
  20 namespace {
  21
  22 // A simple mock to keep track of listener additions and removals.
  23 class MockEventRouterObserver : public EventRouter::Observer {
  24  public:
  25   MockEventRouterObserver()
  26       : listener_added_count_(0),
  27         listener_removed_count_(0) {}
  28   virtual ~MockEventRouterObserver() {}
  29
  30   int listener_added_count() const { return listener_added_count_; }
  31   int listener_removed_count() const { return listener_removed_count_; }
  32   const std::string& last_event_name() const { return last_event_name_; }
  33
  34   void Reset() {
  35     listener_added_count_ = 0;
  36     listener_removed_count_ = 0;
  37     last_event_name_.clear();
  38   }
  39
  40   // EventRouter::Observer overrides:
  41   virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE {
  42     listener_added_count_++;
  43     last_event_name_ = details.event_name;
  44   }
  45
  46   virtual void OnListenerRemoved(const EventListenerInfo& details) OVERRIDE {
  47     listener_removed_count_++;
  48     last_event_name_ = details.event_name;
  49   }
  50
  51  private:
  52   int listener_added_count_;
  53   int listener_removed_count_;
  54   std::string last_event_name_;
  55
  56   DISALLOW_COPY_AND_ASSIGN(MockEventRouterObserver);
  57 };
  58
  59 typedef base::Callback<scoped_ptr<EventListener>(
  60     const std::string&,           // event_name
  61     content::RenderProcessHost*,  // process
  62     base::DictionaryValue*        // filter (takes ownership)
  63     )> EventListenerConstructor;
  64
  65 scoped_ptr<EventListener> CreateEventListenerForExtension(
  66     const std::string& extension_id,
  67     const std::string& event_name,
  68     content::RenderProcessHost* process,
  69     base::DictionaryValue* filter) {
  70   return EventListener::ForExtension(
  71       event_name, extension_id, process, make_scoped_ptr(filter));
  72 }
  73
  74 scoped_ptr<EventListener> CreateEventListenerForURL(
  75     const GURL& listener_url,
  76     const std::string& event_name,
  77     content::RenderProcessHost* process,
  78     base::DictionaryValue* filter) {
  79   return EventListener::ForURL(
  80       event_name, listener_url, process, make_scoped_ptr(filter));
  81 }
  82
  83 }  // namespace
  84
  85 class EventRouterTest : public ExtensionsTest {
  86  public:
  87   EventRouterTest()
  88       : notification_service_(content::NotificationService::Create()) {}
  89
  90  protected:
  91   // Tests adding and removing observers from EventRouter.
  92   void RunEventRouterObserverTest(const EventListenerConstructor& constructor);
  93
  94  private:
  95   scoped_ptr<content::NotificationService> notification_service_;
  96
  97   DISALLOW_COPY_AND_ASSIGN(EventRouterTest);
  98 };
  99
 100 TEST_F(EventRouterTest, GetBaseEventName) {
 101   // Normal event names are passed through unchanged.
 102   EXPECT_EQ("foo.onBar", EventRouter::GetBaseEventName("foo.onBar"));
 103
 104   // Sub-events are converted to the part before the slash.
 105   EXPECT_EQ("foo.onBar", EventRouter::GetBaseEventName("foo.onBar/123"));
 106 }
 107
 108 // Tests adding and removing observers from EventRouter.
 109 void EventRouterTest::RunEventRouterObserverTest(
 110     const EventListenerConstructor& constructor) {
 111   EventRouter router(NULL, NULL);
 112   scoped_ptr<EventListener> listener =
 113       constructor.Run("event_name", NULL, new base::DictionaryValue());
 114
 115   // Add/remove works without any observers.
 116   router.OnListenerAdded(listener.get());
 117   router.OnListenerRemoved(listener.get());
 118
 119   // Register observers that both match and don't match the event above.
 120   MockEventRouterObserver matching_observer;
 121   router.RegisterObserver(&matching_observer, "event_name");
 122   MockEventRouterObserver non_matching_observer;
 123   router.RegisterObserver(&non_matching_observer, "other");
 124
 125   // Adding a listener notifies the appropriate observers.
 126   router.OnListenerAdded(listener.get());
 127   EXPECT_EQ(1, matching_observer.listener_added_count());
 128   EXPECT_EQ(0, non_matching_observer.listener_added_count());
 129
 130   // Removing a listener notifies the appropriate observers.
 131   router.OnListenerRemoved(listener.get());
 132   EXPECT_EQ(1, matching_observer.listener_removed_count());
 133   EXPECT_EQ(0, non_matching_observer.listener_removed_count());
 134
 135   // Adding the listener again notifies again.
 136   router.OnListenerAdded(listener.get());
 137   EXPECT_EQ(2, matching_observer.listener_added_count());
 138   EXPECT_EQ(0, non_matching_observer.listener_added_count());
 139
 140   // Removing the listener again notifies again.
 141   router.OnListenerRemoved(listener.get());
 142   EXPECT_EQ(2, matching_observer.listener_removed_count());
 143   EXPECT_EQ(0, non_matching_observer.listener_removed_count());
 144
 145   // Adding a listener with a sub-event notifies the main observer with
 146   // proper details.
 147   matching_observer.Reset();
 148   scoped_ptr<EventListener> sub_event_listener =
 149       constructor.Run("event_name/1", NULL, new base::DictionaryValue());
 150   router.OnListenerAdded(sub_event_listener.get());
 151   EXPECT_EQ(1, matching_observer.listener_added_count());
 152   EXPECT_EQ(0, matching_observer.listener_removed_count());
 153   EXPECT_EQ("event_name/1", matching_observer.last_event_name());
 154
 155   // Ditto for removing the listener.
 156   matching_observer.Reset();
 157   router.OnListenerRemoved(sub_event_listener.get());
 158   EXPECT_EQ(0, matching_observer.listener_added_count());
 159   EXPECT_EQ(1, matching_observer.listener_removed_count());
 160   EXPECT_EQ("event_name/1", matching_observer.last_event_name());
 161 }
 162
 163 TEST_F(EventRouterTest, EventRouterObserverForExtensions) {
 164   RunEventRouterObserverTest(
 165       base::Bind(&CreateEventListenerForExtension, "extension_id"));
 166 }
 167
 168 TEST_F(EventRouterTest, EventRouterObserverForURLs) {
 169   RunEventRouterObserverTest(
 170       base::Bind(&CreateEventListenerForURL, GURL("http://google.com/path")));
 171 }
 172
 173 }  // namespace extensions