base/message_loop/message_loop_unittest.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 <vector>
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/logging.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/message_loop/message_loop_proxy_impl.h"
  14 #include "base/message_loop/message_loop_test.h"
  15 #include "base/pending_task.h"
  16 #include "base/posix/eintr_wrapper.h"
  17 #include "base/run_loop.h"
  18 #include "base/synchronization/waitable_event.h"
  19 #include "base/thread_task_runner_handle.h"
  20 #include "base/threading/platform_thread.h"
  21 #include "base/threading/thread.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 #if defined(OS_WIN)
  25 #include "base/message_loop/message_pump_dispatcher.h"
  26 #include "base/message_loop/message_pump_win.h"
  27 #include "base/process/memory.h"
  28 #include "base/strings/string16.h"
  29 #include "base/win/scoped_handle.h"
  30 #endif
  31
  32 namespace base {
  33
  34 // TODO(darin): Platform-specific MessageLoop tests should be grouped together
  35 // to avoid chopping this file up with so many #ifdefs.
  36
  37 namespace {
  38
  39 scoped_ptr<MessagePump> TypeDefaultMessagePumpFactory() {
  40   return MessageLoop::CreateMessagePumpForType(MessageLoop::TYPE_DEFAULT);
  41 }
  42
  43 scoped_ptr<MessagePump> TypeIOMessagePumpFactory() {
  44   return MessageLoop::CreateMessagePumpForType(MessageLoop::TYPE_IO);
  45 }
  46
  47 scoped_ptr<MessagePump> TypeUIMessagePumpFactory() {
  48   return MessageLoop::CreateMessagePumpForType(MessageLoop::TYPE_UI);
  49 }
  50
  51 class Foo : public RefCounted<Foo> {
  52  public:
  53   Foo() : test_count_(0) {
  54   }
  55
  56   void Test1ConstRef(const std::string& a) {
  57     ++test_count_;
  58     result_.append(a);
  59   }
  60
  61   int test_count() const { return test_count_; }
  62   const std::string& result() const { return result_; }
  63
  64  private:
  65   friend class RefCounted<Foo>;
  66
  67   ~Foo() {}
  68
  69   int test_count_;
  70   std::string result_;
  71 };
  72
  73 #if defined(OS_WIN)
  74
  75 // This function runs slowly to simulate a large amount of work being done.
  76 static void SlowFunc(TimeDelta pause, int* quit_counter) {
  77     PlatformThread::Sleep(pause);
  78     if (--(*quit_counter) == 0)
  79       MessageLoop::current()->QuitWhenIdle();
  80 }
  81
  82 // This function records the time when Run was called in a Time object, which is
  83 // useful for building a variety of MessageLoop tests.
  84 static void RecordRunTimeFunc(Time* run_time, int* quit_counter) {
  85   *run_time = Time::Now();
  86
  87     // Cause our Run function to take some time to execute.  As a result we can
  88     // count on subsequent RecordRunTimeFunc()s running at a future time,
  89     // without worry about the resolution of our system clock being an issue.
  90   SlowFunc(TimeDelta::FromMilliseconds(10), quit_counter);
  91 }
  92
  93 void SubPumpFunc() {
  94   MessageLoop::current()->SetNestableTasksAllowed(true);
  95   MSG msg;
  96   while (GetMessage(&msg, NULL, 0, 0)) {
  97     TranslateMessage(&msg);
  98     DispatchMessage(&msg);
  99   }
 100   MessageLoop::current()->QuitWhenIdle();
 101 }
 102
 103 void RunTest_PostDelayedTask_SharedTimer_SubPump() {
 104   MessageLoop loop(MessageLoop::TYPE_UI);
 105
 106   // Test that the interval of the timer, used to run the next delayed task, is
 107   // set to a value corresponding to when the next delayed task should run.
 108
 109   // By setting num_tasks to 1, we ensure that the first task to run causes the
 110   // run loop to exit.
 111   int num_tasks = 1;
 112   Time run_time;
 113
 114   loop.PostTask(FROM_HERE, Bind(&SubPumpFunc));
 115
 116   // This very delayed task should never run.
 117   loop.PostDelayedTask(
 118       FROM_HERE,
 119       Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
 120       TimeDelta::FromSeconds(1000));
 121
 122   // This slightly delayed task should run from within SubPumpFunc).
 123   loop.PostDelayedTask(
 124       FROM_HERE,
 125       Bind(&PostQuitMessage, 0),
 126       TimeDelta::FromMilliseconds(10));
 127
 128   Time start_time = Time::Now();
 129
 130   loop.Run();
 131   EXPECT_EQ(1, num_tasks);
 132
 133   // Ensure that we ran in far less time than the slower timer.
 134   TimeDelta total_time = Time::Now() - start_time;
 135   EXPECT_GT(5000, total_time.InMilliseconds());
 136
 137   // In case both timers somehow run at nearly the same time, sleep a little
 138   // and then run all pending to force them both to have run.  This is just
 139   // encouraging flakiness if there is any.
 140   PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
 141   RunLoop().RunUntilIdle();
 142
 143   EXPECT_TRUE(run_time.is_null());
 144 }
 145
 146 const wchar_t kMessageBoxTitle[] = L"MessageLoop Unit Test";
 147
 148 enum TaskType {
 149   MESSAGEBOX,
 150   ENDDIALOG,
 151   RECURSIVE,
 152   TIMEDMESSAGELOOP,
 153   QUITMESSAGELOOP,
 154   ORDERED,
 155   PUMPS,
 156   SLEEP,
 157   RUNS,
 158 };
 159
 160 // Saves the order in which the tasks executed.
 161 struct TaskItem {
 162   TaskItem(TaskType t, int c, bool s)
 163       : type(t),
 164         cookie(c),
 165         start(s) {
 166   }
 167
 168   TaskType type;
 169   int cookie;
 170   bool start;
 171
 172   bool operator == (const TaskItem& other) const {
 173     return type == other.type && cookie == other.cookie && start == other.start;
 174   }
 175 };
 176
 177 std::ostream& operator <<(std::ostream& os, TaskType type) {
 178   switch (type) {
 179   case MESSAGEBOX:        os << "MESSAGEBOX"; break;
 180   case ENDDIALOG:         os << "ENDDIALOG"; break;
 181   case RECURSIVE:         os << "RECURSIVE"; break;
 182   case TIMEDMESSAGELOOP:  os << "TIMEDMESSAGELOOP"; break;
 183   case QUITMESSAGELOOP:   os << "QUITMESSAGELOOP"; break;
 184   case ORDERED:          os << "ORDERED"; break;
 185   case PUMPS:             os << "PUMPS"; break;
 186   case SLEEP:             os << "SLEEP"; break;
 187   default:
 188     NOTREACHED();
 189     os << "Unknown TaskType";
 190     break;
 191   }
 192   return os;
 193 }
 194
 195 std::ostream& operator <<(std::ostream& os, const TaskItem& item) {
 196   if (item.start)
 197     return os << item.type << " " << item.cookie << " starts";
 198   else
 199     return os << item.type << " " << item.cookie << " ends";
 200 }
 201
 202 class TaskList {
 203  public:
 204   void RecordStart(TaskType type, int cookie) {
 205     TaskItem item(type, cookie, true);
 206     DVLOG(1) << item;
 207     task_list_.push_back(item);
 208   }
 209
 210   void RecordEnd(TaskType type, int cookie) {
 211     TaskItem item(type, cookie, false);
 212     DVLOG(1) << item;
 213     task_list_.push_back(item);
 214   }
 215
 216   size_t Size() {
 217     return task_list_.size();
 218   }
 219
 220   TaskItem Get(int n)  {
 221     return task_list_[n];
 222   }
 223
 224  private:
 225   std::vector<TaskItem> task_list_;
 226 };
 227
 228 // MessageLoop implicitly start a "modal message loop". Modal dialog boxes,
 229 // common controls (like OpenFile) and StartDoc printing function can cause
 230 // implicit message loops.
 231 void MessageBoxFunc(TaskList* order, int cookie, bool is_reentrant) {
 232   order->RecordStart(MESSAGEBOX, cookie);
 233   if (is_reentrant)
 234     MessageLoop::current()->SetNestableTasksAllowed(true);
 235   MessageBox(NULL, L"Please wait...", kMessageBoxTitle, MB_OK);
 236   order->RecordEnd(MESSAGEBOX, cookie);
 237 }
 238
 239 // Will end the MessageBox.
 240 void EndDialogFunc(TaskList* order, int cookie) {
 241   order->RecordStart(ENDDIALOG, cookie);
 242   HWND window = GetActiveWindow();
 243   if (window != NULL) {
 244     EXPECT_NE(EndDialog(window, IDCONTINUE), 0);
 245     // Cheap way to signal that the window wasn't found if RunEnd() isn't
 246     // called.
 247     order->RecordEnd(ENDDIALOG, cookie);
 248   }
 249 }
 250
 251 void RecursiveFunc(TaskList* order, int cookie, int depth,
 252                    bool is_reentrant) {
 253   order->RecordStart(RECURSIVE, cookie);
 254   if (depth > 0) {
 255     if (is_reentrant)
 256       MessageLoop::current()->SetNestableTasksAllowed(true);
 257     MessageLoop::current()->PostTask(
 258         FROM_HERE,
 259         Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
 260   }
 261   order->RecordEnd(RECURSIVE, cookie);
 262 }
 263
 264 void QuitFunc(TaskList* order, int cookie) {
 265   order->RecordStart(QUITMESSAGELOOP, cookie);
 266   MessageLoop::current()->QuitWhenIdle();
 267   order->RecordEnd(QUITMESSAGELOOP, cookie);
 268 }
 269
 270 void RecursiveFuncWin(MessageLoop* target,
 271                       HANDLE event,
 272                       bool expect_window,
 273                       TaskList* order,
 274                       bool is_reentrant) {
 275   target->PostTask(FROM_HERE,
 276                    Bind(&RecursiveFunc, order, 1, 2, is_reentrant));
 277   target->PostTask(FROM_HERE,
 278                    Bind(&MessageBoxFunc, order, 2, is_reentrant));
 279   target->PostTask(FROM_HERE,
 280                    Bind(&RecursiveFunc, order, 3, 2, is_reentrant));
 281   // The trick here is that for recursive task processing, this task will be
 282   // ran _inside_ the MessageBox message loop, dismissing the MessageBox
 283   // without a chance.
 284   // For non-recursive task processing, this will be executed _after_ the
 285   // MessageBox will have been dismissed by the code below, where
 286   // expect_window_ is true.
 287   target->PostTask(FROM_HERE,
 288                    Bind(&EndDialogFunc, order, 4));
 289   target->PostTask(FROM_HERE,
 290                    Bind(&QuitFunc, order, 5));
 291
 292   // Enforce that every tasks are sent before starting to run the main thread
 293   // message loop.
 294   ASSERT_TRUE(SetEvent(event));
 295
 296   // Poll for the MessageBox. Don't do this at home! At the speed we do it,
 297   // you will never realize one MessageBox was shown.
 298   for (; expect_window;) {
 299     HWND window = FindWindow(L"#32770", kMessageBoxTitle);
 300     if (window) {
 301       // Dismiss it.
 302       for (;;) {
 303         HWND button = FindWindowEx(window, NULL, L"Button", NULL);
 304         if (button != NULL) {
 305           EXPECT_EQ(0, SendMessage(button, WM_LBUTTONDOWN, 0, 0));
 306           EXPECT_EQ(0, SendMessage(button, WM_LBUTTONUP, 0, 0));
 307           break;
 308         }
 309       }
 310       break;
 311     }
 312   }
 313 }
 314
 315 // TODO(darin): These tests need to be ported since they test critical
 316 // message loop functionality.
 317
 318 // A side effect of this test is the generation a beep. Sorry.
 319 void RunTest_RecursiveDenial2(MessageLoop::Type message_loop_type) {
 320   MessageLoop loop(message_loop_type);
 321
 322   Thread worker("RecursiveDenial2_worker");
 323   Thread::Options options;
 324   options.message_loop_type = message_loop_type;
 325   ASSERT_EQ(true, worker.StartWithOptions(options));
 326   TaskList order;
 327   win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
 328   worker.message_loop()->PostTask(FROM_HERE,
 329                                   Bind(&RecursiveFuncWin,
 330                                              MessageLoop::current(),
 331                                              event.Get(),
 332                                              true,
 333                                              &order,
 334                                              false));
 335   // Let the other thread execute.
 336   WaitForSingleObject(event.Get(), INFINITE);
 337   MessageLoop::current()->Run();
 338
 339   ASSERT_EQ(order.Size(), 17);
 340   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
 341   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
 342   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
 343   EXPECT_EQ(order.Get(3), TaskItem(MESSAGEBOX, 2, false));
 344   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, true));
 345   EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 3, false));
 346   // When EndDialogFunc is processed, the window is already dismissed, hence no
 347   // "end" entry.
 348   EXPECT_EQ(order.Get(6), TaskItem(ENDDIALOG, 4, true));
 349   EXPECT_EQ(order.Get(7), TaskItem(QUITMESSAGELOOP, 5, true));
 350   EXPECT_EQ(order.Get(8), TaskItem(QUITMESSAGELOOP, 5, false));
 351   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 1, true));
 352   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, false));
 353   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 3, true));
 354   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 3, false));
 355   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, true));
 356   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 1, false));
 357   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 3, true));
 358   EXPECT_EQ(order.Get(16), TaskItem(RECURSIVE, 3, false));
 359 }
 360
 361 // A side effect of this test is the generation a beep. Sorry.  This test also
 362 // needs to process windows messages on the current thread.
 363 void RunTest_RecursiveSupport2(MessageLoop::Type message_loop_type) {
 364   MessageLoop loop(message_loop_type);
 365
 366   Thread worker("RecursiveSupport2_worker");
 367   Thread::Options options;
 368   options.message_loop_type = message_loop_type;
 369   ASSERT_EQ(true, worker.StartWithOptions(options));
 370   TaskList order;
 371   win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
 372   worker.message_loop()->PostTask(FROM_HERE,
 373                                   Bind(&RecursiveFuncWin,
 374                                              MessageLoop::current(),
 375                                              event.Get(),
 376                                              false,
 377                                              &order,
 378                                              true));
 379   // Let the other thread execute.
 380   WaitForSingleObject(event.Get(), INFINITE);
 381   MessageLoop::current()->Run();
 382
 383   ASSERT_EQ(order.Size(), 18);
 384   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
 385   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
 386   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
 387   // Note that this executes in the MessageBox modal loop.
 388   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 3, true));
 389   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, false));
 390   EXPECT_EQ(order.Get(5), TaskItem(ENDDIALOG, 4, true));
 391   EXPECT_EQ(order.Get(6), TaskItem(ENDDIALOG, 4, false));
 392   EXPECT_EQ(order.Get(7), TaskItem(MESSAGEBOX, 2, false));
 393   /* The order can subtly change here. The reason is that when RecursiveFunc(1)
 394      is called in the main thread, if it is faster than getting to the
 395      PostTask(FROM_HERE, Bind(&QuitFunc) execution, the order of task
 396      execution can change. We don't care anyway that the order isn't correct.
 397   EXPECT_EQ(order.Get(8), TaskItem(QUITMESSAGELOOP, 5, true));
 398   EXPECT_EQ(order.Get(9), TaskItem(QUITMESSAGELOOP, 5, false));
 399   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
 400   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
 401   */
 402   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 3, true));
 403   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 3, false));
 404   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 1, true));
 405   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 1, false));
 406   EXPECT_EQ(order.Get(16), TaskItem(RECURSIVE, 3, true));
 407   EXPECT_EQ(order.Get(17), TaskItem(RECURSIVE, 3, false));
 408 }
 409
 410 #endif  // defined(OS_WIN)
 411
 412 void PostNTasksThenQuit(int posts_remaining) {
 413   if (posts_remaining > 1) {
 414     MessageLoop::current()->PostTask(
 415         FROM_HERE,
 416         Bind(&PostNTasksThenQuit, posts_remaining - 1));
 417   } else {
 418     MessageLoop::current()->QuitWhenIdle();
 419   }
 420 }
 421
 422 #if defined(OS_WIN)
 423
 424 class DispatcherImpl : public MessagePumpDispatcher {
 425  public:
 426   DispatcherImpl() : dispatch_count_(0) {}
 427
 428   virtual uint32_t Dispatch(const NativeEvent& msg) override {
 429     ::TranslateMessage(&msg);
 430     ::DispatchMessage(&msg);
 431     // Do not count WM_TIMER since it is not what we post and it will cause
 432     // flakiness.
 433     if (msg.message != WM_TIMER)
 434       ++dispatch_count_;
 435     // We treat WM_LBUTTONUP as the last message.
 436     return msg.message == WM_LBUTTONUP ? POST_DISPATCH_QUIT_LOOP
 437                                        : POST_DISPATCH_NONE;
 438   }
 439
 440   int dispatch_count_;
 441 };
 442
 443 void MouseDownUp() {
 444   PostMessage(NULL, WM_LBUTTONDOWN, 0, 0);
 445   PostMessage(NULL, WM_LBUTTONUP, 'A', 0);
 446 }
 447
 448 void RunTest_Dispatcher(MessageLoop::Type message_loop_type) {
 449   MessageLoop loop(message_loop_type);
 450
 451   MessageLoop::current()->PostDelayedTask(
 452       FROM_HERE,
 453       Bind(&MouseDownUp),
 454       TimeDelta::FromMilliseconds(100));
 455   DispatcherImpl dispatcher;
 456   RunLoop run_loop(&dispatcher);
 457   run_loop.Run();
 458   ASSERT_EQ(2, dispatcher.dispatch_count_);
 459 }
 460
 461 LRESULT CALLBACK MsgFilterProc(int code, WPARAM wparam, LPARAM lparam) {
 462   if (code == MessagePumpForUI::kMessageFilterCode) {
 463     MSG* msg = reinterpret_cast<MSG*>(lparam);
 464     if (msg->message == WM_LBUTTONDOWN)
 465       return TRUE;
 466   }
 467   return FALSE;
 468 }
 469
 470 void RunTest_DispatcherWithMessageHook(MessageLoop::Type message_loop_type) {
 471   MessageLoop loop(message_loop_type);
 472
 473   MessageLoop::current()->PostDelayedTask(
 474       FROM_HERE,
 475       Bind(&MouseDownUp),
 476       TimeDelta::FromMilliseconds(100));
 477   HHOOK msg_hook = SetWindowsHookEx(WH_MSGFILTER,
 478                                     MsgFilterProc,
 479                                     NULL,
 480                                     GetCurrentThreadId());
 481   DispatcherImpl dispatcher;
 482   RunLoop run_loop(&dispatcher);
 483   run_loop.Run();
 484   ASSERT_EQ(1, dispatcher.dispatch_count_);
 485   UnhookWindowsHookEx(msg_hook);
 486 }
 487
 488 class TestIOHandler : public MessageLoopForIO::IOHandler {
 489  public:
 490   TestIOHandler(const wchar_t* name, HANDLE signal, bool wait);
 491
 492   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
 493                              DWORD bytes_transfered, DWORD error);
 494
 495   void Init();
 496   void WaitForIO();
 497   OVERLAPPED* context() { return &context_.overlapped; }
 498   DWORD size() { return sizeof(buffer_); }
 499
 500  private:
 501   char buffer_[48];
 502   MessageLoopForIO::IOContext context_;
 503   HANDLE signal_;
 504   win::ScopedHandle file_;
 505   bool wait_;
 506 };
 507
 508 TestIOHandler::TestIOHandler(const wchar_t* name, HANDLE signal, bool wait)
 509     : signal_(signal), wait_(wait) {
 510   memset(buffer_, 0, sizeof(buffer_));
 511   memset(&context_, 0, sizeof(context_));
 512   context_.handler = this;
 513
 514   file_.Set(CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING,
 515                        FILE_FLAG_OVERLAPPED, NULL));
 516   EXPECT_TRUE(file_.IsValid());
 517 }
 518
 519 void TestIOHandler::Init() {
 520   MessageLoopForIO::current()->RegisterIOHandler(file_.Get(), this);
 521
 522   DWORD read;
 523   EXPECT_FALSE(ReadFile(file_.Get(), buffer_, size(), &read, context()));
 524   EXPECT_EQ(ERROR_IO_PENDING, GetLastError());
 525   if (wait_)
 526     WaitForIO();
 527 }
 528
 529 void TestIOHandler::OnIOCompleted(MessageLoopForIO::IOContext* context,
 530                                   DWORD bytes_transfered, DWORD error) {
 531   ASSERT_TRUE(context == &context_);
 532   ASSERT_TRUE(SetEvent(signal_));
 533 }
 534
 535 void TestIOHandler::WaitForIO() {
 536   EXPECT_TRUE(MessageLoopForIO::current()->WaitForIOCompletion(300, this));
 537   EXPECT_TRUE(MessageLoopForIO::current()->WaitForIOCompletion(400, this));
 538 }
 539
 540 void RunTest_IOHandler() {
 541   win::ScopedHandle callback_called(CreateEvent(NULL, TRUE, FALSE, NULL));
 542   ASSERT_TRUE(callback_called.IsValid());
 543
 544   const wchar_t* kPipeName = L"\\\\.\\pipe\\iohandler_pipe";
 545   win::ScopedHandle server(
 546       CreateNamedPipe(kPipeName, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
 547   ASSERT_TRUE(server.IsValid());
 548
 549   Thread thread("IOHandler test");
 550   Thread::Options options;
 551   options.message_loop_type = MessageLoop::TYPE_IO;
 552   ASSERT_TRUE(thread.StartWithOptions(options));
 553
 554   MessageLoop* thread_loop = thread.message_loop();
 555   ASSERT_TRUE(NULL != thread_loop);
 556
 557   TestIOHandler handler(kPipeName, callback_called.Get(), false);
 558   thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
 559                                               Unretained(&handler)));
 560   // Make sure the thread runs and sleeps for lack of work.
 561   PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
 562
 563   const char buffer[] = "Hello there!";
 564   DWORD written;
 565   EXPECT_TRUE(WriteFile(server.Get(), buffer, sizeof(buffer), &written, NULL));
 566
 567   DWORD result = WaitForSingleObject(callback_called.Get(), 1000);
 568   EXPECT_EQ(WAIT_OBJECT_0, result);
 569
 570   thread.Stop();
 571 }
 572
 573 void RunTest_WaitForIO() {
 574   win::ScopedHandle callback1_called(
 575       CreateEvent(NULL, TRUE, FALSE, NULL));
 576   win::ScopedHandle callback2_called(
 577       CreateEvent(NULL, TRUE, FALSE, NULL));
 578   ASSERT_TRUE(callback1_called.IsValid());
 579   ASSERT_TRUE(callback2_called.IsValid());
 580
 581   const wchar_t* kPipeName1 = L"\\\\.\\pipe\\iohandler_pipe1";
 582   const wchar_t* kPipeName2 = L"\\\\.\\pipe\\iohandler_pipe2";
 583   win::ScopedHandle server1(
 584       CreateNamedPipe(kPipeName1, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
 585   win::ScopedHandle server2(
 586       CreateNamedPipe(kPipeName2, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
 587   ASSERT_TRUE(server1.IsValid());
 588   ASSERT_TRUE(server2.IsValid());
 589
 590   Thread thread("IOHandler test");
 591   Thread::Options options;
 592   options.message_loop_type = MessageLoop::TYPE_IO;
 593   ASSERT_TRUE(thread.StartWithOptions(options));
 594
 595   MessageLoop* thread_loop = thread.message_loop();
 596   ASSERT_TRUE(NULL != thread_loop);
 597
 598   TestIOHandler handler1(kPipeName1, callback1_called.Get(), false);
 599   TestIOHandler handler2(kPipeName2, callback2_called.Get(), true);
 600   thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
 601                                               Unretained(&handler1)));
 602   // TODO(ajwong): Do we really need such long Sleeps in ths function?
 603   // Make sure the thread runs and sleeps for lack of work.
 604   TimeDelta delay = TimeDelta::FromMilliseconds(100);
 605   PlatformThread::Sleep(delay);
 606   thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
 607                                               Unretained(&handler2)));
 608   PlatformThread::Sleep(delay);
 609
 610   // At this time handler1 is waiting to be called, and the thread is waiting
 611   // on the Init method of handler2, filtering only handler2 callbacks.
 612
 613   const char buffer[] = "Hello there!";
 614   DWORD written;
 615   EXPECT_TRUE(WriteFile(server1.Get(), buffer, sizeof(buffer), &written, NULL));
 616   PlatformThread::Sleep(2 * delay);
 617   EXPECT_EQ(WAIT_TIMEOUT, WaitForSingleObject(callback1_called.Get(), 0)) <<
 618       "handler1 has not been called";
 619
 620   EXPECT_TRUE(WriteFile(server2.Get(), buffer, sizeof(buffer), &written, NULL));
 621
 622   HANDLE objects[2] = { callback1_called.Get(), callback2_called.Get() };
 623   DWORD result = WaitForMultipleObjects(2, objects, TRUE, 1000);
 624   EXPECT_EQ(WAIT_OBJECT_0, result);
 625
 626   thread.Stop();
 627 }
 628
 629 #endif  // defined(OS_WIN)
 630
 631 }  // namespace
 632
 633 //-----------------------------------------------------------------------------
 634 // Each test is run against each type of MessageLoop.  That way we are sure
 635 // that message loops work properly in all configurations.  Of course, in some
 636 // cases, a unit test may only be for a particular type of loop.
 637
 638 RUN_MESSAGE_LOOP_TESTS(Default, &TypeDefaultMessagePumpFactory);
 639 RUN_MESSAGE_LOOP_TESTS(UI, &TypeUIMessagePumpFactory);
 640 RUN_MESSAGE_LOOP_TESTS(IO, &TypeIOMessagePumpFactory);
 641
 642 #if defined(OS_WIN)
 643 TEST(MessageLoopTest, PostDelayedTask_SharedTimer_SubPump) {
 644   RunTest_PostDelayedTask_SharedTimer_SubPump();
 645 }
 646
 647 // This test occasionally hangs http://crbug.com/44567
 648 TEST(MessageLoopTest, DISABLED_RecursiveDenial2) {
 649   RunTest_RecursiveDenial2(MessageLoop::TYPE_DEFAULT);
 650   RunTest_RecursiveDenial2(MessageLoop::TYPE_UI);
 651   RunTest_RecursiveDenial2(MessageLoop::TYPE_IO);
 652 }
 653
 654 TEST(MessageLoopTest, RecursiveSupport2) {
 655   // This test requires a UI loop
 656   RunTest_RecursiveSupport2(MessageLoop::TYPE_UI);
 657 }
 658 #endif  // defined(OS_WIN)
 659
 660 class DummyTaskObserver : public MessageLoop::TaskObserver {
 661  public:
 662   explicit DummyTaskObserver(int num_tasks)
 663       : num_tasks_started_(0),
 664         num_tasks_processed_(0),
 665         num_tasks_(num_tasks) {}
 666
 667   ~DummyTaskObserver() override {}
 668
 669   void WillProcessTask(const PendingTask& pending_task) override {
 670     num_tasks_started_++;
 671     EXPECT_LE(num_tasks_started_, num_tasks_);
 672     EXPECT_EQ(num_tasks_started_, num_tasks_processed_ + 1);
 673   }
 674
 675   void DidProcessTask(const PendingTask& pending_task) override {
 676     num_tasks_processed_++;
 677     EXPECT_LE(num_tasks_started_, num_tasks_);
 678     EXPECT_EQ(num_tasks_started_, num_tasks_processed_);
 679   }
 680
 681   int num_tasks_started() const { return num_tasks_started_; }
 682   int num_tasks_processed() const { return num_tasks_processed_; }
 683
 684  private:
 685   int num_tasks_started_;
 686   int num_tasks_processed_;
 687   const int num_tasks_;
 688
 689   DISALLOW_COPY_AND_ASSIGN(DummyTaskObserver);
 690 };
 691
 692 TEST(MessageLoopTest, TaskObserver) {
 693   const int kNumPosts = 6;
 694   DummyTaskObserver observer(kNumPosts);
 695
 696   MessageLoop loop;
 697   loop.AddTaskObserver(&observer);
 698   loop.PostTask(FROM_HERE, Bind(&PostNTasksThenQuit, kNumPosts));
 699   loop.Run();
 700   loop.RemoveTaskObserver(&observer);
 701
 702   EXPECT_EQ(kNumPosts, observer.num_tasks_started());
 703   EXPECT_EQ(kNumPosts, observer.num_tasks_processed());
 704 }
 705
 706 #if defined(OS_WIN)
 707 TEST(MessageLoopTest, Dispatcher) {
 708   // This test requires a UI loop
 709   RunTest_Dispatcher(MessageLoop::TYPE_UI);
 710 }
 711
 712 TEST(MessageLoopTest, DispatcherWithMessageHook) {
 713   // This test requires a UI loop
 714   RunTest_DispatcherWithMessageHook(MessageLoop::TYPE_UI);
 715 }
 716
 717 TEST(MessageLoopTest, IOHandler) {
 718   RunTest_IOHandler();
 719 }
 720
 721 TEST(MessageLoopTest, WaitForIO) {
 722   RunTest_WaitForIO();
 723 }
 724
 725 TEST(MessageLoopTest, HighResolutionTimer) {
 726   MessageLoop loop;
 727   Time::EnableHighResolutionTimer(true);
 728
 729   const TimeDelta kFastTimer = TimeDelta::FromMilliseconds(5);
 730   const TimeDelta kSlowTimer = TimeDelta::FromMilliseconds(100);
 731
 732   EXPECT_FALSE(loop.HasHighResolutionTasks());
 733   // Post a fast task to enable the high resolution timers.
 734   loop.PostDelayedTask(FROM_HERE, Bind(&PostNTasksThenQuit, 1),
 735                        kFastTimer);
 736   EXPECT_TRUE(loop.HasHighResolutionTasks());
 737   loop.Run();
 738   EXPECT_FALSE(loop.HasHighResolutionTasks());
 739   EXPECT_FALSE(Time::IsHighResolutionTimerInUse());
 740   // Check that a slow task does not trigger the high resolution logic.
 741   loop.PostDelayedTask(FROM_HERE, Bind(&PostNTasksThenQuit, 1),
 742                        kSlowTimer);
 743   EXPECT_FALSE(loop.HasHighResolutionTasks());
 744   loop.Run();
 745   EXPECT_FALSE(loop.HasHighResolutionTasks());
 746   Time::EnableHighResolutionTimer(false);
 747 }
 748
 749 #endif  // defined(OS_WIN)
 750
 751 #if defined(OS_POSIX) && !defined(OS_NACL)
 752
 753 namespace {
 754
 755 class QuitDelegate : public MessageLoopForIO::Watcher {
 756  public:
 757   void OnFileCanWriteWithoutBlocking(int fd) override {
 758     MessageLoop::current()->QuitWhenIdle();
 759   }
 760   void OnFileCanReadWithoutBlocking(int fd) override {
 761     MessageLoop::current()->QuitWhenIdle();
 762   }
 763 };
 764
 765 TEST(MessageLoopTest, FileDescriptorWatcherOutlivesMessageLoop) {
 766   // Simulate a MessageLoop that dies before an FileDescriptorWatcher.
 767   // This could happen when people use the Singleton pattern or atexit.
 768
 769   // Create a file descriptor.  Doesn't need to be readable or writable,
 770   // as we don't need to actually get any notifications.
 771   // pipe() is just the easiest way to do it.
 772   int pipefds[2];
 773   int err = pipe(pipefds);
 774   ASSERT_EQ(0, err);
 775   int fd = pipefds[1];
 776   {
 777     // Arrange for controller to live longer than message loop.
 778     MessageLoopForIO::FileDescriptorWatcher controller;
 779     {
 780       MessageLoopForIO message_loop;
 781
 782       QuitDelegate delegate;
 783       message_loop.WatchFileDescriptor(fd,
 784           true, MessageLoopForIO::WATCH_WRITE, &controller, &delegate);
 785       // and don't run the message loop, just destroy it.
 786     }
 787   }
 788   if (IGNORE_EINTR(close(pipefds[0])) < 0)
 789     PLOG(ERROR) << "close";
 790   if (IGNORE_EINTR(close(pipefds[1])) < 0)
 791     PLOG(ERROR) << "close";
 792 }
 793
 794 TEST(MessageLoopTest, FileDescriptorWatcherDoubleStop) {
 795   // Verify that it's ok to call StopWatchingFileDescriptor().
 796   // (Errors only showed up in valgrind.)
 797   int pipefds[2];
 798   int err = pipe(pipefds);
 799   ASSERT_EQ(0, err);
 800   int fd = pipefds[1];
 801   {
 802     // Arrange for message loop to live longer than controller.
 803     MessageLoopForIO message_loop;
 804     {
 805       MessageLoopForIO::FileDescriptorWatcher controller;
 806
 807       QuitDelegate delegate;
 808       message_loop.WatchFileDescriptor(fd,
 809           true, MessageLoopForIO::WATCH_WRITE, &controller, &delegate);
 810       controller.StopWatchingFileDescriptor();
 811     }
 812   }
 813   if (IGNORE_EINTR(close(pipefds[0])) < 0)
 814     PLOG(ERROR) << "close";
 815   if (IGNORE_EINTR(close(pipefds[1])) < 0)
 816     PLOG(ERROR) << "close";
 817 }
 818
 819 }  // namespace
 820
 821 #endif  // defined(OS_POSIX) && !defined(OS_NACL)
 822
 823 namespace {
 824 // Inject a test point for recording the destructor calls for Closure objects
 825 // send to MessageLoop::PostTask(). It is awkward usage since we are trying to
 826 // hook the actual destruction, which is not a common operation.
 827 class DestructionObserverProbe :
 828   public RefCounted<DestructionObserverProbe> {
 829  public:
 830   DestructionObserverProbe(bool* task_destroyed,
 831                            bool* destruction_observer_called)
 832       : task_destroyed_(task_destroyed),
 833         destruction_observer_called_(destruction_observer_called) {
 834   }
 835   virtual void Run() {
 836     // This task should never run.
 837     ADD_FAILURE();
 838   }
 839  private:
 840   friend class RefCounted<DestructionObserverProbe>;
 841
 842   virtual ~DestructionObserverProbe() {
 843     EXPECT_FALSE(*destruction_observer_called_);
 844     *task_destroyed_ = true;
 845   }
 846
 847   bool* task_destroyed_;
 848   bool* destruction_observer_called_;
 849 };
 850
 851 class MLDestructionObserver : public MessageLoop::DestructionObserver {
 852  public:
 853   MLDestructionObserver(bool* task_destroyed, bool* destruction_observer_called)
 854       : task_destroyed_(task_destroyed),
 855         destruction_observer_called_(destruction_observer_called),
 856         task_destroyed_before_message_loop_(false) {
 857   }
 858   void WillDestroyCurrentMessageLoop() override {
 859     task_destroyed_before_message_loop_ = *task_destroyed_;
 860     *destruction_observer_called_ = true;
 861   }
 862   bool task_destroyed_before_message_loop() const {
 863     return task_destroyed_before_message_loop_;
 864   }
 865  private:
 866   bool* task_destroyed_;
 867   bool* destruction_observer_called_;
 868   bool task_destroyed_before_message_loop_;
 869 };
 870
 871 }  // namespace
 872
 873 TEST(MessageLoopTest, DestructionObserverTest) {
 874   // Verify that the destruction observer gets called at the very end (after
 875   // all the pending tasks have been destroyed).
 876   MessageLoop* loop = new MessageLoop;
 877   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 878
 879   bool task_destroyed = false;
 880   bool destruction_observer_called = false;
 881
 882   MLDestructionObserver observer(&task_destroyed, &destruction_observer_called);
 883   loop->AddDestructionObserver(&observer);
 884   loop->PostDelayedTask(
 885       FROM_HERE,
 886       Bind(&DestructionObserverProbe::Run,
 887                  new DestructionObserverProbe(&task_destroyed,
 888                                               &destruction_observer_called)),
 889       kDelay);
 890   delete loop;
 891   EXPECT_TRUE(observer.task_destroyed_before_message_loop());
 892   // The task should have been destroyed when we deleted the loop.
 893   EXPECT_TRUE(task_destroyed);
 894   EXPECT_TRUE(destruction_observer_called);
 895 }
 896
 897
 898 // Verify that MessageLoop sets ThreadMainTaskRunner::current() and it
 899 // posts tasks on that message loop.
 900 TEST(MessageLoopTest, ThreadMainTaskRunner) {
 901   MessageLoop loop;
 902
 903   scoped_refptr<Foo> foo(new Foo());
 904   std::string a("a");
 905   ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(
 906       &Foo::Test1ConstRef, foo.get(), a));
 907
 908   // Post quit task;
 909   MessageLoop::current()->PostTask(FROM_HERE, Bind(
 910       &MessageLoop::Quit, Unretained(MessageLoop::current())));
 911
 912   // Now kick things off
 913   MessageLoop::current()->Run();
 914
 915   EXPECT_EQ(foo->test_count(), 1);
 916   EXPECT_EQ(foo->result(), "a");
 917 }
 918
 919 TEST(MessageLoopTest, IsType) {
 920   MessageLoop loop(MessageLoop::TYPE_UI);
 921   EXPECT_TRUE(loop.IsType(MessageLoop::TYPE_UI));
 922   EXPECT_FALSE(loop.IsType(MessageLoop::TYPE_IO));
 923   EXPECT_FALSE(loop.IsType(MessageLoop::TYPE_DEFAULT));
 924 }
 925
 926 #if defined(OS_WIN)
 927 void EmptyFunction() {}
 928
 929 void PostMultipleTasks() {
 930   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&EmptyFunction));
 931   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&EmptyFunction));
 932 }
 933
 934 static const int kSignalMsg = WM_USER + 2;
 935
 936 void PostWindowsMessage(HWND message_hwnd) {
 937   PostMessage(message_hwnd, kSignalMsg, 0, 2);
 938 }
 939
 940 void EndTest(bool* did_run, HWND hwnd) {
 941   *did_run = true;
 942   PostMessage(hwnd, WM_CLOSE, 0, 0);
 943 }
 944
 945 int kMyMessageFilterCode = 0x5002;
 946
 947 LRESULT CALLBACK TestWndProcThunk(HWND hwnd, UINT message,
 948                                   WPARAM wparam, LPARAM lparam) {
 949   if (message == WM_CLOSE)
 950     EXPECT_TRUE(DestroyWindow(hwnd));
 951   if (message != kSignalMsg)
 952     return DefWindowProc(hwnd, message, wparam, lparam);
 953
 954   switch (lparam) {
 955   case 1:
 956     // First, we post a task that will post multiple no-op tasks to make sure
 957     // that the pump's incoming task queue does not become empty during the
 958     // test.
 959     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&PostMultipleTasks));
 960     // Next, we post a task that posts a windows message to trigger the second
 961     // stage of the test.
 962     MessageLoop::current()->PostTask(FROM_HERE,
 963                                      base::Bind(&PostWindowsMessage, hwnd));
 964     break;
 965   case 2:
 966     // Since we're about to enter a modal loop, tell the message loop that we
 967     // intend to nest tasks.
 968     MessageLoop::current()->SetNestableTasksAllowed(true);
 969     bool did_run = false;
 970     MessageLoop::current()->PostTask(FROM_HERE,
 971                                      base::Bind(&EndTest, &did_run, hwnd));
 972     // Run a nested windows-style message loop and verify that our task runs. If
 973     // it doesn't, then we'll loop here until the test times out.
 974     MSG msg;
 975     while (GetMessage(&msg, 0, 0, 0)) {
 976       if (!CallMsgFilter(&msg, kMyMessageFilterCode))
 977         DispatchMessage(&msg);
 978       // If this message is a WM_CLOSE, explicitly exit the modal loop. Posting
 979       // a WM_QUIT should handle this, but unfortunately MessagePumpWin eats
 980       // WM_QUIT messages even when running inside a modal loop.
 981       if (msg.message == WM_CLOSE)
 982         break;
 983     }
 984     EXPECT_TRUE(did_run);
 985     MessageLoop::current()->Quit();
 986     break;
 987   }
 988   return 0;
 989 }
 990
 991 TEST(MessageLoopTest, AlwaysHaveUserMessageWhenNesting) {
 992   MessageLoop loop(MessageLoop::TYPE_UI);
 993   HINSTANCE instance = GetModuleFromAddress(&TestWndProcThunk);
 994   WNDCLASSEX wc = {0};
 995   wc.cbSize = sizeof(wc);
 996   wc.lpfnWndProc = TestWndProcThunk;
 997   wc.hInstance = instance;
 998   wc.lpszClassName = L"MessageLoopTest_HWND";
 999   ATOM atom = RegisterClassEx(&wc);
1000   ASSERT_TRUE(atom);
1001
1002   HWND message_hwnd = CreateWindow(MAKEINTATOM(atom), 0, 0, 0, 0, 0, 0,
1003                                    HWND_MESSAGE, 0, instance, 0);
1004   ASSERT_TRUE(message_hwnd) << GetLastError();
1005
1006   ASSERT_TRUE(PostMessage(message_hwnd, kSignalMsg, 0, 1));
1007
1008   loop.Run();
1009
1010   ASSERT_TRUE(UnregisterClass(MAKEINTATOM(atom), instance));
1011 }
1012 #endif  // defined(OS_WIN)
1013
1014 }  // namespace base