OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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 "base/observer_list.h" | 5 #include "base/observer_list.h" |
6 #include "base/observer_list_threadsafe.h" | 6 #include "base/observer_list_threadsafe.h" |
7 | 7 |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
11 #include "base/memory/weak_ptr.h" | 11 #include "base/memory/weak_ptr.h" |
12 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
13 #include "base/run_loop.h" | 13 #include "base/run_loop.h" |
14 #include "base/threading/platform_thread.h" | 14 #include "base/threading/platform_thread.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 | 16 |
17 namespace base { | 17 namespace base { |
18 namespace { | 18 namespace { |
19 | 19 |
20 class Foo { | 20 class Foo { |
21 public: | 21 public: |
22 virtual void Observe(int x) = 0; | 22 virtual void Observe(int x) = 0; |
23 virtual ~Foo() {} | 23 virtual ~Foo() {} |
24 }; | 24 }; |
25 | 25 |
26 class Adder : public Foo { | 26 class Adder : public Foo { |
27 public: | 27 public: |
28 explicit Adder(int scaler) : total(0), scaler_(scaler) {} | 28 explicit Adder(int scaler) : total(0), scaler_(scaler) {} |
29 virtual void Observe(int x) OVERRIDE { | 29 void Observe(int x) override { total += x * scaler_; } |
30 total += x * scaler_; | |
31 } | |
32 virtual ~Adder() {} | 30 virtual ~Adder() {} |
33 int total; | 31 int total; |
34 | 32 |
35 private: | 33 private: |
36 int scaler_; | 34 int scaler_; |
37 }; | 35 }; |
38 | 36 |
39 class Disrupter : public Foo { | 37 class Disrupter : public Foo { |
40 public: | 38 public: |
41 Disrupter(ObserverList<Foo>* list, Foo* doomed) | 39 Disrupter(ObserverList<Foo>* list, Foo* doomed) |
42 : list_(list), | 40 : list_(list), |
43 doomed_(doomed) { | 41 doomed_(doomed) { |
44 } | 42 } |
45 virtual ~Disrupter() {} | 43 virtual ~Disrupter() {} |
46 virtual void Observe(int x) OVERRIDE { | 44 void Observe(int x) override { list_->RemoveObserver(doomed_); } |
47 list_->RemoveObserver(doomed_); | |
48 } | |
49 | 45 |
50 private: | 46 private: |
51 ObserverList<Foo>* list_; | 47 ObserverList<Foo>* list_; |
52 Foo* doomed_; | 48 Foo* doomed_; |
53 }; | 49 }; |
54 | 50 |
55 class ThreadSafeDisrupter : public Foo { | 51 class ThreadSafeDisrupter : public Foo { |
56 public: | 52 public: |
57 ThreadSafeDisrupter(ObserverListThreadSafe<Foo>* list, Foo* doomed) | 53 ThreadSafeDisrupter(ObserverListThreadSafe<Foo>* list, Foo* doomed) |
58 : list_(list), | 54 : list_(list), |
59 doomed_(doomed) { | 55 doomed_(doomed) { |
60 } | 56 } |
61 virtual ~ThreadSafeDisrupter() {} | 57 virtual ~ThreadSafeDisrupter() {} |
62 virtual void Observe(int x) OVERRIDE { | 58 void Observe(int x) override { list_->RemoveObserver(doomed_); } |
63 list_->RemoveObserver(doomed_); | |
64 } | |
65 | 59 |
66 private: | 60 private: |
67 ObserverListThreadSafe<Foo>* list_; | 61 ObserverListThreadSafe<Foo>* list_; |
68 Foo* doomed_; | 62 Foo* doomed_; |
69 }; | 63 }; |
70 | 64 |
71 template <typename ObserverListType> | 65 template <typename ObserverListType> |
72 class AddInObserve : public Foo { | 66 class AddInObserve : public Foo { |
73 public: | 67 public: |
74 explicit AddInObserve(ObserverListType* observer_list) | 68 explicit AddInObserve(ObserverListType* observer_list) |
75 : added(false), | 69 : added(false), |
76 observer_list(observer_list), | 70 observer_list(observer_list), |
77 adder(1) { | 71 adder(1) { |
78 } | 72 } |
79 | 73 |
80 virtual void Observe(int x) OVERRIDE { | 74 void Observe(int x) override { |
81 if (!added) { | 75 if (!added) { |
82 added = true; | 76 added = true; |
83 observer_list->AddObserver(&adder); | 77 observer_list->AddObserver(&adder); |
84 } | 78 } |
85 } | 79 } |
86 | 80 |
87 bool added; | 81 bool added; |
88 ObserverListType* observer_list; | 82 ObserverListType* observer_list; |
89 Adder adder; | 83 Adder adder; |
90 }; | 84 }; |
(...skipping 14 matching lines...) Expand all Loading... |
105 start_(Time::Now()), | 99 start_(Time::Now()), |
106 count_observes_(0), | 100 count_observes_(0), |
107 count_addtask_(0), | 101 count_addtask_(0), |
108 do_notifies_(notify), | 102 do_notifies_(notify), |
109 weak_factory_(this) { | 103 weak_factory_(this) { |
110 } | 104 } |
111 | 105 |
112 virtual ~AddRemoveThread() { | 106 virtual ~AddRemoveThread() { |
113 } | 107 } |
114 | 108 |
115 virtual void ThreadMain() OVERRIDE { | 109 void ThreadMain() override { |
116 loop_ = new MessageLoop(); // Fire up a message loop. | 110 loop_ = new MessageLoop(); // Fire up a message loop. |
117 loop_->PostTask( | 111 loop_->PostTask( |
118 FROM_HERE, | 112 FROM_HERE, |
119 base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr())); | 113 base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr())); |
120 loop_->Run(); | 114 loop_->Run(); |
121 //LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " << | 115 //LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " << |
122 // count_observes_ << ", " << count_addtask_; | 116 // count_observes_ << ", " << count_addtask_; |
123 delete loop_; | 117 delete loop_; |
124 loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef); | 118 loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef); |
125 delete this; | 119 delete this; |
(...skipping 20 matching lines...) Expand all Loading... |
146 | 140 |
147 loop_->PostTask( | 141 loop_->PostTask( |
148 FROM_HERE, | 142 FROM_HERE, |
149 base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr())); | 143 base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr())); |
150 } | 144 } |
151 | 145 |
152 void Quit() { | 146 void Quit() { |
153 loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure()); | 147 loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure()); |
154 } | 148 } |
155 | 149 |
156 virtual void Observe(int x) OVERRIDE { | 150 void Observe(int x) override { |
157 count_observes_++; | 151 count_observes_++; |
158 | 152 |
159 // If we're getting called after we removed ourselves from | 153 // If we're getting called after we removed ourselves from |
160 // the list, that is very bad! | 154 // the list, that is very bad! |
161 DCHECK(in_list_); | 155 DCHECK(in_list_); |
162 | 156 |
163 // This callback should fire on the appropriate thread | 157 // This callback should fire on the appropriate thread |
164 EXPECT_EQ(loop_, MessageLoop::current()); | 158 EXPECT_EQ(loop_, MessageLoop::current()); |
165 | 159 |
166 list_->RemoveObserver(this); | 160 list_->RemoveObserver(this); |
(...skipping 155 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
322 | 316 |
323 class FooRemover : public Foo { | 317 class FooRemover : public Foo { |
324 public: | 318 public: |
325 explicit FooRemover(ObserverListThreadSafe<Foo>* list) : list_(list) {} | 319 explicit FooRemover(ObserverListThreadSafe<Foo>* list) : list_(list) {} |
326 virtual ~FooRemover() {} | 320 virtual ~FooRemover() {} |
327 | 321 |
328 void AddFooToRemove(Foo* foo) { | 322 void AddFooToRemove(Foo* foo) { |
329 foos_.push_back(foo); | 323 foos_.push_back(foo); |
330 } | 324 } |
331 | 325 |
332 virtual void Observe(int x) OVERRIDE { | 326 void Observe(int x) override { |
333 std::vector<Foo*> tmp; | 327 std::vector<Foo*> tmp; |
334 tmp.swap(foos_); | 328 tmp.swap(foos_); |
335 for (std::vector<Foo*>::iterator it = tmp.begin(); | 329 for (std::vector<Foo*>::iterator it = tmp.begin(); |
336 it != tmp.end(); ++it) { | 330 it != tmp.end(); ++it) { |
337 list_->RemoveObserver(*it); | 331 list_->RemoveObserver(*it); |
338 } | 332 } |
339 } | 333 } |
340 | 334 |
341 private: | 335 private: |
342 const scoped_refptr<ObserverListThreadSafe<Foo> > list_; | 336 const scoped_refptr<ObserverListThreadSafe<Foo> > list_; |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
474 observer_list->Notify(&Foo::Observe, 1); | 468 observer_list->Notify(&Foo::Observe, 1); |
475 RunLoop().RunUntilIdle(); | 469 RunLoop().RunUntilIdle(); |
476 EXPECT_EQ(1, b.adder.total); | 470 EXPECT_EQ(1, b.adder.total); |
477 } | 471 } |
478 | 472 |
479 class AddInClearObserve : public Foo { | 473 class AddInClearObserve : public Foo { |
480 public: | 474 public: |
481 explicit AddInClearObserve(ObserverList<Foo>* list) | 475 explicit AddInClearObserve(ObserverList<Foo>* list) |
482 : list_(list), added_(false), adder_(1) {} | 476 : list_(list), added_(false), adder_(1) {} |
483 | 477 |
484 virtual void Observe(int /* x */) OVERRIDE { | 478 void Observe(int /* x */) override { |
485 list_->Clear(); | 479 list_->Clear(); |
486 list_->AddObserver(&adder_); | 480 list_->AddObserver(&adder_); |
487 added_ = true; | 481 added_ = true; |
488 } | 482 } |
489 | 483 |
490 bool added() const { return added_; } | 484 bool added() const { return added_; } |
491 const Adder& adder() const { return adder_; } | 485 const Adder& adder() const { return adder_; } |
492 | 486 |
493 private: | 487 private: |
494 ObserverList<Foo>* const list_; | 488 ObserverList<Foo>* const list_; |
(...skipping 24 matching lines...) Expand all Loading... |
519 EXPECT_TRUE(a.added()); | 513 EXPECT_TRUE(a.added()); |
520 EXPECT_EQ(0, a.adder().total) | 514 EXPECT_EQ(0, a.adder().total) |
521 << "Adder should not observe, so sum should still be 0."; | 515 << "Adder should not observe, so sum should still be 0."; |
522 } | 516 } |
523 | 517 |
524 class ListDestructor : public Foo { | 518 class ListDestructor : public Foo { |
525 public: | 519 public: |
526 explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {} | 520 explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {} |
527 virtual ~ListDestructor() {} | 521 virtual ~ListDestructor() {} |
528 | 522 |
529 virtual void Observe(int x) OVERRIDE { | 523 void Observe(int x) override { delete list_; } |
530 delete list_; | |
531 } | |
532 | 524 |
533 private: | 525 private: |
534 ObserverList<Foo>* list_; | 526 ObserverList<Foo>* list_; |
535 }; | 527 }; |
536 | 528 |
537 | 529 |
538 TEST(ObserverListTest, IteratorOutlivesList) { | 530 TEST(ObserverListTest, IteratorOutlivesList) { |
539 ObserverList<Foo>* observer_list = new ObserverList<Foo>; | 531 ObserverList<Foo>* observer_list = new ObserverList<Foo>; |
540 ListDestructor a(observer_list); | 532 ListDestructor a(observer_list); |
541 observer_list->AddObserver(&a); | 533 observer_list->AddObserver(&a); |
542 | 534 |
543 FOR_EACH_OBSERVER(Foo, *observer_list, Observe(0)); | 535 FOR_EACH_OBSERVER(Foo, *observer_list, Observe(0)); |
544 // If this test fails, there'll be Valgrind errors when this function goes out | 536 // If this test fails, there'll be Valgrind errors when this function goes out |
545 // of scope. | 537 // of scope. |
546 } | 538 } |
547 | 539 |
548 } // namespace | 540 } // namespace |
549 } // namespace base | 541 } // namespace base |
OLD | NEW |