// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//    * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//    * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//    * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef BASE_MESSAGE_LOOP_H__
#define BASE_MESSAGE_LOOP_H__

#include <deque>
#include <queue>
#include <string>
#include <vector>

#include "base/histogram.h"
#include "base/observer_list.h"
#include "base/id_map.h"
#include "base/task.h"
#include "base/timer.h"
#include "base/thread_local_storage.h"

//
// A MessageLoop is used to process events for a particular thread.
// There is at most one MessageLoop instance per thread.
// Events include Windows Message Queue messages, Tasks submitted to PostTask
// or managed by TimerManager, APC calls (as time permits), and signals sent to
// a registered set of HANDLES.
// Processing events corresponds (respectively) to dispatching Windows messages,
// running Tasks, yielding time to APCs, and calling Watchers when the
// corresponding HANDLE is signaled.

//
// NOTE: Unless otherwise specified, a MessageLoop's methods may only be called
// on the thread where the MessageLoop's Run method executes.
//
// WARNING: MessageLoop has task reentrancy protection. This means that if a
// task is being processed, a second task cannot start until the first task is
// finished. Reentrancy can happen when processing a task, and an inner message
// pump is created.  That inner pump then processes windows messages which could
// implicitly start an inner task. Inner messages pumps are created with dialogs
// (DialogBox), common dialogs (GetOpenFileName), OLE functions (DoDragDrop),
// printer functions (StartDoc) and *many* others.
// Sample workaround when inner task processing is needed:
//   bool old_state = MessageLoop::current()->NestableTasksAllowed();
//   MessageLoop::current()->SetNestableTasksAllowed(true);
//   HRESULT hr = DoDragDrop(...); // Implicitly runs a modal message loop here.
//   MessageLoop::current()->SetNestableTasksAllowed(old_state);
//   // Process hr  (the result returned by DoDragDrop().
//
// Please be **SURE** your task is reentrant and all global variables are stable
// and accessible before calling SetNestableTasksAllowed(true).
//

// Message loop has several distinct functions.  It provides message pumps,
// responds to windows message dispatches, manipulates queues of Tasks.
// The most central operation is the implementation of message pumps, along with
// several subtleties.

// MessageLoop currently implements several different message pumps.  A message
// pump is (traditionally) something that reads from an incoming queue, and then
// dispatches the work.
//
// The first message pump, RunTraditional(), is among other things a
// traditional Windows Message pump.  It contains a nearly infinite loop that
// peeks out messages, and then dispatches them.
// Intermixed with those peeks are checks on a queue of Tasks, checks for
// signaled objects, and checks to see if TimerManager has tasks to run.
// When there are no events to be serviced, this pump goes into a wait state.
// For 99.99% of all events, this first message pump handles all processing.
//
// When a task, or windows event, invokes on the stack a native dialog box or
// such, that window typically provides a bare bones (native?) message pump.
// That bare-bones message pump generally supports little more than a peek of
// the Windows message queue, followed by a dispatch of the peeked message.
// MessageLoop extends that bare-bones message pump to also service Tasks, at
// the cost of some complexity.
// The basic structure of the extension (refered to as a sub-pump) is that a
// special message,kMsgPumpATask, is repeatedly injected into the Windows
// Message queue. Each time the kMsgPumpATask message is peeked, checks are made
// for an extended set of events, including the availability of Tasks to run.
//
// After running a task, the special message kMsgPumpATask is again posted to
// the Windows Message queue, ensuring a future time slice for processing a
// future event.
//
// To prevent flooding the Windows Message queue, care is taken to be sure that
// at most one kMsgPumpATask message is EVER pending in the Winow's Message
// queue.
//
// There are a few additional complexities in this system where, when there are
// no Tasks to run, this otherwise infinite stream of messages which drives the
// sub-pump is halted.  The pump is automatically re-started when Tasks are
// queued.
//
// A second complexity is that the presence of this stream of posted tasks may
// prevent a bare-bones message pump from ever peeking a WM_PAINT or WM_TIMER.
// Such paint and timer events always give priority to a posted message, such as
// kMsgPumpATask messages.  As a result, care is taken to do some peeking in
// between the posting of each kMsgPumpATask message (i.e., after kMsgPumpATask
// is peeked, and before a replacement kMsgPumpATask is posted).
//
//
// NOTE: Although it may seem odd that messages are used to start and stop this
// flow (as opposed to signaling objects, etc.), it should be understood that
// the native message pump will *only* respond to messages.  As a result, it is
// an excellent choice.  It is also helpful that the starter messages that are
// placed in the queue when new task arrive also awakens the RunTraditional()
// loop.

//------------------------------------------------------------------------------
class MessageLoop {
 public:

  // Select a non-default strategy for serving pending requests, that is to be
  // used by all MessageLoop instances.  This is called only once before
  // constructing any instances.
  static void SetStrategy(int strategy);
  static void EnableHistogrammer(bool enable_histogrammer);

#ifdef OS_WIN
  // Used with WatchObject to asynchronously monitor the signaled state of a
  // HANDLE object.
  class Watcher {
   public:
    virtual ~Watcher() {}
    // Called from MessageLoop::Run when a signalled object is detected.
    virtual void OnObjectSignaled(HANDLE object) = 0;
  };

  // Have the current thread's message loop watch for a signaled object.
  // Pass a null watcher to stop watching the object.
  bool WatchObject(HANDLE, Watcher*);

  // An Observer is an object that receives global notifications from the
  // MessageLoop.
  //
  // NOTE: An Observer implementation should be extremely fast!
  //
  class Observer {
   public:
    virtual ~Observer() {}

    // This method is called before processing a message.
    // The message may be undefined in which case msg.message is 0
    virtual void WillProcessMessage(const MSG& msg) = 0;

    // This method is called when control returns from processing a UI message.
    // The message may be undefined in which case msg.message is 0
    virtual void DidProcessMessage(const MSG& msg) = 0;
  };

  // Add an Observer, which will start receiving notifications immediately.
  void AddObserver(Observer* observer);

  // Remove an Observer.  It is safe to call this method while an Observer is
  // receiving a notification callback.
  void RemoveObserver(Observer* observer);

  // Give a chance to code processing additional messages to notify the
  // message loop observers that another message has been processed.
  void WillProcessMessage(const MSG& msg);
  void DidProcessMessage(const MSG& msg);

  // Dispatcher is used during a nested invocation of Run to dispatch events.
  // If Run is invoked with a non-NULL Dispatcher, MessageLoop does not
  // dispatch events (or invoke TranslateMessage), rather every message is
  // passed to Dispatcher's Dispatch method for dispatch. It is up to the
  // Dispatcher to dispatch, or not, the event.
  //
  // The nested loop is exited by either posting a quit, or returning false
  // from Dispatch.
  class Dispatcher {
   public:
    virtual ~Dispatcher() {}
    // Dispatches the event. If true is returned processing continues as
    // normal. If false is returned, the nested loop exits immediately.
    virtual bool Dispatch(const MSG& msg) = 0;
  };
#else  // !OS_WIN
  // On non-Windows platforms, the Dispatcher does not exist, but we allow the
  // typename to exist for convenience.  On non-Windows platforms, a Dispatcher
  // pointer should always be NULL.
  class Dispatcher;
#endif  // OS_*

  // A DestructionObserver is notified when the current MessageLoop is being
  // destroyed.  These obsevers are notified prior to MessageLoop::current()
  // being changed to return NULL.  This gives interested parties the chance to
  // do final cleanup that depends on the MessageLoop.
  //
  // NOTE: Any tasks posted to the MessageLoop during this notification will
  // not be run.  Instead, they will be deleted.
  //
  class DestructionObserver {
   public:
    virtual ~DestructionObserver() {}
    virtual void WillDestroyCurrentMessageLoop() = 0;
  };

  // Add a DestructionObserver, which will start receiving notifications
  // immediately.
  void AddDestructionObserver(DestructionObserver* destruction_observer);

  // Remove a DestructionObserver.  It is safe to call this method while a
  // DestructionObserver is receiving a notification callback.
  void RemoveDestructionObserver(DestructionObserver* destruction_observer);

  // Call the task's Run method asynchronously from within a message loop at
  // some point in the future.  With the PostTask variant, tasks are invoked in
  // FIFO order, inter-mixed with normal UI event processing.  With the
  // PostDelayedTask variant, tasks are called after at least approximately
  // 'delay_ms' have elapsed.
  //
  // The MessageLoop takes ownership of the Task, and deletes it after it
  // has been Run().
  //
  // NOTE: This method may be called on any thread.  The Task will be invoked
  // on the thread that executes MessageLoop::Run().

  void PostTask(const tracked_objects::Location& from_here, Task* task) {
    PostDelayedTask(from_here, task, 0);
  }

  void PostDelayedTask(const tracked_objects::Location& from_here, Task* task,
                       int delay_ms);

  // A variant on PostTask that deletes the given object.  This is useful
  // if the object needs to live until the next run of the MessageLoop (for
  // example, deleting a RenderProcessHost from within an IPC callback is not
  // good).
  //
  // NOTE: This method may be called on any thread.  The object will be deleted
  // on the thread that executes MessageLoop::Run().  If this is not the same
  // as the thread that calls PostDelayedTask(FROM_HERE, ), then T MUST inherit
  // from RefCountedThreadSafe<T>!
  template <class T>
  void DeleteSoon(const tracked_objects::Location& from_here, T* object) {
    PostTask(from_here, new DeleteTask<T>(object));
  }

  // A variant on PostTask that releases the given reference counted object
  // (by calling its Release method).  This is useful if the object needs to
  // live until the next run of the MessageLoop, or if the object needs to be
  // released on a particular thread.
  //
  // NOTE: This method may be called on any thread.  The object will be
  // released (and thus possibly deleted) on the thread that executes
  // MessageLoop::Run().  If this is not the same as the thread that calls
  // PostDelayedTask(FROM_HERE, ), then T MUST inherit from
  // RefCountedThreadSafe<T>!
  template <class T>
  void ReleaseSoon(const tracked_objects::Location& from_here, T* object) {
    PostTask(from_here, new ReleaseTask<T>(object));
  }

  // Run the message loop.
  void Run();

  // Process all pending tasks, windows messages, etc., but don't wait/sleep.
  // Return as soon as all items that can be run are taken care of.
  void RunAllPending();

  // See description of Dispatcher for how Run uses Dispatcher.
  void Run(Dispatcher* dispatcher);

  // Signals the Run method to return after it is done processing all pending
  // messages.  This method may be called from any thread, but no effort is
  // made to support concurrent calls to this method from multiple threads.
  //
  // For example, the first call to Quit may lead to the MessageLoop being
  // deleted once its Run method returns, so a second call from another thread
  // could be problematic.
  void Quit();

  // Invokes Quit on the current MessageLoop when run. Useful to schedule an
  // arbitrary MessageLoop to Quit.
  class QuitTask : public Task {
   public:
    virtual void Run() {
      MessageLoop::current()->Quit();
    }
  };

  // Normally, it is not necessary to instantiate a MessageLoop.  Instead, it
  // is typical to make use of the current thread's MessageLoop instance.
  MessageLoop();
  ~MessageLoop();

  // Optional call to connect the thread name with this loop.
  void SetThreadName(const std::string& thread_name);
  void set_thread_name(const std::string& name) { SetThreadName(name); }
  const std::string& thread_name() const { return thread_name_; }

  // Returns the MessageLoop object for the current thread, or null if none.
  static MessageLoop* current() {
    return static_cast<MessageLoop*>(ThreadLocalStorage::Get(tls_index_));
  }

  // Returns the TimerManager object for the current thread.
  TimerManager* timer_manager() { return &timer_manager_; }

  // 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.
  //
  // The specific case where tasks get queued is:
  // - The thread is running a message loop.
  // - It receives a task #1 and execute it.
  // - The task #1 implicitly start a message loop, like a MessageBox in the
  //   unit test. This can also be StartDoc or GetSaveFileName.
  // - The thread receives a task #2 before or while in this second message
  //   loop.
  // - With NestableTasksAllowed set to true, the task #2 will run right away.
  //   Otherwise, it will get executed right after task #1 completes at "thread
  //   message loop level".
  void SetNestableTasksAllowed(bool allowed);
  bool NestableTasksAllowed() const;

  // Enables or disables the restoration during an exception of the unhandled
  // exception filter that was active when Run() was called. This can happen
  // if some third party code call SetUnhandledExceptionFilter() and never
  // restores the previous filter.
  void set_exception_restoration(bool restore) {
    exception_restoration_ = restore;
  }

  // Public entry point for TimerManager to request the Run() of a task.  If we
  // created the task during an PostTask(FROM_HERE, ), then we will also perform
  // destructions, and we'll have the option of queueing the task.  If we didn't
  // create the timer, then we will Run it immediately.
  bool RunTimerTask(Timer* timer);

  // Since some Timer's are owned by MessageLoop, the TimerManager (when it is
  // being destructed) passses us the timers to discard (without doing a Run()).
  void DiscardTimer(Timer* timer);

  // Applications can call this to encourage us to process all pending WM_PAINT
  // messages.
  // This method will process all paint messages the Windows Message queue can
  // provide, up to some fixed number (to avoid any infinite loops).
  void PumpOutPendingPaintMessages();

  //----------------------------------------------------------------------------
 private:
  friend class TimerManager;  // So it can call DidChangeNextTimerExpiry

  struct ScopedStateSave {
    explicit ScopedStateSave(MessageLoop* loop)
        : loop_(loop),
          dispatcher_(loop->dispatcher_),
          quit_now_(loop->quit_now_),
          quit_received_(loop->quit_received_),
          run_depth_(loop->run_depth_) {
      loop->quit_now_ = loop->quit_received_ = false;
      ++loop->run_depth_;
    }

    ~ScopedStateSave() {
      loop_->run_depth_ = run_depth_;
      loop_->quit_received_ = quit_received_;
      loop_->quit_now_ = quit_now_;
      loop_->dispatcher_ = dispatcher_;
    }

   private:
    MessageLoop* loop_;
    Dispatcher* dispatcher_;
    bool quit_now_;
    bool quit_received_;
    int run_depth_;
  };  // struct ScopedStateSave

  // A prioritized queue with interface that mostly matches std::queue<>.
  // For debugging/performance testing, you can swap in std::queue<Task*>.
  class PrioritizedTaskQueue {
   public:
    PrioritizedTaskQueue() : next_sequence_number_(0) {}
    ~PrioritizedTaskQueue() {}
    void pop()    { queue_.pop(); }
    bool empty()  { return queue_.empty(); }
    size_t size() { return queue_.size(); }
    Task* front() { return queue_.top().task(); }
    void push(Task * task);

   private:
    class PrioritizedTask {
     public:
      PrioritizedTask(Task* task, int sequence_number)
        : task_(task),
          sequence_number_(sequence_number),
          priority_(task->priority()) {}
      Task* task() const { return task_; }
      bool operator < (PrioritizedTask const & right) const ;

     private:
      Task* task_;
      // Number to ensure (default) FIFO ordering in a PriorityQueue.
      int sequence_number_;
      // Priority of task when pushed.
      int priority_;
    };  // class PrioritizedTask

    std::priority_queue<PrioritizedTask> queue_;
    // Default sequence number used when push'ing (monotonically decreasing).
    int next_sequence_number_;
    DISALLOW_EVIL_CONSTRUCTORS(PrioritizedTaskQueue);
  };

  // Implementation of a TaskQueue as a null terminated list, with end pointers.
  class TaskQueue {
   public:
    TaskQueue() : first_(NULL), last_(NULL) {}
    void Push(Task* task);
    Task* Pop();  // Extract the next Task from the queue, and return it.
    bool Empty() const { return !first_; }
   private:
    Task* first_;
    Task* last_;
  };

  // Implementation of a Task queue that automatically switches into a priority
  // queue if it observes any non-zero priorities in tasks.
  class OptionallyPrioritizedTaskQueue {
   public:
    OptionallyPrioritizedTaskQueue() : use_priority_queue_(false) {}
    void Push(Task* task);
    Task* Pop();  // Extract next Task from queue, and return it.
    bool Empty();
    bool use_priority_queue() const { return use_priority_queue_; }

   private:
    bool use_priority_queue_;
    PrioritizedTaskQueue prioritized_queue_;
    TaskQueue queue_;
    DISALLOW_EVIL_CONSTRUCTORS(OptionallyPrioritizedTaskQueue);
  };

#ifdef OS_WIN
  void InitMessageWnd();

  // Windows procedure for message_hwnd_.
  static LRESULT CALLBACK WndProcThunk(
      HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
  LRESULT WndProc(
      HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
#endif  // OS_WIN

  // 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.
  void RunHandler(Dispatcher* dispatcher, bool non_blocking);

  // 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(Dispatcher* dispatcher, bool non_blocking);

  // An extended message loop (message pump) that loops mostly forever, and
  // processes task, signals, timers, etc.
  // If non-blocking is set, it will return rather than wait for new things to
  // arrive for processing.
  void RunTraditional(bool non_blocking);

  //----------------------------------------------------------------------------
  // A list of method wrappers with identical calling signatures (no arguments)
  // for use in the main message loop.  Method pointers to these methods may be
  // called round-robin from the main message loop, on any desired schedule.

  bool ProcessNextDeferredTask();
  bool ProcessNextDelayedNonNestableTask();
  bool ProcessNextObject();
  bool ProcessSomeTimers();

  //----------------------------------------------------------------------------
  // Process some pending messages.  Returns true if a message was processed.
  bool ProcessNextWindowsMessage();

  // Wait until either an object is signaled, a message is available, a timer
  // needs attention, or our incoming_queue_ has gotten a task.
  // Handle (without returning) any APCs (only IO thread currently has APCs.)
  void WaitForWork();

#ifdef OS_WIN
  // Helper function for processing window messages. This includes handling
  // WM_QUIT, message translation and dispatch, etc.
  //
  // If dispatcher_ is non-NULL this method does NOT dispatch the event, instead
  // it invokes Dispatch on the dispatcher_.
  bool ProcessMessageHelper(const MSG& msg);
#endif  // OS_WIN

  // When we encounter a kMsgPumpATask, the following helper can be called to
  // peek and process a replacement message, such as a WM_PAINT or WM_TIMER.
  // The goal is to make the kMsgPumpATask as non-intrusive as possible, even
  // though a continuous stream of such messages are posted.  This method
  // carefully peeks a message while there is no chance for a kMsgPumpATask to
  // be pending, then releases the lock (allowing a replacement kMsgPumpATask to
  // possibly be posted), and finally dispatches that peeked replacement.
  // Note that the re-post of kMsgPumpATask may be asynchronous to this thread!!
  bool ProcessPumpReplacementMessage();

  // Signals a watcher if a wait falls within the range of objects we're
  // waiting on.  object_index is the offset in objects_ that was signaled.
  // Returns true if an object was signaled.
  bool SignalWatcher(size_t object_index);

  // Run a work_queue_ task or new_task, and delete it (if it was processed by
  // PostTask). If there are queued tasks, the oldest one is executed and
  // new_task is queued. new_task is optional and can be NULL. In this NULL
  // case, the method will run one pending task (if any exist). Returns true if
  // it executes a task.
  // Queued tasks accumulate only when there is a nonreentrant task currently
  // processing, in which case the new_task is appended to the list
  // work_queue_.  Such re-entrancy generally happens when an unrequested
  // message pump (typical of a native dialog) is executing in the context of a
  // task.
  bool QueueOrRunTask(Task* new_task);

  // Runs the specified task and deletes it.
  void RunTask(Task* task);

  // Make state adjustments just before and after running tasks so that we can
  // continue to work if a native message loop is employed during a task.
  void BeforeTaskRunSetup();
  void AfterTaskRunRestore();

  // When processing messages in our MessageWndProc(), we are sometimes called
  // by a native message pump (i.e., We are not called out of our Run() pump).
  // In those cases, we need to process tasks during the Windows Message
  // callback.  This method processes a task, and also posts a new kMsgPumpATask
  // messages to the Windows Msg Queue so that we are called back later (to
  // process additional tasks).
  void PumpATaskDuringWndProc();

  // 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.
  void DeletePendingTasks();

  // Make sure a kPumpATask message is in flight, which starts/continues the
  // sub-pump.
  void EnsurePumpATaskWasPosted();

  // Do a PostMessage(), and crash if we can't eventually do the post.
  void EnsureMessageGetsPosted(int message) const;

  // Post a task to our incomming queue.
  void PostTaskInternal(Task* task);

  // Called by the TimerManager when its next timer changes.
  void DidChangeNextTimerExpiry();

  // 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 occurence 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);

  static TLSSlot tls_index_;
  static int strategy_selector_;
  static const LinearHistogram::DescriptionPair event_descriptions_[];
  static bool enable_histogrammer_;

  TimerManager timer_manager_;

  // A list of tasks that need to be processed by this instance.  Note that this
  // queue is only accessed (push/pop) by our current thread.
  // As an optimization, when we don't need to use the prioritization of
  // work_queue_, we use a null terminated list (TaskQueue) as our
  // implementation of the queue. This saves on memory (list uses pointers
  // internal to Task) and probably runs faster than the priority queue when
  // there was no real prioritization.
  OptionallyPrioritizedTaskQueue work_queue_;

#ifdef OS_WIN
  HWND message_hwnd_;

  // A vector of objects (and corresponding watchers) that are routinely
  // serviced by this message loop's pump.
  std::vector<HANDLE> objects_;
  std::vector<Watcher*> watchers_;

  ObserverList<Observer> observers_;
#endif  // OS_WIN

  ObserverList<DestructionObserver> destruction_observers_;
  IDMap<Task> timed_tasks_;
  // A recursion block that prevents accidentally running additonal tasks when
  // insider a (accidentally induced?) nested message pump.
  bool nestable_tasks_allowed_;

  bool exception_restoration_;

  Dispatcher* dispatcher_;
  bool quit_received_;
  bool quit_now_;

  std::string thread_name_;
  // A profiling histogram showing the counts of various messages and events.
  scoped_ptr<LinearHistogram> message_histogram_;

  // A null terminated list which creates an incoming_queue of tasks that are
  // aquired 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 items that
  // will be handled by the TimerManager.
  TaskQueue incoming_queue_;
  // Protect access to incoming_queue_.
  Lock incoming_queue_lock_;

  // A null terminated list of non-nestable tasks that we had to delay 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 delayed_non_nestable_queue_;

  // Indicate if there is a kMsgPumpATask message pending in the Windows Message
  // queue.  There is at most one such message, and it can drive execution of
  // tasks when a native message pump is running.
  bool task_pump_message_pending_;
  // Protect access to task_pump_message_pending_.
  Lock task_pump_message_lock_;

  // Used to count how many Run() invocations are on the stack.
  int run_depth_;

  DISALLOW_EVIL_CONSTRUCTORS(MessageLoop);
};

#endif  // BASE_MESSAGE_LOOP_H__