Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

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>
 
 #include "base/bind.h"
+#include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/system/awakable.h"
 #include "mojo/edk/system/core_test_base.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
-namespace system {
+namespace edk {
 namespace {
 
 const MojoHandleSignalsState kEmptyMojoHandleSignalsState = {0u, 0u};
 const MojoHandleSignalsState kFullMojoHandleSignalsState = {~0u, ~0u};
 const MojoHandleSignals kAllSignals = MOJO_HANDLE_SIGNAL_READABLE |
                                       MOJO_HANDLE_SIGNAL_WRITABLE |
                                       MOJO_HANDLE_SIGNAL_PEER_CLOSED;
 
 using CoreTest = test::CoreTestBase;
 
@@ skipping 622 matching lines @@
   // Write to |h[0]|.
   buffer[0] = 'd';
   EXPECT_EQ(
       MOJO_RESULT_OK,
       core()->WriteMessage(h[0], UserPointer<const void>(buffer), 1,
                            NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Close |h[0]|.
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
 
+  // Wait for |h[1]| to learn about the other end's closure.
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_PEER_CLOSED, 1000000000,
+                         MakeUserPointer(&hss[0])));
+
   // Check that |h[1]| is no longer writable (and will never be).
   hss[0] = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000,
                          MakeUserPointer(&hss[0])));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss[0].satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss[0].satisfiable_signals);
 
@@ skipping 222 matching lines @@
 
   // Write.
   signed char elements[2] = {'A', 'B'};
   uint32_t num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph, UserPointer<const void>(elements),
                               MakeUserPointer(&num_bytes),
                               MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(2u, num_bytes);
 
+  // Wait for the data to arrive to the consumer.
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
+                         MakeUserPointer(&hss)));
+
   // Consumer should now be readable.
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0,
                                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Peek one character.
   elements[0] = -1;
@@ skipping 33 matching lines @@
             core()->WriteData(ph, UserPointer<const void>(elements),
                               MakeUserPointer(&num_bytes),
                               MOJO_WRITE_DATA_FLAG_NONE));
 
   // Actually write the data, and complete it now.
   static_cast<char*>(write_ptr)[0] = 'C';
   static_cast<char*>(write_ptr)[1] = 'D';
   static_cast<char*>(write_ptr)[2] = 'E';
   EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 3u));
 
+  // Wait for the data to arrive to the consumer.
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
+                         MakeUserPointer(&hss)));
+
   // Query how much data we have.
   num_bytes = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                              MOJO_READ_DATA_FLAG_QUERY));
-  EXPECT_EQ(4u, num_bytes);
+  EXPECT_GE(num_bytes, 1u);
 
   // Try to query with peek. Should fail.
   num_bytes = 0;
   EXPECT_EQ(
       MOJO_RESULT_INVALID_ARGUMENT,
       core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                        MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK));
   EXPECT_EQ(0u, num_bytes);
 
   // Try to discard ten characters, in all-or-none mode. Should fail.
   num_bytes = 10;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
             core()->ReadData(
                 ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 
   // Try to discard two characters, in peek mode. Should fail.
   num_bytes = 2;
   EXPECT_EQ(
       MOJO_RESULT_INVALID_ARGUMENT,
       core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                        MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK));
 
-  // Discard two characters.
-  num_bytes = 2;
+  // Discard a character.
+  num_bytes = 1;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(
                 ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 
-  // Try a two-phase read of the remaining two bytes with peek. Should fail.
+  // Ensure the 3 bytes were read.
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
+                         MakeUserPointer(&hss)));
+
+  // Try a two-phase read of the remaining three bytes with peek. Should fail.
   const void* read_ptr = nullptr;
-  num_bytes = 2;
+  num_bytes = 3;
   ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
                                   MakeUserPointer(&num_bytes),
                                   MOJO_READ_DATA_FLAG_PEEK));
 
   // Read the remaining two characters, in two-phase mode (all-or-none).
-  num_bytes = 2;
+  num_bytes = 3;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
                                   MakeUserPointer(&num_bytes),
                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
   // Note: Count on still being able to do the contiguous read here.
-  ASSERT_EQ(2u, num_bytes);
+  ASSERT_EQ(3u, num_bytes);
 
   // Discarding right now should fail.
   num_bytes = 1;
   EXPECT_EQ(MOJO_RESULT_BUSY,
             core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                              MOJO_READ_DATA_FLAG_DISCARD));
 
   // Actually check our data and end the two-phase read.
-  EXPECT_EQ('D', static_cast<const char*>(read_ptr)[0]);
-  EXPECT_EQ('E', static_cast<const char*>(read_ptr)[1]);
-  EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 2u));
+  EXPECT_EQ('C', static_cast<const char*>(read_ptr)[0]);
+  EXPECT_EQ('D', static_cast<const char*>(read_ptr)[1]);
+  EXPECT_EQ('E', static_cast<const char*>(read_ptr)[2]);
+  EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 3u));
 
   // Consumer should now be no longer readable.
   hss = kFullMojoHandleSignalsState;
   EXPECT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // TODO(vtl): More.
 
   // Close the producer.
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
 
+  // Wait for this to get to the consumer.
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 1000000000,
+                         MakeUserPointer(&hss)));
+
   // The consumer should now be never-readable.
   hss = kFullMojoHandleSignalsState;
   EXPECT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
       core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 }
@@ skipping 262 matching lines @@
 
   EXPECT_FALSE(info.GetAddedAwakableAt(0)->Awake(MOJO_RESULT_BUSY, 0));
   EXPECT_EQ(MOJO_RESULT_BUSY, waiter.result);
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 }
 
 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
 
 }  // namespace
-}  // namespace system
+}  // namespace edk
 }  // namespace mojo