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

1 files changed, 562 insertions, 133 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.