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 <memory>
   9 #include <utility>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/location.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/message_loop/message_loop.h"
  17 #include "base/run_loop.h"
  18 #include "base/sequenced_task_runner.h"
  19 #include "base/single_thread_task_runner.h"
  20 #include "base/synchronization/waitable_event.h"
  21 #include "base/task_scheduler/post_task.h"
  22 #include "base/task_scheduler/task_scheduler.h"
  23 #include "base/test/gtest_util.h"
  24 #include "base/test/scoped_task_environment.h"
  25 #include "base/threading/platform_thread.h"
  26 #include "base/threading/thread_restrictions.h"
  27 #include "build/build_config.h"
  28 #include "testing/gmock/include/gmock/gmock.h"
  29 #include "testing/gtest/include/gtest/gtest.h"
  30
  31 namespace base {
  32 namespace {
  33
  34 class Foo {
  35  public:
  36   virtual void Observe(int x) = 0;
  37   virtual ~Foo() = default;
  38   virtual int GetValue() const { return 0; }
  39 };
  40
  41 class Adder : public Foo {
  42  public:
  43   explicit Adder(int scaler) : total(0), scaler_(scaler) {}
  44   ~Adder() override = default;
  45
  46   void Observe(int x) override { total += x * scaler_; }
  47   int GetValue() const override { return total; }
  48
  49   int total;
  50
  51  private:
  52   int scaler_;
  53 };
  54
  55 class Disrupter : public Foo {
  56  public:
  57   Disrupter(ObserverList<Foo>* list, Foo* doomed, bool remove_self)
  58       : list_(list), doomed_(doomed), remove_self_(remove_self) {}
  59   Disrupter(ObserverList<Foo>* list, Foo* doomed)
  60       : Disrupter(list, doomed, false) {}
  61   Disrupter(ObserverList<Foo>* list, bool remove_self)
  62       : Disrupter(list, nullptr, remove_self) {}
  63
  64   ~Disrupter() override = default;
  65
  66   void Observe(int x) override {
  67     if (remove_self_)
  68       list_->RemoveObserver(this);
  69     if (doomed_)
  70       list_->RemoveObserver(doomed_);
  71   }
  72
  73   void SetDoomed(Foo* doomed) { doomed_ = doomed; }
  74
  75  private:
  76   ObserverList<Foo>* list_;
  77   Foo* doomed_;
  78   bool remove_self_;
  79 };
  80
  81 template <typename ObserverListType>
  82 class AddInObserve : public Foo {
  83  public:
  84   explicit AddInObserve(ObserverListType* observer_list)
  85       : observer_list(observer_list), to_add_() {}
  86
  87   void SetToAdd(Foo* to_add) { to_add_ = to_add; }
  88
  89   void Observe(int x) override {
  90     if (to_add_) {
  91       observer_list->AddObserver(to_add_);
  92       to_add_ = nullptr;
  93     }
  94   }
  95
  96   ObserverListType* observer_list;
  97   Foo* to_add_;
  98 };
  99
 100
 101 static const int kThreadRunTime = 2000;  // ms to run the multi-threaded test.
 102
 103 // A thread for use in the ThreadSafeObserver test
 104 // which will add and remove itself from the notification
 105 // list repeatedly.
 106 class AddRemoveThread : public PlatformThread::Delegate,
 107                         public Foo {
 108  public:
 109   AddRemoveThread(ObserverListThreadSafe<Foo>* list,
 110                   bool notify,
 111                   WaitableEvent* ready)
 112       : list_(list),
 113         loop_(nullptr),
 114         in_list_(false),
 115         start_(Time::Now()),
 116         count_observes_(0),
 117         count_addtask_(0),
 118         do_notifies_(notify),
 119         ready_(ready),
 120         weak_factory_(this) {}
 121
 122   ~AddRemoveThread() override = default;
 123
 124   void ThreadMain() override {
 125     loop_ = new MessageLoop();  // Fire up a message loop.
 126     loop_->task_runner()->PostTask(
 127         FROM_HERE,
 128         base::BindOnce(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
 129     ready_->Signal();
 130     // After ready_ is signaled, loop_ is only accessed by the main test thread
 131     // (i.e. not this thread) in particular by Quit() which causes Run() to
 132     // return, and we "control" loop_ again.
 133     RunLoop run_loop;
 134     quit_loop_ = run_loop.QuitClosure();
 135     run_loop.Run();
 136     delete loop_;
 137     loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef);
 138     delete this;
 139   }
 140
 141   // This task just keeps posting to itself in an attempt
 142   // to race with the notifier.
 143   void AddTask() {
 144     count_addtask_++;
 145
 146     if ((Time::Now() - start_).InMilliseconds() > kThreadRunTime) {
 147       VLOG(1) << "DONE!";
 148       return;
 149     }
 150
 151     if (!in_list_) {
 152       list_->AddObserver(this);
 153       in_list_ = true;
 154     }
 155
 156     if (do_notifies_) {
 157       list_->Notify(FROM_HERE, &Foo::Observe, 10);
 158     }
 159
 160     loop_->task_runner()->PostTask(
 161         FROM_HERE,
 162         base::BindOnce(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
 163   }
 164
 165   // This function is only callable from the main thread.
 166   void Quit() { std::move(quit_loop_).Run(); }
 167
 168   void Observe(int x) override {
 169     count_observes_++;
 170
 171     // If we're getting called after we removed ourselves from
 172     // the list, that is very bad!
 173     DCHECK(in_list_);
 174
 175     // This callback should fire on the appropriate thread
 176     EXPECT_EQ(loop_, MessageLoop::current());
 177
 178     list_->RemoveObserver(this);
 179     in_list_ = false;
 180   }
 181
 182  private:
 183   ObserverListThreadSafe<Foo>* list_;
 184   MessageLoop* loop_;
 185   bool in_list_;        // Are we currently registered for notifications.
 186                         // in_list_ is only used on |this| thread.
 187   Time start_;          // The time we started the test.
 188
 189   int count_observes_;  // Number of times we observed.
 190   int count_addtask_;   // Number of times thread AddTask was called
 191   bool do_notifies_;    // Whether these threads should do notifications.
 192   WaitableEvent* ready_;
 193
 194   base::OnceClosure quit_loop_;
 195
 196   base::WeakPtrFactory<AddRemoveThread> weak_factory_;
 197 };
 198
 199 }  // namespace
 200
 201 TEST(ObserverListTest, BasicTest) {
 202   ObserverList<Foo> observer_list;
 203   const ObserverList<Foo>& const_observer_list = observer_list;
 204
 205   {
 206     const ObserverList<Foo>::const_iterator it1 = const_observer_list.begin();
 207     EXPECT_EQ(it1, const_observer_list.end());
 208     // Iterator copy.
 209     const ObserverList<Foo>::const_iterator it2 = it1;
 210     EXPECT_EQ(it2, it1);
 211     // Iterator assignment.
 212     ObserverList<Foo>::const_iterator it3;
 213     it3 = it2;
 214     EXPECT_EQ(it3, it1);
 215     EXPECT_EQ(it3, it2);
 216     // Self assignment.
 217     it3 = *&it3;  // The *& defeats Clang's -Wself-assign warning.
 218     EXPECT_EQ(it3, it1);
 219     EXPECT_EQ(it3, it2);
 220   }
 221
 222   {
 223     const ObserverList<Foo>::iterator it1 = observer_list.begin();
 224     EXPECT_EQ(it1, observer_list.end());
 225     // Iterator copy.
 226     const ObserverList<Foo>::iterator it2 = it1;
 227     EXPECT_EQ(it2, it1);
 228     // Iterator assignment.
 229     ObserverList<Foo>::iterator it3;
 230     it3 = it2;
 231     EXPECT_EQ(it3, it1);
 232     EXPECT_EQ(it3, it2);
 233     // Self assignment.
 234     it3 = *&it3;  // The *& defeats Clang's -Wself-assign warning.
 235     EXPECT_EQ(it3, it1);
 236     EXPECT_EQ(it3, it2);
 237   }
 238
 239   Adder a(1), b(-1), c(1), d(-1), e(-1);
 240   Disrupter evil(&observer_list, &c);
 241
 242   observer_list.AddObserver(&a);
 243   observer_list.AddObserver(&b);
 244
 245   EXPECT_TRUE(const_observer_list.HasObserver(&a));
 246   EXPECT_FALSE(const_observer_list.HasObserver(&c));
 247
 248   {
 249     const ObserverList<Foo>::const_iterator it1 = const_observer_list.begin();
 250     EXPECT_NE(it1, const_observer_list.end());
 251     // Iterator copy.
 252     const ObserverList<Foo>::const_iterator it2 = it1;
 253     EXPECT_EQ(it2, it1);
 254     EXPECT_NE(it2, const_observer_list.end());
 255     // Iterator assignment.
 256     ObserverList<Foo>::const_iterator it3;
 257     it3 = it2;
 258     EXPECT_EQ(it3, it1);
 259     EXPECT_EQ(it3, it2);
 260     // Self assignment.
 261     it3 = *&it3;  // The *& defeats Clang's -Wself-assign warning.
 262     EXPECT_EQ(it3, it1);
 263     EXPECT_EQ(it3, it2);
 264     // Iterator post increment.
 265     ObserverList<Foo>::const_iterator it4 = it3++;
 266     EXPECT_EQ(it4, it1);
 267     EXPECT_EQ(it4, it2);
 268     EXPECT_NE(it4, it3);
 269   }
 270
 271   {
 272     const ObserverList<Foo>::iterator it1 = observer_list.begin();
 273     EXPECT_NE(it1, observer_list.end());
 274     // Iterator copy.
 275     const ObserverList<Foo>::iterator it2 = it1;
 276     EXPECT_EQ(it2, it1);
 277     EXPECT_NE(it2, observer_list.end());
 278     // Iterator assignment.
 279     ObserverList<Foo>::iterator it3;
 280     it3 = it2;
 281     EXPECT_EQ(it3, it1);
 282     EXPECT_EQ(it3, it2);
 283     // Self assignment.
 284     it3 = *&it3;  // The *& defeats Clang's -Wself-assign warning.
 285     EXPECT_EQ(it3, it1);
 286     EXPECT_EQ(it3, it2);
 287     // Iterator post increment.
 288     ObserverList<Foo>::iterator it4 = it3++;
 289     EXPECT_EQ(it4, it1);
 290     EXPECT_EQ(it4, it2);
 291     EXPECT_NE(it4, it3);
 292   }
 293
 294   for (auto& observer : observer_list)
 295     observer.Observe(10);
 296
 297   observer_list.AddObserver(&evil);
 298   observer_list.AddObserver(&c);
 299   observer_list.AddObserver(&d);
 300
 301   // Removing an observer not in the list should do nothing.
 302   observer_list.RemoveObserver(&e);
 303
 304   for (auto& observer : observer_list)
 305     observer.Observe(10);
 306
 307   EXPECT_EQ(20, a.total);
 308   EXPECT_EQ(-20, b.total);
 309   EXPECT_EQ(0, c.total);
 310   EXPECT_EQ(-10, d.total);
 311   EXPECT_EQ(0, e.total);
 312 }
 313
 314 TEST(ObserverListTest, CompactsWhenNoActiveIterator) {
 315   ObserverList<const Foo> ol;
 316   const ObserverList<const Foo>& col = ol;
 317
 318   const Adder a(1);
 319   const Adder b(2);
 320   const Adder c(3);
 321
 322   ol.AddObserver(&a);
 323   ol.AddObserver(&b);
 324
 325   EXPECT_TRUE(col.HasObserver(&a));
 326   EXPECT_FALSE(col.HasObserver(&c));
 327
 328   EXPECT_TRUE(col.might_have_observers());
 329
 330   using It = ObserverList<const Foo>::const_iterator;
 331
 332   {
 333     It it = col.begin();
 334     EXPECT_NE(it, col.end());
 335     It ita = it;
 336     EXPECT_EQ(ita, it);
 337     EXPECT_NE(++it, col.end());
 338     EXPECT_NE(ita, it);
 339     It itb = it;
 340     EXPECT_EQ(itb, it);
 341     EXPECT_EQ(++it, col.end());
 342
 343     EXPECT_TRUE(col.might_have_observers());
 344     EXPECT_EQ(&*ita, &a);
 345     EXPECT_EQ(&*itb, &b);
 346
 347     ol.RemoveObserver(&a);
 348     EXPECT_TRUE(col.might_have_observers());
 349     EXPECT_FALSE(col.HasObserver(&a));
 350     EXPECT_EQ(&*itb, &b);
 351
 352     ol.RemoveObserver(&b);
 353     EXPECT_TRUE(col.might_have_observers());
 354     EXPECT_FALSE(col.HasObserver(&a));
 355     EXPECT_FALSE(col.HasObserver(&b));
 356
 357     it = It();
 358     ita = It();
 359     EXPECT_TRUE(col.might_have_observers());
 360     ita = itb;
 361     itb = It();
 362     EXPECT_TRUE(col.might_have_observers());
 363     ita = It();
 364     EXPECT_FALSE(col.might_have_observers());
 365   }
 366
 367   ol.AddObserver(&a);
 368   ol.AddObserver(&b);
 369   EXPECT_TRUE(col.might_have_observers());
 370   ol.Clear();
 371   EXPECT_FALSE(col.might_have_observers());
 372
 373   ol.AddObserver(&a);
 374   ol.AddObserver(&b);
 375   EXPECT_TRUE(col.might_have_observers());
 376   {
 377     const It it = col.begin();
 378     ol.Clear();
 379     EXPECT_TRUE(col.might_have_observers());
 380   }
 381   EXPECT_FALSE(col.might_have_observers());
 382 }
 383
 384 TEST(ObserverListTest, DisruptSelf) {
 385   ObserverList<Foo> observer_list;
 386   Adder a(1), b(-1), c(1), d(-1);
 387   Disrupter evil(&observer_list, true);
 388
 389   observer_list.AddObserver(&a);
 390   observer_list.AddObserver(&b);
 391
 392   for (auto& observer : observer_list)
 393     observer.Observe(10);
 394
 395   observer_list.AddObserver(&evil);
 396   observer_list.AddObserver(&c);
 397   observer_list.AddObserver(&d);
 398
 399   for (auto& observer : observer_list)
 400     observer.Observe(10);
 401
 402   EXPECT_EQ(20, a.total);
 403   EXPECT_EQ(-20, b.total);
 404   EXPECT_EQ(10, c.total);
 405   EXPECT_EQ(-10, d.total);
 406 }
 407
 408 TEST(ObserverListTest, DisruptBefore) {
 409   ObserverList<Foo> observer_list;
 410   Adder a(1), b(-1), c(1), d(-1);
 411   Disrupter evil(&observer_list, &b);
 412
 413   observer_list.AddObserver(&a);
 414   observer_list.AddObserver(&b);
 415   observer_list.AddObserver(&evil);
 416   observer_list.AddObserver(&c);
 417   observer_list.AddObserver(&d);
 418
 419   for (auto& observer : observer_list)
 420     observer.Observe(10);
 421   for (auto& observer : observer_list)
 422     observer.Observe(10);
 423
 424   EXPECT_EQ(20, a.total);
 425   EXPECT_EQ(-10, b.total);
 426   EXPECT_EQ(20, c.total);
 427   EXPECT_EQ(-20, d.total);
 428 }
 429
 430 TEST(ObserverListThreadSafeTest, BasicTest) {
 431   MessageLoop loop;
 432
 433   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
 434       new ObserverListThreadSafe<Foo>);
 435   Adder a(1);
 436   Adder b(-1);
 437   Adder c(1);
 438   Adder d(-1);
 439
 440   observer_list->AddObserver(&a);
 441   observer_list->AddObserver(&b);
 442
 443   observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
 444   RunLoop().RunUntilIdle();
 445
 446   observer_list->AddObserver(&c);
 447   observer_list->AddObserver(&d);
 448
 449   observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
 450   observer_list->RemoveObserver(&c);
 451   RunLoop().RunUntilIdle();
 452
 453   EXPECT_EQ(20, a.total);
 454   EXPECT_EQ(-20, b.total);
 455   EXPECT_EQ(0, c.total);
 456   EXPECT_EQ(-10, d.total);
 457 }
 458
 459 TEST(ObserverListThreadSafeTest, RemoveObserver) {
 460   MessageLoop loop;
 461
 462   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
 463       new ObserverListThreadSafe<Foo>);
 464   Adder a(1), b(1);
 465
 466   // A workaround for the compiler bug. See http://crbug.com/121960.
 467   EXPECT_NE(&a, &b);
 468
 469   // Should do nothing.
 470   observer_list->RemoveObserver(&a);
 471   observer_list->RemoveObserver(&b);
 472
 473   observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
 474   RunLoop().RunUntilIdle();
 475
 476   EXPECT_EQ(0, a.total);
 477   EXPECT_EQ(0, b.total);
 478
 479   observer_list->AddObserver(&a);
 480
 481   // Should also do nothing.
 482   observer_list->RemoveObserver(&b);
 483
 484   observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
 485   RunLoop().RunUntilIdle();
 486
 487   EXPECT_EQ(10, a.total);
 488   EXPECT_EQ(0, b.total);
 489 }
 490
 491 TEST(ObserverListThreadSafeTest, WithoutSequence) {
 492   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
 493       new ObserverListThreadSafe<Foo>);
 494
 495   Adder a(1), b(1), c(1);
 496
 497   // No sequence, so these should not be added.
 498   observer_list->AddObserver(&a);
 499   observer_list->AddObserver(&b);
 500
 501   {
 502     // Add c when there's a sequence.
 503     MessageLoop loop;
 504     observer_list->AddObserver(&c);
 505
 506     observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
 507     RunLoop().RunUntilIdle();
 508
 509     EXPECT_EQ(0, a.total);
 510     EXPECT_EQ(0, b.total);
 511     EXPECT_EQ(10, c.total);
 512
 513     // Now add a when there's a sequence.
 514     observer_list->AddObserver(&a);
 515
 516     // Remove c when there's a sequence.
 517     observer_list->RemoveObserver(&c);
 518
 519     // Notify again.
 520     observer_list->Notify(FROM_HERE, &Foo::Observe, 20);
 521     RunLoop().RunUntilIdle();
 522
 523     EXPECT_EQ(20, a.total);
 524     EXPECT_EQ(0, b.total);
 525     EXPECT_EQ(10, c.total);
 526   }
 527
 528   // Removing should always succeed with or without a sequence.
 529   observer_list->RemoveObserver(&a);
 530
 531   // Notifying should not fail but should also be a no-op.
 532   MessageLoop loop;
 533   observer_list->AddObserver(&b);
 534   observer_list->Notify(FROM_HERE, &Foo::Observe, 30);
 535   RunLoop().RunUntilIdle();
 536
 537   EXPECT_EQ(20, a.total);
 538   EXPECT_EQ(30, b.total);
 539   EXPECT_EQ(10, c.total);
 540 }
 541
 542 class FooRemover : public Foo {
 543  public:
 544   explicit FooRemover(ObserverListThreadSafe<Foo>* list) : list_(list) {}
 545   ~FooRemover() override = default;
 546
 547   void AddFooToRemove(Foo* foo) {
 548     foos_.push_back(foo);
 549   }
 550
 551   void Observe(int x) override {
 552     std::vector<Foo*> tmp;
 553     tmp.swap(foos_);
 554     for (std::vector<Foo*>::iterator it = tmp.begin();
 555          it != tmp.end(); ++it) {
 556       list_->RemoveObserver(*it);
 557     }
 558   }
 559
 560  private:
 561   const scoped_refptr<ObserverListThreadSafe<Foo> > list_;
 562   std::vector<Foo*> foos_;
 563 };
 564
 565 TEST(ObserverListThreadSafeTest, RemoveMultipleObservers) {
 566   MessageLoop loop;
 567   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
 568       new ObserverListThreadSafe<Foo>);
 569
 570   FooRemover a(observer_list.get());
 571   Adder b(1);
 572
 573   observer_list->AddObserver(&a);
 574   observer_list->AddObserver(&b);
 575
 576   a.AddFooToRemove(&a);
 577   a.AddFooToRemove(&b);
 578
 579   observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
 580   RunLoop().RunUntilIdle();
 581 }
 582
 583 // A test driver for a multi-threaded notification loop.  Runs a number
 584 // of observer threads, each of which constantly adds/removes itself
 585 // from the observer list.  Optionally, if cross_thread_notifies is set
 586 // to true, the observer threads will also trigger notifications to
 587 // all observers.
 588 static void ThreadSafeObserverHarness(int num_threads,
 589                                       bool cross_thread_notifies) {
 590   MessageLoop loop;
 591
 592   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
 593       new ObserverListThreadSafe<Foo>);
 594   Adder a(1);
 595   Adder b(-1);
 596
 597   observer_list->AddObserver(&a);
 598   observer_list->AddObserver(&b);
 599
 600   std::vector<AddRemoveThread*> threaded_observer;
 601   std::vector<base::PlatformThreadHandle> threads(num_threads);
 602   std::vector<std::unique_ptr<base::WaitableEvent>> ready;
 603   threaded_observer.reserve(num_threads);
 604   ready.reserve(num_threads);
 605   for (int index = 0; index < num_threads; index++) {
 606     ready.push_back(std::make_unique<WaitableEvent>(
 607         WaitableEvent::ResetPolicy::MANUAL,
 608         WaitableEvent::InitialState::NOT_SIGNALED));
 609     threaded_observer.push_back(new AddRemoveThread(
 610         observer_list.get(), cross_thread_notifies, ready.back().get()));
 611     EXPECT_TRUE(
 612         PlatformThread::Create(0, threaded_observer.back(), &threads[index]));
 613   }
 614   ASSERT_EQ(static_cast<size_t>(num_threads), threaded_observer.size());
 615   ASSERT_EQ(static_cast<size_t>(num_threads), ready.size());
 616
 617   // This makes sure that threaded_observer has gotten to set loop_, so that we
 618   // can call Quit() below safe-ish-ly.
 619   for (int i = 0; i < num_threads; ++i)
 620     ready[i]->Wait();
 621
 622   Time start = Time::Now();
 623   while (true) {
 624     if ((Time::Now() - start).InMilliseconds() > kThreadRunTime)
 625       break;
 626
 627     observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
 628
 629     RunLoop().RunUntilIdle();
 630   }
 631
 632   for (int index = 0; index < num_threads; index++) {
 633     threaded_observer[index]->Quit();
 634     PlatformThread::Join(threads[index]);
 635   }
 636 }
 637
 638 #if defined(OS_FUCHSIA)
 639 // TODO(crbug.com/738275): This is flaky on Fuchsia.
 640 #define MAYBE_CrossThreadObserver DISABLED_CrossThreadObserver
 641 #else
 642 #define MAYBE_CrossThreadObserver CrossThreadObserver
 643 #endif
 644 TEST(ObserverListThreadSafeTest, MAYBE_CrossThreadObserver) {
 645   // Use 7 observer threads.  Notifications only come from
 646   // the main thread.
 647   ThreadSafeObserverHarness(7, false);
 648 }
 649
 650 TEST(ObserverListThreadSafeTest, CrossThreadNotifications) {
 651   // Use 3 observer threads.  Notifications will fire from
 652   // the main thread and all 3 observer threads.
 653   ThreadSafeObserverHarness(3, true);
 654 }
 655
 656 TEST(ObserverListThreadSafeTest, OutlivesMessageLoop) {
 657   MessageLoop* loop = new MessageLoop;
 658   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
 659       new ObserverListThreadSafe<Foo>);
 660
 661   Adder a(1);
 662   observer_list->AddObserver(&a);
 663   delete loop;
 664   // Test passes if we don't crash here.
 665   observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
 666 }
 667
 668 namespace {
 669
 670 class SequenceVerificationObserver : public Foo {
 671  public:
 672   explicit SequenceVerificationObserver(
 673       scoped_refptr<SequencedTaskRunner> task_runner)
 674       : task_runner_(std::move(task_runner)) {}
 675   ~SequenceVerificationObserver() override = default;
 676
 677   void Observe(int x) override {
 678     called_on_valid_sequence_ = task_runner_->RunsTasksInCurrentSequence();
 679   }
 680
 681   bool called_on_valid_sequence() const { return called_on_valid_sequence_; }
 682
 683  private:
 684   const scoped_refptr<SequencedTaskRunner> task_runner_;
 685   bool called_on_valid_sequence_ = false;
 686
 687   DISALLOW_COPY_AND_ASSIGN(SequenceVerificationObserver);
 688 };
 689
 690 }  // namespace
 691
 692 // Verify that observers are notified on the correct sequence.
 693 TEST(ObserverListThreadSafeTest, NotificationOnValidSequence) {
 694   test::ScopedTaskEnvironment scoped_task_environment;
 695
 696   auto task_runner_1 = CreateSequencedTaskRunnerWithTraits(TaskTraits());
 697   auto task_runner_2 = CreateSequencedTaskRunnerWithTraits(TaskTraits());
 698
 699   auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
 700
 701   SequenceVerificationObserver observer_1(task_runner_1);
 702   SequenceVerificationObserver observer_2(task_runner_2);
 703
 704   task_runner_1->PostTask(FROM_HERE,
 705                           BindOnce(&ObserverListThreadSafe<Foo>::AddObserver,
 706                                    observer_list, Unretained(&observer_1)));
 707   task_runner_2->PostTask(FROM_HERE,
 708                           BindOnce(&ObserverListThreadSafe<Foo>::AddObserver,
 709                                    observer_list, Unretained(&observer_2)));
 710
 711   TaskScheduler::GetInstance()->FlushForTesting();
 712
 713   observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
 714
 715   TaskScheduler::GetInstance()->FlushForTesting();
 716
 717   EXPECT_TRUE(observer_1.called_on_valid_sequence());
 718   EXPECT_TRUE(observer_2.called_on_valid_sequence());
 719 }
 720
 721 // Verify that when an observer is added to a NOTIFY_ALL ObserverListThreadSafe
 722 // from a notification, it is itself notified.
 723 TEST(ObserverListThreadSafeTest, AddObserverFromNotificationNotifyAll) {
 724   test::ScopedTaskEnvironment scoped_task_environment;
 725   auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
 726
 727   Adder observer_added_from_notification(1);
 728
 729   AddInObserve<ObserverListThreadSafe<Foo>> initial_observer(
 730       observer_list.get());
 731   initial_observer.SetToAdd(&observer_added_from_notification);
 732   observer_list->AddObserver(&initial_observer);
 733
 734   observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
 735
 736   base::RunLoop().RunUntilIdle();
 737
 738   EXPECT_EQ(1, observer_added_from_notification.GetValue());
 739 }
 740
 741 namespace {
 742
 743 class RemoveWhileNotificationIsRunningObserver : public Foo {
 744  public:
 745   RemoveWhileNotificationIsRunningObserver()
 746       : notification_running_(WaitableEvent::ResetPolicy::AUTOMATIC,
 747                               WaitableEvent::InitialState::NOT_SIGNALED),
 748         barrier_(WaitableEvent::ResetPolicy::AUTOMATIC,
 749                  WaitableEvent::InitialState::NOT_SIGNALED) {}
 750   ~RemoveWhileNotificationIsRunningObserver() override = default;
 751
 752   void Observe(int x) override {
 753     notification_running_.Signal();
 754     ScopedAllowBaseSyncPrimitivesForTesting allow_base_sync_primitives;
 755     barrier_.Wait();
 756   }
 757
 758   void WaitForNotificationRunning() { notification_running_.Wait(); }
 759   void Unblock() { barrier_.Signal(); }
 760
 761  private:
 762   WaitableEvent notification_running_;
 763   WaitableEvent barrier_;
 764
 765   DISALLOW_COPY_AND_ASSIGN(RemoveWhileNotificationIsRunningObserver);
 766 };
 767
 768 }  // namespace
 769
 770 // Verify that there is no crash when an observer is removed while it is being
 771 // notified.
 772 TEST(ObserverListThreadSafeTest, RemoveWhileNotificationIsRunning) {
 773   auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
 774   RemoveWhileNotificationIsRunningObserver observer;
 775
 776   WaitableEvent task_running(WaitableEvent::ResetPolicy::AUTOMATIC,
 777                              WaitableEvent::InitialState::NOT_SIGNALED);
 778   WaitableEvent barrier(WaitableEvent::ResetPolicy::AUTOMATIC,
 779                         WaitableEvent::InitialState::NOT_SIGNALED);
 780
 781   // This must be after the declaration of |barrier| so that tasks posted to
 782   // TaskScheduler can safely use |barrier|.
 783   test::ScopedTaskEnvironment scoped_task_environment;
 784
 785   CreateSequencedTaskRunnerWithTraits({})->PostTask(
 786       FROM_HERE, base::BindOnce(&ObserverListThreadSafe<Foo>::AddObserver,
 787                                 observer_list, Unretained(&observer)));
 788   TaskScheduler::GetInstance()->FlushForTesting();
 789
 790   observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
 791   observer.WaitForNotificationRunning();
 792   observer_list->RemoveObserver(&observer);
 793
 794   observer.Unblock();
 795 }
 796
 797 TEST(ObserverListTest, Existing) {
 798   ObserverList<Foo> observer_list(ObserverListPolicy::EXISTING_ONLY);
 799   Adder a(1);
 800   AddInObserve<ObserverList<Foo> > b(&observer_list);
 801   Adder c(1);
 802   b.SetToAdd(&c);
 803
 804   observer_list.AddObserver(&a);
 805   observer_list.AddObserver(&b);
 806
 807   for (auto& observer : observer_list)
 808     observer.Observe(1);
 809
 810   EXPECT_FALSE(b.to_add_);
 811   // B's adder should not have been notified because it was added during
 812   // notification.
 813   EXPECT_EQ(0, c.total);
 814
 815   // Notify again to make sure b's adder is notified.
 816   for (auto& observer : observer_list)
 817     observer.Observe(1);
 818   EXPECT_EQ(1, c.total);
 819 }
 820
 821 // Same as above, but for ObserverListThreadSafe
 822 TEST(ObserverListThreadSafeTest, Existing) {
 823   MessageLoop loop;
 824   scoped_refptr<ObserverListThreadSafe<Foo>> observer_list(
 825       new ObserverListThreadSafe<Foo>(ObserverListPolicy::EXISTING_ONLY));
 826   Adder a(1);
 827   AddInObserve<ObserverListThreadSafe<Foo> > b(observer_list.get());
 828   Adder c(1);
 829   b.SetToAdd(&c);
 830
 831   observer_list->AddObserver(&a);
 832   observer_list->AddObserver(&b);
 833
 834   observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
 835   RunLoop().RunUntilIdle();
 836
 837   EXPECT_FALSE(b.to_add_);
 838   // B's adder should not have been notified because it was added during
 839   // notification.
 840   EXPECT_EQ(0, c.total);
 841
 842   // Notify again to make sure b's adder is notified.
 843   observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
 844   RunLoop().RunUntilIdle();
 845   EXPECT_EQ(1, c.total);
 846 }
 847
 848 class AddInClearObserve : public Foo {
 849  public:
 850   explicit AddInClearObserve(ObserverList<Foo>* list)
 851       : list_(list), added_(false), adder_(1) {}
 852
 853   void Observe(int /* x */) override {
 854     list_->Clear();
 855     list_->AddObserver(&adder_);
 856     added_ = true;
 857   }
 858
 859   bool added() const { return added_; }
 860   const Adder& adder() const { return adder_; }
 861
 862  private:
 863   ObserverList<Foo>* const list_;
 864
 865   bool added_;
 866   Adder adder_;
 867 };
 868
 869 TEST(ObserverListTest, ClearNotifyAll) {
 870   ObserverList<Foo> observer_list;
 871   AddInClearObserve a(&observer_list);
 872
 873   observer_list.AddObserver(&a);
 874
 875   for (auto& observer : observer_list)
 876     observer.Observe(1);
 877   EXPECT_TRUE(a.added());
 878   EXPECT_EQ(1, a.adder().total)
 879       << "Adder should observe once and have sum of 1.";
 880 }
 881
 882 TEST(ObserverListTest, ClearNotifyExistingOnly) {
 883   ObserverList<Foo> observer_list(ObserverListPolicy::EXISTING_ONLY);
 884   AddInClearObserve a(&observer_list);
 885
 886   observer_list.AddObserver(&a);
 887
 888   for (auto& observer : observer_list)
 889     observer.Observe(1);
 890   EXPECT_TRUE(a.added());
 891   EXPECT_EQ(0, a.adder().total)
 892       << "Adder should not observe, so sum should still be 0.";
 893 }
 894
 895 class ListDestructor : public Foo {
 896  public:
 897   explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {}
 898   ~ListDestructor() override = default;
 899
 900   void Observe(int x) override { delete list_; }
 901
 902  private:
 903   ObserverList<Foo>* list_;
 904 };
 905
 906
 907 TEST(ObserverListTest, IteratorOutlivesList) {
 908   ObserverList<Foo>* observer_list = new ObserverList<Foo>;
 909   ListDestructor a(observer_list);
 910   observer_list->AddObserver(&a);
 911
 912   for (auto& observer : *observer_list)
 913     observer.Observe(0);
 914
 915   // There are no EXPECT* statements for this test, if we catch
 916   // use-after-free errors for observer_list (eg with ASan) then
 917   // this test has failed.  See http://crbug.com/85296.
 918 }
 919
 920 TEST(ObserverListTest, BasicStdIterator) {
 921   using FooList = ObserverList<Foo>;
 922   FooList observer_list;
 923
 924   // An optimization: begin() and end() do not involve weak pointers on
 925   // empty list.
 926   EXPECT_FALSE(observer_list.begin().list_);
 927   EXPECT_FALSE(observer_list.end().list_);
 928
 929   // Iterate over empty list: no effect, no crash.
 930   for (auto& i : observer_list)
 931     i.Observe(10);
 932
 933   Adder a(1), b(-1), c(1), d(-1);
 934
 935   observer_list.AddObserver(&a);
 936   observer_list.AddObserver(&b);
 937   observer_list.AddObserver(&c);
 938   observer_list.AddObserver(&d);
 939
 940   for (FooList::iterator i = observer_list.begin(), e = observer_list.end();
 941        i != e; ++i)
 942     i->Observe(1);
 943
 944   EXPECT_EQ(1, a.total);
 945   EXPECT_EQ(-1, b.total);
 946   EXPECT_EQ(1, c.total);
 947   EXPECT_EQ(-1, d.total);
 948
 949   // Check an iteration over a 'const view' for a given container.
 950   const FooList& const_list = observer_list;
 951   for (FooList::const_iterator i = const_list.begin(), e = const_list.end();
 952        i != e; ++i) {
 953     EXPECT_EQ(1, std::abs(i->GetValue()));
 954   }
 955
 956   for (const auto& o : const_list)
 957     EXPECT_EQ(1, std::abs(o.GetValue()));
 958 }
 959
 960 TEST(ObserverListTest, StdIteratorRemoveItself) {
 961   ObserverList<Foo> observer_list;
 962   Adder a(1), b(-1), c(1), d(-1);
 963   Disrupter disrupter(&observer_list, true);
 964
 965   observer_list.AddObserver(&a);
 966   observer_list.AddObserver(&b);
 967   observer_list.AddObserver(&disrupter);
 968   observer_list.AddObserver(&c);
 969   observer_list.AddObserver(&d);
 970
 971   for (auto& o : observer_list)
 972     o.Observe(1);
 973
 974   for (auto& o : observer_list)
 975     o.Observe(10);
 976
 977   EXPECT_EQ(11, a.total);
 978   EXPECT_EQ(-11, b.total);
 979   EXPECT_EQ(11, c.total);
 980   EXPECT_EQ(-11, d.total);
 981 }
 982
 983 TEST(ObserverListTest, StdIteratorRemoveBefore) {
 984   ObserverList<Foo> observer_list;
 985   Adder a(1), b(-1), c(1), d(-1);
 986   Disrupter disrupter(&observer_list, &b);
 987
 988   observer_list.AddObserver(&a);
 989   observer_list.AddObserver(&b);
 990   observer_list.AddObserver(&disrupter);
 991   observer_list.AddObserver(&c);
 992   observer_list.AddObserver(&d);
 993
 994   for (auto& o : observer_list)
 995     o.Observe(1);
 996
 997   for (auto& o : observer_list)
 998     o.Observe(10);
 999
1000   EXPECT_EQ(11, a.total);
1001   EXPECT_EQ(-1, b.total);
1002   EXPECT_EQ(11, c.total);
1003   EXPECT_EQ(-11, d.total);
1004 }
1005
1006 TEST(ObserverListTest, StdIteratorRemoveAfter) {
1007   ObserverList<Foo> observer_list;
1008   Adder a(1), b(-1), c(1), d(-1);
1009   Disrupter disrupter(&observer_list, &c);
1010
1011   observer_list.AddObserver(&a);
1012   observer_list.AddObserver(&b);
1013   observer_list.AddObserver(&disrupter);
1014   observer_list.AddObserver(&c);
1015   observer_list.AddObserver(&d);
1016
1017   for (auto& o : observer_list)
1018     o.Observe(1);
1019
1020   for (auto& o : observer_list)
1021     o.Observe(10);
1022
1023   EXPECT_EQ(11, a.total);
1024   EXPECT_EQ(-11, b.total);
1025   EXPECT_EQ(0, c.total);
1026   EXPECT_EQ(-11, d.total);
1027 }
1028
1029 TEST(ObserverListTest, StdIteratorRemoveAfterFront) {
1030   ObserverList<Foo> observer_list;
1031   Adder a(1), b(-1), c(1), d(-1);
1032   Disrupter disrupter(&observer_list, &a);
1033
1034   observer_list.AddObserver(&a);
1035   observer_list.AddObserver(&disrupter);
1036   observer_list.AddObserver(&b);
1037   observer_list.AddObserver(&c);
1038   observer_list.AddObserver(&d);
1039
1040   for (auto& o : observer_list)
1041     o.Observe(1);
1042
1043   for (auto& o : observer_list)
1044     o.Observe(10);
1045
1046   EXPECT_EQ(1, a.total);
1047   EXPECT_EQ(-11, b.total);
1048   EXPECT_EQ(11, c.total);
1049   EXPECT_EQ(-11, d.total);
1050 }
1051
1052 TEST(ObserverListTest, StdIteratorRemoveBeforeBack) {
1053   ObserverList<Foo> observer_list;
1054   Adder a(1), b(-1), c(1), d(-1);
1055   Disrupter disrupter(&observer_list, &d);
1056
1057   observer_list.AddObserver(&a);
1058   observer_list.AddObserver(&b);
1059   observer_list.AddObserver(&c);
1060   observer_list.AddObserver(&disrupter);
1061   observer_list.AddObserver(&d);
1062
1063   for (auto& o : observer_list)
1064     o.Observe(1);
1065
1066   for (auto& o : observer_list)
1067     o.Observe(10);
1068
1069   EXPECT_EQ(11, a.total);
1070   EXPECT_EQ(-11, b.total);
1071   EXPECT_EQ(11, c.total);
1072   EXPECT_EQ(0, d.total);
1073 }
1074
1075 TEST(ObserverListTest, StdIteratorRemoveFront) {
1076   using FooList = ObserverList<Foo>;
1077   FooList observer_list;
1078   Adder a(1), b(-1), c(1), d(-1);
1079   Disrupter disrupter(&observer_list, true);
1080
1081   observer_list.AddObserver(&disrupter);
1082   observer_list.AddObserver(&a);
1083   observer_list.AddObserver(&b);
1084   observer_list.AddObserver(&c);
1085   observer_list.AddObserver(&d);
1086
1087   bool test_disruptor = true;
1088   for (FooList::iterator i = observer_list.begin(), e = observer_list.end();
1089        i != e; ++i) {
1090     i->Observe(1);
1091     // Check that second call to i->Observe() would crash here.
1092     if (test_disruptor) {
1093       EXPECT_FALSE(i.GetCurrent());
1094       test_disruptor = false;
1095     }
1096   }
1097
1098   for (auto& o : observer_list)
1099     o.Observe(10);
1100
1101   EXPECT_EQ(11, a.total);
1102   EXPECT_EQ(-11, b.total);
1103   EXPECT_EQ(11, c.total);
1104   EXPECT_EQ(-11, d.total);
1105 }
1106
1107 TEST(ObserverListTest, StdIteratorRemoveBack) {
1108   ObserverList<Foo> observer_list;
1109   Adder a(1), b(-1), c(1), d(-1);
1110   Disrupter disrupter(&observer_list, true);
1111
1112   observer_list.AddObserver(&a);
1113   observer_list.AddObserver(&b);
1114   observer_list.AddObserver(&c);
1115   observer_list.AddObserver(&d);
1116   observer_list.AddObserver(&disrupter);
1117
1118   for (auto& o : observer_list)
1119     o.Observe(1);
1120
1121   for (auto& o : observer_list)
1122     o.Observe(10);
1123
1124   EXPECT_EQ(11, a.total);
1125   EXPECT_EQ(-11, b.total);
1126   EXPECT_EQ(11, c.total);
1127   EXPECT_EQ(-11, d.total);
1128 }
1129
1130 TEST(ObserverListTest, NestedLoop) {
1131   ObserverList<Foo> observer_list;
1132   Adder a(1), b(-1), c(1), d(-1);
1133   Disrupter disrupter(&observer_list, true);
1134
1135   observer_list.AddObserver(&disrupter);
1136   observer_list.AddObserver(&a);
1137   observer_list.AddObserver(&b);
1138   observer_list.AddObserver(&c);
1139   observer_list.AddObserver(&d);
1140
1141   for (auto& o : observer_list) {
1142     o.Observe(10);
1143
1144     for (auto& o : observer_list)
1145       o.Observe(1);
1146   }
1147
1148   EXPECT_EQ(15, a.total);
1149   EXPECT_EQ(-15, b.total);
1150   EXPECT_EQ(15, c.total);
1151   EXPECT_EQ(-15, d.total);
1152 }
1153
1154 TEST(ObserverListTest, NonCompactList) {
1155   ObserverList<Foo> observer_list;
1156   Adder a(1), b(-1);
1157
1158   Disrupter disrupter1(&observer_list, true);
1159   Disrupter disrupter2(&observer_list, true);
1160
1161   // Disrupt itself and another one.
1162   disrupter1.SetDoomed(&disrupter2);
1163
1164   observer_list.AddObserver(&disrupter1);
1165   observer_list.AddObserver(&disrupter2);
1166   observer_list.AddObserver(&a);
1167   observer_list.AddObserver(&b);
1168
1169   for (auto& o : observer_list) {
1170     // Get the { nullptr, nullptr, &a, &b } non-compact list
1171     // on the first inner pass.
1172     o.Observe(10);
1173
1174     for (auto& o : observer_list)
1175       o.Observe(1);
1176   }
1177
1178   EXPECT_EQ(13, a.total);
1179   EXPECT_EQ(-13, b.total);
1180 }
1181
1182 TEST(ObserverListTest, BecomesEmptyThanNonEmpty) {
1183   ObserverList<Foo> observer_list;
1184   Adder a(1), b(-1);
1185
1186   Disrupter disrupter1(&observer_list, true);
1187   Disrupter disrupter2(&observer_list, true);
1188
1189   // Disrupt itself and another one.
1190   disrupter1.SetDoomed(&disrupter2);
1191
1192   observer_list.AddObserver(&disrupter1);
1193   observer_list.AddObserver(&disrupter2);
1194
1195   bool add_observers = true;
1196   for (auto& o : observer_list) {
1197     // Get the { nullptr, nullptr } empty list on the first inner pass.
1198     o.Observe(10);
1199
1200     for (auto& o : observer_list)
1201       o.Observe(1);
1202
1203     if (add_observers) {
1204       observer_list.AddObserver(&a);
1205       observer_list.AddObserver(&b);
1206       add_observers = false;
1207     }
1208   }
1209
1210   EXPECT_EQ(12, a.total);
1211   EXPECT_EQ(-12, b.total);
1212 }
1213
1214 TEST(ObserverListTest, AddObserverInTheLastObserve) {
1215   using FooList = ObserverList<Foo>;
1216   FooList observer_list;
1217
1218   AddInObserve<FooList> a(&observer_list);
1219   Adder b(-1);
1220
1221   a.SetToAdd(&b);
1222   observer_list.AddObserver(&a);
1223
1224   auto it = observer_list.begin();
1225   while (it != observer_list.end()) {
1226     auto& observer = *it;
1227     // Intentionally increment the iterator before calling Observe(). The
1228     // ObserverList starts with only one observer, and it == observer_list.end()
1229     // should be true after the next line.
1230     ++it;
1231     // However, the first Observe() call will add a second observer: at this
1232     // point, it != observer_list.end() should be true, and Observe() should be
1233     // called on the newly added observer on the next iteration of the loop.
1234     observer.Observe(10);
1235   }
1236
1237   EXPECT_EQ(-10, b.total);
1238 }
1239
1240 class MockLogAssertHandler {
1241  public:
1242   MOCK_METHOD4(
1243       HandleLogAssert,
1244       void(const char*, int, const base::StringPiece, const base::StringPiece));
1245 };
1246
1247 #if DCHECK_IS_ON()
1248 TEST(ObserverListTest, NonReentrantObserverList) {
1249   using ::testing::_;
1250
1251   ObserverList<Foo, /*check_empty=*/false, /*allow_reentrancy=*/false>
1252       non_reentrant_observer_list;
1253   Adder a(1);
1254   non_reentrant_observer_list.AddObserver(&a);
1255
1256   EXPECT_DCHECK_DEATH({
1257     for (const Foo& a : non_reentrant_observer_list) {
1258       for (const Foo& b : non_reentrant_observer_list) {
1259         std::ignore = a;
1260         std::ignore = b;
1261       }
1262     }
1263   });
1264 }
1265
1266 TEST(ObserverListTest, ReentrantObserverList) {
1267   using ::testing::_;
1268
1269   ReentrantObserverList<Foo> reentrant_observer_list;
1270   Adder a(1);
1271   reentrant_observer_list.AddObserver(&a);
1272   bool passed = false;
1273   for (const Foo& a : reentrant_observer_list) {
1274     for (const Foo& b : reentrant_observer_list) {
1275       std::ignore = a;
1276       std::ignore = b;
1277       passed = true;
1278     }
1279   }
1280   EXPECT_TRUE(passed);
1281 }
1282 #endif
1283
1284 }  // namespace base