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

mojo/system/multiprocess_message_pipe_unittest.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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
@@ skipping 151 matching lines @@
     // Wait for our end of the message pipe to be readable.
     MojoResult result = WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE);
     if (result != MOJO_RESULT_OK) {
       // It was closed, probably.
       CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION);
       break;
     }
 
     std::string read_buffer(1000, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             &read_buffer[0], &read_buffer_size,
-                             NULL, NULL,
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                             MakeUserPointer(&read_buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
     VLOG(2) << "Child got: " << read_buffer;
 
     if (read_buffer == quitquitquit) {
       VLOG(2) << "Child quitting.";
       break;
     }
 
@@ skipping 23 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0,
                              hello.data(), static_cast<uint32_t>(hello.size()),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
   std::string read_buffer(1000, '\0');
   uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-  CHECK_EQ(mp->ReadMessage(0,
-                           &read_buffer[0], &read_buffer_size,
-                           NULL, NULL,
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&read_buffer_size), NULL, NULL,
                            MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(read_buffer_size);
   VLOG(2) << "Parent got: " << read_buffer;
   EXPECT_EQ(hello + hello, read_buffer);
 
   mp->Close(0);
 
   // We sent one message.
   EXPECT_EQ(1 % 100, helper()->WaitForChildShutdown());
@@ skipping 26 matching lines @@
                              quitquitquit.data(),
                              static_cast<uint32_t>(quitquitquit.size()),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   for (size_t i = 0; i < kNumMessages; i++) {
     EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
     std::string read_buffer(kNumMessages * 2, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             &read_buffer[0], &read_buffer_size,
-                             NULL, NULL,
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                             MakeUserPointer(&read_buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
 
     EXPECT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer);
   }
 
   // Wait for it to become readable, which should fail (since we sent
   // "quitquitquit").
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ skipping 16 matching lines @@
   channel_thread.Start(client_platform_handle.Pass(), mp);
 
   // Wait for the first message from our parent.
   CHECK_EQ(WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE), MOJO_RESULT_OK);
 
   // It should have a shared buffer.
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   DispatcherVector dispatchers;
   uint32_t num_dispatchers = 10;  // Maximum number to receive.
-  CHECK_EQ(mp->ReadMessage(0,
-                           &read_buffer[0], &num_bytes,
-                           &dispatchers, &num_dispatchers,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), &dispatchers,
+                           &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("go 1"));
   CHECK_EQ(num_dispatchers, 1u);
 
   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypeSharedBuffer);
 
   scoped_refptr<SharedBufferDispatcher> dispatcher(
       static_cast<SharedBufferDispatcher*>(dispatchers[0].get()));
 
@@ skipping 19 matching lines @@
                             static_cast<uint32_t>(go2.size()),
                             NULL,
                             MOJO_WRITE_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
 
   // Now wait for our parent to send us a message.
   CHECK_EQ(WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE), MOJO_RESULT_OK);
 
   read_buffer = std::string(100, '\0');
   num_bytes = static_cast<uint32_t>(read_buffer.size());
-  CHECK_EQ(mp->ReadMessage(0,
-                           &read_buffer[0], &num_bytes,
-                           NULL, NULL,
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), NULL, NULL,
                            MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("go 3"));
 
   // It should have written something to the shared buffer.
   static const char kWorld[] = "world!!!";
   CHECK_EQ(memcmp(mapping->base(), kWorld, sizeof(kWorld)), 0);
 
   // And we're done.
@@ skipping 50 matching lines @@
 
   EXPECT_TRUE(dispatcher->HasOneRef());
   dispatcher = NULL;
 
   // Wait for a message from the child.
   EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(0,
-                            &read_buffer[0], &num_bytes,
-                            NULL, NULL,
+            mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                            MakeUserPointer(&num_bytes), NULL, NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   read_buffer.resize(num_bytes);
   EXPECT_EQ(std::string("go 2"), read_buffer);
 
   // After we get it, the child should have written something to the shared
   // buffer.
   static const char kHello[] = "hello";
   EXPECT_EQ(0, memcmp(mapping->base(), kHello, sizeof(kHello)));
 
   // Now we'll write some stuff to the shared buffer.
@@ skipping 27 matching lines @@
       scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
   channel_thread.Start(client_platform_handle.Pass(), mp);
 
   CHECK_EQ(WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE), MOJO_RESULT_OK);
 
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   DispatcherVector dispatchers;
   uint32_t num_dispatchers = 10;  // Maximum number to receive.
-  CHECK_EQ(mp->ReadMessage(0,
-                           &read_buffer[0], &num_bytes,
-                           &dispatchers, &num_dispatchers,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), &dispatchers,
+                           &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   mp->Close(0);
 
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("hello"));
   CHECK_EQ(num_dispatchers, 1u);
 
   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypePlatformHandle);
 
   scoped_refptr<PlatformHandleDispatcher> dispatcher(
@@ skipping 65 matching lines @@
             WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
   mp->Close(0);
 
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo