Index: base/message_loop/message_loop_proxy_impl.cc |
diff --git a/base/message_loop/message_loop_proxy_impl.cc b/base/message_loop/message_loop_proxy_impl.cc |
index 7dc8caa9f4c047f93cf7366c2e373ad1eebdd0fb..8fc05bd00b73e5d80d4d2672122c7c7734087d59 100644 |
--- a/base/message_loop/message_loop_proxy_impl.cc |
+++ b/base/message_loop/message_loop_proxy_impl.cc |
@@ -4,81 +4,183 @@ |
#include "base/message_loop/message_loop_proxy_impl.h" |
+#include "base/debug/trace_event.h" |
#include "base/location.h" |
#include "base/threading/thread_restrictions.h" |
namespace base { |
-MessageLoopProxyImpl::~MessageLoopProxyImpl() { |
+MessageLoop::ProxyImpl::ProxyImpl() |
+ : message_loop_(MessageLoop::current()), |
+ next_sequence_num_(0) { |
} |
-bool MessageLoopProxyImpl::PostDelayedTask( |
+bool MessageLoop::ProxyImpl::PostDelayedTask( |
const tracked_objects::Location& from_here, |
const base::Closure& task, |
base::TimeDelta delay) { |
- return PostTaskHelper(from_here, task, delay, true); |
+ DCHECK(!task.is_null()) << from_here.ToString(); |
+ return AddToIncomingQueue(from_here, task, delay, true); |
} |
-bool MessageLoopProxyImpl::PostNonNestableDelayedTask( |
+bool MessageLoop::ProxyImpl::PostNonNestableDelayedTask( |
const tracked_objects::Location& from_here, |
const base::Closure& task, |
base::TimeDelta delay) { |
- return PostTaskHelper(from_here, task, delay, false); |
+ DCHECK(!task.is_null()) << from_here.ToString(); |
+ return AddToIncomingQueue(from_here, task, delay, false); |
} |
-bool MessageLoopProxyImpl::RunsTasksOnCurrentThread() const { |
+bool MessageLoop::ProxyImpl::RunsTasksOnCurrentThread() const { |
// We shouldn't use MessageLoop::current() since it uses LazyInstance which |
// may be deleted by ~AtExitManager when a WorkerPool thread calls this |
// function. |
// http://crbug.com/63678 |
base::ThreadRestrictions::ScopedAllowSingleton allow_singleton; |
- AutoLock lock(message_loop_lock_); |
- return (target_message_loop_ && |
- (MessageLoop::current() == target_message_loop_)); |
+ AutoLock lock(incoming_queue_lock_); |
+ return (message_loop_ && (MessageLoop::current() == message_loop_)); |
} |
-// MessageLoop::DestructionObserver implementation |
-void MessageLoopProxyImpl::WillDestroyCurrentMessageLoop() { |
- AutoLock lock(message_loop_lock_); |
- target_message_loop_ = NULL; |
+bool MessageLoop::ProxyImpl::AddToIncomingQueue( |
+ const tracked_objects::Location& from_here, |
+ const Closure& task, |
+ TimeDelta delay, |
+ bool nestable) { |
+ AutoLock locked(incoming_queue_lock_); |
+ PendingTask pending_task( |
+ from_here, task, CalculateDelayedRuntime(delay), nestable); |
+ return PostPendingTask(&pending_task); |
} |
-void MessageLoopProxyImpl::OnDestruct() const { |
- // We shouldn't use MessageLoop::current() since it uses LazyInstance which |
- // may be deleted by ~AtExitManager when a WorkerPool thread calls this |
- // function. |
- // http://crbug.com/63678 |
- base::ThreadRestrictions::ScopedAllowSingleton allow_singleton; |
- bool delete_later = false; |
- { |
- AutoLock lock(message_loop_lock_); |
- if (target_message_loop_ && |
- (MessageLoop::current() != target_message_loop_)) { |
- target_message_loop_->DeleteSoon(FROM_HERE, this); |
- delete_later = true; |
- } |
+bool MessageLoop::ProxyImpl::IsHishResolutionTimersEnabledForTest() { |
+#if defined(OS_WIN) |
+ return !high_resolution_timer_expiration_.is_null(); |
+#else |
+ return true; |
+#endif |
+} |
+ |
+bool MessageLoop::ProxyImpl::IsIdleForTest() { |
+ AutoLock lock(incoming_queue_lock_); |
+ return incoming_queue_.empty(); |
+} |
+ |
+void MessageLoop::ProxyImpl::ReloadWorkQueue(TaskQueue* work_queue) { |
+ // Make sure no tasks are lost. |
+ DCHECK(work_queue->empty()); |
+ |
+ // Acquire all we can from the inter-thread queue with one lock acquisition. |
+ AutoLock lock(incoming_queue_lock_); |
+ if (!incoming_queue_.empty()) |
+ incoming_queue_.Swap(work_queue); // Constant time |
+ |
+ DCHECK(incoming_queue_.empty()); |
+} |
+ |
+bool MessageLoop::ProxyImpl::TryAddToIncomingQueue( |
+ const tracked_objects::Location& from_here, |
+ const Closure& task) { |
+ if (!incoming_queue_lock_.Try()) { |
+ // Reset |task|. |
+ Closure local_task = task; |
+ return false; |
+ } |
+ |
+ AutoLock locked(incoming_queue_lock_, AutoLock::AlreadyAcquired()); |
+ PendingTask pending_task( |
+ from_here, task, CalculateDelayedRuntime(TimeDelta()), true); |
+ return PostPendingTask(&pending_task); |
+} |
+ |
+void MessageLoop::ProxyImpl::WillDestroyCurrentMessageLoop() { |
+#if defined(OS_WIN) |
+ // If we left the high-resolution timer activated, deactivate it now. |
+ // Doing this is not-critical, it is mainly to make sure we track |
+ // the high resolution timer activations properly in our unit tests. |
+ if (!high_resolution_timer_expiration_.is_null()) { |
+ Time::ActivateHighResolutionTimer(false); |
+ high_resolution_timer_expiration_ = TimeTicks(); |
} |
- if (!delete_later) |
- delete this; |
+#endif |
+ |
+ AutoLock lock(incoming_queue_lock_); |
+ message_loop_ = NULL; |
} |
-MessageLoopProxyImpl::MessageLoopProxyImpl() |
- : target_message_loop_(MessageLoop::current()) { |
+MessageLoop::ProxyImpl::~ProxyImpl() { |
+ // Verify that WillDestroyCurrentMessageLoop() has been called. |
+ DCHECK(!message_loop_); |
} |
-bool MessageLoopProxyImpl::PostTaskHelper( |
- const tracked_objects::Location& from_here, const base::Closure& task, |
- base::TimeDelta delay, bool nestable) { |
- AutoLock lock(message_loop_lock_); |
- if (target_message_loop_) { |
- if (nestable) { |
- target_message_loop_->PostDelayedTask(from_here, task, delay); |
- } else { |
- target_message_loop_->PostNonNestableDelayedTask(from_here, task, delay); |
+TimeTicks MessageLoop::ProxyImpl::CalculateDelayedRuntime(TimeDelta delay) { |
+ TimeTicks delayed_run_time; |
+ if (delay > TimeDelta()) { |
+ delayed_run_time = TimeTicks::Now() + delay; |
+ |
+#if defined(OS_WIN) |
+ if (high_resolution_timer_expiration_.is_null()) { |
+ // Windows timers are granular to 15.6ms. If we only set high-res |
+ // timers for those under 15.6ms, then a 18ms timer ticks at ~32ms, |
+ // which as a percentage is pretty inaccurate. So enable high |
+ // res timers for any timer which is within 2x of the granularity. |
+ // This is a tradeoff between accuracy and power management. |
+ bool needs_high_res_timers = delay.InMilliseconds() < |
+ (2 * Time::kMinLowResolutionThresholdMs); |
+ if (needs_high_res_timers) { |
+ if (Time::ActivateHighResolutionTimer(true)) { |
+ high_resolution_timer_expiration_ = TimeTicks::Now() + |
+ TimeDelta::FromMilliseconds( |
+ MessageLoop::kHighResolutionTimerModeLeaseTimeMs); |
+ } |
+ } |
} |
- return true; |
+#endif |
+ } else { |
+ DCHECK_EQ(delay.InMilliseconds(), 0) << "delay should not be negative"; |
+ } |
+ |
+#if defined(OS_WIN) |
+ if (!high_resolution_timer_expiration_.is_null()) { |
+ if (TimeTicks::Now() > high_resolution_timer_expiration_) { |
+ Time::ActivateHighResolutionTimer(false); |
+ high_resolution_timer_expiration_ = TimeTicks(); |
+ } |
+ } |
+#endif |
+ |
+ return delayed_run_time; |
+} |
+ |
+bool MessageLoop::ProxyImpl::PostPendingTask(PendingTask* pending_task) { |
+ // Warning: Don't try to short-circuit, and handle this thread's tasks more |
+ // directly, as it could starve handling of foreign threads. Put every task |
+ // into this queue. |
+ |
+ // This should only be called while the lock is taken. |
+ incoming_queue_lock_.AssertAcquired(); |
+ |
+ if (!message_loop_) { |
+ pending_task->task.Reset(); |
+ return false; |
} |
- return false; |
+ |
+ // Initialize the sequence number. The sequence number is used for delayed |
+ // tasks (to faciliate FIFO sorting when two tasks have the same |
+ // delayed_run_time value) and for identifying the task in about:tracing. |
+ pending_task->sequence_num = next_sequence_num_++; |
+ |
+ TRACE_EVENT_FLOW_BEGIN0("task", "MessageLoop::PostTask", |
+ TRACE_ID_MANGLE(message_loop_->GetTaskTraceID(*pending_task))); |
+ |
+ bool was_empty = incoming_queue_.empty(); |
+ incoming_queue_.push(*pending_task); |
+ pending_task->task.Reset(); |
+ |
+ // Wake up the pump. |
+ if (was_empty) |
+ message_loop_->WakeUpPump(); |
+ |
+ return true; |
} |
scoped_refptr<MessageLoopProxy> |