base/observer_list_unittest.cc

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