Mojo: Add signal for new data pipe consumer data

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 828 matching lines @@
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Consumer should be never-writable, and not yet readable.
   hss = kFullMojoHandleSignalsState;
   ASSERT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
       core()->Wait(ch, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
   ASSERT_EQ(0u, hss.satisfied_signals);
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
             hss.satisfiable_signals);
   hss = kFullMojoHandleSignalsState;
   ASSERT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
   ASSERT_EQ(0u, hss.satisfied_signals);
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
             hss.satisfiable_signals);
 
   // Write.
   signed char elements[2] = {'A', 'B'};
   uint32_t num_bytes = 2u;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph, elements, &num_bytes,
                               MOJO_WRITE_DATA_FLAG_NONE));
   ASSERT_EQ(2u, num_bytes);
 
   // Wait for the data to arrive to the consumer.
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, &hss));
 
   // Consumer should now be readable.
   hss = kEmptyMojoHandleSignalsState;
   ASSERT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0,
                                          &hss));
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
+            hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
             hss.satisfiable_signals);
 
   // Peek one character.
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = 1u;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->ReadData(
                 ch, elements, &num_bytes,
                 MOJO_READ_DATA_FLAG_NONE | MOJO_READ_DATA_FLAG_PEEK));
@@ skipping 100 matching lines @@
   ASSERT_EQ('C', static_cast<const char*>(read_ptr)[0]);
   ASSERT_EQ('D', static_cast<const char*>(read_ptr)[1]);
   ASSERT_EQ('E', static_cast<const char*>(read_ptr)[2]);
   ASSERT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 3u));
 
   // Consumer should now be no longer readable.
   hss = kFullMojoHandleSignalsState;
   ASSERT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
-  ASSERT_EQ(0u, hss.satisfied_signals);
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(0u, hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
             hss.satisfiable_signals);
 
   // TODO(vtl): More.
 
   // Close the producer.
   ASSERT_EQ(MOJO_RESULT_OK, core()->Close(ph));
 
   // Wait for this to get to the consumer.
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->Wait(ch, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 1000000000, &hss));
@@ skipping 65 matching lines @@
 
   // Write to |ph|. Should receive on |ch_received|.
   num_bytes = kWorldSize;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph, kWorld, &num_bytes,
                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   hss = kEmptyMojoHandleSignalsState;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          &hss));
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
+            hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
             hss.satisfiable_signals);
   num_bytes = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->ReadData(ch_received, buffer, &num_bytes,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   ASSERT_EQ(kWorldSize, num_bytes);
   ASSERT_STREQ(kWorld, buffer);
 
   // Now pass |ph| in the same direction.
   ASSERT_EQ(MOJO_RESULT_OK,
@@ skipping 30 matching lines @@
 
   // Write to |ph_received|. Should receive on |ch_received|.
   num_bytes = kHelloSize;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph_received, kHello, &num_bytes,
                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   hss = kEmptyMojoHandleSignalsState;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          &hss));
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
+            hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
             hss.satisfiable_signals);
   num_bytes = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->ReadData(ch_received, buffer, &num_bytes,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   ASSERT_EQ(kHelloSize, num_bytes);
   ASSERT_STREQ(kHello, buffer);
 
   ph = ph_received;
   ph_received = MOJO_HANDLE_INVALID;
@@ skipping 32 matching lines @@
   ASSERT_NE(ch, MOJO_HANDLE_INVALID);
 
   // Complete the two-phase write.
   static_cast<char*>(write_ptr)[0] = 'x';
   ASSERT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 1));
 
   // Wait for |ch| to be readable.
   hss = kEmptyMojoHandleSignalsState;
   ASSERT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE,
                                          1000000000, &hss));
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
-  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
+            hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
             hss.satisfiable_signals);
 
   // Make sure that |ch| can't be sent if it's in a two-phase read.
   const void* read_ptr = nullptr;
   num_bytes = 1;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginReadData(ch, &read_ptr, &num_bytes,
                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(MOJO_RESULT_BUSY,
             core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1,
@@ skipping 39 matching lines @@
   void Awake(MojoResult r) { result = r; }
 
   MojoResult result;
 };
 
 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo