1 // Copyright (c) 2012 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.
5 #include "base/observer_list.h"
6 #include "base/observer_list_threadsafe.h"
10 #include "base/compiler_specific.h"
11 #include "base/memory/weak_ptr.h"
12 #include "base/message_loop/message_loop.h"
13 #include "base/run_loop.h"
14 #include "base/threading/platform_thread.h"
15 #include "testing/gtest/include/gtest/gtest.h"
22 virtual void Observe(int x
) = 0;
26 class Adder
: public Foo
{
28 explicit Adder(int scaler
) : total(0), scaler_(scaler
) {}
29 virtual void Observe(int x
) override
{
39 class Disrupter
: public Foo
{
41 Disrupter(ObserverList
<Foo
>* list
, Foo
* doomed
)
45 virtual ~Disrupter() {}
46 virtual void Observe(int x
) override
{
47 list_
->RemoveObserver(doomed_
);
51 ObserverList
<Foo
>* list_
;
55 class ThreadSafeDisrupter
: public Foo
{
57 ThreadSafeDisrupter(ObserverListThreadSafe
<Foo
>* list
, Foo
* doomed
)
61 virtual ~ThreadSafeDisrupter() {}
62 virtual void Observe(int x
) override
{
63 list_
->RemoveObserver(doomed_
);
67 ObserverListThreadSafe
<Foo
>* list_
;
71 template <typename ObserverListType
>
72 class AddInObserve
: public Foo
{
74 explicit AddInObserve(ObserverListType
* observer_list
)
76 observer_list(observer_list
),
80 virtual void Observe(int x
) override
{
83 observer_list
->AddObserver(&adder
);
88 ObserverListType
* observer_list
;
93 static const int kThreadRunTime
= 2000; // ms to run the multi-threaded test.
95 // A thread for use in the ThreadSafeObserver test
96 // which will add and remove itself from the notification
98 class AddRemoveThread
: public PlatformThread::Delegate
,
101 AddRemoveThread(ObserverListThreadSafe
<Foo
>* list
, bool notify
)
108 do_notifies_(notify
),
109 weak_factory_(this) {
112 virtual ~AddRemoveThread() {
115 virtual void ThreadMain() override
{
116 loop_
= new MessageLoop(); // Fire up a message loop.
119 base::Bind(&AddRemoveThread::AddTask
, weak_factory_
.GetWeakPtr()));
121 //LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " <<
122 // count_observes_ << ", " << count_addtask_;
124 loop_
= reinterpret_cast<MessageLoop
*>(0xdeadbeef);
128 // This task just keeps posting to itself in an attempt
129 // to race with the notifier.
133 if ((Time::Now() - start_
).InMilliseconds() > kThreadRunTime
) {
139 list_
->AddObserver(this);
144 list_
->Notify(&Foo::Observe
, 10);
149 base::Bind(&AddRemoveThread::AddTask
, weak_factory_
.GetWeakPtr()));
153 loop_
->PostTask(FROM_HERE
, MessageLoop::QuitWhenIdleClosure());
156 virtual void Observe(int x
) override
{
159 // If we're getting called after we removed ourselves from
160 // the list, that is very bad!
163 // This callback should fire on the appropriate thread
164 EXPECT_EQ(loop_
, MessageLoop::current());
166 list_
->RemoveObserver(this);
171 ObserverListThreadSafe
<Foo
>* list_
;
173 bool in_list_
; // Are we currently registered for notifications.
174 // in_list_ is only used on |this| thread.
175 Time start_
; // The time we started the test.
177 int count_observes_
; // Number of times we observed.
178 int count_addtask_
; // Number of times thread AddTask was called
179 bool do_notifies_
; // Whether these threads should do notifications.
181 base::WeakPtrFactory
<AddRemoveThread
> weak_factory_
;
184 TEST(ObserverListTest
, BasicTest
) {
185 ObserverList
<Foo
> observer_list
;
186 Adder
a(1), b(-1), c(1), d(-1), e(-1);
187 Disrupter
evil(&observer_list
, &c
);
189 observer_list
.AddObserver(&a
);
190 observer_list
.AddObserver(&b
);
192 FOR_EACH_OBSERVER(Foo
, observer_list
, Observe(10));
194 observer_list
.AddObserver(&evil
);
195 observer_list
.AddObserver(&c
);
196 observer_list
.AddObserver(&d
);
198 // Removing an observer not in the list should do nothing.
199 observer_list
.RemoveObserver(&e
);
201 FOR_EACH_OBSERVER(Foo
, observer_list
, Observe(10));
203 EXPECT_EQ(20, a
.total
);
204 EXPECT_EQ(-20, b
.total
);
205 EXPECT_EQ(0, c
.total
);
206 EXPECT_EQ(-10, d
.total
);
207 EXPECT_EQ(0, e
.total
);
210 TEST(ObserverListThreadSafeTest
, BasicTest
) {
213 scoped_refptr
<ObserverListThreadSafe
<Foo
> > observer_list(
214 new ObserverListThreadSafe
<Foo
>);
219 ThreadSafeDisrupter
evil(observer_list
.get(), &c
);
221 observer_list
->AddObserver(&a
);
222 observer_list
->AddObserver(&b
);
224 observer_list
->Notify(&Foo::Observe
, 10);
225 RunLoop().RunUntilIdle();
227 observer_list
->AddObserver(&evil
);
228 observer_list
->AddObserver(&c
);
229 observer_list
->AddObserver(&d
);
231 observer_list
->Notify(&Foo::Observe
, 10);
232 RunLoop().RunUntilIdle();
234 EXPECT_EQ(20, a
.total
);
235 EXPECT_EQ(-20, b
.total
);
236 EXPECT_EQ(0, c
.total
);
237 EXPECT_EQ(-10, d
.total
);
240 TEST(ObserverListThreadSafeTest
, RemoveObserver
) {
243 scoped_refptr
<ObserverListThreadSafe
<Foo
> > observer_list(
244 new ObserverListThreadSafe
<Foo
>);
247 // A workaround for the compiler bug. See http://crbug.com/121960.
250 // Should do nothing.
251 observer_list
->RemoveObserver(&a
);
252 observer_list
->RemoveObserver(&b
);
254 observer_list
->Notify(&Foo::Observe
, 10);
255 RunLoop().RunUntilIdle();
257 EXPECT_EQ(0, a
.total
);
258 EXPECT_EQ(0, b
.total
);
260 observer_list
->AddObserver(&a
);
262 // Should also do nothing.
263 observer_list
->RemoveObserver(&b
);
265 observer_list
->Notify(&Foo::Observe
, 10);
266 RunLoop().RunUntilIdle();
268 EXPECT_EQ(10, a
.total
);
269 EXPECT_EQ(0, b
.total
);
272 TEST(ObserverListThreadSafeTest
, WithoutMessageLoop
) {
273 scoped_refptr
<ObserverListThreadSafe
<Foo
> > observer_list(
274 new ObserverListThreadSafe
<Foo
>);
276 Adder
a(1), b(1), c(1);
278 // No MessageLoop, so these should not be added.
279 observer_list
->AddObserver(&a
);
280 observer_list
->AddObserver(&b
);
283 // Add c when there's a loop.
285 observer_list
->AddObserver(&c
);
287 observer_list
->Notify(&Foo::Observe
, 10);
288 RunLoop().RunUntilIdle();
290 EXPECT_EQ(0, a
.total
);
291 EXPECT_EQ(0, b
.total
);
292 EXPECT_EQ(10, c
.total
);
294 // Now add a when there's a loop.
295 observer_list
->AddObserver(&a
);
297 // Remove c when there's a loop.
298 observer_list
->RemoveObserver(&c
);
301 observer_list
->Notify(&Foo::Observe
, 20);
302 RunLoop().RunUntilIdle();
304 EXPECT_EQ(20, a
.total
);
305 EXPECT_EQ(0, b
.total
);
306 EXPECT_EQ(10, c
.total
);
309 // Removing should always succeed with or without a loop.
310 observer_list
->RemoveObserver(&a
);
312 // Notifying should not fail but should also be a no-op.
314 observer_list
->AddObserver(&b
);
315 observer_list
->Notify(&Foo::Observe
, 30);
316 RunLoop().RunUntilIdle();
318 EXPECT_EQ(20, a
.total
);
319 EXPECT_EQ(30, b
.total
);
320 EXPECT_EQ(10, c
.total
);
323 class FooRemover
: public Foo
{
325 explicit FooRemover(ObserverListThreadSafe
<Foo
>* list
) : list_(list
) {}
326 virtual ~FooRemover() {}
328 void AddFooToRemove(Foo
* foo
) {
329 foos_
.push_back(foo
);
332 virtual void Observe(int x
) override
{
333 std::vector
<Foo
*> tmp
;
335 for (std::vector
<Foo
*>::iterator it
= tmp
.begin();
336 it
!= tmp
.end(); ++it
) {
337 list_
->RemoveObserver(*it
);
342 const scoped_refptr
<ObserverListThreadSafe
<Foo
> > list_
;
343 std::vector
<Foo
*> foos_
;
346 TEST(ObserverListThreadSafeTest
, RemoveMultipleObservers
) {
348 scoped_refptr
<ObserverListThreadSafe
<Foo
> > observer_list(
349 new ObserverListThreadSafe
<Foo
>);
351 FooRemover
a(observer_list
.get());
354 observer_list
->AddObserver(&a
);
355 observer_list
->AddObserver(&b
);
357 a
.AddFooToRemove(&a
);
358 a
.AddFooToRemove(&b
);
360 observer_list
->Notify(&Foo::Observe
, 1);
361 RunLoop().RunUntilIdle();
364 // A test driver for a multi-threaded notification loop. Runs a number
365 // of observer threads, each of which constantly adds/removes itself
366 // from the observer list. Optionally, if cross_thread_notifies is set
367 // to true, the observer threads will also trigger notifications to
369 static void ThreadSafeObserverHarness(int num_threads
,
370 bool cross_thread_notifies
) {
373 const int kMaxThreads
= 15;
374 num_threads
= num_threads
> kMaxThreads
? kMaxThreads
: num_threads
;
376 scoped_refptr
<ObserverListThreadSafe
<Foo
> > observer_list(
377 new ObserverListThreadSafe
<Foo
>);
383 observer_list
->AddObserver(&a
);
384 observer_list
->AddObserver(&b
);
386 AddRemoveThread
* threaded_observer
[kMaxThreads
];
387 base::PlatformThreadHandle threads
[kMaxThreads
];
388 for (int index
= 0; index
< num_threads
; index
++) {
389 threaded_observer
[index
] = new AddRemoveThread(observer_list
.get(), false);
390 EXPECT_TRUE(PlatformThread::Create(0,
391 threaded_observer
[index
], &threads
[index
]));
394 Time start
= Time::Now();
396 if ((Time::Now() - start
).InMilliseconds() > kThreadRunTime
)
399 observer_list
->Notify(&Foo::Observe
, 10);
401 RunLoop().RunUntilIdle();
404 for (int index
= 0; index
< num_threads
; index
++) {
405 threaded_observer
[index
]->Quit();
406 PlatformThread::Join(threads
[index
]);
410 TEST(ObserverListThreadSafeTest
, CrossThreadObserver
) {
411 // Use 7 observer threads. Notifications only come from
413 ThreadSafeObserverHarness(7, false);
416 TEST(ObserverListThreadSafeTest
, CrossThreadNotifications
) {
417 // Use 3 observer threads. Notifications will fire from
418 // the main thread and all 3 observer threads.
419 ThreadSafeObserverHarness(3, true);
422 TEST(ObserverListThreadSafeTest
, OutlivesMessageLoop
) {
423 MessageLoop
* loop
= new MessageLoop
;
424 scoped_refptr
<ObserverListThreadSafe
<Foo
> > observer_list(
425 new ObserverListThreadSafe
<Foo
>);
428 observer_list
->AddObserver(&a
);
430 // Test passes if we don't crash here.
431 observer_list
->Notify(&Foo::Observe
, 1);
434 TEST(ObserverListTest
, Existing
) {
435 ObserverList
<Foo
> observer_list(ObserverList
<Foo
>::NOTIFY_EXISTING_ONLY
);
437 AddInObserve
<ObserverList
<Foo
> > b(&observer_list
);
439 observer_list
.AddObserver(&a
);
440 observer_list
.AddObserver(&b
);
442 FOR_EACH_OBSERVER(Foo
, observer_list
, Observe(1));
444 EXPECT_TRUE(b
.added
);
445 // B's adder should not have been notified because it was added during
447 EXPECT_EQ(0, b
.adder
.total
);
449 // Notify again to make sure b's adder is notified.
450 FOR_EACH_OBSERVER(Foo
, observer_list
, Observe(1));
451 EXPECT_EQ(1, b
.adder
.total
);
454 // Same as above, but for ObserverListThreadSafe
455 TEST(ObserverListThreadSafeTest
, Existing
) {
457 scoped_refptr
<ObserverListThreadSafe
<Foo
> > observer_list(
458 new ObserverListThreadSafe
<Foo
>(ObserverList
<Foo
>::NOTIFY_EXISTING_ONLY
));
460 AddInObserve
<ObserverListThreadSafe
<Foo
> > b(observer_list
.get());
462 observer_list
->AddObserver(&a
);
463 observer_list
->AddObserver(&b
);
465 observer_list
->Notify(&Foo::Observe
, 1);
466 RunLoop().RunUntilIdle();
468 EXPECT_TRUE(b
.added
);
469 // B's adder should not have been notified because it was added during
471 EXPECT_EQ(0, b
.adder
.total
);
473 // Notify again to make sure b's adder is notified.
474 observer_list
->Notify(&Foo::Observe
, 1);
475 RunLoop().RunUntilIdle();
476 EXPECT_EQ(1, b
.adder
.total
);
479 class AddInClearObserve
: public Foo
{
481 explicit AddInClearObserve(ObserverList
<Foo
>* list
)
482 : list_(list
), added_(false), adder_(1) {}
484 virtual void Observe(int /* x */) override
{
486 list_
->AddObserver(&adder_
);
490 bool added() const { return added_
; }
491 const Adder
& adder() const { return adder_
; }
494 ObserverList
<Foo
>* const list_
;
500 TEST(ObserverListTest
, ClearNotifyAll
) {
501 ObserverList
<Foo
> observer_list
;
502 AddInClearObserve
a(&observer_list
);
504 observer_list
.AddObserver(&a
);
506 FOR_EACH_OBSERVER(Foo
, observer_list
, Observe(1));
507 EXPECT_TRUE(a
.added());
508 EXPECT_EQ(1, a
.adder().total
)
509 << "Adder should observe once and have sum of 1.";
512 TEST(ObserverListTest
, ClearNotifyExistingOnly
) {
513 ObserverList
<Foo
> observer_list(ObserverList
<Foo
>::NOTIFY_EXISTING_ONLY
);
514 AddInClearObserve
a(&observer_list
);
516 observer_list
.AddObserver(&a
);
518 FOR_EACH_OBSERVER(Foo
, observer_list
, Observe(1));
519 EXPECT_TRUE(a
.added());
520 EXPECT_EQ(0, a
.adder().total
)
521 << "Adder should not observe, so sum should still be 0.";
524 class ListDestructor
: public Foo
{
526 explicit ListDestructor(ObserverList
<Foo
>* list
) : list_(list
) {}
527 virtual ~ListDestructor() {}
529 virtual void Observe(int x
) override
{
534 ObserverList
<Foo
>* list_
;
538 TEST(ObserverListTest
, IteratorOutlivesList
) {
539 ObserverList
<Foo
>* observer_list
= new ObserverList
<Foo
>;
540 ListDestructor
a(observer_list
);
541 observer_list
->AddObserver(&a
);
543 FOR_EACH_OBSERVER(Foo
, *observer_list
, Observe(0));
544 // If this test fails, there'll be Valgrind errors when this function goes out