Convert verification of options structs 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));
 
 // Validate options.
 TEST(LocalDataPipeTest, Creation) {
   // Create using default options.
   {
     // Get default options.
     MojoCreateDataPipeOptions default_options = { 0 };
     EXPECT_EQ(MOJO_RESULT_OK,
-              DataPipe::ValidateCreateOptions(NULL, &default_options));
+              DataPipe::ValidateCreateOptions(NullUserPointer(),
+                                              &default_options));
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(default_options));
     dp->ProducerClose();
     dp->ConsumerClose();
   }
 
   // Create using non-default options.
   {
     const MojoCreateDataPipeOptions options = {
       kSizeOfOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       1,  // |element_num_bytes|.
       1000  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions validated_options = { 0 };
     EXPECT_EQ(MOJO_RESULT_OK,
-              DataPipe::ValidateCreateOptions(&options, &validated_options));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &validated_options));
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
     dp->ProducerClose();
     dp->ConsumerClose();
   }
   {
     const MojoCreateDataPipeOptions options = {
       kSizeOfOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       4,  // |element_num_bytes|.
       4000  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions validated_options = { 0 };
     EXPECT_EQ(MOJO_RESULT_OK,
-              DataPipe::ValidateCreateOptions(&options, &validated_options));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &validated_options));
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
     dp->ProducerClose();
     dp->ConsumerClose();
   }
   {
     const MojoCreateDataPipeOptions options = {
       kSizeOfOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
       7,  // |element_num_bytes|.
       7000000  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions validated_options = { 0 };
     EXPECT_EQ(MOJO_RESULT_OK,
-              DataPipe::ValidateCreateOptions(&options, &validated_options));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &validated_options));
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
     dp->ProducerClose();
     dp->ConsumerClose();
   }
   // Default capacity.
   {
     const MojoCreateDataPipeOptions options = {
       kSizeOfOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
       100,  // |element_num_bytes|.
       0  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions validated_options = { 0 };
     EXPECT_EQ(MOJO_RESULT_OK,
-              DataPipe::ValidateCreateOptions(&options, &validated_options));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &validated_options));
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
     dp->ProducerClose();
     dp->ConsumerClose();
   }
 }
 
 TEST(LocalDataPipeTest, SimpleReadWrite) {
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
     static_cast<uint32_t>(sizeof(int32_t)),  // |element_num_bytes|.
     1000 * sizeof(int32_t)  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   int32_t elements[10] = { 0 };
   uint32_t num_bytes = 0;
 
   // Try reading; nothing there yet.
   num_bytes = static_cast<uint32_t>(arraysize(elements) * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             dp->ConsumerReadData(UserPointer<void>(elements),
@@ skipping 83 matching lines @@
   // are strict maximums. This is not guaranteed by the API.
 
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
     static_cast<uint32_t>(sizeof(int32_t)),  // |element_num_bytes|.
     2 * sizeof(int32_t)  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
   Waiter waiter;
   uint32_t context = 0;
 
   // Never readable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12));
 
@@ skipping 105 matching lines @@
 
 TEST(LocalDataPipeTest, BasicConsumerWaiting) {
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
     static_cast<uint32_t>(sizeof(int32_t)),  // |element_num_bytes|.
     1000 * sizeof(int32_t)  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   {
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
     Waiter waiter;
     uint32_t context = 0;
 
     // Never writable.
     waiter.Init();
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12));
@@ skipping 168 matching lines @@
 // Tests that data pipes aren't writable/readable during two-phase writes/reads.
 TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
     static_cast<uint32_t>(sizeof(int32_t)),  // |element_num_bytes|.
     1000 * sizeof(int32_t)  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
   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));
@@ skipping 87 matching lines @@
 // Test that a "may discard" data pipe is writable even when it's full.
 TEST(LocalDataPipeTest, BasicMayDiscardWaiting) {
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
     static_cast<uint32_t>(sizeof(int32_t)),  // |element_num_bytes|.
     1 * sizeof(int32_t)  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
   Waiter waiter;
 
   // Writable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
 
   // Not readable.
@@ skipping 70 matching lines @@
 
 TEST(LocalDataPipeTest, MayDiscard) {
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
     static_cast<uint32_t>(sizeof(int32_t)),  // |element_num_bytes|.
     10 * sizeof(int32_t)  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   int32_t buffer[100] = { 0 };
   uint32_t num_bytes = 0;
 
   num_bytes = 20u * sizeof(int32_t);
   Seq(0, arraysize(buffer), buffer);
   // Try writing more than capacity. (This test relies on the implementation
   // enforcing the capacity strictly.)
@@ skipping 172 matching lines @@
 
 TEST(LocalDataPipeTest, AllOrNone) {
   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|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   // Try writing way too much.
   uint32_t num_bytes = 20u * sizeof(int32_t);
   int32_t buffer[100];
   Seq(0, arraysize(buffer), buffer);
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
             dp->ProducerWriteData(UserPointer<const void>(buffer),
                                   MakeUserPointer(&num_bytes), true));
@@ skipping 139 matching lines @@
 
 TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
     static_cast<uint32_t>(sizeof(int32_t)),  // |element_num_bytes|.
     10 * sizeof(int32_t)  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   // Try writing way too much.
   uint32_t num_bytes = 20u * sizeof(int32_t);
   int32_t buffer[100];
   Seq(0, arraysize(buffer), buffer);
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
             dp->ProducerWriteData(UserPointer<const void>(buffer),
                                   MakeUserPointer(&num_bytes), true));
@@ skipping 78 matching lines @@
 
 TEST(LocalDataPipeTest, 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|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&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(MakeUserPointer(&write_ptr),
                                        MakeUserPointer(&num_bytes), true));
 
@@ skipping 118 matching lines @@
     test_data[i] = static_cast<unsigned char>(i);
 
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
     1u,  // |element_num_bytes|.
     100u  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
   // This test won't be valid if |ValidateCreateOptions()| decides to give the
   // pipe more space.
   ASSERT_EQ(100u, validated_options.capacity_num_bytes);
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   // Write 20 bytes.
   uint32_t num_bytes = 20u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(&test_data[0]),
@@ skipping 63 matching lines @@
   const uint32_t kTestDataSize = static_cast<uint32_t>(sizeof(kTestData));
 
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
     1u,  // |element_num_bytes|.
     1000u  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   // Close producer first, then consumer.
   {
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
     // Write some data, so we'll have something to read.
     uint32_t num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(UserPointer<const void>(kTestData),
                                     MakeUserPointer(&num_bytes), false));
@@ skipping 164 matching lines @@
 
 TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
   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|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   // No data.
   uint32_t num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Try "ending" a two-phase write when one isn't active.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ skipping 105 matching lines @@
 // |ProducerWriteData()| then changes the data underneath the two-phase read.)
 TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) {
   const MojoCreateDataPipeOptions options = {
     kSizeOfOptions,  // |struct_size|.
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
     1,  // |element_num_bytes|.
     2  // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = { 0 };
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&options, &validated_options));
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                            &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   // Write some elements.
   char elements[2] = { 'a', 'b' };
   uint32_t num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
                                   MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(2u, num_bytes);
@@ skipping 46 matching lines @@
   // End reading.
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(2u));
 
   dp->ProducerClose();
   dp->ConsumerClose();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo