Convert verification of options structs to use the new user pointer handling (see r285350).

mojo/system/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/data_pipe.h"
 
 #include <stddef.h>
 
 #include <limits>
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(kSizeOfCreateOptions, validated_options.struct_size);
   // Nothing to check for flags.
   EXPECT_GT(validated_options.element_num_bytes, 0u);
   EXPECT_GT(validated_options.capacity_num_bytes, 0u);
   EXPECT_EQ(0u,
             validated_options.capacity_num_bytes %
                 validated_options.element_num_bytes);
 
   MojoCreateDataPipeOptions revalidated_options = {};
   EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(&validated_options,
+            DataPipe::ValidateCreateOptions(MakeUserPointer(&validated_options),
                                             &revalidated_options));
   EXPECT_EQ(validated_options.struct_size, revalidated_options.struct_size);
   EXPECT_EQ(validated_options.element_num_bytes,
             revalidated_options.element_num_bytes);
   EXPECT_EQ(validated_options.capacity_num_bytes,
             revalidated_options.capacity_num_bytes);
   EXPECT_EQ(validated_options.flags, revalidated_options.flags);
 }
 
 // Checks that a default-computed capacity is correct. (Does not duplicate the
 // checks done by |RevalidateCreateOptions()|.)
 void CheckDefaultCapacity(const MojoCreateDataPipeOptions& validated_options) {
   EXPECT_LE(validated_options.capacity_num_bytes,
             kDefaultDataPipeCapacityBytes);
   EXPECT_GT(validated_options.capacity_num_bytes +
                 validated_options.element_num_bytes,
             kDefaultDataPipeCapacityBytes);
 }
 
 // Tests valid inputs to |ValidateCreateOptions()|.
 TEST(DataPipeTest, ValidateCreateOptionsValid) {
   // Default options.
   {
     MojoCreateDataPipeOptions validated_options = {};
     EXPECT_EQ(MOJO_RESULT_OK,
-              DataPipe::ValidateCreateOptions(NULL, &validated_options));
+              DataPipe::ValidateCreateOptions(NullUserPointer(),
+                                              &validated_options));
     RevalidateCreateOptions(validated_options);
     CheckDefaultCapacity(validated_options);
   }
 
   // Size member, but nothing beyond.
   {
     MojoCreateDataPipeOptions options = {
       offsetof(MojoCreateDataPipeOptions, flags)  // |struct_size|.
     };
     MojoCreateDataPipeOptions validated_options = {};
     EXPECT_EQ(MOJO_RESULT_OK,
-              DataPipe::ValidateCreateOptions(&options, &validated_options));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &validated_options));
     RevalidateCreateOptions(validated_options);
     CheckDefaultCapacity(validated_options);
   }
 
   // Different flags.
   MojoCreateDataPipeOptionsFlags flags_values[] = {
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
     MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD
   };
   for (size_t i = 0; i < arraysize(flags_values); i++) {
     const MojoCreateDataPipeOptionsFlags flags = flags_values[i];
 
     // Flags member, but nothing beyond.
     {
       MojoCreateDataPipeOptions options = {
         // |struct_size|.
         offsetof(MojoCreateDataPipeOptions, element_num_bytes),
         flags  // |flags|.
       };
       MojoCreateDataPipeOptions validated_options = {};
       EXPECT_EQ(MOJO_RESULT_OK,
-                DataPipe::ValidateCreateOptions(&options, &validated_options));
+                DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                                &validated_options));
       RevalidateCreateOptions(validated_options);
       EXPECT_EQ(options.flags, validated_options.flags);
       CheckDefaultCapacity(validated_options);
     }
 
     // Different capacities (size 1).
     for (uint32_t capacity = 1; capacity <= 100 * 1000 * 1000; capacity *= 10) {
       MojoCreateDataPipeOptions options = {
         kSizeOfCreateOptions,  // |struct_size|.
         flags,  // |flags|.
         1,  // |element_num_bytes|.
         capacity  // |capacity_num_bytes|.
       };
       MojoCreateDataPipeOptions validated_options = {};
       EXPECT_EQ(MOJO_RESULT_OK,
-                DataPipe::ValidateCreateOptions(&options, &validated_options))
+                DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                                &validated_options))
           << capacity;
       RevalidateCreateOptions(validated_options);
       EXPECT_EQ(options.flags, validated_options.flags);
       EXPECT_EQ(options.element_num_bytes,
                 validated_options.element_num_bytes);
       EXPECT_EQ(options.capacity_num_bytes,
                 validated_options.capacity_num_bytes);
     }
 
     // Small sizes.
     for (uint32_t size = 1; size < 100; size++) {
       // Different capacities.
       for (uint32_t elements = 1; elements <= 1000 * 1000; elements *= 10) {
         MojoCreateDataPipeOptions options = {
           kSizeOfCreateOptions,  // |struct_size|.
           flags,  // |flags|.
           size,  // |element_num_bytes|.
           size * elements  // |capacity_num_bytes|.
         };
         MojoCreateDataPipeOptions validated_options = {};
         EXPECT_EQ(MOJO_RESULT_OK,
-                  DataPipe::ValidateCreateOptions(&options, &validated_options))
+                  DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                                  &validated_options))
             << size << ", " << elements;
         RevalidateCreateOptions(validated_options);
         EXPECT_EQ(options.flags, validated_options.flags);
         EXPECT_EQ(options.element_num_bytes,
                   validated_options.element_num_bytes);
         EXPECT_EQ(options.capacity_num_bytes,
                   validated_options.capacity_num_bytes);
       }
 
       // Default capacity.
       {
         MojoCreateDataPipeOptions options = {
           kSizeOfCreateOptions,  // |struct_size|.
           flags,  // |flags|.
           size,  // |element_num_bytes|.
           0  // |capacity_num_bytes|.
         };
         MojoCreateDataPipeOptions validated_options = {};
         EXPECT_EQ(MOJO_RESULT_OK,
-                  DataPipe::ValidateCreateOptions(&options, &validated_options))
+                  DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                                  &validated_options))
             << size;
         RevalidateCreateOptions(validated_options);
         EXPECT_EQ(options.flags, validated_options.flags);
         EXPECT_EQ(options.element_num_bytes,
                   validated_options.element_num_bytes);
         CheckDefaultCapacity(validated_options);
       }
 
       // No capacity field.
       {
         MojoCreateDataPipeOptions options = {
           // |struct_size|.
           offsetof(MojoCreateDataPipeOptions, capacity_num_bytes),
           flags,  // |flags|.
           size  // |element_num_bytes|.
         };
         MojoCreateDataPipeOptions validated_options = {};
         EXPECT_EQ(MOJO_RESULT_OK,
-                  DataPipe::ValidateCreateOptions(&options, &validated_options))
+                  DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                                  &validated_options))
             << size;
         RevalidateCreateOptions(validated_options);
         EXPECT_EQ(options.flags, validated_options.flags);
         EXPECT_EQ(options.element_num_bytes,
                   validated_options.element_num_bytes);
         CheckDefaultCapacity(validated_options);
       }
     }
 
     // Larger sizes.
     for (uint32_t size = 100; size <= 100 * 1000; size *= 10) {
       // Capacity of 1000 elements.
       {
         MojoCreateDataPipeOptions options = {
           kSizeOfCreateOptions,  // |struct_size|.
           flags,  // |flags|.
           size,  // |element_num_bytes|.
           1000 * size  // |capacity_num_bytes|.
         };
         MojoCreateDataPipeOptions validated_options = {};
         EXPECT_EQ(MOJO_RESULT_OK,
-                  DataPipe::ValidateCreateOptions(&options, &validated_options))
+                  DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                                  &validated_options))
             << size;
         RevalidateCreateOptions(validated_options);
         EXPECT_EQ(options.flags, validated_options.flags);
         EXPECT_EQ(options.element_num_bytes,
                   validated_options.element_num_bytes);
         EXPECT_EQ(options.capacity_num_bytes,
                   validated_options.capacity_num_bytes);
       }
 
       // Default capacity.
       {
         MojoCreateDataPipeOptions options = {
           kSizeOfCreateOptions,  // |struct_size|.
           flags,  // |flags|.
           size,  // |element_num_bytes|.
           0  // |capacity_num_bytes|.
         };
         MojoCreateDataPipeOptions validated_options = {};
         EXPECT_EQ(MOJO_RESULT_OK,
-                  DataPipe::ValidateCreateOptions(&options, &validated_options))
+                  DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                                  &validated_options))
             << size;
         RevalidateCreateOptions(validated_options);
         EXPECT_EQ(options.flags, validated_options.flags);
         EXPECT_EQ(options.element_num_bytes,
                   validated_options.element_num_bytes);
         CheckDefaultCapacity(validated_options);
       }
 
       // No capacity field.
       {
         MojoCreateDataPipeOptions options = {
           // |struct_size|.
           offsetof(MojoCreateDataPipeOptions, capacity_num_bytes),
           flags,  // |flags|.
           size  // |element_num_bytes|.
         };
         MojoCreateDataPipeOptions validated_options = {};
         EXPECT_EQ(MOJO_RESULT_OK,
-                  DataPipe::ValidateCreateOptions(&options, &validated_options))
+                  DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                                  &validated_options))
             << size;
         RevalidateCreateOptions(validated_options);
         EXPECT_EQ(options.flags, validated_options.flags);
         EXPECT_EQ(options.element_num_bytes,
                   validated_options.element_num_bytes);
         CheckDefaultCapacity(validated_options);
       }
     }
   }
 }
 
 TEST(DataPipeTest, ValidateCreateOptionsInvalid) {
   // Invalid |struct_size|.
   {
     MojoCreateDataPipeOptions options = {
       1,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       1,  // |element_num_bytes|.
       0  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
 
   // Unknown |flags|.
   {
     MojoCreateDataPipeOptions options = {
       kSizeOfCreateOptions,  // |struct_size|.
       ~0u,  // |flags|.
       1,  // |element_num_bytes|.
       0  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
 
   // Invalid |element_num_bytes|.
   {
     MojoCreateDataPipeOptions options = {
       kSizeOfCreateOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       0,  // |element_num_bytes|.
       1000  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
   // |element_num_bytes| too big.
   {
     MojoCreateDataPipeOptions options = {
       kSizeOfCreateOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       std::numeric_limits<uint32_t>::max(),  // |element_num_bytes|.
       std::numeric_limits<uint32_t>::max()  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
   {
     MojoCreateDataPipeOptions options = {
       kSizeOfCreateOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       std::numeric_limits<uint32_t>::max() - 1000,  // |element_num_bytes|.
       std::numeric_limits<uint32_t>::max() - 1000  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
 
   // Invalid |capacity_num_bytes|.
   {
     MojoCreateDataPipeOptions options = {
       kSizeOfCreateOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       2,  // |element_num_bytes|.
       1  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
   {
     MojoCreateDataPipeOptions options = {
       kSizeOfCreateOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       2,  // |element_num_bytes|.
       111  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
   {
     MojoCreateDataPipeOptions options = {
       kSizeOfCreateOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       5,  // |element_num_bytes|.
       104  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
   // |capacity_num_bytes| too big.
   {
     MojoCreateDataPipeOptions options = {
       kSizeOfCreateOptions,  // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       8,  // |element_num_bytes|.
       0xffff0000  // |capacity_num_bytes|.
     };
     MojoCreateDataPipeOptions unused;
     EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-              DataPipe::ValidateCreateOptions(&options, &unused));
+              DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
+                                              &unused));
   }
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo