Mojo: Implement plumbing to support passing handles over MessagePipes.

mojo/system/remote_message_pipe_posix_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.
 
 // TODO(vtl): Factor out the POSIX-specific bits of this test (once we have a
 // non-POSIX implementation).
 
 #include "mojo/system/message_pipe.h"
 
 #include <fcntl.h>
@@ skipping 134 matching lines @@
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
 
   // Write to MP 0, port 0.
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_0->WriteMessage(0,
                                hello, sizeof(hello),
-                               NULL, 0,
+                               NULL,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(123, waiter.Wait(MOJO_DEADLINE_INDEFINITE));
   mp_1->RemoveWaiter(1, &waiter);
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_1->ReadMessage(1,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(hello), static_cast<size_t>(buffer_size));
   EXPECT_EQ(0, strcmp(buffer, hello));
 
   // Write in the other direction: MP 1, port 1 -> ... -> MP 0, port 0.
 
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_0->AddWaiter(0, &waiter, MOJO_WAIT_FLAG_READABLE, 456));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_1->WriteMessage(1,
                                world, sizeof(world),
-                               NULL, 0,
+                               NULL,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(456, waiter.Wait(MOJO_DEADLINE_INDEFINITE));
   mp_0->RemoveWaiter(0, &waiter);
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_0->ReadMessage(0,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(world), static_cast<size_t>(buffer_size));
   EXPECT_EQ(0, strcmp(buffer, world));
 
   // Close MP 0, port 0.
   mp_0->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 48 matching lines @@
 
   // Write: MP 2, port 0 -> MP 3, port 1.
 
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_3->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 789));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_2->WriteMessage(0,
                                hello, sizeof(hello),
-                               NULL, 0,
+                               NULL,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(789, waiter.Wait(MOJO_DEADLINE_INDEFINITE));
   mp_3->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_NOT_FOUND,
             mp_0->ReadMessage(0,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
             mp_1->ReadMessage(1,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
             mp_2->ReadMessage(0,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, 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,
             mp_3->ReadMessage(1,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(hello), static_cast<size_t>(buffer_size));
   EXPECT_EQ(0, strcmp(buffer, hello));
 
   // Write: MP 0, port 0 -> MP 1, port 1 again.
 
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_0->WriteMessage(0,
                                world, sizeof(world),
-                               NULL, 0,
+                               NULL,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(123, waiter.Wait(MOJO_DEADLINE_INDEFINITE));
   mp_1->RemoveWaiter(1, &waiter);
 
   // Make sure there's nothing on the other ports.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
             mp_0->ReadMessage(0,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
             mp_2->ReadMessage(0,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
             mp_3->ReadMessage(1,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             mp_1->ReadMessage(1,
                               buffer, &buffer_size,
-                              NULL, NULL,
+                              0, NULL,
                               MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(world), static_cast<size_t>(buffer_size));
   EXPECT_EQ(0, strcmp(buffer, world));
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo