EDK: Convert most uses of PlatformHandleVector to std::vector<ScopedPlatformHandle>.

mojo/edk/embedder/platform_channel_pair_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>
@@ skipping 100 matching lines @@
   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;
+    std::deque<ScopedPlatformHandle> 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(PlatformChannelPairTest, SendReceiveFDs) {
   mojo::system::test::ScopedTestDir test_dir;
@@ skipping 29 matching lines @@
     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()));
 
     WaitReadable(client_handle.get());
 
     char buf[10000] = {};
-    std::deque<PlatformHandle> received_handles;
+    std::deque<ScopedPlatformHandle> received_handles;
     // We assume that the |recvmsg()| actually reads all the data.
     EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
               PlatformChannelRecvmsg(client_handle.get(), buf, sizeof(buf),
                                      &received_handles));
     EXPECT_STREQ(kHello, buf);
     EXPECT_EQ(i, received_handles.size());
 
     for (size_t j = 0; !received_handles.empty(); j++) {
       util::ScopedFILE fp(test::FILEFromPlatformHandle(
-          ScopedPlatformHandle(received_handles.front()), "rb"));
+          std::move(received_handles.front()), "rb"));
       received_handles.pop_front();
       ASSERT_TRUE(fp);
       rewind(fp.get());
       char read_buf[kNumHandlesToSend];
       size_t bytes_read = fread(read_buf, 1, sizeof(read_buf), fp.get());
       EXPECT_EQ(j + 1, bytes_read);
       EXPECT_EQ(std::string(j + 1, c), std::string(read_buf, bytes_read));
     }
   }
 }
@@ skipping 24 matching lines @@
     // 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()));
   }
 
   WaitReadable(client_handle.get());
 
   // Start with an invalid handle in the deque.
-  std::deque<PlatformHandle> received_handles;
-  received_handles.push_back(PlatformHandle());
+  std::deque<ScopedPlatformHandle> received_handles;
+  received_handles.push_back(ScopedPlatformHandle());
 
   char buf[100] = {};
   // We assume that the |recvmsg()| actually reads all the data.
   EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
             PlatformChannelRecvmsg(client_handle.get(), buf, sizeof(buf),
                                    &received_handles));
   EXPECT_STREQ(kHello, buf);
   ASSERT_EQ(2u, received_handles.size());
   EXPECT_FALSE(received_handles[0].is_valid());
   EXPECT_TRUE(received_handles[1].is_valid());
 
   {
-    util::ScopedFILE fp(test::FILEFromPlatformHandle(
-        ScopedPlatformHandle(received_handles[1]), "rb"));
-    received_handles[1] = PlatformHandle();
+    util::ScopedFILE fp(
+        test::FILEFromPlatformHandle(std::move(received_handles[1]), "rb"));
     ASSERT_TRUE(fp);
     rewind(fp.get());
     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 embedder
 }  // namespace mojo