Jankometer: Generalize the code more. Add better support for monitoring IO thread.

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 <windows.h>
 
 #include <list>
 
+#include "base/basictypes.h"
 #include "base/lock.h"
 #include "base/message_pump.h"
 #include "base/observer_list.h"
 #include "base/scoped_handle.h"
 #include "base/time.h"
 
 namespace base {
 
 // 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 MessagePumpWin : public MessagePump {
  public:
   // An Observer is an object that receives global notifications from the
-  // MessageLoop.
+  // UI MessageLoop.
   //
   // NOTE: An Observer implementation should be extremely fast!
   //
   class Observer {
    public:
     virtual ~Observer() {}
 
     // This method is called before processing a message.
     // The message may be undefined in which case msg.message is 0
     virtual void WillProcessMessage(const MSG& msg) = 0;
@@ skipping 239 matching lines @@
    public:
     virtual ~IOHandler() {}
     // This will be called once the pending IO operation associated with
     // |context| completes. |error| is the Win32 error code of the IO operation
     // (ERROR_SUCCESS if there was no error). |bytes_transfered| will be zero
     // on error.
     virtual void OnIOCompleted(IOContext* context, DWORD bytes_transfered,
                                DWORD error) = 0;
   };
 
+  // An IOObserver is an object that receives IO notifications from the
+  // MessagePump.
+  //
+  // NOTE: An IOObserver implementation should be extremely fast!
+  class IOObserver {
+   public:
+    IOObserver() {}
+
+    virtual void WillProcessIOEvent() = 0;
+    virtual void DidProcessIOEvent() = 0;
+
+   protected:
+    virtual ~IOObserver() {}
+  };
+
   // The extended context that should be used as the base structure on every
   // overlapped IO operation. |handler| must be set to the registered IOHandler
   // for the given file when the operation is started, and it can be set to NULL
   // before the operation completes to indicate that the handler should not be
   // called anymore, and instead, the IOContext should be deleted when the OS
   // notifies the completion of this operation. Please remember that any buffers
   // involved with an IO operation should be around until the callback is
   // received, so this technique can only be used for IO that do not involve
   // additional buffers (other than the overlapped structure itself).
   struct IOContext {
@@ skipping 17 matching lines @@
   // up to |timeout| milliseconds. Return true if any IO operation completed,
   // regardless of the involved handler, and false if the timeout expired. If
   // the completion port received any message and the involved IO handler
   // matches |filter|, the callback is called before returning from this code;
   // if the handler is not the one that we are looking for, the callback will
   // be postponed for another time, so reentrancy problems can be avoided.
   // External use of this method should be reserved for the rare case when the
   // caller is willing to allow pausing regular task dispatching on this thread.
   bool WaitForIOCompletion(DWORD timeout, IOHandler* filter);
 
+  void AddIOObserver(IOObserver* obs);
+  void RemoveIOObserver(IOObserver* obs);
+
  private:
   struct IOItem {
     IOHandler* handler;
     IOContext* context;
     DWORD bytes_transfered;
     DWORD error;
   };
 
   virtual void DoRunLoop();
   void WaitForWork();
   bool MatchCompletedIOItem(IOHandler* filter, IOItem* item);
   bool GetIOItem(DWORD timeout, IOItem* item);
   bool ProcessInternalIOItem(const IOItem& item);
+  void WillProcessIOEvent();
+  void DidProcessIOEvent();
 
   // The completion port associated with this thread.
   ScopedHandle port_;
   // 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_