Convert WriteMessage...() to use the new user pointer handling (see r285350).

mojo/system/core.cc

 // 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.
 
 #include "mojo/system/core.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 182 matching lines @@
                               UserPointer<const void> bytes,
                               uint32_t num_bytes,
                               UserPointer<const MojoHandle> handles,
                               uint32_t num_handles,
                               MojoWriteMessageFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(GetDispatcher(message_pipe_handle));
   if (!dispatcher)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   // Easy case: not sending any handles.
-  if (num_handles == 0) {
-    return dispatcher->WriteMessage(bytes.GetPointerUnsafe(), num_bytes, NULL,
-                                    flags);
-  }
+  if (num_handles == 0)
+    return dispatcher->WriteMessage(bytes, num_bytes, NULL, flags);
 
   // We have to handle |handles| here, since we have to mark them busy in the
   // global handle table. We can't delegate this to the dispatcher, since the
   // handle table lock must be acquired before the dispatcher lock.
   //
   // (This leads to an oddity: |handles|/|num_handles| are always verified for
   // validity, even for dispatchers that don't support |WriteMessage()| and will
   // simply return failure unconditionally. It also breaks the usual
   // left-to-right verification order of arguments.)
   if (num_handles > kMaxMessageNumHandles)
@@ skipping 13 matching lines @@
   // handles from the handle table.
   {
     base::AutoLock locker(handle_table_lock_);
     MojoResult result = handle_table_.MarkBusyAndStartTransport(
         message_pipe_handle, handles_reader.GetPointer(), num_handles,
         &transports);
     if (result != MOJO_RESULT_OK)
       return result;
   }
 
-  MojoResult rv = dispatcher->WriteMessage(bytes.GetPointerUnsafe(), num_bytes,
-                                           &transports, flags);
+  MojoResult rv = dispatcher->WriteMessage(bytes, num_bytes, &transports,
+                                           flags);
 
   // We need to release the dispatcher locks before we take the handle table
   // lock.
   for (uint32_t i = 0; i < num_handles; i++)
     transports[i].End();
 
   {
     base::AutoLock locker(handle_table_lock_);
     if (rv == MOJO_RESULT_OK) {
       handle_table_.RemoveBusyHandles(handles_reader.GetPointer(), num_handles);
@@ skipping 307 matching lines @@
   // |Wait()|/|WaitMany()| call. (Only after doing this can |waiter| be
   // destroyed, but this would still be required if the waiter were in TLS.)
   for (i = 0; i < num_added; i++)
     dispatchers[i]->RemoveWaiter(&waiter);
 
   return rv;
 }
 
 }  // namespace system
 }  // namespace mojo