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