Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

mojo/edk/system/message_pipe_perftest.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 <string>
 #include <vector>
@@ skipping 29 matching lines @@
   void SetUpMeasurement(int message_count, size_t message_size) {
     message_count_ = message_count;
     message_size_ = message_size;
     payload_ = Pickle();
     payload_.WriteString(std::string(message_size, '*'));
     read_buffer_.resize(message_size * 2);
   }
 
  protected:
   void WriteWaitThenRead(scoped_refptr<MessagePipe> mp) {
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(payload_.data()),
-                              static_cast<uint32_t>(payload_.size()),
-                              nullptr,
+    CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(payload_.data()),
+                              static_cast<uint32_t>(payload_.size()), nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     HandleSignalsState hss;
     CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
              MOJO_RESULT_OK);
     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);
     CHECK_EQ(read_buffer_size, static_cast<uint32_t>(payload_.size()));
   }
 
   void SendQuitMessage(scoped_refptr<MessagePipe> mp) {
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(""),
-                              0,
-                              nullptr,
+    CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(""), 0, nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
 
   void Measure(scoped_refptr<MessagePipe> mp) {
     // Have one ping-pong to ensure channel being established.
     WriteWaitThenRead(mp);
 
     std::string test_name =
-        base::StringPrintf("IPC_Perf_%dx_%u",
-                           message_count_,
+        base::StringPrintf("IPC_Perf_%dx_%u", message_count_,
                            static_cast<unsigned>(message_size_));
     base::PerfTimeLogger logger(test_name.c_str());
 
     for (int i = 0; i < message_count_; ++i)
       WriteWaitThenRead(mp);
 
     logger.Done();
   }
 
  private:
@@ skipping 24 matching lines @@
     // Wait for our end of the message pipe to be readable.
     HandleSignalsState hss;
     MojoResult result =
         test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss);
     if (result != MOJO_RESULT_OK) {
       rv = result;
       break;
     }
 
     uint32_t read_size = static_cast<uint32_t>(buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&buffer[0]),
-                             MakeUserPointer(&read_size),
-                             nullptr,
-                             nullptr,
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&buffer[0]),
+                             MakeUserPointer(&read_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
 
     // Empty message indicates quitting
     if (0 == read_size)
       break;
 
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(&buffer[0]),
-                              static_cast<uint32_t>(read_size),
-                              nullptr,
+    CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(&buffer[0]),
+                              static_cast<uint32_t>(read_size), nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
 
   mp->Close(0);
   return rv;
 }
 
 // Repeatedly sends messages as previous one got replied by the child.
 // Waits for the child to close its end before quitting once specified
@@ skipping 15 matching lines @@
   }
 
   SendQuitMessage(mp);
   mp->Close(0);
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo