| Index: mojo/edk/embedder/embedder_unittest.cc
|
| diff --git a/mojo/edk/embedder/embedder_unittest.cc b/mojo/edk/embedder/embedder_unittest.cc
|
| index b138a2d67d6cf21284c88739db6463b7fd98b773..03937489025e2008975704fcc27b0c9089c5a7a7 100644
|
| --- a/mojo/edk/embedder/embedder_unittest.cc
|
| +++ b/mojo/edk/embedder/embedder_unittest.cc
|
| @@ -24,6 +24,13 @@ namespace mojo {
|
| namespace embedder {
|
| 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;
|
| +
|
| class ScopedTestChannel {
|
| public:
|
| // Creates a channel that lives on a given I/O thread (determined by the given
|
| @@ -123,8 +130,12 @@ TEST_F(EmbedderTest, ChannelsBasic) {
|
| 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
|
|
|
| // Now wait for the other side to become readable.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + MojoHandleSignalsState state;
|
| + EXPECT_EQ(MOJO_RESULT_OK,
|
| + MojoNewWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
|
|
| char buffer[1000] = {};
|
| uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
|
| @@ -188,8 +199,12 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
|
| nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
|
|
|
| // Wait for |client_mp| to become readable.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + MojoHandleSignalsState state;
|
| + EXPECT_EQ(MOJO_RESULT_OK,
|
| + MojoNewWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
|
|
| // Read a message from |client_mp|.
|
| char buffer[1000] = {};
|
| @@ -206,8 +221,10 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
|
| h1 = handles[0];
|
|
|
| // Wait for |h1| to become readable.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
|
|
| // Read a message from |h1|.
|
| memset(buffer, 0, sizeof(buffer));
|
| @@ -222,8 +239,10 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
|
| EXPECT_EQ(0u, num_handles);
|
|
|
| // Wait for |h1| to become readable (again).
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
|
|
| // Read the second message from |h1|.
|
| memset(buffer, 0, sizeof(buffer));
|
| @@ -242,8 +261,10 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
|
| nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
|
|
|
| // Wait for |h0| to become readable.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(h0, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
|
|
| // Read a message from |h0|.
|
| memset(buffer, 0, sizeof(buffer));
|
| @@ -282,6 +303,7 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
|
| // 10. (close)
|
| // 11. (wait/cl.)
|
| // 12. (wait/cl.)
|
| +
|
| #if defined(OS_ANDROID)
|
| // Android multi-process tests are not executing the new process. This is flaky.
|
| #define MAYBE_MultiprocessChannels DISABLED_MultiprocessChannels
|
| @@ -313,8 +335,13 @@ TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) {
|
| // |server_mp|), we die with a fatal error in |Channel::HandleLocalError()|.
|
|
|
| // 2. Read a message from |server_mp|.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(server_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + MojoHandleSignalsState state;
|
| + EXPECT_EQ(MOJO_RESULT_OK,
|
| + MojoNewWait(server_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
| +
|
| char buffer[1000] = {};
|
| uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
|
| EXPECT_EQ(MOJO_RESULT_OK,
|
| @@ -346,8 +373,11 @@ TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) {
|
| EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
|
|
|
| // 9. Read a message from |mp0|, which should have |mp2| attached.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp0, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(mp0, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
| +
|
| memset(buffer, 0, sizeof(buffer));
|
| num_bytes = static_cast<uint32_t>(sizeof(buffer));
|
| MojoHandle mp2 = MOJO_HANDLE_INVALID;
|
| @@ -362,8 +392,13 @@ TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) {
|
| EXPECT_NE(mp2, MOJO_HANDLE_INVALID);
|
|
|
| // 7. Read a message from |mp2|.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
|
| + state.satisfied_signals);
|
| + EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
|
| + state.satisfiable_signals);
|
| +
|
| memset(buffer, 0, sizeof(buffer));
|
| num_bytes = static_cast<uint32_t>(sizeof(buffer));
|
| EXPECT_EQ(MOJO_RESULT_OK,
|
| @@ -380,8 +415,11 @@ TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) {
|
| // TODO(vtl): crbug.com/351768
|
| #if 0
|
| EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
|
| - MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + MojoNewWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE,
|
| + &state));
|
| + EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfied_signals);
|
| + EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfiable_signals);
|
| #endif
|
| EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp2));
|
| }
|
| @@ -407,8 +445,13 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
|
| CHECK(client_channel.channel_info() != nullptr);
|
|
|
| // 1. Read the first message from |client_mp|.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + MojoHandleSignalsState state;
|
| + EXPECT_EQ(MOJO_RESULT_OK,
|
| + MojoNewWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
| +
|
| char buffer[1000] = {};
|
| uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
|
| EXPECT_EQ(MOJO_RESULT_OK,
|
| @@ -426,8 +469,15 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
|
| 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
|
|
|
| // 4. Read a message from |client_mp|, which should have |mp1| attached.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + EXPECT_EQ(MOJO_RESULT_OK,
|
| + MojoNewWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + // The other end of the handle may or may not be closed at this point, so we
|
| + // can't test MOJO_HANDLE_SIGNAL_WRITABLE or MOJO_HANDLE_SIGNAL_PEER_CLOSED.
|
| + EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE,
|
| + state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE);
|
| + EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE,
|
| + state.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE);
|
| // TODO(vtl): If the scope were to end here (and |client_mp| closed), we'd
|
| // die (again due to |Channel::HandleLocalError()|).
|
| memset(buffer, 0, sizeof(buffer));
|
| @@ -470,8 +520,11 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
|
| mp2 = MOJO_HANDLE_INVALID;
|
|
|
| // 3. Read a message from |mp1|.
|
| - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
|
| - MOJO_DEADLINE_INDEFINITE));
|
| + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
|
| + EXPECT_EQ(kSignalAll, state.satisfiable_signals);
|
| +
|
| memset(buffer, 0, sizeof(buffer));
|
| num_bytes = static_cast<uint32_t>(sizeof(buffer));
|
| EXPECT_EQ(MOJO_RESULT_OK,
|
| @@ -482,9 +535,11 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
|
| EXPECT_STREQ(kFoo, buffer);
|
|
|
| // 11. Wait on |mp1| (which should eventually fail) and then close it.
|
| - EXPECT_EQ(
|
| - MOJO_RESULT_FAILED_PRECONDITION,
|
| - MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
|
| + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
|
| + MojoNewWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
|
| + MOJO_DEADLINE_INDEFINITE, &state));
|
| + EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
|
| + EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);
|
| EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp1));
|
| }
|
|
|
|
|