Remove ScopedVector from ppapi/.

ppapi/proxy/video_encoder_resource_unittest.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 "ppapi/proxy/video_encoder_resource.h"
 
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/memory/shared_memory.h"
 #include "base/process/process.h"
 #include "base/synchronization/waitable_event.h"
 #include "ppapi/c/pp_codecs.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_video_encoder.h"
 #include "ppapi/c/ppb_video_frame.h"
 #include "ppapi/proxy/locking_resource_releaser.h"
 #include "ppapi/proxy/plugin_message_filter.h"
@@ skipping 263 matching lines @@
                            int32_t success,
                            uint32_t input_frame_count,
                            const PP_Size& input_coded_size) {
     SendReply(params, success, PpapiPluginMsg_VideoEncoder_InitializeReply(
                                    input_frame_count, input_coded_size));
   }
 
   void SendBitstreamBuffers(const ResourceMessageCallParams& params,
                             uint32_t buffer_length) {
     std::vector<SerializedHandle> handles;
-    for (base::SharedMemory* mem : shared_memory_bitstreams_) {
+    for (const auto& mem : shared_memory_bitstreams_) {
       ASSERT_EQ(mem->requested_size(), buffer_length);
       base::SharedMemoryHandle handle = mem->handle().Duplicate();
       ASSERT_TRUE(handle.IsValid());
       handles.push_back(SerializedHandle(handle, buffer_length));
     }
     SendReplyWithHandles(
         params, PP_OK,
         PpapiPluginMsg_VideoEncoder_BitstreamBuffers(buffer_length), handles);
   }
 
@@ skipping 112 matching lines @@
                video_frame, &frame_size) == PP_TRUE;
   }
 
  private:
   // MediaStreamBufferManager::Delegate:
   void OnNewBufferEnqueued() override {}
 
   const PPB_VideoEncoder_0_2* encoder_iface_;
   const PPB_VideoEncoder_0_1* encoder_iface_0_1_;
 
-  ScopedVector<base::SharedMemory> shared_memory_bitstreams_;
+  std::vector<std::unique_ptr<base::SharedMemory>> shared_memory_bitstreams_;
 
   MediaStreamBufferManager video_frames_manager_;
 };
 
 void* ForwardUserData(void* user_data,
                       uint32_t element_count,
                       uint32_t element_size) {
   return user_data;
 }
 
@@ skipping 709 matching lines @@
     ResourceMessageCallParams params;
     uint32_t frame_id;
     bool force_frame;
     ASSERT_TRUE(CheckEncodeMsg(&params, &frame_id, &force_frame));
     SendEncodeReply(params, frame_id);
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi