Move //mojo/{public, edk} underneath //third_party

This CL move //mojo/public and //mojo/edk to live in the following locations:
- //third_party/mojo/src/mojo/public
- //third_party/mojo/src/mojo/edk

It moves the related gypfiles from //mojo to //third_party/mojo and updates
them as necessary to account for the file moves. It also updates clients of the
mojo SDK and EDK targets in both GYP and GN. (Note that for GN, the mojo SDK
and EDK build systems are maintained in the Mojo repo and designed to be
flexible wrt the location of the SDK/EDK in a client repo, so no changes are
needed.

This CL does not update include paths to the code being moved to limit the
number of moving parts, instead relying on the include_dirs that the SDK and
EDK targets supply to their direct dependents to ensure that include paths
continue to resolve correctly.

NOPRESUBMIT=true

Review URL: https://codereview.chromium.org/814543006

Cr-Commit-Position: refs/heads/master@{#312129}

1 files changed, 0 insertions, 639 deletions

diff --git a/mojo/edk/embedder/embedder_unittest.cc b/mojo/edk/embedder/embedder_unittest.cc
deleted file mode 100644
index ed4ea2e..0000000
--- a/mojo/edk/embedder/embedder_unittest.cc
+++ /dev/null
@@ -1,639 +0,0 @@
-// 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 "base/test/test_timeouts.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)
-      : io_thread_task_runner_(io_thread_task_runner),
-        bootstrap_message_pipe_(MOJO_HANDLE_INVALID),
-        did_create_channel_event_(true, false),
-        channel_info_(nullptr) {
-    bootstrap_message_pipe_ =
-        CreateChannel(platform_handle.Pass(), io_thread_task_runner_,
-                      base::Bind(&ScopedTestChannel::DidCreateChannel,
-                                 base::Unretained(this)),
-                      nullptr)
-            .release()
-            .value();
-    CHECK_NE(bootstrap_message_pipe_, MOJO_HANDLE_INVALID);
-  }
-
-  // Destructor: Shuts down the channel. (As noted above, for this to happen,
-  // the I/O thread must be alive and pumping messages.)
-  ~ScopedTestChannel() { DestroyChannel(channel_info_); }
-
-  // Waits for channel creation to be completed.
-  void WaitForChannelCreationCompletion() { did_create_channel_event_.Wait(); }
-
-  MojoHandle bootstrap_message_pipe() const { return bootstrap_message_pipe_; }
-
-  // Call only after |WaitForChannelCreationCompletion()|. Use only to check
-  // that it's not null.
-  const ChannelInfo* channel_info() const { return channel_info_; }
-
- private:
-  void DidCreateChannel(ChannelInfo* channel_info) {
-    CHECK(channel_info);
-    CHECK(!channel_info_);
-    channel_info_ = channel_info;
-    did_create_channel_event_.Signal();
-  }
-
-  scoped_refptr<base::TaskRunner> io_thread_task_runner_;
-
-  // Valid from creation until whenever it gets closed (by the "owner" of this
-  // object).
-  // Note: We don't want use the C++ wrappers here, since we want to test the
-  // API at the lowest level.
-  MojoHandle bootstrap_message_pipe_;
-
-  // Set after channel creation has been completed (i.e., the callback to
-  // |CreateChannel()| has been called).
-  base::WaitableEvent did_create_channel_event_;
-
-  // Valid after channel creation completion until destruction.
-  ChannelInfo* channel_info_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedTestChannel);
-};
-
-class EmbedderTest : public testing::Test {
- public:
-  EmbedderTest() : test_io_thread_(base::TestIOThread::kAutoStart) {}
-  ~EmbedderTest() override {}
-
- protected:
-  base::TestIOThread* test_io_thread() { return &test_io_thread_; }
-
- private:
-  base::TestIOThread test_io_thread_;
-
-  DISALLOW_COPY_AND_ASSIGN(EmbedderTest);
-};
-
-TEST_F(EmbedderTest, ChannelsBasic) {
-  mojo::embedder::test::InitWithSimplePlatformSupport();
-
-  {
-    PlatformChannelPair channel_pair;
-    ScopedTestChannel server_channel(test_io_thread()->task_runner(),
-                                     channel_pair.PassServerHandle());
-    MojoHandle server_mp = server_channel.bootstrap_message_pipe();
-    EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
-    ScopedTestChannel client_channel(test_io_thread()->task_runner(),
-                                     channel_pair.PassClientHandle());
-    MojoHandle client_mp = client_channel.bootstrap_message_pipe();
-    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.
-    MojoHandleSignalsState state;
-    EXPECT_EQ(MOJO_RESULT_OK, MojoWait(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));
-    EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
-
-    // By this point, these waits should basically be no-ops (since we've waited
-    // for the client message pipe to become readable, which implies that both
-    // the server and client channels were completely created).
-    server_channel.WaitForChannelCreationCompletion();
-    client_channel.WaitForChannelCreationCompletion();
-    EXPECT_TRUE(server_channel.channel_info());
-    EXPECT_TRUE(client_channel.channel_info());
-  }
-
-  EXPECT_TRUE(test::Shutdown());
-}
-
-class TestAsyncWaiter {
- public:
-  TestAsyncWaiter() : event_(true, false), wait_result_(MOJO_RESULT_UNKNOWN) {}
-
-  void Awake(MojoResult result) {
-    base::AutoLock l(wait_result_lock_);
-    wait_result_ = result;
-    event_.Signal();
-  }
-
-  bool TryWait() { return event_.TimedWait(TestTimeouts::action_timeout()); }
-
-  MojoResult wait_result() const {
-    base::AutoLock l(wait_result_lock_);
-    return wait_result_;
-  }
-
- private:
-  base::WaitableEvent event_;
-
-  mutable base::Lock wait_result_lock_;
-  MojoResult wait_result_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestAsyncWaiter);
-};
-
-void WriteHello(MessagePipeHandle pipe) {
-  static const char kHello[] = "hello";
-  CHECK_EQ(MOJO_RESULT_OK,
-           WriteMessageRaw(pipe, kHello, static_cast<uint32_t>(sizeof(kHello)),
-                           nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-}
-
-void CloseScopedHandle(ScopedMessagePipeHandle handle) {
-  // Do nothing and the destructor will close it.
-}
-
-TEST_F(EmbedderTest, AsyncWait) {
-  mojo::embedder::test::InitWithSimplePlatformSupport();
-
-  {
-    ScopedMessagePipeHandle client_mp;
-    ScopedMessagePipeHandle server_mp;
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mojo::CreateMessagePipe(nullptr, &client_mp, &server_mp));
-
-    TestAsyncWaiter waiter;
-    EXPECT_EQ(MOJO_RESULT_OK,
-              AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
-                        base::Bind(&TestAsyncWaiter::Awake,
-                                   base::Unretained(&waiter))));
-
-    test_io_thread()->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&WriteHello, server_mp.get()));
-    EXPECT_TRUE(waiter.TryWait());
-    EXPECT_EQ(MOJO_RESULT_OK, waiter.wait_result());
-
-    // If message is in the queue, it does't allow us to wait.
-    TestAsyncWaiter waiter_that_doesnt_wait;
-    EXPECT_EQ(
-        MOJO_RESULT_ALREADY_EXISTS,
-        AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
-                  base::Bind(&TestAsyncWaiter::Awake,
-                             base::Unretained(&waiter_that_doesnt_wait))));
-
-    char buffer[1000];
-    uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
-    CHECK_EQ(MOJO_RESULT_OK,
-             ReadMessageRaw(client_mp.get(), buffer, &num_bytes, nullptr,
-                            nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
-
-    TestAsyncWaiter unsatisfiable_waiter;
-    EXPECT_EQ(MOJO_RESULT_OK,
-              AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
-                        base::Bind(&TestAsyncWaiter::Awake,
-                                   base::Unretained(&unsatisfiable_waiter))));
-
-    test_io_thread()->task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&CloseScopedHandle, base::Passed(server_mp.Pass())));
-
-    EXPECT_TRUE(unsatisfiable_waiter.TryWait());
-    EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              unsatisfiable_waiter.wait_result());
-  }
-
-  EXPECT_TRUE(test::Shutdown());
-}
-
-TEST_F(EmbedderTest, ChannelsHandlePassing) {
-  mojo::embedder::test::InitWithSimplePlatformSupport();
-
-  {
-    PlatformChannelPair channel_pair;
-    ScopedTestChannel server_channel(test_io_thread()->task_runner(),
-                                     channel_pair.PassServerHandle());
-    MojoHandle server_mp = server_channel.bootstrap_message_pipe();
-    EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
-    ScopedTestChannel client_channel(test_io_thread()->task_runner(),
-                                     channel_pair.PassClientHandle());
-    MojoHandle client_mp = client_channel.bootstrap_message_pipe();
-    EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
-
-    MojoHandle h0, h1;
-    EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1));
-
-    // Write a message to |h0| (attaching nothing).
-    const char kHello[] = "hello";
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        MojoWriteMessage(h0, kHello, static_cast<uint32_t>(sizeof(kHello)),
-                         nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-    // Write one message to |server_mp|, attaching |h1|.
-    const char kWorld[] = "world!!!";
-    EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWriteMessage(server_mp, kWorld,
-                               static_cast<uint32_t>(sizeof(kWorld)), &h1, 1,
-                               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.
-    MojoHandleSignalsState state;
-    EXPECT_EQ(MOJO_RESULT_OK, MojoWait(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, &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, &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, &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);
-
-    EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
-    EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
-    EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0));
-    EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1));
-
-    server_channel.WaitForChannelCreationCompletion();
-    client_channel.WaitForChannelCreationCompletion();
-    EXPECT_TRUE(server_channel.channel_info());
-    EXPECT_TRUE(client_channel.channel_info());
-  }
-
-  EXPECT_TRUE(test::Shutdown());
-}
-
-// 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)
-//   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");
-
-  {
-    ScopedTestChannel server_channel(
-        test_io_thread()->task_runner(),
-        multiprocess_test_helper.server_platform_handle.Pass());
-    MojoHandle server_mp = server_channel.bootstrap_message_pipe();
-    EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
-    server_channel.WaitForChannelCreationCompletion();
-    EXPECT_TRUE(server_channel.channel_info());
-
-    // 1. Write a message to |server_mp| (attaching nothing).
-    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|.
-    MojoHandleSignalsState state;
-    EXPECT_EQ(MOJO_RESULT_OK, MojoWait(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|).
-    MojoHandle mp0, mp1;
-    EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &mp0, &mp1));
-
-    // 3. Write something to |mp0|.
-    const char kFoo[] = "FOO";
-    EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWriteMessage(mp0, kFoo, static_cast<uint32_t>(sizeof(kFoo)),
-                               nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-    // 4. Write a message to |server_mp|, attaching |mp1|.
-    const char kBar[] = "Bar";
-    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, &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, &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,
-                       &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|.
-    MojoHandleSignalsState state;
-    EXPECT_EQ(MOJO_RESULT_OK, MojoWait(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, &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";
-    EXPECT_EQ(sizeof(kBar), num_bytes);
-    EXPECT_STREQ(kBar, buffer);
-    EXPECT_EQ(1u, num_handles);
-    EXPECT_NE(mp1, MOJO_HANDLE_INVALID);
-    // TODO(vtl): If the scope were to end here (and the two handles closed),
-    // we'd die due to |Channel::RunRemoteMessagePipeEndpoint()| not handling
-    // write errors (assuming the parent had closed the pipe).
-
-    // 6. Close |client_mp|.
-    EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
-
-    // Create a new message pipe (endpoints |mp2| and |mp3|).
-    MojoHandle mp2, mp3;
-    EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &mp2, &mp3));
-
-    // 7. Write a message to |mp3|.
-    const char kBaz[] = "baz";
-    EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWriteMessage(mp3, kBaz, static_cast<uint32_t>(sizeof(kBaz)),
-                               nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-    // 8. Close |mp3|.
-    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, &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, &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