Don't peek messages in the MessagePumpForUI class when we receive our kMsgHaveWork message.

base/message_loop/message_pump_win.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_
 
 #include <windows.h>
 
 #include <list>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_pump.h"
 #include "base/message_loop/message_pump_dispatcher.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "base/win/scoped_handle.h"
 
 namespace base {
 
+class Thread;
+
 // MessagePumpWin serves as the base for specialized versions of the MessagePump
 // for Windows. It provides basic functionality like handling of observers and
 // controlling the lifetime of the message pump.
 class BASE_EXPORT MessagePumpWin : public MessagePump {
  public:
   MessagePumpWin() : have_work_(0), state_(NULL) {}
 
   // Like MessagePump::Run, but MSG objects are routed through dispatcher.
   void RunWithDispatcher(Delegate* delegate, MessagePumpDispatcher* dispatcher);
 
@@ skipping 96 matching lines @@
   void DoRunLoop() override;
   void InitMessageWnd();
   void WaitForWork();
   void HandleWorkMessage();
   void HandleTimerMessage();
   void RescheduleTimer();
   bool ProcessNextWindowsMessage();
   bool ProcessMessageHelper(const MSG& msg);
   bool ProcessPumpReplacementMessage();
 
+  // We spawn a worker thread to periodically post (3 ms) the kMsgHaveWork
+  // message to the UI message pump. This is to ensure that the main thread
+  // gets to process tasks and delayed tasks when there is no activity in the
+  // Windows message pump or when there is a nested modal loop (sizing/moving/
+  // drag drop/message boxes) etc.
+  void DoWorkerThreadRunLoop();
+
+  // This function is posted as part of a user mode APC to shutdown the worker
+  // thread when the main message pump is shutting down.
+  static void CALLBACK ShutdownWorkerThread(ULONG_PTR param);
+
+  // Helper function for posting the kMsgHaveWork message to wake up the pump
+  // for processing tasks.
+  void PostWorkMessage();
+
+  // Helper function to set the waitable timer used to wake up the UI worker
+  // thread for processing delayed tasks.
+  void SetWakeupTimer(int64 delay);

[scottmg, 2015/06/09 16:22:42]

nit; "delay_ms" (and in the .cc) would be better since the units are not
necessarily clear

[ananta, 2015/06/09 18:25:43]

Done.

+
   // Atom representing the registered window class.
   ATOM atom_;
 
   // A hidden message-only window.
   HWND message_hwnd_;
+
+  // This thread is used to periodically wake up the main thread to process
+  // tasks.
+  scoped_ptr<base::Thread> ui_worker_thread_;
+
+  // The UI worker thread waits on this timer indefinitely. When the main
+  // thread has tasks ready to be processed it sets the timer.
+  base::win::ScopedHandle ui_worker_thread_timer_;
 };
 
 //-----------------------------------------------------------------------------
 // MessagePumpForIO extends MessagePumpWin with methods that are particular to a
 // MessageLoop instantiated with TYPE_IO. This version of MessagePump does not
 // deal with Windows mesagges, and instead has a Run loop based on Completion
 // Ports so it is better suited for IO operations.
 //
 class BASE_EXPORT MessagePumpForIO : public MessagePumpWin {
  public:
@@ skipping 179 matching lines @@
   // This list will be empty almost always. It stores IO completions that have
   // not been delivered yet because somebody was doing cleanup.
   std::list<IOItem> completed_io_;
 
   ObserverList<IOObserver> io_observers_;
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_