Allow mojo::system::RawChannel::Delegate methods to destroy the RawChannel.

mojo/edk/system/raw_channel_posix.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/edk/system/raw_channel.h"
 
 #include <errno.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
@@ skipping 338 matching lines @@
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
 
   if (!pending_read_) {
     NOTREACHED();
     return;
   }
 
   pending_read_ = false;
   size_t bytes_read = 0;
   IOResult io_result = Read(&bytes_read);
-  if (io_result != IO_PENDING)
+  if (io_result != IO_PENDING) {
     OnReadCompleted(io_result, bytes_read);
+    // TODO(vtl): If we weren't destroyed, we'd like to do
+    //
+    //   DCHECK(!read_watcher_ || pending_read_);
+    //
+    // On failure, |read_watcher_| must have been reset; on success, we assume
+    // that |OnReadCompleted()| always schedules another read. Otherwise, we
+    // could end up spinning -- getting |OnFileCanReadWithoutBlocking()| again
+    // and again but not doing any actual read.
+    // TODO(yzshen): An alternative is to stop watching if RawChannel doesn't
+    // schedule a new read. But that code won't be reached under the current
+    // RawChannel implementation.
+    return;  // |this| may have been destroyed in |OnReadCompleted()|.
+  }
 
-  // On failure, |read_watcher_| must have been reset; on success,
-  // we assume that |OnReadCompleted()| always schedules another read.
-  // Otherwise, we could end up spinning -- getting
-  // |OnFileCanReadWithoutBlocking()| again and again but not doing any actual
-  // read.
-  // TODO(yzshen): An alternative is to stop watching if RawChannel doesn't
-  // schedule a new read. But that code won't be reached under the current
-  // RawChannel implementation.
-  DCHECK(!read_watcher_ || pending_read_);
+  DCHECK(pending_read_);
 }
 
 void RawChannelPosix::OnFileCanWriteWithoutBlocking(int fd) {
   DCHECK_EQ(fd, fd_.get().fd);
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
 
   IOResult io_result;
   size_t platform_handles_written = 0;
   size_t bytes_written = 0;
   {
     base::AutoLock locker(write_lock());
 
     DCHECK(pending_write_);
 
     pending_write_ = false;
     io_result = WriteNoLock(&platform_handles_written, &bytes_written);
   }
 
-  if (io_result != IO_PENDING)
+  if (io_result != IO_PENDING) {
     OnWriteCompleted(io_result, platform_handles_written, bytes_written);
+    return;  // |this| may have been destroyed in |OnWriteCompleted()|.
+  }
 }
 
 RawChannel::IOResult RawChannelPosix::ReadImpl(size_t* bytes_read) {
   char* buffer = nullptr;
   size_t bytes_to_read = 0;
   read_buffer()->GetBuffer(&buffer, &bytes_to_read);
 
   size_t old_num_platform_handles = read_platform_handles_.size();
   ssize_t read_result = embedder::PlatformChannelRecvmsg(
       fd_.get(), buffer, bytes_to_read, &read_platform_handles_);
@@ skipping 43 matching lines @@
   if (!message_loop_for_io()->WatchFileDescriptor(
           fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE,
           write_watcher_.get(), this)) {
     {
       base::AutoLock locker(write_lock());
 
       DCHECK(pending_write_);
       pending_write_ = false;
     }
     OnWriteCompleted(IO_FAILED_UNKNOWN, 0, 0);
+    return;  // |this| may have been destroyed in |OnWriteCompleted()|.
   }
 }
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return make_scoped_ptr(new RawChannelPosix(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo