Remove handler from MessagePumpForIO::IOContext.

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>
@@ skipping 130 matching lines @@
 };
 
 //-----------------------------------------------------------------------------
 // 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:
-  struct IOContext;
+  struct BASE_EXPORT IOContext {
+    IOContext();
+    OVERLAPPED overlapped;
+  };
 
   // Clients interested in receiving OS notifications when asynchronous IO
   // operations complete should implement this interface and register themselves
   // with the message pump.
   //
   // Typical use #1:
-  //   // Use only when there are no user's buffers involved on the actual IO,
-  //   // so that all the cleanup can be done by the message pump.
   //   class MyFile : public IOHandler {
   //     MyFile() {
   //       ...
-  //       context_ = new IOContext;
-  //       context_->handler = this;
-  //       message_pump->RegisterIOHandler(file_, this);
-  //     }
-  //     ~MyFile() {
-  //       if (pending_) {
-  //         // By setting the handler to NULL, we're asking for this context
-  //         // to be deleted when received, without calling back to us.
-  //         context_->handler = NULL;
-  //       } else {
-  //         delete context_;
-  //      }
-  //     }
-  //     virtual void OnIOCompleted(IOContext* context, DWORD bytes_transfered,
-  //                                DWORD error) {
-  //         pending_ = false;
-  //     }
-  //     void DoSomeIo() {
-  //       ...
-  //       // The only buffer required for this operation is the overlapped
-  //       // structure.
-  //       ConnectNamedPipe(file_, &context_->overlapped);
-  //       pending_ = true;
-  //     }
-  //     bool pending_;
-  //     IOContext* context_;
-  //     HANDLE file_;
-  //   };
-  //
-  // Typical use #2:
-  //   class MyFile : public IOHandler {
-  //     MyFile() {
-  //       ...
   //       message_pump->RegisterIOHandler(file_, this);
   //     }
   //     // Plus some code to make sure that this destructor is not called
   //     // while there are pending IO operations.
   //     ~MyFile() {
   //     }
   //     virtual void OnIOCompleted(IOContext* context, DWORD bytes_transfered,
   //                                DWORD error) {
   //       ...
   //       delete context;
   //     }
   //     void DoSomeIo() {
   //       ...
   //       IOContext* context = new IOContext;
-  //       // This is not used for anything. It just prevents the context from
-  //       // being considered "abandoned".
-  //       context->handler = this;
-  //       ReadFile(file_, buffer, num_bytes, &read, &context->overlapped);
+  //       ReadFile(file_, buffer, num_bytes, &read, &context);
   //     }
   //     HANDLE file_;
   //   };
   //
-  // Typical use #3:
+  // Typical use #2:
   // Same as the previous example, except that in order to deal with the
   // requirement stated for the destructor, the class calls WaitForIOCompletion
   // from the destructor to block until all IO finishes.
   //     ~MyFile() {
   //       while(pending_)
   //         message_pump->WaitForIOCompletion(INFINITE, this);
   //     }
   //
   class IOHandler {
    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;
   };
 
-  // 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 {
-    OVERLAPPED overlapped;
-    IOHandler* handler;
-  };
-
   MessagePumpForIO();
   ~MessagePumpForIO() override;
 
   // MessagePump methods:
   void ScheduleWork() override;
   void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
   // Register the handler to be used when asynchronous IO for the given file
   // completes. The registration persists as long as |file_handle| is valid, so
   // |handler| must be valid as long as there is pending IO for the given file.
@@ skipping 15 matching lines @@
   // 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);
 
  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);
 
-  // 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_;
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_