This fixes http://code.google.com/p/chromium/issues/detail?id=772,...

base/message_pump_win.cc

 // Copyright (c) 2006-2008 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.
 
 #include "base/message_pump_win.h"
 
 #include <math.h>
 
 #include "base/histogram.h"
 #include "base/win_util.h"
@@ skipping 195 matching lines @@
     return;
 
   state_->delegate->DoDelayedWork(&delayed_work_time_);
   if (!delayed_work_time_.is_null()) {
     // A bit gratuitous to set delayed_work_time_ again, but oh well.
     ScheduleDelayedWork(delayed_work_time_);
   }
 }
 
 bool MessagePumpWin::ProcessNextWindowsMessage() {
+  // If there are sent messages in the queue then PeekMessage internally
+  // dispatches the message and returns false. We return true in this
+  // case to ensure that the message loop peeks again instead of calling
+  // MsgWaitForMultipleObjectsEx again.
+  bool sent_messages_in_queue = false;
+  DWORD queue_status = GetQueueStatus(QS_SENDMESSAGE);
+  if (HIWORD(queue_status) & QS_SENDMESSAGE)
+    sent_messages_in_queue = true;
+
   MSG msg;
   if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
     return ProcessMessageHelper(msg);
-  return false;
+
+  return sent_messages_in_queue;
 }
 
 bool MessagePumpWin::ProcessMessageHelper(const MSG& msg) {
   if (WM_QUIT == msg.message) {
     // Repost the QUIT message so that it will be retrieved by the primary
     // GetMessage() loop.
     state_->should_quit = true;
     PostQuitMessage(static_cast<int>(msg.wParam));
     return false;
   }
@@ skipping 121 matching lines @@
   // Wait until a message is available, up to the time needed by the timer
   // manager to fire the next set of timers.
   int delay = GetCurrentDelay();
   if (delay < 0)  // Negative value means no timers waiting.
     delay = INFINITE;
 
   DWORD result;
   result = MsgWaitForMultipleObjectsEx(0, NULL, delay, QS_ALLINPUT,
                                        MWMO_INPUTAVAILABLE);
 
-  if (WAIT_OBJECT_0 == result)
-    return;  // A WM_* message is available.
+  if (WAIT_OBJECT_0 == result) {
+    // A WM_* message is available.
+    // If a parent child relationship exists between windows across threads
+    // then their thread inputs are implicitly attached.
+    // This causes the MsgWaitForMultipleObjectsEx API to return indicating
+    // that messages are ready for processing (specifically mouse messages
+    // intended for the child window. Occurs if the child window has capture)
+    // The subsequent PeekMessages call fails to return any messages thus
+    // causing us to enter a tight loop at times.
+    // The WaitMessage call below is a workaround to give the child window
+    // sometime to process its input messages.
+    MSG msg = {0};
+    DWORD queue_status = GetQueueStatus(QS_MOUSE);
+    if (HIWORD(queue_status) & QS_MOUSE && 
+       !PeekMessage(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_NOREMOVE)) {
+      WaitMessage();
+    }
+    return;  
+  }
 
   DCHECK_NE(WAIT_FAILED, result) << GetLastError();
 }
 
 //-----------------------------------------------------------------------------
 // MessagePumpForIO public:
 
 void MessagePumpForIO::WatchObject(HANDLE object, Watcher* watcher) {
   DCHECK(object);
   DCHECK_NE(object, INVALID_HANDLE_VALUE);
@@ skipping 218 matching lines @@
   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).
 
   return true;
 }
 
 }  // namespace base