As an intermediary step towards having a message pump handling IO through com...

base/message_pump_win.h

 // 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.
 
 #ifndef BASE_MESSAGE_PUMP_WIN_H_
 #define BASE_MESSAGE_PUMP_WIN_H_
 
 #include <vector>
 
 #include <windows.h>
@@ skipping 44 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 MessagePumpWin : public MessagePump {
  public:
-  // Used with WatchObject to asynchronously monitor the signaled state of a
-  // HANDLE object.
-  class Watcher {
-   public:
-    virtual ~Watcher() {}
-    // Called from MessageLoop::Run when a signalled object is detected.
-    virtual void OnObjectSignaled(HANDLE object) = 0;
-  };
-
   // An Observer is an object that receives global notifications from the
   // MessageLoop.
   //
   // NOTE: An Observer implementation should be extremely fast!
   //
   class Observer {
    public:
     virtual ~Observer() {}
 
     // This method is called before processing a message.
@@ skipping 15 matching lines @@
   // from Dispatch.
   class Dispatcher {
    public:
     virtual ~Dispatcher() {}
     // Dispatches the event. If true is returned processing continues as
     // normal. If false is returned, the nested loop exits immediately.
     virtual bool Dispatch(const MSG& msg) = 0;
   };
 
   MessagePumpWin();
-  ~MessagePumpWin();
-
-  // Have the current thread's message loop watch for a signaled object.
-  // Pass a null watcher to stop watching the object.
-  void WatchObject(HANDLE, Watcher*);
+  virtual ~MessagePumpWin();
 
   // Add an Observer, which will start receiving notifications immediately.
   void AddObserver(Observer* observer);
 
   // Remove an Observer.  It is safe to call this method while an Observer is
   // receiving a notification callback.
   void RemoveObserver(Observer* observer);
 
   // Give a chance to code processing additional messages to notify the
   // message loop observers that another message has been processed.
   void WillProcessMessage(const MSG& msg);
   void DidProcessMessage(const MSG& msg);
 
   // 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();
 
   // Like MessagePump::Run, but MSG objects are routed through dispatcher.
   void RunWithDispatcher(Delegate* delegate, Dispatcher* dispatcher);
 
   // MessagePump methods:
   virtual void Run(Delegate* delegate) { RunWithDispatcher(delegate, NULL); }
   virtual void Quit();
   virtual void ScheduleWork();
   virtual void ScheduleDelayedWork(const Time& delayed_work_time);
 
- private:
+ protected:
   struct RunState {
     Delegate* delegate;
     Dispatcher* dispatcher;
 
     // Used to flag that the current Run() invocation should return ASAP.
     bool should_quit;
 
     // Used to count how many Run() invocations are on the stack.
     int run_depth;
   };
 
   static LRESULT CALLBACK WndProcThunk(
       HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+  virtual void DoRunLoop() = 0;
   void InitMessageWnd();
   void HandleWorkMessage();
   void HandleTimerMessage();
-  void DoRunLoop();
-  void WaitForWork();
   bool ProcessNextWindowsMessage();
   bool ProcessMessageHelper(const MSG& msg);
   bool ProcessPumpReplacementMessage();
-  bool ProcessNextObject();
-  bool SignalWatcher(size_t object_index);
   int GetCurrentDelay() const;
 
   // A hidden message-only window.
   HWND message_hwnd_;
 
-  // A vector of objects (and corresponding watchers) that are routinely
-  // serviced by this message pump.
-  std::vector<HANDLE> objects_;
-  std::vector<Watcher*> watchers_;
-
   ObserverList<Observer> observers_;
 
   // The time at which delayed work should run.
   Time delayed_work_time_;
 
   // A boolean value used to indicate if there is a kMsgDoWork message pending
   // in the Windows Message queue.  There is at most one such message, and it
   // can drive execution of tasks when a native message pump is running.
   LONG have_work_;
 
   // State for the current invocation of Run.
   RunState* state_;
 };
 
+//-----------------------------------------------------------------------------
+// MessagePumpForUI extends MessagePumpWin with methods that are particular to a
+// MessageLoop instantiated with TYPE_UI.
+//
+class MessagePumpForUI : public MessagePumpWin {
+ public:
+  MessagePumpForUI() {}
+  virtual ~MessagePumpForUI() {}
+ private:
+  virtual void DoRunLoop();
+  void WaitForWork();
+};
+
+//-----------------------------------------------------------------------------
+// MessagePumpForIO extends MessagePumpWin with methods that are particular to a
+// MessageLoop instantiated with TYPE_IO.
+//
+class MessagePumpForIO : public MessagePumpWin {
+ public:
+  // Used with WatchObject to asynchronously monitor the signaled state of a
+  // HANDLE object.
+  class Watcher {
+   public:
+    virtual ~Watcher() {}
+    // Called from MessageLoop::Run when a signalled object is detected.
+    virtual void OnObjectSignaled(HANDLE object) = 0;
+  };
+
+  MessagePumpForIO() {}
+  virtual ~MessagePumpForIO() {}
+
+  // Have the current thread's message loop watch for a signaled object.
+  // Pass a null watcher to stop watching the object.
+  void WatchObject(HANDLE, Watcher*);
+
+ private:
+  virtual void DoRunLoop();
+  void WaitForWork();
+  bool ProcessNextObject();
+  bool SignalWatcher(size_t object_index);
+
+  // A vector of objects (and corresponding watchers) that are routinely
+  // serviced by this message pump.
+  std::vector<HANDLE> objects_;
+  std::vector<Watcher*> watchers_;
+};
+
 }  // namespace base
 
 #endif  // BASE_MESSAGE_PUMP_WIN_H_