Cleanup: Remove internal two-phase data pipe all-or-none support.

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 106 matching lines @@
     helper_->SetUp();
   }
 
   void ProducerClose() { helper_->ProducerClose(); }
   MojoResult ProducerWriteData(UserPointer<const void> elements,
                                UserPointer<uint32_t> num_bytes,
                                bool all_or_none) {
     return dpp()->ProducerWriteData(elements, num_bytes, all_or_none);
   }
   MojoResult ProducerBeginWriteData(UserPointer<void*> buffer,
-                                    UserPointer<uint32_t> buffer_num_bytes,
-                                    bool all_or_none) {
-    return dpp()->ProducerBeginWriteData(buffer, buffer_num_bytes, all_or_none);
+                                    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,
                                  uint32_t context,
                                  HandleSignalsState* signals_state) {
     return dpp()->ProducerAddAwakable(awakable, signals, context,
                                       signals_state);
@@ skipping 11 matching lines @@
     return dpc()->ConsumerReadData(elements, num_bytes, all_or_none, peek);
   }
   MojoResult ConsumerDiscardData(UserPointer<uint32_t> num_bytes,
                                  bool all_or_none) {
     return dpc()->ConsumerDiscardData(num_bytes, all_or_none);
   }
   MojoResult ConsumerQueryData(UserPointer<uint32_t> num_bytes) {
     return dpc()->ConsumerQueryData(num_bytes);
   }
   MojoResult ConsumerBeginReadData(UserPointer<const void*> buffer,
-                                   UserPointer<uint32_t> buffer_num_bytes,
-                                   bool all_or_none) {
-    return dpc()->ConsumerBeginReadData(buffer, buffer_num_bytes, all_or_none);
+                                   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,
                                  uint32_t context,
                                  HandleSignalsState* signals_state) {
     return dpc()->ConsumerAddAwakable(awakable, signals, context,
                                       signals_state);
@@ skipping 430 matching lines @@
       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
   };
   this->Create(options);
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context;
 
   int32_t elements[10] = {};
-  uint32_t num_bytes = 0;
+  uint32_t num_bytes = 0u;
 
   // Try reading; nothing there yet.
   num_bytes =
       static_cast<uint32_t>(MOJO_ARRAYSIZE(elements) * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), false, false));
 
   // Query; nothing there yet.
-  num_bytes = 0;
+  num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Discard; nothing there yet.
   num_bytes = static_cast<uint32_t>(5u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             this->ConsumerDiscardData(MakeUserPointer(&num_bytes), false));
 
   // Read with invalid |num_bytes|.
@@ skipping 26 matching lines @@
   this->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Query.
   // TODO(vtl): It's theoretically possible (though not with the current
   // implementation/configured limits) that not all the data has arrived yet.
   // (The theoretically-correct assertion here is that |num_bytes| is |1 * ...|
   // or |2 * ...|.)
-  num_bytes = 0;
+  num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(2 * sizeof(elements[0]), num_bytes);
 
   // 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), false, false));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   EXPECT_EQ(123, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Query.
   // TODO(vtl): See previous TODO. (If we got 2 elements there, however, we
   // should get 1 here.)
-  num_bytes = 0;
+  num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(1 * sizeof(elements[0]), num_bytes);
 
   // 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), false, true));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   EXPECT_EQ(456, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Query. Still has 1 element remaining.
-  num_bytes = 0;
+  num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(1 * sizeof(elements[0]), num_bytes);
 
   // Try to read two elements, with "all or none".
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(-1, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Try to read two elements, without "all or none".
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(elements),
                                    MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   EXPECT_EQ(456, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Query.
-  num_bytes = 0;
+  num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   this->ProducerClose();
   this->ConsumerClose();
 }
 
 // Note: The "basic" waiting tests test that the "wait states" are correct in
 // various situations; they don't test that waiters are properly awoken on state
@@ skipping 120 matching lines @@
   this->ProducerRemoveAwakable(&pwaiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Try writing, using a two-phase write.
   void* buffer = nullptr;
   num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&buffer),
-                                         MakeUserPointer(&num_bytes), false));
+                                         MakeUserPointer(&num_bytes)));
   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));
 
   // 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), false));
+                                        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
   // implementation detail!
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   EXPECT_EQ(456, static_cast<const int32_t*>(read_buffer)[0]);
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(static_cast<uint32_t>(
                                 1u * sizeof(elements[0]))));
 
   // Waiting should succeed.
@@ skipping 300 matching lines @@
 
   // Add waiter: not yet readable.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12,
                                       nullptr));
 
   // Write two elements.
   int32_t* elements = nullptr;
   void* buffer = nullptr;
-  // Request room for three (but we'll only write two).
-  uint32_t num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
+  uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&buffer),
-                                         MakeUserPointer(&num_bytes), true));
+                                         MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(buffer);
   EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0])));
   elements = static_cast<int32_t*>(buffer);
   elements[0] = 123;
   elements[1] = 456;
   EXPECT_EQ(MOJO_RESULT_OK, this->ProducerEndWriteData(static_cast<uint32_t>(
                                 2u * sizeof(elements[0]))));
 
   // Wait for readability (needed for remote cases).
   context = 0;
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyDeadline(), &context));
   EXPECT_EQ(12u, context);
   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,
             hss.satisfiable_signals);
 
   // Read one element.
-  // Request two in all-or-none mode, but only read one.
   const void* read_buffer = nullptr;
-  num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
+  num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
-                                        MakeUserPointer(&num_bytes), true));
+                                        MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(read_buffer);
   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));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             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), false));
+                                        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,
@@ skipping 34 matching lines @@
   // It should be writable.
   pwaiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             this->ProducerAddAwakable(&pwaiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
                                       &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
-  uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
   void* write_ptr = nullptr;
+  uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
-                                         MakeUserPointer(&num_bytes), false));
+                                         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));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, pwaiter.Wait(0, nullptr));
   hss = HandleSignalsState();
@@ skipping 25 matching lines @@
   // It should become readable.
   EXPECT_EQ(MOJO_RESULT_OK, cwaiter.Wait(test::TinyDeadline(), nullptr));
   hss = HandleSignalsState();
   this->ConsumerRemoveAwakable(&cwaiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Start another two-phase write and check that it's readable even in the
   // middle of it.
-  num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
   write_ptr = nullptr;
+  num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
-                                         MakeUserPointer(&num_bytes), false));
+                                         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));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // End the two-phase write without writing anything.
   EXPECT_EQ(MOJO_RESULT_OK, this->ProducerEndWriteData(0u));
 
   // Start a two-phase read.
-  num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
   const void* read_ptr = nullptr;
+  num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
-                                        MakeUserPointer(&num_bytes), false));
+                                        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));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
@@ skipping 232 matching lines @@
 
   // Empty again.
   num_bytes = ~0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   this->ConsumerClose();
 }
 
-TYPED_TEST(DataPipeImplTest, TwoPhaseAllOrNone) {
-  const MojoCreateDataPipeOptions options = {
-      kSizeOfOptions,                           // |struct_size|.
-      MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
-      static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
-      10 * sizeof(int32_t)                      // |capacity_num_bytes|.
-  };
-  this->Create(options);
-  this->DoTransfer();
-
-  Waiter waiter;
-  HandleSignalsState hss;
-
-  // Try writing way too much (two-phase).
-  uint32_t num_bytes = 20u * sizeof(int32_t);
-  void* write_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
-                                         MakeUserPointer(&num_bytes), true));
-
-  // Try writing an amount which isn't a multiple of the element size
-  // (two-phase).
-  static_assert(sizeof(int32_t) > 1u, "Wow! int32_t's have size 1");
-  num_bytes = 1u;
-  write_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
-                                         MakeUserPointer(&num_bytes), true));
-
-  // Try reading way too much (two-phase).
-  num_bytes = 20u * sizeof(int32_t);
-  const void* read_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
-                                        MakeUserPointer(&num_bytes), true));
-
-  // Add waiter.
-  waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1,
-                                      nullptr));
-
-  // Write half (two-phase).
-  num_bytes = 5u * sizeof(int32_t);
-  write_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
-                                         MakeUserPointer(&num_bytes), true));
-  // May provide more space than requested.
-  EXPECT_GE(num_bytes, 5u * sizeof(int32_t));
-  EXPECT_TRUE(write_ptr);
-  Seq(0, 5, static_cast<int32_t*>(write_ptr));
-  EXPECT_EQ(MOJO_RESULT_OK, this->ProducerEndWriteData(5u * sizeof(int32_t)));
-
-  // Wait for data.
-  // TODO(vtl): (See corresponding TODO in AllOrNone.)
-  EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyDeadline(), 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,
-            hss.satisfiable_signals);
-
-  // Try reading an amount which isn't a multiple of the element size
-  // (two-phase).
-  num_bytes = 1u;
-  read_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
-                                        MakeUserPointer(&num_bytes), true));
-
-  // Read one (two-phase).
-  num_bytes = 1u * sizeof(int32_t);
-  read_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
-                                        MakeUserPointer(&num_bytes), true));
-  EXPECT_GE(num_bytes, 1u * sizeof(int32_t));
-  EXPECT_EQ(0, static_cast<const int32_t*>(read_ptr)[0]);
-  EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(1u * sizeof(int32_t)));
-
-  // We should have four left, leaving room for six.
-  num_bytes = 0u;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
-  EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
-
-  // Assuming a tight circular buffer of the specified capacity, we can't do a
-  // two-phase write of six now.
-  num_bytes = 6u * sizeof(int32_t);
-  write_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
-                                         MakeUserPointer(&num_bytes), true));
-
-  // TODO(vtl): Hack (see also the TODO above): We can't currently wait for a
-  // specified amount of space to be available, so poll.
-  for (size_t i = 0; i < kMaxPoll; i++) {
-    // Write six elements (simple), filling the buffer.
-    num_bytes = 6u * sizeof(int32_t);
-    int32_t buffer[100];
-    Seq(100, 6, buffer);
-    MojoResult result = this->ProducerWriteData(
-        UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true);
-    if (result == MOJO_RESULT_OK)
-      break;
-    EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, result);
-
-    test::Sleep(test::EpsilonDeadline());
-  }
-  EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
-
-  // TODO(vtl): Hack: poll again.
-  for (size_t i = 0; i < kMaxPoll; i++) {
-    // We have ten.
-    num_bytes = 0u;
-    EXPECT_EQ(MOJO_RESULT_OK,
-              this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
-    if (num_bytes >= 10u * sizeof(int32_t))
-      break;
-
-    test::Sleep(test::EpsilonDeadline());
-  }
-  EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
-
-  // Note: Whether a two-phase read of ten would fail here or not is
-  // implementation-dependent.
-
-  // Add waiter.
-  waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            this->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                      2, nullptr));
-
-  // Close the producer.
-  this->ProducerClose();
-
-  // A two-phase read of nine should work.
-  num_bytes = 9u * sizeof(int32_t);
-  read_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
-                                        MakeUserPointer(&num_bytes), true));
-  EXPECT_GE(num_bytes, 9u * sizeof(int32_t));
-  EXPECT_EQ(1, static_cast<const int32_t*>(read_ptr)[0]);
-  EXPECT_EQ(2, static_cast<const int32_t*>(read_ptr)[1]);
-  EXPECT_EQ(3, static_cast<const int32_t*>(read_ptr)[2]);
-  EXPECT_EQ(4, static_cast<const int32_t*>(read_ptr)[3]);
-  EXPECT_EQ(100, static_cast<const int32_t*>(read_ptr)[4]);
-  EXPECT_EQ(101, static_cast<const int32_t*>(read_ptr)[5]);
-  EXPECT_EQ(102, static_cast<const int32_t*>(read_ptr)[6]);
-  EXPECT_EQ(103, static_cast<const int32_t*>(read_ptr)[7]);
-  EXPECT_EQ(104, static_cast<const int32_t*>(read_ptr)[8]);
-  EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(9u * sizeof(int32_t)));
-
-  // Wait for peer closed.
-  EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyDeadline(), 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);
-
-  // A two-phase read of two should fail, with "failed precondition".
-  num_bytes = 2u * sizeof(int32_t);
-  read_ptr = nullptr;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
-                                        MakeUserPointer(&num_bytes), true));
-
-  this->ConsumerClose();
-}
-
 // Tests that |ProducerWriteData()| and |ConsumerReadData()| writes and reads,
 // respectively, as much as possible, even if it may have to "wrap around" the
 // internal circular buffer. (Note that the two-phase write and read need not do
 // this.)
 TYPED_TEST(DataPipeImplTest, WrapAround) {
   unsigned char test_data[1000];
   for (size_t i = 0; i < MOJO_ARRAYSIZE(test_data); i++)
     test_data[i] = static_cast<unsigned char>(i);
 
   const MojoCreateDataPipeOptions options = {
@@ skipping 45 matching lines @@
   EXPECT_EQ(10u, num_bytes);
   EXPECT_EQ(0, memcmp(read_buffer, &test_data[0], 10u));
 
   if (this->IsStrictCircularBuffer()) {
     // Check that a two-phase write can now only write (at most) 80 bytes. (This
     // checks an implementation detail; this behavior is not guaranteed.)
     void* write_buffer_ptr = nullptr;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               this->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                           MakeUserPointer(&num_bytes), false));
+                                           MakeUserPointer(&num_bytes)));
     EXPECT_TRUE(write_buffer_ptr);
     EXPECT_EQ(80u, num_bytes);
     EXPECT_EQ(MOJO_RESULT_OK, this->ProducerEndWriteData(0u));
   }
 
   // TODO(vtl): (See corresponding TODO in TwoPhaseAllOrNone.)
-  size_t total_num_bytes = 0;
+  size_t total_num_bytes = 0u;
   for (size_t i = 0; i < kMaxPoll; i++) {
     // Write as much data as we can (using |ProducerWriteData()|). We should
     // write 90 bytes (eventually).
     num_bytes = 200u;
     MojoResult result = this->ProducerWriteData(
         UserPointer<const void>(&test_data[20 + total_num_bytes]),
         MakeUserPointer(&num_bytes), false);
     if (result == MOJO_RESULT_OK) {
       total_num_bytes += num_bytes;
       if (total_num_bytes >= 90u)
@@ skipping 19 matching lines @@
   }
   EXPECT_EQ(100u, num_bytes);
 
   if (this->IsStrictCircularBuffer()) {
     // Check that a two-phase read can now only read (at most) 90 bytes. (This
     // checks an implementation detail; this behavior is not guaranteed.)
     const void* read_buffer_ptr = nullptr;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                          MakeUserPointer(&num_bytes), false));
+                                          MakeUserPointer(&num_bytes)));
     EXPECT_TRUE(read_buffer_ptr);
     EXPECT_EQ(90u, num_bytes);
     EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(0u));
   }
 
   // Read as much as possible (using |ConsumerReadData()|). We should read 100
   // bytes.
   num_bytes = static_cast<uint32_t>(MOJO_ARRAYSIZE(read_buffer) *
                                     sizeof(read_buffer[0]));
   memset(read_buffer, 0, num_bytes);
@@ skipping 34 matching lines @@
   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;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                         MakeUserPointer(&num_bytes), false));
+                                         MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(write_buffer_ptr);
   EXPECT_GT(num_bytes, 0u);
 
   // TODO(vtl): (See corresponding TODO in TwoPhaseAllOrNone.)
   for (size_t i = 0; i < kMaxPoll; i++) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
     if (num_bytes >= 2u * kTestDataSize)
       break;
 
     test::Sleep(test::EpsilonDeadline());
   }
   EXPECT_EQ(2u * kTestDataSize, num_bytes);
 
   // Start two-phase read.
   const void* read_buffer_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes), false));
+                                        MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(read_buffer_ptr);
   EXPECT_EQ(2u * kTestDataSize, num_bytes);
 
   // Close the producer.
   this->ProducerClose();
 
   // The consumer can finish its two-phase read.
   EXPECT_EQ(0, memcmp(read_buffer_ptr, kTestData, kTestDataSize));
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(kTestDataSize));
 
   // And start another.
   read_buffer_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes), false));
+                                        MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(read_buffer_ptr);
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   // Close the consumer, which cancels the two-phase read.
   this->ConsumerClose();
 }
 
 // Tests the behavior of interrupting a two-phase read and write by closing the
 // consumer.
 TYPED_TEST(DataPipeImplTest, TwoPhaseWriteReadCloseConsumer) {
@@ skipping 23 matching lines @@
   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;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                         MakeUserPointer(&num_bytes), false));
+                                         MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(write_buffer_ptr);
   ASSERT_GT(num_bytes, kTestDataSize);
 
   // Wait for data.
   // TODO(vtl): (See corresponding TODO in AllOrNone.)
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::TinyDeadline(), 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,
             hss.satisfiable_signals);
 
   // Start two-phase read.
   const void* read_buffer_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes), false));
+                                        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));
 
   // Close the consumer.
@@ skipping 17 matching lines @@
   num_bytes = kTestDataSize;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             this->ProducerWriteData(UserPointer<const void>(kTestData),
                                     MakeUserPointer(&num_bytes), false));
 
   // As will trying to start another two-phase write.
   write_buffer_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             this->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                         MakeUserPointer(&num_bytes), false));
+                                         MakeUserPointer(&num_bytes)));
 
   this->ProducerClose();
 }
 
 // Tests the behavior of "interrupting" a two-phase write by closing both the
 // producer and the consumer.
 TYPED_TEST(DataPipeImplTest, TwoPhaseWriteCloseBoth) {
   const uint32_t kTestDataSize = 15u;
 
   const MojoCreateDataPipeOptions options = {
       kSizeOfOptions,                           // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       1u,                                       // |element_num_bytes|.
       1000u                                     // |capacity_num_bytes|.
   };
   this->Create(options);
   this->DoTransfer();
 
   // Start two-phase write.
   void* write_buffer_ptr = nullptr;
   uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                         MakeUserPointer(&num_bytes), false));
+                                         MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(write_buffer_ptr);
   ASSERT_GT(num_bytes, kTestDataSize);
 
   this->ConsumerClose();
   this->ProducerClose();
 }
 
 // Tests the behavior of writing, closing the producer, and then reading (with
 // and without data remaining).
 TYPED_TEST(DataPipeImplTest, WriteCloseProducerReadNoData) {
@@ skipping 60 matching lines @@
   num_bytes = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             this->ConsumerReadData(UserPointer<void>(buffer),
                                    MakeUserPointer(&num_bytes), false, false));
 
   // A two-phase read should also fail.
   const void* read_buffer_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes), false));
+                                        MakeUserPointer(&num_bytes)));
 
   // Ditto for discard.
   num_bytes = 10u;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             this->ConsumerDiscardData(MakeUserPointer(&num_bytes), false));
 
   this->ConsumerClose();
 }
 
 // Test that two-phase reads/writes behave correctly when given invalid
@@ skipping 25 matching lines @@
   // have time to propagate.
   test::Sleep(test::EpsilonDeadline());
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Try ending a two-phase write with an invalid amount (too much).
+  void* write_ptr = nullptr;
   num_bytes = 0u;
-  void* write_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
-                                         MakeUserPointer(&num_bytes), false));
+                                         MakeUserPointer(&num_bytes)));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             this->ProducerEndWriteData(num_bytes +
                                        static_cast<uint32_t>(sizeof(int32_t))));
 
   // But the two-phase write still ended.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, this->ProducerEndWriteData(0u));
 
   // Wait a bit (as above).
   test::Sleep(test::EpsilonDeadline());
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Try ending a two-phase write with an invalid amount (not a multiple of the
   // element size).
+  write_ptr = nullptr;
   num_bytes = 0u;
-  write_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
-                                         MakeUserPointer(&num_bytes), false));
+                                         MakeUserPointer(&num_bytes)));
   EXPECT_GE(num_bytes, 1u);
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, this->ProducerEndWriteData(1u));
 
   // But the two-phase write still ended.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, this->ProducerEndWriteData(0u));
 
   // Wait a bit (as above).
   test::Sleep(test::EpsilonDeadline());
 
   // Still no data.
@@ skipping 38 matching lines @@
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
 
   // Try ending a two-phase read with an invalid amount (too much).
   num_bytes = 0u;
   const void* read_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
-                                        MakeUserPointer(&num_bytes), false));
+                                        MakeUserPointer(&num_bytes)));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             this->ConsumerEndReadData(num_bytes +
                                       static_cast<uint32_t>(sizeof(int32_t))));
 
   // Still one element available.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
 
   // Try ending a two-phase read with an invalid amount (not a multiple of the
   // element size).
   num_bytes = 0u;
   read_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
-                                        MakeUserPointer(&num_bytes), false));
+                                        MakeUserPointer(&num_bytes)));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
   EXPECT_EQ(123, static_cast<const int32_t*>(read_ptr)[0]);
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, this->ConsumerEndReadData(1u));
 
   // Still one element available.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
 
@@ skipping 35 matching lines @@
       break;
 
     test::Sleep(test::EpsilonDeadline());
   }
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   const void* read_buffer_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes), false));
+                                        MakeUserPointer(&num_bytes)));
   EXPECT_EQ(kTestDataSize, num_bytes);
   EXPECT_EQ(0, memcmp(read_buffer_ptr, kTestData, kTestDataSize));
 
   // Close the producer.
   this->ProducerClose();
 
   // Note: This tiny sleep is to allow/encourage a certain race. In particular,
   // for the remote producer case in
   // |RemoteProducerDataPipeImpl::MarkDataAsConsumed()| (caused by
   // |ConsumerEndReadData()| below) we want |producer_open()| to be false but
   // the call to |channel_endpoint_->EnqueueMessage()| to fail. (This race can
   // occur without the sleep, but is much less likely.)
   test::Sleep(10u);
 
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(num_bytes));
 
   this->ConsumerClose();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo