base/message_pump_glib_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/message_pump_glib.h"
   6
   7 #include <glib.h>
   8 #include <math.h>
   9
  10 #include <algorithm>
  11 #include <vector>
  12
  13 #include "base/bind.h"
  14 #include "base/bind_helpers.h"
  15 #include "base/callback.h"
  16 #include "base/memory/ref_counted.h"
  17 #include "base/message_loop.h"
  18 #include "base/run_loop.h"
  19 #include "base/threading/thread.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 #if defined(TOOLKIT_GTK)
  23 #include <gtk/gtk.h>
  24 #endif
  25
  26 namespace base {
  27 namespace {
  28
  29 // This class injects dummy "events" into the GLib loop. When "handled" these
  30 // events can run tasks. This is intended to mock gtk events (the corresponding
  31 // GLib source runs at the same priority).
  32 class EventInjector {
  33  public:
  34   EventInjector() : processed_events_(0) {
  35     source_ = static_cast<Source*>(g_source_new(&SourceFuncs, sizeof(Source)));
  36     source_->injector = this;
  37     g_source_attach(source_, NULL);
  38     g_source_set_can_recurse(source_, TRUE);
  39   }
  40
  41   ~EventInjector() {
  42     g_source_destroy(source_);
  43     g_source_unref(source_);
  44   }
  45
  46   int HandlePrepare() {
  47     // If the queue is empty, block.
  48     if (events_.empty())
  49       return -1;
  50     base::TimeDelta delta = events_[0].time - base::Time::NowFromSystemTime();
  51     return std::max(0, static_cast<int>(ceil(delta.InMillisecondsF())));
  52   }
  53
  54   bool HandleCheck() {
  55     if (events_.empty())
  56       return false;
  57     return events_[0].time <= base::Time::NowFromSystemTime();
  58   }
  59
  60   void HandleDispatch() {
  61     if (events_.empty())
  62       return;
  63     Event event = events_[0];
  64     events_.erase(events_.begin());
  65     ++processed_events_;
  66     if (!event.callback.is_null())
  67       event.callback.Run();
  68     else if (!event.task.is_null())
  69       event.task.Run();
  70   }
  71
  72   // Adds an event to the queue. When "handled", executes |callback|.
  73   // delay_ms is relative to the last event if any, or to Now() otherwise.
  74   void AddEvent(int delay_ms, const base::Closure& callback) {
  75     AddEventHelper(delay_ms, callback, base::Closure());
  76   }
  77
  78   void AddDummyEvent(int delay_ms) {
  79     AddEventHelper(delay_ms, base::Closure(), base::Closure());
  80   }
  81
  82   void AddEventAsTask(int delay_ms, const base::Closure& task) {
  83     AddEventHelper(delay_ms, base::Closure(), task);
  84   }
  85
  86   void Reset() {
  87     processed_events_ = 0;
  88     events_.clear();
  89   }
  90
  91   int processed_events() const { return processed_events_; }
  92
  93  private:
  94   struct Event {
  95     base::Time time;
  96     base::Closure callback;
  97     base::Closure task;
  98   };
  99
 100   struct Source : public GSource {
 101     EventInjector* injector;
 102   };
 103
 104   void AddEventHelper(
 105       int delay_ms, const base::Closure& callback, const base::Closure& task) {
 106     base::Time last_time;
 107     if (!events_.empty())
 108       last_time = (events_.end()-1)->time;
 109     else
 110       last_time = base::Time::NowFromSystemTime();
 111
 112     base::Time future = last_time + base::TimeDelta::FromMilliseconds(delay_ms);
 113     EventInjector::Event event = {future, callback, task};
 114     events_.push_back(event);
 115   }
 116
 117   static gboolean Prepare(GSource* source, gint* timeout_ms) {
 118     *timeout_ms = static_cast<Source*>(source)->injector->HandlePrepare();
 119     return FALSE;
 120   }
 121
 122   static gboolean Check(GSource* source) {
 123     return static_cast<Source*>(source)->injector->HandleCheck();
 124   }
 125
 126   static gboolean Dispatch(GSource* source,
 127                            GSourceFunc unused_func,
 128                            gpointer unused_data) {
 129     static_cast<Source*>(source)->injector->HandleDispatch();
 130     return TRUE;
 131   }
 132
 133   Source* source_;
 134   std::vector<Event> events_;
 135   int processed_events_;
 136   static GSourceFuncs SourceFuncs;
 137   DISALLOW_COPY_AND_ASSIGN(EventInjector);
 138 };
 139
 140 GSourceFuncs EventInjector::SourceFuncs = {
 141   EventInjector::Prepare,
 142   EventInjector::Check,
 143   EventInjector::Dispatch,
 144   NULL
 145 };
 146
 147 void IncrementInt(int *value) {
 148   ++*value;
 149 }
 150
 151 // Checks how many events have been processed by the injector.
 152 void ExpectProcessedEvents(EventInjector* injector, int count) {
 153   EXPECT_EQ(injector->processed_events(), count);
 154 }
 155
 156 // Posts a task on the current message loop.
 157 void PostMessageLoopTask(const tracked_objects::Location& from_here,
 158                          const base::Closure& task) {
 159   MessageLoop::current()->PostTask(from_here, task);
 160 }
 161
 162 // Test fixture.
 163 class MessagePumpGLibTest : public testing::Test {
 164  public:
 165   MessagePumpGLibTest() : loop_(NULL), injector_(NULL) { }
 166
 167   // Overridden from testing::Test:
 168   virtual void SetUp() OVERRIDE {
 169     loop_ = new MessageLoop(MessageLoop::TYPE_UI);
 170     injector_ = new EventInjector();
 171   }
 172   virtual void TearDown() OVERRIDE {
 173     delete injector_;
 174     injector_ = NULL;
 175     delete loop_;
 176     loop_ = NULL;
 177   }
 178
 179   MessageLoop* loop() const { return loop_; }
 180   EventInjector* injector() const { return injector_; }
 181
 182  private:
 183   MessageLoop* loop_;
 184   EventInjector* injector_;
 185   DISALLOW_COPY_AND_ASSIGN(MessagePumpGLibTest);
 186 };
 187
 188 }  // namespace
 189
 190 TEST_F(MessagePumpGLibTest, TestQuit) {
 191   // Checks that Quit works and that the basic infrastructure is working.
 192
 193   // Quit from a task
 194   RunLoop().RunUntilIdle();
 195   EXPECT_EQ(0, injector()->processed_events());
 196
 197   injector()->Reset();
 198   // Quit from an event
 199   injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
 200   loop()->Run();
 201   EXPECT_EQ(1, injector()->processed_events());
 202 }
 203
 204 TEST_F(MessagePumpGLibTest, TestEventTaskInterleave) {
 205   // Checks that tasks posted by events are executed before the next event if
 206   // the posted task queue is empty.
 207   // MessageLoop doesn't make strong guarantees that it is the case, but the
 208   // current implementation ensures it and the tests below rely on it.
 209   // If changes cause this test to fail, it is reasonable to change it, but
 210   // TestWorkWhileWaitingForEvents and TestEventsWhileWaitingForWork have to be
 211   // changed accordingly, otherwise they can become flaky.
 212   injector()->AddEventAsTask(0, base::Bind(&base::DoNothing));
 213   base::Closure check_task =
 214       base::Bind(&ExpectProcessedEvents, base::Unretained(injector()), 2);
 215   base::Closure posted_task =
 216       base::Bind(&PostMessageLoopTask, FROM_HERE, check_task);
 217   injector()->AddEventAsTask(0, posted_task);
 218   injector()->AddEventAsTask(0, base::Bind(&base::DoNothing));
 219   injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
 220   loop()->Run();
 221   EXPECT_EQ(4, injector()->processed_events());
 222
 223   injector()->Reset();
 224   injector()->AddEventAsTask(0, base::Bind(&base::DoNothing));
 225   check_task =
 226       base::Bind(&ExpectProcessedEvents, base::Unretained(injector()), 2);
 227   posted_task = base::Bind(&PostMessageLoopTask, FROM_HERE, check_task);
 228   injector()->AddEventAsTask(0, posted_task);
 229   injector()->AddEventAsTask(10, base::Bind(&base::DoNothing));
 230   injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
 231   loop()->Run();
 232   EXPECT_EQ(4, injector()->processed_events());
 233 }
 234
 235 TEST_F(MessagePumpGLibTest, TestWorkWhileWaitingForEvents) {
 236   int task_count = 0;
 237   // Tests that we process tasks while waiting for new events.
 238   // The event queue is empty at first.
 239   for (int i = 0; i < 10; ++i) {
 240     loop()->PostTask(FROM_HERE, base::Bind(&IncrementInt, &task_count));
 241   }
 242   // After all the previous tasks have executed, enqueue an event that will
 243   // quit.
 244   loop()->PostTask(
 245       FROM_HERE,
 246       base::Bind(&EventInjector::AddEvent, base::Unretained(injector()), 0,
 247                  MessageLoop::QuitWhenIdleClosure()));
 248   loop()->Run();
 249   ASSERT_EQ(10, task_count);
 250   EXPECT_EQ(1, injector()->processed_events());
 251
 252   // Tests that we process delayed tasks while waiting for new events.
 253   injector()->Reset();
 254   task_count = 0;
 255   for (int i = 0; i < 10; ++i) {
 256     loop()->PostDelayedTask(
 257         FROM_HERE,
 258         base::Bind(&IncrementInt, &task_count),
 259         base::TimeDelta::FromMilliseconds(10*i));
 260   }
 261   // After all the previous tasks have executed, enqueue an event that will
 262   // quit.
 263   // This relies on the fact that delayed tasks are executed in delay order.
 264   // That is verified in message_loop_unittest.cc.
 265   loop()->PostDelayedTask(
 266       FROM_HERE,
 267       base::Bind(&EventInjector::AddEvent, base::Unretained(injector()), 10,
 268                  MessageLoop::QuitWhenIdleClosure()),
 269       base::TimeDelta::FromMilliseconds(150));
 270   loop()->Run();
 271   ASSERT_EQ(10, task_count);
 272   EXPECT_EQ(1, injector()->processed_events());
 273 }
 274
 275 TEST_F(MessagePumpGLibTest, TestEventsWhileWaitingForWork) {
 276   // Tests that we process events while waiting for work.
 277   // The event queue is empty at first.
 278   for (int i = 0; i < 10; ++i) {
 279     injector()->AddDummyEvent(0);
 280   }
 281   // After all the events have been processed, post a task that will check that
 282   // the events have been processed (note: the task executes after the event
 283   // that posted it has been handled, so we expect 11 at that point).
 284   base::Closure check_task =
 285       base::Bind(&ExpectProcessedEvents, base::Unretained(injector()), 11);
 286   base::Closure posted_task =
 287       base::Bind(&PostMessageLoopTask, FROM_HERE, check_task);
 288   injector()->AddEventAsTask(10, posted_task);
 289
 290   // And then quit (relies on the condition tested by TestEventTaskInterleave).
 291   injector()->AddEvent(10, MessageLoop::QuitWhenIdleClosure());
 292   loop()->Run();
 293
 294   EXPECT_EQ(12, injector()->processed_events());
 295 }
 296
 297 namespace {
 298
 299 // This class is a helper for the concurrent events / posted tasks test below.
 300 // It will quit the main loop once enough tasks and events have been processed,
 301 // while making sure there is always work to do and events in the queue.
 302 class ConcurrentHelper : public base::RefCounted<ConcurrentHelper>  {
 303  public:
 304   explicit ConcurrentHelper(EventInjector* injector)
 305       : injector_(injector),
 306         event_count_(kStartingEventCount),
 307         task_count_(kStartingTaskCount) {
 308   }
 309
 310   void FromTask() {
 311     if (task_count_ > 0) {
 312       --task_count_;
 313     }
 314     if (task_count_ == 0 && event_count_ == 0) {
 315         MessageLoop::current()->QuitWhenIdle();
 316     } else {
 317       MessageLoop::current()->PostTask(
 318           FROM_HERE, base::Bind(&ConcurrentHelper::FromTask, this));
 319     }
 320   }
 321
 322   void FromEvent() {
 323     if (event_count_ > 0) {
 324       --event_count_;
 325     }
 326     if (task_count_ == 0 && event_count_ == 0) {
 327         MessageLoop::current()->QuitWhenIdle();
 328     } else {
 329       injector_->AddEventAsTask(
 330           0, base::Bind(&ConcurrentHelper::FromEvent, this));
 331     }
 332   }
 333
 334   int event_count() const { return event_count_; }
 335   int task_count() const { return task_count_; }
 336
 337  private:
 338   friend class base::RefCounted<ConcurrentHelper>;
 339
 340   ~ConcurrentHelper() {}
 341
 342   static const int kStartingEventCount = 20;
 343   static const int kStartingTaskCount = 20;
 344
 345   EventInjector* injector_;
 346   int event_count_;
 347   int task_count_;
 348 };
 349
 350 }  // namespace
 351
 352 TEST_F(MessagePumpGLibTest, TestConcurrentEventPostedTask) {
 353   // Tests that posted tasks don't starve events, nor the opposite.
 354   // We use the helper class above. We keep both event and posted task queues
 355   // full, the helper verifies that both tasks and events get processed.
 356   // If that is not the case, either event_count_ or task_count_ will not get
 357   // to 0, and MessageLoop::QuitWhenIdle() will never be called.
 358   scoped_refptr<ConcurrentHelper> helper = new ConcurrentHelper(injector());
 359
 360   // Add 2 events to the queue to make sure it is always full (when we remove
 361   // the event before processing it).
 362   injector()->AddEventAsTask(
 363       0, base::Bind(&ConcurrentHelper::FromEvent, helper.get()));
 364   injector()->AddEventAsTask(
 365       0, base::Bind(&ConcurrentHelper::FromEvent, helper.get()));
 366
 367   // Similarly post 2 tasks.
 368   loop()->PostTask(
 369       FROM_HERE, base::Bind(&ConcurrentHelper::FromTask, helper.get()));
 370   loop()->PostTask(
 371       FROM_HERE, base::Bind(&ConcurrentHelper::FromTask, helper.get()));
 372
 373   loop()->Run();
 374   EXPECT_EQ(0, helper->event_count());
 375   EXPECT_EQ(0, helper->task_count());
 376 }
 377
 378 namespace {
 379
 380 void AddEventsAndDrainGLib(EventInjector* injector) {
 381   // Add a couple of dummy events
 382   injector->AddDummyEvent(0);
 383   injector->AddDummyEvent(0);
 384   // Then add an event that will quit the main loop.
 385   injector->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
 386
 387   // Post a couple of dummy tasks
 388   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&base::DoNothing));
 389   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&base::DoNothing));
 390
 391   // Drain the events
 392   while (g_main_context_pending(NULL)) {
 393     g_main_context_iteration(NULL, FALSE);
 394   }
 395 }
 396
 397 }  // namespace
 398
 399 TEST_F(MessagePumpGLibTest, TestDrainingGLib) {
 400   // Tests that draining events using GLib works.
 401   loop()->PostTask(
 402       FROM_HERE,
 403       base::Bind(&AddEventsAndDrainGLib, base::Unretained(injector())));
 404   loop()->Run();
 405
 406   EXPECT_EQ(3, injector()->processed_events());
 407 }
 408
 409
 410 namespace {
 411
 412 #if defined(TOOLKIT_GTK)
 413 void AddEventsAndDrainGtk(EventInjector* injector) {
 414   // Add a couple of dummy events
 415   injector->AddDummyEvent(0);
 416   injector->AddDummyEvent(0);
 417   // Then add an event that will quit the main loop.
 418   injector->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
 419
 420   // Post a couple of dummy tasks
 421   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&base::DoNothing));
 422   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&base::DoNothing));
 423
 424   // Drain the events
 425   while (gtk_events_pending()) {
 426     gtk_main_iteration();
 427   }
 428 }
 429 #endif
 430
 431 }  // namespace
 432
 433 #if defined(TOOLKIT_GTK)
 434 TEST_F(MessagePumpGLibTest, TestDrainingGtk) {
 435   // Tests that draining events using Gtk works.
 436   loop()->PostTask(
 437       FROM_HERE,
 438       base::Bind(&AddEventsAndDrainGtk, base::Unretained(injector())));
 439   loop()->Run();
 440
 441   EXPECT_EQ(3, injector()->processed_events());
 442 }
 443 #endif
 444
 445 namespace {
 446
 447 // Helper class that lets us run the GLib message loop.
 448 class GLibLoopRunner : public base::RefCounted<GLibLoopRunner> {
 449  public:
 450   GLibLoopRunner() : quit_(false) { }
 451
 452   void RunGLib() {
 453     while (!quit_) {
 454       g_main_context_iteration(NULL, TRUE);
 455     }
 456   }
 457
 458   void RunLoop() {
 459 #if defined(TOOLKIT_GTK)
 460     while (!quit_) {
 461       gtk_main_iteration();
 462     }
 463 #else
 464     while (!quit_) {
 465       g_main_context_iteration(NULL, TRUE);
 466     }
 467 #endif
 468   }
 469
 470   void Quit() {
 471     quit_ = true;
 472   }
 473
 474   void Reset() {
 475     quit_ = false;
 476   }
 477
 478  private:
 479   friend class base::RefCounted<GLibLoopRunner>;
 480
 481   ~GLibLoopRunner() {}
 482
 483   bool quit_;
 484 };
 485
 486 void TestGLibLoopInternal(EventInjector* injector) {
 487   // Allow tasks to be processed from 'native' event loops.
 488   MessageLoop::current()->SetNestableTasksAllowed(true);
 489   scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner();
 490
 491   int task_count = 0;
 492   // Add a couple of dummy events
 493   injector->AddDummyEvent(0);
 494   injector->AddDummyEvent(0);
 495   // Post a couple of dummy tasks
 496   MessageLoop::current()->PostTask(
 497       FROM_HERE, base::Bind(&IncrementInt, &task_count));
 498   MessageLoop::current()->PostTask(
 499       FROM_HERE, base::Bind(&IncrementInt, &task_count));
 500   // Delayed events
 501   injector->AddDummyEvent(10);
 502   injector->AddDummyEvent(10);
 503   // Delayed work
 504   MessageLoop::current()->PostDelayedTask(
 505       FROM_HERE,
 506       base::Bind(&IncrementInt, &task_count),
 507       base::TimeDelta::FromMilliseconds(30));
 508   MessageLoop::current()->PostDelayedTask(
 509       FROM_HERE,
 510       base::Bind(&GLibLoopRunner::Quit, runner.get()),
 511       base::TimeDelta::FromMilliseconds(40));
 512
 513   // Run a nested, straight GLib message loop.
 514   runner->RunGLib();
 515
 516   ASSERT_EQ(3, task_count);
 517   EXPECT_EQ(4, injector->processed_events());
 518   MessageLoop::current()->QuitWhenIdle();
 519 }
 520
 521 void TestGtkLoopInternal(EventInjector* injector) {
 522   // Allow tasks to be processed from 'native' event loops.
 523   MessageLoop::current()->SetNestableTasksAllowed(true);
 524   scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner();
 525
 526   int task_count = 0;
 527   // Add a couple of dummy events
 528   injector->AddDummyEvent(0);
 529   injector->AddDummyEvent(0);
 530   // Post a couple of dummy tasks
 531   MessageLoop::current()->PostTask(
 532       FROM_HERE, base::Bind(&IncrementInt, &task_count));
 533   MessageLoop::current()->PostTask(
 534       FROM_HERE, base::Bind(&IncrementInt, &task_count));
 535   // Delayed events
 536   injector->AddDummyEvent(10);
 537   injector->AddDummyEvent(10);
 538   // Delayed work
 539   MessageLoop::current()->PostDelayedTask(
 540       FROM_HERE,
 541       base::Bind(&IncrementInt, &task_count),
 542       base::TimeDelta::FromMilliseconds(30));
 543   MessageLoop::current()->PostDelayedTask(
 544       FROM_HERE,
 545       base::Bind(&GLibLoopRunner::Quit, runner.get()),
 546       base::TimeDelta::FromMilliseconds(40));
 547
 548   // Run a nested, straight Gtk message loop.
 549   runner->RunLoop();
 550
 551   ASSERT_EQ(3, task_count);
 552   EXPECT_EQ(4, injector->processed_events());
 553   MessageLoop::current()->QuitWhenIdle();
 554 }
 555
 556 }  // namespace
 557
 558 TEST_F(MessagePumpGLibTest, TestGLibLoop) {
 559   // Tests that events and posted tasks are correctly executed if the message
 560   // loop is not run by MessageLoop::Run() but by a straight GLib loop.
 561   // Note that in this case we don't make strong guarantees about niceness
 562   // between events and posted tasks.
 563   loop()->PostTask(
 564       FROM_HERE,
 565       base::Bind(&TestGLibLoopInternal, base::Unretained(injector())));
 566   loop()->Run();
 567 }
 568
 569 TEST_F(MessagePumpGLibTest, TestGtkLoop) {
 570   // Tests that events and posted tasks are correctly executed if the message
 571   // loop is not run by MessageLoop::Run() but by a straight Gtk loop.
 572   // Note that in this case we don't make strong guarantees about niceness
 573   // between events and posted tasks.
 574   loop()->PostTask(
 575       FROM_HERE,
 576       base::Bind(&TestGtkLoopInternal, base::Unretained(injector())));
 577   loop()->Run();
 578 }
 579
 580 }  // namespace base