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 {
+namespace win {
+class TextServicesBridge;

[rvargas (doing something else), 2012/08/21 19:45:37]

remove this.

[yoichio, 2012/08/22 08:06:50]

Done.

+}  // namespace win
 
 // 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) {}
   virtual ~MessagePumpWin() {}
 
   // Add an Observer, which will start receiving notifications immediately.
@@ skipping 87 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:
+  // Interface gets message and may process it.

[rvargas (doing something else), 2012/08/21 19:45:37]

How about:
A MessageFilter implements the common Peek/Translate/Dispatch code to deal with
windows messages.

[yoichio, 2012/08/22 08:06:50]

Done.

+  class MessageFilter {
+   public:
+     virtual ~MessageFilter() {}
+     virtual bool Init() = 0;
+     // Implements the functionality exposed by the OS through PeekMessage.
+     virtual BOOL DoPeekMessage(MSG* msg,

[rvargas (doing something else), 2012/08/21 19:45:37]

nit: message

[yoichio, 2012/08/22 08:06:50]

Done.

+                                HWND hwnd,
+                                UINT msg_filter_min,
+                                UINT msg_filter_max,
+                                UINT remove_msg) = 0;
+     // Returns true if |message| was completely consumed by the filter and

[rvargas (doing something else), 2012/08/21 19:45:37]

It is not clear what is expected from an implementation of this interface.

[yoichio, 2012/08/22 08:06:50]

How about this?

+     // should not be dispatched.
+     virtual bool ProcessMessage(const MSG& msg) = 0;

[rvargas (doing something else), 2012/08/21 19:45:37]

nit: message

[rvargas (doing something else), 2012/08/21 19:45:37]

On a more serious note, the interaction between a MessageFilter and a
MessagePumpDispatcher should be documented somewhere... who has priority, given
that both implement similar functionality (which is a bad thing by itself, but
they serve two quite different purposes).

[yoichio, 2012/08/22 08:06:50]

Done.

[yoichio, 2012/08/22 08:06:50]

Add comments.

+   };
+
   // The application-defined code passed to the hook procedure.
   static const int kMessageFilterCode = 0x5001;
 
   MessagePumpForUI();
   virtual ~MessagePumpForUI();
 
   // 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 hwnd,
+                                       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_;
+
+  // A Proxy which gets message.

[rvargas (doing something else), 2012/08/21 19:45:37]

nit: remove comment

[yoichio, 2012/08/22 08:06:50]

Done.

+  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_