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

mojo/system/memory.h

 // 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.
 
 #ifndef MOJO_SYSTEM_MEMORY_H_
 #define MOJO_SYSTEM_MEMORY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>  // For |memcpy()|.
@@ skipping 11 matching lines @@
 // Removes |const| from |T| (available as |remove_const<T>::type|):
 // TODO(vtl): Remove these once we have the C++11 |remove_const|.
 template <typename T> struct remove_const { typedef T type; };
 template <typename T> struct remove_const<const T> { typedef T type; };
 
 // Yields |(const) char| if |T| is |(const) void|, else |T|:
 template <typename T> struct VoidToChar { typedef T type; };
 template <> struct VoidToChar<void> { typedef char type; };
 template <> struct VoidToChar<const void> { typedef const char type; };
 
+// Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to
+// a buffer of the given size and alignment (both in bytes).
 template <size_t size, size_t alignment>
-void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointerHelper(const void* pointer);
+void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer(const void* pointer);
 
+// Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to
+// a buffer of |count| elements of the given size and alignment (both in bytes).
 template <size_t size, size_t alignment>
-void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointerWithCountHelper(
-    const void* pointer,
-    size_t count);
+void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointerWithCount(const void* pointer,
+                                                       size_t count);
+
+// Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to
+// a buffer of the given size and alignment (both in bytes).
+template <size_t alignment>
+void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointerWithSize(const void* pointer,
+                                                      size_t size);
 
 // TODO(vtl): Delete all the |Verify...()| things (and replace them with
 // |Check...()|.
 template <size_t size, size_t alignment>
 bool MOJO_SYSTEM_IMPL_EXPORT VerifyUserPointerHelper(const void* pointer);
 
 // Note: This is also used by options_validation.h.
 template <size_t size, size_t alignment>
 bool MOJO_SYSTEM_IMPL_EXPORT VerifyUserPointerWithCountHelper(
     const void* pointer,
     size_t count);
 
 }  // namespace internal
 
 // Forward declarations so that they can be friended.
 template <typename Type> class UserPointerReader;
 template <typename Type> class UserPointerWriter;
 template <typename Type> class UserPointerReaderWriter;
+template <class Options> class UserOptionsReader;
 
 // Verify (insofar as possible/necessary) that a |T| can be read from the user
 // |pointer|.
 template <typename T>
 bool VerifyUserPointer(const T* pointer) {
   return internal::VerifyUserPointerHelper<sizeof(T), MOJO_ALIGNOF(T)>(pointer);
 }
 
 // Verify (insofar as possible/necessary) that |count| |T|s can be read from the
 // user |pointer|; |count| may be zero. (This is done carefully since |count *
@@ skipping 44 matching lines @@
 
   // Allow conversion to a "non-const" |UserPointer|.
   operator UserPointer<const Type>() const {
     return UserPointer<const Type>(pointer_);
   }
 
   bool IsNull() const {
     return !pointer_;
   }
 
+  // "Reinterpret casts" to a |UserPointer<ToType>|.
+  template <typename ToType>
+  UserPointer<ToType> ReinterpretCast() const {
+    return UserPointer<ToType>(reinterpret_cast<ToType*>(pointer_));
+  }
+
+  // Checks that this pointer points to a valid array (of type |Type|, or just a
+  // buffer if |Type| is |void| or |const void|) of |count| elements (or bytes
+  // if |Type| is |void| or |const void|) in the same way as |GetArray()| and
+  // |PutArray()|.
+  // TODO(vtl): Logically, there should be separate read checks and write
+  // checks.
+  // TODO(vtl): Switch more things to use this.
+  void CheckArray(size_t count) const {
+    internal::CheckUserPointerWithCount<
+        sizeof(NonVoidType), MOJO_ALIGNOF(NonVoidType)>(pointer_, count);
+  }
+
   // Gets the value (of type |Type|) pointed to by this user pointer. Use this
   // when you'd use the rvalue |*user_pointer|, but be aware that this may be
   // costly -- so if the value will be used multiple times, you should save it.
   //
   // (We want to force a copy here, so return |Type| not |const Type&|.)
   Type Get() const {
-    internal::CheckUserPointerHelper<sizeof(Type),
-                                     MOJO_ALIGNOF(Type)>(pointer_);
+    internal::CheckUserPointer<sizeof(Type), MOJO_ALIGNOF(Type)>(pointer_);
     return *pointer_;
   }
 
   // Gets an array (of type |Type|, or just a buffer if |Type| is |void| or
   // |const void|) of |count| elements (or bytes if |Type| is |void| or |const
   // void|) from the location pointed to by this user pointer. Use this when
   // you'd do something like |memcpy(destination, user_pointer, count *
   // sizeof(Type)|.
   void GetArray(typename internal::remove_const<Type>::type* destination,
-                size_t count) {
-    internal::CheckUserPointerWithCountHelper<
+                size_t count) const {
+    internal::CheckUserPointerWithCount<
         sizeof(NonVoidType), MOJO_ALIGNOF(NonVoidType)>(pointer_, count);
     memcpy(destination, pointer_, count * sizeof(NonVoidType));
   }
 
   // Puts a value (of type |Type|, or of type |char| if |Type| is |void|) to the
   // location pointed to by this user pointer. Use this when you'd use the
   // lvalue |*user_pointer|. Since this may be costly, you should avoid using
   // this (for the same user pointer) more than once.
   //
   // Note: This |Put()| method is not valid when |T| is const, e.g., |const
   // uint32_t|, but it's okay to include them so long as this template is only
   // implicitly instantiated (see 14.7.1 of the C++11 standard) and not
   // explicitly instantiated. (On implicit instantiation, only the declarations
   // need be valid, not the definitions.)
   //
   // If |Type| is |void|, we "convert" it to |char|, so that it makes sense.
   // (Otherwise, we'd need a suitable specialization to exclude |Put()|.)
   //
   // In C++11, we could do something like:
   //   template <typename _Type = Type>
   //   typename enable_if<!is_const<_Type>::value &&
   //                      !is_void<_Type>::value>::type Put(
   //       const _Type& value) { ... }
   // (which obviously be correct), but C++03 doesn't allow default function
   // template arguments.
   void Put(const NonVoidType& value) {
-    internal::CheckUserPointerHelper<sizeof(NonVoidType),
-                                     MOJO_ALIGNOF(NonVoidType)>(pointer_);
+    internal::CheckUserPointer<sizeof(NonVoidType), MOJO_ALIGNOF(NonVoidType)>(
+        pointer_);
     *pointer_ = value;
   }
 
   // Puts an array (of type |Type|, or just a buffer if |Type| is |void|) with
   // |count| elements (or bytes |Type| is |void|) to the location pointed to by
   // this user pointer. Use this when you'd do something like
   // |memcpy(user_pointer, source, count * sizeof(Type))|.
   //
   // Note: The same comments about the validity of |Put()| (except for the part
   // about |void|) apply here.
   void PutArray(const Type* source, size_t count) {
-    internal::CheckUserPointerWithCountHelper<
+    internal::CheckUserPointerWithCount<
         sizeof(NonVoidType), MOJO_ALIGNOF(NonVoidType)>(pointer_, count);
     memcpy(pointer_, source, count * sizeof(NonVoidType));
   }
 
   // Gets a |UserPointer| at offset |i| (in |Type|s) relative to this.
   UserPointer At(size_t i) const {
     return UserPointer(static_cast<Type*>(
         static_cast<NonVoidType*>(pointer_) + i));
   }
 
-  // TODO(vtl): This is temporary. Get rid of this. (We should pass
-  // |UserPointer<>|s along appropriately, or access data in a safe way
-  // everywhere.)
-  Type* GetPointerUnsafe() const {
-    return pointer_;
-  }
-
   // These provides safe (read-only/write-only/read-and-write) access to a
   // |UserPointer<Type>| (probably pointing to an array) using just an ordinary
   // pointer (obtained via |GetPointer()|).
   //
   // The memory returned by |GetPointer()| may be a copy of the original user
   // memory, but should be modified only if the user is intended to eventually
   // see the change.) If any changes are made, |Commit()| should be called to
   // guarantee that the changes are written back to user memory (it may be
   // called multiple times).
   //
@@ skipping 19 matching lines @@
   //   }
   //
   // TODO(vtl): Possibly, since we're not really being safe, we should just not
   // copy for Release builds.
   typedef UserPointerReader<Type> Reader;
   typedef UserPointerWriter<Type> Writer;
   typedef UserPointerReaderWriter<Type> ReaderWriter;
 
  private:
   friend class UserPointerReader<Type>;
+  friend class UserPointerReader<const Type>;
   friend class UserPointerWriter<Type>;
   friend class UserPointerReaderWriter<Type>;
+  template <class Options> friend class UserOptionsReader;
 
   Type* pointer_;
   // Allow copy and assignment.
 };
 
 // Provides a convenient way to make a |UserPointer<Type>|.
 template <typename Type>
 inline UserPointer<Type> MakeUserPointer(Type* pointer) {
   return UserPointer<Type>(pointer);
 }
 
 // Implementation of |UserPointer<Type>::Reader|.
 template <typename Type>
 class UserPointerReader {
  private:
   typedef typename internal::remove_const<Type>::type TypeNoConst;
 
  public:
+  // Note: If |count| is zero, |GetPointer()| will always return null.
   UserPointerReader(UserPointer<const Type> user_pointer, size_t count) {
-    Init(user_pointer.pointer_, count);
+    Init(user_pointer.pointer_, count, true);
   }
   UserPointerReader(UserPointer<TypeNoConst> user_pointer, size_t count) {
-    Init(user_pointer.pointer_, count);
+    Init(user_pointer.pointer_, count, true);
   }
 
   const Type* GetPointer() const { return buffer_.get(); }
 
  private:
-  void Init(const Type* user_pointer, size_t count) {
-    internal::CheckUserPointerWithCountHelper<
-        sizeof(Type), MOJO_ALIGNOF(Type)>(user_pointer, count);
+  template <class Options> friend class UserOptionsReader;
+
+  struct NoCheck {};
+  UserPointerReader(NoCheck,
+                    UserPointer<const Type> user_pointer,
+                    size_t count) {
+    Init(user_pointer.pointer_, count, false);
+  }
+
+  void Init(const Type* user_pointer, size_t count, bool check) {
+    if (count == 0)
+      return;
+
+    if (check) {
+      internal::CheckUserPointerWithCount<sizeof(Type), MOJO_ALIGNOF(Type)>(
+          user_pointer, count);
+    }
     buffer_.reset(new TypeNoConst[count]);
     memcpy(buffer_.get(), user_pointer, count * sizeof(Type));
   }
 
   scoped_ptr<TypeNoConst[]> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(UserPointerReader);
 };
 
 // Implementation of |UserPointer<Type>::Writer|.
 template <typename Type>
 class UserPointerWriter {
  public:
+  // Note: If |count| is zero, |GetPointer()| will always return null.
   UserPointerWriter(UserPointer<Type> user_pointer, size_t count)
       : user_pointer_(user_pointer),
         count_(count) {
-    buffer_.reset(new Type[count_]);
-    memset(buffer_.get(), 0, count_ * sizeof(Type));
+    if (count_ > 0) {
+      buffer_.reset(new Type[count_]);
+      memset(buffer_.get(), 0, count_ * sizeof(Type));
+    }
   }
 
   Type* GetPointer() const { return buffer_.get(); }
 
   void Commit() {
-    internal::CheckUserPointerWithCountHelper<
-        sizeof(Type), MOJO_ALIGNOF(Type)>(user_pointer_.pointer_, count_);
+    internal::CheckUserPointerWithCount<sizeof(Type), MOJO_ALIGNOF(Type)>(
+        user_pointer_.pointer_, count_);
     memcpy(user_pointer_.pointer_, buffer_.get(), count_ * sizeof(Type));
   }
 
  private:
   UserPointer<Type> user_pointer_;
   size_t count_;
   scoped_ptr<Type[]> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(UserPointerWriter);
 };
 
 // Implementation of |UserPointer<Type>::ReaderWriter|.
 template <typename Type>
 class UserPointerReaderWriter {
  public:
+  // Note: If |count| is zero, |GetPointer()| will always return null.
   UserPointerReaderWriter(UserPointer<Type> user_pointer, size_t count)
       : user_pointer_(user_pointer),
         count_(count) {
-    internal::CheckUserPointerWithCountHelper<
-        sizeof(Type), MOJO_ALIGNOF(Type)>(user_pointer_.pointer_, count_);
-    buffer_.reset(new Type[count]);
-    memcpy(buffer_.get(), user_pointer.pointer_, count * sizeof(Type));
+    if (count_ > 0) {
+      internal::CheckUserPointerWithCount<sizeof(Type), MOJO_ALIGNOF(Type)>(
+          user_pointer_.pointer_, count_);
+      buffer_.reset(new Type[count]);
+      memcpy(buffer_.get(), user_pointer.pointer_, count * sizeof(Type));
+    }
   }
 
   Type* GetPointer() const { return buffer_.get(); }
   size_t GetCount() const { return count_; }
 
   void Commit() {
-    internal::CheckUserPointerWithCountHelper<
-        sizeof(Type), MOJO_ALIGNOF(Type)>(user_pointer_.pointer_, count_);
+    internal::CheckUserPointerWithCount<sizeof(Type), MOJO_ALIGNOF(Type)>(
+        user_pointer_.pointer_, count_);
     memcpy(user_pointer_.pointer_, buffer_.get(), count_ * sizeof(Type));
   }
 
  private:
   UserPointer<Type> user_pointer_;
   size_t count_;
   scoped_ptr<Type[]> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(UserPointerReaderWriter);
 };
@@ skipping 22 matching lines @@
 // Provides a convenient way to make a |UserPointerValue<Type>|.
 template <typename Type>
 inline UserPointerValue<Type> MakeUserPointerValue(Type* pointer) {
   return UserPointerValue<Type>(pointer);
 }
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_MEMORY_H_