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

mojo/edk/system/raw_channel_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/system/raw_channel.h"
 
 #include <stdint.h>
 #include <stdio.h>
 
 #include <memory>
@@ skipping 13 matching lines @@
 #include "mojo/edk/system/test/test_io_thread.h"
 #include "mojo/edk/system/transport_data.h"
 #include "mojo/edk/test/test_utils.h"
 #include "mojo/edk/util/make_unique.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/scoped_file.h"
 #include "mojo/edk/util/waitable_event.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using mojo::embedder::ScopedPlatformHandle;
 using mojo::util::AutoResetWaitableEvent;
+using mojo::util::MakeUnique;
 using mojo::util::Mutex;
 using mojo::util::MutexLocker;
 
 namespace mojo {
 namespace system {
 namespace {
 
 std::unique_ptr<MessageInTransit> MakeTestMessage(uint32_t num_bytes) {
   std::vector<unsigned char> bytes(num_bytes, 0);
   for (size_t i = 0; i < num_bytes; i++)
@@ skipping 43 matching lines @@
 
   void TearDown() override {
     io_thread_.Stop();
     handles[0].reset();
     handles[1].reset();
   }
 
  protected:
   test::TestIOThread* io_thread() { return &io_thread_; }
 
-  embedder::ScopedPlatformHandle handles[2];
+  ScopedPlatformHandle handles[2];
 
  private:
   test::TestIOThread io_thread_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannelTest);
 };
 
 // RawChannelTest.WriteMessage -------------------------------------------------
 
 class WriteOnlyRawChannelDelegate : public RawChannel::Delegate {
  public:
   WriteOnlyRawChannelDelegate() {}
   ~WriteOnlyRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation:
-  void OnReadMessage(
-      const MessageInTransit::View& /*message_view*/,
-      embedder::ScopedPlatformHandleVectorPtr /*platform_handles*/) override {
+  void OnReadMessage(const MessageInTransit::View& /*message_view*/,
+                     std::unique_ptr<std::vector<ScopedPlatformHandle>>
+                     /*platform_handles*/) override {
     CHECK(false);  // Should not get called.
   }
   void OnError(Error error) override {
     // We'll get a read (shutdown) error when the connection is closed.
     CHECK_EQ(error, ERROR_READ_SHUTDOWN);
   }
 
  private:
   MOJO_DISALLOW_COPY_AND_ASSIGN(WriteOnlyRawChannelDelegate);
 };
@@ skipping 90 matching lines @@
 }
 
 // RawChannelTest.OnReadMessage ------------------------------------------------
 
 class ReadCheckerRawChannelDelegate : public RawChannel::Delegate {
  public:
   ReadCheckerRawChannelDelegate() : position_(0) {}
   ~ReadCheckerRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
-  void OnReadMessage(
-      const MessageInTransit::View& message_view,
-      embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
+  void OnReadMessage(const MessageInTransit::View& message_view,
+                     std::unique_ptr<std::vector<ScopedPlatformHandle>>
+                         platform_handles) override {
     EXPECT_FALSE(platform_handles);
 
     size_t position;
     size_t expected_size;
     bool should_signal = false;
     {
       MutexLocker locker(&mutex_);
       CHECK_LT(position_, expected_sizes_.size());
       position = position_;
       expected_size = expected_sizes_[position];
@@ skipping 92 matching lines @@
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannelWriterThread);
 };
 
 class ReadCountdownRawChannelDelegate : public RawChannel::Delegate {
  public:
   explicit ReadCountdownRawChannelDelegate(size_t expected_count)
       : expected_count_(expected_count), count_(0) {}
   ~ReadCountdownRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
-  void OnReadMessage(
-      const MessageInTransit::View& message_view,
-      embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
+  void OnReadMessage(const MessageInTransit::View& message_view,
+                     std::unique_ptr<std::vector<ScopedPlatformHandle>>
+                         platform_handles) override {
     EXPECT_FALSE(platform_handles);
 
     EXPECT_LT(count_, expected_count_);
     count_++;
 
     EXPECT_TRUE(
         CheckMessageData(message_view.bytes(), message_view.num_bytes()));
 
     if (count_ >= expected_count_)
       done_event_.Signal();
@@ skipping 191 matching lines @@
 class ShutdownOnReadMessageRawChannelDelegate : public RawChannel::Delegate {
  public:
   explicit ShutdownOnReadMessageRawChannelDelegate(RawChannel* raw_channel,
                                                    bool should_destroy)
       : raw_channel_(raw_channel),
         should_destroy_(should_destroy),
         did_shutdown_(false) {}
   ~ShutdownOnReadMessageRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
-  void OnReadMessage(
-      const MessageInTransit::View& message_view,
-      embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
+  void OnReadMessage(const MessageInTransit::View& message_view,
+                     std::unique_ptr<std::vector<ScopedPlatformHandle>>
+                         platform_handles) override {
     EXPECT_FALSE(platform_handles);
     EXPECT_FALSE(did_shutdown_);
     EXPECT_TRUE(
         CheckMessageData(message_view.bytes(), message_view.num_bytes()));
     raw_channel_->Shutdown();
     if (should_destroy_)
       delete raw_channel_;
     did_shutdown_ = true;
     done_event_.Signal();
   }
@@ skipping 53 matching lines @@
                                     Error shutdown_on_error_type)
       : raw_channel_(raw_channel),
         should_destroy_(should_destroy),
         shutdown_on_error_type_(shutdown_on_error_type),
         did_shutdown_(false) {}
   ~ShutdownOnErrorRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   void OnReadMessage(
       const MessageInTransit::View& /*message_view*/,
-      embedder::ScopedPlatformHandleVectorPtr /*platform_handles*/) override {
+      std::unique_ptr<std::vector<ScopedPlatformHandle>> /*platform_handles*/)
+      override {
     CHECK(false);  // Should not get called.
   }
   void OnError(Error error) override {
     EXPECT_FALSE(did_shutdown_);
     if (error != shutdown_on_error_type_)
       return;
     raw_channel_->Shutdown();
     if (should_destroy_)
       delete raw_channel_;
     did_shutdown_ = true;
@@ skipping 78 matching lines @@
 
 // RawChannelTest.ReadWritePlatformHandles -------------------------------------
 
 class ReadPlatformHandlesCheckerRawChannelDelegate
     : public RawChannel::Delegate {
  public:
   ReadPlatformHandlesCheckerRawChannelDelegate() {}
   ~ReadPlatformHandlesCheckerRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
-  void OnReadMessage(
-      const MessageInTransit::View& message_view,
-      embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
+  void OnReadMessage(const MessageInTransit::View& message_view,
+                     std::unique_ptr<std::vector<ScopedPlatformHandle>>
+                         platform_handles) override {
     const char kHello[] = "hello";
 
     EXPECT_EQ(sizeof(kHello), message_view.num_bytes());
     EXPECT_STREQ(kHello, static_cast<const char*>(message_view.bytes()));
 
     ASSERT_TRUE(platform_handles);
     ASSERT_EQ(2u, platform_handles->size());
-    embedder::ScopedPlatformHandle h1(platform_handles->at(0));
+    ScopedPlatformHandle h1(std::move(platform_handles->at(0)));
     EXPECT_TRUE(h1.is_valid());
-    embedder::ScopedPlatformHandle h2(platform_handles->at(1));
+    ScopedPlatformHandle h2(std::move(platform_handles->at(1)));
     EXPECT_TRUE(h2.is_valid());
     platform_handles->clear();
 
     {
       char buffer[100] = {};
 
       util::ScopedFILE fp(mojo::test::FILEFromPlatformHandle(h1.Pass(), "rb"));
       EXPECT_TRUE(fp);
       rewind(fp.get());
       EXPECT_EQ(1u, fread(buffer, 1, sizeof(buffer), fp.get()));
@@ skipping 37 matching lines @@
   io_thread()->PostTaskAndWait(base::Bind(&InitOnIOThread, rc_read.get(),
                                           base::Unretained(&read_delegate)));
 
   util::ScopedFILE fp1(test_dir.CreateFile());
   EXPECT_EQ(1u, fwrite("1", 1, 1, fp1.get()));
   util::ScopedFILE fp2(test_dir.CreateFile());
   EXPECT_EQ(1u, fwrite("2", 1, 1, fp2.get()));
 
   {
     const char kHello[] = "hello";
-    embedder::ScopedPlatformHandleVectorPtr platform_handles(
-        new embedder::PlatformHandleVector());
+    auto platform_handles = MakeUnique<std::vector<ScopedPlatformHandle>>();
     platform_handles->push_back(
-        mojo::test::PlatformHandleFromFILE(std::move(fp1)).release());
+        mojo::test::PlatformHandleFromFILE(std::move(fp1)));
     platform_handles->push_back(
-        mojo::test::PlatformHandleFromFILE(std::move(fp2)).release());
+        mojo::test::PlatformHandleFromFILE(std::move(fp2)));
 
     std::unique_ptr<MessageInTransit> message(
         new MessageInTransit(MessageInTransit::Type::ENDPOINT_CLIENT,
                              MessageInTransit::Subtype::ENDPOINT_CLIENT_DATA,
                              sizeof(kHello), kHello));
     message->SetTransportData(util::MakeUnique<TransportData>(
         std::move(platform_handles),
         rc_write->GetSerializedPlatformHandleSize()));
     EXPECT_TRUE(rc_write->WriteMessage(std::move(message)));
   }
 
   read_delegate.Wait();
 
   io_thread()->PostTaskAndWait(
       base::Bind(&RawChannel::Shutdown, base::Unretained(rc_read.get())));
   io_thread()->PostTaskAndWait(
       base::Bind(&RawChannel::Shutdown, base::Unretained(rc_write.get())));
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo