base/message_loop/message_loop_test.cc

   1 // Copyright 2013 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/message_loop/message_loop_test.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/run_loop.h"
  10 #include "base/synchronization/waitable_event.h"
  11 #include "base/threading/thread.h"
  12
  13 namespace base {
  14 namespace test {
  15
  16 namespace {
  17
  18 class Foo : public RefCounted<Foo> {
  19  public:
  20   Foo() : test_count_(0) {
  21   }
  22
  23   void Test0() {
  24     ++test_count_;
  25   }
  26
  27   void Test1ConstRef(const std::string& a) {
  28     ++test_count_;
  29     result_.append(a);
  30   }
  31
  32   void Test1Ptr(std::string* a) {
  33     ++test_count_;
  34     result_.append(*a);
  35   }
  36
  37   void Test1Int(int a) {
  38     test_count_ += a;
  39   }
  40
  41   void Test2Ptr(std::string* a, std::string* b) {
  42     ++test_count_;
  43     result_.append(*a);
  44     result_.append(*b);
  45   }
  46
  47   void Test2Mixed(const std::string& a, std::string* b) {
  48     ++test_count_;
  49     result_.append(a);
  50     result_.append(*b);
  51   }
  52
  53   int test_count() const { return test_count_; }
  54   const std::string& result() const { return result_; }
  55
  56  private:
  57   friend class RefCounted<Foo>;
  58
  59   ~Foo() {}
  60
  61   int test_count_;
  62   std::string result_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(Foo);
  65 };
  66
  67 // This function runs slowly to simulate a large amount of work being done.
  68 void SlowFunc(TimeDelta pause, int* quit_counter) {
  69     PlatformThread::Sleep(pause);
  70     if (--(*quit_counter) == 0)
  71       MessageLoop::current()->QuitWhenIdle();
  72 }
  73
  74 // This function records the time when Run was called in a Time object, which is
  75 // useful for building a variety of MessageLoop tests.
  76 // TODO(sky): remove?
  77 void RecordRunTimeFunc(Time* run_time, int* quit_counter) {
  78   *run_time = Time::Now();
  79
  80     // Cause our Run function to take some time to execute.  As a result we can
  81     // count on subsequent RecordRunTimeFunc()s running at a future time,
  82     // without worry about the resolution of our system clock being an issue.
  83   SlowFunc(TimeDelta::FromMilliseconds(10), quit_counter);
  84 }
  85
  86 }  // namespace
  87
  88 void RunTest_PostTask(MessagePumpFactory factory) {
  89   scoped_ptr<MessagePump> pump(factory());
  90   MessageLoop loop(pump.Pass());
  91   // Add tests to message loop
  92   scoped_refptr<Foo> foo(new Foo());
  93   std::string a("a"), b("b"), c("c"), d("d");
  94   MessageLoop::current()->PostTask(FROM_HERE, Bind(
  95       &Foo::Test0, foo.get()));
  96   MessageLoop::current()->PostTask(FROM_HERE, Bind(
  97     &Foo::Test1ConstRef, foo.get(), a));
  98   MessageLoop::current()->PostTask(FROM_HERE, Bind(
  99       &Foo::Test1Ptr, foo.get(), &b));
 100   MessageLoop::current()->PostTask(FROM_HERE, Bind(
 101       &Foo::Test1Int, foo.get(), 100));
 102   MessageLoop::current()->PostTask(FROM_HERE, Bind(
 103       &Foo::Test2Ptr, foo.get(), &a, &c));
 104   MessageLoop::current()->PostTask(FROM_HERE, Bind(
 105       &Foo::Test2Mixed, foo.get(), a, &d));
 106   // After all tests, post a message that will shut down the message loop
 107   MessageLoop::current()->PostTask(FROM_HERE, Bind(
 108       &MessageLoop::Quit, Unretained(MessageLoop::current())));
 109
 110   // Now kick things off
 111   MessageLoop::current()->Run();
 112
 113   EXPECT_EQ(foo->test_count(), 105);
 114   EXPECT_EQ(foo->result(), "abacad");
 115 }
 116
 117 void RunTest_PostDelayedTask_Basic(MessagePumpFactory factory) {
 118   scoped_ptr<MessagePump> pump(factory());
 119   MessageLoop loop(pump.Pass());
 120
 121   // Test that PostDelayedTask results in a delayed task.
 122
 123   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 124
 125   int num_tasks = 1;
 126   Time run_time;
 127
 128   loop.PostDelayedTask(
 129       FROM_HERE, Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
 130       kDelay);
 131
 132   Time time_before_run = Time::Now();
 133   loop.Run();
 134   Time time_after_run = Time::Now();
 135
 136   EXPECT_EQ(0, num_tasks);
 137   EXPECT_LT(kDelay, time_after_run - time_before_run);
 138 }
 139
 140 void RunTest_PostDelayedTask_InDelayOrder(MessagePumpFactory factory) {
 141   scoped_ptr<MessagePump> pump(factory());
 142   MessageLoop loop(pump.Pass());
 143
 144   // Test that two tasks with different delays run in the right order.
 145   int num_tasks = 2;
 146   Time run_time1, run_time2;
 147
 148   loop.PostDelayedTask(
 149       FROM_HERE,
 150       Bind(&RecordRunTimeFunc, &run_time1, &num_tasks),
 151       TimeDelta::FromMilliseconds(200));
 152   // If we get a large pause in execution (due to a context switch) here, this
 153   // test could fail.
 154   loop.PostDelayedTask(
 155       FROM_HERE,
 156       Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
 157       TimeDelta::FromMilliseconds(10));
 158
 159   loop.Run();
 160   EXPECT_EQ(0, num_tasks);
 161
 162   EXPECT_TRUE(run_time2 < run_time1);
 163 }
 164
 165 void RunTest_PostDelayedTask_InPostOrder(MessagePumpFactory factory) {
 166   scoped_ptr<MessagePump> pump(factory());
 167   MessageLoop loop(pump.Pass());
 168
 169   // Test that two tasks with the same delay run in the order in which they
 170   // were posted.
 171   //
 172   // NOTE: This is actually an approximate test since the API only takes a
 173   // "delay" parameter, so we are not exactly simulating two tasks that get
 174   // posted at the exact same time.  It would be nice if the API allowed us to
 175   // specify the desired run time.
 176
 177   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 178
 179   int num_tasks = 2;
 180   Time run_time1, run_time2;
 181
 182   loop.PostDelayedTask(
 183       FROM_HERE,
 184       Bind(&RecordRunTimeFunc, &run_time1, &num_tasks), kDelay);
 185   loop.PostDelayedTask(
 186       FROM_HERE,
 187       Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), kDelay);
 188
 189   loop.Run();
 190   EXPECT_EQ(0, num_tasks);
 191
 192   EXPECT_TRUE(run_time1 < run_time2);
 193 }
 194
 195 void RunTest_PostDelayedTask_InPostOrder_2(MessagePumpFactory factory) {
 196   scoped_ptr<MessagePump> pump(factory());
 197   MessageLoop loop(pump.Pass());
 198
 199   // Test that a delayed task still runs after a normal tasks even if the
 200   // normal tasks take a long time to run.
 201
 202   const TimeDelta kPause = TimeDelta::FromMilliseconds(50);
 203
 204   int num_tasks = 2;
 205   Time run_time;
 206
 207   loop.PostTask(FROM_HERE, Bind(&SlowFunc, kPause, &num_tasks));
 208   loop.PostDelayedTask(
 209       FROM_HERE,
 210       Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
 211       TimeDelta::FromMilliseconds(10));
 212
 213   Time time_before_run = Time::Now();
 214   loop.Run();
 215   Time time_after_run = Time::Now();
 216
 217   EXPECT_EQ(0, num_tasks);
 218
 219   EXPECT_LT(kPause, time_after_run - time_before_run);
 220 }
 221
 222 void RunTest_PostDelayedTask_InPostOrder_3(MessagePumpFactory factory) {
 223   scoped_ptr<MessagePump> pump(factory());
 224   MessageLoop loop(pump.Pass());
 225
 226   // Test that a delayed task still runs after a pile of normal tasks.  The key
 227   // difference between this test and the previous one is that here we return
 228   // the MessageLoop a lot so we give the MessageLoop plenty of opportunities
 229   // to maybe run the delayed task.  It should know not to do so until the
 230   // delayed task's delay has passed.
 231
 232   int num_tasks = 11;
 233   Time run_time1, run_time2;
 234
 235   // Clutter the ML with tasks.
 236   for (int i = 1; i < num_tasks; ++i)
 237     loop.PostTask(FROM_HERE,
 238                   Bind(&RecordRunTimeFunc, &run_time1, &num_tasks));
 239
 240   loop.PostDelayedTask(
 241       FROM_HERE, Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
 242       TimeDelta::FromMilliseconds(1));
 243
 244   loop.Run();
 245   EXPECT_EQ(0, num_tasks);
 246
 247   EXPECT_TRUE(run_time2 > run_time1);
 248 }
 249
 250 void RunTest_PostDelayedTask_SharedTimer(MessagePumpFactory factory) {
 251   scoped_ptr<MessagePump> pump(factory());
 252   MessageLoop loop(pump.Pass());
 253
 254   // Test that the interval of the timer, used to run the next delayed task, is
 255   // set to a value corresponding to when the next delayed task should run.
 256
 257   // By setting num_tasks to 1, we ensure that the first task to run causes the
 258   // run loop to exit.
 259   int num_tasks = 1;
 260   Time run_time1, run_time2;
 261
 262   loop.PostDelayedTask(
 263       FROM_HERE,
 264       Bind(&RecordRunTimeFunc, &run_time1, &num_tasks),
 265       TimeDelta::FromSeconds(1000));
 266   loop.PostDelayedTask(
 267       FROM_HERE,
 268       Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
 269       TimeDelta::FromMilliseconds(10));
 270
 271   Time start_time = Time::Now();
 272
 273   loop.Run();
 274   EXPECT_EQ(0, num_tasks);
 275
 276   // Ensure that we ran in far less time than the slower timer.
 277   TimeDelta total_time = Time::Now() - start_time;
 278   EXPECT_GT(5000, total_time.InMilliseconds());
 279
 280   // In case both timers somehow run at nearly the same time, sleep a little
 281   // and then run all pending to force them both to have run.  This is just
 282   // encouraging flakiness if there is any.
 283   PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
 284   RunLoop().RunUntilIdle();
 285
 286   EXPECT_TRUE(run_time1.is_null());
 287   EXPECT_FALSE(run_time2.is_null());
 288 }
 289
 290 // This is used to inject a test point for recording the destructor calls for
 291 // Closure objects send to MessageLoop::PostTask(). It is awkward usage since we
 292 // are trying to hook the actual destruction, which is not a common operation.
 293 class RecordDeletionProbe : public RefCounted<RecordDeletionProbe> {
 294  public:
 295   RecordDeletionProbe(RecordDeletionProbe* post_on_delete, bool* was_deleted)
 296       : post_on_delete_(post_on_delete), was_deleted_(was_deleted) {
 297   }
 298   void Run() {}
 299
 300  private:
 301   friend class RefCounted<RecordDeletionProbe>;
 302
 303   ~RecordDeletionProbe() {
 304     *was_deleted_ = true;
 305     if (post_on_delete_.get())
 306       MessageLoop::current()->PostTask(
 307           FROM_HERE, Bind(&RecordDeletionProbe::Run, post_on_delete_.get()));
 308   }
 309
 310   scoped_refptr<RecordDeletionProbe> post_on_delete_;
 311   bool* was_deleted_;
 312 };
 313
 314 void RunTest_EnsureDeletion(MessagePumpFactory factory) {
 315   bool a_was_deleted = false;
 316   bool b_was_deleted = false;
 317   {
 318     scoped_ptr<MessagePump> pump(factory());
 319     MessageLoop loop(pump.Pass());
 320     loop.PostTask(
 321         FROM_HERE, Bind(&RecordDeletionProbe::Run,
 322                               new RecordDeletionProbe(NULL, &a_was_deleted)));
 323     // TODO(ajwong): Do we really need 1000ms here?
 324     loop.PostDelayedTask(
 325         FROM_HERE, Bind(&RecordDeletionProbe::Run,
 326                               new RecordDeletionProbe(NULL, &b_was_deleted)),
 327         TimeDelta::FromMilliseconds(1000));
 328   }
 329   EXPECT_TRUE(a_was_deleted);
 330   EXPECT_TRUE(b_was_deleted);
 331 }
 332
 333 void RunTest_EnsureDeletion_Chain(MessagePumpFactory factory) {
 334   bool a_was_deleted = false;
 335   bool b_was_deleted = false;
 336   bool c_was_deleted = false;
 337   {
 338     scoped_ptr<MessagePump> pump(factory());
 339     MessageLoop loop(pump.Pass());
 340     // The scoped_refptr for each of the below is held either by the chained
 341     // RecordDeletionProbe, or the bound RecordDeletionProbe::Run() callback.
 342     RecordDeletionProbe* a = new RecordDeletionProbe(NULL, &a_was_deleted);
 343     RecordDeletionProbe* b = new RecordDeletionProbe(a, &b_was_deleted);
 344     RecordDeletionProbe* c = new RecordDeletionProbe(b, &c_was_deleted);
 345     loop.PostTask(FROM_HERE, Bind(&RecordDeletionProbe::Run, c));
 346   }
 347   EXPECT_TRUE(a_was_deleted);
 348   EXPECT_TRUE(b_was_deleted);
 349   EXPECT_TRUE(c_was_deleted);
 350 }
 351
 352 void NestingFunc(int* depth) {
 353   if (*depth > 0) {
 354     *depth -= 1;
 355     MessageLoop::current()->PostTask(FROM_HERE,
 356                                      Bind(&NestingFunc, depth));
 357
 358     MessageLoop::current()->SetNestableTasksAllowed(true);
 359     MessageLoop::current()->Run();
 360   }
 361   MessageLoop::current()->QuitWhenIdle();
 362 }
 363
 364 void RunTest_Nesting(MessagePumpFactory factory) {
 365   scoped_ptr<MessagePump> pump(factory());
 366   MessageLoop loop(pump.Pass());
 367
 368   int depth = 100;
 369   MessageLoop::current()->PostTask(FROM_HERE,
 370                                    Bind(&NestingFunc, &depth));
 371   MessageLoop::current()->Run();
 372   EXPECT_EQ(depth, 0);
 373 }
 374
 375 enum TaskType {
 376   MESSAGEBOX,
 377   ENDDIALOG,
 378   RECURSIVE,
 379   TIMEDMESSAGELOOP,
 380   QUITMESSAGELOOP,
 381   ORDERED,
 382   PUMPS,
 383   SLEEP,
 384   RUNS,
 385 };
 386
 387 struct TaskItem {
 388   TaskItem(TaskType t, int c, bool s)
 389       : type(t),
 390         cookie(c),
 391         start(s) {
 392   }
 393
 394   TaskType type;
 395   int cookie;
 396   bool start;
 397
 398   bool operator == (const TaskItem& other) const {
 399     return type == other.type && cookie == other.cookie && start == other.start;
 400   }
 401 };
 402
 403 std::ostream& operator <<(std::ostream& os, TaskType type) {
 404   switch (type) {
 405   case MESSAGEBOX:        os << "MESSAGEBOX"; break;
 406   case ENDDIALOG:         os << "ENDDIALOG"; break;
 407   case RECURSIVE:         os << "RECURSIVE"; break;
 408   case TIMEDMESSAGELOOP:  os << "TIMEDMESSAGELOOP"; break;
 409   case QUITMESSAGELOOP:   os << "QUITMESSAGELOOP"; break;
 410   case ORDERED:          os << "ORDERED"; break;
 411   case PUMPS:             os << "PUMPS"; break;
 412   case SLEEP:             os << "SLEEP"; break;
 413   default:
 414     NOTREACHED();
 415     os << "Unknown TaskType";
 416     break;
 417   }
 418   return os;
 419 }
 420
 421 std::ostream& operator <<(std::ostream& os, const TaskItem& item) {
 422   if (item.start)
 423     return os << item.type << " " << item.cookie << " starts";
 424   else
 425     return os << item.type << " " << item.cookie << " ends";
 426 }
 427
 428 class TaskList {
 429  public:
 430   void RecordStart(TaskType type, int cookie) {
 431     TaskItem item(type, cookie, true);
 432     DVLOG(1) << item;
 433     task_list_.push_back(item);
 434   }
 435
 436   void RecordEnd(TaskType type, int cookie) {
 437     TaskItem item(type, cookie, false);
 438     DVLOG(1) << item;
 439     task_list_.push_back(item);
 440   }
 441
 442   size_t Size() {
 443     return task_list_.size();
 444   }
 445
 446   TaskItem Get(int n)  {
 447     return task_list_[n];
 448   }
 449
 450  private:
 451   std::vector<TaskItem> task_list_;
 452 };
 453
 454 void RecursiveFunc(TaskList* order, int cookie, int depth,
 455                    bool is_reentrant) {
 456   order->RecordStart(RECURSIVE, cookie);
 457   if (depth > 0) {
 458     if (is_reentrant)
 459       MessageLoop::current()->SetNestableTasksAllowed(true);
 460     MessageLoop::current()->PostTask(
 461         FROM_HERE,
 462         Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
 463   }
 464   order->RecordEnd(RECURSIVE, cookie);
 465 }
 466
 467 void QuitFunc(TaskList* order, int cookie) {
 468   order->RecordStart(QUITMESSAGELOOP, cookie);
 469   MessageLoop::current()->QuitWhenIdle();
 470   order->RecordEnd(QUITMESSAGELOOP, cookie);
 471 }
 472 void RunTest_RecursiveDenial1(MessagePumpFactory factory) {
 473   scoped_ptr<MessagePump> pump(factory());
 474   MessageLoop loop(pump.Pass());
 475
 476   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
 477   TaskList order;
 478   MessageLoop::current()->PostTask(
 479       FROM_HERE,
 480       Bind(&RecursiveFunc, &order, 1, 2, false));
 481   MessageLoop::current()->PostTask(
 482       FROM_HERE,
 483       Bind(&RecursiveFunc, &order, 2, 2, false));
 484   MessageLoop::current()->PostTask(
 485       FROM_HERE,
 486       Bind(&QuitFunc, &order, 3));
 487
 488   MessageLoop::current()->Run();
 489
 490   // FIFO order.
 491   ASSERT_EQ(14U, order.Size());
 492   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
 493   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
 494   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
 495   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
 496   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
 497   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
 498   EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true));
 499   EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
 500   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
 501   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
 502   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
 503   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
 504   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
 505   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
 506 }
 507
 508 void RecursiveSlowFunc(TaskList* order, int cookie, int depth,
 509                        bool is_reentrant) {
 510   RecursiveFunc(order, cookie, depth, is_reentrant);
 511   PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
 512 }
 513
 514 void OrderedFunc(TaskList* order, int cookie) {
 515   order->RecordStart(ORDERED, cookie);
 516   order->RecordEnd(ORDERED, cookie);
 517 }
 518
 519 void RunTest_RecursiveDenial3(MessagePumpFactory factory) {
 520   scoped_ptr<MessagePump> pump(factory());
 521   MessageLoop loop(pump.Pass());
 522
 523   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
 524   TaskList order;
 525   MessageLoop::current()->PostTask(
 526       FROM_HERE, Bind(&RecursiveSlowFunc, &order, 1, 2, false));
 527   MessageLoop::current()->PostTask(
 528       FROM_HERE, Bind(&RecursiveSlowFunc, &order, 2, 2, false));
 529   MessageLoop::current()->PostDelayedTask(
 530       FROM_HERE,
 531       Bind(&OrderedFunc, &order, 3),
 532       TimeDelta::FromMilliseconds(5));
 533   MessageLoop::current()->PostDelayedTask(
 534       FROM_HERE,
 535       Bind(&QuitFunc, &order, 4),
 536       TimeDelta::FromMilliseconds(5));
 537
 538   MessageLoop::current()->Run();
 539
 540   // FIFO order.
 541   ASSERT_EQ(16U, order.Size());
 542   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
 543   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
 544   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
 545   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
 546   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 1, true));
 547   EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 1, false));
 548   EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 3, true));
 549   EXPECT_EQ(order.Get(7), TaskItem(ORDERED, 3, false));
 550   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
 551   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
 552   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 4, true));
 553   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 4, false));
 554   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 1, true));
 555   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, false));
 556   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 2, true));
 557   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 2, false));
 558 }
 559
 560 void RunTest_RecursiveSupport1(MessagePumpFactory factory) {
 561   scoped_ptr<MessagePump> pump(factory());
 562   MessageLoop loop(pump.Pass());
 563
 564   TaskList order;
 565   MessageLoop::current()->PostTask(
 566       FROM_HERE, Bind(&RecursiveFunc, &order, 1, 2, true));
 567   MessageLoop::current()->PostTask(
 568       FROM_HERE, Bind(&RecursiveFunc, &order, 2, 2, true));
 569   MessageLoop::current()->PostTask(
 570       FROM_HERE, Bind(&QuitFunc, &order, 3));
 571
 572   MessageLoop::current()->Run();
 573
 574   // FIFO order.
 575   ASSERT_EQ(14U, order.Size());
 576   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
 577   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
 578   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
 579   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
 580   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
 581   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
 582   EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true));
 583   EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
 584   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
 585   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
 586   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
 587   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
 588   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
 589   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
 590 }
 591
 592 // Tests that non nestable tasks run in FIFO if there are no nested loops.
 593 void RunTest_NonNestableWithNoNesting(MessagePumpFactory factory) {
 594   scoped_ptr<MessagePump> pump(factory());
 595   MessageLoop loop(pump.Pass());
 596
 597   TaskList order;
 598
 599   MessageLoop::current()->PostNonNestableTask(
 600       FROM_HERE,
 601       Bind(&OrderedFunc, &order, 1));
 602   MessageLoop::current()->PostTask(FROM_HERE,
 603                                    Bind(&OrderedFunc, &order, 2));
 604   MessageLoop::current()->PostTask(FROM_HERE,
 605                                    Bind(&QuitFunc, &order, 3));
 606   MessageLoop::current()->Run();
 607
 608   // FIFO order.
 609   ASSERT_EQ(6U, order.Size());
 610   EXPECT_EQ(order.Get(0), TaskItem(ORDERED, 1, true));
 611   EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 1, false));
 612   EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 2, true));
 613   EXPECT_EQ(order.Get(3), TaskItem(ORDERED, 2, false));
 614   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
 615   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
 616 }
 617
 618 void FuncThatPumps(TaskList* order, int cookie) {
 619   order->RecordStart(PUMPS, cookie);
 620   {
 621     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
 622     RunLoop().RunUntilIdle();
 623   }
 624   order->RecordEnd(PUMPS, cookie);
 625 }
 626
 627 void SleepFunc(TaskList* order, int cookie, TimeDelta delay) {
 628   order->RecordStart(SLEEP, cookie);
 629   PlatformThread::Sleep(delay);
 630   order->RecordEnd(SLEEP, cookie);
 631 }
 632
 633 // Tests that non nestable tasks don't run when there's code in the call stack.
 634 void RunTest_NonNestableInNestedLoop(MessagePumpFactory factory,
 635                                      bool use_delayed) {
 636   scoped_ptr<MessagePump> pump(factory());
 637   MessageLoop loop(pump.Pass());
 638
 639   TaskList order;
 640
 641   MessageLoop::current()->PostTask(
 642       FROM_HERE,
 643       Bind(&FuncThatPumps, &order, 1));
 644   if (use_delayed) {
 645     MessageLoop::current()->PostNonNestableDelayedTask(
 646         FROM_HERE,
 647         Bind(&OrderedFunc, &order, 2),
 648         TimeDelta::FromMilliseconds(1));
 649   } else {
 650     MessageLoop::current()->PostNonNestableTask(
 651         FROM_HERE,
 652         Bind(&OrderedFunc, &order, 2));
 653   }
 654   MessageLoop::current()->PostTask(FROM_HERE,
 655                                    Bind(&OrderedFunc, &order, 3));
 656   MessageLoop::current()->PostTask(
 657       FROM_HERE,
 658       Bind(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50)));
 659   MessageLoop::current()->PostTask(FROM_HERE,
 660                                    Bind(&OrderedFunc, &order, 5));
 661   if (use_delayed) {
 662     MessageLoop::current()->PostNonNestableDelayedTask(
 663         FROM_HERE,
 664         Bind(&QuitFunc, &order, 6),
 665         TimeDelta::FromMilliseconds(2));
 666   } else {
 667     MessageLoop::current()->PostNonNestableTask(
 668         FROM_HERE,
 669         Bind(&QuitFunc, &order, 6));
 670   }
 671
 672   MessageLoop::current()->Run();
 673
 674   // FIFO order.
 675   ASSERT_EQ(12U, order.Size());
 676   EXPECT_EQ(order.Get(0), TaskItem(PUMPS, 1, true));
 677   EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 3, true));
 678   EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 3, false));
 679   EXPECT_EQ(order.Get(3), TaskItem(SLEEP, 4, true));
 680   EXPECT_EQ(order.Get(4), TaskItem(SLEEP, 4, false));
 681   EXPECT_EQ(order.Get(5), TaskItem(ORDERED, 5, true));
 682   EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 5, false));
 683   EXPECT_EQ(order.Get(7), TaskItem(PUMPS, 1, false));
 684   EXPECT_EQ(order.Get(8), TaskItem(ORDERED, 2, true));
 685   EXPECT_EQ(order.Get(9), TaskItem(ORDERED, 2, false));
 686   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 6, true));
 687   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 6, false));
 688 }
 689
 690 void FuncThatRuns(TaskList* order, int cookie, RunLoop* run_loop) {
 691   order->RecordStart(RUNS, cookie);
 692   {
 693     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
 694     run_loop->Run();
 695   }
 696   order->RecordEnd(RUNS, cookie);
 697 }
 698
 699 void FuncThatQuitsNow() {
 700   MessageLoop::current()->QuitNow();
 701 }
 702 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 703 void RunTest_QuitNow(MessagePumpFactory factory) {
 704   scoped_ptr<MessagePump> pump(factory());
 705   MessageLoop loop(pump.Pass());
 706
 707   TaskList order;
 708
 709   RunLoop run_loop;
 710
 711   MessageLoop::current()->PostTask(FROM_HERE,
 712       Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
 713   MessageLoop::current()->PostTask(
 714       FROM_HERE, Bind(&OrderedFunc, &order, 2));
 715   MessageLoop::current()->PostTask(
 716       FROM_HERE, Bind(&FuncThatQuitsNow));
 717   MessageLoop::current()->PostTask(
 718       FROM_HERE, Bind(&OrderedFunc, &order, 3));
 719   MessageLoop::current()->PostTask(
 720       FROM_HERE, Bind(&FuncThatQuitsNow));
 721   MessageLoop::current()->PostTask(
 722       FROM_HERE, Bind(&OrderedFunc, &order, 4)); // never runs
 723
 724   MessageLoop::current()->Run();
 725
 726   ASSERT_EQ(6U, order.Size());
 727   int task_index = 0;
 728   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
 729   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
 730   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
 731   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
 732   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
 733   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
 734   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 735 }
 736
 737 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 738 void RunTest_RunLoopQuitTop(MessagePumpFactory factory) {
 739   scoped_ptr<MessagePump> pump(factory());
 740   MessageLoop loop(pump.Pass());
 741
 742   TaskList order;
 743
 744   RunLoop outer_run_loop;
 745   RunLoop nested_run_loop;
 746
 747   MessageLoop::current()->PostTask(FROM_HERE,
 748       Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
 749   MessageLoop::current()->PostTask(
 750       FROM_HERE, outer_run_loop.QuitClosure());
 751   MessageLoop::current()->PostTask(
 752       FROM_HERE, Bind(&OrderedFunc, &order, 2));
 753   MessageLoop::current()->PostTask(
 754       FROM_HERE, nested_run_loop.QuitClosure());
 755
 756   outer_run_loop.Run();
 757
 758   ASSERT_EQ(4U, order.Size());
 759   int task_index = 0;
 760   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
 761   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
 762   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
 763   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
 764   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 765 }
 766
 767 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 768 void RunTest_RunLoopQuitNested(MessagePumpFactory factory) {
 769   scoped_ptr<MessagePump> pump(factory());
 770   MessageLoop loop(pump.Pass());
 771
 772   TaskList order;
 773
 774   RunLoop outer_run_loop;
 775   RunLoop nested_run_loop;
 776
 777   MessageLoop::current()->PostTask(FROM_HERE,
 778       Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
 779   MessageLoop::current()->PostTask(
 780       FROM_HERE, nested_run_loop.QuitClosure());
 781   MessageLoop::current()->PostTask(
 782       FROM_HERE, Bind(&OrderedFunc, &order, 2));
 783   MessageLoop::current()->PostTask(
 784       FROM_HERE, outer_run_loop.QuitClosure());
 785
 786   outer_run_loop.Run();
 787
 788   ASSERT_EQ(4U, order.Size());
 789   int task_index = 0;
 790   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
 791   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
 792   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
 793   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
 794   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 795 }
 796
 797 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 798 void RunTest_RunLoopQuitBogus(MessagePumpFactory factory) {
 799   scoped_ptr<MessagePump> pump(factory());
 800   MessageLoop loop(pump.Pass());
 801
 802   TaskList order;
 803
 804   RunLoop outer_run_loop;
 805   RunLoop nested_run_loop;
 806   RunLoop bogus_run_loop;
 807
 808   MessageLoop::current()->PostTask(FROM_HERE,
 809       Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
 810   MessageLoop::current()->PostTask(
 811       FROM_HERE, bogus_run_loop.QuitClosure());
 812   MessageLoop::current()->PostTask(
 813       FROM_HERE, Bind(&OrderedFunc, &order, 2));
 814   MessageLoop::current()->PostTask(
 815       FROM_HERE, outer_run_loop.QuitClosure());
 816   MessageLoop::current()->PostTask(
 817       FROM_HERE, nested_run_loop.QuitClosure());
 818
 819   outer_run_loop.Run();
 820
 821   ASSERT_EQ(4U, order.Size());
 822   int task_index = 0;
 823   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
 824   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
 825   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
 826   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
 827   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 828 }
 829
 830 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 831 void RunTest_RunLoopQuitDeep(MessagePumpFactory factory) {
 832   scoped_ptr<MessagePump> pump(factory());
 833   MessageLoop loop(pump.Pass());
 834
 835   TaskList order;
 836
 837   RunLoop outer_run_loop;
 838   RunLoop nested_loop1;
 839   RunLoop nested_loop2;
 840   RunLoop nested_loop3;
 841   RunLoop nested_loop4;
 842
 843   MessageLoop::current()->PostTask(FROM_HERE,
 844       Bind(&FuncThatRuns, &order, 1, Unretained(&nested_loop1)));
 845   MessageLoop::current()->PostTask(FROM_HERE,
 846       Bind(&FuncThatRuns, &order, 2, Unretained(&nested_loop2)));
 847   MessageLoop::current()->PostTask(FROM_HERE,
 848       Bind(&FuncThatRuns, &order, 3, Unretained(&nested_loop3)));
 849   MessageLoop::current()->PostTask(FROM_HERE,
 850       Bind(&FuncThatRuns, &order, 4, Unretained(&nested_loop4)));
 851   MessageLoop::current()->PostTask(
 852       FROM_HERE, Bind(&OrderedFunc, &order, 5));
 853   MessageLoop::current()->PostTask(
 854       FROM_HERE, outer_run_loop.QuitClosure());
 855   MessageLoop::current()->PostTask(
 856       FROM_HERE, Bind(&OrderedFunc, &order, 6));
 857   MessageLoop::current()->PostTask(
 858       FROM_HERE, nested_loop1.QuitClosure());
 859   MessageLoop::current()->PostTask(
 860       FROM_HERE, Bind(&OrderedFunc, &order, 7));
 861   MessageLoop::current()->PostTask(
 862       FROM_HERE, nested_loop2.QuitClosure());
 863   MessageLoop::current()->PostTask(
 864       FROM_HERE, Bind(&OrderedFunc, &order, 8));
 865   MessageLoop::current()->PostTask(
 866       FROM_HERE, nested_loop3.QuitClosure());
 867   MessageLoop::current()->PostTask(
 868       FROM_HERE, Bind(&OrderedFunc, &order, 9));
 869   MessageLoop::current()->PostTask(
 870       FROM_HERE, nested_loop4.QuitClosure());
 871   MessageLoop::current()->PostTask(
 872       FROM_HERE, Bind(&OrderedFunc, &order, 10));
 873
 874   outer_run_loop.Run();
 875
 876   ASSERT_EQ(18U, order.Size());
 877   int task_index = 0;
 878   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
 879   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, true));
 880   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, true));
 881   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, true));
 882   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, true));
 883   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, false));
 884   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, true));
 885   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, false));
 886   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, true));
 887   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, false));
 888   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, true));
 889   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, false));
 890   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, true));
 891   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, false));
 892   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, false));
 893   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, false));
 894   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, false));
 895   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
 896   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 897 }
 898
 899 // Tests RunLoopQuit works before RunWithID.
 900 void RunTest_RunLoopQuitOrderBefore(MessagePumpFactory factory) {
 901   scoped_ptr<MessagePump> pump(factory());
 902   MessageLoop loop(pump.Pass());
 903
 904   TaskList order;
 905
 906   RunLoop run_loop;
 907
 908   run_loop.Quit();
 909
 910   MessageLoop::current()->PostTask(
 911       FROM_HERE, Bind(&OrderedFunc, &order, 1)); // never runs
 912   MessageLoop::current()->PostTask(
 913       FROM_HERE, Bind(&FuncThatQuitsNow)); // never runs
 914
 915   run_loop.Run();
 916
 917   ASSERT_EQ(0U, order.Size());
 918 }
 919
 920 // Tests RunLoopQuit works during RunWithID.
 921 void RunTest_RunLoopQuitOrderDuring(MessagePumpFactory factory) {
 922   scoped_ptr<MessagePump> pump(factory());
 923   MessageLoop loop(pump.Pass());
 924
 925   TaskList order;
 926
 927   RunLoop run_loop;
 928
 929   MessageLoop::current()->PostTask(
 930       FROM_HERE, Bind(&OrderedFunc, &order, 1));
 931   MessageLoop::current()->PostTask(
 932       FROM_HERE, run_loop.QuitClosure());
 933   MessageLoop::current()->PostTask(
 934       FROM_HERE, Bind(&OrderedFunc, &order, 2)); // never runs
 935   MessageLoop::current()->PostTask(
 936       FROM_HERE, Bind(&FuncThatQuitsNow)); // never runs
 937
 938   run_loop.Run();
 939
 940   ASSERT_EQ(2U, order.Size());
 941   int task_index = 0;
 942   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, true));
 943   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, false));
 944   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 945 }
 946
 947 // Tests RunLoopQuit works after RunWithID.
 948 void RunTest_RunLoopQuitOrderAfter(MessagePumpFactory factory) {
 949   scoped_ptr<MessagePump> pump(factory());
 950   MessageLoop loop(pump.Pass());
 951
 952   TaskList order;
 953
 954   RunLoop run_loop;
 955
 956   MessageLoop::current()->PostTask(FROM_HERE,
 957       Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
 958   MessageLoop::current()->PostTask(
 959       FROM_HERE, Bind(&OrderedFunc, &order, 2));
 960   MessageLoop::current()->PostTask(
 961       FROM_HERE, Bind(&FuncThatQuitsNow));
 962   MessageLoop::current()->PostTask(
 963       FROM_HERE, Bind(&OrderedFunc, &order, 3));
 964   MessageLoop::current()->PostTask(
 965       FROM_HERE, run_loop.QuitClosure()); // has no affect
 966   MessageLoop::current()->PostTask(
 967       FROM_HERE, Bind(&OrderedFunc, &order, 4));
 968   MessageLoop::current()->PostTask(
 969       FROM_HERE, Bind(&FuncThatQuitsNow));
 970
 971   RunLoop outer_run_loop;
 972   outer_run_loop.Run();
 973
 974   ASSERT_EQ(8U, order.Size());
 975   int task_index = 0;
 976   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
 977   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
 978   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
 979   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
 980   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
 981   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
 982   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, true));
 983   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, false));
 984   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 985 }
 986
 987 void PostNTasksThenQuit(int posts_remaining) {
 988   if (posts_remaining > 1) {
 989     MessageLoop::current()->PostTask(
 990         FROM_HERE,
 991         Bind(&PostNTasksThenQuit, posts_remaining - 1));
 992   } else {
 993     MessageLoop::current()->QuitWhenIdle();
 994   }
 995 }
 996
 997 // There was a bug in the MessagePumpGLib where posting tasks recursively
 998 // caused the message loop to hang, due to the buffer of the internal pipe
 999 // becoming full. Test all MessageLoop types to ensure this issue does not
1000 // exist in other MessagePumps.
1001 //
1002 // On Linux, the pipe buffer size is 64KiB by default. The bug caused one
1003 // byte accumulated in the pipe per two posts, so we should repeat 128K
1004 // times to reproduce the bug.
1005 void RunTest_RecursivePosts(MessagePumpFactory factory) {
1006   const int kNumTimes = 1 << 17;
1007   scoped_ptr<MessagePump> pump(factory());
1008   MessageLoop loop(pump.Pass());
1009   loop.PostTask(FROM_HERE, Bind(&PostNTasksThenQuit, kNumTimes));
1010   loop.Run();
1011 }
1012
1013 }  // namespace test
1014 }  // namespace base