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

R=darin@chromium.org

Review URL: https://codereview.chromium.org/411253011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@285503 0039d316-1c4b-4281-b951-d872f2087c98

mojo/system/core.cc

@@ -371,8 +371,7 @@ MojoResult Core::BeginWriteData(MojoHandle data_pipe_producer_handle,
   if (!dispatcher)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
-  return dispatcher->BeginWriteData(buffer.GetPointerUnsafe(),
-                                    buffer_num_bytes.GetPointerUnsafe(), flags);
+  return dispatcher->BeginWriteData(buffer, buffer_num_bytes, flags);
 }
 
 MojoResult Core::EndWriteData(MojoHandle data_pipe_producer_handle,

mojo/system/core_test_base.cc

@@ -98,8 +98,8 @@ class MockDispatcher : public Dispatcher {
   }
 
   virtual MojoResult BeginWriteDataImplNoLock(
-      void** /*buffer*/,
-      uint32_t* /*buffer_num_bytes*/,
+      UserPointer<void*> /*buffer*/,
+      UserPointer<uint32_t> /*buffer_num_bytes*/,
       MojoWriteDataFlags /*flags*/) OVERRIDE {
     info_->IncrementBeginWriteDataCallCount();
     lock().AssertAcquired();

mojo/system/data_pipe.cc

@@ -120,9 +120,10 @@ MojoResult DataPipe::ProducerWriteData(const void* elements,
   return rv;
 }
 
-MojoResult DataPipe::ProducerBeginWriteData(void** buffer,
-                                            uint32_t* buffer_num_bytes,
-                                            bool all_or_none) {
+MojoResult DataPipe::ProducerBeginWriteData(
+    UserPointer<void*> buffer,
+    UserPointer<uint32_t> buffer_num_bytes,
+    bool all_or_none) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
 
@@ -131,11 +132,15 @@ MojoResult DataPipe::ProducerBeginWriteData(void** buffer,
   if (!consumer_open_no_lock())
     return MOJO_RESULT_FAILED_PRECONDITION;
 
-  if (all_or_none && *buffer_num_bytes % element_num_bytes_ != 0)
-    return MOJO_RESULT_INVALID_ARGUMENT;
+  uint32_t min_num_bytes_to_write = 0;
+  if (all_or_none) {
+    min_num_bytes_to_write = buffer_num_bytes.Get();
+    if (min_num_bytes_to_write % element_num_bytes_ != 0)
+      return MOJO_RESULT_INVALID_ARGUMENT;
+  }
 
   MojoResult rv = ProducerBeginWriteDataImplNoLock(buffer, buffer_num_bytes,
-                                                   all_or_none);
+                                                   min_num_bytes_to_write);
   if (rv != MOJO_RESULT_OK)
     return rv;
   // Note: No need to awake producer waiters, even though we're going from

mojo/system/data_pipe.h

@@ -14,6 +14,7 @@
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/types.h"
 #include "mojo/system/handle_signals_state.h"
+#include "mojo/system/memory.h"
 #include "mojo/system/system_impl_export.h"
 
 namespace mojo {
@@ -54,9 +55,8 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe :
   MojoResult ProducerWriteData(const void* elements,
                                uint32_t* num_bytes,
                                bool all_or_none);
-  // This does not validate its arguments.
-  MojoResult ProducerBeginWriteData(void** buffer,
-                                    uint32_t* buffer_num_bytes,
+  MojoResult ProducerBeginWriteData(UserPointer<void*> buffer,
+                                    UserPointer<uint32_t> buffer_num_bytes,
                                     bool all_or_none);
   MojoResult ProducerEndWriteData(uint32_t num_bytes_written);
   MojoResult ProducerAddWaiter(Waiter* waiter,
@@ -102,9 +102,9 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe :
                                                  uint32_t* num_bytes,
                                                  bool all_or_none) = 0;
   virtual MojoResult ProducerBeginWriteDataImplNoLock(
-      void** buffer,
-      uint32_t* buffer_num_bytes,
-      bool all_or_none) = 0;
+      UserPointer<void*> buffer,
+      UserPointer<uint32_t> buffer_num_bytes,
+      uint32_t min_num_bytes_to_write) = 0;
   virtual MojoResult ProducerEndWriteDataImplNoLock(
       uint32_t num_bytes_written) = 0;
   // Note: A producer should not be writable during a two-phase write.

mojo/system/data_pipe_producer_dispatcher.cc

@@ -66,16 +66,11 @@ MojoResult DataPipeProducerDispatcher::WriteDataImplNoLock(
 }
 
 MojoResult DataPipeProducerDispatcher::BeginWriteDataImplNoLock(
-    void** buffer,
-    uint32_t* buffer_num_bytes,
+    UserPointer<void*> buffer,
+    UserPointer<uint32_t> buffer_num_bytes,
     MojoWriteDataFlags flags) {
   lock().AssertAcquired();
 
-  if (!VerifyUserPointerWithCount<void*>(buffer, 1))
-    return MOJO_RESULT_INVALID_ARGUMENT;
-  if (!VerifyUserPointer<uint32_t>(buffer_num_bytes))
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
   return data_pipe_->ProducerBeginWriteData(
       buffer, buffer_num_bytes, (flags & MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
 }

mojo/system/data_pipe_producer_dispatcher.h

@@ -41,8 +41,8 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipeProducerDispatcher : public Dispatcher {
                                          uint32_t* num_bytes,
                                          MojoWriteDataFlags flags) OVERRIDE;
   virtual MojoResult BeginWriteDataImplNoLock(
-      void** buffer,
-      uint32_t* buffer_num_bytes,
+      UserPointer<void*> buffer,
+      UserPointer<uint32_t> buffer_num_bytes,
       MojoWriteDataFlags flags) OVERRIDE;
   virtual MojoResult EndWriteDataImplNoLock(
       uint32_t num_bytes_written) OVERRIDE;

mojo/system/dispatcher.cc

@@ -146,8 +146,8 @@ MojoResult Dispatcher::WriteData(const void* elements,
   return WriteDataImplNoLock(elements, num_bytes, flags);
 }
 
-MojoResult Dispatcher::BeginWriteData(void** buffer,
-                                      uint32_t* buffer_num_bytes,
+MojoResult Dispatcher::BeginWriteData(UserPointer<void*> buffer,
+                                      UserPointer<uint32_t> buffer_num_bytes,
                                       MojoWriteDataFlags flags) {
   base::AutoLock locker(lock_);
   if (is_closed_)
@@ -285,9 +285,10 @@ MojoResult Dispatcher::WriteDataImplNoLock(const void* /*elements*/,
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
-MojoResult Dispatcher::BeginWriteDataImplNoLock(void** /*buffer*/,
-                                                uint32_t* /*buffer_num_bytes*/,
-                                                MojoWriteDataFlags /*flags*/) {
+MojoResult Dispatcher::BeginWriteDataImplNoLock(
+    UserPointer<void*> /*buffer*/,
+    UserPointer<uint32_t> /*buffer_num_bytes*/,
+    MojoWriteDataFlags /*flags*/) {
   lock_.AssertAcquired();
   DCHECK(!is_closed_);
   // By default, not supported. Only needed for data pipe dispatchers.

mojo/system/dispatcher.h

@@ -20,6 +20,7 @@
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/message_pipe.h"
 #include "mojo/public/c/system/types.h"
+#include "mojo/system/memory.h"
 #include "mojo/system/system_impl_export.h"
 
 namespace mojo {
@@ -94,8 +95,8 @@ class MOJO_SYSTEM_IMPL_EXPORT Dispatcher :
   MojoResult WriteData(const void* elements,
                        uint32_t* elements_num_bytes,
                        MojoWriteDataFlags flags);
-  MojoResult BeginWriteData(void** buffer,
-                            uint32_t* buffer_num_bytes,
+  MojoResult BeginWriteData(UserPointer<void*> buffer,
+                            UserPointer<uint32_t> buffer_num_bytes,
                             MojoWriteDataFlags flags);
   MojoResult EndWriteData(uint32_t num_bytes_written);
   MojoResult ReadData(void* elements,
@@ -224,9 +225,10 @@ class MOJO_SYSTEM_IMPL_EXPORT Dispatcher :
   virtual MojoResult WriteDataImplNoLock(const void* elements,
                                          uint32_t* num_bytes,
                                          MojoWriteDataFlags flags);
-  virtual MojoResult BeginWriteDataImplNoLock(void** buffer,
-                                              uint32_t* buffer_num_bytes,
-                                              MojoWriteDataFlags flags);
+  virtual MojoResult BeginWriteDataImplNoLock(
+      UserPointer<void*> buffer,
+      UserPointer<uint32_t> buffer_num_bytes,
+      MojoWriteDataFlags flags);
   virtual MojoResult EndWriteDataImplNoLock(uint32_t num_bytes_written);
   virtual MojoResult ReadDataImplNoLock(void* elements,
                                         uint32_t* num_bytes,

mojo/system/dispatcher_unittest.cc

@@ -9,6 +9,7 @@
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
+#include "mojo/system/memory.h"
 #include "mojo/system/raw_shared_buffer.h"
 #include "mojo/system/waiter.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -52,7 +53,8 @@ TEST(DispatcherTest, Basic) {
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->WriteData(NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->BeginWriteData(NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
+            d->BeginWriteData(NullUserPointer(), NullUserPointer(),
+                              MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->EndWriteData(0));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
@@ -79,7 +81,8 @@ TEST(DispatcherTest, Basic) {
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->WriteData(NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->BeginWriteData(NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
+            d->BeginWriteData(NullUserPointer(), NullUserPointer(),
+                              MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->EndWriteData(0));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
@@ -157,7 +160,8 @@ class ThreadSafetyStressThread : public base::SimpleThread {
         break;
       case BEGIN_WRITE_DATA:
         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-                  dispatcher_->BeginWriteData(NULL, NULL,
+                  dispatcher_->BeginWriteData(NullUserPointer(),
+                                              NullUserPointer(),
                                               MOJO_WRITE_DATA_FLAG_NONE));
         break;
       case END_WRITE_DATA:

mojo/system/local_data_pipe.cc

@@ -101,9 +101,9 @@ MojoResult LocalDataPipe::ProducerWriteDataImplNoLock(const void* elements,
 }
 
 MojoResult LocalDataPipe::ProducerBeginWriteDataImplNoLock(
-    void** buffer,
-    uint32_t* buffer_num_bytes,
-    bool all_or_none) {
+    UserPointer<void*> buffer,
+    UserPointer<uint32_t> buffer_num_bytes,
+    uint32_t min_num_bytes_to_write) {
   DCHECK(consumer_open_no_lock());
 
   // The index we need to start writing at.
@@ -111,17 +111,17 @@ MojoResult LocalDataPipe::ProducerBeginWriteDataImplNoLock(
       (start_index_ + current_num_bytes_) % capacity_num_bytes();
 
   size_t max_num_bytes_to_write = GetMaxNumBytesToWriteNoLock();
-  if (all_or_none && *buffer_num_bytes > max_num_bytes_to_write) {
+  if (min_num_bytes_to_write > max_num_bytes_to_write) {
     // In "may discard" mode, we can always write from the write index to the
     // end of the buffer.
     if (may_discard() &&
-        *buffer_num_bytes <= capacity_num_bytes() - write_index) {
+        min_num_bytes_to_write <= capacity_num_bytes() - write_index) {
       // To do so, we need to discard an appropriate amount of data.
       // We should only reach here if the start index is after the write index!
       DCHECK_GE(start_index_, write_index);
-      DCHECK_GT(*buffer_num_bytes - max_num_bytes_to_write, 0u);
-      MarkDataAsConsumedNoLock(*buffer_num_bytes - max_num_bytes_to_write);
-      max_num_bytes_to_write = *buffer_num_bytes;
+      DCHECK_GT(min_num_bytes_to_write - max_num_bytes_to_write, 0u);
+      MarkDataAsConsumedNoLock(min_num_bytes_to_write - max_num_bytes_to_write);
+      max_num_bytes_to_write = min_num_bytes_to_write;
     } else {
       // Don't return "should wait" since you can't wait for a specified amount
       // of data.
@@ -134,8 +134,8 @@ MojoResult LocalDataPipe::ProducerBeginWriteDataImplNoLock(
     return MOJO_RESULT_SHOULD_WAIT;
 
   EnsureBufferNoLock();
-  *buffer = buffer_.get() + write_index;
-  *buffer_num_bytes = static_cast<uint32_t>(max_num_bytes_to_write);
+  buffer.Put(buffer_.get() + write_index);
+  buffer_num_bytes.Put(static_cast<uint32_t>(max_num_bytes_to_write));
   set_producer_two_phase_max_num_bytes_written_no_lock(
       static_cast<uint32_t>(max_num_bytes_to_write));
   return MOJO_RESULT_OK;

mojo/system/local_data_pipe.h

@@ -35,9 +35,9 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalDataPipe : public DataPipe {
                                                  uint32_t* num_bytes,
                                                  bool all_or_none) OVERRIDE;
   virtual MojoResult ProducerBeginWriteDataImplNoLock(
-      void** buffer,
-      uint32_t* buffer_num_bytes,
-      bool all_or_none) OVERRIDE;
+      UserPointer<void*> buffer,
+      UserPointer<uint32_t> buffer_num_bytes,
+      uint32_t min_num_bytes_to_write) OVERRIDE;
   virtual MojoResult ProducerEndWriteDataImplNoLock(
       uint32_t num_bytes_written) OVERRIDE;
   virtual HandleSignalsState

mojo/system/local_data_pipe_unittest.cc

@@ -9,6 +9,7 @@
 #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"
 
@@ -250,7 +251,8 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) {
   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);
 
@@ -419,7 +421,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     // 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);
@@ -507,7 +510,8 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
   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)));
 
@@ -545,7 +549,8 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
   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)));
 
@@ -778,7 +783,8 @@ TEST(LocalDataPipeTest, MayDiscard) {
   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));
@@ -791,7 +797,8 @@ TEST(LocalDataPipeTest, MayDiscard) {
   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)));
@@ -802,14 +809,16 @@ TEST(LocalDataPipeTest, MayDiscard) {
   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));
@@ -822,7 +831,8 @@ TEST(LocalDataPipeTest, MayDiscard) {
   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));
@@ -1096,7 +1106,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   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).
@@ -1104,7 +1115,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   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);
@@ -1116,7 +1128,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   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);
@@ -1149,7 +1162,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   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);
@@ -1242,7 +1256,8 @@ TEST(LocalDataPipeTest, WrapAround) {
   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));
@@ -1315,7 +1330,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     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);
 
@@ -1360,7 +1376,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     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);
 
@@ -1391,7 +1408,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     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();
   }
@@ -1405,7 +1423,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     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);
 
@@ -1485,7 +1504,8 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
   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))));
@@ -1503,7 +1523,8 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
   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));