Made MessagePump a non-thread safe class.

base/message_loop/message_loop_proxy_impl.h

 // 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.
 
 #ifndef BASE_MESSAGE_LOOP_MESSAGE_LOOP_PROXY_IMPL_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_LOOP_PROXY_IMPL_H_
 
 #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 {
 
 // A stock implementation of MessageLoopProxy that is created and managed by a
 // MessageLoop. For now a MessageLoopProxyImpl can only be created as part of a
 // MessageLoop.
 class BASE_EXPORT MessageLoopProxyImpl : public MessageLoopProxy {
  public:
   // MessageLoopProxy implementation
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const base::Closure& task,
                                base::TimeDelta delay) OVERRIDE;
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       const base::Closure& task,
       base::TimeDelta delay) OVERRIDE;
   virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
 
  protected:
   virtual ~MessageLoopProxyImpl();
 
   // Override OnDestruct so that we can delete the object on the target message
   // loop if it still exists.
   virtual void OnDestruct() const OVERRIDE;
 
  private:
   // Allow the MessageLoop to create a MessageLoopProxyImpl.
   friend class MessageLoop;
+  friend class MessageLoopLockTest;
   friend class DeleteHelper<MessageLoopProxyImpl>;
 
   MessageLoopProxyImpl();
 
   // 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,

[rvargas (doing something else), 2013/06/28 22:59:44]

it would be nice to have some sort of indication of what methods are supposed to
be used by the message_loop. The fact that it is a friend and all methods are
private makes that difficult.

+                             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);
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_LOOP_PROXY_IMPL_H_