OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "extensions/browser/event_listener_map.h" | 5 #include "extensions/browser/event_listener_map.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "content/public/test/mock_render_process_host.h" | 8 #include "content/public/test/mock_render_process_host.h" |
9 #include "content/public/test/test_browser_context.h" | 9 #include "content/public/test/test_browser_context.h" |
10 #include "extensions/browser/event_router.h" | 10 #include "extensions/browser/event_router.h" |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
59 | 59 |
60 scoped_ptr<Event> CreateNamedEvent(const std::string& event_name) { | 60 scoped_ptr<Event> CreateNamedEvent(const std::string& event_name) { |
61 return CreateEvent(event_name, GURL()); | 61 return CreateEvent(event_name, GURL()); |
62 } | 62 } |
63 | 63 |
64 scoped_ptr<Event> CreateEvent(const std::string& event_name, | 64 scoped_ptr<Event> CreateEvent(const std::string& event_name, |
65 const GURL& url) { | 65 const GURL& url) { |
66 EventFilteringInfo info; | 66 EventFilteringInfo info; |
67 info.SetURL(url); | 67 info.SetURL(url); |
68 scoped_ptr<Event> result(new Event(event_name, | 68 scoped_ptr<Event> result(new Event(event_name, |
69 make_scoped_ptr(new ListValue()), NULL, GURL(), | 69 make_scoped_ptr(new ListValue()), |
70 EventRouter::USER_GESTURE_UNKNOWN, info)); | 70 nullptr, |
| 71 GURL(), |
| 72 EventRouter::USER_GESTURE_UNKNOWN, |
| 73 info)); |
71 return result.Pass(); | 74 return result.Pass(); |
72 } | 75 } |
73 | 76 |
74 protected: | 77 protected: |
75 void TestUnfilteredEventsGoToAllListeners( | 78 void TestUnfilteredEventsGoToAllListeners( |
76 const EventListenerConstructor& constructor); | 79 const EventListenerConstructor& constructor); |
77 void TestRemovingByProcess(const EventListenerConstructor& constructor); | 80 void TestRemovingByProcess(const EventListenerConstructor& constructor); |
78 void TestRemovingByListener(const EventListenerConstructor& constructor); | 81 void TestRemovingByListener(const EventListenerConstructor& constructor); |
79 void TestAddExistingUnfilteredListener( | 82 void TestAddExistingUnfilteredListener( |
80 const EventListenerConstructor& constructor); | 83 const EventListenerConstructor& constructor); |
(...skipping 19 matching lines...) Expand all Loading... |
100 const std::string& event_name, | 103 const std::string& event_name, |
101 content::RenderProcessHost* process, | 104 content::RenderProcessHost* process, |
102 base::DictionaryValue* filter) { | 105 base::DictionaryValue* filter) { |
103 return EventListener::ForURL( | 106 return EventListener::ForURL( |
104 event_name, listener_url, process, make_scoped_ptr(filter)); | 107 event_name, listener_url, process, make_scoped_ptr(filter)); |
105 } | 108 } |
106 | 109 |
107 void EventListenerMapTest::TestUnfilteredEventsGoToAllListeners( | 110 void EventListenerMapTest::TestUnfilteredEventsGoToAllListeners( |
108 const EventListenerConstructor& constructor) { | 111 const EventListenerConstructor& constructor) { |
109 listeners_->AddListener( | 112 listeners_->AddListener( |
110 constructor.Run(kEvent1Name, NULL, new DictionaryValue())); | 113 constructor.Run(kEvent1Name, nullptr, new DictionaryValue())); |
111 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); | 114 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); |
112 ASSERT_EQ(1u, listeners_->GetEventListeners(*event).size()); | 115 ASSERT_EQ(1u, listeners_->GetEventListeners(*event).size()); |
113 } | 116 } |
114 | 117 |
115 TEST_F(EventListenerMapTest, UnfilteredEventsGoToAllListenersForExtensions) { | 118 TEST_F(EventListenerMapTest, UnfilteredEventsGoToAllListenersForExtensions) { |
116 TestUnfilteredEventsGoToAllListeners( | 119 TestUnfilteredEventsGoToAllListeners( |
117 base::Bind(&CreateEventListenerForExtension, kExt1Id)); | 120 base::Bind(&CreateEventListenerForExtension, kExt1Id)); |
118 } | 121 } |
119 | 122 |
120 TEST_F(EventListenerMapTest, UnfilteredEventsGoToAllListenersForURLs) { | 123 TEST_F(EventListenerMapTest, UnfilteredEventsGoToAllListenersForURLs) { |
121 TestUnfilteredEventsGoToAllListeners( | 124 TestUnfilteredEventsGoToAllListeners( |
122 base::Bind(&CreateEventListenerForURL, GURL(kURL))); | 125 base::Bind(&CreateEventListenerForURL, GURL(kURL))); |
123 } | 126 } |
124 | 127 |
125 TEST_F(EventListenerMapTest, FilteredEventsGoToAllMatchingListeners) { | 128 TEST_F(EventListenerMapTest, FilteredEventsGoToAllMatchingListeners) { |
126 listeners_->AddListener(EventListener::ForExtension( | 129 listeners_->AddListener(EventListener::ForExtension( |
127 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 130 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
128 listeners_->AddListener(EventListener::ForExtension( | 131 listeners_->AddListener(EventListener::ForExtension( |
129 kEvent1Name, | 132 kEvent1Name, |
130 kExt1Id, | 133 kExt1Id, |
131 NULL, | 134 nullptr, |
132 scoped_ptr<DictionaryValue>(new DictionaryValue))); | 135 scoped_ptr<DictionaryValue>(new DictionaryValue))); |
133 | 136 |
134 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); | 137 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); |
135 event->filter_info.SetURL(GURL("http://www.google.com")); | 138 event->filter_info.SetURL(GURL("http://www.google.com")); |
136 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); | 139 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); |
137 ASSERT_EQ(2u, targets.size()); | 140 ASSERT_EQ(2u, targets.size()); |
138 } | 141 } |
139 | 142 |
140 TEST_F(EventListenerMapTest, FilteredEventsOnlyGoToMatchingListeners) { | 143 TEST_F(EventListenerMapTest, FilteredEventsOnlyGoToMatchingListeners) { |
141 listeners_->AddListener(EventListener::ForExtension( | 144 listeners_->AddListener(EventListener::ForExtension( |
142 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 145 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
143 listeners_->AddListener(EventListener::ForExtension( | 146 listeners_->AddListener(EventListener::ForExtension( |
144 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("yahoo.com"))); | 147 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("yahoo.com"))); |
145 | 148 |
146 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); | 149 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); |
147 event->filter_info.SetURL(GURL("http://www.google.com")); | 150 event->filter_info.SetURL(GURL("http://www.google.com")); |
148 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); | 151 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); |
149 ASSERT_EQ(1u, targets.size()); | 152 ASSERT_EQ(1u, targets.size()); |
150 } | 153 } |
151 | 154 |
152 TEST_F(EventListenerMapTest, LazyAndUnlazyListenersGetReturned) { | 155 TEST_F(EventListenerMapTest, LazyAndUnlazyListenersGetReturned) { |
153 listeners_->AddListener(EventListener::ForExtension( | 156 listeners_->AddListener(EventListener::ForExtension( |
154 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 157 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
155 | 158 |
156 listeners_->AddListener( | 159 listeners_->AddListener( |
157 EventListener::ForExtension(kEvent1Name, | 160 EventListener::ForExtension(kEvent1Name, |
158 kExt1Id, | 161 kExt1Id, |
159 process_.get(), | 162 process_.get(), |
160 CreateHostSuffixFilter("google.com"))); | 163 CreateHostSuffixFilter("google.com"))); |
161 | 164 |
162 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); | 165 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); |
163 event->filter_info.SetURL(GURL("http://www.google.com")); | 166 event->filter_info.SetURL(GURL("http://www.google.com")); |
164 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); | 167 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); |
165 ASSERT_EQ(2u, targets.size()); | 168 ASSERT_EQ(2u, targets.size()); |
166 } | 169 } |
167 | 170 |
168 void EventListenerMapTest::TestRemovingByProcess( | 171 void EventListenerMapTest::TestRemovingByProcess( |
169 const EventListenerConstructor& constructor) { | 172 const EventListenerConstructor& constructor) { |
170 listeners_->AddListener(constructor.Run( | 173 listeners_->AddListener(constructor.Run( |
171 kEvent1Name, NULL, CreateHostSuffixFilter("google.com").release())); | 174 kEvent1Name, nullptr, CreateHostSuffixFilter("google.com").release())); |
172 | 175 |
173 listeners_->AddListener( | 176 listeners_->AddListener( |
174 constructor.Run(kEvent1Name, | 177 constructor.Run(kEvent1Name, |
175 process_.get(), | 178 process_.get(), |
176 CreateHostSuffixFilter("google.com").release())); | 179 CreateHostSuffixFilter("google.com").release())); |
177 | 180 |
178 listeners_->RemoveListenersForProcess(process_.get()); | 181 listeners_->RemoveListenersForProcess(process_.get()); |
179 | 182 |
180 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); | 183 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); |
181 event->filter_info.SetURL(GURL("http://www.google.com")); | 184 event->filter_info.SetURL(GURL("http://www.google.com")); |
182 ASSERT_EQ(1u, listeners_->GetEventListeners(*event).size()); | 185 ASSERT_EQ(1u, listeners_->GetEventListeners(*event).size()); |
183 } | 186 } |
184 | 187 |
185 TEST_F(EventListenerMapTest, TestRemovingByProcessForExtension) { | 188 TEST_F(EventListenerMapTest, TestRemovingByProcessForExtension) { |
186 TestRemovingByProcess(base::Bind(&CreateEventListenerForExtension, kExt1Id)); | 189 TestRemovingByProcess(base::Bind(&CreateEventListenerForExtension, kExt1Id)); |
187 } | 190 } |
188 | 191 |
189 TEST_F(EventListenerMapTest, TestRemovingByProcessForURL) { | 192 TEST_F(EventListenerMapTest, TestRemovingByProcessForURL) { |
190 TestRemovingByProcess(base::Bind(&CreateEventListenerForURL, GURL(kURL))); | 193 TestRemovingByProcess(base::Bind(&CreateEventListenerForURL, GURL(kURL))); |
191 } | 194 } |
192 | 195 |
193 void EventListenerMapTest::TestRemovingByListener( | 196 void EventListenerMapTest::TestRemovingByListener( |
194 const EventListenerConstructor& constructor) { | 197 const EventListenerConstructor& constructor) { |
195 listeners_->AddListener(constructor.Run( | 198 listeners_->AddListener(constructor.Run( |
196 kEvent1Name, NULL, CreateHostSuffixFilter("google.com").release())); | 199 kEvent1Name, nullptr, CreateHostSuffixFilter("google.com").release())); |
197 | 200 |
198 listeners_->AddListener( | 201 listeners_->AddListener( |
199 constructor.Run(kEvent1Name, | 202 constructor.Run(kEvent1Name, |
200 process_.get(), | 203 process_.get(), |
201 CreateHostSuffixFilter("google.com").release())); | 204 CreateHostSuffixFilter("google.com").release())); |
202 | 205 |
203 scoped_ptr<EventListener> listener( | 206 scoped_ptr<EventListener> listener( |
204 constructor.Run(kEvent1Name, | 207 constructor.Run(kEvent1Name, |
205 process_.get(), | 208 process_.get(), |
206 CreateHostSuffixFilter("google.com").release())); | 209 CreateHostSuffixFilter("google.com").release())); |
207 listeners_->RemoveListener(listener.get()); | 210 listeners_->RemoveListener(listener.get()); |
208 | 211 |
209 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); | 212 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); |
210 event->filter_info.SetURL(GURL("http://www.google.com")); | 213 event->filter_info.SetURL(GURL("http://www.google.com")); |
211 ASSERT_EQ(1u, listeners_->GetEventListeners(*event).size()); | 214 ASSERT_EQ(1u, listeners_->GetEventListeners(*event).size()); |
212 } | 215 } |
213 | 216 |
214 TEST_F(EventListenerMapTest, TestRemovingByListenerForExtension) { | 217 TEST_F(EventListenerMapTest, TestRemovingByListenerForExtension) { |
215 TestRemovingByListener(base::Bind(&CreateEventListenerForExtension, kExt1Id)); | 218 TestRemovingByListener(base::Bind(&CreateEventListenerForExtension, kExt1Id)); |
216 } | 219 } |
217 | 220 |
218 TEST_F(EventListenerMapTest, TestRemovingByListenerForURL) { | 221 TEST_F(EventListenerMapTest, TestRemovingByListenerForURL) { |
219 TestRemovingByListener(base::Bind(&CreateEventListenerForURL, GURL(kURL))); | 222 TestRemovingByListener(base::Bind(&CreateEventListenerForURL, GURL(kURL))); |
220 } | 223 } |
221 | 224 |
222 TEST_F(EventListenerMapTest, TestLazyDoubleAddIsUndoneByRemove) { | 225 TEST_F(EventListenerMapTest, TestLazyDoubleAddIsUndoneByRemove) { |
223 listeners_->AddListener(EventListener::ForExtension( | 226 listeners_->AddListener(EventListener::ForExtension( |
224 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 227 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
225 listeners_->AddListener(EventListener::ForExtension( | 228 listeners_->AddListener(EventListener::ForExtension( |
226 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 229 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
227 | 230 |
228 scoped_ptr<EventListener> listener(EventListener::ForExtension( | 231 scoped_ptr<EventListener> listener(EventListener::ForExtension( |
229 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 232 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
230 listeners_->RemoveListener(listener.get()); | 233 listeners_->RemoveListener(listener.get()); |
231 | 234 |
232 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); | 235 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); |
233 event->filter_info.SetURL(GURL("http://www.google.com")); | 236 event->filter_info.SetURL(GURL("http://www.google.com")); |
234 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); | 237 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); |
235 ASSERT_EQ(0u, targets.size()); | 238 ASSERT_EQ(0u, targets.size()); |
236 } | 239 } |
237 | 240 |
238 TEST_F(EventListenerMapTest, HostSuffixFilterEquality) { | 241 TEST_F(EventListenerMapTest, HostSuffixFilterEquality) { |
239 scoped_ptr<DictionaryValue> filter1(CreateHostSuffixFilter("google.com")); | 242 scoped_ptr<DictionaryValue> filter1(CreateHostSuffixFilter("google.com")); |
240 scoped_ptr<DictionaryValue> filter2(CreateHostSuffixFilter("google.com")); | 243 scoped_ptr<DictionaryValue> filter2(CreateHostSuffixFilter("google.com")); |
241 ASSERT_TRUE(filter1->Equals(filter2.get())); | 244 ASSERT_TRUE(filter1->Equals(filter2.get())); |
242 } | 245 } |
243 | 246 |
244 TEST_F(EventListenerMapTest, RemoveLazyListeners) { | 247 TEST_F(EventListenerMapTest, RemoveLazyListeners) { |
245 listeners_->AddListener(EventListener::ForExtension( | 248 listeners_->AddListener(EventListener::ForExtension( |
246 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 249 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
247 listeners_->AddListener(EventListener::ForExtension( | 250 listeners_->AddListener(EventListener::ForExtension( |
248 kEvent2Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 251 kEvent2Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
249 | 252 |
250 listeners_->RemoveLazyListenersForExtension(kExt1Id); | 253 listeners_->RemoveLazyListenersForExtension(kExt1Id); |
251 | 254 |
252 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); | 255 scoped_ptr<Event> event(CreateNamedEvent(kEvent1Name)); |
253 event->filter_info.SetURL(GURL("http://www.google.com")); | 256 event->filter_info.SetURL(GURL("http://www.google.com")); |
254 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); | 257 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); |
255 ASSERT_EQ(0u, targets.size()); | 258 ASSERT_EQ(0u, targets.size()); |
256 | 259 |
257 event->event_name = kEvent2Name; | 260 event->event_name = kEvent2Name; |
258 targets = listeners_->GetEventListeners(*event); | 261 targets = listeners_->GetEventListeners(*event); |
259 ASSERT_EQ(0u, targets.size()); | 262 ASSERT_EQ(0u, targets.size()); |
260 } | 263 } |
261 | 264 |
262 TEST_F(EventListenerMapTest, AddExistingFilteredListener) { | 265 TEST_F(EventListenerMapTest, AddExistingFilteredListener) { |
263 bool first_new = listeners_->AddListener(EventListener::ForExtension( | 266 bool first_new = listeners_->AddListener(EventListener::ForExtension( |
264 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 267 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
265 bool second_new = listeners_->AddListener(EventListener::ForExtension( | 268 bool second_new = listeners_->AddListener(EventListener::ForExtension( |
266 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 269 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
267 | 270 |
268 ASSERT_TRUE(first_new); | 271 ASSERT_TRUE(first_new); |
269 ASSERT_FALSE(second_new); | 272 ASSERT_FALSE(second_new); |
270 } | 273 } |
271 | 274 |
272 void EventListenerMapTest::TestAddExistingUnfilteredListener( | 275 void EventListenerMapTest::TestAddExistingUnfilteredListener( |
273 const EventListenerConstructor& constructor) { | 276 const EventListenerConstructor& constructor) { |
274 bool first_add = listeners_->AddListener( | 277 bool first_add = listeners_->AddListener( |
275 constructor.Run(kEvent1Name, NULL, new DictionaryValue())); | 278 constructor.Run(kEvent1Name, nullptr, new DictionaryValue())); |
276 bool second_add = listeners_->AddListener( | 279 bool second_add = listeners_->AddListener( |
277 constructor.Run(kEvent1Name, NULL, new DictionaryValue())); | 280 constructor.Run(kEvent1Name, nullptr, new DictionaryValue())); |
278 | 281 |
279 scoped_ptr<EventListener> listener( | 282 scoped_ptr<EventListener> listener( |
280 constructor.Run(kEvent1Name, NULL, new DictionaryValue())); | 283 constructor.Run(kEvent1Name, nullptr, new DictionaryValue())); |
281 bool first_remove = listeners_->RemoveListener(listener.get()); | 284 bool first_remove = listeners_->RemoveListener(listener.get()); |
282 bool second_remove = listeners_->RemoveListener(listener.get()); | 285 bool second_remove = listeners_->RemoveListener(listener.get()); |
283 | 286 |
284 ASSERT_TRUE(first_add); | 287 ASSERT_TRUE(first_add); |
285 ASSERT_FALSE(second_add); | 288 ASSERT_FALSE(second_add); |
286 ASSERT_TRUE(first_remove); | 289 ASSERT_TRUE(first_remove); |
287 ASSERT_FALSE(second_remove); | 290 ASSERT_FALSE(second_remove); |
288 } | 291 } |
289 | 292 |
290 TEST_F(EventListenerMapTest, AddExistingUnfilteredListenerForExtensions) { | 293 TEST_F(EventListenerMapTest, AddExistingUnfilteredListenerForExtensions) { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
329 } | 332 } |
330 | 333 |
331 TEST_F(EventListenerMapTest, HasListenerForExtension) { | 334 TEST_F(EventListenerMapTest, HasListenerForExtension) { |
332 ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name)); | 335 ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name)); |
333 | 336 |
334 // Non-lazy listener. | 337 // Non-lazy listener. |
335 listeners_->AddListener(EventListener::ForExtension( | 338 listeners_->AddListener(EventListener::ForExtension( |
336 kEvent1Name, kExt1Id, process_.get(), scoped_ptr<DictionaryValue>())); | 339 kEvent1Name, kExt1Id, process_.get(), scoped_ptr<DictionaryValue>())); |
337 // Lazy listener. | 340 // Lazy listener. |
338 listeners_->AddListener(EventListener::ForExtension( | 341 listeners_->AddListener(EventListener::ForExtension( |
339 kEvent1Name, kExt1Id, NULL, scoped_ptr<DictionaryValue>())); | 342 kEvent1Name, kExt1Id, nullptr, scoped_ptr<DictionaryValue>())); |
340 | 343 |
341 ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent2Name)); | 344 ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent2Name)); |
342 ASSERT_TRUE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name)); | 345 ASSERT_TRUE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name)); |
343 ASSERT_FALSE(listeners_->HasListenerForExtension(kExt2Id, kEvent1Name)); | 346 ASSERT_FALSE(listeners_->HasListenerForExtension(kExt2Id, kEvent1Name)); |
344 listeners_->RemoveListenersForProcess(process_.get()); | 347 listeners_->RemoveListenersForProcess(process_.get()); |
345 ASSERT_TRUE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name)); | 348 ASSERT_TRUE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name)); |
346 listeners_->RemoveLazyListenersForExtension(kExt1Id); | 349 listeners_->RemoveLazyListenersForExtension(kExt1Id); |
347 ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name)); | 350 ASSERT_FALSE(listeners_->HasListenerForExtension(kExt1Id, kEvent1Name)); |
348 } | 351 } |
349 | 352 |
350 TEST_F(EventListenerMapTest, AddLazyListenersFromPreferences) { | 353 TEST_F(EventListenerMapTest, AddLazyListenersFromPreferences) { |
351 scoped_ptr<DictionaryValue> filter1(CreateHostSuffixFilter("google.com")); | 354 scoped_ptr<DictionaryValue> filter1(CreateHostSuffixFilter("google.com")); |
352 scoped_ptr<DictionaryValue> filter2(CreateHostSuffixFilter("yahoo.com")); | 355 scoped_ptr<DictionaryValue> filter2(CreateHostSuffixFilter("yahoo.com")); |
353 | 356 |
354 DictionaryValue filtered_listeners; | 357 DictionaryValue filtered_listeners; |
355 ListValue* filter_list = new ListValue(); | 358 ListValue* filter_list = new ListValue(); |
356 filtered_listeners.Set(kEvent1Name, filter_list); | 359 filtered_listeners.Set(kEvent1Name, filter_list); |
357 | 360 |
358 filter_list->Append(filter1.release()); | 361 filter_list->Append(filter1.release()); |
359 filter_list->Append(filter2.release()); | 362 filter_list->Append(filter2.release()); |
360 | 363 |
361 listeners_->LoadFilteredLazyListeners(kExt1Id, filtered_listeners); | 364 listeners_->LoadFilteredLazyListeners(kExt1Id, filtered_listeners); |
362 | 365 |
363 scoped_ptr<Event> event(CreateEvent(kEvent1Name, | 366 scoped_ptr<Event> event(CreateEvent(kEvent1Name, |
364 GURL("http://www.google.com"))); | 367 GURL("http://www.google.com"))); |
365 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); | 368 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); |
366 ASSERT_EQ(1u, targets.size()); | 369 ASSERT_EQ(1u, targets.size()); |
367 scoped_ptr<EventListener> listener(EventListener::ForExtension( | 370 scoped_ptr<EventListener> listener(EventListener::ForExtension( |
368 kEvent1Name, kExt1Id, NULL, CreateHostSuffixFilter("google.com"))); | 371 kEvent1Name, kExt1Id, nullptr, CreateHostSuffixFilter("google.com"))); |
369 ASSERT_TRUE((*targets.begin())->Equals(listener.get())); | 372 ASSERT_TRUE((*targets.begin())->Equals(listener.get())); |
370 } | 373 } |
371 | 374 |
372 TEST_F(EventListenerMapTest, CorruptedExtensionPrefsShouldntCrash) { | 375 TEST_F(EventListenerMapTest, CorruptedExtensionPrefsShouldntCrash) { |
373 scoped_ptr<DictionaryValue> filter1(CreateHostSuffixFilter("google.com")); | 376 scoped_ptr<DictionaryValue> filter1(CreateHostSuffixFilter("google.com")); |
374 | 377 |
375 DictionaryValue filtered_listeners; | 378 DictionaryValue filtered_listeners; |
376 // kEvent1Name should be associated with a list, not a dictionary. | 379 // kEvent1Name should be associated with a list, not a dictionary. |
377 filtered_listeners.Set(kEvent1Name, filter1.release()); | 380 filtered_listeners.Set(kEvent1Name, filter1.release()); |
378 | 381 |
379 listeners_->LoadFilteredLazyListeners(kExt1Id, filtered_listeners); | 382 listeners_->LoadFilteredLazyListeners(kExt1Id, filtered_listeners); |
380 | 383 |
381 scoped_ptr<Event> event(CreateEvent(kEvent1Name, | 384 scoped_ptr<Event> event(CreateEvent(kEvent1Name, |
382 GURL("http://www.google.com"))); | 385 GURL("http://www.google.com"))); |
383 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); | 386 std::set<const EventListener*> targets(listeners_->GetEventListeners(*event)); |
384 ASSERT_EQ(0u, targets.size()); | 387 ASSERT_EQ(0u, targets.size()); |
385 } | 388 } |
386 | 389 |
387 } // namespace | 390 } // namespace |
388 | 391 |
389 } // namespace extensions | 392 } // namespace extensions |
OLD | NEW |