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

mojo/system/remote_message_pipe_unittest.cc

 // Copyright 2014 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 <vector>
 
@@ skipping 196 matching lines @@
                               NULL,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   mp1->RemoveWaiter(1, &waiter);
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // Write in the other direction: MP 1, port 1 -> ... -> MP 0, port 0.
 
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp1->WriteMessage(1,
                               kWorld, sizeof(kWorld),
                               NULL,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   mp0->RemoveWaiter(0, &waiter);
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->ReadMessage(0,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kWorld, buffer);
 
   // Close MP 0, port 0.
   mp0->Close(0);
 
   // Try to wait for MP 1, port 1 to become readable. This will eventually fail
   // when it realizes that MP 0, port 0 has been closed. (It may also fail
   // immediately.)
@@ skipping 53 matching lines @@
                               NULL,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   mp3->RemoveWaiter(1, &waiter);
 
   // Make sure there's nothing on MP 0, port 0 or MP 1, port 1 or MP 2, port 0.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp0->ReadMessage(0,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp1->ReadMessage(1,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp2->ReadMessage(0,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp2->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Read from MP 3, port 1.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp3->ReadMessage(1,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp3->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // Write: MP 0, port 0 -> MP 1, port 1 again.
 
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp0->WriteMessage(0,
                               kWorld, sizeof(kWorld),
                               NULL,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   mp1->RemoveWaiter(1, &waiter);
 
   // Make sure there's nothing on the other ports.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp0->ReadMessage(0,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp2->ReadMessage(0,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp2->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp3->ReadMessage(1,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp3->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kWorld, buffer);
 
   mp0->Close(0);
   mp1->Close(1);
   mp2->Close(0);
   mp3->Close(1);
 }
 
@@ skipping 37 matching lines @@
 
   BootstrapMessagePipeNoWait(1, mp1);
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   mp1->RemoveWaiter(1, &waiter);
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             buffer, &buffer_size,
-                             NULL, NULL,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), NULL, NULL,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // And MP 1, port 1.
   mp1->Close(1);
 }
 
 TEST_F(RemoteMessagePipeTest, HandlePassing) {
   static const char kHello[] = "hello";
@@ skipping 43 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   mp1->RemoveWaiter(1, &waiter);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = { 0 };
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1, read_buffer, &read_buffer_size,
+            mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                             MakeUserPointer(&read_buffer_size),
                              &read_dispatchers, &read_num_dispatchers,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0]);
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType());
@@ skipping 14 matching lines @@
 
   // Wait for the dispatcher to become readable.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   dispatcher->RemoveWaiter(&waiter);
 
   // Read from the dispatcher.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            dispatcher->ReadMessage(read_buffer, &read_buffer_size, 0, NULL,
+            dispatcher->ReadMessage(UserPointer<void>(read_buffer),
+                                    MakeUserPointer(&read_buffer_size), 0, NULL,
                                     MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789));
 
   // Write to the dispatcher.
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->WriteMessage(kHello, sizeof(kHello), NULL,
                                      MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   local_mp->RemoveWaiter(1, &waiter);
 
   // Read from "local_mp", port 1.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->ReadMessage(1, read_buffer, &read_buffer_size, NULL, NULL,
-                                  MOJO_READ_MESSAGE_FLAG_NONE));
+            local_mp->ReadMessage(1, UserPointer<void>(read_buffer),
+                                  MakeUserPointer(&read_buffer_size), NULL,
+                                  NULL, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // TODO(vtl): Also test that messages queued up before the handle was sent are
   // delivered properly.
 
   // Close everything that belongs to us.
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
@@ skipping 69 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   mp1->RemoveWaiter(1, &waiter);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = { 0 };
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1, read_buffer, &read_buffer_size,
+            mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                             MakeUserPointer(&read_buffer_size),
                              &read_dispatchers, &read_num_dispatchers,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0]);
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypeSharedBuffer, read_dispatchers[0]->GetType());
@@ skipping 94 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   mp1->RemoveWaiter(1, &waiter);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = { 0 };
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1, read_buffer, &read_buffer_size,
+            mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                             MakeUserPointer(&read_buffer_size),
                              &read_dispatchers, &read_num_dispatchers,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0]);
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypePlatformHandle, read_dispatchers[0]->GetType());
@@ skipping 56 matching lines @@
 
     mp1->Close(1);
 
     RestoreInitialState();
   }
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo