rollback portions of r928 to test to see if it impacts perf

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@936 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 858 insertions, 251 deletions

diff --git a/base/message_loop.cc b/base/message_loop.cc
index b920167..18f4448 100644
--- a/base/message_loop.cc
+++ b/base/message_loop.cc
@@ -27,13 +27,14 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include "base/message_loop.h"
-
 #include <algorithm>
 
+#include "base/message_loop.h"
+
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/thread_local_storage.h"
+#include "base/win_util.h"
 
 // a TLS index to the message loop for the current thread
 // Note that if we start doing complex stuff in other static initializers
@@ -42,10 +43,25 @@
 
 //------------------------------------------------------------------------------
 
+static const wchar_t kWndClass[] = L"Chrome_MessageLoopWindow";
+
+// Windows Message numbers handled by WindowMessageProc.
+
+// Message sent to get an additional time slice for pumping (processing) another
+// task (a series of such messages creates a continuous task pump).
+static const int kMsgPumpATask =        WM_USER + 1;
+
+// Message sent by Quit() to cause our main message pump to terminate as soon as
+// all pending task and message queues have been emptied.
+static const int kMsgQuit =             WM_USER + 2;
+
 // Logical events for Histogram profiling. Run with -message-loop-histogrammer
 // to get an accounting of messages and actions taken on each thread.
-static const int kTaskRunEvent = 0x1;
-static const int kTimerEvent = 0x2;
+static const int kTaskRunEvent =        WM_USER + 16;  // 0x411
+static const int kSleepingApcEvent =    WM_USER + 17;  // 0x411
+static const int kPollingSignalEvent =  WM_USER + 18;  // 0x412
+static const int kSleepingSignalEvent = WM_USER + 19;  // 0x413
+static const int kTimerEvent =          WM_USER + 20;  // 0x414
 
 // Provide range of message IDs for use in histogramming and debug display.
 static const int kLeastNonZeroMessageId = 1;
@@ -54,8 +70,26 @@ static const int kNumberOfDistinctMessagesDisplayed = 1100;
 
 //------------------------------------------------------------------------------
 
-#if defined(OS_WIN)
+#ifndef NDEBUG
+// Force exercise of polling model.
+#define CHROME_MAXIMUM_WAIT_OBJECTS 8
+#else
+#define CHROME_MAXIMUM_WAIT_OBJECTS MAXIMUM_WAIT_OBJECTS
+#endif
 
+//------------------------------------------------------------------------------
+// A strategy of -1 uses the default case. All strategies are selected as
+// positive integers.
+// static
+int MessageLoop::strategy_selector_ = -1;
+
+// static
+void MessageLoop::SetStrategy(int strategy) {
+  DCHECK(-1 == strategy_selector_);
+  strategy_selector_ = strategy;
+}
+
+//------------------------------------------------------------------------------
 // Upon a SEH exception in this thread, it restores the original unhandled
 // exception filter.
 static int SEHFilter(LPTOP_LEVEL_EXCEPTION_FILTER old_filter) {
@@ -72,22 +106,23 @@ static LPTOP_LEVEL_EXCEPTION_FILTER GetTopSEHFilter() {
   return top_filter;
 }
 
-#endif  // defined(OS_WIN)
-
 //------------------------------------------------------------------------------
 
 MessageLoop::MessageLoop()
 #pragma warning(suppress: 4355)  // OK, to use |this| in the initializer list.
     : timer_manager_(this),
+      message_hwnd_(NULL),
       exception_restoration_(false),
       nestable_tasks_allowed_(true),
-      state_(NULL) {
+      dispatcher_(NULL),
+      quit_received_(false),
+      quit_now_(false),
+      task_pump_message_pending_(false),
+      run_depth_(0) {
   DCHECK(tls_index_) << "static initializer failed";
   DCHECK(!current()) << "should only have one message loop per thread";
   ThreadLocalStorage::Set(tls_index_, this);
-#if defined(OS_WIN)
-  pump_ = new base::MessagePumpWin();
-#endif
+  InitMessageWnd();
 }
 
 MessageLoop::~MessageLoop() {
@@ -100,7 +135,8 @@ MessageLoop::~MessageLoop() {
   // OK, now make it so that no one can find us.
   ThreadLocalStorage::Set(tls_index_, NULL);
 
-  DCHECK(!state_);
+  DCHECK(!dispatcher_);
+  DCHECK(!quit_received_ && !quit_now_);
 
   // Most tasks that have not been Run() are deleted in the |timer_manager_|
   // destructor after we remove our tls index.  We delete the tasks in our
@@ -111,6 +147,12 @@ MessageLoop::~MessageLoop() {
   DeletePendingTasks();
 }
 
+void MessageLoop::SetThreadName(const std::string& thread_name) {
+  DCHECK(thread_name_.empty());
+  thread_name_ = thread_name;
+  StartHistogrammer();
+}
+
 void MessageLoop::AddDestructionObserver(DestructionObserver *obs) {
   DCHECK(this == current());
   destruction_observers_.AddObserver(obs);
@@ -121,23 +163,26 @@ void MessageLoop::RemoveDestructionObserver(DestructionObserver *obs) {
   destruction_observers_.RemoveObserver(obs);
 }
 
+void MessageLoop::AddObserver(Observer *obs) {
+  DCHECK(this == current());
+  observers_.AddObserver(obs);
+}
+
+void MessageLoop::RemoveObserver(Observer *obs) {
+  DCHECK(this == current());
+  observers_.RemoveObserver(obs);
+}
+
 void MessageLoop::Run() {
-  AutoRunState save_state(this);
-  RunHandler();
+  RunHandler(NULL, false);
 }
 
-#if defined(OS_WIN)
-void MessageLoop::Run(base::MessagePumpWin::Dispatcher* dispatcher) {
-  AutoRunState save_state(this);
-  state_->dispatcher = dispatcher;
-  RunHandler();
+void MessageLoop::Run(Dispatcher* dispatcher) {
+  RunHandler(dispatcher, false);
 }
-#endif
 
 void MessageLoop::RunAllPending() {
-  AutoRunState save_state(this);
-  state_->quit_received = true;  // Means run until we would otherwise block.
-  RunHandler();
+  RunHandler(NULL, true);
 }
 
 // Runs the loop in two different SEH modes:
@@ -145,43 +190,94 @@ void MessageLoop::RunAllPending() {
 // one that calls SetUnhandledExceptionFilter().
 // enable_SEH_restoration_ = true : any unhandled exception goes to the filter
 // that was existed before the loop was run.
-void MessageLoop::RunHandler() {
-#if defined(OS_WIN)
+void MessageLoop::RunHandler(Dispatcher* dispatcher, bool non_blocking) {
   if (exception_restoration_) {
     LPTOP_LEVEL_EXCEPTION_FILTER current_filter = GetTopSEHFilter();
     __try {
-      RunInternal();
+      RunInternal(dispatcher, non_blocking);
     } __except(SEHFilter(current_filter)) {
     }
-    return;
+  } else {
+    RunInternal(dispatcher, non_blocking);
   }
-#endif
-
-  RunInternal();
 }
 
 //------------------------------------------------------------------------------
+// IF this was just a simple PeekMessage() loop (servicing all passible work
+// queues), then Windows would try to achieve the following order according to
+// MSDN documentation about PeekMessage with no filter):
+//    * Sent messages
+//    * Posted messages
+//    * Sent messages (again)
+//    * WM_PAINT messages
+//    * WM_TIMER messages
+//
+// Summary: none of the above classes is starved, and sent messages has twice
+// the chance of being processed (i.e., reduced service time).
+
+void MessageLoop::RunInternal(Dispatcher* dispatcher, bool non_blocking) {
+  // Preserve ability to be called recursively.
+  ScopedStateSave save(this);  // State is restored on exit.
+  dispatcher_ = dispatcher;
+  StartHistogrammer();
 
-void MessageLoop::RunInternal() {
   DCHECK(this == current());
+  //
+  // Process pending messages and signaled objects.
+  //
+  // Flush these queues before exiting due to a kMsgQuit or else we risk not
+  // shutting down properly as some operations may depend on further event
+  // processing. (Note: some tests may use quit_now_ to exit more swiftly,
+  // and leave messages pending, so don't assert the above fact).
+  RunTraditional(non_blocking);
+  DCHECK(non_blocking || quit_received_ || quit_now_);
+}
 
-  StartHistogrammer();
+void MessageLoop::RunTraditional(bool non_blocking) {
+  for (;;) {
+    // If we do any work, we may create more messages etc., and more work
+    // may possibly be waiting in another task group.  When we (for example)
+    // ProcessNextWindowsMessage(), there is a good chance there are still more
+    // messages waiting (same thing for ProcessNextObject(), which responds to
+    // only one signaled object; etc.).  On the other hand, when any of these
+    // methods return having done no work, then it is pretty unlikely that
+    // calling them again quickly will find any work to do.
+    // Finally, if they all say they had no work, then it is a good time to
+    // consider sleeping (waiting) for more work.
+    bool more_work_is_plausible = ProcessNextWindowsMessage();
+    if (quit_now_)
+      return;
 
-#if defined(OS_WIN)
-  if (state_->dispatcher) {
-    pump_win()->RunWithDispatcher(this, state_->dispatcher);
-    return;
+    more_work_is_plausible |= ProcessNextDeferredTask();
+    more_work_is_plausible |= ProcessNextObject();
+    if (more_work_is_plausible)
+      continue;
+
+    if (quit_received_)
+      return;
+
+    // Run any timer that is ready to run. It may create messages etc.
+    if (ProcessSomeTimers())
+      continue;
+
+    // We run delayed non nestable tasks only after all nestable tasks have
+    // run, to preserve FIFO ordering.
+    if (ProcessNextDelayedNonNestableTask())
+      continue;
+
+    if (non_blocking)
+      return;
+
+    // We service APCs in WaitForWork, without returning.
+    WaitForWork();  // Wait (sleep) until we have work to do again.
   }
-#endif
-  
-  pump_->Run(this);
 }
 
 //------------------------------------------------------------------------------
 // Wrapper functions for use in above message loop framework.
 
 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
-  if (state_->run_depth != 1)
+  if (run_depth_ != 1)
     return false;
 
   if (delayed_non_nestable_queue_.Empty())
@@ -203,12 +299,41 @@ bool MessageLoop::ProcessSomeTimers() {
 //------------------------------------------------------------------------------
 
 void MessageLoop::Quit() {
-  DCHECK(current() == this);
-  if (state_) {
-    state_->quit_received = true;
-  } else {
-    NOTREACHED() << "Must be inside Run to call Quit";
+  EnsureMessageGetsPosted(kMsgQuit);
+}
+
+bool MessageLoop::WatchObject(HANDLE object, Watcher* watcher) {
+  DCHECK(this == current());
+  DCHECK(object);
+  DCHECK_NE(object, INVALID_HANDLE_VALUE);
+
+  std::vector<HANDLE>::iterator it = find(objects_.begin(), objects_.end(),
+                                          object);
+  if (watcher) {
+    if (it == objects_.end()) {
+     static size_t warning_multiple = 1;
+     if (objects_.size() >= warning_multiple * MAXIMUM_WAIT_OBJECTS / 2) {
+       LOG(INFO) << "More than " << warning_multiple * MAXIMUM_WAIT_OBJECTS / 2
+           << " objects being watched";
+       // This DCHECK() is an artificial limitation, meant to warn us if we
+       // start creating too many objects.  It can safely be raised to a higher
+       // level, and the program is designed to handle much larger values.
+       // Before raising this limit, make sure that there is a very good reason
+       // (in your debug testing) to be watching this many objects.
+       DCHECK(2 <= warning_multiple);
+       ++warning_multiple;
+      }
+      objects_.push_back(object);
+      watchers_.push_back(watcher);
+    } else {
+      watchers_[it - objects_.begin()] = watcher;
+    }
+  } else if (it != objects_.end()) {
+    std::vector<HANDLE>::difference_type index = it - objects_.begin();
+    objects_.erase(it);
+    watchers_.erase(watchers_.begin() + index);
   }
+  return true;
 }
 
 // Possibly called on a background thread!
@@ -227,23 +352,88 @@ void MessageLoop::PostTaskInternal(Task* task) {
   // directly, as it could starve handling of foreign threads.  Put every task
   // into this queue.
 
-  scoped_refptr<base::MessagePump> pump;
+  // Local stack variables to use IF we need to process after releasing locks.
+  HWND message_hwnd;
   {
-    AutoLock locked(incoming_queue_lock_);
-
+    AutoLock lock1(incoming_queue_lock_);
     bool was_empty = incoming_queue_.Empty();
     incoming_queue_.Push(task);
     if (!was_empty)
       return;  // Someone else should have started the sub-pump.
 
-    pump = pump_;
+    // We may have to start the sub-pump.
+    AutoLock lock2(task_pump_message_lock_);
+    if (task_pump_message_pending_)
+      return;  // Someone else continued the pumping.
+    task_pump_message_pending_ = true;  // We'll send one.
+    message_hwnd = message_hwnd_;
+  }  // Release both locks.
+  // We may have just posted a kMsgQuit, and so this instance may now destroyed!
+  // Do not invoke non-static methods, or members in any way!
+
+  // PostMessage may fail, as the hwnd may have vanished due to kMsgQuit.
+  PostMessage(message_hwnd, kMsgPumpATask, 0, 0);
+}
+
+void MessageLoop::InitMessageWnd() {
+  HINSTANCE hinst = GetModuleHandle(NULL);
+
+  WNDCLASSEX wc = {0};
+  wc.cbSize = sizeof(wc);
+  wc.lpfnWndProc = WndProcThunk;
+  wc.hInstance = hinst;
+  wc.lpszClassName = kWndClass;
+  RegisterClassEx(&wc);
+
+  message_hwnd_ = CreateWindow(kWndClass, 0, 0, 0, 0, 0, 0, HWND_MESSAGE, 0,
+                               hinst, 0);
+  DCHECK(message_hwnd_);
+}
+
+// static
+LRESULT CALLBACK MessageLoop::WndProcThunk(
+    HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+  DCHECK(MessageLoop::current());
+  return MessageLoop::current()->WndProc(hwnd, message, wparam, lparam);
+}
+
+LRESULT MessageLoop::WndProc(
+    HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+  if (hwnd == message_hwnd_) {
+    switch (message) {
+      case kMsgPumpATask: {
+        ProcessPumpReplacementMessage();  // Avoid starving paint and timer.
+        if (!nestable_tasks_allowed_)
+          return 0;
+        PumpATaskDuringWndProc();
+        return 0;
+      }
+
+      case WM_TIMER:
+        ProcessSomeTimers();         // Give the TimerManager a tickle.
+        DidChangeNextTimerExpiry();  // Maybe generate another WM_TIMER.
+        return 0;
+
+      case kMsgQuit: {
+        // TODO(jar): bug 1300541 The following assert should be used, but
+        // currently too much code actually triggers the assert, especially in
+        // tests :-(.
+        // Discarding a second quit will cause a hang.
+        //CHECK(!quit_received_);
+        quit_received_ = true;
+        return 0;
+      }
+    }
   }
-  // Since the incoming_queue_ may contain a task that destroys this message
-  // loop, we cannot exit incoming_queue_lock_ until we are done with |this|.
-  // We use a stack-based reference to the message pump so that we can call
-  // ScheduleWork outside of incoming_queue_lock_.
+  return ::DefWindowProc(hwnd, message, wparam, lparam);
+}
+
+void MessageLoop::WillProcessMessage(const MSG& msg) {
+  FOR_EACH_OBSERVER(Observer, observers_, WillProcessMessage(msg));
+}
 
-  pump->ScheduleWork();
+void MessageLoop::DidProcessMessage(const MSG& msg) {
+  FOR_EACH_OBSERVER(Observer, observers_, DidProcessMessage(msg));
 }
 
 void MessageLoop::SetNestableTasksAllowed(bool allowed) {
@@ -252,7 +442,7 @@ void MessageLoop::SetNestableTasksAllowed(bool allowed) {
     if (!nestable_tasks_allowed_)
       return;
     // Start the native pump if we are not already pumping.
-    pump_->ScheduleWork();
+    EnsurePumpATaskWasPosted();
   }
 }
 
@@ -260,7 +450,215 @@ bool MessageLoop::NestableTasksAllowed() const {
   return nestable_tasks_allowed_;
 }
 
+bool MessageLoop::ProcessNextWindowsMessage() {
+  MSG msg;
+  if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+    return ProcessMessageHelper(msg);
+  }
+  return false;
+}
+
+bool MessageLoop::ProcessMessageHelper(const MSG& msg) {
+  HistogramEvent(msg.message);
+
+  if (WM_QUIT == msg.message) {
+    // Repost the QUIT message so that it will be retrieved by the primary
+    // GetMessage() loop.
+    quit_now_ = true;
+    PostQuitMessage(static_cast<int>(msg.wParam));
+    return false;
+  }
+
+  // While running our main message pump, we discard kMsgPumpATask messages.
+  if  (msg.message == kMsgPumpATask && msg.hwnd == message_hwnd_)
+    return ProcessPumpReplacementMessage();
+
+  WillProcessMessage(msg);
+
+  if (dispatcher_) {
+    if (!dispatcher_->Dispatch(msg))
+      quit_now_ = true;
+  } else {
+    TranslateMessage(&msg);
+    DispatchMessage(&msg);
+  }
+
+  DidProcessMessage(msg);
+  return true;
+}
+
+bool MessageLoop::ProcessPumpReplacementMessage() {
+  MSG msg;
+  bool have_message = (0 != PeekMessage(&msg, NULL, 0, 0, PM_REMOVE));
+  DCHECK(!have_message || kMsgPumpATask != msg.message
+         || msg.hwnd != message_hwnd_);
+  {
+    // Since we discarded a kMsgPumpATask message, we must update the flag.
+    AutoLock lock(task_pump_message_lock_);
+    DCHECK(task_pump_message_pending_);
+    task_pump_message_pending_ = false;
+  }
+  return have_message && ProcessMessageHelper(msg);
+}
+
+// Create a mini-message-pump to force immediate processing of only Windows
+// WM_PAINT messages.
+void MessageLoop::PumpOutPendingPaintMessages() {
+  // Don't provide an infinite loop, but do enough peeking to get the job done.
+  // Actual common max is 4 peeks, but we'll be a little safe here.
+  const int kMaxPeekCount = 20;
+  int peek_count;
+  bool win2k(true);
+  if (win_util::GetWinVersion() > win_util::WINVERSION_2000)
+    win2k = false;
+  for (peek_count = 0; peek_count < kMaxPeekCount; ++peek_count) {
+    MSG msg;
+    if (win2k) {
+      if (!PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_REMOVE))
+        break;
+    } else {
+      if (!PeekMessage(&msg, NULL, 0, 0, PM_REMOVE | PM_QS_PAINT))
+        break;
+    }
+    ProcessMessageHelper(msg);
+    if (quit_now_ )  // Handle WM_QUIT.
+      break;
+  }
+  // Histogram what was really being used, to help to adjust kMaxPeekCount.
+  DHISTOGRAM_COUNTS(L"Loop.PumpOutPendingPaintMessages Peeks", peek_count);
+}
+
 //------------------------------------------------------------------------------
+// If we handle more than the OS limit on the number of objects that can be
+// waited for, we'll need to poll (sequencing through subsets of the objects
+// that can be passed in a single OS wait call).  The following is the polling
+// interval used in that (unusual) case. (I don't have a lot of justifcation
+// for the specific value, but it needed to be short enough that it would not
+// add a lot of latency, and long enough that we wouldn't thrash the CPU for no
+// reason... especially considering the silly user probably has a million tabs
+// open, etc.)
+static const int kMultipleWaitPollingInterval = 20;
+
+void MessageLoop::WaitForWork() {
+  bool original_can_run = nestable_tasks_allowed_;
+  int wait_flags = original_can_run ? MWMO_ALERTABLE | MWMO_INPUTAVAILABLE
+                                    : MWMO_INPUTAVAILABLE;
+
+  bool use_polling = false;  // Poll if too many objects for one OS Wait call.
+  for (;;) {
+    // Do initialization here, in case APC modifies object list.
+    size_t total_objs = original_can_run ? objects_.size() : 0;
+
+    int delay;
+    size_t polling_index = 0;  // The first unprocessed object index.
+    do {
+      size_t objs_len =
+          (polling_index < total_objs) ? total_objs - polling_index : 0;
+      if (objs_len >= CHROME_MAXIMUM_WAIT_OBJECTS) {
+        objs_len = CHROME_MAXIMUM_WAIT_OBJECTS - 1;
+        use_polling = true;
+      }
+      HANDLE* objs = objs_len ? polling_index + &objects_.front() : NULL;
+
+      // Only wait up to the time needed by the timer manager to fire the next
+      // set of timers.
+      delay = timer_manager_.GetCurrentDelay();
+      if (use_polling && delay > kMultipleWaitPollingInterval)
+        delay = kMultipleWaitPollingInterval;
+      if (delay < 0)  // Negative value means no timers waiting.
+        delay = INFINITE;
+
+      DWORD result;
+      result = MsgWaitForMultipleObjectsEx(static_cast<DWORD>(objs_len), objs,
+                                           delay, QS_ALLINPUT, wait_flags);
+
+      if (WAIT_IO_COMPLETION == result) {
+        HistogramEvent(kSleepingApcEvent);
+        // We'll loop here when we service an APC.  At it currently stands,
+        // *ONLY* the IO thread uses *any* APCs, so this should have no impact
+        // on the UI thread.
+        break;  // Break to outer loop, and waitforwork() again.
+      }
+
+      // Use unsigned type to simplify range detection;
+      size_t signaled_index = result - WAIT_OBJECT_0;
+      if (signaled_index < objs_len) {
+        SignalWatcher(polling_index + signaled_index);
+        HistogramEvent(kSleepingSignalEvent);
+        return;  // We serviced a signaled object.
+      }
+
+      if (objs_len == signaled_index)
+        return;  // A WM_* message is available.
+
+      DCHECK_NE(WAIT_FAILED, result) << GetLastError();
+
+      DCHECK(!objs || result == WAIT_TIMEOUT);
+      if (!use_polling)
+        return;
+      polling_index += objs_len;
+    } while (polling_index < total_objs);
+    // For compatibility, we didn't return sooner.  This made us do *some* wait
+    // call(s) before returning. This will probably change in next rev.
+    if (!delay || !timer_manager_.GetCurrentDelay())
+      return;  // No work done, but timer is ready to fire.
+  }
+}
+
+// Note: MsgWaitMultipleObjects() can't take a nil list, and that is why I had
+// to use SleepEx() to handle APCs when there were no objects.
+bool MessageLoop::ProcessNextObject() {
+  if (!nestable_tasks_allowed_)
+    return false;
+
+  size_t total_objs = objects_.size();
+  if (!total_objs) {
+    return false;
+  }
+
+  size_t polling_index = 0;  // The first unprocessed object index.
+  do {
+    DCHECK(polling_index < total_objs);
+    size_t objs_len = total_objs - polling_index;
+    if (objs_len >= CHROME_MAXIMUM_WAIT_OBJECTS)
+      objs_len = CHROME_MAXIMUM_WAIT_OBJECTS - 1;
+    HANDLE* objs = polling_index + &objects_.front();
+
+    // Identify 1 pending object, or allow an IO APC to be completed.
+    DWORD result = WaitForMultipleObjectsEx(static_cast<DWORD>(objs_len), objs,
+                                            FALSE,    // 1 signal is sufficient.
+                                            0,        // Wait 0ms.
+                                            false);  // Not alertable (no APC).
+
+    // Use unsigned type to simplify range detection;
+    size_t signaled_index = result - WAIT_OBJECT_0;
+    if (signaled_index < objs_len) {
+      SignalWatcher(polling_index + signaled_index);
+      HistogramEvent(kPollingSignalEvent);
+      return true;  // We serviced a signaled object.
+    }
+
+    // If an handle is invalid, it will be WAIT_FAILED.
+    DCHECK_EQ(WAIT_TIMEOUT, result) << GetLastError();
+    polling_index += objs_len;
+  } while (polling_index < total_objs);
+  return false;  // We serviced nothing.
+}
+
+bool MessageLoop::SignalWatcher(size_t object_index) {
+  BeforeTaskRunSetup();
+  DCHECK(objects_.size() > object_index);
+  // On reception of OnObjectSignaled() to a Watcher object, it may call
+  // WatchObject(). watchers_ and objects_ will be modified. This is
+  // expected, so don't be afraid if, while tracing a OnObjectSignaled()
+  // function, the corresponding watchers_[result] is inexistant.
+  watchers_[object_index]->OnObjectSignaled(objects_[object_index]);
+  // Signaled objects tend to be removed from the watch list, and then added
+  // back (appended).  As a result, they move to the end of the objects_ array,
+  // and this should make their service "fair" (no HANDLEs should be starved).
+  AfterTaskRunRestore();
+  return true;
+}
 
 bool MessageLoop::RunTimerTask(Timer* timer) {
   HistogramEvent(kTimerEvent);
@@ -307,15 +705,16 @@ bool MessageLoop::QueueOrRunTask(Task* new_task) {
   // Execute oldest task.
   while (!work_queue_.Empty()) {
     Task* task = work_queue_.Pop();
-    if (task->nestable() || state_->run_depth == 1) {
+    if (task->nestable() || run_depth_ == 1) {
       RunTask(task);
       // Show that we ran a task (Note: a new one might arrive as a
       // consequence!).
       return true;
+    } else {
+      // We couldn't run the task now because we're in a nested message loop
+      // and the task isn't nestable.
+      delayed_non_nestable_queue_.Push(task);
     }
-    // We couldn't run the task now because we're in a nested message loop
-    // and the task isn't nestable.
-    delayed_non_nestable_queue_.Push(task);
   }
 
   // Nothing happened.
@@ -344,12 +743,54 @@ void MessageLoop::AfterTaskRunRestore() {
   nestable_tasks_allowed_ = true;
 }
 
+void MessageLoop::PumpATaskDuringWndProc() {
+  // TODO(jar): Perchance we should check on signaled objects here??
+  // Signals are generally starved during a native message loop.  Even if we
+  // try to service a signaled object now, we wouldn't automatically get here
+  // (i.e., the native pump would not re-start) when the next object was
+  // signaled. If we really want to avoid starving signaled objects, we need
+  // to translate them into Tasks that can be passed in via PostTask.
+  // If these native message loops (and sub-pumping activities) are short
+  // lived, then the starvation won't be that long :-/.
+
+  if (!ProcessNextDeferredTask())
+    return;  // Nothing to do, so lets stop the sub-pump.
+
+  // We ran a task, so make sure we come back and try to run more tasks.
+  EnsurePumpATaskWasPosted();
+}
+
+void MessageLoop::EnsurePumpATaskWasPosted() {
+  {
+    AutoLock lock(task_pump_message_lock_);
+    if (task_pump_message_pending_)
+      return;  // Someone else continued the pumping.
+    task_pump_message_pending_ = true;  // We'll send one.
+  }
+  EnsureMessageGetsPosted(kMsgPumpATask);
+}
+
+void MessageLoop::EnsureMessageGetsPosted(int message) const {
+  const int kRetryCount = 30;
+  const int kSleepDurationWhenFailing = 100;
+  for (int i = 0; i < kRetryCount; ++i) {
+    // Posting to our own windows should always succeed.  If it doesn't we're in
+    // big trouble.
+    if (PostMessage(message_hwnd_, message, 0, 0))
+      return;
+    Sleep(kSleepDurationWhenFailing);
+  }
+  LOG(FATAL) << "Crash with last error " << GetLastError();
+  int* p = NULL;
+  *p = 0;  // Crash.
+}
+
 void MessageLoop::ReloadWorkQueue() {
   // We can improve performance of our loading tasks from incoming_queue_ to
-  // work_queue_ by waiting until the last minute (work_queue_ is empty) to
-  // load.  That reduces the number of locks-per-task significantly when our
-  // queues get large.  The optimization is disabled on threads that make use
-  // of the priority queue (prioritization requires all our tasks to be in the
+  // work_queue_ by wating until the last minute (work_queue_ is empty) to load.
+  // That reduces the number of locks-per-task significantly when our queues get
+  // large.  The optimization is disabled on threads that make use of the
+  // priority queue (prioritization requires all our tasks to be in the
   // work_queue_ ASAP).
   if (!work_queue_.Empty() && !work_queue_.use_priority_queue())
     return;  // Wait till we *really* need to lock and load.
@@ -392,78 +833,42 @@ void MessageLoop::DeletePendingTasks() {
 }
 
 void MessageLoop::DidChangeNextTimerExpiry() {
+#if defined(OS_WIN)
+  //
+  // We would *like* to provide high resolution timers.  Windows timers using
+  // SetTimer() have a 10ms granularity.  We have to use WM_TIMER as a wakeup
+  // mechanism because the application can enter modal windows loops where it
+  // is not running our MessageLoop; the only way to have our timers fire in
+  // these cases is to post messages there.
+  //
+  // To provide sub-10ms timers, we process timers directly from our run loop.
+  // For the common case, timers will be processed there as the run loop does
+  // its normal work.  However, we *also* set the system timer so that WM_TIMER
+  // events fire.  This mops up the case of timers not being able to work in
+  // modal message loops.  It is possible for the SetTimer to pop and have no
+  // pending timers, because they could have already been processed by the
+  // run loop itself.
+  //
+  // We use a single SetTimer corresponding to the timer that will expire
+  // soonest.  As new timers are created and destroyed, we update SetTimer.
+  // Getting a spurrious SetTimer event firing is benign, as we'll just be
+  // processing an empty timer queue.
+  //
   int delay = timer_manager_.GetCurrentDelay(); 
-  if (delay == -1)
-    return;
-
-  // Simulates malfunctioning, early firing timers. Pending tasks should only
-  // be invoked when the delay they specify has elapsed.
-  if (timer_manager_.use_broken_delay())
-    delay = 10;
-
-  pump_->ScheduleDelayedWork(TimeDelta::FromMilliseconds(delay));
-}
-
-bool MessageLoop::DoWork() {
-  if (ProcessNextDeferredTask()) {
-    // TODO(darin): Temporarily moved into MessagePumpWin::HandleWorkMessage.
-#if 0
-    // Let the MessagePump know that we may have more work to do.  It is
-    // tempting to only call this function if our work queue is not empty, but
-    // doing so is insufficient.  The issue is that ReloadWorkQueue does not
-    // look at the incoming queue if the work queue is not empty, and we may
-    // have just processed the last task on the work queue.  ScheduleWork is
-    // very low cost (in the case where it is redundant), so we don't worry
-    // about optimizing away spurious ScheduleWork calls.
-    pump_->ScheduleWork();
-#endif
-    return true;
-  }
-  return false;
-}
-
-bool MessageLoop::DoDelayedWork() {
-  bool did_work = ProcessSomeTimers();
-
-  // We may not have run any timers, but we may still have future timers to
-  // run, so we need to inform the pump again of pending timers.
-  DidChangeNextTimerExpiry(); 
-
-  return did_work;
-}
-
-bool MessageLoop::DoIdleWork() {
-  if (ProcessNextDelayedNonNestableTask())
-    return true;
-
-  if (state_->quit_received)
-    pump_->Quit();
-
-  return false;
-}
-
-//------------------------------------------------------------------------------
-// MessageLoop::AutoRunState
-
-MessageLoop::AutoRunState::AutoRunState(MessageLoop* loop) : loop_(loop) {
-  // Make the loop reference us.
-  previous_state_ = loop_->state_;
-  if (previous_state_) {
-    run_depth = previous_state_->run_depth + 1;
+  if (delay == -1) {
+    KillTimer(message_hwnd_, reinterpret_cast<UINT_PTR>(this));
   } else {
-    run_depth = 1;
+    if (delay < USER_TIMER_MINIMUM)
+      delay = USER_TIMER_MINIMUM;
+    // Simulates malfunctioning, early firing timers. Pending tasks should only
+    // be invoked when the delay they specify has elapsed.
+    if (timer_manager_.use_broken_delay())
+      delay = 10;
+    // Create a WM_TIMER event that will wake us up to check for any pending
+    // timers (in case we are running within a nested, external sub-pump).
+    SetTimer(message_hwnd_, reinterpret_cast<UINT_PTR>(this), delay, NULL);
   }
-  loop_->state_ = this;
-
-  // Initialize the other fields:
-  quit_received = false;
-#if defined(OS_WIN)
-  dispatcher = NULL;
-#endif
-}
-
-MessageLoop::AutoRunState::~AutoRunState() {
-  loop_->state_ = previous_state_;
+#endif  // defined(OS_WIN)
 }
 
 //------------------------------------------------------------------------------
@@ -558,7 +963,6 @@ void MessageLoop::EnableHistogrammer(bool enable) {
 void MessageLoop::StartHistogrammer() {
   if (enable_histogrammer_ && !message_histogram_.get()
       && StatisticsRecorder::WasStarted()) {
-    DCHECK(!thread_name_.empty());
     message_histogram_.reset(new LinearHistogram(
         ASCIIToWide("MsgLoop:" + thread_name_).c_str(),
                     kLeastNonZeroMessageId,
@@ -574,6 +978,11 @@ void MessageLoop::HistogramEvent(int event) {
     message_histogram_->Add(event);
 }
 
+// Add one undocumented windows message to clean up our display.
+#ifndef WM_SYSTIMER
+#define WM_SYSTIMER 0x118
+#endif
+
 // Provide a macro that takes an expression (such as a constant, or macro
 // constant) and creates a pair to initalize an array of pairs.  In this case,
 // our pair consists of the expressions value, and the "stringized" version
@@ -590,13 +999,33 @@ void MessageLoop::HistogramEvent(int event) {
 // in the pair (i.e., the quoted string) when printing out a histogram.
 #define VALUE_TO_NUMBER_AND_NAME(name) {name, #name},
 
+
 // static
 const LinearHistogram::DescriptionPair MessageLoop::event_descriptions_[] = {
+  // Only provide an extensive list in debug mode.  In release mode, we have to
+  // read the octal values.... but we save about 450 strings, each of length
+  // 10 from our binary image.
+#ifndef NDEBUG
+  // Prepare to include a list of names provided in a special header file4.
+#define A_NAMED_MESSAGE_FROM_WINUSER_H VALUE_TO_NUMBER_AND_NAME
+#include "base/windows_message_list.h"
+#undef A_NAMED_MESSAGE_FROM_WINUSER_H
+  // Add an undocumented message that appeared in our list :-/.
+  VALUE_TO_NUMBER_AND_NAME(WM_SYSTIMER)
+#endif  // NDEBUG
+
   // Provide some pretty print capability in our histogram for our internal
   // messages.
 
+  // Values we use for WM_USER+n
+  VALUE_TO_NUMBER_AND_NAME(kMsgPumpATask)
+  VALUE_TO_NUMBER_AND_NAME(kMsgQuit)
+
   // A few events we handle (kindred to messages), and used to profile actions.
   VALUE_TO_NUMBER_AND_NAME(kTaskRunEvent)
+  VALUE_TO_NUMBER_AND_NAME(kSleepingApcEvent)
+  VALUE_TO_NUMBER_AND_NAME(kSleepingSignalEvent)
+  VALUE_TO_NUMBER_AND_NAME(kPollingSignalEvent)
   VALUE_TO_NUMBER_AND_NAME(kTimerEvent)
 
   {-1, NULL}  // The list must be null terminated, per API to histogram.
diff --git a/base/message_loop.h b/base/message_loop.h
index 8ae12c8..8ff2c62 100644
--- a/base/message_loop.h
+++ b/base/message_loop.h
@@ -27,8 +27,8 @@
 // (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_
+#ifndef BASE_MESSAGE_LOOP_H__
+#define BASE_MESSAGE_LOOP_H__
 
 #include <deque>
 #include <queue>
@@ -36,39 +36,33 @@
 #include <vector>
 
 #include "base/histogram.h"
-#include "base/message_pump.h"
 #include "base/observer_list.h"
-#include "base/ref_counted.h"
+#include "base/id_map.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "base/thread_local_storage.h"
 
-#if defined(OS_WIN)
-// We need this to declare base::MessagePumpWin::Dispatcher, which we should
-// really just eliminate.
-#include "base/message_pump_win.h"
-#endif
-
-// A MessageLoop is used to process events for a particular thread.  There is
-// at most one MessageLoop instance per thread.
 //
-// Events include at minimum Task instances submitted to PostTask or those
-// managed by TimerManager.  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.
+// 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.
 //
-// NOTE: MessageLoop has task reentrancy protection.  This means that if a
+// 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 native messages
-// which could implicitly start an inner task.  Inner message pumps are created
-// with dialogs (DialogBox), common dialogs (GetOpenFileName), OLE functions
-// (DoDragDrop), printer functions (StartDoc) and *many* others.
-//
+// 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);
@@ -76,13 +70,142 @@
 //   MessageLoop::current()->SetNestableTasksAllowed(old_state);
 //   // Process hr  (the result returned by DoDragDrop().
 //
-// Please be SURE your task is reentrant (nestable) and all global variables
-// are stable and accessible before calling SetNestableTasksAllowed(true).
+// 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.
 //
-class MessageLoop : public base::MessagePump::Delegate {
+// 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
@@ -160,18 +283,19 @@ class MessageLoop : public base::MessagePump::Delegate {
   // 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 only be called on the same thread that called
-  // Run, and Run must still be on the call stack.
-  //
-  // Use QuitTask if you need to Quit another thread's MessageLoop, but note
-  // that doing so is fairly dangerous if the target thread makes nested calls
-  // to MessageLoop::Run.  The problem being that you won't know which nested
-  // run loop you are quiting, so be careful!
+  // 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
+  // Invokes Quit on the current MessageLoop when run. Useful to schedule an
   // arbitrary MessageLoop to Quit.
   class QuitTask : public Task {
    public:
@@ -186,10 +310,8 @@ class MessageLoop : public base::MessagePump::Delegate {
   ~MessageLoop();
 
   // 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;
-  }
+  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.
@@ -226,62 +348,51 @@ class MessageLoop : public base::MessagePump::Delegate {
     exception_restoration_ = restore;
   }
 
-  //----------------------------------------------------------------------------
-#if defined(OS_WIN)
-  // Backwards-compat for the old Windows-specific MessageLoop API.  These APIs
-  // are deprecated.
-
-  typedef base::MessagePumpWin::Dispatcher Dispatcher;
-  typedef base::MessagePumpWin::Observer Observer;
-  typedef base::MessagePumpWin::Watcher Watcher;
+  // 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);
 
-  void Run(Dispatcher* dispatcher);
+  // 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);
 
-  void WatchObject(HANDLE object, Watcher* watcher) {
-    pump_win()->WatchObject(object, watcher);
-  }
-  void AddObserver(Observer* observer) {
-    pump_win()->AddObserver(observer);
-  }
-  void RemoveObserver(Observer* observer) {
-    pump_win()->RemoveObserver(observer);
-  }
-  void WillProcessMessage(const MSG& message) {
-    pump_win()->WillProcessMessage(message);
-  }
-  void DidProcessMessage(const MSG& message) {
-    pump_win()->DidProcessMessage(message);
-  }
-  void PumpOutPendingPaintMessages() {
-    pump_win()->PumpOutPendingPaintMessages();
-  }
-#endif  // defined(OS_WIN)
+  // 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 RunState {
-    // Used to count how many Run() invocations are on the stack.
-    int run_depth;
-
-    // Used to record that Quit() was called, or that we should quit the pump
-    // once it becomes idle.
-    bool quit_received;
+  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_;
+    }
 
-#if defined(OS_WIN)
-    base::MessagePumpWin::Dispatcher* dispatcher;
-#endif
-  };
+    ~ScopedStateSave() {
+      loop_->run_depth_ = run_depth_;
+      loop_->quit_received_ = quit_received_;
+      loop_->quit_now_ = quit_now_;
+      loop_->dispatcher_ = dispatcher_;
+    }
 
-  class AutoRunState : RunState {
-   public:
-    AutoRunState(MessageLoop* loop);
-    ~AutoRunState();
    private:
     MessageLoop* loop_;
-    RunState* previous_state_;
-  };
+    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*>.
@@ -348,22 +459,32 @@ class MessageLoop : public base::MessagePump::Delegate {
     DISALLOW_EVIL_CONSTRUCTORS(OptionallyPrioritizedTaskQueue);
   };
 
-#if defined(OS_WIN)
-  base::MessagePumpWin* pump_win() {
-    return static_cast<base::MessagePumpWin*>(pump_.get());
-  }
-#endif
+#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();
+  // 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();
+  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)
@@ -372,18 +493,52 @@ class MessageLoop : public base::MessagePump::Delegate {
 
   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
-  // non-nestable 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.
+  // 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.
@@ -394,6 +549,14 @@ class MessageLoop : public base::MessagePump::Delegate {
   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.
@@ -403,27 +566,19 @@ class MessageLoop : public base::MessagePump::Delegate {
   // 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();
 
-  // 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);
-
-  // base::MessagePump::Delegate methods:
-  virtual bool DoWork();
-  virtual bool DoDelayedWork();
-  virtual bool DoIdleWork();
-
   // 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();
@@ -434,6 +589,7 @@ class MessageLoop : public base::MessagePump::Delegate {
   void HistogramEvent(int event);
 
   static TLSSlot tls_index_;
+  static int strategy_selector_;
   static const LinearHistogram::DescriptionPair event_descriptions_[];
   static bool enable_histogrammer_;
 
@@ -448,15 +604,29 @@ class MessageLoop : public base::MessagePump::Delegate {
   // there was no real prioritization.
   OptionallyPrioritizedTaskQueue work_queue_;
 
-  scoped_refptr<base::MessagePump> pump_;
+#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_;
@@ -474,9 +644,17 @@ class MessageLoop : public base::MessagePump::Delegate {
   // will execute once we're out of nested message loops.
   TaskQueue delayed_non_nestable_queue_;
 
-  RunState* state_;
+  // 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_COPY_AND_ASSIGN(MessageLoop);
+  DISALLOW_EVIL_CONSTRUCTORS(MessageLoop);
 };
 
-#endif  // BASE_MESSAGE_LOOP_H_
+#endif  // BASE_MESSAGE_LOOP_H__