Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

mojo/edk/system/multiprocess_message_pipe_unittest.cc

 // Copyright 2013 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 <string>
 #include <vector>
@@ skipping 54 matching lines @@
       CHECK_EQ(hss.satisfied_signals, 0u);
       CHECK_EQ(hss.satisfiable_signals, 0u);
       break;
     } else {
       CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
       CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
     }
 
     std::string read_buffer(1000, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&read_buffer[0]),
-                             MakeUserPointer(&read_buffer_size),
-                             nullptr,
-                             nullptr,
-                             MOJO_READ_MESSAGE_FLAG_NONE),
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                             MakeUserPointer(&read_buffer_size), nullptr,
+                             nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
     VLOG(2) << "Child got: " << read_buffer;
 
     if (read_buffer == quitquitquit) {
       VLOG(2) << "Child quitting.";
       break;
     }
 
     std::string write_buffer = read_buffer + read_buffer;
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(write_buffer.data()),
+    CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(write_buffer.data()),
                               static_cast<uint32_t>(write_buffer.size()),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE),
+                              nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
 
   mp->Close(0);
   return rv;
 }
 
 // Sends "hello" to child, and expects "hellohello" back.
 TEST_F(MultiprocessMessagePipeTest, Basic) {
   helper()->StartChild("EchoEcho");
 
   scoped_refptr<ChannelEndpoint> ep;
   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
   Init(ep);
 
   std::string hello("hello");
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(hello.data()),
-                             static_cast<uint32_t>(hello.size()),
-                             nullptr,
+            mp->WriteMessage(0, UserPointer<const void>(hello.data()),
+                             static_cast<uint32_t>(hello.size()), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_OK,
             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
   // The child may or may not have closed its end of the message pipe and died
   // (and we may or may not know it yet), so our end may or may not appear as
   // writable.
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
   std::string read_buffer(1000, '\0');
   uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&read_buffer_size),
-                           nullptr,
-                           nullptr,
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&read_buffer_size), nullptr, nullptr,
                            MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(read_buffer_size);
   VLOG(2) << "Parent got: " << read_buffer;
   EXPECT_EQ(hello + hello, read_buffer);
 
   mp->Close(0);
 
   // We sent one message.
   EXPECT_EQ(1 % 100, helper()->WaitForChildShutdown());
 }
 
 // Sends a bunch of messages to the child. Expects them "repeated" back. Waits
 // for the child to close its end before quitting.
 TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
   helper()->StartChild("EchoEcho");
 
   scoped_refptr<ChannelEndpoint> ep;
   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
   Init(ep);
 
   static const size_t kNumMessages = 1001;
   for (size_t i = 0; i < kNumMessages; i++) {
     std::string write_buffer(i, 'A' + (i % 26));
     EXPECT_EQ(MOJO_RESULT_OK,
-              mp->WriteMessage(0,
-                               UserPointer<const void>(write_buffer.data()),
+              mp->WriteMessage(0, UserPointer<const void>(write_buffer.data()),
                                static_cast<uint32_t>(write_buffer.size()),
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
 
   const std::string quitquitquit("quitquitquit");
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(quitquitquit.data()),
+            mp->WriteMessage(0, UserPointer<const void>(quitquitquit.data()),
                              static_cast<uint32_t>(quitquitquit.size()),
-                             nullptr,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   for (size_t i = 0; i < kNumMessages; i++) {
     HandleSignalsState hss;
     EXPECT_EQ(MOJO_RESULT_OK,
               test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     // The child may or may not have closed its end of the message pipe and died
     // (and we may or may not know it yet), so our end may or may not appear as
     // writable.
     EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
     EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
     std::string read_buffer(kNumMessages * 2, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&read_buffer[0]),
-                             MakeUserPointer(&read_buffer_size),
-                             nullptr,
-                             nullptr,
-                             MOJO_READ_MESSAGE_FLAG_NONE),
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                             MakeUserPointer(&read_buffer_size), nullptr,
+                             nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
 
     EXPECT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer);
   }
 
   // Wait for it to become readable, which should fail (since we sent
   // "quitquitquit").
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ skipping 26 matching lines @@
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 
   // It should have a shared buffer.
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   DispatcherVector dispatchers;
   uint32_t num_dispatchers = 10;  // Maximum number to receive.
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           &dispatchers,
-                           &num_dispatchers,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), &dispatchers,
+                           &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("go 1"));
   CHECK_EQ(num_dispatchers, 1u);
 
   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypeSharedBuffer);
 
   scoped_refptr<SharedBufferDispatcher> dispatcher(
       static_cast<SharedBufferDispatcher*>(dispatchers[0].get()));
 
   // Make a mapping.
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
   CHECK_EQ(dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping),
            MOJO_RESULT_OK);
   CHECK(mapping);
   CHECK(mapping->GetBase());
   CHECK_EQ(mapping->GetLength(), 100u);
 
   // Write some stuff to the shared buffer.
   static const char kHello[] = "hello";
   memcpy(mapping->GetBase(), kHello, sizeof(kHello));
 
   // We should be able to close the dispatcher now.
   dispatcher->Close();
 
   // And send a message to signal that we've written stuff.
   const std::string go2("go 2");
-  CHECK_EQ(mp->WriteMessage(0,
-                            UserPointer<const void>(&go2[0]),
-                            static_cast<uint32_t>(go2.size()),
-                            nullptr,
+  CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(&go2[0]),
+                            static_cast<uint32_t>(go2.size()), nullptr,
                             MOJO_WRITE_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
 
   // Now wait for our parent to send us a message.
   hss = HandleSignalsState();
   CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
            MOJO_RESULT_OK);
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 
   read_buffer = std::string(100, '\0');
   num_bytes = static_cast<uint32_t>(read_buffer.size());
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           nullptr,
-                           nullptr,
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), nullptr, nullptr,
                            MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("go 3"));
 
   // It should have written something to the shared buffer.
   static const char kWorld[] = "world!!!";
   CHECK_EQ(memcmp(mapping->GetBase(), kWorld, sizeof(kWorld)), 0);
 
   // And we're done.
@@ skipping 10 matching lines @@
 #endif
 TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
   helper()->StartChild("CheckSharedBuffer");
 
   scoped_refptr<ChannelEndpoint> ep;
   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
   Init(ep);
 
   // Make a shared buffer.
   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> mapping;
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
   ASSERT_TRUE(mapping);
   ASSERT_TRUE(mapping->GetBase());
   ASSERT_EQ(100u, mapping->GetLength());
 
   // Send the shared buffer.
   const std::string go1("go 1");
   DispatcherTransport transport(
       test::DispatcherTryStartTransport(dispatcher.get()));
   ASSERT_TRUE(transport.is_valid());
 
   std::vector<DispatcherTransport> transports;
   transports.push_back(transport);
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&go1[0]),
-                             static_cast<uint32_t>(go1.size()),
-                             &transports,
+            mp->WriteMessage(0, UserPointer<const void>(&go1[0]),
+                             static_cast<uint32_t>(go1.size()), &transports,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   transport.End();
 
   EXPECT_TRUE(dispatcher->HasOneRef());
   dispatcher = nullptr;
 
   // Wait for a message from the child.
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_OK,
             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(0,
-                            UserPointer<void>(&read_buffer[0]),
-                            MakeUserPointer(&num_bytes),
-                            nullptr,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                            MakeUserPointer(&num_bytes), nullptr, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   read_buffer.resize(num_bytes);
   EXPECT_EQ(std::string("go 2"), read_buffer);
 
   // After we get it, the child should have written something to the shared
   // buffer.
   static const char kHello[] = "hello";
   EXPECT_EQ(0, memcmp(mapping->GetBase(), kHello, sizeof(kHello)));
 
   // Now we'll write some stuff to the shared buffer.
   static const char kWorld[] = "world!!!";
   memcpy(mapping->GetBase(), kWorld, sizeof(kWorld));
 
   // And send a message to signal that we've written stuff.
   const std::string go3("go 3");
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&go3[0]),
-                             static_cast<uint32_t>(go3.size()),
-                             nullptr,
+            mp->WriteMessage(0, UserPointer<const void>(&go3[0]),
+                             static_cast<uint32_t>(go3.size()), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait for |mp| to become readable, which should fail.
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   mp->Close(0);
@@ skipping 16 matching lines @@
            MOJO_RESULT_OK);
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   DispatcherVector dispatchers;
   uint32_t num_dispatchers = 10;  // Maximum number to receive.
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           &dispatchers,
-                           &num_dispatchers,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), &dispatchers,
+                           &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   mp->Close(0);
 
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("hello"));
   CHECK_EQ(num_dispatchers, 1u);
 
   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypePlatformHandle);
 
   scoped_refptr<PlatformHandleDispatcher> dispatcher(
@@ skipping 42 matching lines @@
       new PlatformHandleDispatcher(h.Pass()));
 
   const std::string hello("hello");
   DispatcherTransport transport(
       test::DispatcherTryStartTransport(dispatcher.get()));
   ASSERT_TRUE(transport.is_valid());
 
   std::vector<DispatcherTransport> transports;
   transports.push_back(transport);
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&hello[0]),
-                             static_cast<uint32_t>(hello.size()),
-                             &transports,
+            mp->WriteMessage(0, UserPointer<const void>(&hello[0]),
+                             static_cast<uint32_t>(hello.size()), &transports,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   transport.End();
 
   EXPECT_TRUE(dispatcher->HasOneRef());
   dispatcher = nullptr;
 
   // Wait for it to become readable, which should fail.
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   mp->Close(0);
 
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo