Update mojo sdk to rev f6c8ec07c01deebc13178d516225fd12695c3dc2

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 <string.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_io_thread.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/multiprocess_test_helper.h"
 #include "mojo/public/c/system/core.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 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
   // |TaskRunner|) attached to the given |platform_handle|. After construction,
   // |bootstrap_message_pipe()| gives the Mojo handle for the bootstrap message
   // pipe on this channel; it is up to the caller to close this handle.
   // Note: The I/O thread must outlive this object (and its message loop must
   // continue pumping messages while this object is alive).
   ScopedTestChannel(scoped_refptr<base::TaskRunner> io_thread_task_runner,
                     ScopedPlatformHandle platform_handle)
@@ skipping 79 matching lines @@
     EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
 
     // We can write to a message pipe handle immediately.
     const char kHello[] = "hello";
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(server_mp, kHello,
                                static_cast<uint32_t>(sizeof(kHello)), nullptr,
                                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));
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoReadMessage(client_mp, buffer, &num_bytes, nullptr, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(sizeof(kHello), num_bytes);
     EXPECT_STREQ(kHello, buffer);
 
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
@@ skipping 43 matching lines @@
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
     h1 = MOJO_HANDLE_INVALID;
 
     // Write another message to |h0|.
     const char kFoo[] = "foo";
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h0, kFoo, static_cast<uint32_t>(sizeof(kFoo)),
                                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] = {};
     uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
     MojoHandle handles[10] = {};
     uint32_t num_handles = arraysize(handles);
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoReadMessage(client_mp, buffer, &num_bytes, handles,
                               &num_handles, MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(sizeof(kWorld), num_bytes);
     EXPECT_STREQ(kWorld, buffer);
     EXPECT_EQ(1u, num_handles);
     EXPECT_NE(handles[0], MOJO_HANDLE_INVALID);
     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));
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
     memset(handles, 0, sizeof(handles));
     num_handles = arraysize(handles);
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoReadMessage(h1, buffer, &num_bytes, handles, &num_handles,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(sizeof(kHello), num_bytes);
     EXPECT_STREQ(kHello, buffer);
     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));
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoReadMessage(h1, buffer, &num_bytes, nullptr, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(sizeof(kFoo), num_bytes);
     EXPECT_STREQ(kFoo, buffer);
 
     // Write a message to |h1|.
     const char kBarBaz[] = "barbaz";
     EXPECT_EQ(
         MOJO_RESULT_OK,
         MojoWriteMessage(h1, kBarBaz, static_cast<uint32_t>(sizeof(kBarBaz)),
                          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));
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoReadMessage(h0, buffer, &num_bytes, nullptr, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(sizeof(kBarBaz), num_bytes);
     EXPECT_STREQ(kBarBaz, buffer);
 
@@ skipping 18 matching lines @@
 //   3.                          "FOO"
 //   4.  "Bar"+mp1
 //   5.  (close)
 //   6.              (close)
 //   7.                                                              "baz"
 //   8.                                                              (closed)
 //   9.                                      "quux"+mp2
 //  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
 #else
 #define MAYBE_MultiprocessChannels MultiprocessChannels
 #endif  // defined(OS_ANDROID)
 TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) {
   mojo::embedder::test::InitWithSimplePlatformSupport();
   mojo::test::MultiprocessTestHelper multiprocess_test_helper;
   multiprocess_test_helper.StartChild("MultiprocessChannelsClient");
@@ skipping 11 matching lines @@
     const char kHello[] = "hello";
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(server_mp, kHello,
                                static_cast<uint32_t>(sizeof(kHello)), nullptr,
                                0, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // TODO(vtl): If the scope were ended immediately here (maybe after closing
     // |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,
               MojoReadMessage(server_mp, buffer, &num_bytes, nullptr, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     const char kWorld[] = "world!";
     EXPECT_EQ(sizeof(kWorld), num_bytes);
     EXPECT_STREQ(kWorld, buffer);
 
     // Create a new message pipe (endpoints |mp0| and |mp1|).
@@ skipping 11 matching lines @@
     EXPECT_EQ(
         MOJO_RESULT_OK,
         MojoWriteMessage(server_mp, kBar, static_cast<uint32_t>(sizeof(kBar)),
                          &mp1, 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
     mp1 = MOJO_HANDLE_INVALID;
 
     // 5. Close |server_mp|.
     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;
     uint32_t num_handles = 1;
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoReadMessage(mp0, buffer, &num_bytes, &mp2, &num_handles,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     const char kQuux[] = "quux";
     EXPECT_EQ(sizeof(kQuux), num_bytes);
     EXPECT_STREQ(kQuux, buffer);
     EXPECT_EQ(1u, num_handles);
     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,
               MojoReadMessage(mp2, buffer, &num_bytes, nullptr, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     const char kBaz[] = "baz";
     EXPECT_EQ(sizeof(kBaz), num_bytes);
     EXPECT_STREQ(kBaz, buffer);
 
     // 10. Close |mp0|.
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp0));
 
 // 12. Wait on |mp2| (which should eventually fail) and then close it.
 // 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));
   }
 
   EXPECT_TRUE(multiprocess_test_helper.WaitForChildTestShutdown());
   EXPECT_TRUE(test::Shutdown());
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
   ScopedPlatformHandle client_platform_handle =
       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
   EXPECT_TRUE(client_platform_handle.is_valid());
 
   base::TestIOThread test_io_thread(base::TestIOThread::kAutoStart);
   mojo::embedder::test::InitWithSimplePlatformSupport();
 
   {
     ScopedTestChannel client_channel(test_io_thread.task_runner(),
                                      client_platform_handle.Pass());
     MojoHandle client_mp = client_channel.bootstrap_message_pipe();
     EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
     client_channel.WaitForChannelCreationCompletion();
     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,
               MojoReadMessage(client_mp, buffer, &num_bytes, nullptr, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     const char kHello[] = "hello";
     EXPECT_EQ(sizeof(kHello), num_bytes);
     EXPECT_STREQ(kHello, buffer);
 
     // 2. Write a message to |client_mp| (attaching nothing).
     const char kWorld[] = "world!";
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(client_mp, kWorld,
                                static_cast<uint32_t>(sizeof(kWorld)), nullptr,
                                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));
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
     MojoHandle mp1 = MOJO_HANDLE_INVALID;
     uint32_t num_handles = 1;
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoReadMessage(client_mp, buffer, &num_bytes, &mp1, &num_handles,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     const char kBar[] = "Bar";
@@ skipping 22 matching lines @@
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp3));
 
     // 9. Write a message to |mp1|, attaching |mp2|.
     const char kQuux[] = "quux";
     EXPECT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(mp1, kQuux, static_cast<uint32_t>(sizeof(kQuux)),
                                &mp2, 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
     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,
               MojoReadMessage(mp1, buffer, &num_bytes, nullptr, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     const char kFoo[] = "FOO";
     EXPECT_EQ(sizeof(kFoo), num_bytes);
     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));
   }
 
   EXPECT_TRUE(test::Shutdown());
 }
 
 // TODO(vtl): Test immediate write & close.
 // TODO(vtl): Test broken-connection cases.
 
 }  // namespace
 }  // namespace embedder
 }  // namespace mojo