Convert Pass()→std::move() in mojo/edk/

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 <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "build/build_config.h"
@@ skipping 17 matching lines @@
 
 class MultiprocessMessagePipeTest
     : public test::MultiprocessMessagePipeTestBase {};
 
 // For each message received, sends a reply message with the same contents
 // repeated twice, until the other end is closed or it receives "quitquitquit"
 // (which it doesn't reply to). It'll return the number of messages received,
 // not including any "quitquitquit" message, modulo 100.
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
   ScopedPlatformHandle client_platform_handle =
-      test::MultiprocessTestHelper::client_platform_handle.Pass();
+      std::move(test::MultiprocessTestHelper::client_platform_handle);
   CHECK(client_platform_handle.is_valid());
   ScopedMessagePipeHandle mp =
-      CreateMessagePipe(client_platform_handle.Pass());
+      CreateMessagePipe(std::move(client_platform_handle));
 
   const std::string quitquitquit("quitquitquit");
   int rv = 0;
   for (;; rv = (rv + 1) % 100) {
     // Wait for our end of the message pipe to be readable.
     HandleSignalsState hss;
     MojoResult result =
         MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
                  MOJO_DEADLINE_INDEFINITE, &hss);
     if (result != MOJO_RESULT_OK) {
@@ skipping 34 matching lines @@
 // Sends "hello" to child, and expects "hellohello" back.
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_Basic DISABLED_Basic
 #else
 #define MAYBE_Basic Basic
 #endif  // defined(OS_ANDROID)
 TEST_F(MultiprocessMessagePipeTest, MAYBE_Basic) {
   helper()->StartChild("EchoEcho");
 
-  ScopedMessagePipeHandle mp = CreateMessagePipe(
-      helper()->server_platform_handle.Pass());
+  ScopedMessagePipeHandle mp =
+      CreateMessagePipe(std::move(helper()->server_platform_handle));
 
   std::string hello("hello");
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoWriteMessage(mp.get().value(), hello.data(),
                              static_cast<uint32_t>(hello.size()), nullptr, 0u,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   HandleSignalsState hss;
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
@@ skipping 24 matching lines @@
 // for the child to close its end before quitting.
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_QueueMessages DISABLED_QueueMessages
 #else
 #define MAYBE_QueueMessages QueueMessages
 #endif  // defined(OS_ANDROID)
 TEST_F(MultiprocessMessagePipeTest, MAYBE_QueueMessages) {
   helper()->StartChild("EchoEcho");
 
-  ScopedMessagePipeHandle mp = CreateMessagePipe(
-      helper()->server_platform_handle.Pass());
+  ScopedMessagePipeHandle mp =
+      CreateMessagePipe(std::move(helper()->server_platform_handle));
 
   static const size_t kNumMessages = 1001;
   for (size_t i = 0; i < kNumMessages; i++) {
     std::string write_buffer(i, 'A' + (i % 26));
     ASSERT_EQ(MOJO_RESULT_OK,
             MojoWriteMessage(mp.get().value(), write_buffer.data(),
                              static_cast<uint32_t>(write_buffer.size()),
                              nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
 
@@ skipping 33 matching lines @@
                      MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   ASSERT_EQ(static_cast<int>(kNumMessages % 100),
             helper()->WaitForChildShutdown());
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
   ScopedPlatformHandle client_platform_handle =
-      test::MultiprocessTestHelper::client_platform_handle.Pass();
+      std::move(test::MultiprocessTestHelper::client_platform_handle);
   CHECK(client_platform_handle.is_valid());
   ScopedMessagePipeHandle mp =
-      CreateMessagePipe(client_platform_handle.Pass());
+      CreateMessagePipe(std::move(client_platform_handle));
 
   // Wait for the first message from our parent.
   HandleSignalsState hss;
   CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
                MOJO_DEADLINE_INDEFINITE, &hss),
            MOJO_RESULT_OK);
   // In this test, the parent definitely doesn't close its end of the message
   // pipe before we do.
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
@@ skipping 64 matching lines @@
 
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_SharedBufferPassing DISABLED_SharedBufferPassing
 #else
 #define MAYBE_SharedBufferPassing SharedBufferPassing
 #endif
 TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
   helper()->StartChild("CheckSharedBuffer");
 
-  ScopedMessagePipeHandle mp = CreateMessagePipe(
-      helper()->server_platform_handle.Pass());
+  ScopedMessagePipeHandle mp =
+      CreateMessagePipe(std::move(helper()->server_platform_handle));
 
   // Make a shared buffer.
   MojoCreateSharedBufferOptions options;
   options.struct_size = sizeof(options);
   options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;
 
   MojoHandle shared_buffer;
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoCreateSharedBuffer(&options, 100, &shared_buffer));
 
@@ skipping 59 matching lines @@
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   MojoClose(mp.release().value());
 
   ASSERT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) {
   ScopedPlatformHandle client_platform_handle =
-      test::MultiprocessTestHelper::client_platform_handle.Pass();
+      std::move(test::MultiprocessTestHelper::client_platform_handle);
   CHECK(client_platform_handle.is_valid());
   ScopedMessagePipeHandle mp =
-      CreateMessagePipe(client_platform_handle.Pass());
+      CreateMessagePipe(std::move(client_platform_handle));
 
   HandleSignalsState hss;
   CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
                MOJO_DEADLINE_INDEFINITE, &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 |
                                         MOJO_HANDLE_SIGNAL_PEER_CLOSED);
@@ skipping 17 matching lines @@
   CHECK_GT(num_handles, 0);
 
   for (int i = 0; i < num_handles; ++i) {
     ScopedPlatformHandle h;
     CHECK_EQ(PassWrappedPlatformHandle(
                 handles[i], &h),
              MOJO_RESULT_OK);
     CHECK(h.is_valid());
     MojoClose(handles[i]);
 
-    base::ScopedFILE fp(test::FILEFromPlatformHandle(h.Pass(), "r"));
+    base::ScopedFILE fp(test::FILEFromPlatformHandle(std::move(h), "r"));
     CHECK(fp);
     std::string fread_buffer(100, '\0');
     size_t bytes_read =
         fread(&fread_buffer[0], 1, fread_buffer.size(), fp.get());
     fread_buffer.resize(bytes_read);
     CHECK_EQ(fread_buffer, "world");
   }
 
   return 0;
 }
 
 class MultiprocessMessagePipeTestWithPipeCount
     : public test::MultiprocessMessagePipeTestBase,
       public testing::WithParamInterface<size_t> {};
 
 TEST_P(MultiprocessMessagePipeTestWithPipeCount, PlatformHandlePassing) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   helper()->StartChild("CheckPlatformHandleFile");
-  ScopedMessagePipeHandle mp = CreateMessagePipe(
-      helper()->server_platform_handle.Pass());
+  ScopedMessagePipeHandle mp =
+      CreateMessagePipe(std::move(helper()->server_platform_handle));
 
   std::vector<MojoHandle> handles;
 
   size_t pipe_count = GetParam();
   for (size_t i = 0; i < pipe_count; ++i) {
     base::FilePath unused;
     base::ScopedFILE fp(
         CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
     const std::string world("world");
     CHECK_EQ(fwrite(&world[0], 1, world.size(), fp.get()), world.size());
     fflush(fp.get());
     rewind(fp.get());
     MojoHandle handle;
-    ASSERT_EQ(CreatePlatformHandleWrapper(
-                  ScopedPlatformHandle(test::PlatformHandleFromFILE(fp.Pass())),
-                  &handle),
-              MOJO_RESULT_OK);
+    ASSERT_EQ(
+        CreatePlatformHandleWrapper(
+            ScopedPlatformHandle(test::PlatformHandleFromFILE(std::move(fp))),
+            &handle),
+        MOJO_RESULT_OK);
     handles.push_back(handle);
   }
 
   char message[128];
   sprintf(message, "hello %d", static_cast<int>(pipe_count));
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoWriteMessage(mp.get().value(), message,
                              static_cast<uint32_t>(strlen(message)),
                              &handles[0], static_cast<uint32_t>(handles.size()),
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
@@ skipping 13 matching lines @@
 
 // Android multi-process tests are not executing the new process. This is flaky.
 #if !defined(OS_ANDROID)
 INSTANTIATE_TEST_CASE_P(PipeCount,
                         MultiprocessMessagePipeTestWithPipeCount,
                         testing::Values(1u, 128u, 140u));
 #endif
 
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckMessagePipe) {
   ScopedPlatformHandle client_platform_handle =
-      test::MultiprocessTestHelper::client_platform_handle.Pass();
+      std::move(test::MultiprocessTestHelper::client_platform_handle);
   CHECK(client_platform_handle.is_valid());
 
   ScopedMessagePipeHandle mp =
-      CreateMessagePipe(client_platform_handle.Pass());
+      CreateMessagePipe(std::move(client_platform_handle));
 
   // Wait for the first message from our parent.
   HandleSignalsState hss;
   CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
                MOJO_DEADLINE_INDEFINITE, &hss),
            MOJO_RESULT_OK);
   // In this test, the parent definitely doesn't close its end of the message
   // pipe before we do.
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
@@ skipping 42 matching lines @@
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_MessagePipePassing DISABLED_MessagePipePassing
 #else
 #define MAYBE_MessagePipePassing MessagePipePassing
 #endif
 TEST_F(MultiprocessMessagePipeTest, MAYBE_MessagePipePassing) {
   helper()->StartChild("CheckMessagePipe");
 
   ScopedMessagePipeHandle mp =
-      CreateMessagePipe(helper()->server_platform_handle.Pass());
+      CreateMessagePipe(std::move(helper()->server_platform_handle));
   MojoCreateSharedBufferOptions options;
   options.struct_size = sizeof(options);
   options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;
 
   MojoHandle mp1, mp2;
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoCreateMessagePipe(nullptr, &mp1, &mp2));
 
   // Write a string into one end of the new message pipe and send the other end.
   const std::string hello("hello");
@@ skipping 32 matching lines @@
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_MessagePipeTwoPassing DISABLED_MessagePipeTwoPassing
 #else
 #define MAYBE_MessagePipeTwoPassing MessagePipeTwoPassing
 #endif
 TEST_F(MultiprocessMessagePipeTest, MAYBE_MessagePipeTwoPassing) {
   helper()->StartChild("CheckMessagePipe");
 
   ScopedMessagePipeHandle mp =
-      CreateMessagePipe(helper()->server_platform_handle.Pass());
+      CreateMessagePipe(std::move(helper()->server_platform_handle));
 
   MojoHandle mp1, mp2;
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoCreateMessagePipe(nullptr, &mp2, &mp1));
 
   // Write a string into one end of the new message pipe and send the other end.
   const std::string hello("hello");
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoWriteMessage(mp1, &hello[0],
                              static_cast<uint32_t>(hello.size()), nullptr, 0u,
@@ skipping 19 matching lines @@
   read_buffer.resize(read_buffer_size);
   CHECK_EQ(read_buffer, std::string("world"));
 
   MojoClose(mp.release().value());
 
   ASSERT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(DataPipeConsumer) {
   ScopedPlatformHandle client_platform_handle =
-      test::MultiprocessTestHelper::client_platform_handle.Pass();
+      std::move(test::MultiprocessTestHelper::client_platform_handle);
   CHECK(client_platform_handle.is_valid());
 
   ScopedMessagePipeHandle mp =
-      CreateMessagePipe(client_platform_handle.Pass());
+      CreateMessagePipe(std::move(client_platform_handle));
 
   // Wait for the first message from our parent.
   HandleSignalsState hss;
   CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
                MOJO_DEADLINE_INDEFINITE, &hss),
            MOJO_RESULT_OK);
   // In this test, the parent definitely doesn't close its end of the message
   // pipe before we do.
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
@@ skipping 42 matching lines @@
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_DataPipeConsumer DISABLED_DataPipeConsumer
 #else
 #define MAYBE_DataPipeConsumer DataPipeConsumer
 #endif
 TEST_F(MultiprocessMessagePipeTest, MAYBE_DataPipeConsumer) {
   helper()->StartChild("DataPipeConsumer");
 
   ScopedMessagePipeHandle mp =
-      CreateMessagePipe(helper()->server_platform_handle.Pass());
+      CreateMessagePipe(std::move(helper()->server_platform_handle));
   MojoCreateSharedBufferOptions options;
   options.struct_size = sizeof(options);
   options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;
 
   MojoHandle mp1, mp2;
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoCreateMessagePipe(nullptr, &mp2, &mp1));
 
   // Write a string into one end of the new message pipe and send the other end.
   const std::string hello("hello");
@@ skipping 24 matching lines @@
 
   MojoClose(mp1);
   MojoClose(mp.release().value());
 
   ASSERT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo