Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(229)

Side by Side Diff: extensions/browser/event_listener_map_unittest.cc

Issue 598173003: Run clang-modernize -use-nullptr over src/extensions/. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698