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

mojo/edk/system/slave_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/slave_connection_manager.h"
 
 #include <utility>
 
 #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/system/connection_manager_messages.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/util/make_unique.h"
 
+using mojo::embedder::ScopedPlatformHandle;
 using mojo::platform::TaskRunner;
 using mojo::util::MutexLocker;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 
 // SlaveConnectionManager ------------------------------------------------------
 
 SlaveConnectionManager::SlaveConnectionManager(
@@ skipping 14 matching lines @@
   DCHECK_EQ(awaiting_ack_type_, NOT_AWAITING_ACK);
   DCHECK(!ack_result_);
   DCHECK(!ack_peer_process_identifier_);
   DCHECK(!ack_is_first_);
   DCHECK(!ack_platform_handle_);
 }
 
 void SlaveConnectionManager::Init(
     RefPtr<TaskRunner>&& delegate_thread_task_runner,
     embedder::SlaveProcessDelegate* slave_process_delegate,
-    embedder::ScopedPlatformHandle platform_handle) {
+    ScopedPlatformHandle platform_handle) {
   DCHECK(delegate_thread_task_runner);
   DCHECK(slave_process_delegate);
   DCHECK(platform_handle.is_valid());
   DCHECK(!delegate_thread_task_runner_);
   DCHECK(!slave_process_delegate_);
   DCHECK(!private_thread_.message_loop());
 
   delegate_thread_task_runner_ = std::move(delegate_thread_task_runner);
   slave_process_delegate_ = slave_process_delegate;
   CHECK(private_thread_.StartWithOptions(
@@ skipping 46 matching lines @@
                  base::Unretained(this), connection_id, &result));
   event_.Wait();
   DCHECK(result == Result::FAILURE || result == Result::SUCCESS);
   return result == Result::SUCCESS;
 }
 
 ConnectionManager::Result SlaveConnectionManager::Connect(
     const ConnectionIdentifier& connection_id,
     ProcessIdentifier* peer_process_identifier,
     bool* is_first,
-    embedder::ScopedPlatformHandle* platform_handle) {
+    ScopedPlatformHandle* platform_handle) {
   AssertNotOnPrivateThread();
   DCHECK(peer_process_identifier);
   DCHECK(is_first);
   DCHECK(platform_handle);
   DCHECK(!platform_handle->is_valid());  // Not technically wrong, but unlikely.
 
   MutexLocker locker(&mutex_);
   Result result = Result::FAILURE;
   private_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&SlaveConnectionManager::ConnectOnPrivateThread,
                  base::Unretained(this), connection_id, &result,
                  peer_process_identifier, is_first, platform_handle));
   event_.Wait();
   return result;
 }
 
 void SlaveConnectionManager::InitOnPrivateThread(
-    embedder::ScopedPlatformHandle platform_handle) {
+    ScopedPlatformHandle platform_handle) {
   AssertOnPrivateThread();
 
   raw_channel_ = RawChannel::Create(platform_handle.Pass());
   raw_channel_->Init(this);
   event_.Signal();
 }
 
 void SlaveConnectionManager::ShutdownOnPrivateThread() {
   AssertOnPrivateThread();
 
@@ skipping 52 matching lines @@
   }
   awaiting_ack_type_ = AWAITING_CANCEL_CONNECT_ACK;
   ack_result_ = result;
 }
 
 void SlaveConnectionManager::ConnectOnPrivateThread(
     const ConnectionIdentifier& connection_id,
     Result* result,
     ProcessIdentifier* peer_process_identifier,
     bool* is_first,
-    embedder::ScopedPlatformHandle* platform_handle) {
+    ScopedPlatformHandle* platform_handle) {
   DCHECK(result);
   AssertOnPrivateThread();
   // This should only posted (from another thread, to |private_thread_|) with
   // the lock held (until this thread triggers |event_|).
   DCHECK(!mutex_.TryLock());
   DCHECK_EQ(awaiting_ack_type_, NOT_AWAITING_ACK);
 
   DVLOG(1) << "Sending Connect: connection ID " << connection_id.ToString();
   if (!raw_channel_->WriteMessage(util::MakeUnique<MessageInTransit>(
           MessageInTransit::Type::CONNECTION_MANAGER,
           MessageInTransit::Subtype::CONNECTION_MANAGER_CONNECT,
           sizeof(connection_id), &connection_id))) {
     // Don't tear things down; possibly we'll still read some messages.
     *result = Result::FAILURE;
     platform_handle->reset();
     event_.Signal();
     return;
   }
   awaiting_ack_type_ = AWAITING_CONNECT_ACK;
   ack_result_ = result;
   ack_peer_process_identifier_ = peer_process_identifier;
   ack_is_first_ = is_first;
   ack_platform_handle_ = platform_handle;
 }
 
 void SlaveConnectionManager::OnReadMessage(
     const MessageInTransit::View& message_view,
-    embedder::ScopedPlatformHandleVectorPtr platform_handles) {
+    std::unique_ptr<std::vector<ScopedPlatformHandle>> platform_handles) {
   AssertOnPrivateThread();
 
   // Set |*ack_result_| to failure by default.
   *ack_result_ = Result::FAILURE;
 
   // Note: Since we should be able to trust the master, simply crash (i.e.,
   // |CHECK()|-fail) if it sends us something invalid.
 
   // Unsolicited message.
   CHECK_NE(awaiting_ack_type_, NOT_AWAITING_ACK);
@@ skipping 35 matching lines @@
         case MessageInTransit::Subtype::
             CONNECTION_MANAGER_ACK_SUCCESS_CONNECT_SAME_PROCESS:
           DCHECK_EQ(num_platform_handles, 0u);
           *ack_result_ = Result::SUCCESS_CONNECT_SAME_PROCESS;
           ack_platform_handle_->reset();
           break;
         case MessageInTransit::Subtype::
             CONNECTION_MANAGER_ACK_SUCCESS_CONNECT_NEW_CONNECTION:
           CHECK_EQ(num_platform_handles, 1u);
           *ack_result_ = Result::SUCCESS_CONNECT_NEW_CONNECTION;
-          ack_platform_handle_->reset(platform_handles->at(0));
-          platform_handles->at(0) = embedder::PlatformHandle();
+          *ack_platform_handle_ = std::move(platform_handles->at(0));
           break;
         case MessageInTransit::Subtype::
             CONNECTION_MANAGER_ACK_SUCCESS_CONNECT_REUSE_CONNECTION:
           DCHECK_EQ(num_platform_handles, 0u);
           *ack_result_ = Result::SUCCESS_CONNECT_REUSE_CONNECTION;
           ack_platform_handle_->reset();
           break;
         default:
           CHECK(false);
       }
@@ skipping 33 matching lines @@
 }
 
 void SlaveConnectionManager::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