Add an unconditional version of DispatcherAddAwakable(): AddAwakableUnconditional().

mojo/edk/system/data_pipe_impl_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 contains tests that are shared between different implementations of
 // |DataPipeImpl|.
 
 #include "mojo/edk/system/data_pipe_impl.h"
 
 #include <stdint.h>
@@ skipping 123 matching lines @@
   }
   MojoResult ProducerBeginWriteData(UserPointer<void*> buffer,
                                     UserPointer<uint32_t> buffer_num_bytes) {
     return dpp()->ProducerBeginWriteData(buffer, buffer_num_bytes);
   }
   MojoResult ProducerEndWriteData(uint32_t num_bytes_written) {
     return dpp()->ProducerEndWriteData(num_bytes_written);
   }
   MojoResult ProducerAddAwakable(Awakable* awakable,
                                  MojoHandleSignals signals,
+                                 bool force,
                                  uint64_t context,
                                  HandleSignalsState* signals_state) {
-    return dpp()->ProducerAddAwakable(awakable, signals, context,
+    return dpp()->ProducerAddAwakable(awakable, signals, force, context,
                                       signals_state);
   }
   void ProducerRemoveAwakable(Awakable* awakable,
                               HandleSignalsState* signals_state) {
     return dpp()->ProducerRemoveAwakable(awakable, signals_state);
   }
 
   void ConsumerClose() { helper_->ConsumerClose(); }
   MojoResult ConsumerSetOptions(uint32_t read_threshold_num_bytes) {
     return dpc()->ConsumerSetOptions(read_threshold_num_bytes);
@@ skipping 16 matching lines @@
   }
   MojoResult ConsumerBeginReadData(UserPointer<const void*> buffer,
                                    UserPointer<uint32_t> buffer_num_bytes) {
     return dpc()->ConsumerBeginReadData(buffer, buffer_num_bytes);
   }
   MojoResult ConsumerEndReadData(uint32_t num_bytes_read) {
     return dpc()->ConsumerEndReadData(num_bytes_read);
   }
   MojoResult ConsumerAddAwakable(Awakable* awakable,
                                  MojoHandleSignals signals,
+                                 bool force,
                                  uint64_t context,
                                  HandleSignalsState* signals_state) {
-    return dpc()->ConsumerAddAwakable(awakable, signals, context,
+    return dpc()->ConsumerAddAwakable(awakable, signals, force, context,
                                       signals_state);
   }
   void ConsumerRemoveAwakable(Awakable* awakable,
                               HandleSignalsState* signals_state) {
     return dpc()->ConsumerRemoveAwakable(awakable, signals_state);
   }
 
  private:
   DataPipe* dpp() { return helper_->DataPipeForProducer(); }
   DataPipe* dpc() { return helper_->DataPipeForConsumer(); }
@@ skipping 75 matching lines @@
                   const Handle& handle_to_send,
                   Handle* handle_to_receive) {
     DCHECK(source_i == 0 || source_i == 1);
     size_t dest_i = source_i ^ 1;
 
     // Write the dispatcher to MP |source_i| (port 0). Wait and receive on MP
     // |dest_i| (port 0). (Add the waiter first, to avoid any handling the case
     // where it's already readable.)
     Waiter waiter;
     waiter.Init();
-    ASSERT_EQ(MOJO_RESULT_OK,
-              message_pipe(dest_i)->AddAwakable(
-                  0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 987, nullptr));
+    ASSERT_EQ(MOJO_RESULT_OK, message_pipe(dest_i)->AddAwakable(
+                                  0, &waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                  false, 987, nullptr));
     {
       HandleTransport transport(test::HandleTryStartTransport(handle_to_send));
       ASSERT_TRUE(transport.is_valid());
 
       std::vector<HandleTransport> transports;
       transports.push_back(transport);
       ASSERT_EQ(MOJO_RESULT_OK, message_pipe(source_i)->WriteMessage(
                                     0, NullUserPointer(), 0, &transports,
                                     MOJO_WRITE_MESSAGE_FLAG_NONE));
       transport.End();
@@ skipping 369 matching lines @@
 
   // Read with invalid |num_bytes|.
   num_bytes = sizeof(elements[0]) + 1;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), false, false));
 
   // For remote data pipes, we'll have to wait; add the waiter before writing.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 123,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 123, nullptr));
 
   // Write two elements.
   elements[0] = 123;
   elements[1] = 456;
   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(elements),
                                     MakeUserPointer(&num_bytes), false));
   // It should have written everything (even without "all or none").
   EXPECT_EQ(2u * sizeof(elements[0]), num_bytes);
@@ skipping 106 matching lines @@
 
   Waiter pwaiter;  // For producer.
   Waiter cwaiter;  // For consumer.
   HandleSignalsState hss;
   uint64_t context;
 
   // Never readable.
   pwaiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_READABLE, 12,
-                                      &hss));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 12, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   // Already writable.
   pwaiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 34,
-                                      &hss));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 34, &hss));
 
   // We'll need to wait for readability for the remote cases.
   cwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE,
-                                      1234, nullptr));
+                                      false, 1234, nullptr));
 
   // Write two elements.
   int32_t elements[2] = {123, 456};
   uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(elements),
                                     MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
 
   // Adding a waiter should now succeed.
   pwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56,
-                                      nullptr));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 56, nullptr));
   // And it shouldn't be writable yet.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, pwaiter.Wait(0, nullptr));
   hss = HandleSignalsState();
   this->ProducerRemoveAwakable(&pwaiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   // Wait for data to become available to the consumer.
@@ skipping 15 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), true, true));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   EXPECT_EQ(123, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Add a waiter.
   pwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56,
-                                      nullptr));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 56, nullptr));
   // And it still shouldn't be writable yet.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, pwaiter.Wait(0, nullptr));
   hss = HandleSignalsState();
   this->ProducerRemoveAwakable(&pwaiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   // Do it again.
   pwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 78,
-                                      nullptr));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 78, nullptr));
 
   // Read one element.
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   EXPECT_EQ(123, elements[0]);
@@ skipping 20 matching lines @@
   EXPECT_TRUE(buffer);
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 
   static_cast<int32_t*>(buffer)[0] = 789;
   EXPECT_EQ(MOJO_RESULT_OK, this->ProducerEndWriteData(static_cast<uint32_t>(
                                 1u * sizeof(elements[0]))));
 
   // Add a waiter.
   pwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 90,
-                                      nullptr));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 90, nullptr));
 
   // Read one element, using a two-phase read.
   const void* read_buffer = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
                                         MakeUserPointer(&num_bytes)));
   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
@@ skipping 19 matching lines @@
   elements[0] = 123;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(elements),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 
   // Add a waiter.
   pwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12,
-                                      nullptr));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 12, nullptr));
 
   // Close the consumer.
   this->ConsumerClose();
 
   // It should now be never-writable.
   context = 0;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             pwaiter.Wait(test::TinyTimeout(), &context));
   EXPECT_EQ(12u, context);
   hss = HandleSignalsState();
@@ skipping 15 matching lines @@
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
   uint64_t context;
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      12, nullptr));
+                                      false, 12, nullptr));
 
   // Close the consumer.
   this->ConsumerClose();
 
   // It should be signaled.
   context = 0;
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), &context));
   EXPECT_EQ(12u, context);
   hss = HandleSignalsState();
   this->ProducerRemoveAwakable(&waiter, &hss);
@@ skipping 14 matching lines @@
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
   uint64_t context;
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      12, nullptr));
+                                      false, 12, nullptr));
 
   // Close the producer.
   this->ProducerClose();
 
   // It should be signaled.
   context = 0;
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), &context));
   EXPECT_EQ(12u, context);
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
@@ skipping 15 matching lines @@
 
   Waiter waiter;
   Waiter waiter2;
   HandleSignalsState hss;
   uint64_t context;
 
   // Never writable.
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12,
-                                      &hss));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 12, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Add waiter: not yet readable.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 34, nullptr));
 
   // Write two elements.
   int32_t elements[2] = {123, 456};
   uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(elements),
                                     MakeUserPointer(&num_bytes), true));
 
   // Wait for readability (needed for remote cases).
   context = 0;
@@ skipping 10 matching lines @@
   // Discard one element.
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 
   // Should still be readable.
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78,
-                                      &hss));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 78, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Peek one element.
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), true, true));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   EXPECT_EQ(456, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Should still be readable.
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78,
-                                      &hss));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 78, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Read one element.
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   EXPECT_EQ(456, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Adding a waiter should now succeed.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 90,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 90, nullptr));
 
   // Write one element.
   elements[0] = 789;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(elements),
                                     MakeUserPointer(&num_bytes), true));
 
   // Waiting should now succeed.
   context = 0;
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), &context));
   EXPECT_EQ(90u, context);
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // We'll want to wait for the peer closed signal to propagate.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      12, nullptr));
+                                      false, 12, nullptr));
 
   // Close the producer.
   this->ProducerClose();
 
   // Should still be readable, even if the peer closed signal hasn't propagated
   // yet.
   waiter2.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ConsumerAddAwakable(&waiter2, MOJO_HANDLE_SIGNAL_READABLE, 34,
-                                      &hss));
+            this->ConsumerAddAwakable(&waiter2, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 34, &hss));
   // We don't know if the peer closed signal has propagated yet (for the remote
   // cases).
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Wait for the peer closed signal.
   context = 0;
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), &context));
@@ skipping 15 matching lines @@
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   EXPECT_EQ(789, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Should be never-readable.
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56,
-                                      &hss));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 56, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   this->ConsumerClose();
 }
 
 // Test with two-phase APIs and also closing the producer with an active
 // consumer waiter.
 TYPED_TEST(DataPipeImplTest, ConsumerWaitingTwoPhase) {
   const MojoCreateDataPipeOptions options = {
       kSizeOfOptions,                           // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
   };
   this->Create(options);
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
   uint64_t context;
 
   // Add waiter: not yet readable.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 12, nullptr));
 
   // Write two elements.
   int32_t* elements = nullptr;
   void* buffer = nullptr;
   uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&buffer),
                                          MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(buffer);
   EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0])));
@@ skipping 25 matching lines @@
   EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
   const int32_t* read_elements = static_cast<const int32_t*>(read_buffer);
   EXPECT_EQ(123, read_elements[0]);
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(static_cast<uint32_t>(
                                 1u * sizeof(elements[0]))));
 
   // Should still be readable.
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34,
-                                      &hss));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 34, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Read one element.
   // Request three, but not in all-or-none mode.
   read_buffer = nullptr;
   num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
                                         MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(read_buffer);
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   read_elements = static_cast<const int32_t*>(read_buffer);
   EXPECT_EQ(456, read_elements[0]);
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(static_cast<uint32_t>(
                                 1u * sizeof(elements[0]))));
 
   // Adding a waiter should now succeed.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 56, nullptr));
 
   // Close the producer.
   this->ProducerClose();
 
   // Should be never-readable.
   context = 0;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             waiter.Wait(test::TinyTimeout(), &context));
   EXPECT_EQ(56u, context);
   hss = HandleSignalsState();
@@ skipping 16 matching lines @@
   this->DoTransfer();
 
   Waiter pwaiter;  // For producer.
   Waiter cwaiter;  // For consumer.
   HandleSignalsState hss;
 
   // It should be writable.
   pwaiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
-                                      &hss));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   void* write_ptr = nullptr;
   uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                          MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(write_ptr);
   EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
 
   // At this point, it shouldn't be writable.
   pwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 1,
-                                      nullptr));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 1, nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, pwaiter.Wait(0, nullptr));
   hss = HandleSignalsState();
   this->ProducerRemoveAwakable(&pwaiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   // It shouldn't be readable yet either (we'll wait later).
   cwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE, 2,
-                                      nullptr));
+            this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 2, nullptr));
 
   static_cast<int32_t*>(write_ptr)[0] = 123;
   EXPECT_EQ(MOJO_RESULT_OK, this->ProducerEndWriteData(
                                 static_cast<uint32_t>(1u * sizeof(int32_t))));
 
   // It should immediately be writable again.
   pwaiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3,
-                                      &hss));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 3, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   // It should become readable.
   EXPECT_EQ(MOJO_RESULT_OK, cwaiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&cwaiter, &hss);
@@ skipping 10 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                          MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(write_ptr);
   EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
 
   // It should be readable.
   cwaiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE, 5,
-                                      &hss));
+            this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 5, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // End the two-phase write without writing anything.
   EXPECT_EQ(MOJO_RESULT_OK, this->ProducerEndWriteData(0u));
 
   // Start a two-phase read.
   const void* read_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
                                         MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(read_ptr);
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes);
 
   // At this point, it should still be writable.
   pwaiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6,
-                                      &hss));
+            this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 6, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   // But not readable.
   cwaiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE, 7,
-                                      nullptr));
+            this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 7, nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, cwaiter.Wait(0, nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&cwaiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // End the two-phase read without reading anything.
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(0u));
 
   // It should be readable again.
   cwaiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE, 8,
-                                      &hss));
+            this->ConsumerAddAwakable(&cwaiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 8, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   this->ProducerClose();
   this->ConsumerClose();
 }
 
@@ skipping 25 matching lines @@
 
   // Should still be empty.
   num_bytes = ~0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Add waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 1, nullptr));
 
   // Write some data.
   num_bytes = 5u * sizeof(int32_t);
   Seq(100, MOJO_ARRAYSIZE(buffer), buffer);
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(buffer),
                                     MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
 
   // Wait for data.
@@ skipping 101 matching lines @@
   // Three left.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(3u * sizeof(int32_t), num_bytes);
 
   // We'll need to wait for the peer closed to propagate.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      2, nullptr));
+                                      false, 2, nullptr));
 
   // Close the producer, then test producer-closed cases.
   this->ProducerClose();
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
@@ skipping 65 matching lines @@
   ASSERT_EQ(100u, validated_options.capacity_num_bytes);
   this->Create(options);
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
 
   // Add waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 1, nullptr));
 
   // Write 20 bytes.
   uint32_t num_bytes = 20u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(&test_data[0]),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(20u, num_bytes);
 
   // Wait for data.
   // TODO(vtl): (See corresponding TODO in AllOrNone.)
@@ skipping 183 matching lines @@
   };
   this->Create(options);
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
 
   // Add waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 1, nullptr));
 
   // Write some data, so we'll have something to read.
   uint32_t num_bytes = kTestDataSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(kTestData),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   // Start two-phase write.
   void* write_buffer_ptr = nullptr;
@@ skipping 21 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
                                         MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(read_buffer_ptr);
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   // Add waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      1, nullptr));
+                                      false, 1, nullptr));
 
   // Close the consumer.
   this->ConsumerClose();
 
   // Wait for producer to know that the consumer is closed.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
@@ skipping 70 matching lines @@
   uint32_t num_bytes = kTestDataSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(kTestData),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   // Add waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      1, nullptr));
+                                      false, 1, nullptr));
 
   // Close the producer.
   this->ProducerClose();
 
   // Wait. (Note that once the consumer knows that the producer is closed, it
   // must also know about all the data that was sent.)
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
@@ skipping 56 matching lines @@
   };
   this->Create(options);
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
 
   // Add waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 0,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 0, nullptr));
 
   // Write some data, so we'll have something to read.
   uint32_t num_bytes = kTestDataSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(&kTestData),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), nullptr));
@@ skipping 10 matching lines @@
   num_bytes = static_cast<uint32_t>(sizeof(data));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(data),
                                    MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(kTestDataSize, num_bytes);
   EXPECT_EQ(kTestData, data[0]);
 
   // Add waiter again.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 0,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 0, nullptr));
 
   // Close the producer.
   this->ProducerClose();
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             waiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
@@ skipping 17 matching lines @@
   };
   this->Create(options);
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
 
   // Add waiter (for the consumer to become readable).
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 0,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 0, nullptr));
 
   // Write some data, so we'll have something to read.
   uint32_t num_bytes = kTestDataSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(&kTestData),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), nullptr));
@@ skipping 11 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
                                         MakeUserPointer(&num_bytes)));
   EXPECT_EQ(kTestDataSize, num_bytes);
   EXPECT_EQ(kTestData, static_cast<const int64_t*>(read_ptr)[0]);
 
   // Add waiter (for the producer to be closed).
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      0, nullptr));
+                                      false, 0, nullptr));
 
   // Close the producer.
   this->ProducerClose();
 
   // Wait for producer close to be detected.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Add waiter (for the consumer to become readable).
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 0,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 0, nullptr));
 
   // Complete the two-phase read.
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(kTestDataSize));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             waiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
@@ skipping 23 matching lines @@
   void* write_ptr = nullptr;
   uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                          MakeUserPointer(&num_bytes)));
 
   // Add waiter (for the consumer to be closed).
   waiter1.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ProducerAddAwakable(&waiter1, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      0, nullptr));
+                                      false, 0, nullptr));
 
   // Add a separate waiter (for the producer to become writable).
   waiter2.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(&waiter2, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
-                                      nullptr));
+            this->ProducerAddAwakable(&waiter2, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                      false, 0, nullptr));
 
   // Close the consumer.
   this->ConsumerClose();
 
   // Wait for the consumer close to be detected.
   // Note: If we didn't wait for the consumer close to be detected before
   // completing the two-phase write, wait might succeed (in the remote cases).
   // This is because the first |Awake()| "wins".
   EXPECT_EQ(MOJO_RESULT_OK, waiter1.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
@@ skipping 90 matching lines @@
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Add waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1,
-                                      nullptr));
+            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE,
+                                      false, 1, nullptr));
 
   // Now write some data, so we'll be able to try reading.
   int32_t element = 123;
   num_bytes = 1u * sizeof(int32_t);
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(&element),
                                     MakeUserPointer(&num_bytes), false));
 
   // Wait for data.
   // TODO(vtl): (See corresponding TODO in AllOrNone.)
@@ skipping 136 matching lines @@
   this->ProducerGetOptions(&write_threshold_num_bytes);
   EXPECT_EQ(0u, write_threshold_num_bytes);
 
   Waiter waiter;
   HandleSignalsState hss;
 
   // Try to wait to the write threshold signal; it should already have it.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             this->ProducerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, &hss));
+                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, false, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   // Before writing, add a waiter on the consumer (since we'll need to know when
   // the written bytes have propagated).
   Waiter read_waiter;
   read_waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(&read_waiter, MOJO_HANDLE_SIGNAL_READABLE,
-                                      0, nullptr));
+                                      false, 0, nullptr));
 
   // Write 5 bytes.
   static const char kTestData[5] = {'A', 'B', 'C', 'D', 'E'};
   uint32_t num_bytes = 5;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(kTestData),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(5u, num_bytes);
 
   // It should still have the write threshold signal.
   waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ProducerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, nullptr));
+  ASSERT_EQ(
+      MOJO_RESULT_ALREADY_EXISTS,
+      this->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
+                                false, 0, nullptr));
 
   // Set the write threshold to 5.
   this->ProducerSetOptions(5);
   write_threshold_num_bytes = 123u;
   this->ProducerGetOptions(&write_threshold_num_bytes);
   EXPECT_EQ(5u, write_threshold_num_bytes);
 
   // Should still have the write threshold signal.
   waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            this->ProducerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, nullptr));
+  ASSERT_EQ(
+      MOJO_RESULT_ALREADY_EXISTS,
+      this->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
+                                false, 0, nullptr));
 
   // Set the write threshold to 6.
   this->ProducerSetOptions(6);
 
   // Should no longer have the write threshold signal.
   waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK, this->ProducerAddAwakable(
+                                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
+                                false, 0, nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
   this->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
 
   // Add a waiter.
   waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK, this->ProducerAddAwakable(
+                                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
+                                false, 0, nullptr));
 
   // Wait for the consumer to be readable.
   EXPECT_EQ(MOJO_RESULT_OK, read_waiter.Wait(test::TinyTimeout(), nullptr));
   this->ConsumerRemoveAwakable(&read_waiter, nullptr);
 
   // Read a byte.
   char read_byte = 'a';
   num_bytes = sizeof(read_byte);
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(&read_byte),
@@ skipping 14 matching lines @@
   // Write 6 more bytes.
   static const char kMoreTestData[6] = {'1', '2', '3', '4', '5', '6'};
   num_bytes = 6;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(kMoreTestData),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(6u, num_bytes);
 
   // Should no longer have the write threshold signal.
   waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK, this->ProducerAddAwakable(
+                                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
+                                false, 0, nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   this->ProducerRemoveAwakable(&waiter, nullptr);
 
   // Set the write threshold to 0 (which means the element size, 1).
   this->ProducerSetOptions(0);
   write_threshold_num_bytes = 123u;
   this->ProducerGetOptions(&write_threshold_num_bytes);
   EXPECT_EQ(0u, write_threshold_num_bytes);
 
   // Should still not have the write threshold signal.
   waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK, this->ProducerAddAwakable(
+                                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
+                                false, 0, nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   this->ProducerRemoveAwakable(&waiter, nullptr);
 
   // Add a waiter.
   waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            this->ProducerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK, this->ProducerAddAwakable(
+                                &waiter, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
+                                false, 0, nullptr));
 
   // Close the consumer.
   this->ConsumerClose();
 
   // Wait; the condition should now never be satisfiable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             waiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
@@ skipping 18 matching lines @@
   this->ConsumerGetOptions(&read_threshold_num_bytes);
   EXPECT_EQ(0u, read_threshold_num_bytes);
 
   Waiter waiter;
   HandleSignalsState hss;
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, nullptr));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, nullptr));
   // Trivial wait: it shouldn't have the read threshold signal.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, nullptr));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, nullptr));
 
   // Write a byte.
   const char kTestData[] = {'x'};
   const uint32_t kTestDataSize = static_cast<uint32_t>(sizeof(kTestData));
   uint32_t num_bytes = kTestDataSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(kTestData),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(kTestDataSize, num_bytes);
 
@@ skipping 12 matching lines @@
   read_threshold_num_bytes = 123u;
   this->ConsumerGetOptions(&read_threshold_num_bytes);
   EXPECT_EQ(1u, read_threshold_num_bytes);
 
   // Try to add a waiter: it should (still) already have the read threshold
   // signal.
   waiter.Init();
   hss = HandleSignalsState();
   ASSERT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, &hss));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Set the read threshold to 2.
   this->ConsumerSetOptions(2);
   read_threshold_num_bytes = 123u;
   this->ConsumerGetOptions(&read_threshold_num_bytes);
   EXPECT_EQ(2u, read_threshold_num_bytes);
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, nullptr));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, nullptr));
 
   // Write another byte.
   num_bytes = kTestDataSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerWriteData(UserPointer<const void>(kTestData),
                                     MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   // Wait for the read threshold signal.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyTimeout(), nullptr));
@@ skipping 11 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(&read_byte),
                                    MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(1u, num_bytes);
   EXPECT_EQ(kTestData[0], read_byte);
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, nullptr));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, nullptr));
   // Trivial wait: it shouldn't have the read threshold signal.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, nullptr));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, nullptr));
   // Trivial wait: it shouldn't have the read threshold signal.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, nullptr));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, nullptr));
 
   // Close the producer.
   this->ProducerClose();
 
   // Wait; the current read threshold becomes never satisfiable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             waiter.Wait(test::TinyTimeout(), nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Set the read threshold back to zero to 0.
   this->ConsumerSetOptions(0);
   read_threshold_num_bytes = 123u;
   this->ConsumerGetOptions(&read_threshold_num_bytes);
   // "Get options" should preserve 0 (and not set it to the element size).
   EXPECT_EQ(0u, read_threshold_num_bytes);
 
   // Try to add a waiter: it should have the read threshold signal.
   waiter.Init();
   hss = HandleSignalsState();
   ASSERT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, &hss));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Read the other byte.
   read_byte = 'a';
   num_bytes = sizeof(read_byte);
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(&read_byte),
                                    MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(1u, num_bytes);
   EXPECT_EQ(kTestData[0], read_byte);
 
   // Try to add a waiter: the read threshold signal should be unsatisfiable.
   waiter.Init();
   hss = HandleSignalsState();
   ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             this->ConsumerAddAwakable(
-                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, &hss));
+                &waiter, MOJO_HANDLE_SIGNAL_READ_THRESHOLD, false, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   this->ConsumerClose();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo