EDK: Add implementation of data pipe consumer read threshold stuff.

mojo/public/platform/native/system_impl_private_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.
 
 // This file tests the C API, but using the explicit MojoSystemImpl parameter.
 
 #include <string.h>
 
 #include "mojo/public/platform/native/system_impl_private.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
-const MojoHandleSignals kSignalReadadableWritable =
-    MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE;
-
-const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE |
-                                     MOJO_HANDLE_SIGNAL_WRITABLE |
-                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED;
-
 TEST(SystemImplTest, GetTimeTicksNow) {
   MojoSystemImpl system = MojoSystemImplCreateImpl();
   const MojoTimeTicks start = MojoSystemImplGetTimeTicksNow(system);
   EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
       << "MojoGetTimeTicksNow should return nonzero value";
 
   // SystemImpl is leaked...
 }
 
 TEST(SystemImplTest, BasicMessagePipe) {
@@ skipping 16 matching lines @@
   // Move the other end of the pipe to a different SystemImpl.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplTransferHandle(sys0, h1, sys1, &h1));
   EXPECT_NE(h1, MOJO_HANDLE_INVALID);
 
   // Shouldn't be readable, we haven't written anything.
   MojoHandleSignalsState state;
   EXPECT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       MojoSystemImplWait(sys0, h0, MOJO_HANDLE_SIGNAL_READABLE, 0, &state));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals);
-  EXPECT_EQ(kSignalAll, state.satisfiable_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
+                MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            state.satisfiable_signals);
 
   // Should be writable.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       MojoSystemImplWait(sys0, h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &state));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals);
-  EXPECT_EQ(kSignalAll, state.satisfiable_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
+                MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            state.satisfiable_signals);
 
   // Last parameter is optional.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       MojoSystemImplWait(sys0, h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, nullptr));
 
   // Try to read.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             MojoSystemImplReadMessage(sys0, h0, buffer, &buffer_size, nullptr,
                                       nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Write to |h1|.
   static const char kHello[] = "hello";
   buffer_size = static_cast<uint32_t>(sizeof(kHello));
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplWriteMessage(sys1, h1, kHello, buffer_size, nullptr,
                                        0, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // |h0| should be readable.
   uint32_t result_index = 1;
   MojoHandleSignalsState states[1];
   sig = MOJO_HANDLE_SIGNAL_READABLE;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplWaitMany(sys0, &h0, &sig, 1, MOJO_DEADLINE_INDEFINITE,
                                    &result_index, states));
 
   EXPECT_EQ(0u, result_index);
-  EXPECT_EQ(kSignalReadadableWritable, states[0].satisfied_signals);
-  EXPECT_EQ(kSignalAll, states[0].satisfiable_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            states[0].satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
+                MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            states[0].satisfiable_signals);
 
   // Read from |h0|.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplReadMessage(sys0, h0, buffer, &buffer_size, nullptr,
                                       nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(kHello)), buffer_size);
   EXPECT_STREQ(kHello, buffer);
 
   // |h0| should no longer be readable.
   EXPECT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       MojoSystemImplWait(sys0, h0, MOJO_HANDLE_SIGNAL_READABLE, 10, &state));
 
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals);
-  EXPECT_EQ(kSignalAll, state.satisfiable_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
+                MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            state.satisfiable_signals);
 
   // Close |h0|.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplClose(sys0, h0));
 
   // |h1| should no longer be readable or writable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             MojoSystemImplWait(sys1, h1, MOJO_HANDLE_SIGNAL_READABLE |
                                              MOJO_HANDLE_SIGNAL_WRITABLE,
                                1000, &state));
 
@@ skipping 28 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplTransferHandle(sys0, hc, sys1, &hc));
   EXPECT_NE(hc, MOJO_HANDLE_INVALID);
 
   // The consumer |hc| shouldn't be readable.
   MojoHandleSignalsState state;
   EXPECT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       MojoSystemImplWait(sys1, hc, MOJO_HANDLE_SIGNAL_READABLE, 0, &state));
 
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             state.satisfiable_signals);
 
   // The producer |hp| should be writable.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       MojoSystemImplWait(sys0, hp, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &state));
 
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             state.satisfiable_signals);
@@ skipping 20 matching lines @@
 
   // |hc| should be(come) readable.
   uint32_t result_index = 1;
   MojoHandleSignalsState states[1];
   sig = MOJO_HANDLE_SIGNAL_READABLE;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplWaitMany(sys1, &hc, &sig, 1, MOJO_DEADLINE_INDEFINITE,
                                    &result_index, states));
 
   EXPECT_EQ(0u, result_index);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, states[0].satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
+            states[0].satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             states[0].satisfiable_signals);
 
   // Do a two-phase write to |hp|.
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplBeginWriteData(sys0, hp, &write_pointer, &buffer_size,
                                          MOJO_WRITE_DATA_FLAG_NONE));
   static const char kWorld[] = "world";
   ASSERT_GE(buffer_size, sizeof(kWorld));
   // Include the terminating null.
   memcpy(write_pointer, kWorld, sizeof(kWorld));
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplEndWriteData(sys0, hp,
                                        static_cast<uint32_t>(sizeof(kWorld))));
 
   // Read one character from |hc|.
   memset(buffer, 0, sizeof(buffer));
   buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplReadData(sys1, hc, buffer, &buffer_size,
                                    MOJO_READ_DATA_FLAG_NONE));
 
   // Close |hp|.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplClose(sys0, hp));
 
   // |hc| should still be readable.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       MojoSystemImplWait(sys1, hc, MOJO_HANDLE_SIGNAL_READABLE, 0, &state));
 
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             state.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             state.satisfiable_signals);
 
   // Do a two-phase read from |hc|.
   read_pointer = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplBeginReadData(sys1, hc, &read_pointer, &buffer_size,
                                         MOJO_READ_DATA_FLAG_NONE));
   ASSERT_LE(buffer_size, sizeof(buffer) - 1);
   memcpy(&buffer[1], read_pointer, buffer_size);
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplEndReadData(sys1, hc, buffer_size));
@@ skipping 92 matching lines @@
   // Unmap it.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplUnmapBuffer(sys1, pointer));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplClose(sys1, h1));
 
   // 2 SystemImpls are leaked...
 }
 
 }  // namespace
 }  // namespace mojo