Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

mojo/edk/system/remote_message_pipe_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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <vector>
 
@@ skipping 30 matching lines @@
 namespace system {
 namespace {
 
 class RemoteMessagePipeTest : public testing::Test {
  public:
   RemoteMessagePipeTest() : io_thread_(base::TestIOThread::kAutoStart) {}
   ~RemoteMessagePipeTest() override {}
 
   void SetUp() override {
     io_thread_.PostTaskAndWait(
-        FROM_HERE,
-        base::Bind(&RemoteMessagePipeTest::SetUpOnIOThread,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&RemoteMessagePipeTest::SetUpOnIOThread,
+                              base::Unretained(this)));
   }
 
   void TearDown() override {
     io_thread_.PostTaskAndWait(
-        FROM_HERE,
-        base::Bind(&RemoteMessagePipeTest::TearDownOnIOThread,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&RemoteMessagePipeTest::TearDownOnIOThread,
+                              base::Unretained(this)));
   }
 
  protected:
   // This connects the two given |ChannelEndpoint|s. It assumes/requires that
   // this is the bootstrap case (i.e., no other message pipes have ever been
   // hosted on the channel).
   void BootstrapChannelEndpoints(scoped_refptr<ChannelEndpoint> ep0,
                                  scoped_refptr<ChannelEndpoint> ep1) {
     io_thread_.PostTaskAndWait(
         FROM_HERE,
         base::Bind(&RemoteMessagePipeTest::BootstrapChannelEndpointsOnIOThread,
-                   base::Unretained(this),
-                   ep0,
-                   ep1));
+                   base::Unretained(this), ep0, ep1));
   }
 
   // This bootstraps |ep| on |channels_[channel_index]|. It assumes/requires
   // that this is the bootstrap case (i.e., no message pipes have ever been
   // hosted on the channel). This returns *without* waiting.
   void BootstrapChannelEndpointNoWait(unsigned channel_index,
                                       scoped_refptr<ChannelEndpoint> ep) {
     io_thread_.PostTask(
         FROM_HERE,
         base::Bind(&RemoteMessagePipeTest::BootstrapChannelEndpointOnIOThread,
-                   base::Unretained(this),
-                   channel_index,
-                   ep));
+                   base::Unretained(this), channel_index, ep));
   }
 
   void RestoreInitialState() {
     io_thread_.PostTaskAndWait(
         FROM_HERE,
         base::Bind(&RemoteMessagePipeTest::RestoreInitialStateOnIOThread,
                    base::Unretained(this)));
   }
 
   embedder::PlatformSupport* platform_support() { return &platform_support_; }
@@ skipping 93 matching lines @@
   // Write in one direction: MP 0, port 0 -> ... -> MP 1, port 1.
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(kHello),
-                              sizeof(kHello),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // Write in the other direction: MP 1, port 1 -> ... -> MP 0, port 0.
 
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
 
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->WriteMessage(1,
-                              UserPointer<const void>(kWorld),
-                              sizeof(kWorld),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
   mp0->RemoveWaiter(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kWorld, buffer);
 
   // Close MP 0, port 0.
   mp0->Close(0);
 
   // Try to wait for MP 1, port 1 to become readable. This will eventually fail
   // when it realizes that MP 0, port 0 has been closed. (It may also fail
   // immediately.)
@@ skipping 44 matching lines @@
   ASSERT_TRUE(channels(0));
   ChannelEndpointId remote_id = channels(0)->AttachAndRunEndpoint(ep2, false);
   EXPECT_TRUE(remote_id.is_remote());
 
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(&remote_id),
-                              sizeof(remote_id),
-                              nullptr,
+            mp0->WriteMessage(0, UserPointer<const void>(&remote_id),
+                              sizeof(remote_id), nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   ChannelEndpointId received_id;
   buffer_size = static_cast<uint32_t>(sizeof(received_id));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(&received_id),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(&received_id),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(received_id), static_cast<size_t>(buffer_size));
   EXPECT_EQ(remote_id, received_id);
 
   // Warning: The local side of mp3 is port 0, not port 1.
   scoped_refptr<MessagePipe> mp3 =
       channels(1)->PassIncomingMessagePipe(received_id);
   ASSERT_TRUE(mp3.get());
 
   // Write: MP 2, port 0 -> MP 3, port 1.
 
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp3->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
 
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp2->WriteMessage(0,
-                              UserPointer<const void>(kHello),
-                              sizeof(kHello),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp2->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
   mp3->RemoveWaiter(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Make sure there's nothing on MP 0, port 0 or MP 1, port 1 or MP 2, port 0.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp0->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp2->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp2->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Read from MP 3, port 1.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp3->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp3->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // Write: MP 0, port 0 -> MP 1, port 1 again.
 
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(kWorld),
-                              sizeof(kWorld),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Make sure there's nothing on the other ports.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp0->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp2->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp2->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp3->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp3->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kWorld, buffer);
 
   mp0->Close(0);
   mp1->Close(1);
   mp2->Close(0);
   mp3->Close(0);
 }
 
 TEST_F(RemoteMessagePipeTest, CloseBeforeAttachAndRun) {
   static const char kHello[] = "hello";
   char buffer[100] = {0};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
   scoped_refptr<ChannelEndpoint> ep0;
   scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
 
   // Write to MP 0, port 0.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(kHello),
-                              sizeof(kHello),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Close MP 0, port 0 before it's even been attached to the channel and run.
   mp0->Close(0);
 
   BootstrapChannelEndpointNoWait(0, ep0);
 
   scoped_refptr<ChannelEndpoint> ep1;
   scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
@@ skipping 12 matching lines @@
   // Note: MP 1, port 1 should definitely should be readable, but it may or may
   // not appear as writable (there's a race, and it may not have noticed that
   // the other side was closed yet -- e.g., inserting a sleep here would make it
   // much more likely to notice that it's no longer writable).
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // And MP 1, port 1.
   mp1->Close(1);
 }
 
 TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) {
   static const char kHello[] = "hello";
   char buffer[100] = {0};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
   scoped_refptr<ChannelEndpoint> ep0;
   scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
 
   // Write to MP 0, port 0.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(kHello),
-                              sizeof(kHello),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   BootstrapChannelEndpointNoWait(0, ep0);
 
   // Close MP 0, port 0 before channel 1 is even connected.
   mp0->Close(0);
 
   scoped_refptr<ChannelEndpoint> ep1;
   scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
@@ skipping 12 matching lines @@
   // Note: MP 1, port 1 should definitely should be readable, but it may or may
   // not appear as writable (there's a race, and it may not have noticed that
   // the other side was closed yet -- e.g., inserting a sleep here would make it
   // much more likely to notice that it's no longer writable).
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // And MP 1, port 1.
   mp1->Close(1);
 }
 
 TEST_F(RemoteMessagePipeTest, HandlePassing) {
   static const char kHello[] = "hello";
@@ skipping 21 matching lines @@
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kHello),
-                                sizeof(kHello),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
     EXPECT_TRUE(dispatcher->HasOneRef());
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0].get());
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType());
   dispatcher = static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get());
 
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddWaiter(
-                &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
+            dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456,
+                                  nullptr));
 
   // Write to "local_mp", port 1.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->WriteMessage(1,
-                                   UserPointer<const void>(kHello),
-                                   sizeof(kHello),
-                                   nullptr,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // TODO(vtl): FIXME -- We (racily) crash if I close |dispatcher| immediately
   // here. (We don't crash if I sleep and then close.)
 
   // Wait for the dispatcher to become readable.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
   dispatcher->RemoveWaiter(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from the dispatcher.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
-                                    MakeUserPointer(&read_buffer_size),
-                                    0,
-                                    nullptr,
-                                    MOJO_READ_MESSAGE_FLAG_NONE));
+                                    MakeUserPointer(&read_buffer_size), 0,
+                                    nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            local_mp->AddWaiter(
-                1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+            local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                nullptr));
 
   // Write to the dispatcher.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            dispatcher->WriteMessage(UserPointer<const void>(kHello),
-                                     sizeof(kHello),
-                                     nullptr,
-                                     MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
+                                UserPointer<const void>(kHello), sizeof(kHello),
+                                nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
   local_mp->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from "local_mp", port 1.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->ReadMessage(1,
-                                  UserPointer<void>(read_buffer),
-                                  MakeUserPointer(&read_buffer_size),
-                                  nullptr,
-                                  nullptr,
-                                  MOJO_READ_MESSAGE_FLAG_NONE));
+            local_mp->ReadMessage(1, UserPointer<void>(read_buffer),
+                                  MakeUserPointer(&read_buffer_size), nullptr,
+                                  nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // TODO(vtl): Also test that messages queued up before the handle was sent are
   // delivered properly.
 
   // Close everything that belongs to us.
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
@@ skipping 12 matching lines @@
   scoped_refptr<MessagePipeDispatcher> dispatcher(
       new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions));
   scoped_refptr<MessagePipe> local_mp(MessagePipe::CreateLocalLocal());
   dispatcher->Init(local_mp, 0);
 
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
   // Write to the other end (|local_mp|, port 1), and then close it.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->WriteMessage(1,
-                                   UserPointer<const void>(kHello),
-                                   sizeof(kHello),
-                                   nullptr,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
   // Then the second message....
-  EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->WriteMessage(1,
-                                   UserPointer<const void>(kWorld),
-                                   sizeof(kWorld),
-                                   nullptr,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      local_mp->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
   // Then close it.
   local_mp->Close(1);
 
   scoped_refptr<ChannelEndpoint> ep0;
   scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
   scoped_refptr<ChannelEndpoint> ep1;
   scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
   BootstrapChannelEndpoints(ep0, ep1);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kHello),
-                                sizeof(kHello),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
     EXPECT_TRUE(dispatcher->HasOneRef());
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0].get());
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType());
   dispatcher = static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get());
 
   // |dispatcher| should already be readable and not writable.
   hss = dispatcher->GetHandleSignalsState();
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
   // So read from it.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
-                                    MakeUserPointer(&read_buffer_size),
-                                    0,
-                                    nullptr,
-                                    MOJO_READ_MESSAGE_FLAG_NONE));
+                                    MakeUserPointer(&read_buffer_size), 0,
+                                    nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   // It should still be readable.
   hss = dispatcher->GetHandleSignalsState();
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
   // So read from it.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
-                                    MakeUserPointer(&read_buffer_size),
-                                    0,
-                                    nullptr,
-                                    MOJO_READ_MESSAGE_FLAG_NONE));
+                                    MakeUserPointer(&read_buffer_size), 0,
+                                    nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   // Now it should no longer be readable.
   hss = dispatcher->GetHandleSignalsState();
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, hss.satisfiable_signals);
 
   // Close everything that belongs to us.
   mp0->Close(0);
   mp1->Close(1);
@@ skipping 13 matching lines @@
   uint32_t context = 0;
 
   scoped_refptr<ChannelEndpoint> ep0;
   scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
   scoped_refptr<ChannelEndpoint> ep1;
   scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
   BootstrapChannelEndpoints(ep0, ep1);
 
   // We'll try to pass this dispatcher.
   scoped_refptr<SharedBufferDispatcher> dispatcher;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher));
