[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 356 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));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);

[Anand Mistry (off Chromium), 2016/01/08 03:28:02]

EXPECT_EQ and next one.

[Eliot Courtney, 2016/01/08 04:44:39]

Done.

+  ASSERT_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));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);

[Anand Mistry (off Chromium), 2016/01/08 03:28:02]

EXPECT_EQ and next one.

[Eliot Courtney, 2016/01/08 04:44:40]

Done.

+  ASSERT_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(hss.satisfied_signals & MOJO_HANDLE_SIGNAL_PEER_CLOSED, 0u);
   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 1259 matching lines @@
   EXPECT_TRUE(WriteAllData(producer, kMultiprocessTestData, kTestDataSize));
 
   // We swapped ends, so close the producer.
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo