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