+  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+                                platform_support(),
+                                SharedBufferDispatcher::kDefaultCreateOptions,
+                                100, &dispatcher));
   ASSERT_TRUE(dispatcher.get());
 
   // Make a mapping.
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping0;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+                                0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
   ASSERT_TRUE(mapping0);
   ASSERT_TRUE(mapping0->GetBase());
   ASSERT_EQ(100u, mapping0->GetLength());
   static_cast<char*>(mapping0->GetBase())[0] = 'A';
   static_cast<char*>(mapping0->GetBase())[50] = 'B';
   static_cast<char*>(mapping0->GetBase())[99] = 'C';
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kHello),
-                                sizeof(kHello),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
     EXPECT_TRUE(dispatcher->HasOneRef());
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0].get());
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypeSharedBuffer, read_dispatchers[0]->GetType());
   dispatcher = static_cast<SharedBufferDispatcher*>(read_dispatchers[0].get());
 
   // Make another mapping.
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping1;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+                                0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
   ASSERT_TRUE(mapping1);
   ASSERT_TRUE(mapping1->GetBase());
   ASSERT_EQ(100u, mapping1->GetLength());
   EXPECT_NE(mapping1->GetBase(), mapping0->GetBase());
   EXPECT_EQ('A', static_cast<char*>(mapping1->GetBase())[0]);
   EXPECT_EQ('B', static_cast<char*>(mapping1->GetBase())[50]);
   EXPECT_EQ('C', static_cast<char*>(mapping1->GetBase())[99]);
 
   // Write stuff either way.
   static_cast<char*>(mapping1->GetBase())[1] = 'x';
@@ skipping 54 matching lines @@
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kWorld),
-                                sizeof(kWorld),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
     EXPECT_TRUE(dispatcher->HasOneRef());
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0].get());
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypePlatformHandle, read_dispatchers[0]->GetType());
   dispatcher =
       static_cast<PlatformHandleDispatcher*>(read_dispatchers[0].get());
@@ skipping 86 matching lines @@
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kHello),
-                                sizeof(kHello),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
     EXPECT_TRUE(dispatcher->HasOneRef());
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0].get());
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType());
   dispatcher = static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get());
   read_dispatchers.clear();
 
   // Now pass it back.
 
   // Prepare to wait on MP 0, port 0. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
 
   // Write to MP 1, port 1.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp1->WriteMessage(1,
-                                UserPointer<const void>(kWorld),
-                                sizeof(kWorld),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
     EXPECT_TRUE(dispatcher->HasOneRef());
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
   mp0->RemoveWaiter(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from MP 0, port 0.
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->ReadMessage(0,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->ReadMessage(0, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0].get());
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType());
   dispatcher = static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get());
   read_dispatchers.clear();
 
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddWaiter(
-                &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+            dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                  nullptr));
 
   // Write to "local_mp", port 1.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->WriteMessage(1,
-                                   UserPointer<const void>(kHello),
-                                   sizeof(kHello),
-                                   nullptr,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait for the dispatcher to become readable.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
   dispatcher->RemoveWaiter(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from the dispatcher.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
-                                    MakeUserPointer(&read_buffer_size),
-                                    0,
-                                    nullptr,
-                                    MOJO_READ_MESSAGE_FLAG_NONE));
+                                    MakeUserPointer(&read_buffer_size), 0,
+                                    nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            local_mp->AddWaiter(
-                1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+            local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                nullptr));
 
   // Write to the dispatcher.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            dispatcher->WriteMessage(UserPointer<const void>(kHello),
-                                     sizeof(kHello),
-                                     nullptr,
-                                     MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
+                                UserPointer<const void>(kHello), sizeof(kHello),
+                                nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
   local_mp->RemoveWaiter(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Read from "local_mp", port 1.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->ReadMessage(1,
-                                  UserPointer<void>(read_buffer),
-                                  MakeUserPointer(&read_buffer_size),
-                                  nullptr,
-                                  nullptr,
-                                  MOJO_READ_MESSAGE_FLAG_NONE));
+            local_mp->ReadMessage(1, UserPointer<void>(read_buffer),
+                                  MakeUserPointer(&read_buffer_size), nullptr,
+                                  nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // TODO(vtl): Also test the cases where messages are written and read (at
   // various points) on the message pipe being passed around.
 
   // Close everything that belongs to us.
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
   // Note that |local_mp|'s port 0 belong to |dispatcher|, which was closed.
   local_mp->Close(1);
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo