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

mojo/system/message_pipe_dispatcher_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.
 
 // NOTE(vtl): Some of these tests are inherently flaky (e.g., if run on a
 // heavily-loaded system). Sorry. |test::EpsilonTimeout()| may be increased to
 // increase tolerance and reduce observed flakiness (though doing so reduces the
 // meaningfulness of the test).
 
 #include "mojo/system/message_pipe_dispatcher.h"
@@ skipping 64 matching lines @@
     // Try adding a readable waiter when already readable (from above).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 2));
     // Shouldn't need to remove the waiter (it was not added).
 
     // Make |d0| no longer readable (by reading from it).
     buffer[0] = 0;
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d0->ReadMessage(buffer, &buffer_size,
-                              0, NULL,
+              d0->ReadMessage(UserPointer<void>(buffer),
+                              MakeUserPointer(&buffer_size), 0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(kBufferSize, buffer_size);
     EXPECT_EQ(123456789, buffer[0]);
 
     // Wait for zero time for readability on |d0| (will time out).
     w.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3));
     stopwatch.Start();
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, NULL));
@@ skipping 35 matching lines @@
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d0->WriteMessage(NULL, 1,
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   // Huge buffer size.
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             d0->WriteMessage(buffer, std::numeric_limits<uint32_t>::max(),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
-  // |ReadMessage|:
-  // Null buffer with nonzero buffer size.
-  uint32_t buffer_size = 1;
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d0->ReadMessage(NULL, &buffer_size,
-                            0, NULL,
-                            MOJO_READ_MESSAGE_FLAG_NONE));
-
   EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
 }
 
 // Test what happens when one end is closed (single-threaded test).
 TEST(MessagePipeDispatcherTest, BasicClosed) {
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
@@ skipping 24 matching lines @@
 
     // Try waiting for readable on |d0|; should fail (already satisfied).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
     // Try reading from |d1|; should fail (nothing to read).
     buffer[0] = 0;
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-              d1->ReadMessage(buffer, &buffer_size,
-                              0, NULL,
+              d1->ReadMessage(UserPointer<void>(buffer),
+                              MakeUserPointer(&buffer_size), 0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
 
     // Close |d1|.
     EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
 
     // Try waiting for readable on |d0|; should fail (already satisfied).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1));
 
     // Read from |d0|.
     buffer[0] = 0;
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d0->ReadMessage(buffer, &buffer_size,
-                              0, NULL,
+              d0->ReadMessage(UserPointer<void>(buffer),
+                              MakeUserPointer(&buffer_size), 0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(kBufferSize, buffer_size);
     EXPECT_EQ(123456789, buffer[0]);
 
     // Try waiting for readable on |d0|; should fail (already satisfied).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 2));
 
     // Read again from |d0|.
     buffer[0] = 0;
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d0->ReadMessage(buffer, &buffer_size,
-                              0, NULL,
+              d0->ReadMessage(UserPointer<void>(buffer),
+                              MakeUserPointer(&buffer_size), 0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(kBufferSize, buffer_size);
     EXPECT_EQ(234567890, buffer[0]);
 
     // Try waiting for readable on |d0|; should fail (unsatisfiable).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3));
 
     // Try waiting for writable on |d0|; should fail (unsatisfiable).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4));
 
     // Try reading from |d0|; should fail (nothing to read and other end
     // closed).
     buffer[0] = 0;
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              d0->ReadMessage(buffer, &buffer_size,
-                              0, NULL,
+              d0->ReadMessage(UserPointer<void>(buffer),
+                              MakeUserPointer(&buffer_size), 0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
 
     // Try writing to |d0|; should fail (other end closed).
     buffer[0] = 345678901;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               d0->WriteMessage(buffer, kBufferSize,
                                NULL,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
@@ skipping 63 matching lines @@
       thread.Start();
     }  // Joins the thread.
     EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
     EXPECT_FALSE(did_wait);
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, result);
 
     // Consume what we wrote to |d0|.
     buffer[0] = 0;
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d1->ReadMessage(buffer, &buffer_size,
-                              0, NULL,
+              d1->ReadMessage(UserPointer<void>(buffer),
+                              MakeUserPointer(&buffer_size), 0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(kBufferSize, buffer_size);
     EXPECT_EQ(123456789, buffer[0]);
 
     // Wait for readable on |d1| and close |d0| after some time, which should
     // cancel that wait.
     {
       test::WaiterThread thread(d1,
                                 MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE,
@@ skipping 139 matching lines @@
       if (result == MOJO_RESULT_OK) {
         // Actually need to wait.
         EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, NULL));
         read_dispatcher_->RemoveWaiter(&w);
       }
 
       // Now, try to do the read.
       // Clear the buffer so that we can check the result.
       memset(buffer, 0, sizeof(buffer));
       uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
-      result = read_dispatcher_->ReadMessage(buffer, &buffer_size,
-                                             0, NULL,
-                                             MOJO_READ_MESSAGE_FLAG_NONE);
+      result = read_dispatcher_->ReadMessage(UserPointer<void>(buffer),
+                                             MakeUserPointer(&buffer_size), 0,
+                                             NULL, MOJO_READ_MESSAGE_FLAG_NONE);
       EXPECT_TRUE(result == MOJO_RESULT_OK ||
                   result == MOJO_RESULT_SHOULD_WAIT) << "result: " << result;
       // We're racing with others to read, so maybe we failed.
       if (result == MOJO_RESULT_SHOULD_WAIT)
         continue;  // In which case, try again.
       // Check for quit.
       if (buffer_size == 4 && memcmp("quit", buffer, 4) == 0)
         return;
       EXPECT_GE(buffer_size, 1u);
       EXPECT_LE(buffer_size, kMaxMessageSize);
@@ skipping 90 matching lines @@
   EXPECT_EQ(total_messages_written, total_messages_read);
   EXPECT_EQ(total_bytes_written, total_bytes_read);
 
   EXPECT_EQ(MOJO_RESULT_OK, d_write->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d_read->Close());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo