base/message_loop.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/message_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_proxy_impl.h"
  17 #include "base/message_pump_default.h"
  18 #include "base/metrics/histogram.h"
  19 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
  20 #include "base/threading/thread_local.h"
  21 #include "base/time.h"
  22 #include "base/tracked_objects.h"
  23
  24 #if defined(OS_MACOSX)
  25 #include "base/message_pump_mac.h"
  26 #endif
  27 #if defined(OS_POSIX)
  28 #include "base/message_pump_libevent.h"
  29 #endif
  30 #if defined(OS_ANDROID)
  31 #include "base/message_pump_android.h"
  32 #endif
  33 #if defined(TOOLKIT_USES_GTK)
  34 #include <gdk/gdk.h>
  35 #include <gdk/gdkx.h>
  36 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
  37
  38 using base::PendingTask;
  39 using base::TimeDelta;
  40 using base::TimeTicks;
  41
  42 namespace {
  43
  44 // A lazily created thread local storage for quick access to a thread's message
  45 // loop, if one exists.  This should be safe and free of static constructors.
  46 base::LazyInstance<base::ThreadLocalPointer<MessageLoop> > lazy_tls_ptr =
  47     LAZY_INSTANCE_INITIALIZER;
  48
  49 // Logical events for Histogram profiling. Run with -message-loop-histogrammer
  50 // to get an accounting of messages and actions taken on each thread.
  51 const int kTaskRunEvent = 0x1;
  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 base::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
  86 bool enable_histogrammer_ = false;
  87
  88 MessageLoop::MessagePumpFactory* message_pump_for_ui_factory_ = NULL;
  89
  90 }  // namespace
  91
  92 //------------------------------------------------------------------------------
  93
  94 #if defined(OS_WIN)
  95
  96 // Upon a SEH exception in this thread, it restores the original unhandled
  97 // exception filter.
  98 static int SEHFilter(LPTOP_LEVEL_EXCEPTION_FILTER old_filter) {
  99   ::SetUnhandledExceptionFilter(old_filter);
 100   return EXCEPTION_CONTINUE_SEARCH;
 101 }
 102
 103 // Retrieves a pointer to the current unhandled exception filter. There
 104 // is no standalone getter method.
 105 static LPTOP_LEVEL_EXCEPTION_FILTER GetTopSEHFilter() {
 106   LPTOP_LEVEL_EXCEPTION_FILTER top_filter = NULL;
 107   top_filter = ::SetUnhandledExceptionFilter(0);
 108   ::SetUnhandledExceptionFilter(top_filter);
 109   return top_filter;
 110 }
 111
 112 #endif  // defined(OS_WIN)
 113
 114 //------------------------------------------------------------------------------
 115
 116 MessageLoop::TaskObserver::TaskObserver() {
 117 }
 118
 119 MessageLoop::TaskObserver::~TaskObserver() {
 120 }
 121
 122 MessageLoop::DestructionObserver::~DestructionObserver() {
 123 }
 124
 125 //------------------------------------------------------------------------------
 126
 127 MessageLoop::MessageLoop(Type type)
 128     : type_(type),
 129       nestable_tasks_allowed_(true),
 130       exception_restoration_(false),
 131       message_histogram_(NULL),
 132       state_(NULL),
 133       should_leak_tasks_(true),
 134 #ifdef OS_WIN
 135       os_modal_loop_(false),
 136 #endif  // OS_WIN
 137       next_sequence_num_(0) {
 138   DCHECK(!current()) << "should only have one message loop per thread";
 139   lazy_tls_ptr.Pointer()->Set(this);
 140
 141   message_loop_proxy_ = new base::MessageLoopProxyImpl();
 142
 143 // TODO(rvargas): Get rid of the OS guards.
 144 #if defined(OS_WIN)
 145 #define MESSAGE_PUMP_UI new base::MessagePumpForUI()
 146 #define MESSAGE_PUMP_IO new base::MessagePumpForIO()
 147 #elif defined(OS_MACOSX)
 148 #define MESSAGE_PUMP_UI base::MessagePumpMac::Create()
 149 #define MESSAGE_PUMP_IO new base::MessagePumpLibevent()
 150 #elif defined(OS_NACL)
 151 // Currently NaCl doesn't have a UI or an IO MessageLoop.
 152 // TODO(abarth): Figure out if we need these.
 153 #define MESSAGE_PUMP_UI NULL
 154 #define MESSAGE_PUMP_IO NULL
 155 #elif defined(OS_POSIX)  // POSIX but not MACOSX.
 156 #define MESSAGE_PUMP_UI new base::MessagePumpForUI()
 157 #define MESSAGE_PUMP_IO new base::MessagePumpLibevent()
 158 #else
 159 #error Not implemented
 160 #endif
 161
 162   if (type_ == TYPE_UI) {
 163     if (message_pump_for_ui_factory_)
 164       pump_ = message_pump_for_ui_factory_();
 165     else
 166       pump_ = MESSAGE_PUMP_UI;
 167   } else if (type_ == TYPE_IO) {
 168     pump_ = MESSAGE_PUMP_IO;
 169   } else {
 170     DCHECK_EQ(TYPE_DEFAULT, type_);
 171     pump_ = new base::MessagePumpDefault();
 172   }
 173 }
 174
 175 MessageLoop::~MessageLoop() {
 176   DCHECK_EQ(this, current());
 177
 178   DCHECK(!state_);
 179
 180   // Clean up any unprocessed tasks, but take care: deleting a task could
 181   // result in the addition of more tasks (e.g., via DeleteSoon).  We set a
 182   // limit on the number of times we will allow a deleted task to generate more
 183   // tasks.  Normally, we should only pass through this loop once or twice.  If
 184   // we end up hitting the loop limit, then it is probably due to one task that
 185   // is being stubborn.  Inspect the queues to see who is left.
 186   bool did_work;
 187   for (int i = 0; i < 100; ++i) {
 188     DeletePendingTasks();
 189     ReloadWorkQueue();
 190     // If we end up with empty queues, then break out of the loop.
 191     did_work = DeletePendingTasks();
 192     if (!did_work)
 193       break;
 194   }
 195   DCHECK(!did_work);
 196
 197   // Let interested parties have one last shot at accessing this.
 198   FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
 199                     WillDestroyCurrentMessageLoop());
 200
 201   // Tell the message_loop_proxy that we are dying.
 202   static_cast<base::MessageLoopProxyImpl*>(message_loop_proxy_.get())->
 203       WillDestroyCurrentMessageLoop();
 204   message_loop_proxy_ = NULL;
 205
 206   // OK, now make it so that no one can find us.
 207   lazy_tls_ptr.Pointer()->Set(NULL);
 208
 209 #if defined(OS_WIN)
 210   // If we left the high-resolution timer activated, deactivate it now.
 211   // Doing this is not-critical, it is mainly to make sure we track
 212   // the high resolution timer activations properly in our unit tests.
 213   if (!high_resolution_timer_expiration_.is_null()) {
 214     base::Time::ActivateHighResolutionTimer(false);
 215     high_resolution_timer_expiration_ = base::TimeTicks();
 216   }
 217 #endif
 218 }
 219
 220 // static
 221 MessageLoop* MessageLoop::current() {
 222   // TODO(darin): sadly, we cannot enable this yet since people call us even
 223   // when they have no intention of using us.
 224   // DCHECK(loop) << "Ouch, did you forget to initialize me?";
 225   return lazy_tls_ptr.Pointer()->Get();
 226 }
 227
 228 // static
 229 void MessageLoop::EnableHistogrammer(bool enable) {
 230   enable_histogrammer_ = enable;
 231 }
 232
 233 // static
 234 void MessageLoop::InitMessagePumpForUIFactory(MessagePumpFactory* factory) {
 235   DCHECK(!message_pump_for_ui_factory_);
 236   message_pump_for_ui_factory_ = factory;
 237 }
 238
 239 void MessageLoop::AddDestructionObserver(
 240     DestructionObserver* destruction_observer) {
 241   DCHECK_EQ(this, current());
 242   destruction_observers_.AddObserver(destruction_observer);
 243 }
 244
 245 void MessageLoop::RemoveDestructionObserver(
 246     DestructionObserver* destruction_observer) {
 247   DCHECK_EQ(this, current());
 248   destruction_observers_.RemoveObserver(destruction_observer);
 249 }
 250
 251 void MessageLoop::PostTask(
 252     const tracked_objects::Location& from_here, const base::Closure& task) {
 253   DCHECK(!task.is_null()) << from_here.ToString();
 254   PendingTask pending_task(from_here, task, CalculateDelayedRuntime(0), true);
 255   AddToIncomingQueue(&pending_task);
 256 }
 257
 258 void MessageLoop::PostDelayedTask(
 259     const tracked_objects::Location& from_here,
 260     const base::Closure& task,
 261     int64 delay_ms) {
 262   DCHECK(!task.is_null()) << from_here.ToString();
 263   PendingTask pending_task(from_here, task,
 264                            CalculateDelayedRuntime(delay_ms), true);
 265   AddToIncomingQueue(&pending_task);
 266 }
 267
 268 void MessageLoop::PostDelayedTask(
 269     const tracked_objects::Location& from_here,
 270     const base::Closure& task,
 271     base::TimeDelta delay) {
 272   PostDelayedTask(from_here, task, delay.InMillisecondsRoundedUp());
 273 }
 274
 275 void MessageLoop::PostNonNestableTask(
 276     const tracked_objects::Location& from_here, const base::Closure& task) {
 277   DCHECK(!task.is_null()) << from_here.ToString();
 278   PendingTask pending_task(from_here, task, CalculateDelayedRuntime(0), false);
 279   AddToIncomingQueue(&pending_task);
 280 }
 281
 282 void MessageLoop::PostNonNestableDelayedTask(
 283     const tracked_objects::Location& from_here, const base::Closure& task,
 284     int64 delay_ms) {
 285   DCHECK(!task.is_null()) << from_here.ToString();
 286   PendingTask pending_task(from_here, task,
 287                            CalculateDelayedRuntime(delay_ms), false);
 288   AddToIncomingQueue(&pending_task);
 289 }
 290
 291 void MessageLoop::PostNonNestableDelayedTask(
 292     const tracked_objects::Location& from_here,
 293     const base::Closure& task,
 294     base::TimeDelta delay) {
 295   PostNonNestableDelayedTask(from_here, task, delay.InMillisecondsRoundedUp());
 296 }
 297
 298 void MessageLoop::Run() {
 299   AutoRunState save_state(this);
 300   RunHandler();
 301 }
 302
 303 void MessageLoop::RunAllPending() {
 304   AutoRunState save_state(this);
 305   state_->quit_received = true;  // Means run until we would otherwise block.
 306   RunHandler();
 307 }
 308
 309 void MessageLoop::Quit() {
 310   DCHECK_EQ(this, current());
 311   if (state_) {
 312     state_->quit_received = true;
 313   } else {
 314     NOTREACHED() << "Must be inside Run to call Quit";
 315   }
 316 }
 317
 318 void MessageLoop::QuitNow() {
 319   DCHECK_EQ(this, current());
 320   if (state_) {
 321     pump_->Quit();
 322   } else {
 323     NOTREACHED() << "Must be inside Run to call Quit";
 324   }
 325 }
 326
 327 static void QuitCurrent() {
 328   MessageLoop::current()->Quit();
 329 }
 330
 331 // static
 332 base::Closure MessageLoop::QuitClosure() {
 333   return base::Bind(&QuitCurrent);
 334 }
 335
 336 void MessageLoop::SetNestableTasksAllowed(bool allowed) {
 337   if (nestable_tasks_allowed_ != allowed) {
 338     nestable_tasks_allowed_ = allowed;
 339     if (!nestable_tasks_allowed_)
 340       return;
 341     // Start the native pump if we are not already pumping.
 342     pump_->ScheduleWork();
 343   }
 344 }
 345
 346 bool MessageLoop::NestableTasksAllowed() const {
 347   return nestable_tasks_allowed_;
 348 }
 349
 350 bool MessageLoop::IsNested() {
 351   return state_->run_depth > 1;
 352 }
 353
 354 void MessageLoop::AddTaskObserver(TaskObserver* task_observer) {
 355   DCHECK_EQ(this, current());
 356   task_observers_.AddObserver(task_observer);
 357 }
 358
 359 void MessageLoop::RemoveTaskObserver(TaskObserver* task_observer) {
 360   DCHECK_EQ(this, current());
 361   task_observers_.RemoveObserver(task_observer);
 362 }
 363
 364 void MessageLoop::AssertIdle() const {
 365   // We only check |incoming_queue_|, since we don't want to lock |work_queue_|.
 366   base::AutoLock lock(incoming_queue_lock_);
 367   DCHECK(incoming_queue_.empty());
 368 }
 369
 370 bool MessageLoop::is_running() const {
 371   DCHECK_EQ(this, current());
 372   return state_ != NULL;
 373 }
 374
 375 //------------------------------------------------------------------------------
 376
 377 // Runs the loop in two different SEH modes:
 378 // enable_SEH_restoration_ = false : any unhandled exception goes to the last
 379 // one that calls SetUnhandledExceptionFilter().
 380 // enable_SEH_restoration_ = true : any unhandled exception goes to the filter
 381 // that was existed before the loop was run.
 382 void MessageLoop::RunHandler() {
 383 #if defined(OS_WIN)
 384   if (exception_restoration_) {
 385     RunInternalInSEHFrame();
 386     return;
 387   }
 388 #endif
 389
 390   RunInternal();
 391 }
 392
 393 #if defined(OS_WIN)
 394 __declspec(noinline) void MessageLoop::RunInternalInSEHFrame() {
 395   LPTOP_LEVEL_EXCEPTION_FILTER current_filter = GetTopSEHFilter();
 396   __try {
 397     RunInternal();
 398   } __except(SEHFilter(current_filter)) {
 399   }
 400   return;
 401 }
 402 #endif
 403
 404 void MessageLoop::RunInternal() {
 405   DCHECK_EQ(this, current());
 406
 407   StartHistogrammer();
 408
 409 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
 410   if (state_->dispatcher && type() == TYPE_UI) {
 411     static_cast<base::MessagePumpForUI*>(pump_.get())->
 412         RunWithDispatcher(this, state_->dispatcher);
 413     return;
 414   }
 415 #endif
 416
 417   pump_->Run(this);
 418 }
 419
 420 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
 421   if (state_->run_depth != 1)
 422     return false;
 423
 424   if (deferred_non_nestable_work_queue_.empty())
 425     return false;
 426
 427   PendingTask pending_task = deferred_non_nestable_work_queue_.front();
 428   deferred_non_nestable_work_queue_.pop();
 429
 430   RunTask(pending_task);
 431   return true;
 432 }
 433
 434 void MessageLoop::RunTask(const PendingTask& pending_task) {
 435   TRACE_EVENT2("task", "MessageLoop::RunTask",
 436                "src_file", pending_task.posted_from.file_name(),
 437                "src_func", pending_task.posted_from.function_name());
 438   DCHECK(nestable_tasks_allowed_);
 439   // Execute the task and assume the worst: It is probably not reentrant.
 440   nestable_tasks_allowed_ = false;
 441
 442   // Before running the task, store the program counter where it was posted
 443   // and deliberately alias it to ensure it is on the stack if the task
 444   // crashes. Be careful not to assume that the variable itself will have the
 445   // expected value when displayed by the optimizer in an optimized build.
 446   // Look at a memory dump of the stack.
 447   const void* program_counter =
 448       pending_task.posted_from.program_counter();
 449   base::debug::Alias(&program_counter);
 450
 451   HistogramEvent(kTaskRunEvent);
 452
 453   tracked_objects::TrackedTime start_time =
 454       tracked_objects::ThreadData::NowForStartOfRun(pending_task.birth_tally);
 455
 456   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
 457                     WillProcessTask(pending_task.time_posted));
 458   pending_task.task.Run();
 459   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
 460                     DidProcessTask(pending_task.time_posted));
 461
 462   tracked_objects::ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
 463       start_time, tracked_objects::ThreadData::NowForEndOfRun());
 464
 465   nestable_tasks_allowed_ = true;
 466 }
 467
 468 bool MessageLoop::DeferOrRunPendingTask(const PendingTask& pending_task) {
 469   if (pending_task.nestable || state_->run_depth == 1) {
 470     RunTask(pending_task);
 471     // Show that we ran a task (Note: a new one might arrive as a
 472     // consequence!).
 473     return true;
 474   }
 475
 476   // We couldn't run the task now because we're in a nested message loop
 477   // and the task isn't nestable.
 478   deferred_non_nestable_work_queue_.push(pending_task);
 479   return false;
 480 }
 481
 482 void MessageLoop::AddToDelayedWorkQueue(const PendingTask& pending_task) {
 483   // Move to the delayed work queue.  Initialize the sequence number
 484   // before inserting into the delayed_work_queue_.  The sequence number
 485   // is used to faciliate FIFO sorting when two tasks have the same
 486   // delayed_run_time value.
 487   PendingTask new_pending_task(pending_task);
 488   new_pending_task.sequence_num = next_sequence_num_++;
 489   delayed_work_queue_.push(new_pending_task);
 490 }
 491
 492 void MessageLoop::ReloadWorkQueue() {
 493   // We can improve performance of our loading tasks from incoming_queue_ to
 494   // work_queue_ by waiting until the last minute (work_queue_ is empty) to
 495   // load.  That reduces the number of locks-per-task significantly when our
 496   // queues get large.
 497   if (!work_queue_.empty())
 498     return;  // Wait till we *really* need to lock and load.
 499
 500   // Acquire all we can from the inter-thread queue with one lock acquisition.
 501   {
 502     base::AutoLock lock(incoming_queue_lock_);
 503     if (incoming_queue_.empty())
 504       return;
 505     incoming_queue_.Swap(&work_queue_);  // Constant time
 506     DCHECK(incoming_queue_.empty());
 507   }
 508 }
 509
 510 bool MessageLoop::DeletePendingTasks() {
 511   bool did_work = !work_queue_.empty();
 512   // TODO(darin): Delete all tasks once it is safe to do so.
 513   // Until it is totally safe, just do it when running Valgrind.
 514   //
 515   // See http://crbug.com/61131
 516   //
 517 #if defined(USE_HEAPCHECKER)
 518   should_leak_tasks_ = false;
 519 #else
 520       if (RunningOnValgrind())
 521         should_leak_tasks_ = false;
 522 #endif  // defined(OS_POSIX)
 523   while (!work_queue_.empty()) {
 524     PendingTask pending_task = work_queue_.front();
 525     work_queue_.pop();
 526     if (!pending_task.delayed_run_time.is_null()) {
 527       // We want to delete delayed tasks in the same order in which they would
 528       // normally be deleted in case of any funny dependencies between delayed
 529       // tasks.
 530       AddToDelayedWorkQueue(pending_task);
 531     }
 532   }
 533   did_work |= !deferred_non_nestable_work_queue_.empty();
 534   while (!deferred_non_nestable_work_queue_.empty()) {
 535     deferred_non_nestable_work_queue_.pop();
 536   }
 537   did_work |= !delayed_work_queue_.empty();
 538
 539   // Historically, we always delete the task regardless of valgrind status. It's
 540   // not completely clear why we want to leak them in the loops above.  This
 541   // code is replicating legacy behavior, and should not be considered
 542   // absolutely "correct" behavior.  See TODO above about deleting all tasks
 543   // when it's safe.
 544   should_leak_tasks_ = false;
 545   while (!delayed_work_queue_.empty()) {
 546     delayed_work_queue_.pop();
 547   }
 548   should_leak_tasks_ = true;
 549   return did_work;
 550 }
 551
 552 TimeTicks MessageLoop::CalculateDelayedRuntime(int64 delay_ms) {
 553   TimeTicks delayed_run_time;
 554   if (delay_ms > 0) {
 555     delayed_run_time =
 556         TimeTicks::Now() + TimeDelta::FromMilliseconds(delay_ms);
 557
 558 #if defined(OS_WIN)
 559     if (high_resolution_timer_expiration_.is_null()) {
 560       // Windows timers are granular to 15.6ms.  If we only set high-res
 561       // timers for those under 15.6ms, then a 18ms timer ticks at ~32ms,
 562       // which as a percentage is pretty inaccurate.  So enable high
 563       // res timers for any timer which is within 2x of the granularity.
 564       // This is a tradeoff between accuracy and power management.
 565       bool needs_high_res_timers =
 566           delay_ms < (2 * base::Time::kMinLowResolutionThresholdMs);
 567       if (needs_high_res_timers) {
 568         if (base::Time::ActivateHighResolutionTimer(true)) {
 569           high_resolution_timer_expiration_ = TimeTicks::Now() +
 570               TimeDelta::FromMilliseconds(kHighResolutionTimerModeLeaseTimeMs);
 571         }
 572       }
 573     }
 574 #endif
 575   } else {
 576     DCHECK_EQ(delay_ms, 0) << "delay should not be negative";
 577   }
 578
 579 #if defined(OS_WIN)
 580   if (!high_resolution_timer_expiration_.is_null()) {
 581     if (TimeTicks::Now() > high_resolution_timer_expiration_) {
 582       base::Time::ActivateHighResolutionTimer(false);
 583       high_resolution_timer_expiration_ = TimeTicks();
 584     }
 585   }
 586 #endif
 587
 588   return delayed_run_time;
 589 }
 590
 591 // Possibly called on a background thread!
 592 void MessageLoop::AddToIncomingQueue(PendingTask* pending_task) {
 593   // Warning: Don't try to short-circuit, and handle this thread's tasks more
 594   // directly, as it could starve handling of foreign threads.  Put every task
 595   // into this queue.
 596
 597   scoped_refptr<base::MessagePump> pump;
 598   {
 599     base::AutoLock locked(incoming_queue_lock_);
 600
 601     bool was_empty = incoming_queue_.empty();
 602     incoming_queue_.push(*pending_task);
 603     pending_task->task.Reset();
 604     if (!was_empty)
 605       return;  // Someone else should have started the sub-pump.
 606
 607     pump = pump_;
 608   }
 609   // Since the incoming_queue_ may contain a task that destroys this message
 610   // loop, we cannot exit incoming_queue_lock_ until we are done with |this|.
 611   // We use a stack-based reference to the message pump so that we can call
 612   // ScheduleWork outside of incoming_queue_lock_.
 613
 614   pump->ScheduleWork();
 615 }
 616
 617 //------------------------------------------------------------------------------
 618 // Method and data for histogramming events and actions taken by each instance
 619 // on each thread.
 620
 621 void MessageLoop::StartHistogrammer() {
 622   if (enable_histogrammer_ && !message_histogram_
 623       && base::StatisticsRecorder::IsActive()) {
 624     DCHECK(!thread_name_.empty());
 625     message_histogram_ = base::LinearHistogram::FactoryGet(
 626         "MsgLoop:" + thread_name_,
 627         kLeastNonZeroMessageId, kMaxMessageId,
 628         kNumberOfDistinctMessagesDisplayed,
 629         message_histogram_->kHexRangePrintingFlag);
 630     message_histogram_->SetRangeDescriptions(event_descriptions_);
 631   }
 632 }
 633
 634 void MessageLoop::HistogramEvent(int event) {
 635   if (message_histogram_)
 636     message_histogram_->Add(event);
 637 }
 638
 639 bool MessageLoop::DoWork() {
 640   if (!nestable_tasks_allowed_) {
 641     // Task can't be executed right now.
 642     return false;
 643   }
 644
 645   for (;;) {
 646     ReloadWorkQueue();
 647     if (work_queue_.empty())
 648       break;
 649
 650     // Execute oldest task.
 651     do {
 652       PendingTask pending_task = work_queue_.front();
 653       work_queue_.pop();
 654       if (!pending_task.delayed_run_time.is_null()) {
 655         AddToDelayedWorkQueue(pending_task);
 656         // If we changed the topmost task, then it is time to reschedule.
 657         if (delayed_work_queue_.top().task.Equals(pending_task.task))
 658           pump_->ScheduleDelayedWork(pending_task.delayed_run_time);
 659       } else {
 660         if (DeferOrRunPendingTask(pending_task))
 661           return true;
 662       }
 663     } while (!work_queue_.empty());
 664   }
 665
 666   // Nothing happened.
 667   return false;
 668 }
 669
 670 bool MessageLoop::DoDelayedWork(TimeTicks* next_delayed_work_time) {
 671   if (!nestable_tasks_allowed_ || delayed_work_queue_.empty()) {
 672     recent_time_ = *next_delayed_work_time = TimeTicks();
 673     return false;
 674   }
 675
 676   // When we "fall behind," there will be a lot of tasks in the delayed work
 677   // queue that are ready to run.  To increase efficiency when we fall behind,
 678   // we will only call Time::Now() intermittently, and then process all tasks
 679   // that are ready to run before calling it again.  As a result, the more we
 680   // fall behind (and have a lot of ready-to-run delayed tasks), the more
 681   // efficient we'll be at handling the tasks.
 682
 683   TimeTicks next_run_time = delayed_work_queue_.top().delayed_run_time;
 684   if (next_run_time > recent_time_) {
 685     recent_time_ = TimeTicks::Now();  // Get a better view of Now();
 686     if (next_run_time > recent_time_) {
 687       *next_delayed_work_time = next_run_time;
 688       return false;
 689     }
 690   }
 691
 692   PendingTask pending_task = delayed_work_queue_.top();
 693   delayed_work_queue_.pop();
 694
 695   if (!delayed_work_queue_.empty())
 696     *next_delayed_work_time = delayed_work_queue_.top().delayed_run_time;
 697
 698   return DeferOrRunPendingTask(pending_task);
 699 }
 700
 701 bool MessageLoop::DoIdleWork() {
 702   if (ProcessNextDelayedNonNestableTask())
 703     return true;
 704
 705   if (state_->quit_received)
 706     pump_->Quit();
 707
 708   return false;
 709 }
 710
 711 void MessageLoop::DeleteSoonInternal(const tracked_objects::Location& from_here,
 712                                      void(*deleter)(const void*),
 713                                      const void* object) {
 714   PostNonNestableTask(from_here, base::Bind(deleter, object));
 715 }
 716
 717 void MessageLoop::ReleaseSoonInternal(
 718     const tracked_objects::Location& from_here,
 719     void(*releaser)(const void*),
 720     const void* object) {
 721   PostNonNestableTask(from_here, base::Bind(releaser, object));
 722 }
 723
 724 //------------------------------------------------------------------------------
 725 // MessageLoop::AutoRunState
 726
 727 MessageLoop::AutoRunState::AutoRunState(MessageLoop* loop) : loop_(loop) {
 728   // Make the loop reference us.
 729   previous_state_ = loop_->state_;
 730   if (previous_state_) {
 731     run_depth = previous_state_->run_depth + 1;
 732   } else {
 733     run_depth = 1;
 734   }
 735   loop_->state_ = this;
 736
 737   // Initialize the other fields:
 738   quit_received = false;
 739 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
 740   dispatcher = NULL;
 741 #endif
 742 }
 743
 744 MessageLoop::AutoRunState::~AutoRunState() {
 745   loop_->state_ = previous_state_;
 746 }
 747
 748 //------------------------------------------------------------------------------
 749 // MessageLoopForUI
 750
 751 #if defined(OS_WIN)
 752 void MessageLoopForUI::DidProcessMessage(const MSG& message) {
 753   pump_win()->DidProcessMessage(message);
 754 }
 755 #endif  // defined(OS_WIN)
 756
 757 #if defined(OS_ANDROID)
 758 void MessageLoopForUI::Start() {
 759   // No Histogram support for UI message loop as it is managed by Java side
 760   static_cast<base::MessagePumpForUI*>(pump_.get())->Start(this);
 761 }
 762 #endif
 763
 764 #if !defined(OS_MACOSX) && !defined(OS_NACL) && !defined(OS_ANDROID)
 765 void MessageLoopForUI::AddObserver(Observer* observer) {
 766   pump_ui()->AddObserver(observer);
 767 }
 768
 769 void MessageLoopForUI::RemoveObserver(Observer* observer) {
 770   pump_ui()->RemoveObserver(observer);
 771 }
 772
 773 void MessageLoopForUI::RunWithDispatcher(Dispatcher* dispatcher) {
 774   AutoRunState save_state(this);
 775   state_->dispatcher = dispatcher;
 776   RunHandler();
 777 }
 778
 779 void MessageLoopForUI::RunAllPendingWithDispatcher(Dispatcher* dispatcher) {
 780   AutoRunState save_state(this);
 781   state_->dispatcher = dispatcher;
 782   state_->quit_received = true;  // Means run until we would otherwise block.
 783   RunHandler();
 784 }
 785
 786 #endif  //  !defined(OS_MACOSX) && !defined(OS_NACL) && !defined(OS_ANDROID)
 787
 788 //------------------------------------------------------------------------------
 789 // MessageLoopForIO
 790
 791 #if defined(OS_WIN)
 792
 793 void MessageLoopForIO::RegisterIOHandler(HANDLE file, IOHandler* handler) {
 794   pump_io()->RegisterIOHandler(file, handler);
 795 }
 796
 797 bool MessageLoopForIO::WaitForIOCompletion(DWORD timeout, IOHandler* filter) {
 798   return pump_io()->WaitForIOCompletion(timeout, filter);
 799 }
 800
 801 #elif defined(OS_POSIX) && !defined(OS_NACL)
 802
 803 bool MessageLoopForIO::WatchFileDescriptor(int fd,
 804                                            bool persistent,
 805                                            Mode mode,
 806                                            FileDescriptorWatcher *controller,
 807                                            Watcher *delegate) {
 808   return pump_libevent()->WatchFileDescriptor(
 809       fd,
 810       persistent,
 811       static_cast<base::MessagePumpLibevent::Mode>(mode),
 812       controller,
 813       delegate);
 814 }
 815
 816 #endif