Made MessagePump a non-thread safe class.

base/message_loop/message_loop.h

 // Copyright 2013 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_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_
 
 #include <queue>
 #include <string>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/incoming_task_queue.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/message_loop/message_loop_proxy_impl.h"
 #include "base/message_loop/message_pump.h"
 #include "base/observer_list.h"
 #include "base/pending_task.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/tracking_info.h"
 
 #if defined(OS_WIN)
 // We need this to declare base::MessagePumpWin::Dispatcher, which we should
@@ skipping 12 matching lines @@
 #else
 #include "base/message_loop/message_pump_gtk.h"
 #endif
 
 #endif
 #endif
 
 namespace base {
 
 class HistogramBase;
-class MessageLoopLockTest;
 class RunLoop;
 class ThreadTaskRunnerHandle;
 #if defined(OS_ANDROID)
 class MessagePumpForUI;
 #endif
+class WaitableEvent;
 
 // A MessageLoop is used to process events for a particular thread.  There is
 // at most one MessageLoop instance per thread.
 //
 // Events include at a minimum Task instances submitted to PostTask and its
 // variants.  Depending on the type of message pump used by the MessageLoop
 // other events such as UI messages may be processed.  On Windows APC calls (as
 // time permits) and signals sent to a registered set of HANDLEs may also be
 // processed.
 //
@@ skipping 211 matching lines @@
 
   // Optional call to connect the thread name with this loop.
   void set_thread_name(const std::string& thread_name) {
     DCHECK(thread_name_.empty()) << "Should not rename this thread!";
     thread_name_ = thread_name;
   }
   const std::string& thread_name() const { return thread_name_; }
 
   // Gets the message loop proxy associated with this message loop.
   scoped_refptr<MessageLoopProxy> message_loop_proxy() {
-    return message_loop_proxy_.get();
+    return message_loop_proxy_;
   }
 
   // Enables or disables the recursive task processing. This happens in the case
   // of recursive message loops. Some unwanted message loop may occurs when
   // using common controls or printer functions. By default, recursive task
   // processing is disabled.
   //
   // Please utilize |ScopedNestableTaskAllower| instead of calling these methods
   // directly.  In general nestable message loops are to be avoided.  They are
   // dangerous and difficult to get right, so please use with extreme caution.
@@ skipping 55 matching lines @@
 
    protected:
     virtual ~TaskObserver();
   };
 
   // These functions can only be called on the same thread that |this| is
   // running on.
   void AddTaskObserver(TaskObserver* task_observer);
   void RemoveTaskObserver(TaskObserver* task_observer);
 
-  // Returns true if the message loop has high resolution timers enabled.
-  // Provided for testing.
-  bool high_resolution_timers_enabled() {
-#if defined(OS_WIN)
-    return !high_resolution_timer_expiration_.is_null();
-#else
-    return true;
-#endif
-  }
-
   // When we go into high resolution timer mode, we will stay in hi-res mode
   // for at least 1s.
   static const int kHighResolutionTimerModeLeaseTimeMs = 1000;
 
-  // Asserts that the MessageLoop is "idle".
-  void AssertIdle() const;
-
 #if defined(OS_WIN)
   void set_os_modal_loop(bool os_modal_loop) {
     os_modal_loop_ = os_modal_loop;
   }
 
   bool os_modal_loop() const {
     return os_modal_loop_;
   }
 #endif  // OS_WIN
 
   // Can only be called from the thread that owns the MessageLoop.
   bool is_running() const;
 
+  // Returns true if the message loop has high resolution timers enabled.
+  // Provided for testing.
+  bool IsHighResolutionTimerEnabledForTesting();
+
+  // Returns true if the message loop is "idle". Provided for testing.
+  bool IsIdleForTesting();
+
+  // Takes the incoming queue lock, signals |caller_wait| and waits until
+  // |caller_signal| is signalled.
+  void LockWaitUnLockForTesting(WaitableEvent* caller_wait,
+                                WaitableEvent* caller_signal);
+
   //----------------------------------------------------------------------------
  protected:
 
 #if defined(OS_WIN)
   MessagePumpWin* pump_win() {
     return static_cast<MessagePumpWin*>(pump_.get());
   }
 #elif defined(OS_POSIX) && !defined(OS_IOS)
   MessagePumpLibevent* pump_libevent() {
     return static_cast<MessagePumpLibevent*>(pump_.get());
   }
 #endif
 
-  scoped_refptr<MessagePump> pump_;
+  scoped_ptr<MessagePump> pump_;
 
  private:
+  friend class internal::IncomingTaskQueue;
   friend class RunLoop;
-  friend class MessageLoopLockTest;
 
   // A function to encapsulate all the exception handling capability in the
   // stacks around the running of a main message loop.  It will run the message
   // loop in a SEH try block or not depending on the set_SEH_restoration()
   // flag invoking respectively RunInternalInSEHFrame() or RunInternal().
   void RunHandler();
 
 #if defined(OS_WIN)
   __declspec(noinline) void RunInternalInSEHFrame();
 #endif
 
   // A surrounding stack frame around the running of the message loop that
   // supports all saving and restoring of state, as is needed for any/all (ugly)
   // recursive calls.
   void RunInternal();
 
   // Called to process any delayed non-nestable tasks.
   bool ProcessNextDelayedNonNestableTask();
 
   // Runs the specified PendingTask.
   void RunTask(const PendingTask& pending_task);
 
   // Calls RunTask or queues the pending_task on the deferred task list if it
   // cannot be run right now.  Returns true if the task was run.
   bool DeferOrRunPendingTask(const PendingTask& pending_task);
 
   // Adds the pending task to delayed_work_queue_.
   void AddToDelayedWorkQueue(const PendingTask& pending_task);
 
-  // This function attempts to add pending task to our incoming_queue_.
-  // The append can only possibly fail when |use_try_lock| is true.
-  //
-  // When |use_try_lock| is true, then this call will avoid blocking if
-  // the related lock is already held, and will in that case (when the
-  // lock is contended) fail to perform the append, and will return false.
-  //
-  // If the call succeeds to append to the queue, then this call
-  // will return true.
-  //
-  // 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 AddToIncomingQueue(PendingTask* pending_task, bool use_try_lock);
-
-  // 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();
-
   // Delete tasks that haven't run yet without running them.  Used in the
   // destructor to make sure all the task's destructors get called.  Returns
   // true if some work was done.
   bool DeletePendingTasks();
 
-  // Calculates the time at which a PendingTask should run.
-  TimeTicks CalculateDelayedRuntime(TimeDelta delay);
+  // Creates a process-wide unique ID to represent this task in trace events.
+  // This will be mangled with a Process ID hash to reduce the likelyhood of
+  // colliding with MessageLoop pointers on other processes.
+  uint64 GetTaskTraceID(const PendingTask& task);
+
+  // Loads tasks from the incoming queue to |work_queue_| if the latter is
+  // empty.
+  void ReloadWorkQueue();
+
+  // Wakes up the message pump. Can be called on any thread. The caller is
+  // responsible for synchronizing ScheduleWork() calls.
+  void ScheduleWork(bool was_empty);
 
   // Start recording histogram info about events and action IF it was enabled
   // and IF the statistics recorder can accept a registration of our histogram.
   void StartHistogrammer();
 
   // Add occurrence of event to our histogram, so that we can see what is being
   // done in a specific MessageLoop instance (i.e., specific thread).
   // If message_histogram_ is NULL, this is a no-op.
   void HistogramEvent(int event);
 
@@ skipping 14 matching lines @@
   // A recent snapshot of Time::Now(), used to check delayed_work_queue_.
   TimeTicks recent_time_;
 
   // A queue of non-nestable tasks that we had to defer because when it came
   // time to execute them we were in a nested message loop.  They will execute
   // once we're out of nested message loops.
   TaskQueue deferred_non_nestable_work_queue_;
 
   ObserverList<DestructionObserver> destruction_observers_;
 
+  bool exception_restoration_;
+
   // A recursion block that prevents accidentally running additional tasks when
   // insider a (accidentally induced?) nested message pump.
   bool nestable_tasks_allowed_;
 
-  bool exception_restoration_;
+#if defined(OS_WIN)
+  // Should be set to true before calling Windows APIs like TrackPopupMenu, etc
+  // which enter a modal message loop.
+  bool os_modal_loop_;
+#endif
 
   std::string thread_name_;
   // A profiling histogram showing the counts of various messages and events.
   HistogramBase* message_histogram_;
 
-  // An incoming queue of tasks that are acquired under a mutex for processing
-  // on this instance's thread. These tasks have not yet been sorted out into
-  // items for our work_queue_ vs delayed_work_queue_.
-  TaskQueue incoming_queue_;
-  // Protect access to incoming_queue_.
-  mutable Lock incoming_queue_lock_;
-
   RunLoop* run_loop_;
 
-#if defined(OS_WIN)
-  TimeTicks high_resolution_timer_expiration_;
-  // Should be set to true before calling Windows APIs like TrackPopupMenu, etc
-  // which enter a modal message loop.
-  bool os_modal_loop_;
-#endif
-
-  // The next sequence number to use for delayed tasks. Updating this counter is
-  // protected by incoming_queue_lock_.
-  int next_sequence_num_;
-
   ObserverList<TaskObserver> task_observers_;
 
-  // The message loop proxy associated with this message loop, if one exists.
-  scoped_refptr<MessageLoopProxy> message_loop_proxy_;
+  scoped_refptr<internal::IncomingTaskQueue> incoming_task_queue_;
+
+  // The message loop proxy associated with this message loop.
+  scoped_refptr<internal::MessageLoopProxyImpl> message_loop_proxy_;
   scoped_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_;
 
   template <class T, class R> friend class base::subtle::DeleteHelperInternal;
   template <class T, class R> friend class base::subtle::ReleaseHelperInternal;
 
   void DeleteSoonInternal(const tracked_objects::Location& from_here,
                           void(*deleter)(const void*),
                           const void* object);
   void ReleaseSoonInternal(const tracked_objects::Location& from_here,
                            void(*releaser)(const void*),
@@ skipping 175 matching lines @@
 
 // Do not add any member variables to MessageLoopForIO!  This is important b/c
 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO).  Any extra
 // data that you need should be stored on the MessageLoop's pump_ instance.
 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO),
                MessageLoopForIO_should_not_have_extra_member_variables);
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_