Allow data pipe producer/consumer handles to be transferred during two-phase operations.

mojo/edk/system/core_unittest.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/core.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 1624 matching lines @@
                              MakeUserPointer(&num_bytes),
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
 
   ph = ph_received;
   ph_received = MOJO_HANDLE_INVALID;
   ch = ch_received;
   ch_received = MOJO_HANDLE_INVALID;
 
-  // Make sure that |ph| can't be sent if it's in a two-phase write.
+  // Sending |ph| during a two-phase write cancels the two-phase write.
   void* write_ptr = nullptr;
   num_bytes = 0;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginWriteData(ph, MakeUserPointer(&write_ptr),
                                    MakeUserPointer(&num_bytes),
                                    MOJO_WRITE_DATA_FLAG_NONE));
+  ASSERT_TRUE(write_ptr);
   ASSERT_GE(num_bytes, 1u);
-  EXPECT_EQ(MOJO_RESULT_BUSY,
+  EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
                                  kHelloSize, MakeUserPointer(&ph), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
+  ph = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
+                         NullUserPointer()));
+  num_bytes = kBufferSize;
+  num_handles = MOJO_ARRAYSIZE(handles);
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->ReadMessage(
+                h_passing[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(kHelloSize, num_bytes);
+  EXPECT_STREQ(kHello, buffer);
+  EXPECT_EQ(1u, num_handles);
+  ph = handles[0];
+  EXPECT_NE(ph, MOJO_HANDLE_INVALID);
+  // The two-phase write is over, so trying to complete it will fail.
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->EndWriteData(ph, 0));
+  // And we can begin a two-phase write on the new handle.
+  write_ptr = nullptr;
+  num_bytes = 0;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            core()->BeginWriteData(ph, MakeUserPointer(&write_ptr),
+                                   MakeUserPointer(&num_bytes),
+                                   MOJO_WRITE_DATA_FLAG_NONE));
+  ASSERT_TRUE(write_ptr);
+  ASSERT_GE(num_bytes, 1u);
 
-  // But |ch| can, even if |ph| is in a two-phase write.
+  // |ch| can be sent, even if |ph| is in a two-phase write.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
                                  kHelloSize, MakeUserPointer(&ch), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   ch = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          NullUserPointer()));
   num_bytes = kBufferSize;
   num_handles = MOJO_ARRAYSIZE(handles);
@@ skipping 15 matching lines @@
   // Wait for |ch| to be readable.
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE,
                                          1000000000, MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
-  // Make sure that |ch| can't be sent if it's in a two-phase read.
+  // Sending |ch| during a two-phase read cancels the two-phase read.
   const void* read_ptr = nullptr;
-  num_bytes = 1;
+  num_bytes = 0;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
                                   MakeUserPointer(&num_bytes),
                                   MOJO_READ_DATA_FLAG_NONE));
-  EXPECT_EQ(MOJO_RESULT_BUSY,
+  ASSERT_TRUE(read_ptr);
+  EXPECT_EQ(1u, num_bytes);
+  EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
                                  kHelloSize, MakeUserPointer(&ch), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
+  ch = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
+                         NullUserPointer()));
+  num_bytes = kBufferSize;
+  num_handles = MOJO_ARRAYSIZE(handles);
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->ReadMessage(
+                h_passing[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(kHelloSize, num_bytes);
+  EXPECT_STREQ(kHello, buffer);
+  EXPECT_EQ(1u, num_handles);
+  ch = handles[0];
+  EXPECT_NE(ch, MOJO_HANDLE_INVALID);
+  // The two-phase read is over, so trying to complete it will fail.
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->EndReadData(ch, 1));
+  // And we can begin a two-phase read on the new handle.
+  read_ptr = nullptr;
+  num_bytes = 0;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
+                                  MakeUserPointer(&num_bytes),
+                                  MOJO_READ_DATA_FLAG_NONE));
+  ASSERT_TRUE(read_ptr);
+  EXPECT_EQ(1u, num_bytes);
 
-  // But |ph| can, even if |ch| is in a two-phase read.
+  // |ph| can be sent, even if |ch| is in a two-phase write.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
                                  kWorldSize, MakeUserPointer(&ph), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   ph = MOJO_HANDLE_INVALID;
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ skipping 140 matching lines @@
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 }
 
 // TODO(vtl): Test |CreateSharedBuffer()|, |DuplicateBufferHandle()|, and
 // |MapBuffer()|.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo