Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / mojo / system / message_pipe_unittest.cc

diff --git a/src/mojo/system/message_pipe_unittest.cc b/src/mojo/system/message_pipe_unittest.cc
index 5405fd5..d0aae93 100644 (file)
--- a/src/mojo/system/message_pipe_unittest.cc
+++ b/src/mojo/system/message_pipe_unittest.cc
@@ -40,8 +40,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kBufferSize, buffer_size);
   EXPECT_EQ(123, buffer[0]);
@@ -53,8 +55,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(1,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Write from port 1 (to port 0).
@@ -62,7 +66,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(1,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ -72,8 +77,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(789012345, buffer[0]);
@@ -83,8 +90,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Write two messages from port 0 (to port 1).
@@ -92,14 +101,16 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   buffer[0] = 234567890;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ -108,8 +119,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = 0;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             mp->ReadMessage(1,
-                            NULL, &buffer_size,
-                            0, NULL,
+                            NullUserPointer(),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
@@ -120,8 +133,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             mp->ReadMessage(1,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(123, buffer[0]);
@@ -133,8 +148,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->ReadMessage(1,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(123456789, buffer[0]);
@@ -146,8 +163,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->ReadMessage(1,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(234567890, buffer[0]);
@@ -157,8 +176,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(1,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Write from port 0 (to port 1).
@@ -166,7 +187,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ -178,7 +200,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             mp->WriteMessage(1,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ -188,8 +211,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->ReadMessage(1,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(345678901, buffer[0]);
@@ -199,8 +224,10 @@ TEST(MessagePipeTest, Basic) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             mp->ReadMessage(1,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   mp->Close(1);
@@ -218,7 +245,8 @@ TEST(MessagePipeTest, CloseWithQueuedIncomingMessages) {
     buffer[0] = i;
     EXPECT_EQ(MOJO_RESULT_OK,
               mp->WriteMessage(1,
-                               buffer, kBufferSize,
+                               UserPointer<const void>(buffer),
+                               kBufferSize,
                                NULL,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
@@ -227,8 +255,10 @@ TEST(MessagePipeTest, CloseWithQueuedIncomingMessages) {
   buffer_size = 0;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             mp->ReadMessage(0,
-                            NULL, &buffer_size,
-                            0, NULL,
+                            NullUserPointer(),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kBufferSize, buffer_size);
 
@@ -249,7 +279,8 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(1,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ -257,8 +288,10 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer_size = 0;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             mp->ReadMessage(0,
-                            NULL, &buffer_size,
-                            0, NULL,
+                            NullUserPointer(),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
@@ -266,8 +299,10 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // Write from port 1 (to port 0).
@@ -275,7 +310,8 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(1,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ -285,8 +321,10 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(890123456, buffer[0]);
@@ -296,8 +334,10 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // Write from port 1 (to port 0).
@@ -305,7 +345,8 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(1,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ -313,8 +354,10 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
@@ -322,8 +365,10 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // Write from port 1 (to port 0).
@@ -331,7 +376,8 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(1,
-                             buffer, static_cast<uint32_t>(sizeof(buffer[0])),
+                             UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ -339,16 +385,20 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             mp->ReadMessage(0,
-                            NULL, NULL,
-                            0, NULL,
+                            NullUserPointer(),
+                            NullUserPointer(),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(0,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   mp->Close(0);
@@ -358,6 +408,7 @@ TEST(MessagePipeTest, DiscardMode) {
 TEST(MessagePipeTest, BasicWaiting) {
   scoped_refptr<MessagePipe> mp(new MessagePipe());
   Waiter waiter;
+  HandleSignalsState hss;
 
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
@@ -365,74 +416,115 @@ TEST(MessagePipeTest, BasicWaiting) {
 
   // Always writable (until the other port is closed).
   waiter.Init();
+  hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
+            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfiable_signals);
   waiter.Init();
-  EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(0,
-                          &waiter,
-                          MOJO_HANDLE_SIGNAL_READABLE |
-                              MOJO_HANDLE_SIGNAL_WRITABLE,
-                          0));
+  hss = HandleSignalsState();
+  EXPECT_EQ(
+      MOJO_RESULT_ALREADY_EXISTS,
+      mp->AddWaiter(0,
+                    &waiter,
+                    MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+                    0,
+                    &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfiable_signals);
 
   // Not yet readable.
   waiter.Init();
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 1));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, NULL));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, NULL));
-  mp->RemoveWaiter(0, &waiter);
+  hss = HandleSignalsState();
+  mp->RemoveWaiter(0, &waiter, &hss);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfiable_signals);
 
   // Write from port 0 (to port 1), to make port 1 readable.
   buffer[0] = 123456789;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0,
-                             buffer, kBufferSize,
+                             UserPointer<const void>(buffer),
+                             kBufferSize,
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Port 1 should already be readable now.
   waiter.Init();
+  hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 2));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfiable_signals);
   waiter.Init();
-  EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1,
-                          &waiter,
-                          MOJO_HANDLE_SIGNAL_READABLE |
-                              MOJO_HANDLE_SIGNAL_WRITABLE,
-                          0));
+  hss = HandleSignalsState();
+  EXPECT_EQ(
+      MOJO_RESULT_ALREADY_EXISTS,
+      mp->AddWaiter(1,
+                    &waiter,
+                    MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+                    0,
+                    &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfiable_signals);
   // ... and still writable.
   waiter.Init();
+  hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3, &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfiable_signals);
 
   // Close port 0.
   mp->Close(0);
 
   // Now port 1 should not be writable.
   waiter.Init();
+  hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
   // But it should still be readable.
   waiter.Init();
+  hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 5));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
   // Read from port 1.
   buffer[0] = 0;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->ReadMessage(1,
-                            buffer, &buffer_size,
-                            0, NULL,
+                            UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size),
+                            0,
+                            NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(123456789, buffer[0]);
 
   // Now port 1 should no longer be readable.
   waiter.Init();
+  hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 6));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 6, NULL));
+  EXPECT_EQ(0u, hss.satisfied_signals);
+  EXPECT_EQ(0u, hss.satisfiable_signals);
 
   mp->Close(1);
 }
@@ -450,20 +542,26 @@ TEST(MessagePipeTest, ThreadedWaiting) {
     test::SimpleWaiterThread thread(&result, &context);
 
     thread.waiter()->Init();
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
-                            1));
+    ASSERT_EQ(MOJO_RESULT_OK,
+              mp->AddWaiter(
+                  1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1, NULL));
     thread.Start();
 
     buffer[0] = 123456789;
     // Write from port 0 (to port 1), which should wake up the waiter.
     EXPECT_EQ(MOJO_RESULT_OK,
               mp->WriteMessage(0,
-                               buffer, kBufferSize,
+                               UserPointer<const void>(buffer),
+                               kBufferSize,
                                NULL,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
-    mp->RemoveWaiter(1, thread.waiter());
+    HandleSignalsState hss;
+    mp->RemoveWaiter(1, thread.waiter(), &hss);
+    EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+              hss.satisfied_signals);
+    EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+              hss.satisfiable_signals);
 
     mp->Close(0);
     mp->Close(1);
@@ -478,9 +576,9 @@ TEST(MessagePipeTest, ThreadedWaiting) {
     test::SimpleWaiterThread thread(&result, &context);
 
     thread.waiter()->Init();
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
-                            2));
+    ASSERT_EQ(MOJO_RESULT_OK,
+              mp->AddWaiter(
+                  1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2, NULL));
     thread.Start();
 
     // Close port 1 first -- this should result in the waiter being cancelled.
@@ -501,9 +599,9 @@ TEST(MessagePipeTest, ThreadedWaiting) {
     test::SimpleWaiterThread thread(&result, &context);
 
     thread.waiter()->Init();
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
-                            3));
+    ASSERT_EQ(MOJO_RESULT_OK,
+              mp->AddWaiter(
+                  1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3, NULL));
     thread.Start();
 
     // Close port 0 first -- this should wake the waiter up, since port 1 will
@@ -511,7 +609,10 @@ TEST(MessagePipeTest, ThreadedWaiting) {
     mp->CancelAllWaiters(0);
     mp->Close(0);
 
-    mp->RemoveWaiter(1, thread.waiter());
+    HandleSignalsState hss;
+    mp->RemoveWaiter(1, thread.waiter(), &hss);
+    EXPECT_EQ(0u, hss.satisfied_signals);
+    EXPECT_EQ(0u, hss.satisfiable_signals);
 
     mp->CancelAllWaiters(1);
     mp->Close(1);