1 // Copyright (c) 2010 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.
5 #include "base/message_loop.h"
9 #include "base/compiler_specific.h"
10 #include "base/lazy_instance.h"
11 #include "base/logging.h"
12 #include "base/message_pump_default.h"
13 #include "base/metrics/histogram.h"
14 #include "base/thread_local.h"
16 #if defined(OS_MACOSX)
17 #include "base/message_pump_mac.h"
20 #include "base/message_pump_libevent.h"
21 #include "base/third_party/valgrind/valgrind.h"
23 #if defined(OS_POSIX) && !defined(OS_MACOSX)
24 #include "base/message_pump_glib.h"
28 using base::TimeDelta
;
32 // A lazily created thread local storage for quick access to a thread's message
33 // loop, if one exists. This should be safe and free of static constructors.
34 base::LazyInstance
<base::ThreadLocalPointer
<MessageLoop
> > lazy_tls_ptr(
35 base::LINKER_INITIALIZED
);
37 // Logical events for Histogram profiling. Run with -message-loop-histogrammer
38 // to get an accounting of messages and actions taken on each thread.
39 const int kTaskRunEvent
= 0x1;
40 const int kTimerEvent
= 0x2;
42 // Provide range of message IDs for use in histogramming and debug display.
43 const int kLeastNonZeroMessageId
= 1;
44 const int kMaxMessageId
= 1099;
45 const int kNumberOfDistinctMessagesDisplayed
= 1100;
47 // Provide a macro that takes an expression (such as a constant, or macro
48 // constant) and creates a pair to initalize an array of pairs. In this case,
49 // our pair consists of the expressions value, and the "stringized" version
50 // of the expression (i.e., the exrpression put in quotes). For example, if
54 // then the following:
55 // VALUE_TO_NUMBER_AND_NAME(FOO + BAR)
58 // We use the resulting array as an argument to our histogram, which reads the
59 // number as a bucket identifier, and proceeds to use the corresponding name
60 // in the pair (i.e., the quoted string) when printing out a histogram.
61 #define VALUE_TO_NUMBER_AND_NAME(name) {name, #name},
63 const base::LinearHistogram::DescriptionPair event_descriptions_
[] = {
64 // Provide some pretty print capability in our histogram for our internal
67 // A few events we handle (kindred to messages), and used to profile actions.
68 VALUE_TO_NUMBER_AND_NAME(kTaskRunEvent
)
69 VALUE_TO_NUMBER_AND_NAME(kTimerEvent
)
71 {-1, NULL
} // The list must be null terminated, per API to histogram.
74 bool enable_histogrammer_
= false;
78 //------------------------------------------------------------------------------
82 // Upon a SEH exception in this thread, it restores the original unhandled
84 static int SEHFilter(LPTOP_LEVEL_EXCEPTION_FILTER old_filter
) {
85 ::SetUnhandledExceptionFilter(old_filter
);
86 return EXCEPTION_CONTINUE_SEARCH
;
89 // Retrieves a pointer to the current unhandled exception filter. There
90 // is no standalone getter method.
91 static LPTOP_LEVEL_EXCEPTION_FILTER
GetTopSEHFilter() {
92 LPTOP_LEVEL_EXCEPTION_FILTER top_filter
= NULL
;
93 top_filter
= ::SetUnhandledExceptionFilter(0);
94 ::SetUnhandledExceptionFilter(top_filter
);
98 #endif // defined(OS_WIN)
100 //------------------------------------------------------------------------------
102 MessageLoop::TaskObserver::TaskObserver() {
105 MessageLoop::TaskObserver::~TaskObserver() {
108 MessageLoop::DestructionObserver::~DestructionObserver() {
111 //------------------------------------------------------------------------------
114 MessageLoop
* MessageLoop::current() {
115 // TODO(darin): sadly, we cannot enable this yet since people call us even
116 // when they have no intention of using us.
117 // DCHECK(loop) << "Ouch, did you forget to initialize me?";
118 return lazy_tls_ptr
.Pointer()->Get();
121 MessageLoop::MessageLoop(Type type
)
123 nestable_tasks_allowed_(true),
124 exception_restoration_(false),
126 next_sequence_num_(0) {
127 DCHECK(!current()) << "should only have one message loop per thread";
128 lazy_tls_ptr
.Pointer()->Set(this);
130 // TODO(rvargas): Get rid of the OS guards.
132 #define MESSAGE_PUMP_UI new base::MessagePumpForUI()
133 #define MESSAGE_PUMP_IO new base::MessagePumpForIO()
134 #elif defined(OS_MACOSX)
135 #define MESSAGE_PUMP_UI base::MessagePumpMac::Create()
136 #define MESSAGE_PUMP_IO new base::MessagePumpLibevent()
137 #elif defined(OS_POSIX) // POSIX but not MACOSX.
138 #define MESSAGE_PUMP_UI new base::MessagePumpForUI()
139 #define MESSAGE_PUMP_IO new base::MessagePumpLibevent()
141 #error Not implemented
144 if (type_
== TYPE_UI
) {
145 pump_
= MESSAGE_PUMP_UI
;
146 } else if (type_
== TYPE_IO
) {
147 pump_
= MESSAGE_PUMP_IO
;
149 DCHECK_EQ(TYPE_DEFAULT
, type_
);
150 pump_
= new base::MessagePumpDefault();
154 MessageLoop::~MessageLoop() {
155 DCHECK(this == current());
157 // Let interested parties have one last shot at accessing this.
158 FOR_EACH_OBSERVER(DestructionObserver
, destruction_observers_
,
159 WillDestroyCurrentMessageLoop());
163 // Clean up any unprocessed tasks, but take care: deleting a task could
164 // result in the addition of more tasks (e.g., via DeleteSoon). We set a
165 // limit on the number of times we will allow a deleted task to generate more
166 // tasks. Normally, we should only pass through this loop once or twice. If
167 // we end up hitting the loop limit, then it is probably due to one task that
168 // is being stubborn. Inspect the queues to see who is left.
170 for (int i
= 0; i
< 100; ++i
) {
171 DeletePendingTasks();
173 // If we end up with empty queues, then break out of the loop.
174 did_work
= DeletePendingTasks();
180 // OK, now make it so that no one can find us.
181 lazy_tls_ptr
.Pointer()->Set(NULL
);
184 void MessageLoop::AddDestructionObserver(
185 DestructionObserver
* destruction_observer
) {
186 DCHECK(this == current());
187 destruction_observers_
.AddObserver(destruction_observer
);
190 void MessageLoop::RemoveDestructionObserver(
191 DestructionObserver
* destruction_observer
) {
192 DCHECK(this == current());
193 destruction_observers_
.RemoveObserver(destruction_observer
);
196 void MessageLoop::AddTaskObserver(TaskObserver
* task_observer
) {
197 DCHECK_EQ(this, current());
198 task_observers_
.AddObserver(task_observer
);
201 void MessageLoop::RemoveTaskObserver(TaskObserver
* task_observer
) {
202 DCHECK_EQ(this, current());
203 task_observers_
.RemoveObserver(task_observer
);
206 void MessageLoop::Run() {
207 AutoRunState
save_state(this);
211 void MessageLoop::RunAllPending() {
212 AutoRunState
save_state(this);
213 state_
->quit_received
= true; // Means run until we would otherwise block.
217 // Runs the loop in two different SEH modes:
218 // enable_SEH_restoration_ = false : any unhandled exception goes to the last
219 // one that calls SetUnhandledExceptionFilter().
220 // enable_SEH_restoration_ = true : any unhandled exception goes to the filter
221 // that was existed before the loop was run.
222 void MessageLoop::RunHandler() {
224 if (exception_restoration_
) {
225 RunInternalInSEHFrame();
232 //------------------------------------------------------------------------------
234 __declspec(noinline
) void MessageLoop::RunInternalInSEHFrame() {
235 LPTOP_LEVEL_EXCEPTION_FILTER current_filter
= GetTopSEHFilter();
238 } __except(SEHFilter(current_filter
)) {
243 //------------------------------------------------------------------------------
245 void MessageLoop::RunInternal() {
246 DCHECK(this == current());
250 #if !defined(OS_MACOSX)
251 if (state_
->dispatcher
&& type() == TYPE_UI
) {
252 static_cast<base::MessagePumpForUI
*>(pump_
.get())->
253 RunWithDispatcher(this, state_
->dispatcher
);
261 //------------------------------------------------------------------------------
262 // Wrapper functions for use in above message loop framework.
264 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
265 if (state_
->run_depth
!= 1)
268 if (deferred_non_nestable_work_queue_
.empty())
271 Task
* task
= deferred_non_nestable_work_queue_
.front().task
;
272 deferred_non_nestable_work_queue_
.pop();
278 //------------------------------------------------------------------------------
280 void MessageLoop::Quit() {
281 DCHECK(current() == this);
283 state_
->quit_received
= true;
285 NOTREACHED() << "Must be inside Run to call Quit";
289 void MessageLoop::QuitNow() {
290 DCHECK(current() == this);
294 NOTREACHED() << "Must be inside Run to call Quit";
298 void MessageLoop::PostTask(
299 const tracked_objects::Location
& from_here
, Task
* task
) {
300 PostTask_Helper(from_here
, task
, 0, true);
303 void MessageLoop::PostDelayedTask(
304 const tracked_objects::Location
& from_here
, Task
* task
, int64 delay_ms
) {
305 PostTask_Helper(from_here
, task
, delay_ms
, true);
308 void MessageLoop::PostNonNestableTask(
309 const tracked_objects::Location
& from_here
, Task
* task
) {
310 PostTask_Helper(from_here
, task
, 0, false);
313 void MessageLoop::PostNonNestableDelayedTask(
314 const tracked_objects::Location
& from_here
, Task
* task
, int64 delay_ms
) {
315 PostTask_Helper(from_here
, task
, delay_ms
, false);
318 // Possibly called on a background thread!
319 void MessageLoop::PostTask_Helper(
320 const tracked_objects::Location
& from_here
, Task
* task
, int64 delay_ms
,
322 task
->SetBirthPlace(from_here
);
324 PendingTask
pending_task(task
, nestable
);
327 pending_task
.delayed_run_time
=
328 Time::Now() + TimeDelta::FromMilliseconds(delay_ms
);
331 if (high_resolution_timer_expiration_
.is_null()) {
332 // Windows timers are granular to 15.6ms. If we only set high-res
333 // timers for those under 15.6ms, then a 18ms timer ticks at ~32ms,
334 // which as a percentage is pretty inaccurate. So enable high
335 // res timers for any timer which is within 2x of the granularity.
336 // This is a tradeoff between accuracy and power management.
337 bool needs_high_res_timers
=
338 delay_ms
< (2 * Time::kMinLowResolutionThresholdMs
);
339 if (needs_high_res_timers
) {
340 Time::ActivateHighResolutionTimer(true);
341 high_resolution_timer_expiration_
= base::TimeTicks::Now() +
342 TimeDelta::FromMilliseconds(kHighResolutionTimerModeLeaseTimeMs
);
347 DCHECK_EQ(delay_ms
, 0) << "delay should not be negative";
351 if (!high_resolution_timer_expiration_
.is_null()) {
352 if (base::TimeTicks::Now() > high_resolution_timer_expiration_
) {
353 Time::ActivateHighResolutionTimer(false);
354 high_resolution_timer_expiration_
= base::TimeTicks();
359 // Warning: Don't try to short-circuit, and handle this thread's tasks more
360 // directly, as it could starve handling of foreign threads. Put every task
363 scoped_refptr
<base::MessagePump
> pump
;
365 AutoLock
locked(incoming_queue_lock_
);
367 bool was_empty
= incoming_queue_
.empty();
368 incoming_queue_
.push(pending_task
);
370 return; // Someone else should have started the sub-pump.
374 // Since the incoming_queue_ may contain a task that destroys this message
375 // loop, we cannot exit incoming_queue_lock_ until we are done with |this|.
376 // We use a stack-based reference to the message pump so that we can call
377 // ScheduleWork outside of incoming_queue_lock_.
379 pump
->ScheduleWork();
382 void MessageLoop::SetNestableTasksAllowed(bool allowed
) {
383 if (nestable_tasks_allowed_
!= allowed
) {
384 nestable_tasks_allowed_
= allowed
;
385 if (!nestable_tasks_allowed_
)
387 // Start the native pump if we are not already pumping.
388 pump_
->ScheduleWork();
392 bool MessageLoop::NestableTasksAllowed() const {
393 return nestable_tasks_allowed_
;
396 bool MessageLoop::IsNested() {
397 return state_
->run_depth
> 1;
400 //------------------------------------------------------------------------------
402 void MessageLoop::RunTask(Task
* task
) {
403 DCHECK(nestable_tasks_allowed_
);
404 // Execute the task and assume the worst: It is probably not reentrant.
405 nestable_tasks_allowed_
= false;
407 HistogramEvent(kTaskRunEvent
);
408 FOR_EACH_OBSERVER(TaskObserver
, task_observers_
,
409 WillProcessTask(task
->tracked_birth_time()));
411 FOR_EACH_OBSERVER(TaskObserver
, task_observers_
, DidProcessTask());
414 nestable_tasks_allowed_
= true;
417 bool MessageLoop::DeferOrRunPendingTask(const PendingTask
& pending_task
) {
418 if (pending_task
.nestable
|| state_
->run_depth
== 1) {
419 RunTask(pending_task
.task
);
420 // Show that we ran a task (Note: a new one might arrive as a
425 // We couldn't run the task now because we're in a nested message loop
426 // and the task isn't nestable.
427 deferred_non_nestable_work_queue_
.push(pending_task
);
431 void MessageLoop::AddToDelayedWorkQueue(const PendingTask
& pending_task
) {
432 // Move to the delayed work queue. Initialize the sequence number
433 // before inserting into the delayed_work_queue_. The sequence number
434 // is used to faciliate FIFO sorting when two tasks have the same
435 // delayed_run_time value.
436 PendingTask
new_pending_task(pending_task
);
437 new_pending_task
.sequence_num
= next_sequence_num_
++;
438 delayed_work_queue_
.push(new_pending_task
);
441 void MessageLoop::ReloadWorkQueue() {
442 // We can improve performance of our loading tasks from incoming_queue_ to
443 // work_queue_ by waiting until the last minute (work_queue_ is empty) to
444 // load. That reduces the number of locks-per-task significantly when our
446 if (!work_queue_
.empty())
447 return; // Wait till we *really* need to lock and load.
449 // Acquire all we can from the inter-thread queue with one lock acquisition.
451 AutoLock
lock(incoming_queue_lock_
);
452 if (incoming_queue_
.empty())
454 incoming_queue_
.Swap(&work_queue_
); // Constant time
455 DCHECK(incoming_queue_
.empty());
459 bool MessageLoop::DeletePendingTasks() {
460 bool did_work
= !work_queue_
.empty();
461 while (!work_queue_
.empty()) {
462 PendingTask pending_task
= work_queue_
.front();
464 if (!pending_task
.delayed_run_time
.is_null()) {
465 // We want to delete delayed tasks in the same order in which they would
466 // normally be deleted in case of any funny dependencies between delayed
468 AddToDelayedWorkQueue(pending_task
);
470 // TODO(darin): Delete all tasks once it is safe to do so.
471 // Until it is totally safe, just do it when running Purify or
474 delete pending_task
.task
;
475 #elif defined(OS_POSIX)
476 if (RUNNING_ON_VALGRIND
)
477 delete pending_task
.task
;
478 #endif // defined(OS_POSIX)
481 did_work
|= !deferred_non_nestable_work_queue_
.empty();
482 while (!deferred_non_nestable_work_queue_
.empty()) {
483 // TODO(darin): Delete all tasks once it is safe to do so.
484 // Until it is totaly safe, only delete them under Purify and Valgrind.
487 task
= deferred_non_nestable_work_queue_
.front().task
;
488 #elif defined(OS_POSIX)
489 if (RUNNING_ON_VALGRIND
)
490 task
= deferred_non_nestable_work_queue_
.front().task
;
492 deferred_non_nestable_work_queue_
.pop();
496 did_work
|= !delayed_work_queue_
.empty();
497 while (!delayed_work_queue_
.empty()) {
498 Task
* task
= delayed_work_queue_
.top().task
;
499 delayed_work_queue_
.pop();
505 bool MessageLoop::DoWork() {
506 if (!nestable_tasks_allowed_
) {
507 // Task can't be executed right now.
513 if (work_queue_
.empty())
516 // Execute oldest task.
518 PendingTask pending_task
= work_queue_
.front();
520 if (!pending_task
.delayed_run_time
.is_null()) {
521 AddToDelayedWorkQueue(pending_task
);
522 // If we changed the topmost task, then it is time to re-schedule.
523 if (delayed_work_queue_
.top().task
== pending_task
.task
)
524 pump_
->ScheduleDelayedWork(pending_task
.delayed_run_time
);
526 if (DeferOrRunPendingTask(pending_task
))
529 } while (!work_queue_
.empty());
536 bool MessageLoop::DoDelayedWork(Time
* next_delayed_work_time
) {
537 if (!nestable_tasks_allowed_
|| delayed_work_queue_
.empty()) {
538 *next_delayed_work_time
= Time();
542 if (delayed_work_queue_
.top().delayed_run_time
> Time::Now()) {
543 *next_delayed_work_time
= delayed_work_queue_
.top().delayed_run_time
;
547 PendingTask pending_task
= delayed_work_queue_
.top();
548 delayed_work_queue_
.pop();
550 if (!delayed_work_queue_
.empty())
551 *next_delayed_work_time
= delayed_work_queue_
.top().delayed_run_time
;
553 return DeferOrRunPendingTask(pending_task
);
556 bool MessageLoop::DoIdleWork() {
557 if (ProcessNextDelayedNonNestableTask())
560 if (state_
->quit_received
)
566 //------------------------------------------------------------------------------
567 // MessageLoop::AutoRunState
569 MessageLoop::AutoRunState::AutoRunState(MessageLoop
* loop
) : loop_(loop
) {
570 // Make the loop reference us.
571 previous_state_
= loop_
->state_
;
572 if (previous_state_
) {
573 run_depth
= previous_state_
->run_depth
+ 1;
577 loop_
->state_
= this;
579 // Initialize the other fields:
580 quit_received
= false;
581 #if !defined(OS_MACOSX)
586 MessageLoop::AutoRunState::~AutoRunState() {
587 loop_
->state_
= previous_state_
;
590 //------------------------------------------------------------------------------
591 // MessageLoop::PendingTask
593 bool MessageLoop::PendingTask::operator<(const PendingTask
& other
) const {
594 // Since the top of a priority queue is defined as the "greatest" element, we
595 // need to invert the comparison here. We want the smaller time to be at the
598 if (delayed_run_time
< other
.delayed_run_time
)
601 if (delayed_run_time
> other
.delayed_run_time
)
604 // If the times happen to match, then we use the sequence number to decide.
605 // Compare the difference to support integer roll-over.
606 return (sequence_num
- other
.sequence_num
) > 0;
609 //------------------------------------------------------------------------------
610 // Method and data for histogramming events and actions taken by each instance
614 void MessageLoop::EnableHistogrammer(bool enable
) {
615 enable_histogrammer_
= enable
;
618 void MessageLoop::StartHistogrammer() {
619 if (enable_histogrammer_
&& !message_histogram_
.get()
620 && base::StatisticsRecorder::WasStarted()) {
621 DCHECK(!thread_name_
.empty());
622 message_histogram_
= base::LinearHistogram::FactoryGet(
623 "MsgLoop:" + thread_name_
,
624 kLeastNonZeroMessageId
, kMaxMessageId
,
625 kNumberOfDistinctMessagesDisplayed
,
626 message_histogram_
->kHexRangePrintingFlag
);
627 message_histogram_
->SetRangeDescriptions(event_descriptions_
);
631 void MessageLoop::HistogramEvent(int event
) {
632 if (message_histogram_
.get())
633 message_histogram_
->Add(event
);
636 //------------------------------------------------------------------------------
640 void MessageLoopForUI::DidProcessMessage(const MSG
& message
) {
641 pump_win()->DidProcessMessage(message
);
643 #endif // defined(OS_WIN)
645 #if !defined(OS_MACOSX)
646 void MessageLoopForUI::AddObserver(Observer
* observer
) {
647 pump_ui()->AddObserver(observer
);
650 void MessageLoopForUI::RemoveObserver(Observer
* observer
) {
651 pump_ui()->RemoveObserver(observer
);
654 void MessageLoopForUI::Run(Dispatcher
* dispatcher
) {
655 AutoRunState
save_state(this);
656 state_
->dispatcher
= dispatcher
;
659 #endif // !defined(OS_MACOSX)
661 //------------------------------------------------------------------------------
666 void MessageLoopForIO::RegisterIOHandler(HANDLE file
, IOHandler
* handler
) {
667 pump_io()->RegisterIOHandler(file
, handler
);
670 bool MessageLoopForIO::WaitForIOCompletion(DWORD timeout
, IOHandler
* filter
) {
671 return pump_io()->WaitForIOCompletion(timeout
, filter
);
674 #elif defined(OS_POSIX)
676 bool MessageLoopForIO::WatchFileDescriptor(int fd
,
679 FileDescriptorWatcher
*controller
,
681 return pump_libevent()->WatchFileDescriptor(
684 static_cast<base::MessagePumpLibevent::Mode
>(mode
),