Convert WriteMessage...() 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 45 matching lines @@
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
     // Shouldn't need to remove the waiter (it was not added).
 
     // Add a readable waiter to |d0|, then make it readable (by writing to
     // |d1|), then wait.
     w.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1));
     buffer[0] = 123456789;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d1->WriteMessage(buffer, kBufferSize,
-                               NULL,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                               NULL, MOJO_WRITE_MESSAGE_FLAG_NONE));
     stopwatch.Start();
     EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, &context));
     EXPECT_EQ(1u, context);
     EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
     d0->RemoveWaiter(&w);
 
     // 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));
@@ skipping 42 matching lines @@
         MessagePipeDispatcher::kDefaultCreateOptions));
   scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher(
         MessagePipeDispatcher::kDefaultCreateOptions));
   {
     scoped_refptr<MessagePipe> mp(new MessagePipe());
     d0->Init(mp, 0);
     d1->Init(mp, 1);
   }
 
   // |WriteMessage|:
+  // Huge buffer size.
+  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
+            d0->WriteMessage(UserPointer<const void>(buffer),
+                             std::numeric_limits<uint32_t>::max(), NULL,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
+  EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
+}
+
+// These test invalid arguments that should cause death if we're being paranoid
+// about checking arguments (which we would want to do if, e.g., we were in a
+// true "kernel" situation, but we might not want to do otherwise for
+// performance reasons). Probably blatant errors like passing in null pointers
+// (for required pointer arguments) will still cause death, but perhaps not
+// predictably.
+TEST(MessagePipeDispatcherTest, InvalidParamsDeath) {
+  const char kMemoryCheckFailedRegex[] = "Check failed";
+
+  scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
+  scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
+  {
+    scoped_refptr<MessagePipe> mp(new MessagePipe());
+    d0->Init(mp, 0);
+    d1->Init(mp, 1);
+  }
+
+  // |WriteMessage|:
   // Null buffer with nonzero buffer size.
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d0->WriteMessage(NULL, 1,
-                             NULL,
+  EXPECT_DEATH_IF_SUPPORTED(
+      d0->WriteMessage(NullUserPointer(), 1, NULL,
+                       MOJO_WRITE_MESSAGE_FLAG_NONE),
+      kMemoryCheckFailedRegex);
+
+  // |ReadMessage|:
+  // Null buffer with nonzero buffer size.
+  // First write something so that we actually have something to read.
+  EXPECT_EQ(MOJO_RESULT_OK,
+            d1->WriteMessage(UserPointer<const void>("x"), 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));
+  uint32_t buffer_size = 1;
+  EXPECT_DEATH_IF_SUPPORTED(
+      d0->ReadMessage(NullUserPointer(), MakeUserPointer(&buffer_size), 0, NULL,
+                      MOJO_READ_MESSAGE_FLAG_NONE),
+      kMemoryCheckFailedRegex);
 
   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;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
     scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher(
         MessagePipeDispatcher::kDefaultCreateOptions));
     scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher(
         MessagePipeDispatcher::kDefaultCreateOptions));
     {
       scoped_refptr<MessagePipe> mp(new MessagePipe());
       d0->Init(mp, i);  // 0, 1.
       d1->Init(mp, i ^ 1);  // 1, 0.
     }
     Waiter w;
 
     // Write (twice) to |d1|.
     buffer[0] = 123456789;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d1->WriteMessage(buffer, kBufferSize,
-                               NULL,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                               NULL, MOJO_WRITE_MESSAGE_FLAG_NONE));
     buffer[0] = 234567890;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d1->WriteMessage(buffer, kBufferSize,
-                               NULL,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                               NULL, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // 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,
@@ skipping 49 matching lines @@
     buffer[0] = 0;
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               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));
+              d0->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                               NULL, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
   }
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/396386
 #define MAYBE_BasicThreaded DISABLED_BasicThreaded
 #else
 #define MAYBE_BasicThreaded BasicThreaded
@@ skipping 26 matching lines @@
                                MOJO_HANDLE_SIGNAL_READABLE,
                                MOJO_DEADLINE_INDEFINITE,
                                1,
                                &did_wait, &result, &context);
       stopwatch.Start();
       thread.Start();
       base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
       // Wake it up by writing to |d0|.
       buffer[0] = 123456789;
       EXPECT_EQ(MOJO_RESULT_OK,
-                d0->WriteMessage(buffer, kBufferSize,
-                                 NULL,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
+                d0->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                                 NULL, MOJO_WRITE_MESSAGE_FLAG_NONE));
     }  // Joins the thread.
     elapsed = stopwatch.Elapsed();
     EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout());
     EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout());
     EXPECT_TRUE(did_wait);
     EXPECT_EQ(MOJO_RESULT_OK, result);
     EXPECT_EQ(1u, context);
 
     // Now |d1| is already readable. Try waiting for it again.
     {
@@ skipping 107 matching lines @@
       buffer[i] = static_cast<unsigned char>(i);
 
     // Number of messages to write.
     *messages_written_ = static_cast<size_t>(base::RandInt(1000, 6000));
 
     // Write messages.
     for (size_t i = 0; i < *messages_written_; i++) {
       uint32_t bytes_to_write = static_cast<uint32_t>(
           base::RandInt(1, static_cast<int>(kMaxMessageSize)));
       EXPECT_EQ(MOJO_RESULT_OK,
-                write_dispatcher_->WriteMessage(buffer, bytes_to_write,
-                                                NULL,
+                write_dispatcher_->WriteMessage(UserPointer<const void>(buffer),
+                                                bytes_to_write, NULL,
                                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
       *bytes_written_ += bytes_to_write;
     }
 
     // Write one last "quit" message.
     EXPECT_EQ(MOJO_RESULT_OK,
-              write_dispatcher_->WriteMessage("quit", 4,
-                                              NULL,
+              write_dispatcher_->WriteMessage(UserPointer<const void>("quit"),
+                                              4, NULL,
                                               MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
 
   const scoped_refptr<Dispatcher> write_dispatcher_;
   size_t* const messages_written_;
   size_t* const bytes_written_;
 
   DISALLOW_COPY_AND_ASSIGN(WriterThread);
 };
 
@@ skipping 143 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