Support mojo connections between unrelated peer processes.

mojo/edk/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 <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
@@ skipping 50 matching lines @@
       return p;
     }
 
     void Exit() { WriteMessage(h_, "exit"); }
 
    private:
     MojoHandle h_;
   };
 };
 
+class MultiprocessMessagePipeTestWithPeerSupport
+    : public MultiprocessMessagePipeTest,
+      public testing::WithParamInterface<test::MojoTestBase::LaunchType> {
+ protected:
+  void SetUp() override {
+    test::MojoTestBase::SetUp();
+    set_launch_type(GetParam());
+  }
+};
+
 // For each message received, sends a reply message with the same contents
 // repeated twice, until the other end is closed or it receives "quitquitquit"
 // (which it doesn't reply to). It'll return the number of messages received,
 // not including any "quitquitquit" message, modulo 100.
 DEFINE_TEST_CLIENT_WITH_PIPE(EchoEcho, MultiprocessMessagePipeTest, h) {
   const std::string quitquitquit("quitquitquit");
   int rv = 0;
   for (;; rv = (rv + 1) % 100) {
     // Wait for our end of the message pipe to be readable.
     HandleSignalsState hss;
@@ skipping 28 matching lines @@
     std::string write_buffer = read_buffer + read_buffer;
     CHECK_EQ(MojoWriteMessage(h, write_buffer.data(),
                               static_cast<uint32_t>(write_buffer.size()),
                               nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
 
   return rv;
 }
 
-TEST_F(MultiprocessMessagePipeTest, Basic) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, Basic) {
   RUN_CHILD_ON_PIPE(EchoEcho, h)
     std::string hello("hello");
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, hello.data(),
                                static_cast<uint32_t>(hello.size()), nullptr, 0u,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
@@ skipping 15 matching lines @@
     ASSERT_EQ(hello + hello, read_buffer);
 
     std::string quitquitquit("quitquitquit");
     CHECK_EQ(MojoWriteMessage(h, quitquitquit.data(),
                               static_cast<uint32_t>(quitquitquit.size()),
                               nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   END_CHILD_AND_EXPECT_EXIT_CODE(1 % 100);
 }
 
-TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, QueueMessages) {
   static const size_t kNumMessages = 1001;
   RUN_CHILD_ON_PIPE(EchoEcho, h)
     for (size_t i = 0; i < kNumMessages; i++) {
       std::string write_buffer(i, 'A' + (i % 26));
       ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, write_buffer.data(),
                                static_cast<uint32_t>(write_buffer.size()),
                                nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE));
     }
 
@@ skipping 336 matching lines @@
   // Now write some data into the message pipe.
   std::string write_buffer = "world";
   CHECK_EQ(MojoWriteMessage(handles[0], write_buffer.data(),
                             static_cast<uint32_t>(write_buffer.size()), nullptr,
                             0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   MojoClose(handles[0]);
   return 0;
 }
 
-TEST_F(MultiprocessMessagePipeTest, MessagePipePassing) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, MessagePipePassing) {
   RUN_CHILD_ON_PIPE(CheckMessagePipe, h)
     MojoCreateSharedBufferOptions options;
     options.struct_size = sizeof(options);
     options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;
 
     MojoHandle mp1, mp2;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoCreateMessagePipe(nullptr, &mp1, &mp2));
 
     // Write a string into one end of the new message pipe and send the other
@@ skipping 21 matching lines @@
                              &read_buffer_size, nullptr,
                              0, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
     CHECK_EQ(read_buffer, std::string("world"));
 
     MojoClose(mp1);
   END_CHILD()
 }
 
-TEST_F(MultiprocessMessagePipeTest, MessagePipeTwoPassing) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, MessagePipeTwoPassing) {
   RUN_CHILD_ON_PIPE(CheckMessagePipe, h)
     MojoHandle mp1, mp2;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoCreateMessagePipe(nullptr, &mp2, &mp1));
 
     // Write a string into one end of the new message pipe and send the other
     // end.
     const std::string hello("hello");
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(mp1, &hello[0],
@@ skipping 109 matching lines @@
                              &read_buffer_size, nullptr,
                              0, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
     CHECK_EQ(read_buffer, std::string("world"));
 
     MojoClose(mp1);
   END_CHILD();
 }
 
-TEST_F(MultiprocessMessagePipeTest, CreateMessagePipe) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, CreateMessagePipe) {
   MojoHandle p0, p1;
   CreateMessagePipe(&p0, &p1);
   VerifyTransmission(p0, p1, "hey man");
   VerifyTransmission(p1, p0, "slow down");
   VerifyTransmission(p0, p1, std::string(10 * 1024 * 1024, 'a'));
   VerifyTransmission(p1, p0, std::string(10 * 1024 * 1024, 'e'));
 
   CloseHandle(p0);
   CloseHandle(p1);
 }
 
-TEST_F(MultiprocessMessagePipeTest, PassMessagePipeLocal) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, PassMessagePipeLocal) {
   MojoHandle p0, p1;
   CreateMessagePipe(&p0, &p1);
   VerifyTransmission(p0, p1, "testing testing");
   VerifyTransmission(p1, p0, "one two three");
 
   MojoHandle p2, p3;
 
   CreateMessagePipe(&p2, &p3);
   VerifyTransmission(p2, p3, "testing testing");
   VerifyTransmission(p3, p2, "one two three");
@@ skipping 19 matching lines @@
                              h) {
   for (;;) {
     std::string message = ReadMessage(h);
     if (message == "exit")
       break;
     WriteMessage(h, message);
   }
   return 0;
 }
 
-TEST_F(MultiprocessMessagePipeTest, MultiprocessChannelPipe) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, MultiprocessChannelPipe) {
   RUN_CHILD_ON_PIPE(ChannelEchoClient, h)
     VerifyEcho(h, "in an interstellar burst");
     VerifyEcho(h, "i am back to save the universe");
     VerifyEcho(h, std::string(10 * 1024 * 1024, 'o'));
 
     WriteMessage(h, "exit");
   END_CHILD()
 }
 
 // Receives a pipe handle from the primordial channel and echos on it until
 // "exit". Used to test simple pipe transfer across processes via channels.
 DEFINE_TEST_CLIENT_WITH_PIPE(EchoServiceClient, MultiprocessMessagePipeTest,
                              h) {
   MojoHandle p;
   ReadMessageWithHandles(h, &p, 1);
   for (;;) {
     std::string message = ReadMessage(p);
     if (message == "exit")
       break;
     WriteMessage(p, message);
   }
   return 0;
 }
 
-TEST_F(MultiprocessMessagePipeTest, PassMessagePipeCrossProcess) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport,
+       PassMessagePipeCrossProcess) {
   MojoHandle p0, p1;
   CreateMessagePipe(&p0, &p1);
   RUN_CHILD_ON_PIPE(EchoServiceClient, h)
 
     // Pass one end of the pipe to the other process.
     WriteMessageWithHandles(h, "here take this", &p1, 1);
 
     VerifyEcho(p0, "and you may ask yourself");
     VerifyEcho(p0, "where does that highway go?");
     VerifyEcho(p0, std::string(20 * 1024 * 1024, 'i'));
@@ skipping 36 matching lines @@
       WriteMessage(handles[index], ReadMessage(handles[index]));
     }
   }
 
   for (size_t i = 1; i < handles.size(); ++i)
     CloseHandle(handles[i]);
 
   return 0;
 }
 
-TEST_F(MultiprocessMessagePipeTest, PassMoarMessagePipesCrossProcess) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport,
+       PassMoarMessagePipesCrossProcess) {
   MojoHandle echo_factory_proxy, echo_factory_request;
   CreateMessagePipe(&echo_factory_proxy, &echo_factory_request);
 
   MojoHandle echo_proxy_a, echo_request_a;
   CreateMessagePipe(&echo_proxy_a, &echo_request_a);
 
   MojoHandle echo_proxy_b, echo_request_b;
   CreateMessagePipe(&echo_proxy_b, &echo_request_b);
 
   MojoHandle echo_proxy_c, echo_request_c;
@@ skipping 24 matching lines @@
 
     WriteMessage(h, "exit");
   END_CHILD()
 
   CloseHandle(echo_factory_proxy);
   CloseHandle(echo_proxy_a);
   CloseHandle(echo_proxy_b);
   CloseHandle(echo_proxy_c);
 }
 
-TEST_F(MultiprocessMessagePipeTest, ChannelPipesWithMultipleChildren) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport,
+       ChannelPipesWithMultipleChildren) {
   RUN_CHILD_ON_PIPE(ChannelEchoClient, a)
     RUN_CHILD_ON_PIPE(ChannelEchoClient, b)
       VerifyEcho(a, "hello child 0");
       VerifyEcho(b, "hello child 1");
 
       WriteMessage(a, "exit");
       WriteMessage(b, "exit");
     END_CHILD()
   END_CHILD()
 }
 
 // Reads and turns a pipe handle some number of times to create lots of
 // transient proxies.
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(PingPongPipeClient,
                                   MultiprocessMessagePipeTest, h) {
   const size_t kNumBounces = 50;
   MojoHandle p0, p1;
   ReadMessageWithHandles(h, &p0, 1);
   ReadMessageWithHandles(h, &p1, 1);
   for (size_t i = 0; i < kNumBounces; ++i) {
     WriteMessageWithHandles(h, "", &p1, 1);
     ReadMessageWithHandles(h, &p1, 1);
   }
   WriteMessageWithHandles(h, "", &p0, 1);
   WriteMessage(p1, "bye");
   MojoClose(p1);
   EXPECT_EQ("quit", ReadMessage(h));
 }
 
-TEST_F(MultiprocessMessagePipeTest, PingPongPipe) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, PingPongPipe) {
   MojoHandle p0, p1;
   CreateMessagePipe(&p0, &p1);
 
   RUN_CHILD_ON_PIPE(PingPongPipeClient, h)
     const size_t kNumBounces = 50;
     WriteMessageWithHandles(h, "", &p0, 1);
     WriteMessageWithHandles(h, "", &p1, 1);
     for (size_t i = 0; i < kNumBounces; ++i) {
       ReadMessageWithHandles(h, &p1, 1);
       WriteMessageWithHandles(h, "", &p1, 1);
@@ skipping 185 matching lines @@
       END_CHILD()
     END_CHILD()
   END_CHILD()
 }
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReceivePipeWithClosedPeer,
                                   MultiprocessMessagePipeTest, h) {
   MojoHandle p;
   EXPECT_EQ("foo", ReadMessageWithHandles(h, &p, 1));
 
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+  auto result = MojoWait(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                         MOJO_DEADLINE_INDEFINITE, nullptr);
+  EXPECT_EQ(MOJO_RESULT_OK, result);
 }
 
-TEST_F(MultiprocessMessagePipeTest, SendPipeThenClosePeer) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, SendPipeThenClosePeer) {
   RUN_CHILD_ON_PIPE(ReceivePipeWithClosedPeer, h)
     MojoHandle a, b;
     CreateMessagePipe(&a, &b);
 
     // Send |a| and immediately close |b|. The child should observe closure.
     WriteMessageWithHandles(h, "foo", &a, 1);
     MojoClose(b);
   END_CHILD()
 }
 
@@ skipping 55 matching lines @@
       EXPECT_EQ("c2a plz",
                 ReadMessageWithHandles(kid_a, &application_request, 1));
 
       WriteMessageWithHandles(kid_b, "c2a", &application_request, 1);
     END_CHILD()
 
     WriteMessage(kid_a, "quit");
   END_CHILD()
 }
 
-
-TEST_F(MultiprocessMessagePipeTest, SendClosePeerSend) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, SendClosePeerSend) {
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
 
   MojoHandle c, d;
   CreateMessagePipe(&c, &d);
 
   // Send |a| over |c|, immediately close |b|, then send |a| back over |d|.
   WriteMessageWithHandles(c, "foo", &a, 1);
   EXPECT_EQ("foo", ReadMessageWithHandles(d, &a, 1));
   WriteMessageWithHandles(d, "bar", &a, 1);
@@ skipping 22 matching lines @@
   // the parent, just for some extra proxying goodness.
   WriteMessageWithHandles(c, "foo", &pipe[1], 1);
   EXPECT_EQ("foo", ReadMessageWithHandles(d, &pipe[1], 1));
 
   // And finally pass it back to the parent.
   WriteMessageWithHandles(h, "bar", &pipe[1], 1);
 
   EXPECT_EQ("quit", ReadMessage(h));
 }
 
-TEST_F(MultiprocessMessagePipeTest, WriteCloseSendPeer) {
+TEST_P(MultiprocessMessagePipeTestWithPeerSupport, WriteCloseSendPeer) {
   MojoHandle pipe[2];
   CreateMessagePipe(&pipe[0], &pipe[1]);
 
   RUN_CHILD_ON_PIPE(WriteCloseSendPeerClient, h)
     // Pass the pipe to the child.
     WriteMessageWithHandles(h, "foo", pipe, 2);
 
     // Read back an endpoint which should have messages on it.
     MojoHandle p;
     EXPECT_EQ("bar", ReadMessageWithHandles(h, &p, 1));
@@ skipping 104 matching lines @@
       WriteMessage(child2, "bye");
     END_CHILD();
 
     WriteMessage(child1, "bye");
   END_CHILD()
 
   // The error messages should match the processes which triggered them.
   EXPECT_NE(std::string::npos, first_process_error.find(kFirstErrorMessage));
   EXPECT_NE(std::string::npos, second_process_error.find(kSecondErrorMessage));
 }
-
+INSTANTIATE_TEST_CASE_P(,
+                        MultiprocessMessagePipeTestWithPeerSupport,
+                        testing::Values(test::MojoTestBase::LaunchType::CHILD,
+                                        test::MojoTestBase::LaunchType::PEER));
 }  // namespace
 }  // namespace edk
 }  // namespace mojo