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

mojo/edk/embedder/platform_channel_pair_posix_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 "mojo/edk/embedder/platform_channel_pair.h"
 
 #include <errno.h>
 #include <poll.h>
 #include <signal.h>
 #include <stdio.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
-
 #include <deque>
+#include <utility>
 
 #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/logging.h"
 #include "mojo/edk/embedder/platform_channel_utils_posix.h"
 #include "mojo/edk/embedder/platform_handle.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
@@ skipping 30 matching lines @@
   }
 
  private:
   struct sigaction old_action_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(PlatformChannelPairPosixTest);
 };
 
 TEST_F(PlatformChannelPairPosixTest, NoSigPipe) {
   PlatformChannelPair channel_pair;
-  ScopedPlatformHandle server_handle = channel_pair.PassServerHandle().Pass();
-  ScopedPlatformHandle client_handle = channel_pair.PassClientHandle().Pass();
+  ScopedPlatformHandle server_handle = channel_pair.PassServerHandle();
+  ScopedPlatformHandle client_handle = channel_pair.PassClientHandle();
 
   // Write to the client.
   static const char kHello[] = "hello";
   EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
             write(client_handle.get().handle, kHello, sizeof(kHello)));
 
   // Close the client.
   client_handle.reset();
 
   // Read from the server; this should be okay.
@@ skipping 19 matching lines @@
   struct iovec iov[2] = {{const_cast<char*>(kHello), sizeof(kHello)},
                          {const_cast<char*>(kHello), sizeof(kHello)}};
   result = PlatformChannelWritev(server_handle.get(), iov, 2);
   EXPECT_EQ(-1, result);
   if (errno != EPIPE)
     PLOG(WARNING) << "write (expected EPIPE)";
 }
 
 TEST_F(PlatformChannelPairPosixTest, SendReceiveData) {
   PlatformChannelPair channel_pair;
-  ScopedPlatformHandle server_handle = channel_pair.PassServerHandle().Pass();
-  ScopedPlatformHandle client_handle = channel_pair.PassClientHandle().Pass();
+  ScopedPlatformHandle server_handle = channel_pair.PassServerHandle();
+  ScopedPlatformHandle client_handle = channel_pair.PassClientHandle();
 
   for (size_t i = 0; i < 10; i++) {
     std::string send_string(1 << i, 'A' + i);
 
     EXPECT_EQ(static_cast<ssize_t>(send_string.size()),
               PlatformChannelWrite(server_handle.get(), send_string.data(),
                                    send_string.size()));
 
     WaitReadable(client_handle.get());
 
     char buf[10000] = {};
     std::deque<PlatformHandle> received_handles;
     ssize_t result = PlatformChannelRecvmsg(client_handle.get(), buf,
                                             sizeof(buf), &received_handles);
     EXPECT_EQ(static_cast<ssize_t>(send_string.size()), result);
     EXPECT_EQ(send_string, std::string(buf, static_cast<size_t>(result)));
     EXPECT_TRUE(received_handles.empty());
   }
 }
 
 TEST_F(PlatformChannelPairPosixTest, SendReceiveFDs) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   static const char kHello[] = "hello";
 
   PlatformChannelPair channel_pair;
-  ScopedPlatformHandle server_handle = channel_pair.PassServerHandle().Pass();
-  ScopedPlatformHandle client_handle = channel_pair.PassClientHandle().Pass();
+  ScopedPlatformHandle server_handle = channel_pair.PassServerHandle();
+  ScopedPlatformHandle client_handle = channel_pair.PassClientHandle();
 
 // Reduce the number of FDs opened on OS X to avoid test flake.
 #if defined(OS_MACOSX)
   const size_t kNumHandlesToSend = kPlatformChannelMaxNumHandles / 2;
 #else
   const size_t kNumHandlesToSend = kPlatformChannelMaxNumHandles;
 #endif
 
   for (size_t i = 1; i < kNumHandlesToSend; i++) {
     // Make |i| files, with the j-th file consisting of j copies of the digit
     // |c|.
     const char c = '0' + (i % 10);
     ScopedPlatformHandleVectorPtr platform_handles(new PlatformHandleVector);
     for (size_t j = 1; j <= i; j++) {
       base::FilePath unused;
       base::ScopedFILE fp(
           base::CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
       ASSERT_TRUE(fp);
       ASSERT_EQ(j, fwrite(std::string(j, c).data(), 1, j, fp.get()));
       platform_handles->push_back(
-          test::PlatformHandleFromFILE(fp.Pass()).release());
+          test::PlatformHandleFromFILE(std::move(fp)).release());
       ASSERT_TRUE(platform_handles->back().is_valid());
     }
 
     // Send the FDs (+ "hello").
     struct iovec iov = {const_cast<char*>(kHello), sizeof(kHello)};
     // We assume that the |sendmsg()| actually sends all the data.
     EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
               PlatformChannelSendmsgWithHandles(server_handle.get(), &iov, 1,
                                                 &platform_handles->at(0),
                                                 platform_handles->size()));
@@ skipping 23 matching lines @@
   }
 }
 
 TEST_F(PlatformChannelPairPosixTest, AppendReceivedFDs) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   static const char kHello[] = "hello";
 
   PlatformChannelPair channel_pair;
-  ScopedPlatformHandle server_handle = channel_pair.PassServerHandle().Pass();
-  ScopedPlatformHandle client_handle = channel_pair.PassClientHandle().Pass();
+  ScopedPlatformHandle server_handle = channel_pair.PassServerHandle();
+  ScopedPlatformHandle client_handle = channel_pair.PassClientHandle();
 
   const std::string file_contents("hello world");
 
   {
     base::FilePath unused;
     base::ScopedFILE fp(
         base::CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
     ASSERT_TRUE(fp);
     ASSERT_EQ(file_contents.size(),
               fwrite(file_contents.data(), 1, file_contents.size(), fp.get()));
     ScopedPlatformHandleVectorPtr platform_handles(new PlatformHandleVector);
     platform_handles->push_back(
-        test::PlatformHandleFromFILE(fp.Pass()).release());
+        test::PlatformHandleFromFILE(std::move(fp)).release());
     ASSERT_TRUE(platform_handles->back().is_valid());
 
     // Send the FD (+ "hello").
     struct iovec iov = {const_cast<char*>(kHello), sizeof(kHello)};
     // We assume that the |sendmsg()| actually sends all the data.
     EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
               PlatformChannelSendmsgWithHandles(server_handle.get(), &iov, 1,
                                                 &platform_handles->at(0),
                                                 platform_handles->size()));
   }
@@ skipping 23 matching lines @@
     char read_buf[100];
     size_t bytes_read = fread(read_buf, 1, sizeof(read_buf), fp.get());
     EXPECT_EQ(file_contents.size(), bytes_read);
     EXPECT_EQ(file_contents, std::string(read_buf, bytes_read));
   }
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo