Convert ReadMessage...() 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 71 matching lines @@
 // 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 {
+ private:
+  typedef typename internal::VoidToChar<Type>::type NonVoidType;
+
  public:
   // Instead of explicitly using these constructors, you can often use
   // |MakeUserPointer()| (or |NullUserPointer()| for null pointers). (The common
   // exception is when you have, e.g., a |char*| and want to get a
   // |UserPointer<void>|.)
   UserPointer() : pointer_(NULL) {}
   explicit UserPointer(Type* pointer) : pointer_(pointer) {}
   // Allow implicit conversion from the "null user pointer".
   UserPointer(NullUserPointer) : pointer_(NULL) {}
   ~UserPointer() {}
 
   // Allow assignment from the "null user pointer".
   UserPointer<Type>& operator=(NullUserPointer) {
     pointer_ = NULL;
     return *this;
   }
 
   // Allow conversion to a "non-const" |UserPointer|.
   operator UserPointer<const Type>() const {
     return UserPointer<const Type>(pointer_);
   }
 
   bool IsNull() const {
     return !pointer_;
   }
 
-  // We want to force a copy here, so return |Type| not |const Type&|.
+  // 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_);
     return *pointer_;
   }
 
+  // TODO(vtl): Add a |GetArray()| method (see |PutArray()|).
+
+  // 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 typename internal::VoidToChar<Type>::type& value) {
-    internal::CheckUserPointerHelper<sizeof(Type),
-                                     MOJO_ALIGNOF(Type)>(pointer_);
+  void Put(const NonVoidType& value) {
+    internal::CheckUserPointerHelper<sizeof(NonVoidType),
+                                     MOJO_ALIGNOF(NonVoidType)>(pointer_);
     *pointer_ = value;
   }
 
+  // Puts an array (of type |Type|, or just a buffer if |Type| is |void|) and
+  // size |count| (number of elements, or number of bytes if |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<sizeof(NonVoidType),
+                                              MOJO_ALIGNOF(NonVoidType)>(source,
+                                                                         count);
+    memcpy(pointer_, source, count * sizeof(NonVoidType));
+  }
+
+  // Gets a |UserPointer| at offset |i| (in |Type|s) relative to this. This
+  // method is not valid if |Type| is |void| (TODO(vtl): Maybe I should make it
+  // valid, with the offset in bytes?).
   UserPointer At(size_t i) const {
     return UserPointer(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_;
   }
@@ skipping 160 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_