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 // Returns true if MessagePump::ScheduleWork() must be called one
  90 // time for every task that is added to the MessageLoop incoming queue.
  91 bool AlwaysNotifyPump(MessageLoop::Type type) {
  92 #if defined(OS_ANDROID)
  93   // The Android UI message loop needs to get notified each time a task is added
  94   // to the incoming queue.
  95   return type == MessageLoop::TYPE_UI || type == MessageLoop::TYPE_JAVA;
  96 #else
  97   return false;
  98 #endif
  99 }
 100
 101 #if defined(OS_IOS)
 102 typedef MessagePumpIOSForIO MessagePumpForIO;
 103 #elif defined(OS_NACL)
 104 typedef MessagePumpDefault MessagePumpForIO;
 105 #elif defined(OS_POSIX)
 106 typedef MessagePumpLibevent MessagePumpForIO;
 107 #endif
 108
 109 MessagePumpForIO* ToPumpIO(MessagePump* pump) {
 110   return static_cast<MessagePumpForIO*>(pump);
 111 }
 112
 113 }  // namespace
 114
 115 //------------------------------------------------------------------------------
 116
 117 MessageLoop::TaskObserver::TaskObserver() {
 118 }
 119
 120 MessageLoop::TaskObserver::~TaskObserver() {
 121 }
 122
 123 MessageLoop::DestructionObserver::~DestructionObserver() {
 124 }
 125
 126 //------------------------------------------------------------------------------
 127
 128 MessageLoop::MessageLoop(Type type)
 129     : type_(type),
 130       pending_high_res_tasks_(0),
 131       in_high_res_mode_(false),
 132       nestable_tasks_allowed_(true),
 133 #if defined(OS_WIN)
 134       os_modal_loop_(false),
 135 #endif  // OS_WIN
 136       message_histogram_(NULL),
 137       run_loop_(NULL) {
 138   Init();
 139
 140   pump_ = CreateMessagePumpForType(type).Pass();
 141 }
 142
 143 MessageLoop::MessageLoop(scoped_ptr<MessagePump> pump)
 144     : pump_(pump.Pass()),
 145       type_(TYPE_CUSTOM),
 146       pending_high_res_tasks_(0),
 147       in_high_res_mode_(false),
 148       nestable_tasks_allowed_(true),
 149 #if defined(OS_WIN)
 150       os_modal_loop_(false),
 151 #endif  // OS_WIN
 152       message_histogram_(NULL),
 153       run_loop_(NULL) {
 154   DCHECK(pump_.get());
 155   Init();
 156 }
 157
 158 MessageLoop::~MessageLoop() {
 159   DCHECK_EQ(this, current());
 160
 161   DCHECK(!run_loop_);
 162 #if defined(OS_WIN)
 163   if (in_high_res_mode_)
 164     Time::ActivateHighResolutionTimer(false);
 165 #endif
 166   // Clean up any unprocessed tasks, but take care: deleting a task could
 167   // result in the addition of more tasks (e.g., via DeleteSoon).  We set a
 168   // limit on the number of times we will allow a deleted task to generate more
 169   // tasks.  Normally, we should only pass through this loop once or twice.  If
 170   // we end up hitting the loop limit, then it is probably due to one task that
 171   // is being stubborn.  Inspect the queues to see who is left.
 172   bool did_work;
 173   for (int i = 0; i < 100; ++i) {
 174     DeletePendingTasks();
 175     ReloadWorkQueue();
 176     // If we end up with empty queues, then break out of the loop.
 177     did_work = DeletePendingTasks();
 178     if (!did_work)
 179       break;
 180   }
 181   DCHECK(!did_work);
 182
 183   // Let interested parties have one last shot at accessing this.
 184   FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
 185                     WillDestroyCurrentMessageLoop());
 186
 187   thread_task_runner_handle_.reset();
 188
 189   // Tell the incoming queue that we are dying.
 190   incoming_task_queue_->WillDestroyCurrentMessageLoop();
 191   incoming_task_queue_ = NULL;
 192   message_loop_proxy_ = NULL;
 193
 194   // OK, now make it so that no one can find us.
 195   lazy_tls_ptr.Pointer()->Set(NULL);
 196 }
 197
 198 // static
 199 MessageLoop* MessageLoop::current() {
 200   // TODO(darin): sadly, we cannot enable this yet since people call us even
 201   // when they have no intention of using us.
 202   // DCHECK(loop) << "Ouch, did you forget to initialize me?";
 203   return lazy_tls_ptr.Pointer()->Get();
 204 }
 205
 206 // static
 207 void MessageLoop::EnableHistogrammer(bool enable) {
 208   enable_histogrammer_ = enable;
 209 }
 210
 211 // static
 212 bool MessageLoop::InitMessagePumpForUIFactory(MessagePumpFactory* factory) {
 213   if (message_pump_for_ui_factory_)
 214     return false;
 215
 216   message_pump_for_ui_factory_ = factory;
 217   return true;
 218 }
 219
 220 // static
 221 scoped_ptr<MessagePump> MessageLoop::CreateMessagePumpForType(Type type) {
 222 // TODO(rvargas): Get rid of the OS guards.
 223 #if defined(USE_GLIB) && !defined(OS_NACL)
 224   typedef MessagePumpGlib MessagePumpForUI;
 225 #elif defined(OS_LINUX) && !defined(OS_NACL)
 226   typedef MessagePumpLibevent MessagePumpForUI;
 227 #endif
 228
 229 #if defined(OS_IOS) || defined(OS_MACOSX)
 230 #define MESSAGE_PUMP_UI scoped_ptr<MessagePump>(MessagePumpMac::Create())
 231 #elif defined(OS_NACL)
 232 // Currently NaCl doesn't have a UI MessageLoop.
 233 // TODO(abarth): Figure out if we need this.
 234 #define MESSAGE_PUMP_UI scoped_ptr<MessagePump>()
 235 #else
 236 #define MESSAGE_PUMP_UI scoped_ptr<MessagePump>(new MessagePumpForUI())
 237 #endif
 238
 239 #if defined(OS_MACOSX)
 240   // Use an OS native runloop on Mac to support timer coalescing.
 241   #define MESSAGE_PUMP_DEFAULT \
 242       scoped_ptr<MessagePump>(new MessagePumpCFRunLoop())
 243 #else
 244   #define MESSAGE_PUMP_DEFAULT scoped_ptr<MessagePump>(new MessagePumpDefault())
 245 #endif
 246
 247   if (type == MessageLoop::TYPE_UI) {
 248     if (message_pump_for_ui_factory_)
 249       return message_pump_for_ui_factory_();
 250     return MESSAGE_PUMP_UI;
 251   }
 252   if (type == MessageLoop::TYPE_IO)
 253     return scoped_ptr<MessagePump>(new MessagePumpForIO());
 254
 255 #if defined(OS_ANDROID)
 256   if (type == MessageLoop::TYPE_JAVA)
 257     return scoped_ptr<MessagePump>(new MessagePumpForUI());
 258 #endif
 259
 260   DCHECK_EQ(MessageLoop::TYPE_DEFAULT, type);
 261   return MESSAGE_PUMP_DEFAULT;
 262 }
 263
 264 void MessageLoop::AddDestructionObserver(
 265     DestructionObserver* destruction_observer) {
 266   DCHECK_EQ(this, current());
 267   destruction_observers_.AddObserver(destruction_observer);
 268 }
 269
 270 void MessageLoop::RemoveDestructionObserver(
 271     DestructionObserver* destruction_observer) {
 272   DCHECK_EQ(this, current());
 273   destruction_observers_.RemoveObserver(destruction_observer);
 274 }
 275
 276 void MessageLoop::PostTask(
 277     const tracked_objects::Location& from_here,
 278     const Closure& task) {
 279   DCHECK(!task.is_null()) << from_here.ToString();
 280   incoming_task_queue_->AddToIncomingQueue(from_here, task, TimeDelta(), true);
 281 }
 282
 283 void MessageLoop::PostDelayedTask(
 284     const tracked_objects::Location& from_here,
 285     const Closure& task,
 286     TimeDelta delay) {
 287   DCHECK(!task.is_null()) << from_here.ToString();
 288   incoming_task_queue_->AddToIncomingQueue(from_here, task, delay, true);
 289 }
 290
 291 void MessageLoop::PostNonNestableTask(
 292     const tracked_objects::Location& from_here,
 293     const Closure& task) {
 294   DCHECK(!task.is_null()) << from_here.ToString();
 295   incoming_task_queue_->AddToIncomingQueue(from_here, task, TimeDelta(), false);
 296 }
 297
 298 void MessageLoop::PostNonNestableDelayedTask(
 299     const tracked_objects::Location& from_here,
 300     const Closure& task,
 301     TimeDelta delay) {
 302   DCHECK(!task.is_null()) << from_here.ToString();
 303   incoming_task_queue_->AddToIncomingQueue(from_here, task, delay, false);
 304 }
 305
 306 void MessageLoop::Run() {
 307   RunLoop run_loop;
 308   run_loop.Run();
 309 }
 310
 311 void MessageLoop::RunUntilIdle() {
 312   RunLoop run_loop;
 313   run_loop.RunUntilIdle();
 314 }
 315
 316 void MessageLoop::QuitWhenIdle() {
 317   DCHECK_EQ(this, current());
 318   if (run_loop_) {
 319     run_loop_->quit_when_idle_received_ = true;
 320   } else {
 321     NOTREACHED() << "Must be inside Run to call Quit";
 322   }
 323 }
 324
 325 void MessageLoop::QuitNow() {
 326   DCHECK_EQ(this, current());
 327   if (run_loop_) {
 328     pump_->Quit();
 329   } else {
 330     NOTREACHED() << "Must be inside Run to call Quit";
 331   }
 332 }
 333
 334 bool MessageLoop::IsType(Type type) const {
 335   return type_ == type;
 336 }
 337
 338 static void QuitCurrentWhenIdle() {
 339   MessageLoop::current()->QuitWhenIdle();
 340 }
 341
 342 // static
 343 Closure MessageLoop::QuitWhenIdleClosure() {
 344   return Bind(&QuitCurrentWhenIdle);
 345 }
 346
 347 void MessageLoop::SetNestableTasksAllowed(bool allowed) {
 348   if (allowed) {
 349     // Kick the native pump just in case we enter a OS-driven nested message
 350     // loop.
 351     pump_->ScheduleWork();
 352   }
 353   nestable_tasks_allowed_ = allowed;
 354 }
 355
 356 bool MessageLoop::NestableTasksAllowed() const {
 357   return nestable_tasks_allowed_;
 358 }
 359
 360 bool MessageLoop::IsNested() {
 361   return run_loop_->run_depth_ > 1;
 362 }
 363
 364 void MessageLoop::AddTaskObserver(TaskObserver* task_observer) {
 365   DCHECK_EQ(this, current());
 366   task_observers_.AddObserver(task_observer);
 367 }
 368
 369 void MessageLoop::RemoveTaskObserver(TaskObserver* task_observer) {
 370   DCHECK_EQ(this, current());
 371   task_observers_.RemoveObserver(task_observer);
 372 }
 373
 374 bool MessageLoop::is_running() const {
 375   DCHECK_EQ(this, current());
 376   return run_loop_ != NULL;
 377 }
 378
 379 bool MessageLoop::HasHighResolutionTasks() {
 380   return incoming_task_queue_->HasHighResolutionTasks();
 381 }
 382
 383 bool MessageLoop::IsIdleForTesting() {
 384   // We only check the imcoming queue|, since we don't want to lock the work
 385   // queue.
 386   return incoming_task_queue_->IsIdleForTesting();
 387 }
 388
 389 //------------------------------------------------------------------------------
 390
 391 void MessageLoop::Init() {
 392   DCHECK(!current()) << "should only have one message loop per thread";
 393   lazy_tls_ptr.Pointer()->Set(this);
 394
 395   incoming_task_queue_ = new internal::IncomingTaskQueue(this);
 396   message_loop_proxy_ =
 397       new internal::MessageLoopProxyImpl(incoming_task_queue_);
 398   thread_task_runner_handle_.reset(
 399       new ThreadTaskRunnerHandle(message_loop_proxy_));
 400 }
 401
 402 void MessageLoop::RunHandler() {
 403   DCHECK_EQ(this, current());
 404
 405   StartHistogrammer();
 406
 407 #if defined(OS_WIN)
 408   if (run_loop_->dispatcher_ && type() == TYPE_UI) {
 409     static_cast<MessagePumpForUI*>(pump_.get())->
 410         RunWithDispatcher(this, run_loop_->dispatcher_);
 411     return;
 412   }
 413 #endif
 414
 415   pump_->Run(this);
 416 }
 417
 418 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
 419   if (run_loop_->run_depth_ != 1)
 420     return false;
 421
 422   if (deferred_non_nestable_work_queue_.empty())
 423     return false;
 424
 425   PendingTask pending_task = deferred_non_nestable_work_queue_.front();
 426   deferred_non_nestable_work_queue_.pop();
 427
 428   RunTask(pending_task);
 429   return true;
 430 }
 431
 432 void MessageLoop::RunTask(const PendingTask& pending_task) {
 433   DCHECK(nestable_tasks_allowed_);
 434
 435   if (pending_task.is_high_res) {
 436     pending_high_res_tasks_--;
 437     CHECK(pending_high_res_tasks_ >= 0);
 438   }
 439   // Execute the task and assume the worst: It is probably not reentrant.
 440   nestable_tasks_allowed_ = false;
 441
 442   HistogramEvent(kTaskRunEvent);
 443
 444   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
 445                     WillProcessTask(pending_task));
 446   task_annotator_.RunTask(
 447       "MessageLoop::PostTask", "MessageLoop::RunTask", pending_task);
 448   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
 449                     DidProcessTask(pending_task));
 450
 451   nestable_tasks_allowed_ = true;
 452 }
 453
 454 bool MessageLoop::DeferOrRunPendingTask(const PendingTask& pending_task) {
 455   if (pending_task.nestable || run_loop_->run_depth_ == 1) {
 456     RunTask(pending_task);
 457     // Show that we ran a task (Note: a new one might arrive as a
 458     // consequence!).
 459     return true;
 460   }
 461
 462   // We couldn't run the task now because we're in a nested message loop
 463   // and the task isn't nestable.
 464   deferred_non_nestable_work_queue_.push(pending_task);
 465   return false;
 466 }
 467
 468 void MessageLoop::AddToDelayedWorkQueue(const PendingTask& pending_task) {
 469   // Move to the delayed work queue.
 470   delayed_work_queue_.push(pending_task);
 471 }
 472
 473 bool MessageLoop::DeletePendingTasks() {
 474   bool did_work = !work_queue_.empty();
 475   while (!work_queue_.empty()) {
 476     PendingTask pending_task = work_queue_.front();
 477     work_queue_.pop();
 478     if (!pending_task.delayed_run_time.is_null()) {
 479       // We want to delete delayed tasks in the same order in which they would
 480       // normally be deleted in case of any funny dependencies between delayed
 481       // tasks.
 482       AddToDelayedWorkQueue(pending_task);
 483     }
 484   }
 485   did_work |= !deferred_non_nestable_work_queue_.empty();
 486   while (!deferred_non_nestable_work_queue_.empty()) {
 487     deferred_non_nestable_work_queue_.pop();
 488   }
 489   did_work |= !delayed_work_queue_.empty();
 490
 491   // Historically, we always delete the task regardless of valgrind status. It's
 492   // not completely clear why we want to leak them in the loops above.  This
 493   // code is replicating legacy behavior, and should not be considered
 494   // absolutely "correct" behavior.  See TODO above about deleting all tasks
 495   // when it's safe.
 496   while (!delayed_work_queue_.empty()) {
 497     delayed_work_queue_.pop();
 498   }
 499   return did_work;
 500 }
 501
 502 void MessageLoop::ReloadWorkQueue() {
 503   // We can improve performance of our loading tasks from the incoming queue to
 504   // |*work_queue| by waiting until the last minute (|*work_queue| is empty) to
 505   // load. That reduces the number of locks-per-task significantly when our
 506   // queues get large.
 507   if (work_queue_.empty()) {
 508     pending_high_res_tasks_ +=
 509         incoming_task_queue_->ReloadWorkQueue(&work_queue_);
 510   }
 511 }
 512
 513 void MessageLoop::ScheduleWork(bool was_empty) {
 514   if (was_empty || AlwaysNotifyPump(type_))
 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)
 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)
 718
 719 }  // namespace base