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

mojo/system/shared_buffer_dispatcher.cc

 // Copyright 2014 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/shared_buffer_dispatcher.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 17 matching lines @@
 
 // static
 const MojoCreateSharedBufferOptions
     SharedBufferDispatcher::kDefaultCreateOptions = {
   static_cast<uint32_t>(sizeof(MojoCreateSharedBufferOptions)),
   MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE
 };
 
 // static
 MojoResult SharedBufferDispatcher::ValidateCreateOptions(
-    const MojoCreateSharedBufferOptions* in_options,
+    UserPointer<const MojoCreateSharedBufferOptions> in_options,
     MojoCreateSharedBufferOptions* out_options) {
   const MojoCreateSharedBufferOptionsFlags kKnownFlags =
       MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;
 
   *out_options = kDefaultCreateOptions;
-  if (!in_options)
+  if (in_options.IsNull())
     return MOJO_RESULT_OK;
 
-  MojoResult result =
-      ValidateOptionsStructPointerSizeAndFlags<MojoCreateSharedBufferOptions>(
-          in_options, kKnownFlags, out_options);
-  if (result != MOJO_RESULT_OK)
-    return result;
+  UserOptionsReader<MojoCreateSharedBufferOptions> reader(in_options);
+  if (!reader.is_valid())
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+  if (!OPTIONS_STRUCT_HAS_MEMBER(MojoCreateSharedBufferOptions, flags, reader))
+    return MOJO_RESULT_OK;
+  if ((reader.options().flags & ~kKnownFlags))
+    return MOJO_RESULT_UNIMPLEMENTED;
+  out_options->flags = reader.options().flags;
 
   // Checks for fields beyond |flags|:
 
   // (Nothing here yet.)
 
   return MOJO_RESULT_OK;
 }
 
 // static
 MojoResult SharedBufferDispatcher::Create(
@@ skipping 71 matching lines @@
     scoped_refptr<RawSharedBuffer> shared_buffer)
     : shared_buffer_(shared_buffer) {
   DCHECK(shared_buffer_);
 }
 
 SharedBufferDispatcher::~SharedBufferDispatcher() {
 }
 
 // static
 MojoResult SharedBufferDispatcher::ValidateDuplicateOptions(
-    const MojoDuplicateBufferHandleOptions* in_options,
+    UserPointer<const MojoDuplicateBufferHandleOptions> in_options,
     MojoDuplicateBufferHandleOptions* out_options) {
   const MojoDuplicateBufferHandleOptionsFlags kKnownFlags =
       MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE;
   static const MojoDuplicateBufferHandleOptions kDefaultOptions = {
     static_cast<uint32_t>(sizeof(MojoDuplicateBufferHandleOptions)),
     MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE
   };
 
   *out_options = kDefaultOptions;
-  if (!in_options)
+  if (in_options.IsNull())
     return MOJO_RESULT_OK;
 
-  MojoResult result =
-      ValidateOptionsStructPointerSizeAndFlags<
-          MojoDuplicateBufferHandleOptions>(
-              in_options, kKnownFlags, out_options);
-  if (result != MOJO_RESULT_OK)
-    return result;
+  UserOptionsReader<MojoDuplicateBufferHandleOptions> reader(in_options);
+  if (!reader.is_valid())
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+  if (!OPTIONS_STRUCT_HAS_MEMBER(MojoDuplicateBufferHandleOptions, flags,
+                                 reader))
+    return MOJO_RESULT_OK;
+  if ((reader.options().flags & ~kKnownFlags))
+    return MOJO_RESULT_UNIMPLEMENTED;
+  out_options->flags = reader.options().flags;
 
   // Checks for fields beyond |flags|:
 
   // (Nothing here yet.)
 
   return MOJO_RESULT_OK;
 }
 
 void SharedBufferDispatcher::CloseImplNoLock() {
   lock().AssertAcquired();
   DCHECK(shared_buffer_);
   shared_buffer_ = NULL;
 }
 
 scoped_refptr<Dispatcher>
     SharedBufferDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
   lock().AssertAcquired();
   DCHECK(shared_buffer_);
   scoped_refptr<RawSharedBuffer> shared_buffer;
   shared_buffer.swap(shared_buffer_);
   return scoped_refptr<Dispatcher>(new SharedBufferDispatcher(shared_buffer));
 }
 
 MojoResult SharedBufferDispatcher::DuplicateBufferHandleImplNoLock(
-    const MojoDuplicateBufferHandleOptions* options,
+    UserPointer<const MojoDuplicateBufferHandleOptions> options,
     scoped_refptr<Dispatcher>* new_dispatcher) {
   lock().AssertAcquired();
 
   MojoDuplicateBufferHandleOptions validated_options;
   MojoResult result = ValidateDuplicateOptions(options, &validated_options);
   if (result != MOJO_RESULT_OK)
     return result;
 
   *new_dispatcher = new SharedBufferDispatcher(shared_buffer_);
   return MOJO_RESULT_OK;
@@ skipping 66 matching lines @@
   return true;
 }
 
 HandleSignalsState SharedBufferDispatcher::GetHandleSignalsStateNoLock() const {
   // TODO(vtl): Add transferrable flag.
   return HandleSignalsState();
 }
 
 }  // namespace system
 }  // namespace mojo