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

mojo/edk/system/raw_channel_posix.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 "mojo/edk/system/raw_channel.h"
 
 #include <errno.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <deque>
+#include <iterator>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/platform_channel_utils.h"
 #include "mojo/edk/embedder/platform_handle.h"
-#include "mojo/edk/embedder/platform_handle_vector.h"
+#include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/transport_data.h"
 #include "mojo/edk/util/make_unique.h"
 #include "mojo/public/cpp/system/macros.h"
 
+using mojo::embedder::ScopedPlatformHandle;
+using mojo::util::MakeUnique;
 using mojo::util::MutexLocker;
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 class RawChannelPosix final : public RawChannel,
                               public base::MessageLoopForIO::Watcher {
  public:
   explicit RawChannelPosix(embedder::ScopedPlatformHandle handle);
   ~RawChannelPosix() override;
 
   // |RawChannel| public methods:
   size_t GetSerializedPlatformHandleSize() const override;
 
  private:
   // |RawChannel| protected methods:
   // Actually override this so that we can send multiple messages with (only)
   // FDs if necessary.
   void EnqueueMessageNoLock(std::unique_ptr<MessageInTransit> message) override
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(write_mutex());
   // Override this to handle those extra FD-only messages.
   bool OnReadMessageForRawChannel(
       const MessageInTransit::View& message_view) override;
   IOResult Read(size_t* bytes_read) override;
   IOResult ScheduleRead() override;
-  embedder::ScopedPlatformHandleVectorPtr GetReadPlatformHandles(
+  std::unique_ptr<std::vector<ScopedPlatformHandle>> GetReadPlatformHandles(
       size_t num_platform_handles,
       const void* platform_handle_table) override;
   IOResult WriteNoLock(size_t* platform_handles_written,
                        size_t* bytes_written) override;
   IOResult ScheduleWriteNoLock() override;
   void OnInit() override;
   void OnShutdownNoLock(std::unique_ptr<ReadBuffer> read_buffer,
                         std::unique_ptr<WriteBuffer> write_buffer) override;
 
   // |base::MessageLoopForIO::Watcher| implementation:
   void OnFileCanReadWithoutBlocking(int fd) override;
   void OnFileCanWriteWithoutBlocking(int fd) override;
 
   // Implements most of |Read()| (except for a bit of clean-up):
   IOResult ReadImpl(size_t* bytes_read);
 
   // Watches for |fd_| to become writable. Must be called on the I/O thread.
   void WaitToWrite();
 
   embedder::ScopedPlatformHandle fd_;
 
   // The following members are only used on the I/O thread:
   std::unique_ptr<base::MessageLoopForIO::FileDescriptorWatcher> read_watcher_;
   std::unique_ptr<base::MessageLoopForIO::FileDescriptorWatcher> write_watcher_;
 
   bool pending_read_;
 
-  std::deque<embedder::PlatformHandle> read_platform_handles_;
+  std::deque<embedder::ScopedPlatformHandle> read_platform_handles_;
 
   bool pending_write_ MOJO_GUARDED_BY(write_mutex());
 
   // This is used for posting tasks from write threads to the I/O thread. The
   // weak pointers it produces are only used/invalidated on the I/O thread.
   base::WeakPtrFactory<RawChannelPosix> weak_ptr_factory_
       MOJO_GUARDED_BY(write_mutex());
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannelPosix);
 };
@@ skipping 11 matching lines @@
   DCHECK(!pending_write_);
 
   // No need to take |write_mutex()| here -- if there are still weak pointers
   // outstanding, then we're hosed anyway (since we wouldn't be able to
   // invalidate them cleanly, since we might not be on the I/O thread).
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
 
   // These must have been shut down/destroyed on the I/O thread.
   DCHECK(!read_watcher_);
   DCHECK(!write_watcher_);
-
-  embedder::CloseAllPlatformHandles(&read_platform_handles_);
 }
 
 size_t RawChannelPosix::GetSerializedPlatformHandleSize() const {
   // We don't actually need any space on POSIX (since we just send FDs).
   return 0;
 }
 
 void RawChannelPosix::EnqueueMessageNoLock(
     std::unique_ptr<MessageInTransit> message) {
   if (message->transport_data()) {
-    embedder::PlatformHandleVector* const platform_handles =
+    std::vector<ScopedPlatformHandle>* const platform_handles =
         message->transport_data()->platform_handles();
     if (platform_handles &&
         platform_handles->size() > embedder::kPlatformChannelMaxNumHandles) {
       // We can't attach all the FDs to a single message, so we have to "split"
       // the message. Send as many control messages as needed first with FDs
       // attached (and no data).
       size_t i = 0;
       for (; platform_handles->size() - i >
                  embedder::kPlatformChannelMaxNumHandles;
            i += embedder::kPlatformChannelMaxNumHandles) {
         std::unique_ptr<MessageInTransit> fd_message(new MessageInTransit(
             MessageInTransit::Type::RAW_CHANNEL,
             MessageInTransit::Subtype::RAW_CHANNEL_POSIX_EXTRA_PLATFORM_HANDLES,
             0, nullptr));
-        embedder::ScopedPlatformHandleVectorPtr fds(
-            new embedder::PlatformHandleVector(
-                platform_handles->begin() + i,
-                platform_handles->begin() + i +
-                    embedder::kPlatformChannelMaxNumHandles));
+        using IteratorType = std::vector<ScopedPlatformHandle>::iterator;
+        std::unique_ptr<std::vector<ScopedPlatformHandle>> fds(
+            MakeUnique<std::vector<ScopedPlatformHandle>>(
+                std::move_iterator<IteratorType>(platform_handles->begin() + i),
+                std::move_iterator<IteratorType>(
+                    platform_handles->begin() + i +
+                    embedder::kPlatformChannelMaxNumHandles)));
         fd_message->SetTransportData(util::MakeUnique<TransportData>(
             std::move(fds), GetSerializedPlatformHandleSize()));
         RawChannel::EnqueueMessageNoLock(std::move(fd_message));
       }
 
       // Remove the handles that we "moved" into the other messages.
       platform_handles->erase(platform_handles->begin(),
                               platform_handles->begin() + i);
     }
   }
@@ skipping 29 matching lines @@
 
 RawChannel::IOResult RawChannelPosix::ScheduleRead() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
   DCHECK(!pending_read_);
 
   pending_read_ = true;
 
   return IO_PENDING;
 }
 
-embedder::ScopedPlatformHandleVectorPtr RawChannelPosix::GetReadPlatformHandles(
-    size_t num_platform_handles,
-    const void* /*platform_handle_table*/) {
+std::unique_ptr<std::vector<ScopedPlatformHandle>>
+RawChannelPosix::GetReadPlatformHandles(size_t num_platform_handles,
+                                        const void* /*platform_handle_table*/) {
   DCHECK_GT(num_platform_handles, 0u);
 
   if (read_platform_handles_.size() < num_platform_handles) {
-    embedder::CloseAllPlatformHandles(&read_platform_handles_);
     read_platform_handles_.clear();
-    return embedder::ScopedPlatformHandleVectorPtr();
+    return nullptr;
   }
 
-  embedder::ScopedPlatformHandleVectorPtr rv(
-      new embedder::PlatformHandleVector(num_platform_handles));
-  rv->assign(read_platform_handles_.begin(),
-             read_platform_handles_.begin() + num_platform_handles);
+  auto rv = MakeUnique<std::vector<ScopedPlatformHandle>>(num_platform_handles);
+  using IteratorType = std::deque<ScopedPlatformHandle>::iterator;
+  rv->assign(std::move_iterator<IteratorType>(read_platform_handles_.begin()),
+             std::move_iterator<IteratorType>(read_platform_handles_.begin() +
+                                              num_platform_handles));
   read_platform_handles_.erase(
       read_platform_handles_.begin(),
       read_platform_handles_.begin() + num_platform_handles);
   return rv;
 }
 
 RawChannel::IOResult RawChannelPosix::WriteNoLock(
     size_t* platform_handles_written,
     size_t* bytes_written) {
   write_mutex().AssertHeld();
@@ skipping 194 matching lines @@
 
     // We should never accumulate more than |TransportData::kMaxPlatformHandles
     // + embedder::kPlatformChannelMaxNumHandles| handles. (The latter part is
     // possible because we could have accumulated all the handles for a message,
     // then received the message data plus the first set of handles for the next
     // message in the subsequent |recvmsg()|.)
     if (read_platform_handles_.size() >
         (TransportData::GetMaxPlatformHandles() +
          embedder::kPlatformChannelMaxNumHandles)) {
       LOG(ERROR) << "Received too many platform handles";
-      embedder::CloseAllPlatformHandles(&read_platform_handles_);
       read_platform_handles_.clear();
       return IO_FAILED_UNKNOWN;
     }
   }
 
   if (read_result > 0) {
     *bytes_read = static_cast<size_t>(read_result);
     return IO_SUCCEEDED;
   }
 
@@ skipping 36 matching lines @@
 
 // Static factory method declared in raw_channel.h.
 // static
 std::unique_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return util::MakeUnique<RawChannelPosix>(handle.Pass());
 }
 
 }  // namespace system
 }  // namespace mojo