Convert BeginWriteData...() 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"
 #include "mojo/system/data_pipe.h"
+#include "mojo/system/memory.h"
 #include "mojo/system/waiter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
 const uint32_t kSizeOfOptions =
     static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions));
 
@@ skipping 221 matching lines @@
 
   // Waiting should now succeed.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
   EXPECT_EQ(78u, context);
   dp->ProducerRemoveWaiter(&waiter);
 
   // Try writing, using a two-phase write.
   void* buffer = NULL;
   num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&buffer, &num_bytes, false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&buffer),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(buffer != NULL);
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 
   static_cast<int32_t*>(buffer)[0] = 789;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerEndWriteData(
                 static_cast<uint32_t>(1u * sizeof(elements[0]))));
 
   // Add a waiter.
   waiter.Init();
@@ skipping 148 matching lines @@
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
     Waiter waiter;
     uint32_t context = 0;
 
     // Write two elements.
     int32_t* elements = NULL;
     void* buffer = NULL;
     // Request room for three (but we'll only write two).
     uint32_t num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ProducerBeginWriteData(&buffer, &num_bytes, true));
+              dp->ProducerBeginWriteData(MakeUserPointer(&buffer),
+                                         MakeUserPointer(&num_bytes), true));
     EXPECT_TRUE(buffer != NULL);
     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,
               dp->ProducerEndWriteData(
                   static_cast<uint32_t>(2u * sizeof(elements[0]))));
 
     // Should already be readable.
@@ skipping 67 matching lines @@
   Waiter waiter;
 
   // It should be writable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
 
   uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
   void* write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(write_ptr != NULL);
   EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
 
   // At this point, it shouldn't be writable.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 1));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, NULL));
   dp->ProducerRemoveWaiter(&waiter);
 
@@ skipping 17 matching lines @@
   // And readable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 4));
 
   // 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 = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(write_ptr != NULL);
   EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
 
   // It should be readable.
   waiter.Init();
   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));
@@ skipping 212 matching lines @@
   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
 
   // Test two-phase writes, including in all-or-none mode.
   // Note: Again, the following depends on an implementation detail -- namely
   // that the write pointer will point at the 5th element of the buffer (and the
   // buffer has exactly the capacity requested).
 
   num_bytes = 0u;
   void* write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(write_ptr != NULL);
   EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
   Seq(400, 6, static_cast<int32_t*>(write_ptr));
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(6u * sizeof(int32_t)));
   // Internally, a circular buffer would now look like:
   //   -, -, -, -, 400, 401, 402, 403, 404, 405
 
   // |ProducerBeginWriteData()| ignores |*num_bytes| except in "all-or-none"
   // mode.
   num_bytes = 6u * sizeof(int32_t);
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
   static_cast<int32_t*>(write_ptr)[0] = 500;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(1u * sizeof(int32_t)));
   // Internally, a circular buffer would now look like:
   //   500, -, -, -, 400, 401, 402, 403, 404, 405
 
   // Requesting a 10-element buffer in all-or-none mode fails at this point.
   num_bytes = 10u * sizeof(int32_t);
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, true));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
 
   // But requesting, say, a 5-element (up to 9, really) buffer should be okay.
   // It will discard two elements.
   num_bytes = 5u * sizeof(int32_t);
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, true));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
   // Only write 4 elements though.
   Seq(600, 4, static_cast<int32_t*>(write_ptr));
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(4u * sizeof(int32_t)));
   // Internally, a circular buffer would now look like:
   //   500, 600, 601, 602, 603, -, 402, 403, 404, 405
 
   // Do this again. Make sure we can get a buffer all the way out to the end of
   // the internal buffer.
   num_bytes = 5u * sizeof(int32_t);
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, true));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
   // Only write 3 elements though.
   Seq(700, 3, static_cast<int32_t*>(write_ptr));
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(3u * sizeof(int32_t)));
   // Internally, a circular buffer would now look like:
   //   500, 600, 601, 602, 603, 700, 701, 702, -, -
 
   // Read everything.
   num_bytes = sizeof(buffer);
   memset(buffer, 0xab, sizeof(buffer));
