Mojo: Remove redundant verification of Options pointers.

mojo/system/core.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/core.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 275 matching lines @@
       }
     }
   }
 
   return rv;
 }
 
 MojoResult Core::CreateDataPipe(const MojoCreateDataPipeOptions* options,
                                 MojoHandle* data_pipe_producer_handle,
                                 MojoHandle* data_pipe_consumer_handle) {
-  if (options) {
-    // The |struct_size| field must be valid to read.
-    if (!VerifyUserPointer<uint32_t>(&options->struct_size))
-      return MOJO_RESULT_INVALID_ARGUMENT;
-    // And then |options| must point to at least |options->struct_size| bytes.
-    if (!VerifyUserPointerWithSize<MOJO_ALIGNOF(int64_t)>(options,
-                                                          options->struct_size))
-      return MOJO_RESULT_INVALID_ARGUMENT;
-  }
+  MojoCreateDataPipeOptions validated_options = {};
+  // This will verify the |options| pointer.
+  MojoResult result = DataPipe::ValidateCreateOptions(options,
+                                                      &validated_options);
+  if (result != MOJO_RESULT_OK)
+    return result;
   if (!VerifyUserPointer<MojoHandle>(data_pipe_producer_handle))
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (!VerifyUserPointer<MojoHandle>(data_pipe_consumer_handle))
     return MOJO_RESULT_INVALID_ARGUMENT;
 
-  MojoCreateDataPipeOptions validated_options = { 0 };
-  MojoResult result = DataPipe::ValidateCreateOptions(options,
-                                                      &validated_options);
-  if (result != MOJO_RESULT_OK)
-    return result;
-
   scoped_refptr<DataPipeProducerDispatcher> producer_dispatcher(
       new DataPipeProducerDispatcher());
   scoped_refptr<DataPipeConsumerDispatcher> consumer_dispatcher(
       new DataPipeConsumerDispatcher());
 
   std::pair<MojoHandle, MojoHandle> handle_pair;
   {
     base::AutoLock locker(handle_table_lock_);
     handle_pair = handle_table_.AddDispatcherPair(producer_dispatcher,
                                                   consumer_dispatcher);
@@ skipping 81 matching lines @@
   if (!dispatcher)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   return dispatcher->EndReadData(num_bytes_read);
 }
 
 MojoResult Core::CreateSharedBuffer(
     const MojoCreateSharedBufferOptions* options,
     uint64_t num_bytes,
     MojoHandle* shared_buffer_handle) {
-  if (options) {
-    // The |struct_size| field must be valid to read.
-    if (!VerifyUserPointer<uint32_t>(&options->struct_size))
-      return MOJO_RESULT_INVALID_ARGUMENT;
-    // And then |options| must point to at least |options->struct_size| bytes.
-    if (!VerifyUserPointerWithSize<MOJO_ALIGNOF(int64_t)>(options,
-                                                          options->struct_size))
-      return MOJO_RESULT_INVALID_ARGUMENT;
-  }
-  if (!VerifyUserPointer<MojoHandle>(shared_buffer_handle))
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  MojoCreateSharedBufferOptions validated_options = { 0 };
+  MojoCreateSharedBufferOptions validated_options = {};
+  // This will verify the |options| pointer.
   MojoResult result =
       SharedBufferDispatcher::ValidateCreateOptions(options,
                                                     &validated_options);
   if (result != MOJO_RESULT_OK)
     return result;
+  if (!VerifyUserPointer<MojoHandle>(shared_buffer_handle))
+    return MOJO_RESULT_INVALID_ARGUMENT;
 
   scoped_refptr<SharedBufferDispatcher> dispatcher;
   result = SharedBufferDispatcher::Create(validated_options, num_bytes,
                                           &dispatcher);
   if (result != MOJO_RESULT_OK) {
     DCHECK(!dispatcher);
     return result;
   }
 
   MojoHandle h = AddDispatcher(dispatcher);
@@ skipping 114 matching lines @@
   // |Wait()|/|WaitMany()| call. (Only after doing this can |waiter| be
   // destroyed, but this would still be required if the waiter were in TLS.)
   for (i = 0; i < num_added; i++)
     dispatchers[i]->RemoveWaiter(&waiter);
 
   return rv;
 }
 
 }  // namespace system
 }  // namespace mojo