Convert BeginReadData...() to use the new user pointer handling (see r285350).

mojo/system/local_data_pipe_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/system/local_data_pipe.h"
 
 #include <string.h>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
@@ skipping 252 matching lines @@
 
   // Add a waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 90));
 
   // Read one element, using a two-phase read.
   const void* read_buffer = NULL;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_buffer, &num_bytes, false));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(read_buffer != NULL);
   // 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,
             dp->ConsumerEndReadData(
                 static_cast<uint32_t>(1u * sizeof(elements[0]))));
 
@@ skipping 151 matching lines @@
     // Should already be readable.
     waiter.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
               dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12));
 
     // Read one element.
     // Request two in all-or-none mode, but only read one.
     const void* read_buffer = NULL;
     num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerBeginReadData(&read_buffer, &num_bytes, true));
+              dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+                                        MakeUserPointer(&num_bytes), true));
     EXPECT_TRUE(read_buffer != NULL);
     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,
               dp->ConsumerEndReadData(
                   static_cast<uint32_t>(1u * sizeof(elements[0]))));
 
     // Should still be readable.
     waiter.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
               dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34));
 
     // Read one element.
     // Request three, but not in all-or-none mode.
     read_buffer = NULL;
     num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerBeginReadData(&read_buffer, &num_bytes, false));
+              dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+                                        MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(read_buffer != NULL);
     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,
               dp->ConsumerEndReadData(
                   static_cast<uint32_t>(1u * sizeof(elements[0]))));
 
     // Adding a waiter should now succeed.
     waiter.Init();
@@ skipping 84 matching lines @@
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5));
 
   // End the two-phase write without writing anything.
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u));
 
   // Start a two-phase read.
   num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
   const void* read_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, false));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(read_ptr != NULL);
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes);
 
   // At this point, it should still be writable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6));
 
   // But not readable.
   waiter.Init();
@@ skipping 535 matching lines @@
   num_bytes = 1u;
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             dp->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 = NULL;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
 
   // Write half (two-phase).
   num_bytes = 5u * sizeof(int32_t);
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->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 != NULL);
   Seq(0, 5, static_cast<int32_t*>(write_ptr));
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(5u * sizeof(int32_t)));
 
   // Try reading an amount which isn't a multiple of the element size
   // (two-phase).
   num_bytes = 1u;
   read_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
 
   // Read one (two-phase).
   num_bytes = 1u * sizeof(int32_t);
   read_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, true));
+            dp->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, dp->ConsumerEndReadData(1u * sizeof(int32_t)));
 
   // We should have four left, leaving room for six.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(&num_bytes));
   EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
 
   // Assuming a tight circular buffer of the specified capacity, we can't do a
@@ skipping 13 matching lines @@
 
   // We have ten.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(&num_bytes));
   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
 
   // But a two-phase read of ten should fail.
   num_bytes = 10u * sizeof(int32_t);
   read_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
 
   // Close the producer.
   dp->ProducerClose();
 
   // A two-phase read of nine should work.
   num_bytes = 9u * sizeof(int32_t);
   read_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, true));
+            dp->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, dp->ConsumerEndReadData(9u * sizeof(int32_t)));
 
   // A two-phase read of two should fail, with "failed precondition".
   num_bytes = 2u * sizeof(int32_t);
   read_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
 
   dp->ConsumerClose();
 }
 
 // Tests that |ProducerWriteData()| and |ConsumerReadData()| writes and reads,
 // respectively, as much as possible, even if it has to "wrap around" the
 // internal circular buffer. (Note that the two-phase write and read do not do
 // this.)
 TEST(LocalDataPipeTest, WrapAround) {
   unsigned char test_data[1000];
@@ skipping 47 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(&test_data[20], &num_bytes, false));
   EXPECT_EQ(90u, num_bytes);
 
   // Check that a two-phase read can now only read (at most) 90 bytes. (This
   // checks an implementation detail; this behavior is not guaranteed, but we
   // need it for this test.)
   const void* read_buffer_ptr = NULL;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_buffer_ptr, &num_bytes, false));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(read_buffer_ptr != NULL);
   EXPECT_EQ(90u, num_bytes);
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u));
 
   // Read as much as possible (using |ConsumerReadData()|). We should read 100
   // bytes.
   num_bytes =
       static_cast<uint32_t>(arraysize(read_buffer) * sizeof(read_buffer[0]));
   memset(read_buffer, 0, num_bytes);
   EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 43 matching lines @@
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
                                          MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(write_buffer_ptr != NULL);
     EXPECT_GT(num_bytes, 0u);
 
     // Start two-phase read.
     const void* read_buffer_ptr = NULL;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerBeginReadData(&read_buffer_ptr, &num_bytes, false));
+              dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
+                                        MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(read_buffer_ptr != NULL);
     EXPECT_EQ(2u * kTestDataSize, num_bytes);
 
     // Close the producer.
     dp->ProducerClose();
 
     // The consumer can finish its two-phase read.
     EXPECT_EQ(0, memcmp(read_buffer_ptr, kTestData, kTestDataSize));
     EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(kTestDataSize));
 
     // And start another.
     read_buffer_ptr = NULL;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerBeginReadData(&read_buffer_ptr, &num_bytes, false));
+              dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
+                                        MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(read_buffer_ptr != NULL);
     EXPECT_EQ(kTestDataSize, num_bytes);
 
     // Close the consumer, which cancels the two-phase read.
     dp->ConsumerClose();
   }
 
   // Close consumer first, then producer.
   {
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ skipping 10 matching lines @@
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
                                          MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(write_buffer_ptr != NULL);
     ASSERT_GT(num_bytes, kTestDataSize);
 
     // Start two-phase read.
     const void* read_buffer_ptr = NULL;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerBeginReadData(&read_buffer_ptr, &num_bytes, false));
+              dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
+                                        MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(read_buffer_ptr != NULL);
     EXPECT_EQ(kTestDataSize, num_bytes);
 
     // Close the consumer.
     dp->ConsumerClose();
 
     // Actually write some data. (Note: Premature freeing of the buffer would
     // probably only be detected under ASAN or similar.)
     memcpy(write_buffer_ptr, kTestData, kTestDataSize);
     // Note: Even though the consumer has been closed, ending the two-phase
@@ skipping 56 matching lines @@
 
     // A second read should fail.
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               dp->ConsumerReadData(buffer, &num_bytes, false));
 
     // A two-phase read should also fail.
     const void* read_buffer_ptr = NULL;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              dp->ConsumerBeginReadData(&read_buffer_ptr, &num_bytes, false));
+              dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
+                                        MakeUserPointer(&num_bytes), false));
 
     // Ditto for discard.
     num_bytes = 10u;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               dp->ConsumerDiscardData(&num_bytes, false));
 
     dp->ConsumerClose();
   }
 }
 
@@ skipping 76 matching lines @@
 
   // Still one element available.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(&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 = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, false));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             dp->ConsumerEndReadData(
                 num_bytes + static_cast<uint32_t>(sizeof(int32_t))));
 
   // Still one element available.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(&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 = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, false));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   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, dp->ConsumerEndReadData(1u));
 
   // Still one element available.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(&num_bytes));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
 
   dp->ProducerClose();
@@ skipping 23 matching lines @@
   // Write some elements.
   char elements[2] = { 'a', 'b' };
   uint32_t num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(elements, &num_bytes, false));
   EXPECT_EQ(2u, num_bytes);
 
   // Begin reading.
   const void* read_ptr = NULL;
   num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, false));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(2u, num_bytes);
   EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
   EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]);
 
   // Try to write some more. But nothing should be discardable right now.
   elements[0] = 'x';
   elements[1] = 'y';
   num_bytes = 2u;
   // TODO(vtl): This should be:
   //  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
   //            dp->ProducerWriteData(elements, &num_bytes, false));
   // but we incorrectly think that the bytes being read are discardable. Letting
   // this through reveals the significant consequence.
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(elements, &num_bytes, false));
 
   // Check that our read buffer hasn't changed underneath us.
   EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
   EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]);
 
   // End reading.
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(2u));
 
   // Now writing should succeed.
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(elements, &num_bytes, false));
 
   // And if we read, we should get the new values.
   read_ptr = NULL;
   num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(&read_ptr, &num_bytes, false));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(2u, num_bytes);
   EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
   EXPECT_EQ('y', static_cast<const char*>(read_ptr)[1]);
 
   // End reading.
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(2u));
 
   dp->ProducerClose();
   dp->ConsumerClose();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo