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

mojo/edk/system/raw_channel_unittest.cc

 // Copyright 2014 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 <stdint.h>
 #include <stdio.h>
 
 #include <vector>
@@ skipping 460 matching lines @@
   RawChannel* rc = RawChannel::Create(handles[0].Pass());
   test_io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&InitOnIOThread, rc, base::Unretained(&delegate)));
 
   // Close the handle of the other end, which should make writing fail.
   handles[1].reset();
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 
-  // We should get a write error.
-  delegate.WaitForWriteError();
-
-  // We should also get a read error.
+  // We should get a shutdown error.
   delegate.WaitForReadError();
 
-  EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(2)));
-
   // Sleep a bit, to make sure we don't get another |OnError()|
   // notification. (If we actually get another one, |OnError()| crashes.)
   test::Sleep(test::DeadlineFromMilliseconds(20));
 
   test_io_thread()->PostTaskAndWait(
       FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(rc)));
 }
 
 // RawChannelTest.ReadUnaffectedByWriteError -----------------------------------
 
 TEST_F(RawChannelTest, ReadUnaffectedByWriteError) {
   const size_t kMessageCount = 5;
 
   // Write a few messages into the other end.
+  RawChannel* other = RawChannel::Create(handles[1].Pass());
+  WriteOnlyRawChannelDelegate write_delegate;
+  test_io_thread()->PostTaskAndWait(
+      FROM_HERE,
+      base::Bind(&InitOnIOThread, other, base::Unretained(&write_delegate)));
   uint32_t message_size = 1;
   for (size_t i = 0; i < kMessageCount;
        i++, message_size += message_size / 2 + 1)
-    EXPECT_TRUE(WriteTestMessageToHandle(handles[1].get(), message_size));
+    EXPECT_TRUE(other->WriteMessage(MakeTestMessage(message_size)));
 
   // Close the other end, which should make writing fail.
-  handles[1].reset();
+  test_io_thread()->PostTaskAndWait(
+      FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(other)));
 
-  // Only start up reading here. The system buffer should still contain the
-  // messages that were written.
+  // Only start up reading here. The RawChannel ensures that it won't close the
+  // pipe until the other end read everything.
   ErrorRecordingRawChannelDelegate delegate(kMessageCount, true, true);
   RawChannel* rc = RawChannel::Create(handles[0].Pass());
   test_io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&InitOnIOThread, rc, base::Unretained(&delegate)));
 
-  EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
-
-  // We should definitely get a write error.
-  delegate.WaitForWriteError();
-
   // Wait for reading to finish. A writing failure shouldn't affect reading.
   delegate.Wait();
 
   // And then we should get a read error.
   delegate.WaitForReadError();
 
   test_io_thread()->PostTaskAndWait(
       FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(rc)));
 }
 
@@ skipping 118 matching lines @@
       FROM_HERE,
       base::Bind(&RawChannel::Shutdown, base::Unretained(rc_read)));
   test_io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&RawChannel::Shutdown, base::Unretained(rc_write)));
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo