Replace PeekMessage for TSF awareness

base/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_PUMP_WIN_H_
 #define BASE_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_pump.h"
 #include "base/message_pump_dispatcher.h"
 #include "base/message_pump_observer.h"
 #include "base/observer_list.h"
 #include "base/time.h"
 #include "base/win/scoped_handle.h"
 
 namespace base {
 
 // MessagePumpWin serves as the base for specialized versions of the MessagePump
@@ skipping 95 matching lines @@
 // is peeked, and before a replacement kMsgHaveWork 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 DoRunLoop.
 //
 class BASE_EXPORT MessagePumpForUI : public MessagePumpWin {
  public:
+  // A MessageFilter implements the common Peek/Translate/Dispatch code to deal
+  // with windows messages.
+  // This abstraction is used to inject TSF message peeking. See
+  // TextServicesMessageFilter.
+  class BASE_EXPORT MessageFilter {
+   public:
+    virtual ~MessageFilter() {}
+    // Implements the functionality exposed by the OS through PeekMessage.
+    virtual BOOL DoPeekMessage(MSG* msg,
+                               HWND window_handle,
+                               UINT msg_filter_min,
+                               UINT msg_filter_max,
+                               UINT remove_msg) {
+      return PeekMessage(msg, window_handle, msg_filter_min, msg_filter_max,
+                         remove_msg);
+    }
+    // Returns true if |message| was consumed by the filter and no extra
+    // processing is required. If this method returns false, it is the
+    // responsibility of the caller to ensure that normal processing takes
+    // place.
+    // The priority to consume messages is the following:
+    // - Native Windows' message filter (CallMsgFilter).
+    // - MessageFilter::ProcessMessage.
+    // - MessagePumpDispatcher.
+    // - TranslateMessage / DispatchMessage.
+    virtual bool ProcessMessage(const MSG& msg) { return false;}
+  };
   // The application-defined code passed to the hook procedure.
   static const int kMessageFilterCode = 0x5001;
 
   MessagePumpForUI();
   virtual ~MessagePumpForUI();
 
+  // Sets a new MessageFilter. MessagePumpForUI takes ownership of
+  // |message_filter|. When SetMessageFilter is called, old MessageFilter is
+  // deleted.
+  void SetMessageFilter(scoped_ptr<MessageFilter> message_filter);
+
   // MessagePump methods:
   virtual void ScheduleWork();
   virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time);
 
   // 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:
-  static LRESULT CALLBACK WndProcThunk(
-      HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+  static LRESULT CALLBACK WndProcThunk(HWND window_handle,
+                                       UINT message,
+                                       WPARAM wparam,
+                                       LPARAM lparam);
   virtual void DoRunLoop();
   void InitMessageWnd();
   void WaitForWork();
   void HandleWorkMessage();
   void HandleTimerMessage();
   bool ProcessNextWindowsMessage();
   bool ProcessMessageHelper(const MSG& msg);
   bool ProcessPumpReplacementMessage();
 
   // Instance of the module containing the window procedure.
   HMODULE instance_;
 
   // A hidden message-only window.
   HWND message_hwnd_;
+
+  scoped_ptr<MessageFilter> message_filter_;
 };
 
 //-----------------------------------------------------------------------------
 // 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_PUMP_WIN_H_