[mojo] Implement data pipe using a shared buffer.

mojo/edk/system/data_pipe_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 349 matching lines @@
 
   // Read one element.
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   ASSERT_EQ(MOJO_RESULT_OK, ReadData(elements, &num_bytes, true, false));
   ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   ASSERT_EQ(123, elements[0]);
   ASSERT_EQ(-1, elements[1]);
 
+  // Wait until we can write.
+  hss = MojoHandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            hss.satisfiable_signals);
+
   // Try writing, using a two-phase write.
   void* buffer = nullptr;
   num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
   ASSERT_EQ(MOJO_RESULT_OK, BeginWriteData(&buffer, &num_bytes));
   EXPECT_TRUE(buffer);
   ASSERT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(elements[0])));
 
   static_cast<int32_t*>(buffer)[0] = 789;
   ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(static_cast<uint32_t>(
                                          1u * sizeof(elements[0]))));
 
   // Read one element, using a two-phase read.
   const void* read_buffer = nullptr;
   num_bytes = 0u;
   ASSERT_EQ(MOJO_RESULT_OK,
             BeginReadData(&read_buffer, &num_bytes, false));
   EXPECT_TRUE(read_buffer);
   // Since we only read one element (after having written three in all), the
   // two-phase read should only allow us to read one. This checks an
   // implementation detail!
   ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   ASSERT_EQ(456, static_cast<const int32_t*>(read_buffer)[0]);
   ASSERT_EQ(MOJO_RESULT_OK, EndReadData(static_cast<uint32_t>(
                                         1u * sizeof(elements[0]))));
 
+  // Wait until we can write.
+  hss = MojoHandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            hss.satisfiable_signals);
+
   // Write one element.
   elements[0] = 123;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes));
   ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 
   // Close the consumer.
   CloseConsumer();
 
   // It should now be never-writable.
@@ skipping 150 matching lines @@
                      MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Wait for the peer closed signal.
   hss = MojoHandleSignalsState();
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoWait(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
                      MOJO_DEADLINE_INDEFINITE, &hss));
-  ASSERT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_PEER_CLOSED) != 0);
+  ASSERT_NE(0u, hss.satisfied_signals & MOJO_HANDLE_SIGNAL_PEER_CLOSED);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Read one element.
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   ASSERT_EQ(MOJO_RESULT_OK, ReadData(elements, &num_bytes, true));
   ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   ASSERT_EQ(789, elements[0]);
@@ skipping 1046 matching lines @@
   ASSERT_EQ(sizeof(read_data), num_bytes);
   ASSERT_EQ(data, read_data);
 
   ASSERT_EQ(MOJO_RESULT_OK, MojoClose(pipe0));
   ASSERT_EQ(MOJO_RESULT_OK, MojoClose(pipe1));
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo