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

mojo/edk/system/raw_channel.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_RAW_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_RAW_CHANNEL_H_
 
 #include <memory>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
-#include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_in_transit_queue.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/thread_annotations.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace base {
 class MessageLoopForIO;
 }
@@ skipping 37 matching lines @@
       // Unknown read error.
       ERROR_READ_UNKNOWN,
       // Generic write error.
       ERROR_WRITE
     };
 
     // Called when a message is read. This may call the |RawChannel|'s
     // |Shutdown()| and then (if desired) destroy it.
     virtual void OnReadMessage(
         const MessageInTransit::View& message_view,
-        embedder::ScopedPlatformHandleVectorPtr platform_handles) = 0;
+        std::unique_ptr<std::vector<embedder::ScopedPlatformHandle>>
+            platform_handles) = 0;
 
     // Called when there's a (fatal) error. This may call the |RawChannel|'s
     // |Shutdown()| and then (if desired) destroy it.
     //
     // For each raw channel, there'll be at most one |ERROR_READ_...| and at
     // most one |ERROR_WRITE| notification. After |OnError(ERROR_READ_...)|,
     // |OnReadMessage()| won't be called again.
     virtual void OnError(Error error) = 0;
 
    protected:
@@ skipping 173 matching lines @@
   // Similar to |Read()|, except that the implementing subclass must also
   // guarantee that the method doesn't succeed synchronously, i.e., it only
   // returns |IO_FAILED_...| or |IO_PENDING|.
   virtual IOResult ScheduleRead() MOJO_LOCKS_EXCLUDED(write_mutex_) = 0;
 
   // Called by |OnReadCompleted()| to get the platform handles associated with
   // the given platform handle table (from a message). This should only be
   // called when |num_platform_handles| is nonzero. Returns null if the
   // |num_platform_handles| handles are not available. Only called on the I/O
   // thread.
-  virtual embedder::ScopedPlatformHandleVectorPtr GetReadPlatformHandles(
-      size_t num_platform_handles,
-      const void* platform_handle_table) MOJO_LOCKS_EXCLUDED(write_mutex_) = 0;
+  virtual std::unique_ptr<std::vector<embedder::ScopedPlatformHandle>>
+  GetReadPlatformHandles(size_t num_platform_handles,
+                         const void* platform_handle_table)
+      MOJO_LOCKS_EXCLUDED(write_mutex_) = 0;
 
   // Writes contents in |write_buffer_no_lock()|.
   // This class guarantees that:
   // - the |PlatformHandle|s given by |GetPlatformHandlesToSend()| and the
   //   buffer(s) given by |GetBuffers()| will remain valid until write
   //   completion (see also the comments for |OnShutdownNoLock()|);
   // - a second write is not started if there is a pending write.
   //
   // The implementing subclass must guarantee that:
   // - |platform_handles_written| and |bytes_written| are untouched unless
@@ skipping 53 matching lines @@
   base::WeakPtrFactory<RawChannel> weak_ptr_factory_
       MOJO_GUARDED_BY(write_mutex_);
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_RAW_CHANNEL_H_