Mojo: Convert MemoryTest.Valid to 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 28 matching lines @@
 template <size_t size, size_t alignment>
 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 *
-// sizeof(T)| may overflow a |size_t|.)
-template <typename T>
-bool VerifyUserPointerWithCount(const T* pointer, size_t count) {
-  return internal::VerifyUserPointerWithCountHelper<sizeof(T),
-                                                    MOJO_ALIGNOF(T)>(pointer,
-                                                                     count);
-}
-
-// Verify that |size| bytes (which may be zero) can be read from the user
-// |pointer|, and that |pointer| has the specified |alignment| (if |size| is
-// nonzero).
-template <size_t alignment>
-bool MOJO_SYSTEM_IMPL_EXPORT VerifyUserPointerWithSize(const void* pointer,
-                                                       size_t size);
-
 // Provides a convenient way to implicitly get null |UserPointer<Type>|s.
 struct NullUserPointer {};
 
 // Represents a user pointer to a single |Type| (which must be POD), for Mojo
 // primitive parameters.
 //
 // Use a const |Type| for in parameters, and non-const |Type|s for out and
 // in-out parameters (in which case the |Put()| method is available).
 template <typename Type>
 class UserPointer {
@@ skipping 105 matching lines @@
         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));
   }
 
+  // Gets the value of the |UserPointer| as a |uintptr_t|. This should not be
+  // casted back to a pointer (and dereferenced), but may be used as a key for
+  // lookup or passed back to the user.
+  uintptr_t GetPointerValue() const {
+    return reinterpret_cast<uintptr_t>(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 141 matching lines @@
   }
 
  private:
   UserPointer<Type> user_pointer_;
   size_t count_;
   scoped_ptr<Type[]> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(UserPointerReaderWriter);
 };
 
-// Represents a user pointer that will never be dereferenced by the system. The
-// pointer value (i.e., the address) may be as a key for lookup, or may be a
-// value that is only passed to the user at some point.
-template <typename Type>
-class UserPointerValue {
- public:
-  UserPointerValue() : pointer_() {}
-  explicit UserPointerValue(Type* pointer) : pointer_(pointer) {}
-  ~UserPointerValue() {}
-
-  // Returns the *value* of the pointer, which shouldn't be cast back to a
-  // pointer and dereferenced.
-  uintptr_t GetValue() const {
-    return reinterpret_cast<uintptr_t>(pointer_);
-  }
-
- private:
-  Type* pointer_;
-  // Allow copy and assignment.
-};
-
-// 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_