Convert WriteMessage...() 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 111 matching lines @@
   // 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()|).
+  // 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<
+        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_);
     *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))|.
+  // 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<sizeof(NonVoidType),
-                                              MOJO_ALIGNOF(NonVoidType)>(source,
-                                                                         count);
+    internal::CheckUserPointerWithCountHelper<
+        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. 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);
   }
 
@@ skipping 166 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_