Made MessagePump a non-thread safe class.

base/message_loop/message_loop_proxy_impl.h

Index: base/message_loop/message_loop_proxy_impl.h
diff --git a/base/message_loop/message_loop_proxy_impl.h b/base/message_loop/message_loop_proxy_impl.h
index 2269023ac2d19c0f9074fcadf181a3a9da1f3f51..369495773f2dd1a6f357b1cfaaf24ce8fef66953 100644
--- a/base/message_loop/message_loop_proxy_impl.h
+++ b/base/message_loop/message_loop_proxy_impl.h
@@ -8,7 +8,9 @@
 #include "base/base_export.h"
 #include "base/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/pending_task.h"
 #include "base/synchronization/lock.h"
+#include "base/time.h"
 
 namespace base {
 
@@ -37,6 +39,7 @@ class BASE_EXPORT MessageLoopProxyImpl : public MessageLoopProxy {
  private:
   // Allow the MessageLoop to create a MessageLoopProxyImpl.
   friend class MessageLoop;
+  friend class MessageLoopLockTest;
   friend class DeleteHelper<MessageLoopProxyImpl>;
 
   MessageLoopProxyImpl();
@@ -44,15 +47,67 @@ class BASE_EXPORT MessageLoopProxyImpl : public MessageLoopProxy {
   // Called directly by MessageLoop::~MessageLoop.
   virtual void WillDestroyCurrentMessageLoop();
 
+  // Acquires |incoming_queue_lock_| and appends a task to |incoming_queue_|.
+  // Posting of all tasks is routed though AddToIncomingQueue() or
+  // TryAddToIncomingQueue() to make sure that posting task is properly
+  // synchronized between different threads.
+  //
+  // Returns true if the task was successfully added to the queue, otherwise
+  // returns false. In all cases, the ownership of |task| is transferred to the
+  // called method.
+  bool AddToIncomingQueue(const tracked_objects::Location& from_here,
+                          const Closure& task,
+                          TimeDelta delay,
+                          bool nestable);
 
-  bool PostTaskHelper(const tracked_objects::Location& from_here,
-                      const base::Closure& task,
-                      base::TimeDelta delay,
-                      bool nestable);
+  // Calculates the time at which a PendingTask should run.
+  TimeTicks CalculateDelayedRuntime(TimeDelta delay);
 
-  // The lock that protects access to target_message_loop_.
-  mutable base::Lock message_loop_lock_;
-  MessageLoop* target_message_loop_;
+  // Returns true if the message loop has high resolution timers enabled.
+  // Provided for testing.
+  bool IsHishResolutionTimersEnabledForTest();
+
+  // Returns true if the message loop is "idle". Provided for testing.
+  bool IsIdleForTest();
+
+  // Same as AddToIncomingQueue() except that it will avoid blocking if the lock
+  // is already held, and will in that case (when the lock is contended) fail to
+  // add the task, and will return false.
+  bool TryAddToIncomingQueue(const tracked_objects::Location& from_here,
+                             const Closure& task);
+
+  // Adds a task to |incoming_queue_|. This method can be called on any thread.
+  // The caller is responsible for synchronizing calls to this method.
+  //
+  // In all cases, the caller retains ownership of |pending_task|, but this
+  // function will reset the value of |pending_task->task|. This is needed to
+  // ensure that the posting call stack does not retain |pending_task->task|
+  // beyond this function call.
+  bool PostPendingTask(PendingTask* pending_task);
+
+  // Load tasks from the |incoming_queue_| into |*work_queue| if the latter is
+  // empty. The former requires a lock to access, while the latter is directly
+  // accessible on this thread.
+  void ReloadWorkQueue(TaskQueue* work_queue);
+
+#if defined(OS_WIN)
+  TimeTicks high_resolution_timer_expiration_;
+#endif
+
+  // The lock that protects access to |incoming_queue_|, |message_loop_| and
+  // |next_sequence_num_|.
+  mutable base::Lock incoming_queue_lock_;
+
+  // An incoming queue of tasks that are acquired under a mutex for processing
+  // on this instance's thread. These tasks have not yet been been pushed to
+  // |message_loop_|.
+  TaskQueue incoming_queue_;
+
+  // Points to the message loop that owns |this|.
+  MessageLoop* message_loop_;
+
+  // The next sequence number to use for delayed tasks.
+  int next_sequence_num_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageLoopProxyImpl);
 };