alexeypa@chromium.org | 27c8ca7 | 2012-04-06 02:52:10 +0900 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
license.bot | f003cfe | 2008-08-24 09:55:55 +0900 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 4 | |
| 5 | #include "base/observer_list.h" |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 6 | #include "base/observer_list_threadsafe.h" |
willchan@chromium.org | 2777ca5 | 2010-09-18 04:33:06 +0900 | [diff] [blame] | 7 | |
| 8 | #include <vector> |
| 9 | |
jhawkins@chromium.org | 22d6756 | 2011-10-13 05:26:50 +0900 | [diff] [blame] | 10 | #include "base/compiler_specific.h" |
| 11 | #include "base/memory/weak_ptr.h" |
avi@chromium.org | a043a86 | 2013-07-18 17:12:40 +0900 | [diff] [blame] | 12 | #include "base/message_loop/message_loop.h" |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 13 | #include "base/run_loop.h" |
brettw@chromium.org | 6139182 | 2011-01-01 05:02:16 +0900 | [diff] [blame] | 14 | #include "base/threading/platform_thread.h" |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 15 | #include "testing/gtest/include/gtest/gtest.h" |
| 16 | |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 17 | namespace base { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 18 | namespace { |
| 19 | |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 20 | class Foo { |
| 21 | public: |
| 22 | virtual void Observe(int x) = 0; |
pinkerton@google.com | 15f4b11 | 2008-08-09 01:37:43 +0900 | [diff] [blame] | 23 | virtual ~Foo() {} |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 24 | }; |
| 25 | |
| 26 | class Adder : public Foo { |
| 27 | public: |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 28 | explicit Adder(int scaler) : total(0), scaler_(scaler) {} |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 29 | virtual void Observe(int x) OVERRIDE { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 30 | total += x * scaler_; |
| 31 | } |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 32 | virtual ~Adder() {} |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 33 | int total; |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 34 | |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 35 | private: |
| 36 | int scaler_; |
| 37 | }; |
| 38 | |
| 39 | class Disrupter : public Foo { |
| 40 | public: |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 41 | Disrupter(ObserverList<Foo>* list, Foo* doomed) |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 42 | : list_(list), |
| 43 | doomed_(doomed) { |
| 44 | } |
| 45 | virtual ~Disrupter() {} |
| 46 | virtual void Observe(int x) OVERRIDE { |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 47 | list_->RemoveObserver(doomed_); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 48 | } |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 49 | |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 50 | private: |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 51 | ObserverList<Foo>* list_; |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 52 | Foo* doomed_; |
| 53 | }; |
| 54 | |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 55 | class ThreadSafeDisrupter : public Foo { |
| 56 | public: |
| 57 | ThreadSafeDisrupter(ObserverListThreadSafe<Foo>* list, Foo* doomed) |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 58 | : list_(list), |
| 59 | doomed_(doomed) { |
| 60 | } |
| 61 | virtual ~ThreadSafeDisrupter() {} |
| 62 | virtual void Observe(int x) OVERRIDE { |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 63 | list_->RemoveObserver(doomed_); |
| 64 | } |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 65 | |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 66 | private: |
| 67 | ObserverListThreadSafe<Foo>* list_; |
| 68 | Foo* doomed_; |
| 69 | }; |
| 70 | |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 71 | template <typename ObserverListType> |
sky@google.com | b92a56b | 2008-10-31 12:32:06 +0900 | [diff] [blame] | 72 | class AddInObserve : public Foo { |
| 73 | public: |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 74 | explicit AddInObserve(ObserverListType* observer_list) |
sky@google.com | b92a56b | 2008-10-31 12:32:06 +0900 | [diff] [blame] | 75 | : added(false), |
| 76 | observer_list(observer_list), |
| 77 | adder(1) { |
| 78 | } |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 79 | |
| 80 | virtual void Observe(int x) OVERRIDE { |
sky@google.com | b92a56b | 2008-10-31 12:32:06 +0900 | [diff] [blame] | 81 | if (!added) { |
| 82 | added = true; |
| 83 | observer_list->AddObserver(&adder); |
| 84 | } |
| 85 | } |
| 86 | |
| 87 | bool added; |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 88 | ObserverListType* observer_list; |
sky@google.com | b92a56b | 2008-10-31 12:32:06 +0900 | [diff] [blame] | 89 | Adder adder; |
| 90 | }; |
| 91 | |
| 92 | |
phajdan.jr@chromium.org | cd3a707 | 2009-11-06 03:46:47 +0900 | [diff] [blame] | 93 | static const int kThreadRunTime = 2000; // ms to run the multi-threaded test. |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 94 | |
| 95 | // A thread for use in the ThreadSafeObserver test |
| 96 | // which will add and remove itself from the notification |
| 97 | // list repeatedly. |
| 98 | class AddRemoveThread : public PlatformThread::Delegate, |
| 99 | public Foo { |
| 100 | public: |
| 101 | AddRemoveThread(ObserverListThreadSafe<Foo>* list, bool notify) |
| 102 | : list_(list), |
tfarina@chromium.org | 2774420 | 2012-08-06 10:03:05 +0900 | [diff] [blame] | 103 | loop_(NULL), |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 104 | in_list_(false), |
| 105 | start_(Time::Now()), |
| 106 | count_observes_(0), |
| 107 | count_addtask_(0), |
jhawkins@chromium.org | 22d6756 | 2011-10-13 05:26:50 +0900 | [diff] [blame] | 108 | do_notifies_(notify), |
tfarina@chromium.org | 506c208 | 2013-04-25 21:17:15 +0900 | [diff] [blame] | 109 | weak_factory_(this) { |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 110 | } |
| 111 | |
erikkay@google.com | 5874ffb | 2009-01-06 04:40:53 +0900 | [diff] [blame] | 112 | virtual ~AddRemoveThread() { |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 113 | } |
| 114 | |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 115 | virtual void ThreadMain() OVERRIDE { |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 116 | loop_ = new MessageLoop(); // Fire up a message loop. |
willchan@chromium.org | d52d47f | 2010-02-13 06:38:37 +0900 | [diff] [blame] | 117 | loop_->PostTask( |
jhawkins@chromium.org | 22d6756 | 2011-10-13 05:26:50 +0900 | [diff] [blame] | 118 | FROM_HERE, |
| 119 | base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr())); |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 120 | loop_->Run(); |
maruel@chromium.org | 8fe7adc | 2009-03-04 00:01:12 +0900 | [diff] [blame] | 121 | //LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " << |
| 122 | // count_observes_ << ", " << count_addtask_; |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 123 | delete loop_; |
| 124 | loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef); |
erikkay@google.com | 5874ffb | 2009-01-06 04:40:53 +0900 | [diff] [blame] | 125 | delete this; |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 126 | } |
| 127 | |
| 128 | // This task just keeps posting to itself in an attempt |
| 129 | // to race with the notifier. |
| 130 | void AddTask() { |
| 131 | count_addtask_++; |
| 132 | |
| 133 | if ((Time::Now() - start_).InMilliseconds() > kThreadRunTime) { |
pkasting@chromium.org | 9fc8707 | 2010-10-19 11:31:03 +0900 | [diff] [blame] | 134 | VLOG(1) << "DONE!"; |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 135 | return; |
| 136 | } |
| 137 | |
| 138 | if (!in_list_) { |
| 139 | list_->AddObserver(this); |
| 140 | in_list_ = true; |
| 141 | } |
| 142 | |
| 143 | if (do_notifies_) { |
| 144 | list_->Notify(&Foo::Observe, 10); |
| 145 | } |
| 146 | |
jhawkins@chromium.org | 22d6756 | 2011-10-13 05:26:50 +0900 | [diff] [blame] | 147 | loop_->PostTask( |
| 148 | FROM_HERE, |
| 149 | base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr())); |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 150 | } |
| 151 | |
| 152 | void Quit() { |
thakis@chromium.org | fc6f929 | 2013-02-05 08:40:00 +0900 | [diff] [blame] | 153 | loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure()); |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 154 | } |
| 155 | |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 156 | virtual void Observe(int x) OVERRIDE { |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 157 | count_observes_++; |
| 158 | |
| 159 | // If we're getting called after we removed ourselves from |
| 160 | // the list, that is very bad! |
| 161 | DCHECK(in_list_); |
| 162 | |
| 163 | // This callback should fire on the appropriate thread |
| 164 | EXPECT_EQ(loop_, MessageLoop::current()); |
| 165 | |
| 166 | list_->RemoveObserver(this); |
| 167 | in_list_ = false; |
| 168 | } |
| 169 | |
| 170 | private: |
| 171 | ObserverListThreadSafe<Foo>* list_; |
| 172 | MessageLoop* loop_; |
| 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. |
| 176 | |
| 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. |
| 180 | |
jhawkins@chromium.org | 22d6756 | 2011-10-13 05:26:50 +0900 | [diff] [blame] | 181 | base::WeakPtrFactory<AddRemoveThread> weak_factory_; |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 182 | }; |
| 183 | |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 184 | TEST(ObserverListTest, BasicTest) { |
| 185 | ObserverList<Foo> observer_list; |
akalin@chromium.org | cbec5fb | 2011-06-05 16:07:12 +0900 | [diff] [blame] | 186 | Adder a(1), b(-1), c(1), d(-1), e(-1); |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 187 | Disrupter evil(&observer_list, &c); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 188 | |
| 189 | observer_list.AddObserver(&a); |
| 190 | observer_list.AddObserver(&b); |
| 191 | |
| 192 | FOR_EACH_OBSERVER(Foo, observer_list, Observe(10)); |
| 193 | |
| 194 | observer_list.AddObserver(&evil); |
| 195 | observer_list.AddObserver(&c); |
| 196 | observer_list.AddObserver(&d); |
| 197 | |
akalin@chromium.org | cbec5fb | 2011-06-05 16:07:12 +0900 | [diff] [blame] | 198 | // Removing an observer not in the list should do nothing. |
| 199 | observer_list.RemoveObserver(&e); |
| 200 | |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 201 | FOR_EACH_OBSERVER(Foo, observer_list, Observe(10)); |
| 202 | |
tfarina@chromium.org | 4caddb0 | 2012-08-23 18:59:19 +0900 | [diff] [blame] | 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); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 208 | } |
license.bot | f003cfe | 2008-08-24 09:55:55 +0900 | [diff] [blame] | 209 | |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 210 | TEST(ObserverListThreadSafeTest, BasicTest) { |
| 211 | MessageLoop loop; |
| 212 | |
| 213 | scoped_refptr<ObserverListThreadSafe<Foo> > observer_list( |
| 214 | new ObserverListThreadSafe<Foo>); |
| 215 | Adder a(1); |
| 216 | Adder b(-1); |
| 217 | Adder c(1); |
| 218 | Adder d(-1); |
| 219 | ThreadSafeDisrupter evil(observer_list.get(), &c); |
| 220 | |
| 221 | observer_list->AddObserver(&a); |
| 222 | observer_list->AddObserver(&b); |
| 223 | |
| 224 | observer_list->Notify(&Foo::Observe, 10); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 225 | RunLoop().RunUntilIdle(); |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 226 | |
| 227 | observer_list->AddObserver(&evil); |
| 228 | observer_list->AddObserver(&c); |
| 229 | observer_list->AddObserver(&d); |
| 230 | |
| 231 | observer_list->Notify(&Foo::Observe, 10); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 232 | RunLoop().RunUntilIdle(); |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 233 | |
tfarina@chromium.org | 4caddb0 | 2012-08-23 18:59:19 +0900 | [diff] [blame] | 234 | EXPECT_EQ(20, a.total); |
| 235 | EXPECT_EQ(-20, b.total); |
| 236 | EXPECT_EQ(0, c.total); |
| 237 | EXPECT_EQ(-10, d.total); |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 238 | } |
| 239 | |
akalin@chromium.org | cbec5fb | 2011-06-05 16:07:12 +0900 | [diff] [blame] | 240 | TEST(ObserverListThreadSafeTest, RemoveObserver) { |
| 241 | MessageLoop loop; |
| 242 | |
| 243 | scoped_refptr<ObserverListThreadSafe<Foo> > observer_list( |
| 244 | new ObserverListThreadSafe<Foo>); |
| 245 | Adder a(1), b(1); |
| 246 | |
alexeypa@chromium.org | 27c8ca7 | 2012-04-06 02:52:10 +0900 | [diff] [blame] | 247 | // A workaround for the compiler bug. See http://crbug.com/121960. |
| 248 | EXPECT_NE(&a, &b); |
| 249 | |
akalin@chromium.org | cbec5fb | 2011-06-05 16:07:12 +0900 | [diff] [blame] | 250 | // Should do nothing. |
| 251 | observer_list->RemoveObserver(&a); |
| 252 | observer_list->RemoveObserver(&b); |
| 253 | |
| 254 | observer_list->Notify(&Foo::Observe, 10); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 255 | RunLoop().RunUntilIdle(); |
akalin@chromium.org | cbec5fb | 2011-06-05 16:07:12 +0900 | [diff] [blame] | 256 | |
tfarina@chromium.org | 4caddb0 | 2012-08-23 18:59:19 +0900 | [diff] [blame] | 257 | EXPECT_EQ(0, a.total); |
| 258 | EXPECT_EQ(0, b.total); |
akalin@chromium.org | cbec5fb | 2011-06-05 16:07:12 +0900 | [diff] [blame] | 259 | |
| 260 | observer_list->AddObserver(&a); |
| 261 | |
| 262 | // Should also do nothing. |
| 263 | observer_list->RemoveObserver(&b); |
| 264 | |
| 265 | observer_list->Notify(&Foo::Observe, 10); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 266 | RunLoop().RunUntilIdle(); |
akalin@chromium.org | cbec5fb | 2011-06-05 16:07:12 +0900 | [diff] [blame] | 267 | |
tfarina@chromium.org | 4caddb0 | 2012-08-23 18:59:19 +0900 | [diff] [blame] | 268 | EXPECT_EQ(10, a.total); |
| 269 | EXPECT_EQ(0, b.total); |
akalin@chromium.org | cbec5fb | 2011-06-05 16:07:12 +0900 | [diff] [blame] | 270 | } |
| 271 | |
rsesek@chromium.org | 1aab77c | 2011-11-24 05:34:04 +0900 | [diff] [blame] | 272 | TEST(ObserverListThreadSafeTest, WithoutMessageLoop) { |
| 273 | scoped_refptr<ObserverListThreadSafe<Foo> > observer_list( |
| 274 | new ObserverListThreadSafe<Foo>); |
| 275 | |
| 276 | Adder a(1), b(1), c(1); |
| 277 | |
| 278 | // No MessageLoop, so these should not be added. |
| 279 | observer_list->AddObserver(&a); |
| 280 | observer_list->AddObserver(&b); |
| 281 | |
| 282 | { |
| 283 | // Add c when there's a loop. |
| 284 | MessageLoop loop; |
| 285 | observer_list->AddObserver(&c); |
| 286 | |
| 287 | observer_list->Notify(&Foo::Observe, 10); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 288 | RunLoop().RunUntilIdle(); |
rsesek@chromium.org | 1aab77c | 2011-11-24 05:34:04 +0900 | [diff] [blame] | 289 | |
| 290 | EXPECT_EQ(0, a.total); |
| 291 | EXPECT_EQ(0, b.total); |
| 292 | EXPECT_EQ(10, c.total); |
| 293 | |
| 294 | // Now add a when there's a loop. |
| 295 | observer_list->AddObserver(&a); |
| 296 | |
| 297 | // Remove c when there's a loop. |
| 298 | observer_list->RemoveObserver(&c); |
| 299 | |
| 300 | // Notify again. |
| 301 | observer_list->Notify(&Foo::Observe, 20); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 302 | RunLoop().RunUntilIdle(); |
rsesek@chromium.org | 1aab77c | 2011-11-24 05:34:04 +0900 | [diff] [blame] | 303 | |
| 304 | EXPECT_EQ(20, a.total); |
| 305 | EXPECT_EQ(0, b.total); |
| 306 | EXPECT_EQ(10, c.total); |
| 307 | } |
| 308 | |
| 309 | // Removing should always succeed with or without a loop. |
| 310 | observer_list->RemoveObserver(&a); |
| 311 | |
| 312 | // Notifying should not fail but should also be a no-op. |
| 313 | MessageLoop loop; |
| 314 | observer_list->AddObserver(&b); |
| 315 | observer_list->Notify(&Foo::Observe, 30); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 316 | RunLoop().RunUntilIdle(); |
rsesek@chromium.org | 1aab77c | 2011-11-24 05:34:04 +0900 | [diff] [blame] | 317 | |
| 318 | EXPECT_EQ(20, a.total); |
| 319 | EXPECT_EQ(30, b.total); |
| 320 | EXPECT_EQ(10, c.total); |
| 321 | } |
| 322 | |
willchan@chromium.org | 2777ca5 | 2010-09-18 04:33:06 +0900 | [diff] [blame] | 323 | class FooRemover : public Foo { |
| 324 | public: |
| 325 | explicit FooRemover(ObserverListThreadSafe<Foo>* list) : list_(list) {} |
| 326 | virtual ~FooRemover() {} |
| 327 | |
| 328 | void AddFooToRemove(Foo* foo) { |
| 329 | foos_.push_back(foo); |
| 330 | } |
| 331 | |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 332 | virtual void Observe(int x) OVERRIDE { |
willchan@chromium.org | 2777ca5 | 2010-09-18 04:33:06 +0900 | [diff] [blame] | 333 | std::vector<Foo*> tmp; |
| 334 | tmp.swap(foos_); |
| 335 | for (std::vector<Foo*>::iterator it = tmp.begin(); |
| 336 | it != tmp.end(); ++it) { |
| 337 | list_->RemoveObserver(*it); |
| 338 | } |
| 339 | } |
| 340 | |
| 341 | private: |
| 342 | const scoped_refptr<ObserverListThreadSafe<Foo> > list_; |
| 343 | std::vector<Foo*> foos_; |
| 344 | }; |
| 345 | |
| 346 | TEST(ObserverListThreadSafeTest, RemoveMultipleObservers) { |
| 347 | MessageLoop loop; |
| 348 | scoped_refptr<ObserverListThreadSafe<Foo> > observer_list( |
| 349 | new ObserverListThreadSafe<Foo>); |
| 350 | |
rsleevi@chromium.org | 7501b03 | 2013-06-01 06:37:53 +0900 | [diff] [blame] | 351 | FooRemover a(observer_list.get()); |
willchan@chromium.org | 2777ca5 | 2010-09-18 04:33:06 +0900 | [diff] [blame] | 352 | Adder b(1); |
| 353 | |
| 354 | observer_list->AddObserver(&a); |
| 355 | observer_list->AddObserver(&b); |
| 356 | |
| 357 | a.AddFooToRemove(&a); |
| 358 | a.AddFooToRemove(&b); |
| 359 | |
| 360 | observer_list->Notify(&Foo::Observe, 1); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 361 | RunLoop().RunUntilIdle(); |
willchan@chromium.org | 2777ca5 | 2010-09-18 04:33:06 +0900 | [diff] [blame] | 362 | } |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 363 | |
| 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 |
| 368 | // all observers. |
maruel@chromium.org | 8fe7adc | 2009-03-04 00:01:12 +0900 | [diff] [blame] | 369 | static void ThreadSafeObserverHarness(int num_threads, |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 370 | bool cross_thread_notifies) { |
| 371 | MessageLoop loop; |
| 372 | |
| 373 | const int kMaxThreads = 15; |
| 374 | num_threads = num_threads > kMaxThreads ? kMaxThreads : num_threads; |
| 375 | |
| 376 | scoped_refptr<ObserverListThreadSafe<Foo> > observer_list( |
| 377 | new ObserverListThreadSafe<Foo>); |
| 378 | Adder a(1); |
| 379 | Adder b(-1); |
| 380 | Adder c(1); |
| 381 | Adder d(-1); |
| 382 | |
| 383 | observer_list->AddObserver(&a); |
| 384 | observer_list->AddObserver(&b); |
| 385 | |
| 386 | AddRemoveThread* threaded_observer[kMaxThreads]; |
brettw@chromium.org | 6139182 | 2011-01-01 05:02:16 +0900 | [diff] [blame] | 387 | base::PlatformThreadHandle threads[kMaxThreads]; |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 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])); |
| 392 | } |
| 393 | |
| 394 | Time start = Time::Now(); |
| 395 | while (true) { |
| 396 | if ((Time::Now() - start).InMilliseconds() > kThreadRunTime) |
| 397 | break; |
| 398 | |
| 399 | observer_list->Notify(&Foo::Observe, 10); |
| 400 | |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 401 | RunLoop().RunUntilIdle(); |
mbelshe@google.com | 877d203 | 2008-10-23 08:09:21 +0900 | [diff] [blame] | 402 | } |
| 403 | |
| 404 | for (int index = 0; index < num_threads; index++) { |
| 405 | threaded_observer[index]->Quit(); |
| 406 | PlatformThread::Join(threads[index]); |
| 407 | } |
| 408 | } |
| 409 | |
| 410 | TEST(ObserverListThreadSafeTest, CrossThreadObserver) { |
| 411 | // Use 7 observer threads. Notifications only come from |
| 412 | // the main thread. |
| 413 | ThreadSafeObserverHarness(7, false); |
| 414 | } |
| 415 | |
| 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); |
| 420 | } |
sky@google.com | b92a56b | 2008-10-31 12:32:06 +0900 | [diff] [blame] | 421 | |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 422 | TEST(ObserverListThreadSafeTest, OutlivesMessageLoop) { |
| 423 | MessageLoop* loop = new MessageLoop; |
| 424 | scoped_refptr<ObserverListThreadSafe<Foo> > observer_list( |
| 425 | new ObserverListThreadSafe<Foo>); |
| 426 | |
| 427 | Adder a(1); |
| 428 | observer_list->AddObserver(&a); |
| 429 | delete loop; |
| 430 | // Test passes if we don't crash here. |
| 431 | observer_list->Notify(&Foo::Observe, 1); |
| 432 | } |
| 433 | |
sky@google.com | b92a56b | 2008-10-31 12:32:06 +0900 | [diff] [blame] | 434 | TEST(ObserverListTest, Existing) { |
| 435 | ObserverList<Foo> observer_list(ObserverList<Foo>::NOTIFY_EXISTING_ONLY); |
| 436 | Adder a(1); |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 437 | AddInObserve<ObserverList<Foo> > b(&observer_list); |
sky@google.com | b92a56b | 2008-10-31 12:32:06 +0900 | [diff] [blame] | 438 | |
| 439 | observer_list.AddObserver(&a); |
| 440 | observer_list.AddObserver(&b); |
| 441 | |
| 442 | FOR_EACH_OBSERVER(Foo, observer_list, Observe(1)); |
| 443 | |
| 444 | EXPECT_TRUE(b.added); |
| 445 | // B's adder should not have been notified because it was added during |
tnagel@chromium.org | a521af4 | 2014-05-09 08:49:40 +0900 | [diff] [blame] | 446 | // notification. |
sky@google.com | b92a56b | 2008-10-31 12:32:06 +0900 | [diff] [blame] | 447 | EXPECT_EQ(0, b.adder.total); |
| 448 | |
| 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); |
| 452 | } |
willchan@chromium.org | 57c5630 | 2010-02-25 12:09:41 +0900 | [diff] [blame] | 453 | |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 454 | // Same as above, but for ObserverListThreadSafe |
| 455 | TEST(ObserverListThreadSafeTest, Existing) { |
| 456 | MessageLoop loop; |
| 457 | scoped_refptr<ObserverListThreadSafe<Foo> > observer_list( |
| 458 | new ObserverListThreadSafe<Foo>(ObserverList<Foo>::NOTIFY_EXISTING_ONLY)); |
| 459 | Adder a(1); |
| 460 | AddInObserve<ObserverListThreadSafe<Foo> > b(observer_list.get()); |
| 461 | |
| 462 | observer_list->AddObserver(&a); |
| 463 | observer_list->AddObserver(&b); |
| 464 | |
| 465 | observer_list->Notify(&Foo::Observe, 1); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 466 | RunLoop().RunUntilIdle(); |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 467 | |
| 468 | EXPECT_TRUE(b.added); |
| 469 | // B's adder should not have been notified because it was added during |
tnagel@chromium.org | a521af4 | 2014-05-09 08:49:40 +0900 | [diff] [blame] | 470 | // notification. |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 471 | EXPECT_EQ(0, b.adder.total); |
| 472 | |
| 473 | // Notify again to make sure b's adder is notified. |
| 474 | observer_list->Notify(&Foo::Observe, 1); |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 475 | RunLoop().RunUntilIdle(); |
adamk@chromium.org | 2bc73e7 | 2011-08-10 06:29:59 +0900 | [diff] [blame] | 476 | EXPECT_EQ(1, b.adder.total); |
| 477 | } |
| 478 | |
willchan@chromium.org | 57c5630 | 2010-02-25 12:09:41 +0900 | [diff] [blame] | 479 | class AddInClearObserve : public Foo { |
| 480 | public: |
| 481 | explicit AddInClearObserve(ObserverList<Foo>* list) |
| 482 | : list_(list), added_(false), adder_(1) {} |
| 483 | |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 484 | virtual void Observe(int /* x */) OVERRIDE { |
willchan@chromium.org | 57c5630 | 2010-02-25 12:09:41 +0900 | [diff] [blame] | 485 | list_->Clear(); |
| 486 | list_->AddObserver(&adder_); |
| 487 | added_ = true; |
| 488 | } |
| 489 | |
| 490 | bool added() const { return added_; } |
| 491 | const Adder& adder() const { return adder_; } |
| 492 | |
| 493 | private: |
| 494 | ObserverList<Foo>* const list_; |
| 495 | |
| 496 | bool added_; |
| 497 | Adder adder_; |
| 498 | }; |
| 499 | |
| 500 | TEST(ObserverListTest, ClearNotifyAll) { |
| 501 | ObserverList<Foo> observer_list; |
| 502 | AddInClearObserve a(&observer_list); |
| 503 | |
| 504 | observer_list.AddObserver(&a); |
| 505 | |
| 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."; |
| 510 | } |
| 511 | |
| 512 | TEST(ObserverListTest, ClearNotifyExistingOnly) { |
| 513 | ObserverList<Foo> observer_list(ObserverList<Foo>::NOTIFY_EXISTING_ONLY); |
| 514 | AddInClearObserve a(&observer_list); |
| 515 | |
| 516 | observer_list.AddObserver(&a); |
| 517 | |
| 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."; |
| 522 | } |
| 523 | |
akalin@chromium.org | a7d2bc4 | 2011-06-09 12:41:18 +0900 | [diff] [blame] | 524 | class ListDestructor : public Foo { |
| 525 | public: |
| 526 | explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {} |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 527 | virtual ~ListDestructor() {} |
| 528 | |
| 529 | virtual void Observe(int x) OVERRIDE { |
akalin@chromium.org | a7d2bc4 | 2011-06-09 12:41:18 +0900 | [diff] [blame] | 530 | delete list_; |
| 531 | } |
tfarina@chromium.org | 2774420 | 2012-08-06 10:03:05 +0900 | [diff] [blame] | 532 | |
akalin@chromium.org | a7d2bc4 | 2011-06-09 12:41:18 +0900 | [diff] [blame] | 533 | private: |
| 534 | ObserverList<Foo>* list_; |
| 535 | }; |
| 536 | |
| 537 | |
| 538 | TEST(ObserverListTest, IteratorOutlivesList) { |
| 539 | ObserverList<Foo>* observer_list = new ObserverList<Foo>; |
| 540 | ListDestructor a(observer_list); |
| 541 | observer_list->AddObserver(&a); |
| 542 | |
| 543 | FOR_EACH_OBSERVER(Foo, *observer_list, Observe(0)); |
| 544 | // If this test fails, there'll be Valgrind errors when this function goes out |
| 545 | // of scope. |
| 546 | } |
| 547 | |
willchan@chromium.org | 57c5630 | 2010-02-25 12:09:41 +0900 | [diff] [blame] | 548 | } // namespace |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 549 | } // namespace base |