@@ skipping 253 matching lines @@
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
             DataPipe::ValidateCreateOptions(&options, &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   // Try writing way too much (two-phase).
   uint32_t num_bytes = 20u * sizeof(int32_t);
   void* write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, true));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
 
   // Try writing an amount which isn't a multiple of the element size
   // (two-phase).
   COMPILE_ASSERT(sizeof(int32_t) > 1u, wow_int32_ts_have_size_1);
   num_bytes = 1u;
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, true));
+            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));
 
   // Write half (two-phase).
   num_bytes = 5u * sizeof(int32_t);
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, true));
+            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;
@@ skipping 12 matching lines @@
   // 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
   // two-phase write of six now.
   num_bytes = 6u * sizeof(int32_t);
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, true));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
 
   // Write six elements (simple), filling the buffer.
   num_bytes = 6u * sizeof(int32_t);
   int32_t buffer[100];
   Seq(100, 6, buffer);
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(buffer, &num_bytes, true));
   EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
 
   // We have ten.
   num_bytes = 0u;
@@ skipping 72 matching lines @@
             dp->ConsumerReadData(read_buffer, &num_bytes, false));
   EXPECT_EQ(10u, num_bytes);
   EXPECT_EQ(0, memcmp(read_buffer, &test_data[0], 10u));
 
   // Check that a two-phase write can now only write (at most) 80 bytes. (This
   // checks an implementation detail; this behavior is not guaranteed, but we
   // need it for this test.)
   void* write_buffer_ptr = NULL;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_buffer_ptr, &num_bytes, false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(write_buffer_ptr != NULL);
   EXPECT_EQ(80u, num_bytes);
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u));
 
   // Write as much data as we can (using |ProducerWriteData()|). We should write
   // 90 bytes.
   num_bytes = 200u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(&test_data[20], &num_bytes, false));
   EXPECT_EQ(90u, num_bytes);
@@ skipping 52 matching lines @@
     // Write it again, so we'll have something left over.
     num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(kTestData, &num_bytes, false));
     EXPECT_EQ(kTestDataSize, num_bytes);
 
     // Start two-phase write.
     void* write_buffer_ptr = NULL;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ProducerBeginWriteData(&write_buffer_ptr, &num_bytes, false));
+              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));
     EXPECT_TRUE(read_buffer_ptr != NULL);
     EXPECT_EQ(2u * kTestDataSize, num_bytes);
@@ skipping 24 matching lines @@
     // Write some data, so we'll have something to read.
     uint32_t num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(kTestData, &num_bytes, false));
     EXPECT_EQ(kTestDataSize, num_bytes);
 
     // Start two-phase write.
     void* write_buffer_ptr = NULL;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ProducerBeginWriteData(&write_buffer_ptr, &num_bytes, false));
+              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));
     EXPECT_TRUE(read_buffer_ptr != NULL);
     EXPECT_EQ(kTestDataSize, num_bytes);
@@ skipping 10 matching lines @@
 
     // But trying to write should result in failure.
     num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               dp->ProducerWriteData(kTestData, &num_bytes, false));
 
     // As will trying to start another two-phase write.
     write_buffer_ptr = NULL;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              dp->ProducerBeginWriteData(&write_buffer_ptr, &num_bytes, false));
+              dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
+                                         MakeUserPointer(&num_bytes), false));
 
     dp->ProducerClose();
   }
 
   // Test closing the consumer first, then the producer, with an active
   // two-phase write.
   {
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
     // Start two-phase write.
     void* write_buffer_ptr = NULL;
     uint32_t num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ProducerBeginWriteData(&write_buffer_ptr, &num_bytes, false));
+              dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
+                                         MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(write_buffer_ptr != NULL);
     ASSERT_GT(num_bytes, kTestDataSize);
 
     dp->ConsumerClose();
     dp->ProducerClose();
   }
 
   // Test closing the producer and then trying to read (with no data).
   {
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ skipping 59 matching lines @@
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(&num_bytes));
   EXPECT_EQ(0u, num_bytes);
 
   // Try ending a two-phase write with an invalid amount (too much).
   num_bytes = 0u;
   void* write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             dp->ProducerEndWriteData(
                 num_bytes + static_cast<uint32_t>(sizeof(int32_t))));
 
   // But the two-phase write still ended.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerEndWriteData(0u));
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(&num_bytes));
   EXPECT_EQ(0u, num_bytes);
 
   // Try ending a two-phase write with an invalid amount (not a multiple of the
   // element size).
   num_bytes = 0u;
   write_ptr = NULL;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(&write_ptr, &num_bytes, false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_GE(num_bytes, 1u);
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ProducerEndWriteData(1u));
 
   // But the two-phase write still ended.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerEndWriteData(0u));
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(&num_bytes));
   EXPECT_EQ(0u, num_bytes);
@@ skipping 118 matching lines @@
   // End reading.
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(2u));
 
   dp->ProducerClose();
   dp->ConsumerClose();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo