Remove IOObservers from MessageLoopForIO.

base/message_loop/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_LOOP_MESSAGE_PUMP_WIN_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_
 
 #include <windows.h>
 
 #include <list>
 
 #include "base/base_export.h"
 #include "base/message_loop/message_pump.h"
-#include "base/observer_list.h"
 #include "base/time/time.h"
 #include "base/win/scoped_handle.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 BASE_EXPORT MessagePumpWin : public MessagePump {
  public:
@@ skipping 204 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 23 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;
 
     // In some cases |context| can be a non-pointer value casted to a pointer.
     // |has_valid_io_context| is true if |context| is a valid IOContext
     // pointer, and false otherwise.
     bool has_valid_io_context;
   };
 
   void DoRunLoop() override;
   void WaitForWork();
   bool MatchCompletedIOItem(IOHandler* filter, IOItem* item);
   bool GetIOItem(DWORD timeout, IOItem* item);
   bool ProcessInternalIOItem(const IOItem& item);
-  void WillProcessIOEvent();
-  void DidProcessIOEvent();
 
   // Converts an IOHandler pointer to a completion port key.
   // |has_valid_io_context| specifies whether completion packets posted to
   // |handler| will have valid OVERLAPPED pointers.
   static ULONG_PTR HandlerToKey(IOHandler* handler, bool has_valid_io_context);
 
   // Converts a completion port key to an IOHandler pointer.
   static IOHandler* KeyToHandler(ULONG_PTR key, bool* has_valid_io_context);
 
   // The completion port associated with this thread.
   win::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_LOOP_MESSAGE_PUMP_WIN_H_