Mojo: Handle "nested" Shutdown() in RawChannelWin.

mojo/system/raw_channel_win.cc

 // Copyright 2013 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.
 
 #include "mojo/system/raw_channel.h"
 
 #include <windows.h>
 
-#include "base/basictypes.h"
+#include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/win/windows_version.h"
 #include "mojo/embedder/platform_handle.h"
 
 namespace mojo {
 namespace system {
 
 namespace {
@@ skipping 92 matching lines @@
                                scoped_ptr<WriteBuffer> write_buffer);
 
    private:
     virtual ~RawChannelIOHandler();
 
     // Returns true if |owner_| has been reset and there is not pending read or
     // write.
     // Must be called on the I/O thread.
     bool ShouldSelfDestruct() const;
 
-    // Must be called on the I/O thread. It could be called before or after
-    // detached from the owner.
+    // Must be called on the I/O thread. It may be called before or after
+    // detaching from the owner.
     void OnReadCompleted(DWORD bytes_read, DWORD error);
-    // Must be called on the I/O thread. It could be called before or after
-    // detached from the owner.
+    // Must be called on the I/O thread. It may be called before or after
+    // detaching from the owner.
     void OnWriteCompleted(DWORD bytes_written, DWORD error);
 
     embedder::ScopedPlatformHandle handle_;
 
     // |owner_| is reset on the I/O thread under |owner_->write_lock()|.
     // Therefore, it may be used on any thread under lock; or on the I/O thread
     // without locking.
     RawChannelWin* owner_;
 
     // The following members must be used on the I/O thread.
     scoped_ptr<ReadBuffer> preserved_read_buffer_after_detach_;
     scoped_ptr<WriteBuffer> preserved_write_buffer_after_detach_;
+    bool suppress_self_destruct_;
 
     bool pending_read_;
     base::MessageLoopForIO::IOContext read_context_;
 
     // The following members must be used under |owner_->write_lock()| while the
     // object is still attached to the owner, and only on the I/O thread
     // afterwards.
     bool pending_write_;
     base::MessageLoopForIO::IOContext write_context_;
 
@@ skipping 17 matching lines @@
 
   const bool skip_completion_port_on_success_;
 
   DISALLOW_COPY_AND_ASSIGN(RawChannelWin);
 };
 
 RawChannelWin::RawChannelIOHandler::RawChannelIOHandler(
     RawChannelWin* owner,
     embedder::ScopedPlatformHandle handle) : handle_(handle.Pass()),
                                              owner_(owner),
+                                             suppress_self_destruct_(false),
                                              pending_read_(false),
                                              pending_write_(false) {
   memset(&read_context_.overlapped, 0, sizeof(read_context_.overlapped));
   read_context_.handler = this;
   memset(&write_context_.overlapped, 0, sizeof(write_context_.overlapped));
   write_context_.handler = this;
 
   owner_->message_loop_for_io()->RegisterIOHandler(handle_.get().handle, this);
 }
 
@@ skipping 41 matching lines @@
   pending_write_ = true;
 }
 
 void RawChannelWin::RawChannelIOHandler::OnIOCompleted(
     base::MessageLoopForIO::IOContext* context,
     DWORD bytes_transferred,
     DWORD error) {
   DCHECK(!owner_ ||
          base::MessageLoop::current() == owner_->message_loop_for_io());
 
-  if (context == &read_context_)
-    OnReadCompleted(bytes_transferred, error);
-  else if (context == &write_context_)
-    OnWriteCompleted(bytes_transferred, error);
-  else
-    NOTREACHED();
+  {
+    // Suppress self-destruction inside |OnReadCompleted()|, etc. (in case they
+    // result in a call to |Shutdown()|).
+    base::AutoReset<bool> resetter(&suppress_self_destruct_, true);
+
+    if (context == &read_context_)
+      OnReadCompleted(bytes_transferred, error);
+    else if (context == &write_context_)
+      OnWriteCompleted(bytes_transferred, error);
+    else
+      NOTREACHED();
+  }
 
   if (ShouldSelfDestruct())
     delete this;
 }
 
 void RawChannelWin::RawChannelIOHandler::DetachFromOwnerNoLock(
     scoped_ptr<ReadBuffer> read_buffer,
     scoped_ptr<WriteBuffer> write_buffer) {
   DCHECK(owner_);
   DCHECK_EQ(base::MessageLoop::current(), owner_->message_loop_for_io());
   owner_->write_lock().AssertAcquired();
 
   // If read/write is pending, we have to retain the corresponding buffer.
   if (pending_read_)
     preserved_read_buffer_after_detach_ = read_buffer.Pass();
   if (pending_write_)
     preserved_write_buffer_after_detach_ = write_buffer.Pass();
 
   owner_ = NULL;
   if (ShouldSelfDestruct())
     delete this;
 }
 
 bool RawChannelWin::RawChannelIOHandler::ShouldSelfDestruct() const {
-  if (owner_)
+  if (owner_ || suppress_self_destruct_)
     return false;
 
   // Note: Detached, hence no lock needed for |pending_write_|.
   return !pending_read_ && !pending_write_;
 }
 
 void RawChannelWin::RawChannelIOHandler::OnReadCompleted(DWORD bytes_read,
                                                          DWORD error) {
   DCHECK(!owner_ ||
          base::MessageLoop::current() == owner_->message_loop_for_io());
+  DCHECK(suppress_self_destruct_);
 
   CHECK(pending_read_);
   pending_read_ = false;
   if (!owner_)
     return;
 
   if (error != ERROR_SUCCESS) {
     DCHECK_EQ(bytes_read, 0u);
     PLOG_IF(ERROR, error != ERROR_BROKEN_PIPE) << "ReadFile";
     owner_->OnReadCompleted(false, 0);
   } else {
     DCHECK_GT(bytes_read, 0u);
     owner_->OnReadCompleted(true, bytes_read);
   }
 }
 
 void RawChannelWin::RawChannelIOHandler::OnWriteCompleted(DWORD bytes_written,
                                                           DWORD error) {
   DCHECK(!owner_ ||
          base::MessageLoop::current() == owner_->message_loop_for_io());
+  DCHECK(suppress_self_destruct_);
 
   if (!owner_) {
     // No lock needed.
     CHECK(pending_write_);
     pending_write_ = false;
     return;
   }
 
   {
     base::AutoLock locker(owner_->write_lock());
@@ skipping 203 matching lines @@
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return scoped_ptr<RawChannel>(new RawChannelWin(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo