Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(5296)

Unified Diff: base/message_loop/message_loop_proxy_impl.cc

Issue 17567007: Made MessagePump a non-thread safe class. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rebased Created 7 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
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>

Powered by Google App Engine
This is Rietveld 408576698