OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ | 5 #ifndef BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ |
6 #define BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ | 6 #define BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ |
7 | 7 |
8 #include <queue> | 8 #include <queue> |
9 #include <string> | 9 #include <string> |
10 | 10 |
11 #include "base/base_export.h" | 11 #include "base/base_export.h" |
12 #include "base/basictypes.h" | 12 #include "base/basictypes.h" |
13 #include "base/callback_forward.h" | 13 #include "base/callback_forward.h" |
14 #include "base/location.h" | 14 #include "base/location.h" |
15 #include "base/memory/ref_counted.h" | 15 #include "base/memory/ref_counted.h" |
| 16 #include "base/memory/scoped_ptr.h" |
| 17 #include "base/message_loop/incoming_task_queue.h" |
16 #include "base/message_loop/message_loop_proxy.h" | 18 #include "base/message_loop/message_loop_proxy.h" |
| 19 #include "base/message_loop/message_loop_proxy_impl.h" |
17 #include "base/message_loop/message_pump.h" | 20 #include "base/message_loop/message_pump.h" |
18 #include "base/observer_list.h" | 21 #include "base/observer_list.h" |
19 #include "base/pending_task.h" | 22 #include "base/pending_task.h" |
20 #include "base/sequenced_task_runner_helpers.h" | 23 #include "base/sequenced_task_runner_helpers.h" |
21 #include "base/synchronization/lock.h" | 24 #include "base/synchronization/lock.h" |
22 #include "base/time/time.h" | 25 #include "base/time/time.h" |
23 #include "base/tracking_info.h" | 26 #include "base/tracking_info.h" |
24 | 27 |
25 #if defined(OS_WIN) | 28 #if defined(OS_WIN) |
26 // We need this to declare base::MessagePumpWin::Dispatcher, which we should | 29 // We need this to declare base::MessagePumpWin::Dispatcher, which we should |
(...skipping 12 matching lines...) Expand all Loading... |
39 #else | 42 #else |
40 #include "base/message_loop/message_pump_gtk.h" | 43 #include "base/message_loop/message_pump_gtk.h" |
41 #endif | 44 #endif |
42 | 45 |
43 #endif | 46 #endif |
44 #endif | 47 #endif |
45 | 48 |
46 namespace base { | 49 namespace base { |
47 | 50 |
48 class HistogramBase; | 51 class HistogramBase; |
49 class MessageLoopLockTest; | |
50 class RunLoop; | 52 class RunLoop; |
51 class ThreadTaskRunnerHandle; | 53 class ThreadTaskRunnerHandle; |
52 #if defined(OS_ANDROID) | 54 #if defined(OS_ANDROID) |
53 class MessagePumpForUI; | 55 class MessagePumpForUI; |
54 #endif | 56 #endif |
| 57 class WaitableEvent; |
55 | 58 |
56 // A MessageLoop is used to process events for a particular thread. There is | 59 // A MessageLoop is used to process events for a particular thread. There is |
57 // at most one MessageLoop instance per thread. | 60 // at most one MessageLoop instance per thread. |
58 // | 61 // |
59 // Events include at a minimum Task instances submitted to PostTask and its | 62 // Events include at a minimum Task instances submitted to PostTask and its |
60 // variants. Depending on the type of message pump used by the MessageLoop | 63 // variants. Depending on the type of message pump used by the MessageLoop |
61 // other events such as UI messages may be processed. On Windows APC calls (as | 64 // other events such as UI messages may be processed. On Windows APC calls (as |
62 // time permits) and signals sent to a registered set of HANDLEs may also be | 65 // time permits) and signals sent to a registered set of HANDLEs may also be |
63 // processed. | 66 // processed. |
64 // | 67 // |
(...skipping 211 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
276 | 279 |
277 // Optional call to connect the thread name with this loop. | 280 // Optional call to connect the thread name with this loop. |
278 void set_thread_name(const std::string& thread_name) { | 281 void set_thread_name(const std::string& thread_name) { |
279 DCHECK(thread_name_.empty()) << "Should not rename this thread!"; | 282 DCHECK(thread_name_.empty()) << "Should not rename this thread!"; |
280 thread_name_ = thread_name; | 283 thread_name_ = thread_name; |
281 } | 284 } |
282 const std::string& thread_name() const { return thread_name_; } | 285 const std::string& thread_name() const { return thread_name_; } |
283 | 286 |
284 // Gets the message loop proxy associated with this message loop. | 287 // Gets the message loop proxy associated with this message loop. |
285 scoped_refptr<MessageLoopProxy> message_loop_proxy() { | 288 scoped_refptr<MessageLoopProxy> message_loop_proxy() { |
286 return message_loop_proxy_.get(); | 289 return message_loop_proxy_; |
287 } | 290 } |
288 | 291 |
289 // Enables or disables the recursive task processing. This happens in the case | 292 // Enables or disables the recursive task processing. This happens in the case |
290 // of recursive message loops. Some unwanted message loop may occurs when | 293 // of recursive message loops. Some unwanted message loop may occurs when |
291 // using common controls or printer functions. By default, recursive task | 294 // using common controls or printer functions. By default, recursive task |
292 // processing is disabled. | 295 // processing is disabled. |
293 // | 296 // |
294 // Please utilize |ScopedNestableTaskAllower| instead of calling these methods | 297 // Please utilize |ScopedNestableTaskAllower| instead of calling these methods |
295 // directly. In general nestable message loops are to be avoided. They are | 298 // directly. In general nestable message loops are to be avoided. They are |
296 // dangerous and difficult to get right, so please use with extreme caution. | 299 // dangerous and difficult to get right, so please use with extreme caution. |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
352 | 355 |
353 protected: | 356 protected: |
354 virtual ~TaskObserver(); | 357 virtual ~TaskObserver(); |
355 }; | 358 }; |
356 | 359 |
357 // These functions can only be called on the same thread that |this| is | 360 // These functions can only be called on the same thread that |this| is |
358 // running on. | 361 // running on. |
359 void AddTaskObserver(TaskObserver* task_observer); | 362 void AddTaskObserver(TaskObserver* task_observer); |
360 void RemoveTaskObserver(TaskObserver* task_observer); | 363 void RemoveTaskObserver(TaskObserver* task_observer); |
361 | 364 |
362 // Returns true if the message loop has high resolution timers enabled. | |
363 // Provided for testing. | |
364 bool high_resolution_timers_enabled() { | |
365 #if defined(OS_WIN) | |
366 return !high_resolution_timer_expiration_.is_null(); | |
367 #else | |
368 return true; | |
369 #endif | |
370 } | |
371 | |
372 // When we go into high resolution timer mode, we will stay in hi-res mode | 365 // When we go into high resolution timer mode, we will stay in hi-res mode |
373 // for at least 1s. | 366 // for at least 1s. |
374 static const int kHighResolutionTimerModeLeaseTimeMs = 1000; | 367 static const int kHighResolutionTimerModeLeaseTimeMs = 1000; |
375 | 368 |
376 // Asserts that the MessageLoop is "idle". | |
377 void AssertIdle() const; | |
378 | |
379 #if defined(OS_WIN) | 369 #if defined(OS_WIN) |
380 void set_os_modal_loop(bool os_modal_loop) { | 370 void set_os_modal_loop(bool os_modal_loop) { |
381 os_modal_loop_ = os_modal_loop; | 371 os_modal_loop_ = os_modal_loop; |
382 } | 372 } |
383 | 373 |
384 bool os_modal_loop() const { | 374 bool os_modal_loop() const { |
385 return os_modal_loop_; | 375 return os_modal_loop_; |
386 } | 376 } |
387 #endif // OS_WIN | 377 #endif // OS_WIN |
388 | 378 |
389 // Can only be called from the thread that owns the MessageLoop. | 379 // Can only be called from the thread that owns the MessageLoop. |
390 bool is_running() const; | 380 bool is_running() const; |
391 | 381 |
| 382 // Returns true if the message loop has high resolution timers enabled. |
| 383 // Provided for testing. |
| 384 bool IsHighResolutionTimerEnabledForTesting(); |
| 385 |
| 386 // Returns true if the message loop is "idle". Provided for testing. |
| 387 bool IsIdleForTesting(); |
| 388 |
| 389 // Takes the incoming queue lock, signals |caller_wait| and waits until |
| 390 // |caller_signal| is signalled. |
| 391 void LockWaitUnLockForTesting(WaitableEvent* caller_wait, |
| 392 WaitableEvent* caller_signal); |
| 393 |
392 //---------------------------------------------------------------------------- | 394 //---------------------------------------------------------------------------- |
393 protected: | 395 protected: |
394 | 396 |
395 #if defined(OS_WIN) | 397 #if defined(OS_WIN) |
396 MessagePumpWin* pump_win() { | 398 MessagePumpWin* pump_win() { |
397 return static_cast<MessagePumpWin*>(pump_.get()); | 399 return static_cast<MessagePumpWin*>(pump_.get()); |
398 } | 400 } |
399 #elif defined(OS_POSIX) && !defined(OS_IOS) | 401 #elif defined(OS_POSIX) && !defined(OS_IOS) |
400 MessagePumpLibevent* pump_libevent() { | 402 MessagePumpLibevent* pump_libevent() { |
401 return static_cast<MessagePumpLibevent*>(pump_.get()); | 403 return static_cast<MessagePumpLibevent*>(pump_.get()); |
402 } | 404 } |
403 #endif | 405 #endif |
404 | 406 |
405 scoped_refptr<MessagePump> pump_; | 407 scoped_ptr<MessagePump> pump_; |
406 | 408 |
407 private: | 409 private: |
| 410 friend class internal::IncomingTaskQueue; |
408 friend class RunLoop; | 411 friend class RunLoop; |
409 friend class MessageLoopLockTest; | |
410 | 412 |
411 // A function to encapsulate all the exception handling capability in the | 413 // A function to encapsulate all the exception handling capability in the |
412 // stacks around the running of a main message loop. It will run the message | 414 // stacks around the running of a main message loop. It will run the message |
413 // loop in a SEH try block or not depending on the set_SEH_restoration() | 415 // loop in a SEH try block or not depending on the set_SEH_restoration() |
414 // flag invoking respectively RunInternalInSEHFrame() or RunInternal(). | 416 // flag invoking respectively RunInternalInSEHFrame() or RunInternal(). |
415 void RunHandler(); | 417 void RunHandler(); |
416 | 418 |
417 #if defined(OS_WIN) | 419 #if defined(OS_WIN) |
418 __declspec(noinline) void RunInternalInSEHFrame(); | 420 __declspec(noinline) void RunInternalInSEHFrame(); |
419 #endif | 421 #endif |
420 | 422 |
421 // A surrounding stack frame around the running of the message loop that | 423 // A surrounding stack frame around the running of the message loop that |
422 // supports all saving and restoring of state, as is needed for any/all (ugly) | 424 // supports all saving and restoring of state, as is needed for any/all (ugly) |
423 // recursive calls. | 425 // recursive calls. |
424 void RunInternal(); | 426 void RunInternal(); |
425 | 427 |
426 // Called to process any delayed non-nestable tasks. | 428 // Called to process any delayed non-nestable tasks. |
427 bool ProcessNextDelayedNonNestableTask(); | 429 bool ProcessNextDelayedNonNestableTask(); |
428 | 430 |
429 // Runs the specified PendingTask. | 431 // Runs the specified PendingTask. |
430 void RunTask(const PendingTask& pending_task); | 432 void RunTask(const PendingTask& pending_task); |
431 | 433 |
432 // Calls RunTask or queues the pending_task on the deferred task list if it | 434 // Calls RunTask or queues the pending_task on the deferred task list if it |
433 // cannot be run right now. Returns true if the task was run. | 435 // cannot be run right now. Returns true if the task was run. |
434 bool DeferOrRunPendingTask(const PendingTask& pending_task); | 436 bool DeferOrRunPendingTask(const PendingTask& pending_task); |
435 | 437 |
436 // Adds the pending task to delayed_work_queue_. | 438 // Adds the pending task to delayed_work_queue_. |
437 void AddToDelayedWorkQueue(const PendingTask& pending_task); | 439 void AddToDelayedWorkQueue(const PendingTask& pending_task); |
438 | 440 |
439 // This function attempts to add pending task to our incoming_queue_. | |
440 // The append can only possibly fail when |use_try_lock| is true. | |
441 // | |
442 // When |use_try_lock| is true, then this call will avoid blocking if | |
443 // the related lock is already held, and will in that case (when the | |
444 // lock is contended) fail to perform the append, and will return false. | |
445 // | |
446 // If the call succeeds to append to the queue, then this call | |
447 // will return true. | |
448 // | |
449 // In all cases, the caller retains ownership of |pending_task|, but this | |
450 // function will reset the value of pending_task->task. This is needed to | |
451 // ensure that the posting call stack does not retain pending_task->task | |
452 // beyond this function call. | |
453 bool AddToIncomingQueue(PendingTask* pending_task, bool use_try_lock); | |
454 | |
455 // Load tasks from the incoming_queue_ into work_queue_ if the latter is | |
456 // empty. The former requires a lock to access, while the latter is directly | |
457 // accessible on this thread. | |
458 void ReloadWorkQueue(); | |
459 | |
460 // Delete tasks that haven't run yet without running them. Used in the | 441 // Delete tasks that haven't run yet without running them. Used in the |
461 // destructor to make sure all the task's destructors get called. Returns | 442 // destructor to make sure all the task's destructors get called. Returns |
462 // true if some work was done. | 443 // true if some work was done. |
463 bool DeletePendingTasks(); | 444 bool DeletePendingTasks(); |
464 | 445 |
465 // Calculates the time at which a PendingTask should run. | 446 // Creates a process-wide unique ID to represent this task in trace events. |
466 TimeTicks CalculateDelayedRuntime(TimeDelta delay); | 447 // This will be mangled with a Process ID hash to reduce the likelyhood of |
| 448 // colliding with MessageLoop pointers on other processes. |
| 449 uint64 GetTaskTraceID(const PendingTask& task); |
| 450 |
| 451 // Loads tasks from the incoming queue to |work_queue_| if the latter is |
| 452 // empty. |
| 453 void ReloadWorkQueue(); |
| 454 |
| 455 // Wakes up the message pump. Can be called on any thread. The caller is |
| 456 // responsible for synchronizing ScheduleWork() calls. |
| 457 void ScheduleWork(bool was_empty); |
467 | 458 |
468 // Start recording histogram info about events and action IF it was enabled | 459 // Start recording histogram info about events and action IF it was enabled |
469 // and IF the statistics recorder can accept a registration of our histogram. | 460 // and IF the statistics recorder can accept a registration of our histogram. |
470 void StartHistogrammer(); | 461 void StartHistogrammer(); |
471 | 462 |
472 // Add occurrence of event to our histogram, so that we can see what is being | 463 // Add occurrence of event to our histogram, so that we can see what is being |
473 // done in a specific MessageLoop instance (i.e., specific thread). | 464 // done in a specific MessageLoop instance (i.e., specific thread). |
474 // If message_histogram_ is NULL, this is a no-op. | 465 // If message_histogram_ is NULL, this is a no-op. |
475 void HistogramEvent(int event); | 466 void HistogramEvent(int event); |
476 | 467 |
(...skipping 14 matching lines...) Expand all Loading... |
491 // A recent snapshot of Time::Now(), used to check delayed_work_queue_. | 482 // A recent snapshot of Time::Now(), used to check delayed_work_queue_. |
492 TimeTicks recent_time_; | 483 TimeTicks recent_time_; |
493 | 484 |
494 // A queue of non-nestable tasks that we had to defer because when it came | 485 // A queue of non-nestable tasks that we had to defer because when it came |
495 // time to execute them we were in a nested message loop. They will execute | 486 // time to execute them we were in a nested message loop. They will execute |
496 // once we're out of nested message loops. | 487 // once we're out of nested message loops. |
497 TaskQueue deferred_non_nestable_work_queue_; | 488 TaskQueue deferred_non_nestable_work_queue_; |
498 | 489 |
499 ObserverList<DestructionObserver> destruction_observers_; | 490 ObserverList<DestructionObserver> destruction_observers_; |
500 | 491 |
| 492 bool exception_restoration_; |
| 493 |
501 // A recursion block that prevents accidentally running additional tasks when | 494 // A recursion block that prevents accidentally running additional tasks when |
502 // insider a (accidentally induced?) nested message pump. | 495 // insider a (accidentally induced?) nested message pump. |
503 bool nestable_tasks_allowed_; | 496 bool nestable_tasks_allowed_; |
504 | 497 |
505 bool exception_restoration_; | 498 #if defined(OS_WIN) |
| 499 // Should be set to true before calling Windows APIs like TrackPopupMenu, etc |
| 500 // which enter a modal message loop. |
| 501 bool os_modal_loop_; |
| 502 #endif |
506 | 503 |
507 std::string thread_name_; | 504 std::string thread_name_; |
508 // A profiling histogram showing the counts of various messages and events. | 505 // A profiling histogram showing the counts of various messages and events. |
509 HistogramBase* message_histogram_; | 506 HistogramBase* message_histogram_; |
510 | 507 |
511 // An incoming queue of tasks that are acquired under a mutex for processing | |
512 // on this instance's thread. These tasks have not yet been sorted out into | |
513 // items for our work_queue_ vs delayed_work_queue_. | |
514 TaskQueue incoming_queue_; | |
515 // Protect access to incoming_queue_. | |
516 mutable Lock incoming_queue_lock_; | |
517 | |
518 RunLoop* run_loop_; | 508 RunLoop* run_loop_; |
519 | 509 |
520 #if defined(OS_WIN) | |
521 TimeTicks high_resolution_timer_expiration_; | |
522 // Should be set to true before calling Windows APIs like TrackPopupMenu, etc | |
523 // which enter a modal message loop. | |
524 bool os_modal_loop_; | |
525 #endif | |
526 | |
527 // The next sequence number to use for delayed tasks. Updating this counter is | |
528 // protected by incoming_queue_lock_. | |
529 int next_sequence_num_; | |
530 | |
531 ObserverList<TaskObserver> task_observers_; | 510 ObserverList<TaskObserver> task_observers_; |
532 | 511 |
533 // The message loop proxy associated with this message loop, if one exists. | 512 scoped_refptr<internal::IncomingTaskQueue> incoming_task_queue_; |
534 scoped_refptr<MessageLoopProxy> message_loop_proxy_; | 513 |
| 514 // The message loop proxy associated with this message loop. |
| 515 scoped_refptr<internal::MessageLoopProxyImpl> message_loop_proxy_; |
535 scoped_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_; | 516 scoped_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_; |
536 | 517 |
537 template <class T, class R> friend class base::subtle::DeleteHelperInternal; | 518 template <class T, class R> friend class base::subtle::DeleteHelperInternal; |
538 template <class T, class R> friend class base::subtle::ReleaseHelperInternal; | 519 template <class T, class R> friend class base::subtle::ReleaseHelperInternal; |
539 | 520 |
540 void DeleteSoonInternal(const tracked_objects::Location& from_here, | 521 void DeleteSoonInternal(const tracked_objects::Location& from_here, |
541 void(*deleter)(const void*), | 522 void(*deleter)(const void*), |
542 const void* object); | 523 const void* object); |
543 void ReleaseSoonInternal(const tracked_objects::Location& from_here, | 524 void ReleaseSoonInternal(const tracked_objects::Location& from_here, |
544 void(*releaser)(const void*), | 525 void(*releaser)(const void*), |
(...skipping 175 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
720 | 701 |
721 // Do not add any member variables to MessageLoopForIO! This is important b/c | 702 // Do not add any member variables to MessageLoopForIO! This is important b/c |
722 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO). Any extra | 703 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO). Any extra |
723 // data that you need should be stored on the MessageLoop's pump_ instance. | 704 // data that you need should be stored on the MessageLoop's pump_ instance. |
724 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO), | 705 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO), |
725 MessageLoopForIO_should_not_have_extra_member_variables); | 706 MessageLoopForIO_should_not_have_extra_member_variables); |
726 | 707 |
727 } // namespace base | 708 } // namespace base |
728 | 709 |
729 #endif // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ | 710 #endif // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ |
OLD | NEW |