Made MessagePump a non-thread safe class.

base/message_loop/message_loop_proxy_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #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();
+  }
+#endif
+
+  AutoLock lock(incoming_queue_lock_);
+  message_loop_ = NULL;
+}
+
+MessageLoop::ProxyImpl::~ProxyImpl() {
+  // Verify that WillDestroyCurrentMessageLoop() has been called.
+  DCHECK(!message_loop_);
+}
+
+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);
+        }
+      }
+    }
+#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();
     }
   }
-  if (!delete_later)
-    delete this;
+#endif
+
+  return delayed_run_time;
 }
 
-MessageLoopProxyImpl::MessageLoopProxyImpl()
-    : target_message_loop_(MessageLoop::current()) {
-}
+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.
 
-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);
-    }
-    return true;
+  // 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>
 MessageLoopProxy::current() {
   MessageLoop* cur_loop = MessageLoop::current();
   if (!cur_loop)
     return NULL;
   return cur_loop->message_loop_proxy();
 }
 
 }  // namespace base