base/message_loop/message_loop.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.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/logging.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/message_loop/message_pump_default.h"
  15 #include "base/metrics/histogram.h"
  16 #include "base/metrics/statistics_recorder.h"
  17 #include "base/run_loop.h"
  18 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
  19 #include "base/thread_task_runner_handle.h"
  20 #include "base/threading/thread_local.h"
  21 #include "base/time/time.h"
  22 #include "base/tracked_objects.h"
  23
  24 #if defined(OS_MACOSX)
  25 #include "base/message_loop/message_pump_mac.h"
  26 #endif
  27 #if defined(OS_POSIX) && !defined(OS_IOS)
  28 #include "base/message_loop/message_pump_libevent.h"
  29 #endif
  30 #if defined(OS_ANDROID)
  31 #include "base/message_loop/message_pump_android.h"
  32 #endif
  33 #if defined(USE_GLIB)
  34 #include "base/message_loop/message_pump_glib.h"
  35 #endif
  36
  37 namespace base {
  38
  39 namespace {
  40
  41 // A lazily created thread local storage for quick access to a thread's message
  42 // loop, if one exists.  This should be safe and free of static constructors.
  43 LazyInstance<base::ThreadLocalPointer<MessageLoop> >::Leaky lazy_tls_ptr =
  44     LAZY_INSTANCE_INITIALIZER;
  45
  46 // Logical events for Histogram profiling. Run with -message-loop-histogrammer
  47 // to get an accounting of messages and actions taken on each thread.
  48 const int kTaskRunEvent = 0x1;
  49 #if !defined(OS_NACL)
  50 const int kTimerEvent = 0x2;
  51
  52 // Provide range of message IDs for use in histogramming and debug display.
  53 const int kLeastNonZeroMessageId = 1;
  54 const int kMaxMessageId = 1099;
  55 const int kNumberOfDistinctMessagesDisplayed = 1100;
  56
  57 // Provide a macro that takes an expression (such as a constant, or macro
  58 // constant) and creates a pair to initalize an array of pairs.  In this case,
  59 // our pair consists of the expressions value, and the "stringized" version
  60 // of the expression (i.e., the exrpression put in quotes).  For example, if
  61 // we have:
  62 //    #define FOO 2
  63 //    #define BAR 5
  64 // then the following:
  65 //    VALUE_TO_NUMBER_AND_NAME(FOO + BAR)
  66 // will expand to:
  67 //   {7, "FOO + BAR"}
  68 // We use the resulting array as an argument to our histogram, which reads the
  69 // number as a bucket identifier, and proceeds to use the corresponding name
  70 // in the pair (i.e., the quoted string) when printing out a histogram.
  71 #define VALUE_TO_NUMBER_AND_NAME(name) {name, #name},
  72
  73 const LinearHistogram::DescriptionPair event_descriptions_[] = {
  74   // Provide some pretty print capability in our histogram for our internal
  75   // messages.
  76
  77   // A few events we handle (kindred to messages), and used to profile actions.
  78   VALUE_TO_NUMBER_AND_NAME(kTaskRunEvent)
  79   VALUE_TO_NUMBER_AND_NAME(kTimerEvent)
  80
  81   {-1, NULL}  // The list must be null terminated, per API to histogram.
  82 };
  83 #endif  // !defined(OS_NACL)
  84
  85 bool enable_histogrammer_ = false;
  86
  87 MessageLoop::MessagePumpFactory* message_pump_for_ui_factory_ = NULL;
  88
  89 #if defined(OS_IOS)
  90 typedef MessagePumpIOSForIO MessagePumpForIO;
  91 #elif defined(OS_NACL_SFI)
  92 typedef MessagePumpDefault MessagePumpForIO;
  93 #elif defined(OS_POSIX)
  94 typedef MessagePumpLibevent MessagePumpForIO;
  95 #endif
  96
  97 #if !defined(OS_NACL_SFI)
  98 MessagePumpForIO* ToPumpIO(MessagePump* pump) {
  99   return static_cast<MessagePumpForIO*>(pump);
 100 }
 101 #endif  // !defined(OS_NACL_SFI)
 102
 103 }  // namespace
 104
 105 //------------------------------------------------------------------------------
 106
 107 MessageLoop::TaskObserver::TaskObserver() {
 108 }
 109
 110 MessageLoop::TaskObserver::~TaskObserver() {
 111 }
 112
 113 MessageLoop::DestructionObserver::~DestructionObserver() {
 114 }
 115
 116 //------------------------------------------------------------------------------
 117
 118 MessageLoop::MessageLoop(Type type)
 119     : type_(type),
 120 #if defined(OS_WIN)
 121       pending_high_res_tasks_(0),
 122       in_high_res_mode_(false),
 123 #endif
 124       nestable_tasks_allowed_(true),
 125 #if defined(OS_WIN)
 126       os_modal_loop_(false),
 127 #endif  // OS_WIN
 128       message_histogram_(NULL),
 129       run_loop_(NULL) {
 130   Init();
 131
 132   pump_ = CreateMessagePumpForType(type).Pass();
 133 }
 134
 135 MessageLoop::MessageLoop(scoped_ptr<MessagePump> pump)
 136     : pump_(pump.Pass()),
 137       type_(TYPE_CUSTOM),
 138 #if defined(OS_WIN)
 139       pending_high_res_tasks_(0),
 140       in_high_res_mode_(false),
 141 #endif
 142       nestable_tasks_allowed_(true),
 143 #if defined(OS_WIN)
 144       os_modal_loop_(false),
 145 #endif  // OS_WIN
 146       message_histogram_(NULL),
 147       run_loop_(NULL) {
 148   DCHECK(pump_.get());
 149   Init();
 150 }
 151
 152 MessageLoop::~MessageLoop() {
 153   DCHECK_EQ(this, current());
 154
 155   DCHECK(!run_loop_);
 156 #if defined(OS_WIN)
 157   if (in_high_res_mode_)
 158     Time::ActivateHighResolutionTimer(false);
 159 #endif
 160   // Clean up any unprocessed tasks, but take care: deleting a task could
 161   // result in the addition of more tasks (e.g., via DeleteSoon).  We set a
 162   // limit on the number of times we will allow a deleted task to generate more
 163   // tasks.  Normally, we should only pass through this loop once or twice.  If
 164   // we end up hitting the loop limit, then it is probably due to one task that
 165   // is being stubborn.  Inspect the queues to see who is left.
 166   bool did_work;
 167   for (int i = 0; i < 100; ++i) {
 168     DeletePendingTasks();
 169     ReloadWorkQueue();
 170     // If we end up with empty queues, then break out of the loop.
 171     did_work = DeletePendingTasks();
 172     if (!did_work)
 173       break;
 174   }
 175   DCHECK(!did_work);
 176
 177   // Let interested parties have one last shot at accessing this.
 178   FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
 179                     WillDestroyCurrentMessageLoop());
 180
 181   thread_task_runner_handle_.reset();
 182
 183   // Tell the incoming queue that we are dying.
 184   incoming_task_queue_->WillDestroyCurrentMessageLoop();
 185   incoming_task_queue_ = NULL;
 186   message_loop_proxy_ = NULL;
 187
 188   // OK, now make it so that no one can find us.
 189   lazy_tls_ptr.Pointer()->Set(NULL);
 190 }
 191
 192 // static
 193 MessageLoop* MessageLoop::current() {
 194   // TODO(darin): sadly, we cannot enable this yet since people call us even
 195   // when they have no intention of using us.
 196   // DCHECK(loop) << "Ouch, did you forget to initialize me?";
 197   return lazy_tls_ptr.Pointer()->Get();
 198 }
 199
 200 // static
 201 void MessageLoop::EnableHistogrammer(bool enable) {
 202   enable_histogrammer_ = enable;
 203 }
 204
 205 // static
 206 bool MessageLoop::InitMessagePumpForUIFactory(MessagePumpFactory* factory) {
 207   if (message_pump_for_ui_factory_)
 208     return false;
 209
 210   message_pump_for_ui_factory_ = factory;
 211   return true;
 212 }
 213
 214 // static
 215 scoped_ptr<MessagePump> MessageLoop::CreateMessagePumpForType(Type type) {
 216 // TODO(rvargas): Get rid of the OS guards.
 217 #if defined(USE_GLIB) && !defined(OS_NACL)
 218   typedef MessagePumpGlib MessagePumpForUI;
 219 #elif defined(OS_LINUX) && !defined(OS_NACL)
 220   typedef MessagePumpLibevent MessagePumpForUI;
 221 #endif
 222
 223 #if defined(OS_IOS) || defined(OS_MACOSX)
 224 #define MESSAGE_PUMP_UI scoped_ptr<MessagePump>(MessagePumpMac::Create())
 225 #elif defined(OS_NACL)
 226 // Currently NaCl doesn't have a UI MessageLoop.
 227 // TODO(abarth): Figure out if we need this.
 228 #define MESSAGE_PUMP_UI scoped_ptr<MessagePump>()
 229 #else
 230 #define MESSAGE_PUMP_UI scoped_ptr<MessagePump>(new MessagePumpForUI())
 231 #endif
 232
 233 #if defined(OS_MACOSX)
 234   // Use an OS native runloop on Mac to support timer coalescing.
 235   #define MESSAGE_PUMP_DEFAULT \
 236       scoped_ptr<MessagePump>(new MessagePumpCFRunLoop())
 237 #else
 238   #define MESSAGE_PUMP_DEFAULT scoped_ptr<MessagePump>(new MessagePumpDefault())
 239 #endif
 240
 241   if (type == MessageLoop::TYPE_UI) {
 242     if (message_pump_for_ui_factory_)
 243       return message_pump_for_ui_factory_();
 244     return MESSAGE_PUMP_UI;
 245   }
 246   if (type == MessageLoop::TYPE_IO)
 247     return scoped_ptr<MessagePump>(new MessagePumpForIO());
 248
 249 #if defined(OS_ANDROID)
 250   if (type == MessageLoop::TYPE_JAVA)
 251     return scoped_ptr<MessagePump>(new MessagePumpForUI());
 252 #endif
 253
 254   DCHECK_EQ(MessageLoop::TYPE_DEFAULT, type);
 255   return MESSAGE_PUMP_DEFAULT;
 256 }
 257
 258 void MessageLoop::AddDestructionObserver(
 259     DestructionObserver* destruction_observer) {
 260   DCHECK_EQ(this, current());
 261   destruction_observers_.AddObserver(destruction_observer);
 262 }
 263
 264 void MessageLoop::RemoveDestructionObserver(
 265     DestructionObserver* destruction_observer) {
 266   DCHECK_EQ(this, current());
 267   destruction_observers_.RemoveObserver(destruction_observer);
 268 }
 269
 270 void MessageLoop::PostTask(
 271     const tracked_objects::Location& from_here,
 272     const Closure& task) {
 273   DCHECK(!task.is_null()) << from_here.ToString();
 274   incoming_task_queue_->AddToIncomingQueue(from_here, task, TimeDelta(), true);
 275 }
 276
 277 void MessageLoop::PostDelayedTask(
 278     const tracked_objects::Location& from_here,
 279     const Closure& task,
 280     TimeDelta delay) {
 281   DCHECK(!task.is_null()) << from_here.ToString();
 282   incoming_task_queue_->AddToIncomingQueue(from_here, task, delay, true);
 283 }
 284
 285 void MessageLoop::PostNonNestableTask(
 286     const tracked_objects::Location& from_here,
 287     const Closure& task) {
 288   DCHECK(!task.is_null()) << from_here.ToString();
 289   incoming_task_queue_->AddToIncomingQueue(from_here, task, TimeDelta(), false);
 290 }
 291
 292 void MessageLoop::PostNonNestableDelayedTask(
 293     const tracked_objects::Location& from_here,
 294     const Closure& task,
 295     TimeDelta delay) {
 296   DCHECK(!task.is_null()) << from_here.ToString();
 297   incoming_task_queue_->AddToIncomingQueue(from_here, task, delay, false);
 298 }
 299
 300 void MessageLoop::Run() {
 301   RunLoop run_loop;
 302   run_loop.Run();
 303 }
 304
 305 void MessageLoop::RunUntilIdle() {
 306   RunLoop run_loop;
 307   run_loop.RunUntilIdle();
 308 }
 309
 310 void MessageLoop::QuitWhenIdle() {
 311   DCHECK_EQ(this, current());
 312   if (run_loop_) {
 313     run_loop_->quit_when_idle_received_ = true;
 314   } else {
 315     NOTREACHED() << "Must be inside Run to call Quit";
 316   }
 317 }
 318
 319 void MessageLoop::QuitNow() {
 320   DCHECK_EQ(this, current());
 321   if (run_loop_) {
 322     pump_->Quit();
 323   } else {
 324     NOTREACHED() << "Must be inside Run to call Quit";
 325   }
 326 }
 327
 328 bool MessageLoop::IsType(Type type) const {
 329   return type_ == type;
 330 }
 331
 332 static void QuitCurrentWhenIdle() {
 333   MessageLoop::current()->QuitWhenIdle();
 334 }
 335
 336 // static
 337 Closure MessageLoop::QuitWhenIdleClosure() {
 338   return Bind(&QuitCurrentWhenIdle);
 339 }
 340
 341 void MessageLoop::SetNestableTasksAllowed(bool allowed) {
 342   if (allowed) {
 343     // Kick the native pump just in case we enter a OS-driven nested message
 344     // loop.
 345     pump_->ScheduleWork();
 346   }
 347   nestable_tasks_allowed_ = allowed;
 348 }
 349
 350 bool MessageLoop::NestableTasksAllowed() const {
 351   return nestable_tasks_allowed_;
 352 }
 353
 354 bool MessageLoop::IsNested() {
 355   return run_loop_->run_depth_ > 1;
 356 }
 357
 358 void MessageLoop::AddTaskObserver(TaskObserver* task_observer) {
 359   DCHECK_EQ(this, current());
 360   task_observers_.AddObserver(task_observer);
 361 }
 362
 363 void MessageLoop::RemoveTaskObserver(TaskObserver* task_observer) {
 364   DCHECK_EQ(this, current());
 365   task_observers_.RemoveObserver(task_observer);
 366 }
 367
 368 bool MessageLoop::is_running() const {
 369   DCHECK_EQ(this, current());
 370   return run_loop_ != NULL;
 371 }
 372
 373 bool MessageLoop::HasHighResolutionTasks() {
 374   return incoming_task_queue_->HasHighResolutionTasks();
 375 }
 376
 377 bool MessageLoop::IsIdleForTesting() {
 378   // We only check the imcoming queue|, since we don't want to lock the work
 379   // queue.
 380   return incoming_task_queue_->IsIdleForTesting();
 381 }
 382
 383 //------------------------------------------------------------------------------
 384
 385 void MessageLoop::Init() {
 386   DCHECK(!current()) << "should only have one message loop per thread";
 387   lazy_tls_ptr.Pointer()->Set(this);
 388
 389   incoming_task_queue_ = new internal::IncomingTaskQueue(this);
 390   message_loop_proxy_ =
 391       new internal::MessageLoopProxyImpl(incoming_task_queue_);
 392   thread_task_runner_handle_.reset(
 393       new ThreadTaskRunnerHandle(message_loop_proxy_));
 394 }
 395
 396 void MessageLoop::RunHandler() {
 397   DCHECK_EQ(this, current());
 398
 399   StartHistogrammer();
 400
 401 #if defined(OS_WIN)
 402   if (run_loop_->dispatcher_ && type() == TYPE_UI) {
 403     static_cast<MessagePumpForUI*>(pump_.get())->
 404         RunWithDispatcher(this, run_loop_->dispatcher_);
 405     return;
 406   }
 407 #endif
 408
 409   pump_->Run(this);
 410 }
 411
 412 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
 413   if (run_loop_->run_depth_ != 1)
 414     return false;
 415
 416   if (deferred_non_nestable_work_queue_.empty())
 417     return false;
 418
 419   PendingTask pending_task = deferred_non_nestable_work_queue_.front();
 420   deferred_non_nestable_work_queue_.pop();
 421
 422   RunTask(pending_task);
 423   return true;
 424 }
 425
 426 void MessageLoop::RunTask(const PendingTask& pending_task) {
 427   DCHECK(nestable_tasks_allowed_);
 428
 429 #if defined(OS_WIN)
 430   if (pending_task.is_high_res) {
 431     pending_high_res_tasks_--;
 432     CHECK_GE(pending_high_res_tasks_, 0);
 433   }
 434 #endif
 435
 436   // Execute the task and assume the worst: It is probably not reentrant.
 437   nestable_tasks_allowed_ = false;
 438
 439   HistogramEvent(kTaskRunEvent);
 440
 441   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
 442                     WillProcessTask(pending_task));
 443   task_annotator_.RunTask(
 444       "MessageLoop::PostTask", "MessageLoop::RunTask", pending_task);
 445   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
 446                     DidProcessTask(pending_task));
 447
 448   nestable_tasks_allowed_ = true;
 449 }
 450
 451 bool MessageLoop::DeferOrRunPendingTask(const PendingTask& pending_task) {
 452   if (pending_task.nestable || run_loop_->run_depth_ == 1) {
 453     RunTask(pending_task);
 454     // Show that we ran a task (Note: a new one might arrive as a
 455     // consequence!).
 456     return true;
 457   }
 458
 459   // We couldn't run the task now because we're in a nested message loop
 460   // and the task isn't nestable.
 461   deferred_non_nestable_work_queue_.push(pending_task);
 462   return false;
 463 }
 464
 465 void MessageLoop::AddToDelayedWorkQueue(const PendingTask& pending_task) {
 466   // Move to the delayed work queue.
 467   delayed_work_queue_.push(pending_task);
 468 }
 469
 470 bool MessageLoop::DeletePendingTasks() {
 471   bool did_work = !work_queue_.empty();
 472   while (!work_queue_.empty()) {
 473     PendingTask pending_task = work_queue_.front();
 474     work_queue_.pop();
 475     if (!pending_task.delayed_run_time.is_null()) {
 476       // We want to delete delayed tasks in the same order in which they would
 477       // normally be deleted in case of any funny dependencies between delayed
 478       // tasks.
 479       AddToDelayedWorkQueue(pending_task);
 480     }
 481   }
 482   did_work |= !deferred_non_nestable_work_queue_.empty();
 483   while (!deferred_non_nestable_work_queue_.empty()) {
 484     deferred_non_nestable_work_queue_.pop();
 485   }
 486   did_work |= !delayed_work_queue_.empty();
 487
 488   // Historically, we always delete the task regardless of valgrind status. It's
 489   // not completely clear why we want to leak them in the loops above.  This
 490   // code is replicating legacy behavior, and should not be considered
 491   // absolutely "correct" behavior.  See TODO above about deleting all tasks
 492   // when it's safe.
 493   while (!delayed_work_queue_.empty()) {
 494     delayed_work_queue_.pop();
 495   }
 496   return did_work;
 497 }
 498
 499 void MessageLoop::ReloadWorkQueue() {
 500   // We can improve performance of our loading tasks from the incoming queue to
 501   // |*work_queue| by waiting until the last minute (|*work_queue| is empty) to
 502   // load. That reduces the number of locks-per-task significantly when our
 503   // queues get large.
 504   if (work_queue_.empty()) {
 505 #if defined(OS_WIN)
 506     pending_high_res_tasks_ +=
 507         incoming_task_queue_->ReloadWorkQueue(&work_queue_);
 508 #else
 509     incoming_task_queue_->ReloadWorkQueue(&work_queue_);
 510 #endif
 511   }
 512 }
 513
 514 void MessageLoop::ScheduleWork() {
 515   pump_->ScheduleWork();
 516 }
 517
 518 //------------------------------------------------------------------------------
 519 // Method and data for histogramming events and actions taken by each instance
 520 // on each thread.
 521
 522 void MessageLoop::StartHistogrammer() {
 523 #if !defined(OS_NACL)  // NaCl build has no metrics code.
 524   if (enable_histogrammer_ && !message_histogram_
 525       && StatisticsRecorder::IsActive()) {
 526     DCHECK(!thread_name_.empty());
 527     message_histogram_ = LinearHistogram::FactoryGetWithRangeDescription(
 528         "MsgLoop:" + thread_name_,
 529         kLeastNonZeroMessageId, kMaxMessageId,
 530         kNumberOfDistinctMessagesDisplayed,
 531         message_histogram_->kHexRangePrintingFlag,
 532         event_descriptions_);
 533   }
 534 #endif
 535 }
 536
 537 void MessageLoop::HistogramEvent(int event) {
 538 #if !defined(OS_NACL)
 539   if (message_histogram_)
 540     message_histogram_->Add(event);
 541 #endif
 542 }
 543
 544 bool MessageLoop::DoWork() {
 545   if (!nestable_tasks_allowed_) {
 546     // Task can't be executed right now.
 547     return false;
 548   }
 549
 550   for (;;) {
 551     ReloadWorkQueue();
 552     if (work_queue_.empty())
 553       break;
 554
 555     // Execute oldest task.
 556     do {
 557       PendingTask pending_task = work_queue_.front();
 558       work_queue_.pop();
 559       if (!pending_task.delayed_run_time.is_null()) {
 560         AddToDelayedWorkQueue(pending_task);
 561         // If we changed the topmost task, then it is time to reschedule.
 562         if (delayed_work_queue_.top().task.Equals(pending_task.task))
 563           pump_->ScheduleDelayedWork(pending_task.delayed_run_time);
 564       } else {
 565         if (DeferOrRunPendingTask(pending_task))
 566           return true;
 567       }
 568     } while (!work_queue_.empty());
 569   }
 570
 571   // Nothing happened.
 572   return false;
 573 }
 574
 575 bool MessageLoop::DoDelayedWork(TimeTicks* next_delayed_work_time) {
 576   if (!nestable_tasks_allowed_ || delayed_work_queue_.empty()) {
 577     recent_time_ = *next_delayed_work_time = TimeTicks();
 578     return false;
 579   }
 580
 581   // When we "fall behind," there will be a lot of tasks in the delayed work
 582   // queue that are ready to run.  To increase efficiency when we fall behind,
 583   // we will only call Time::Now() intermittently, and then process all tasks
 584   // that are ready to run before calling it again.  As a result, the more we
 585   // fall behind (and have a lot of ready-to-run delayed tasks), the more
 586   // efficient we'll be at handling the tasks.
 587
 588   TimeTicks next_run_time = delayed_work_queue_.top().delayed_run_time;
 589   if (next_run_time > recent_time_) {
 590     recent_time_ = TimeTicks::Now();  // Get a better view of Now();
 591     if (next_run_time > recent_time_) {
 592       *next_delayed_work_time = next_run_time;
 593       return false;
 594     }
 595   }
 596
 597   PendingTask pending_task = delayed_work_queue_.top();
 598   delayed_work_queue_.pop();
 599
 600   if (!delayed_work_queue_.empty())
 601     *next_delayed_work_time = delayed_work_queue_.top().delayed_run_time;
 602
 603   return DeferOrRunPendingTask(pending_task);
 604 }
 605
 606 bool MessageLoop::DoIdleWork() {
 607   if (ProcessNextDelayedNonNestableTask())
 608     return true;
 609
 610   if (run_loop_->quit_when_idle_received_)
 611     pump_->Quit();
 612
 613   // When we return we will do a kernel wait for more tasks.
 614 #if defined(OS_WIN)
 615   // On Windows we activate the high resolution timer so that the wait
 616   // _if_ triggered by the timer happens with good resolution. If we don't
 617   // do this the default resolution is 15ms which might not be acceptable
 618   // for some tasks.
 619   bool high_res = pending_high_res_tasks_ > 0;
 620   if (high_res != in_high_res_mode_) {
 621     in_high_res_mode_ = high_res;
 622     Time::ActivateHighResolutionTimer(in_high_res_mode_);
 623   }
 624 #endif
 625   return false;
 626 }
 627
 628 void MessageLoop::DeleteSoonInternal(const tracked_objects::Location& from_here,
 629                                      void(*deleter)(const void*),
 630                                      const void* object) {
 631   PostNonNestableTask(from_here, Bind(deleter, object));
 632 }
 633
 634 void MessageLoop::ReleaseSoonInternal(
 635     const tracked_objects::Location& from_here,
 636     void(*releaser)(const void*),
 637     const void* object) {
 638   PostNonNestableTask(from_here, Bind(releaser, object));
 639 }
 640
 641 #if !defined(OS_NACL)
 642 //------------------------------------------------------------------------------
 643 // MessageLoopForUI
 644
 645 #if defined(OS_ANDROID)
 646 void MessageLoopForUI::Start() {
 647   // No Histogram support for UI message loop as it is managed by Java side
 648   static_cast<MessagePumpForUI*>(pump_.get())->Start(this);
 649 }
 650 #endif
 651
 652 #if defined(OS_IOS)
 653 void MessageLoopForUI::Attach() {
 654   static_cast<MessagePumpUIApplication*>(pump_.get())->Attach(this);
 655 }
 656 #endif
 657
 658 #if defined(USE_OZONE) || (defined(USE_X11) && !defined(USE_GLIB))
 659 bool MessageLoopForUI::WatchFileDescriptor(
 660     int fd,
 661     bool persistent,
 662     MessagePumpLibevent::Mode mode,
 663     MessagePumpLibevent::FileDescriptorWatcher *controller,
 664     MessagePumpLibevent::Watcher *delegate) {
 665   return static_cast<MessagePumpLibevent*>(pump_.get())->WatchFileDescriptor(
 666       fd,
 667       persistent,
 668       mode,
 669       controller,
 670       delegate);
 671 }
 672 #endif
 673
 674 #endif  // !defined(OS_NACL)
 675
 676 //------------------------------------------------------------------------------
 677 // MessageLoopForIO
 678
 679 #if !defined(OS_NACL_SFI)
 680 void MessageLoopForIO::AddIOObserver(
 681     MessageLoopForIO::IOObserver* io_observer) {
 682   ToPumpIO(pump_.get())->AddIOObserver(io_observer);
 683 }
 684
 685 void MessageLoopForIO::RemoveIOObserver(
 686     MessageLoopForIO::IOObserver* io_observer) {
 687   ToPumpIO(pump_.get())->RemoveIOObserver(io_observer);
 688 }
 689
 690 #if defined(OS_WIN)
 691 void MessageLoopForIO::RegisterIOHandler(HANDLE file, IOHandler* handler) {
 692   ToPumpIO(pump_.get())->RegisterIOHandler(file, handler);
 693 }
 694
 695 bool MessageLoopForIO::RegisterJobObject(HANDLE job, IOHandler* handler) {
 696   return ToPumpIO(pump_.get())->RegisterJobObject(job, handler);
 697 }
 698
 699 bool MessageLoopForIO::WaitForIOCompletion(DWORD timeout, IOHandler* filter) {
 700   return ToPumpIO(pump_.get())->WaitForIOCompletion(timeout, filter);
 701 }
 702 #elif defined(OS_POSIX)
 703 bool MessageLoopForIO::WatchFileDescriptor(int fd,
 704                                            bool persistent,
 705                                            Mode mode,
 706                                            FileDescriptorWatcher* controller,
 707                                            Watcher* delegate) {
 708   return ToPumpIO(pump_.get())->WatchFileDescriptor(
 709       fd,
 710       persistent,
 711       mode,
 712       controller,
 713       delegate);
 714 }
 715 #endif
 716
 717 #endif  // !defined(OS_NACL_SFI)
 718
 719 }  // namespace base