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

mojo/edk/system/master_connection_manager.cc

 // Copyright 2015 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/master_connection_manager.h"
 
 #include <memory>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/platform_channel_pair.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/connection_manager_messages.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/system/transport_data.h"
 #include "mojo/edk/util/make_unique.h"
 #include "mojo/edk/util/waitable_event.h"
 #include "mojo/public/cpp/system/macros.h"
 
+using mojo::embedder::ScopedPlatformHandle;
 using mojo::platform::TaskRunner;
 using mojo::util::AutoResetWaitableEvent;
+using mojo::util::MakeUnique;
 using mojo::util::MutexLocker;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 const ProcessIdentifier kFirstSlaveProcessIdentifier = 2;
 
@@ skipping 37 matching lines @@
          ProcessIdentifier process_identifier,
          embedder::SlaveInfo slave_info,
          embedder::ScopedPlatformHandle platform_handle);
   ~Helper() override;
 
   void Init();
   embedder::SlaveInfo Shutdown();
 
  private:
   // |RawChannel::Delegate| methods:
-  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;
   void OnError(Error error) override;
 
   // Handles an error that's fatal to this object. Note that this probably
   // results in |Shutdown()| being called (in the nested context) and then this
   // object being destroyed.
   void FatalError();
 
   MasterConnectionManager* const owner_;
   const ProcessIdentifier process_identifier_;
   embedder::SlaveInfo const slave_info_;
@@ skipping 22 matching lines @@
 }
 
 embedder::SlaveInfo MasterConnectionManager::Helper::Shutdown() {
   raw_channel_->Shutdown();
   raw_channel_.reset();
   return slave_info_;
 }
 
 void MasterConnectionManager::Helper::OnReadMessage(
     const MessageInTransit::View& message_view,
-    embedder::ScopedPlatformHandleVectorPtr platform_handles) {
+    std::unique_ptr<std::vector<ScopedPlatformHandle>> platform_handles) {
   if (message_view.type() != MessageInTransit::Type::CONNECTION_MANAGER) {
     LOG(ERROR) << "Invalid message type " << message_view.type();
     FatalError();  // WARNING: This destroys us.
     return;
   }
 
   // Currently, all the messages simply have a |ConnectionIdentifier| as data.
   if (message_view.num_bytes() != sizeof(ConnectionIdentifier)) {
     LOG(ERROR) << "Invalid message size " << message_view.num_bytes();
     FatalError();  // WARNING: This destroys us.
@@ skipping 49 matching lines @@
 
   std::unique_ptr<MessageInTransit> response(new MessageInTransit(
       MessageInTransit::Type::CONNECTION_MANAGER_ACK,
       ConnectionManagerResultToMessageInTransitSubtype(result), num_bytes,
       bytes));
 
   if (result == Result::SUCCESS_CONNECT_NEW_CONNECTION) {
     DCHECK_EQ(message_view.subtype(),
               MessageInTransit::Subtype::CONNECTION_MANAGER_CONNECT);
     DCHECK(platform_handle.is_valid());
-    embedder::ScopedPlatformHandleVectorPtr platform_handles(
-        new embedder::PlatformHandleVector());
-    platform_handles->push_back(platform_handle.release());
+    auto platform_handles = MakeUnique<std::vector<ScopedPlatformHandle>>();
+    platform_handles->push_back(std::move(platform_handle));
     response->SetTransportData(util::MakeUnique<TransportData>(
         std::move(platform_handles),
         raw_channel_->GetSerializedPlatformHandleSize()));
   } else {
     DCHECK(!platform_handle.is_valid());
   }
 
   if (!raw_channel_->WriteMessage(std::move(response))) {
     LOG(ERROR) << "WriteMessage failed";
     FatalError();  // WARNING: This destroys us.
@@ skipping 95 matching lines @@
     } else if (status == ConnectionStatus::PENDING) {
       DCHECK(pending_platform_handle.is_valid());
       process_connections_[to_process_identifier] =
           pending_platform_handle.release();
     } else {
       NOTREACHED();
     }
   }
 
  private:
+  // TODO(vtl): Make |second| |ScopedPlatformHandle|s.
   std::unordered_map<ProcessIdentifier, embedder::PlatformHandle>
       process_connections_;  // "Owns" any valid platform handles.
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ProcessConnections);
 };
 
 // MasterConnectionManager -----------------------------------------------------
 
 MasterConnectionManager::MasterConnectionManager(
     embedder::PlatformSupport* platform_support)
@@ skipping 412 matching lines @@
 }
 
 void MasterConnectionManager::AssertOnPrivateThread() const {
   // This should only be called after |Init()| and before |Shutdown()|.
   DCHECK(private_thread_.message_loop());
   DCHECK_EQ(base::MessageLoop::current(), private_thread_.message_loop());
 }
 
 }  // namespace system
 }  // namespace mojo