Last set of fixes to make the src/mojo/edk pass the page cycler.

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/stat.h>
 #include <sys/uio.h>
 #include <unistd.h>
@@ skipping 351 matching lines @@
 
   if (!pending_read_) {
     NOTREACHED();
     return;
   }
 
   pending_read_ = false;
   size_t bytes_read = 0;
   IOResult io_result = Read(&bytes_read);
   if (io_result != IO_PENDING) {
-    OnReadCompleted(io_result, bytes_read);
+    base::AutoLock locker(read_lock());
+    OnReadCompletedNoLock(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
@@ skipping 14 matching lines @@
   {
     base::AutoLock locker(write_lock());
 
     DCHECK(pending_write_);
 
     pending_write_ = false;
     io_result = WriteNoLock(&platform_handles_written, &bytes_written);
   }
 
   if (io_result != IO_PENDING) {
-    OnWriteCompleted(io_result, platform_handles_written, bytes_written);
-    return;  // |this| may have been destroyed in |OnWriteCompleted()|.
+    base::AutoLock locker(write_lock());
+    OnWriteCompletedNoLock(io_result, platform_handles_written, bytes_written);
+    return;
   }
 }
 
 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 = PlatformChannelRecvmsg(
@@ skipping 37 matching lines @@
 }
 
 void RawChannelPosix::WaitToWrite() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
 
   DCHECK(write_watcher_);
 
   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()|.
+    base::AutoLock locker(write_lock());
+    DCHECK(pending_write_);
+    pending_write_ = false;
+    OnWriteCompletedNoLock(IO_FAILED_UNKNOWN, 0, 0);
+    return;
   }
 }
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Static factory method declared in raw_channel.h.
 // static
 RawChannel* RawChannel::Create(ScopedPlatformHandle handle) {
@@ skipping 13 matching lines @@
   struct stat stat1, stat2;
   if (fstat(this_handle.fd, &stat1) < 0)
     return false;
   if (fstat(other_handle.fd, &stat2) < 0)
     return false;
   return (stat1.st_dev == stat2.st_dev) && (stat1.st_ino == stat2.st_ino);
 }
 
 }  // namespace edk
 }  // namespace mojo