Replace PeekMessage for TSF awareness

base/message_pump_win.cc

 // 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.
 
 #include "base/message_pump_win.h"
 
 #include <math.h>
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
+#include "base/win/text_services_message_filter.h"
 #include "base/win/wrapped_window_proc.h"
 
 namespace {
 
 enum MessageLoopProblems {
   MESSAGE_POST_ERROR,
   COMPLETION_POST_ERROR,
   SET_TIMER_ERROR,
   MESSAGE_LOOP_PROBLEM_MAX,
 };
 
+class SimpleMessageFilter : public base::MessagePumpForUI::MessageFilter {
+ public:
+  virtual ~SimpleMessageFilter() {}
+  virtual bool Init() OVERRIDE {
+    return true;
+  }
+  virtual bool DoPeekMessage(MSG* message,
+                             HWND window,
+                             UINT msg_filter_min,
+                             UINT msg_filter_max,
+                             UINT remove_msg) OVERRIDE {
+    return !!PeekMessage(message, window, msg_filter_min, msg_filter_max,
+                         remove_msg);
+  }
+  virtual bool ProcessMessage(const MSG& message) OVERRIDE {
+    return false;
+  }
+};
+
 }  // namespace
 
 namespace base {
 
 static const wchar_t kWndClass[] = L"Chrome_MessagePumpWindow";
 
 // 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 kMsgHaveWork = WM_USER + 1;
 
@@ skipping 56 matching lines @@
     delay = 0;
 
   return delay;
 }
 
 //-----------------------------------------------------------------------------
 // MessagePumpForUI public:
 
 MessagePumpForUI::MessagePumpForUI() : instance_(NULL) {
   InitMessageWnd();
+
+  if (base::win::IsTsfAwareRequired())
+    message_filter_.reset(new win::TextServicesMessageFilter);
+

[cpu_(ooo_6.6-7.5), 2012/08/23 23:51:16]

I discussed it a bit with others and the COM issue is a side effect of this code
here.

Let me explain the COM issue first. Objects should not try to initialize COM,
COM initialization should be a property of the owner of the thread, in the case
of the main UI thread is browser_main, it should be initialized (or not) once,
with a well defined threading_model (like sta, mta, none, etc) and no other code
should attempt to do this.

For example the chrome main UI thread in desktop mode I believe needs to be STA,
but the main thread in chrome metro mode is not sta or mta (!!) is an ASTA:
http://stackoverflow.com/questions/10951750/about-windows-metro-threading-model

The ideal scenario would be that the message_filter_ be specified during
construction or initialization of the message pump, that way we can for the
browser process (and only for that one) pass win::TextServicesMessageFilter at
the chrome/browser layer

With that change then the win::TextServicesMessageFilter does not need to be
here.

That option has a fair amount of work but otherwise is very clean. I think it
will address Ricardo's concerns as well.

Now there is another way, which is *mostly* clean, one that windows itself
provides. For that to work the only thing we need to add here is a call to
CallMsgFilter 

If this message pump calls this, then from outside this code we can cleanly
filter messages using the technique explained here
http://blogs.msdn.com/b/oldnewthing/archive/2005/04/28/412574.aspx

So you have two options. I don't know if Ricardo will like the second one. I
like them both.

[rvargas (doing something else), 2012/08/24 01:21:06]

The first option is actually quite simple. The filter doesn't even have to be
supplied at construction time: we can instantiate a default filter at
construction and just have a method to set another filter after that (knowingly
replacing whatever was there before, no chaining here, maybe a debug only check
that the method is not called twice).

The second option is fine because we already have the code in place for that.
The problem would be PeekMessage, which brings me to my next point.

It is unfortunate that we need two closely related hooks for the same thing (do
we really need both?) :
- PeekMessage (for TSF pump)
- MessageFilter (for key state)
given that conceptually they do the same thing (first chance to look at
messages). Unless they don't, in which case we have something else to worry
about...

At first it seemed natural to forward all Peek calls through the new code... but
now I'm not so sure. There are multiple calls that we care about when TSF should
not really be involved (only paint and timers, peeking without removing) and at
this point I'm not sure anymore that it's a good idea to forward everything.

Carlos?

+  if (!message_filter_.get() || !message_filter_->Init()) {
+    message_filter_.reset(new SimpleMessageFilter);
+    DCHECK(message_filter_->Init());
+  }
 }
 
 MessagePumpForUI::~MessagePumpForUI() {
   DestroyWindow(message_hwnd_);
   UnregisterClass(kWndClass, instance_);
 }
 
 void MessagePumpForUI::ScheduleWork() {
   if (InterlockedExchange(&have_work_, 1))
     return;  // Someone else continued the pumping.
@@ skipping 64 matching lines @@
   if (!state_)
     return;
 
   // Create a mini-message-pump to force immediate processing of only Windows
   // WM_PAINT messages.  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;
   for (peek_count = 0; peek_count < kMaxPeekCount; ++peek_count) {
-    MSG msg;
-    if (!PeekMessage(&msg, NULL, 0, 0, PM_REMOVE | PM_QS_PAINT))
+    MSG message;
+    if (!message_filter_->DoPeekMessage(&message, NULL, 0, 0,
+                                        PM_REMOVE | PM_QS_PAINT))
       break;
-    ProcessMessageHelper(msg);
+    ProcessMessageHelper(message);
     if (state_->should_quit)  // Handle WM_QUIT.
       break;
   }
   // Histogram what was really being used, to help to adjust kMaxPeekCount.
   DHISTOGRAM_COUNTS("Loop.PumpOutPendingPaintMessages Peeks", peek_count);
 }
 
 //-----------------------------------------------------------------------------
 // MessagePumpForUI private:
 
@@ skipping 90 matching lines @@
 
   DWORD result;
   result = MsgWaitForMultipleObjectsEx(0, NULL, delay, QS_ALLINPUT,
                                        MWMO_INPUTAVAILABLE);
 
   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
+    // that messages are ready for processing (Specifically, mouse messages
+    // intended for the child window may appear if the child window has
+    // capture).
+    // The subsequent PeekMessages call may fail 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.
+    // some time 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)) {
+        !message_filter_->DoPeekMessage(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST,
+                                        PM_NOREMOVE)) {
       WaitMessage();
     }
     return;
   }
 
   DCHECK_NE(WAIT_FAILED, result) << GetLastError();
 }
 
 void MessagePumpForUI::HandleWorkMessage() {
   // If we are being called outside of the context of Run, then don't try to do
@@ skipping 36 matching lines @@
   // 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))
+  if (message_filter_->DoPeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
     return ProcessMessageHelper(msg);
 
   return sent_messages_in_queue;
 }
 
-bool MessagePumpForUI::ProcessMessageHelper(const MSG& msg) {
+bool MessagePumpForUI::ProcessMessageHelper(const MSG& message) {
   TRACE_EVENT1("base", "MessagePumpForUI::ProcessMessageHelper",
-               "message", msg.message);
-  if (WM_QUIT == msg.message) {
+               "message", message.message);
+  if (WM_QUIT == message.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));
+    PostQuitMessage(static_cast<int>(message.wParam));
     return false;
   }
 
   // While running our main message pump, we discard kMsgHaveWork messages.
-  if (msg.message == kMsgHaveWork && msg.hwnd == message_hwnd_)
+  if (message.message == kMsgHaveWork && message.hwnd == message_hwnd_)
     return ProcessPumpReplacementMessage();
 
-  if (CallMsgFilter(const_cast<MSG*>(&msg), kMessageFilterCode))
+  if (CallMsgFilter(const_cast<MSG*>(&message), kMessageFilterCode))
     return true;
 
-  WillProcessMessage(msg);
+  WillProcessMessage(message);
 
-  if (state_->dispatcher) {
-    if (!state_->dispatcher->Dispatch(msg))
-      state_->should_quit = true;
-  } else {
-    TranslateMessage(&msg);
-    DispatchMessage(&msg);
+  if (!message_filter_->ProcessMessage(message)) {
+    if (state_->dispatcher) {
+      if (!state_->dispatcher->Dispatch(message))
+        state_->should_quit = true;
+    } else {
+      TranslateMessage(&message);
+      DispatchMessage(&message);
+    }
   }
 
-  DidProcessMessage(msg);
+  DidProcessMessage(message);
   return true;
 }
 
 bool MessagePumpForUI::ProcessPumpReplacementMessage() {
   // When we encounter a kMsgHaveWork message, this method is called to peek
   // and process a replacement message, such as a WM_PAINT or WM_TIMER.  The
   // goal is to make the kMsgHaveWork 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 kMsgHaveWork to be pending,
   // then resets the have_work_ flag (allowing a replacement kMsgHaveWork to
   // possibly be posted), and finally dispatches that peeked replacement.  Note
   // that the re-post of kMsgHaveWork may be asynchronous to this thread!!
 
   bool have_message = false;
-  MSG msg;
+  MSG message;
   // We should not process all window messages if we are in the context of an
   // OS modal loop, i.e. in the context of a windows API call like MessageBox.
   // This is to ensure that these messages are peeked out by the OS modal loop.
   if (MessageLoop::current()->os_modal_loop()) {
     // We only peek out WM_PAINT and WM_TIMER here for reasons mentioned above.
-    have_message = PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_REMOVE) ||
-                   PeekMessage(&msg, NULL, WM_TIMER, WM_TIMER, PM_REMOVE);
+    have_message =
+        message_filter_->DoPeekMessage(&message, NULL, WM_PAINT, WM_PAINT,
+                                       PM_REMOVE) ||
+        message_filter_->DoPeekMessage(&message, NULL, WM_TIMER, WM_TIMER,
+                                       PM_REMOVE);
   } else {
-    have_message = (0 != PeekMessage(&msg, NULL, 0, 0, PM_REMOVE));
+    have_message = message_filter_->DoPeekMessage(&message, NULL, 0, 0,
+                                                  PM_REMOVE);
   }
 
-  DCHECK(!have_message || kMsgHaveWork != msg.message ||
-         msg.hwnd != message_hwnd_);
+  DCHECK(!have_message || kMsgHaveWork != message.message ||
+         message.hwnd != message_hwnd_);
 
   // Since we discarded a kMsgHaveWork message, we must update the flag.
   int old_have_work = InterlockedExchange(&have_work_, 0);
   DCHECK(old_have_work);
 
   // We don't need a special time slice if we didn't have_message to process.
   if (!have_message)
     return false;
 
   // Guarantee we'll get another time slice in the case where we go into native
   // windows code.   This ScheduleWork() may hurt performance a tiny bit when
   // tasks appear very infrequently, but when the event queue is busy, the
   // kMsgHaveWork events get (percentage wise) rarer and rarer.
   ScheduleWork();
-  return ProcessMessageHelper(msg);
+  return ProcessMessageHelper(message);
 }
 
 //-----------------------------------------------------------------------------
 // MessagePumpForIO public:
 
 MessagePumpForIO::MessagePumpForIO() {
   port_.Set(CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 1));
   DCHECK(port_.IsValid());
 }
 
@@ skipping 208 matching lines @@
 
 // static
 MessagePumpForIO::IOHandler* MessagePumpForIO::KeyToHandler(
     ULONG_PTR key,
     bool* has_valid_io_context) {
   *has_valid_io_context = ((key & 1) == 0);
   return reinterpret_cast<IOHandler*>(key & ~static_cast<ULONG_PTR>(1));
 }
 
 }  // namespace base