Mojo: Move waiting APIs to public library

mojo/edk/embedder/embedder_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 "mojo/edk/embedder/embedder.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
@@ skipping 17 matching lines @@
 #include "mojo/edk/embedder/named_platform_handle.h"
 #include "mojo/edk/embedder/named_platform_handle_utils.h"
 #include "mojo/edk/embedder/pending_process_connection.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/test_embedder.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/test/mojo_test_base.h"
 #include "mojo/public/c/system/core.h"
 #include "mojo/public/cpp/system/handle.h"
 #include "mojo/public/cpp/system/message_pipe.h"
+#include "mojo/public/cpp/system/wait.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace edk {
 namespace {
 
-const MojoHandleSignals kSignalReadadableWritable =
-    MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE;
-
-const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE |
-                                     MOJO_HANDLE_SIGNAL_WRITABLE |
-                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED;
-
 // The multiprocess tests that use these don't compile on iOS.
 #if !defined(OS_IOS)
 const char kHelloWorld[] = "hello world";
 const char kByeWorld[] = "bye world";
 #endif
 
 using EmbedderTest = test::MojoTestBase;
 
 TEST_F(EmbedderTest, ChannelBasic) {
   MojoHandle server_mp, client_mp;
   CreateMessagePipe(&server_mp, &client_mp);
 
   const std::string kHello = "hello";
 
   // We can write to a message pipe handle immediately.
   WriteMessage(server_mp, kHello);
   EXPECT_EQ(kHello, ReadMessage(client_mp));
 
   ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
   ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
 }
 
-// Test sending a MP which has read messages out of the OS pipe but which have
-// not been consumed using MojoReadMessage yet.
-TEST_F(EmbedderTest, SendReadableMessagePipe) {
-  MojoHandle server_mp, client_mp;
-  CreateMessagePipe(&server_mp, &client_mp);
-
-  MojoHandle server_mp2, client_mp2;
-  CreateMessagePipe(&server_mp2, &client_mp2);
-
-  // Write to server2 and wait for client2 to be readable before sending it.
-  // client2's MessagePipeDispatcher will have the message below in its
-  // message_queue_. For extra measures, also verify that this pending message
-  // can contain a message pipe.
-  MojoHandle server_mp3, client_mp3;
-  CreateMessagePipe(&server_mp3, &client_mp3);
-
-  const std::string kHello = "hello";
-  WriteMessageWithHandles(server_mp2, kHello, &client_mp3, 1);
-
-  MojoHandleSignalsState state;
-  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(client_mp2, MOJO_HANDLE_SIGNAL_READABLE,
-                                     MOJO_DEADLINE_INDEFINITE, &state));
-  ASSERT_EQ(kSignalReadadableWritable, state.satisfied_signals);
-  ASSERT_EQ(kSignalAll, state.satisfiable_signals);
-
-  // Now send client2
-  WriteMessageWithHandles(server_mp, kHello, &client_mp2, 1);
-
-  MojoHandle port;
-  std::string message = ReadMessageWithHandles(client_mp, &port, 1);
-  EXPECT_EQ(kHello, message);
-
-  client_mp2 = port;
-  message = ReadMessageWithHandles(client_mp2, &client_mp3, 1);
-  EXPECT_EQ(kHello, message);
-
-  ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp3));
-  ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp3));
-  ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp2));
-  ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp2));
-  ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
-  ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
-}
-
 // Verifies that a MP with pending messages to be written can be sent and the
 // pending messages aren't dropped.
 TEST_F(EmbedderTest, SendMessagePipeWithWriteQueue) {
   MojoHandle server_mp, client_mp;
   CreateMessagePipe(&server_mp, &client_mp);
 
   MojoHandle server_mp2, client_mp2;
   CreateMessagePipe(&server_mp2, &client_mp2);
 
   static const size_t kNumMessages = 1001;
@@ skipping 83 matching lines @@
   PendingProcessConnection process;
   std::string pipe_token;
   ScopedMessagePipeHandle parent_mp = process.CreateMessagePipe(&pipe_token);
   process.Connect(base::GetCurrentProcessHandle(),
                   ConnectionParams(pair.PassServerHandle()));
 
   // Close the remote end, simulating child death before the child connects to
   // the reserved port.
   ignore_result(pair.PassClientHandle());
 
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(parent_mp.get().value(),
-                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE,
-                                     nullptr));
+  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(parent_mp.get().value(),
+                                           MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 }
 
 TEST_F(EmbedderTest, PipeSetup_LaunchFailure) {
   PlatformChannelPair pair;
 
   auto process = base::MakeUnique<PendingProcessConnection>();
   std::string pipe_token;
   ScopedMessagePipeHandle parent_mp = process->CreateMessagePipe(&pipe_token);
 
   // Ensure that if a PendingProcessConnection goes away before Connect() is
   // called, any message pipes associated with it detect peer closure.
   process.reset();
 
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(parent_mp.get().value(),
-                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE,
-                                     nullptr));
+  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(parent_mp.get().value(),
+                                           MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 }
 
 // The sequence of messages sent is:
 //       server_mp   client_mp   mp0         mp1         mp2         mp3
 //   1.  "hello"
 //   2.              "world!"
 //   3.                          "FOO"
 //   4.  "Bar"+mp1
 //   5.  (close)
 //   6.              (close)
@@ skipping 34 matching lines @@
 
     // 8. Close |mp0|.
     ASSERT_EQ(MOJO_RESULT_OK, MojoClose(mp0));
 
     // 9. Tell the client to quit.
     WriteMessage(server_mp, "quit");
 
     // 10. Wait on |mp2| (which should eventually fail) and then close it.
     MojoHandleSignalsState state;
     ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE,
-                       &state));
+              WaitForSignals(mp2, MOJO_HANDLE_SIGNAL_READABLE, &state));
     ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
     ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);
 
     ASSERT_EQ(MOJO_RESULT_OK, MojoClose(mp2));
   END_CHILD()
 }
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MultiprocessChannelsClient, EmbedderTest,
                                   client_mp) {
   // 1. Read the first message from |client_mp|.
@@ skipping 21 matching lines @@
   mp2 = MOJO_HANDLE_INVALID;
 
   // 9. Read a message from |mp1|.
   EXPECT_EQ("FOO", ReadMessage(mp1));
 
   EXPECT_EQ("quit", ReadMessage(client_mp));
 
   // 10. Wait on |mp1| (which should eventually fail) and then close it.
   MojoHandleSignalsState state;
   ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
-                      MOJO_DEADLINE_INDEFINITE, &state));
+            WaitForSignals(mp1, MOJO_HANDLE_SIGNAL_READABLE, &state));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);
   ASSERT_EQ(MOJO_RESULT_OK, MojoClose(mp1));
 }
 
 TEST_F(EmbedderTest, MultiprocessBaseSharedMemory) {
   RUN_CHILD_ON_PIPE(MultiprocessSharedMemoryClient, server_mp)
     // 1. Create a base::SharedMemory object and create a mojo shared buffer
     // from it.
     base::SharedMemoryCreateOptions options;
@@ skipping 228 matching lines @@
   *output = CreateClientHandle(named_handle);
 }
 
 TEST_F(EmbedderTest, ClosePendingPeerConnection) {
   NamedPlatformHandle named_handle = GenerateChannelName();
   std::string peer_token = GenerateRandomToken();
   ScopedMessagePipeHandle server_pipe =
       ConnectToPeerProcess(CreateServerHandle(named_handle), peer_token);
   ClosePeerConnection(peer_token);
   EXPECT_EQ(MOJO_RESULT_OK,
-            Wait(server_pipe.get(), MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                 MOJO_DEADLINE_INDEFINITE, nullptr));
+            Wait(server_pipe.get(), MOJO_HANDLE_SIGNAL_PEER_CLOSED));
   base::MessageLoop message_loop;
   base::RunLoop run_loop;
   ScopedPlatformHandle client_handle;
   // Closing the channel involves posting a task to the IO thread to do the
   // work. By the time the local message pipe has been observerd as closed,
   // that task will have been posted. Therefore, a task to create the client
   // connection should be handled after the channel is closed.
   GetIOTaskRunner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&CreateClientHandleOnIoThread, named_handle, &client_handle),
       run_loop.QuitClosure());
   run_loop.Run();
   EXPECT_FALSE(client_handle.is_valid());
 }
 
 #if !defined(OS_IOS)
 
 TEST_F(EmbedderTest, ClosePipeToConnectedPeer) {
   set_launch_type(LaunchType::PEER);
   auto& controller = StartClient("ClosePipeToConnectedPeerClient");
   MojoHandle server_mp = controller.pipe();
   // 1. Write a message to |server_mp| (attaching nothing).
   WriteMessage(server_mp, "hello");
 
   // 2. Read a message from |server_mp|.
   EXPECT_EQ("world!", ReadMessage(server_mp));
 
   controller.ClosePeerConnection();
 
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(server_mp, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            WaitForSignals(server_mp, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 
   EXPECT_EQ(0, controller.WaitForShutdown());
 }
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ClosePipeToConnectedPeerClient, EmbedderTest,
                                   client_mp) {
   // 1. Read the first message from |client_mp|.
   EXPECT_EQ("hello", ReadMessage(client_mp));
 
   // 2. Write a message to |client_mp| (attaching nothing).
   WriteMessage(client_mp, "world!");
 
   ASSERT_EQ(MOJO_RESULT_OK,
-            MojoWait(client_mp, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                      MOJO_DEADLINE_INDEFINITE, nullptr));
+            WaitForSignals(client_mp, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 }
 
 TEST_F(EmbedderTest, ClosePipeToConnectingPeer) {
   set_launch_type(LaunchType::PEER);
   auto& controller = StartClient("ClosePipeToConnectingPeerClient");
   controller.ClosePeerConnection();
 
   MojoHandle server_mp = controller.pipe();
 
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(server_mp, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            WaitForSignals(server_mp, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 
   EXPECT_EQ(0, controller.WaitForShutdown());
 }
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ClosePipeToConnectingPeerClient, EmbedderTest,
                                   client_mp) {
-  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            WaitForSignals(client_mp, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 }
 
 #endif  // !defined(OS_IOS)
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo