Remove ScopedVector from audio/video renderer related code in media/

base::ScopedVector is deprecated, see bug.

BUG=554289, 588249

Review-Url: https://codereview.chromium.org/2871503002
Cr-Commit-Position: refs/heads/master@{#471186}

media/base/decoder_factory.cc

@@ -14,11 +14,11 @@ DecoderFactory::~DecoderFactory() {}
 
 void DecoderFactory::CreateAudioDecoders(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    ScopedVector<AudioDecoder>* audio_decoders) {}
+    std::vector<std::unique_ptr<AudioDecoder>>* audio_decoders) {}
 
 void DecoderFactory::CreateVideoDecoders(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     GpuVideoAcceleratorFactories* gpu_factories,
-    ScopedVector<VideoDecoder>* video_decoders) {}
+    std::vector<std::unique_ptr<VideoDecoder>>* video_decoders) {}
 
 }  // namespace media

media/base/decoder_factory.h

@@ -5,9 +5,11 @@
 #ifndef MEDIA_BASE_DECODER_FACTORY_H_
 #define MEDIA_BASE_DECODER_FACTORY_H_
 
+#include <memory>
+#include <vector>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "media/base/media_export.h"
 
 namespace base {
@@ -30,14 +32,14 @@ class MEDIA_EXPORT DecoderFactory {
   // Decoders are single-threaded, each decoder should run on |task_runner|.
   virtual void CreateAudioDecoders(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      ScopedVector<AudioDecoder>* audio_decoders);
+      std::vector<std::unique_ptr<AudioDecoder>>* audio_decoders);
 
   // Creates video decoders and append them to the end of |video_decoders|.
   // Decoders are single-threaded, each decoder should run on |task_runner|.
   virtual void CreateVideoDecoders(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       GpuVideoAcceleratorFactories* gpu_factories,
-      ScopedVector<VideoDecoder>* video_decoders);
+      std::vector<std::unique_ptr<VideoDecoder>>* video_decoders);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DecoderFactory);

media/filters/audio_decoder_selector_unittest.cc

@@ -4,10 +4,10 @@
 
 #include <stddef.h>
 #include <utility>
-#include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
@@ -60,8 +60,8 @@ class AudioDecoderSelectorTest : public ::testing::Test {
             new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)),
         decoder_1_(new StrictMock<MockAudioDecoder>(kDecoder1)),
         decoder_2_(new StrictMock<MockAudioDecoder>(kDecoder2)) {
-    all_decoders_.push_back(decoder_1_);
-    all_decoders_.push_back(decoder_2_);
+    all_decoders_.push_back(base::WrapUnique(decoder_1_));
+    all_decoders_.push_back(base::WrapUnique(decoder_2_));
     // |cdm_context_| and |decryptor_| are conditionally created in
     // InitializeDecoderSelector().
   }
@@ -91,7 +91,7 @@ class AudioDecoderSelectorTest : public ::testing::Test {
     demuxer_stream_->set_audio_decoder_config(encrypted_audio_config);
   }
 
-  ScopedVector<AudioDecoder> CreateVideoDecodersForTest() {
+  std::vector<std::unique_ptr<AudioDecoder>> CreateAudioDecodersForTest() {
     return std::move(all_decoders_);
   }
 
@@ -119,7 +119,7 @@ class AudioDecoderSelectorTest : public ::testing::Test {
 
     decoder_selector_.reset(new AudioDecoderSelector(
         message_loop_.task_runner(),
-        base::Bind(&AudioDecoderSelectorTest::CreateVideoDecodersForTest,
+        base::Bind(&AudioDecoderSelectorTest::CreateAudioDecodersForTest,
                    base::Unretained(this)),
         &media_log_));
   }
@@ -172,7 +172,7 @@ class AudioDecoderSelectorTest : public ::testing::Test {
 
   StrictMock<MockAudioDecoder>* decoder_1_;
   StrictMock<MockAudioDecoder>* decoder_2_;
-  ScopedVector<AudioDecoder> all_decoders_;
+  std::vector<std::unique_ptr<AudioDecoder>> all_decoders_;
   std::unique_ptr<AudioDecoder> selected_decoder_;
 
   base::MessageLoop message_loop_;

media/filters/decoder_selector.cc

@@ -202,8 +202,8 @@ void DecoderSelector<StreamType>::InitializeDecoder() {
 
   // Select the next non-blacklisted decoder.
   while (!decoders_.empty()) {
-    std::unique_ptr<Decoder> decoder(decoders_.front());
-    decoders_.weak_erase(decoders_.begin());
+    std::unique_ptr<Decoder> decoder(std::move(decoders_.front()));
+    decoders_.erase(decoders_.begin());
     // When |decrypted_stream_| is selected, the |config_| has changed so ignore
     // the blacklist.
     if (decrypted_stream_ ||

media/filters/decoder_selector.h

@@ -6,11 +6,11 @@
 #define MEDIA_FILTERS_DECODER_SELECTOR_H_
 
 #include <memory>
+#include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 #include "media/base/demuxer_stream.h"
@@ -42,7 +42,8 @@ class MEDIA_EXPORT DecoderSelector {
   // Callback to create a list of decoders to select from.
   // TODO(xhwang): Use a DecoderFactory to create decoders one by one as needed,
   // instead of creating a list of decoders all at once.
-  using CreateDecodersCB = base::RepeatingCallback<ScopedVector<Decoder>()>;
+  using CreateDecodersCB =
+      base::RepeatingCallback<std::vector<std::unique_ptr<Decoder>>()>;
 
   // Indicates completion of Decoder selection.
   // - First parameter: The initialized Decoder. If it's set to NULL, then
@@ -116,7 +117,7 @@ class MEDIA_EXPORT DecoderSelector {
   typename Decoder::OutputCB output_cb_;
   base::Closure waiting_for_decryption_key_cb_;
 
-  ScopedVector<Decoder> decoders_;
+  std::vector<std::unique_ptr<Decoder>> decoders_;
 
   std::unique_ptr<Decoder> decoder_;
   std::unique_ptr<DecryptingDemuxerStream> decrypted_stream_;

media/filters/decoder_stream.h

@@ -8,11 +8,11 @@
 #include <deque>
 #include <list>
 #include <memory>
+#include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_timestamp_helper.h"
@@ -51,7 +51,8 @@ class MEDIA_EXPORT DecoderStream {
   };
 
   // Callback to create a list of decoders.
-  using CreateDecodersCB = base::RepeatingCallback<ScopedVector<Decoder>()>;
+  using CreateDecodersCB =
+      base::RepeatingCallback<std::vector<std::unique_ptr<Decoder>>()>;
 
   // Indicates completion of a DecoderStream initialization.
   using InitCB = base::Callback<void(bool success)>;

media/filters/gpu_video_decoder.h

@@ -49,6 +49,7 @@ class MEDIA_EXPORT GpuVideoDecoder
   GpuVideoDecoder(GpuVideoAcceleratorFactories* factories,
                   const RequestSurfaceCB& request_surface_cb,
                   MediaLog* media_log);
+  ~GpuVideoDecoder() override;
 
   // VideoDecoder implementation.
   std::string GetDisplayName() const override;
@@ -80,9 +81,6 @@ class MEDIA_EXPORT GpuVideoDecoder
 
   static const char kDecoderName[];
 
- protected:
-  ~GpuVideoDecoder() override;
-
  private:
   enum State {
     kNormal,

media/filters/video_decoder_selector_unittest.cc

@@ -4,10 +4,10 @@
 
 #include <stddef.h>
 #include <utility>
-#include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
@@ -58,8 +58,8 @@ class VideoDecoderSelectorTest : public ::testing::Test {
             new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         decoder_1_(new StrictMock<MockVideoDecoder>(kDecoder1)),
         decoder_2_(new StrictMock<MockVideoDecoder>(kDecoder2)) {
-    all_decoders_.push_back(decoder_1_);
-    all_decoders_.push_back(decoder_2_);
+    all_decoders_.push_back(base::WrapUnique(decoder_1_));
+    all_decoders_.push_back(base::WrapUnique(decoder_2_));
     // |cdm_context_| and |decryptor_| are conditionally created in
     // InitializeDecoderSelector().
   }
@@ -84,7 +84,7 @@ class VideoDecoderSelectorTest : public ::testing::Test {
         TestVideoConfig::NormalEncrypted());
   }
 
-  ScopedVector<VideoDecoder> CreateVideoDecodersForTest() {
+  std::vector<std::unique_ptr<VideoDecoder>> CreateVideoDecodersForTest() {
     return std::move(all_decoders_);
   }
 
@@ -167,7 +167,7 @@ class VideoDecoderSelectorTest : public ::testing::Test {
 
   StrictMock<MockVideoDecoder>* decoder_1_;
   StrictMock<MockVideoDecoder>* decoder_2_;
-  ScopedVector<VideoDecoder> all_decoders_;
+  std::vector<std::unique_ptr<VideoDecoder>> all_decoders_;
   std::unique_ptr<VideoDecoder> selected_decoder_;
 
   base::MessageLoop message_loop_;

media/filters/video_frame_stream_unittest.cc

@@ -8,6 +8,7 @@
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ -124,7 +125,7 @@ class VideoFrameStreamTest
   //   decoder_->SimulateFailureToInit(), and
   // - on decode error of the first buffer, which can be simulated by calling
   //   decoder_->SimulateError() before reading the first frame.
-  ScopedVector<VideoDecoder> CreateVideoDecodersForTest() {
+  std::vector<std::unique_ptr<VideoDecoder>> CreateVideoDecodersForTest() {
     // Previously decoders could have been destroyed on decoder reselection.
     decoders_.clear();
 
@@ -132,22 +133,22 @@ class VideoFrameStreamTest
     // TODO(xhwang): We should test the case where only certain decoder
     // supports encrypted streams. Currently this is hard to test because we use
     // parameterized tests which need to pass in all combinations.
-    ScopedVector<VideoDecoder> decoders;
+    std::vector<std::unique_ptr<VideoDecoder>> decoders;
     for (int i = 0; i < 3; ++i) {
-      FakeVideoDecoder* decoder =
-          new FakeVideoDecoder(GetDecoderName(i), GetParam().decoding_delay,
-                               GetParam().parallel_decoding,
-                               base::Bind(&VideoFrameStreamTest::OnBytesDecoded,
-                                          base::Unretained(this)));
+      auto decoder = base::MakeUnique<FakeVideoDecoder>(
+          GetDecoderName(i), GetParam().decoding_delay,
+          GetParam().parallel_decoding,
+          base::Bind(&VideoFrameStreamTest::OnBytesDecoded,
+                     base::Unretained(this)));
 
       if (GetParam().is_encrypted && !GetParam().has_decryptor)
         decoder->EnableEncryptedConfigSupport();
 
-      decoders.push_back(decoder);
-
       // Keep a copy of the raw pointers so we can change the behavior of each
       // decoder.
-      decoders_.push_back(decoder);
+      decoders_.push_back(decoder.get());
+
+      decoders.push_back(std::move(decoder));
     }
 
     for (const auto& i : decoder_indices_to_fail_init_)

media/mojo/clients/mojo_decoder_factory.cc

@@ -4,6 +4,7 @@
 
 #include "media/mojo/clients/mojo_decoder_factory.h"
 
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "media/mojo/clients/mojo_audio_decoder.h"
 #include "media/mojo/clients/mojo_video_decoder.h"
@@ -22,27 +23,27 @@ MojoDecoderFactory::~MojoDecoderFactory() {}
 
 void MojoDecoderFactory::CreateAudioDecoders(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    ScopedVector<AudioDecoder>* audio_decoders) {
+    std::vector<std::unique_ptr<AudioDecoder>>* audio_decoders) {
 #if defined(ENABLE_MOJO_AUDIO_DECODER)
   mojom::AudioDecoderPtr audio_decoder_ptr;
   service_manager::GetInterface<mojom::AudioDecoder>(interface_provider_,
                                                      &audio_decoder_ptr);
 
-  audio_decoders->push_back(
-      new MojoAudioDecoder(task_runner, std::move(audio_decoder_ptr)));
+  audio_decoders->push_back(base::MakeUnique<MojoAudioDecoder>(
+      task_runner, std::move(audio_decoder_ptr)));
 #endif
 }
 
 void MojoDecoderFactory::CreateVideoDecoders(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     GpuVideoAcceleratorFactories* gpu_factories,
-    ScopedVector<VideoDecoder>* video_decoders) {
+    std::vector<std::unique_ptr<VideoDecoder>>* video_decoders) {
 #if defined(ENABLE_MOJO_VIDEO_DECODER)
   mojom::VideoDecoderPtr remote_decoder;
   service_manager::GetInterface<mojom::VideoDecoder>(interface_provider_,
                                                      &remote_decoder);
-  video_decoders->push_back(new MojoVideoDecoder(task_runner, gpu_factories,
-                                                 std::move(remote_decoder)));
+  video_decoders->push_back(base::MakeUnique<MojoVideoDecoder>(
+      task_runner, gpu_factories, std::move(remote_decoder)));
 #endif
 }
 

media/mojo/clients/mojo_decoder_factory.h

@@ -19,12 +19,12 @@ class MojoDecoderFactory : public DecoderFactory {
 
   void CreateAudioDecoders(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      ScopedVector<AudioDecoder>* audio_decoders) final;
+      std::vector<std::unique_ptr<AudioDecoder>>* audio_decoders) final;
 
   void CreateVideoDecoders(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       GpuVideoAcceleratorFactories* gpu_factories,
-      ScopedVector<VideoDecoder>* video_decoders) final;
+      std::vector<std::unique_ptr<VideoDecoder>>* video_decoders) final;
 
  private:
   service_manager::mojom::InterfaceProvider* interface_provider_;

media/renderers/audio_renderer_impl_unittest.cc

@@ -6,11 +6,13 @@
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
@@ -66,8 +68,8 @@ ACTION_P(EnterPendingDecoderInitStateAction, test) {
 
 class AudioRendererImplTest : public ::testing::Test, public RendererClient {
  public:
-  ScopedVector<AudioDecoder> CreateAudioDecoderForTest() {
-    MockAudioDecoder* decoder = new MockAudioDecoder();
+  std::vector<std::unique_ptr<AudioDecoder>> CreateAudioDecoderForTest() {
+    auto decoder = base::MakeUnique<MockAudioDecoder>();
     if (!enter_pending_decoder_init_) {
       EXPECT_CALL(*decoder, Initialize(_, _, _, _))
           .WillOnce(DoAll(SaveArg<3>(&output_cb_),
@@ -80,8 +82,8 @@ class AudioRendererImplTest : public ::testing::Test, public RendererClient {
         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::DecodeDecoder));
     EXPECT_CALL(*decoder, Reset(_))
         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ResetDecoder));
-    ScopedVector<AudioDecoder> decoders;
-    decoders.push_back(decoder);
+    std::vector<std::unique_ptr<AudioDecoder>> decoders;
+    decoders.push_back(std::move(decoder));
     return decoders;
   }
 

media/renderers/default_renderer_factory.cc

@@ -42,14 +42,15 @@ DefaultRendererFactory::DefaultRendererFactory(
 DefaultRendererFactory::~DefaultRendererFactory() {
 }
 
-ScopedVector<AudioDecoder> DefaultRendererFactory::CreateAudioDecoders(
+std::vector<std::unique_ptr<AudioDecoder>>
+DefaultRendererFactory::CreateAudioDecoders(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner) {
   // Create our audio decoders and renderer.
-  ScopedVector<AudioDecoder> audio_decoders;
+  std::vector<std::unique_ptr<AudioDecoder>> audio_decoders;
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
   audio_decoders.push_back(
-      new FFmpegAudioDecoder(media_task_runner, media_log_));
+      base::MakeUnique<FFmpegAudioDecoder>(media_task_runner, media_log_));
 #endif
 
   // Use an external decoder only if we cannot otherwise decode in the
@@ -60,12 +61,13 @@ ScopedVector<AudioDecoder> DefaultRendererFactory::CreateAudioDecoders(
   return audio_decoders;
 }
 
-ScopedVector<VideoDecoder> DefaultRendererFactory::CreateVideoDecoders(
+std::vector<std::unique_ptr<VideoDecoder>>
+DefaultRendererFactory::CreateVideoDecoders(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const RequestSurfaceCB& request_surface_cb,
     GpuVideoAcceleratorFactories* gpu_factories) {
   // Create our video decoders and renderer.
-  ScopedVector<VideoDecoder> video_decoders;
+  std::vector<std::unique_ptr<VideoDecoder>> video_decoders;
 
   // Prefer an external decoder since one will only exist if it is hardware
   // accelerated.
@@ -79,16 +81,16 @@ ScopedVector<VideoDecoder> DefaultRendererFactory::CreateVideoDecoders(
       decoder_factory_->CreateVideoDecoders(media_task_runner, gpu_factories,
                                             &video_decoders);
     }
-    video_decoders.push_back(
-        new GpuVideoDecoder(gpu_factories, request_surface_cb, media_log_));
+    video_decoders.push_back(base::MakeUnique<GpuVideoDecoder>(
+        gpu_factories, request_surface_cb, media_log_));
   }
 
 #if !defined(MEDIA_DISABLE_LIBVPX)
-  video_decoders.push_back(new VpxVideoDecoder());
+  video_decoders.push_back(base::MakeUnique<VpxVideoDecoder>());
 #endif
 
 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(DISABLE_FFMPEG_VIDEO_DECODERS)
-  video_decoders.push_back(new FFmpegVideoDecoder(media_log_));
+  video_decoders.push_back(base::MakeUnique<FFmpegVideoDecoder>(media_log_));
 #endif
 
   return video_decoders;

media/renderers/default_renderer_factory.h

@@ -6,10 +6,10 @@
 #define MEDIA_RENDERERS_DEFAULT_RENDERER_FACTORY_H_
 
 #include <memory>
+#include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
 #include "media/base/media_export.h"
 #include "media/base/renderer_factory.h"
 
@@ -24,9 +24,9 @@ class VideoDecoder;
 class VideoRendererSink;
 
 using CreateAudioDecodersCB =
-    base::RepeatingCallback<ScopedVector<AudioDecoder>()>;
+    base::RepeatingCallback<std::vector<std::unique_ptr<AudioDecoder>>()>;
 using CreateVideoDecodersCB =
-    base::RepeatingCallback<ScopedVector<VideoDecoder>()>;
+    base::RepeatingCallback<std::vector<std::unique_ptr<VideoDecoder>>()>;
 
 // The default factory class for creating RendererImpl.
 class MEDIA_EXPORT DefaultRendererFactory : public RendererFactory {
@@ -46,9 +46,9 @@ class MEDIA_EXPORT DefaultRendererFactory : public RendererFactory {
       const RequestSurfaceCB& request_surface_cb) final;
 
  private:
-  ScopedVector<AudioDecoder> CreateAudioDecoders(
+  std::vector<std::unique_ptr<AudioDecoder>> CreateAudioDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner);
-  ScopedVector<VideoDecoder> CreateVideoDecoders(
+  std::vector<std::unique_ptr<VideoDecoder>> CreateVideoDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const RequestSurfaceCB& request_surface_cb,
       GpuVideoAcceleratorFactories* gpu_factories);

media/renderers/video_renderer_impl.h

@@ -13,7 +13,6 @@
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"

media/renderers/video_renderer_impl_unittest.cc

@@ -53,10 +53,10 @@ MATCHER_P(HasTimestampMatcher, ms, "") {
 
 class VideoRendererImplTest : public testing::Test {
  public:
-  ScopedVector<VideoDecoder> CreateVideoDecodersForTest() {
+  std::vector<std::unique_ptr<VideoDecoder>> CreateVideoDecodersForTest() {
     decoder_ = new NiceMock<MockVideoDecoder>();
-    ScopedVector<VideoDecoder> decoders;
-    decoders.push_back(decoder_);
+    std::vector<std::unique_ptr<VideoDecoder>> decoders;
+    decoders.push_back(base::WrapUnique(decoder_));
     ON_CALL(*decoder_, Initialize(_, _, _, _, _))
         .WillByDefault(DoAll(SaveArg<4>(&output_cb_),
                              RunCallback<3>(expect_init_success_)));

media/test/pipeline_integration_test.cc

@@ -1369,9 +1369,9 @@ TEST_F(PipelineIntegrationTest, BasicPlaybackHi10P) {
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-ScopedVector<VideoDecoder> CreateFailingVideoDecoder() {
-  ScopedVector<VideoDecoder> failing_video_decoder;
-  failing_video_decoder.push_back(new FailingVideoDecoder());
+std::vector<std::unique_ptr<VideoDecoder>> CreateFailingVideoDecoder() {
+  std::vector<std::unique_ptr<VideoDecoder>> failing_video_decoder;
+  failing_video_decoder.push_back(base::MakeUnique<FailingVideoDecoder>());
   return failing_video_decoder;
 }
 

media/test/pipeline_integration_test_base.cc

@@ -9,7 +9,6 @@
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/media_log.h"
@@ -41,10 +40,10 @@ using ::testing::SaveArg;
 
 namespace media {
 
-static ScopedVector<VideoDecoder> CreateVideoDecodersForTest(
+static std::vector<std::unique_ptr<VideoDecoder>> CreateVideoDecodersForTest(
     MediaLog* media_log,
     CreateVideoDecodersCB prepend_video_decoders_cb) {
-  ScopedVector<VideoDecoder> video_decoders;
+  std::vector<std::unique_ptr<VideoDecoder>> video_decoders;
 
   if (!prepend_video_decoders_cb.is_null()) {
     video_decoders = prepend_video_decoders_cb.Run();
@@ -52,22 +51,22 @@ static ScopedVector<VideoDecoder> CreateVideoDecodersForTest(
   }
 
 #if !defined(MEDIA_DISABLE_LIBVPX)
-  video_decoders.push_back(new VpxVideoDecoder());
+  video_decoders.push_back(base::MakeUnique<VpxVideoDecoder>());
 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
 
 // Android does not have an ffmpeg video decoder.
 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID) && \
     !defined(DISABLE_FFMPEG_VIDEO_DECODERS)
-  video_decoders.push_back(new FFmpegVideoDecoder(media_log));
+  video_decoders.push_back(base::MakeUnique<FFmpegVideoDecoder>(media_log));
 #endif
   return video_decoders;
 }
 
-static ScopedVector<AudioDecoder> CreateAudioDecodersForTest(
+static std::vector<std::unique_ptr<AudioDecoder>> CreateAudioDecodersForTest(
     MediaLog* media_log,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     CreateAudioDecodersCB prepend_audio_decoders_cb) {
-  ScopedVector<AudioDecoder> audio_decoders;
+  std::vector<std::unique_ptr<AudioDecoder>> audio_decoders;
 
   if (!prepend_audio_decoders_cb.is_null()) {
     audio_decoders = prepend_audio_decoders_cb.Run();
@@ -76,7 +75,7 @@ static ScopedVector<AudioDecoder> CreateAudioDecodersForTest(
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
   audio_decoders.push_back(
-      new FFmpegAudioDecoder(media_task_runner, media_log));
+      base::MakeUnique<FFmpegAudioDecoder>(media_task_runner, media_log));
 #endif
   return audio_decoders;
 }