src/mojo/embedder/embedder_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/embedder/embedder.h"
   6
   7 #include <string.h>
   8
   9 #include "base/bind.h"
  10 #include "base/location.h"
  11 #include "base/logging.h"
  12 #include "base/macros.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/synchronization/waitable_event.h"
  15 #include "base/test/test_io_thread.h"
  16 #include "mojo/common/test/multiprocess_test_helper.h"
  17 #include "mojo/embedder/platform_channel_pair.h"
  18 #include "mojo/embedder/test_embedder.h"
  19 #include "mojo/public/c/system/core.h"
  20 #include "mojo/system/test_utils.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 namespace mojo {
  24 namespace embedder {
  25 namespace {
  26
  27 class ScopedTestChannel {
  28  public:
  29   // Creates a channel that lives on a given I/O thread (determined by the given
  30   // |TaskRunner|) attached to the given |platform_handle|. After construction,
  31   // |bootstrap_message_pipe()| gives the Mojo handle for the bootstrap message
  32   // pipe on this channel; it is up to the caller to close this handle.
  33   // Note: The I/O thread must outlive this object (and its message loop must
  34   // continue pumping messages while this object is alive).
  35   ScopedTestChannel(scoped_refptr<base::TaskRunner> io_thread_task_runner,
  36                     ScopedPlatformHandle platform_handle)
  37       : io_thread_task_runner_(io_thread_task_runner),
  38         bootstrap_message_pipe_(MOJO_HANDLE_INVALID),
  39         did_create_channel_event_(true, false),
  40         channel_info_(nullptr) {
  41     bootstrap_message_pipe_ =
  42         CreateChannel(platform_handle.Pass(),
  43                       io_thread_task_runner_,
  44                       base::Bind(&ScopedTestChannel::DidCreateChannel,
  45                                  base::Unretained(this)),
  46                       nullptr)
  47             .release()
  48             .value();
  49     CHECK_NE(bootstrap_message_pipe_, MOJO_HANDLE_INVALID);
  50   }
  51
  52   // Destructor: Shuts down the channel. (As noted above, for this to happen,
  53   // the I/O thread must be alive and pumping messages.)
  54   ~ScopedTestChannel() {
  55     system::test::PostTaskAndWait(
  56         io_thread_task_runner_,
  57         FROM_HERE,
  58         base::Bind(&ScopedTestChannel::DestroyChannel, base::Unretained(this)));
  59   }
  60
  61   // Waits for channel creation to be completed.
  62   void WaitForChannelCreationCompletion() { did_create_channel_event_.Wait(); }
  63
  64   MojoHandle bootstrap_message_pipe() const { return bootstrap_message_pipe_; }
  65
  66   // Call only after |WaitForChannelCreationCompletion()|. Use only to check
  67   // that it's not null.
  68   const ChannelInfo* channel_info() const { return channel_info_; }
  69
  70  private:
  71   void DidCreateChannel(ChannelInfo* channel_info) {
  72     CHECK(channel_info);
  73     CHECK(!channel_info_);
  74     channel_info_ = channel_info;
  75     did_create_channel_event_.Signal();
  76   }
  77
  78   void DestroyChannel() {
  79     CHECK(channel_info_);
  80     DestroyChannelOnIOThread(channel_info_);
  81     channel_info_ = nullptr;
  82   }
  83
  84   scoped_refptr<base::TaskRunner> io_thread_task_runner_;
  85
  86   // Valid from creation until whenever it gets closed (by the "owner" of this
  87   // object).
  88   // Note: We don't want use the C++ wrappers here, since we want to test the
  89   // API at the lowest level.
  90   MojoHandle bootstrap_message_pipe_;
  91
  92   // Set after channel creation has been completed (i.e., the callback to
  93   // |CreateChannel()| has been called).
  94   base::WaitableEvent did_create_channel_event_;
  95
  96   // Valid after channel creation completion until destruction.
  97   ChannelInfo* channel_info_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(ScopedTestChannel);
 100 };
 101
 102 class EmbedderTest : public testing::Test {
 103  public:
 104   EmbedderTest() : test_io_thread_(base::TestIOThread::kAutoStart) {}
 105   virtual ~EmbedderTest() {}
 106
 107  protected:
 108   base::TestIOThread* test_io_thread() { return &test_io_thread_; }
 109
 110  private:
 111   base::TestIOThread test_io_thread_;
 112
 113   DISALLOW_COPY_AND_ASSIGN(EmbedderTest);
 114 };
 115
 116 TEST_F(EmbedderTest, ChannelsBasic) {
 117   mojo::embedder::test::InitWithSimplePlatformSupport();
 118
 119   {
 120     PlatformChannelPair channel_pair;
 121     ScopedTestChannel server_channel(test_io_thread()->task_runner(),
 122                                      channel_pair.PassServerHandle());
 123     MojoHandle server_mp = server_channel.bootstrap_message_pipe();
 124     EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
 125     ScopedTestChannel client_channel(test_io_thread()->task_runner(),
 126                                      channel_pair.PassClientHandle());
 127     MojoHandle client_mp = client_channel.bootstrap_message_pipe();
 128     EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
 129
 130     // We can write to a message pipe handle immediately.
 131     const char kHello[] = "hello";
 132     EXPECT_EQ(MOJO_RESULT_OK,
 133               MojoWriteMessage(server_mp,
 134                                kHello,
 135                                static_cast<uint32_t>(sizeof(kHello)),
 136                                nullptr,
 137                                0,
 138                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 139
 140     // Now wait for the other side to become readable.
 141     EXPECT_EQ(
 142         MOJO_RESULT_OK,
 143         MojoWait(
 144             client_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 145
 146     char buffer[1000] = {};
 147     uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
 148     EXPECT_EQ(MOJO_RESULT_OK,
 149               MojoReadMessage(client_mp,
 150                               buffer,
 151                               &num_bytes,
 152                               nullptr,
 153                               nullptr,
 154                               MOJO_READ_MESSAGE_FLAG_NONE));
 155     EXPECT_EQ(sizeof(kHello), num_bytes);
 156     EXPECT_STREQ(kHello, buffer);
 157
 158     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
 159     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
 160
 161     // By this point, these waits should basically be no-ops (since we've waited
 162     // for the client message pipe to become readable, which implies that both
 163     // the server and client channels were completely created).
 164     server_channel.WaitForChannelCreationCompletion();
 165     client_channel.WaitForChannelCreationCompletion();
 166     EXPECT_TRUE(server_channel.channel_info());
 167     EXPECT_TRUE(client_channel.channel_info());
 168   }
 169
 170   EXPECT_TRUE(test::Shutdown());
 171 }
 172
 173 TEST_F(EmbedderTest, ChannelsHandlePassing) {
 174   mojo::embedder::test::InitWithSimplePlatformSupport();
 175
 176   {
 177     PlatformChannelPair channel_pair;
 178     ScopedTestChannel server_channel(test_io_thread()->task_runner(),
 179                                      channel_pair.PassServerHandle());
 180     MojoHandle server_mp = server_channel.bootstrap_message_pipe();
 181     EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
 182     ScopedTestChannel client_channel(test_io_thread()->task_runner(),
 183                                      channel_pair.PassClientHandle());
 184     MojoHandle client_mp = client_channel.bootstrap_message_pipe();
 185     EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
 186
 187     MojoHandle h0, h1;
 188     EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1));
 189
 190     // Write a message to |h0| (attaching nothing).
 191     const char kHello[] = "hello";
 192     EXPECT_EQ(MOJO_RESULT_OK,
 193               MojoWriteMessage(h0,
 194                                kHello,
 195                                static_cast<uint32_t>(sizeof(kHello)),
 196                                nullptr,
 197                                0,
 198                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 199
 200     // Write one message to |server_mp|, attaching |h1|.
 201     const char kWorld[] = "world!!!";
 202     EXPECT_EQ(MOJO_RESULT_OK,
 203               MojoWriteMessage(server_mp,
 204                                kWorld,
 205                                static_cast<uint32_t>(sizeof(kWorld)),
 206                                &h1,
 207                                1,
 208                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 209     h1 = MOJO_HANDLE_INVALID;
 210
 211     // Write another message to |h0|.
 212     const char kFoo[] = "foo";
 213     EXPECT_EQ(MOJO_RESULT_OK,
 214               MojoWriteMessage(h0,
 215                                kFoo,
 216                                static_cast<uint32_t>(sizeof(kFoo)),
 217                                nullptr,
 218                                0,
 219                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 220
 221     // Wait for |client_mp| to become readable.
 222     EXPECT_EQ(
 223         MOJO_RESULT_OK,
 224         MojoWait(
 225             client_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 226
 227     // Read a message from |client_mp|.
 228     char buffer[1000] = {};
 229     uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
 230     MojoHandle handles[10] = {};
 231     uint32_t num_handles = arraysize(handles);
 232     EXPECT_EQ(MOJO_RESULT_OK,
 233               MojoReadMessage(client_mp,
 234                               buffer,
 235                               &num_bytes,
 236                               handles,
 237                               &num_handles,
 238                               MOJO_READ_MESSAGE_FLAG_NONE));
 239     EXPECT_EQ(sizeof(kWorld), num_bytes);
 240     EXPECT_STREQ(kWorld, buffer);
 241     EXPECT_EQ(1u, num_handles);
 242     EXPECT_NE(handles[0], MOJO_HANDLE_INVALID);
 243     h1 = handles[0];
 244
 245     // Wait for |h1| to become readable.
 246     EXPECT_EQ(
 247         MOJO_RESULT_OK,
 248         MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 249
 250     // Read a message from |h1|.
 251     memset(buffer, 0, sizeof(buffer));
 252     num_bytes = static_cast<uint32_t>(sizeof(buffer));
 253     memset(handles, 0, sizeof(handles));
 254     num_handles = arraysize(handles);
 255     EXPECT_EQ(MOJO_RESULT_OK,
 256               MojoReadMessage(h1,
 257                               buffer,
 258                               &num_bytes,
 259                               handles,
 260                               &num_handles,
 261                               MOJO_READ_MESSAGE_FLAG_NONE));
 262     EXPECT_EQ(sizeof(kHello), num_bytes);
 263     EXPECT_STREQ(kHello, buffer);
 264     EXPECT_EQ(0u, num_handles);
 265
 266     // Wait for |h1| to become readable (again).
 267     EXPECT_EQ(
 268         MOJO_RESULT_OK,
 269         MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 270
 271     // Read the second message from |h1|.
 272     memset(buffer, 0, sizeof(buffer));
 273     num_bytes = static_cast<uint32_t>(sizeof(buffer));
 274     EXPECT_EQ(MOJO_RESULT_OK,
 275               MojoReadMessage(h1,
 276                               buffer,
 277                               &num_bytes,
 278                               nullptr,
 279                               nullptr,
 280                               MOJO_READ_MESSAGE_FLAG_NONE));
 281     EXPECT_EQ(sizeof(kFoo), num_bytes);
 282     EXPECT_STREQ(kFoo, buffer);
 283
 284     // Write a message to |h1|.
 285     const char kBarBaz[] = "barbaz";
 286     EXPECT_EQ(MOJO_RESULT_OK,
 287               MojoWriteMessage(h1,
 288                                kBarBaz,
 289                                static_cast<uint32_t>(sizeof(kBarBaz)),
 290                                nullptr,
 291                                0,
 292                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 293
 294     // Wait for |h0| to become readable.
 295     EXPECT_EQ(
 296         MOJO_RESULT_OK,
 297         MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 298
 299     // Read a message from |h0|.
 300     memset(buffer, 0, sizeof(buffer));
 301     num_bytes = static_cast<uint32_t>(sizeof(buffer));
 302     EXPECT_EQ(MOJO_RESULT_OK,
 303               MojoReadMessage(h0,
 304                               buffer,
 305                               &num_bytes,
 306                               nullptr,
 307                               nullptr,
 308                               MOJO_READ_MESSAGE_FLAG_NONE));
 309     EXPECT_EQ(sizeof(kBarBaz), num_bytes);
 310     EXPECT_STREQ(kBarBaz, buffer);
 311
 312     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
 313     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
 314     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0));
 315     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1));
 316
 317     server_channel.WaitForChannelCreationCompletion();
 318     client_channel.WaitForChannelCreationCompletion();
 319     EXPECT_TRUE(server_channel.channel_info());
 320     EXPECT_TRUE(client_channel.channel_info());
 321   }
 322
 323   EXPECT_TRUE(test::Shutdown());
 324 }
 325
 326 // The sequence of messages sent is:
 327 //       server_mp   client_mp   mp0         mp1         mp2         mp3
 328 //   1.  "hello"
 329 //   2.              "world!"
 330 //   3.                          "FOO"
 331 //   4.  "Bar"+mp1
 332 //   5.  (close)
 333 //   6.              (close)
 334 //   7.                                                              "baz"
 335 //   8.                                                              (closed)
 336 //   9.                                      "quux"+mp2
 337 //  10.                          (close)
 338 //  11.                                      (wait/cl.)
 339 //  12.                                                  (wait/cl.)
 340 TEST_F(EmbedderTest, MultiprocessChannels) {
 341   mojo::embedder::test::InitWithSimplePlatformSupport();
 342   mojo::test::MultiprocessTestHelper multiprocess_test_helper;
 343   multiprocess_test_helper.StartChild("MultiprocessChannelsClient");
 344
 345   {
 346     ScopedTestChannel server_channel(
 347         test_io_thread()->task_runner(),
 348         multiprocess_test_helper.server_platform_handle.Pass());
 349     MojoHandle server_mp = server_channel.bootstrap_message_pipe();
 350     EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
 351     server_channel.WaitForChannelCreationCompletion();
 352     EXPECT_TRUE(server_channel.channel_info());
 353
 354     // 1. Write a message to |server_mp| (attaching nothing).
 355     const char kHello[] = "hello";
 356     EXPECT_EQ(MOJO_RESULT_OK,
 357               MojoWriteMessage(server_mp,
 358                                kHello,
 359                                static_cast<uint32_t>(sizeof(kHello)),
 360                                nullptr,
 361                                0,
 362                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 363
 364     // TODO(vtl): If the scope were ended immediately here (maybe after closing
 365     // |server_mp|), we die with a fatal error in |Channel::HandleLocalError()|.
 366
 367     // 2. Read a message from |server_mp|.
 368     EXPECT_EQ(
 369         MOJO_RESULT_OK,
 370         MojoWait(
 371             server_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 372     char buffer[1000] = {};
 373     uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
 374     EXPECT_EQ(MOJO_RESULT_OK,
 375               MojoReadMessage(server_mp,
 376                               buffer,
 377                               &num_bytes,
 378                               nullptr,
 379                               nullptr,
 380                               MOJO_READ_MESSAGE_FLAG_NONE));
 381     const char kWorld[] = "world!";
 382     EXPECT_EQ(sizeof(kWorld), num_bytes);
 383     EXPECT_STREQ(kWorld, buffer);
 384
 385     // Create a new message pipe (endpoints |mp0| and |mp1|).
 386     MojoHandle mp0, mp1;
 387     EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &mp0, &mp1));
 388
 389     // 3. Write something to |mp0|.
 390     const char kFoo[] = "FOO";
 391     EXPECT_EQ(MOJO_RESULT_OK,
 392               MojoWriteMessage(mp0,
 393                                kFoo,
 394                                static_cast<uint32_t>(sizeof(kFoo)),
 395                                nullptr,
 396                                0,
 397                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 398
 399     // 4. Write a message to |server_mp|, attaching |mp1|.
 400     const char kBar[] = "Bar";
 401     EXPECT_EQ(MOJO_RESULT_OK,
 402               MojoWriteMessage(server_mp,
 403                                kBar,
 404                                static_cast<uint32_t>(sizeof(kBar)),
 405                                &mp1,
 406                                1,
 407                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 408     mp1 = MOJO_HANDLE_INVALID;
 409
 410     // 5. Close |server_mp|.
 411     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
 412
 413     // 9. Read a message from |mp0|, which should have |mp2| attached.
 414     EXPECT_EQ(
 415         MOJO_RESULT_OK,
 416         MojoWait(mp0, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 417     memset(buffer, 0, sizeof(buffer));
 418     num_bytes = static_cast<uint32_t>(sizeof(buffer));
 419     MojoHandle mp2 = MOJO_HANDLE_INVALID;
 420     uint32_t num_handles = 1;
 421     EXPECT_EQ(MOJO_RESULT_OK,
 422               MojoReadMessage(mp0,
 423                               buffer,
 424                               &num_bytes,
 425                               &mp2,
 426                               &num_handles,
 427                               MOJO_READ_MESSAGE_FLAG_NONE));
 428     const char kQuux[] = "quux";
 429     EXPECT_EQ(sizeof(kQuux), num_bytes);
 430     EXPECT_STREQ(kQuux, buffer);
 431     EXPECT_EQ(1u, num_handles);
 432     EXPECT_NE(mp2, MOJO_HANDLE_INVALID);
 433
 434     // 7. Read a message from |mp2|.
 435     EXPECT_EQ(
 436         MOJO_RESULT_OK,
 437         MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 438     memset(buffer, 0, sizeof(buffer));
 439     num_bytes = static_cast<uint32_t>(sizeof(buffer));
 440     EXPECT_EQ(MOJO_RESULT_OK,
 441               MojoReadMessage(mp2,
 442                               buffer,
 443                               &num_bytes,
 444                               nullptr,
 445                               nullptr,
 446                               MOJO_READ_MESSAGE_FLAG_NONE));
 447     const char kBaz[] = "baz";
 448     EXPECT_EQ(sizeof(kBaz), num_bytes);
 449     EXPECT_STREQ(kBaz, buffer);
 450
 451     // 10. Close |mp0|.
 452     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp0));
 453
 454 // 12. Wait on |mp2| (which should eventually fail) and then close it.
 455 // TODO(vtl): crbug.com/351768
 456 #if 0
 457     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 458               MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
 459                        MOJO_DEADLINE_INDEFINITE));
 460 #endif
 461     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp2));
 462   }
 463
 464   EXPECT_TRUE(multiprocess_test_helper.WaitForChildTestShutdown());
 465   EXPECT_TRUE(test::Shutdown());
 466 }
 467
 468 MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
 469   ScopedPlatformHandle client_platform_handle =
 470       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
 471   EXPECT_TRUE(client_platform_handle.is_valid());
 472
 473   base::TestIOThread test_io_thread(base::TestIOThread::kAutoStart);
 474   mojo::embedder::test::InitWithSimplePlatformSupport();
 475
 476   {
 477     ScopedTestChannel client_channel(test_io_thread.task_runner(),
 478                                      client_platform_handle.Pass());
 479     MojoHandle client_mp = client_channel.bootstrap_message_pipe();
 480     EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
 481     client_channel.WaitForChannelCreationCompletion();
 482     CHECK(client_channel.channel_info() != nullptr);
 483
 484     // 1. Read the first message from |client_mp|.
 485     EXPECT_EQ(
 486         MOJO_RESULT_OK,
 487         MojoWait(
 488             client_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 489     char buffer[1000] = {};
 490     uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
 491     EXPECT_EQ(MOJO_RESULT_OK,
 492               MojoReadMessage(client_mp,
 493                               buffer,
 494                               &num_bytes,
 495                               nullptr,
 496                               nullptr,
 497                               MOJO_READ_MESSAGE_FLAG_NONE));
 498     const char kHello[] = "hello";
 499     EXPECT_EQ(sizeof(kHello), num_bytes);
 500     EXPECT_STREQ(kHello, buffer);
 501
 502     // 2. Write a message to |client_mp| (attaching nothing).
 503     const char kWorld[] = "world!";
 504     EXPECT_EQ(MOJO_RESULT_OK,
 505               MojoWriteMessage(client_mp,
 506                                kWorld,
 507                                static_cast<uint32_t>(sizeof(kWorld)),
 508                                nullptr,
 509                                0,
 510                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 511
 512     // 4. Read a message from |client_mp|, which should have |mp1| attached.
 513     EXPECT_EQ(
 514         MOJO_RESULT_OK,
 515         MojoWait(
 516             client_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 517     // TODO(vtl): If the scope were to end here (and |client_mp| closed), we'd
 518     // die (again due to |Channel::HandleLocalError()|).
 519     memset(buffer, 0, sizeof(buffer));
 520     num_bytes = static_cast<uint32_t>(sizeof(buffer));
 521     MojoHandle mp1 = MOJO_HANDLE_INVALID;
 522     uint32_t num_handles = 1;
 523     EXPECT_EQ(MOJO_RESULT_OK,
 524               MojoReadMessage(client_mp,
 525                               buffer,
 526                               &num_bytes,
 527                               &mp1,
 528                               &num_handles,
 529                               MOJO_READ_MESSAGE_FLAG_NONE));
 530     const char kBar[] = "Bar";
 531     EXPECT_EQ(sizeof(kBar), num_bytes);
 532     EXPECT_STREQ(kBar, buffer);
 533     EXPECT_EQ(1u, num_handles);
 534     EXPECT_NE(mp1, MOJO_HANDLE_INVALID);
 535     // TODO(vtl): If the scope were to end here (and the two handles closed),
 536     // we'd die due to |Channel::RunRemoteMessagePipeEndpoint()| not handling
 537     // write errors (assuming the parent had closed the pipe).
 538
 539     // 6. Close |client_mp|.
 540     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
 541
 542     // Create a new message pipe (endpoints |mp2| and |mp3|).
 543     MojoHandle mp2, mp3;
 544     EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &mp2, &mp3));
 545
 546     // 7. Write a message to |mp3|.
 547     const char kBaz[] = "baz";
 548     EXPECT_EQ(MOJO_RESULT_OK,
 549               MojoWriteMessage(mp3,
 550                                kBaz,
 551                                static_cast<uint32_t>(sizeof(kBaz)),
 552                                nullptr,
 553                                0,
 554                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 555
 556     // 8. Close |mp3|.
 557     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp3));
 558
 559     // 9. Write a message to |mp1|, attaching |mp2|.
 560     const char kQuux[] = "quux";
 561     EXPECT_EQ(MOJO_RESULT_OK,
 562               MojoWriteMessage(mp1,
 563                                kQuux,
 564                                static_cast<uint32_t>(sizeof(kQuux)),
 565                                &mp2,
 566                                1,
 567                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 568     mp2 = MOJO_HANDLE_INVALID;
 569
 570     // 3. Read a message from |mp1|.
 571     EXPECT_EQ(
 572         MOJO_RESULT_OK,
 573         MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 574     memset(buffer, 0, sizeof(buffer));
 575     num_bytes = static_cast<uint32_t>(sizeof(buffer));
 576     EXPECT_EQ(MOJO_RESULT_OK,
 577               MojoReadMessage(mp1,
 578                               buffer,
 579                               &num_bytes,
 580                               nullptr,
 581                               nullptr,
 582                               MOJO_READ_MESSAGE_FLAG_NONE));
 583     const char kFoo[] = "FOO";
 584     EXPECT_EQ(sizeof(kFoo), num_bytes);
 585     EXPECT_STREQ(kFoo, buffer);
 586
 587     // 11. Wait on |mp1| (which should eventually fail) and then close it.
 588     EXPECT_EQ(
 589         MOJO_RESULT_FAILED_PRECONDITION,
 590         MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
 591     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp1));
 592   }
 593
 594   EXPECT_TRUE(test::Shutdown());
 595 }
 596
 597 // TODO(vtl): Test immediate write & close.
 598 // TODO(vtl): Test broken-connection cases.
 599
 600 }  // namespace
 601 }  // namespace embedder
 602 }  // namespace mojo