Replace scoped_ptr with std::unique_ptr in //media/base.

media/base/android/media_codec_player_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 "media/base/android/media_codec_player.h"
 
 #include <stdint.h>
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/timer/timer.h"
 #include "media/base/android/demuxer_android.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/android/media_player_manager.h"
 #include "media/base/android/media_task_runner.h"
 #include "media/base/android/sdk_media_codec_bridge.h"
 #include "media/base/android/test_data_factory.h"
 #include "media/base/android/test_statistics.h"
 #include "media/base/timestamp_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 318 matching lines @@
 
   // Helper methods that enable using a weak pointer when posting to the player.
   void OnDemuxerDataAvailable(const DemuxerData& chunk);
   void OnDemuxerSeekDone(base::TimeDelta reported_seek_time);
 
   // Sets the callback that is fired when demuxer is deleted (deletion
   // happens on the Media thread).
   void SetDemuxerDeletedCallback(base::Closure cb) { demuxer_deleted_cb_ = cb; }
 
   // Sets the audio data factory.
-  void SetAudioFactory(scoped_ptr<AudioFactory> factory) {
+  void SetAudioFactory(std::unique_ptr<AudioFactory> factory) {
     audio_factory_ = std::move(factory);
   }
 
   // Sets the video data factory.
-  void SetVideoFactory(scoped_ptr<VideoFactory> factory) {
+  void SetVideoFactory(std::unique_ptr<VideoFactory> factory) {
     video_factory_ = std::move(factory);
   }
 
   // Accessors for data factories.
   AudioFactory* audio_factory() const { return audio_factory_.get(); }
   VideoFactory* video_factory() const { return video_factory_.get(); }
 
   // Set the preroll interval after seek for audio stream.
   void SetAudioPrerollInterval(base::TimeDelta value) {
     audio_preroll_interval_ = value;
@@ skipping 16 matching lines @@
   // Conditions to wait for.
   bool IsInitialized() const { return client_; }
   bool HasPendingConfigs() const { return !!pending_configs_; }
   bool ReceivedSeekRequest() const { return num_seeks_ > 0; }
   bool ReceivedBrowserSeekRequest() const { return num_browser_seeks_ > 0; }
 
  private:
   base::MessageLoop* ui_message_loop_;
   DemuxerAndroidClient* client_;
 
-  scoped_ptr<DemuxerConfigs> pending_configs_;
-  scoped_ptr<AudioFactory> audio_factory_;
-  scoped_ptr<VideoFactory> video_factory_;
+  std::unique_ptr<DemuxerConfigs> pending_configs_;
+  std::unique_ptr<AudioFactory> audio_factory_;
+  std::unique_ptr<VideoFactory> video_factory_;
 
   base::TimeDelta audio_preroll_interval_;
   base::TimeDelta video_preroll_interval_;
   base::TimeDelta seek_done_delay_;
 
   int num_seeks_;
   int num_browser_seeks_;
 
   base::Closure demuxer_deleted_cb_;
 
@@ skipping 100 matching lines @@
 void MockDemuxerAndroid::PostConfigs(const DemuxerConfigs& configs) {
   RUN_ON_MEDIA_THREAD(MockDemuxerAndroid, PostConfigs, configs);
 
   DVLOG(1) << "MockDemuxerAndroid::" << __FUNCTION__;
 
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   if (client_)
     client_->OnDemuxerConfigsAvailable(configs);
   else
-    pending_configs_ = scoped_ptr<DemuxerConfigs>(new DemuxerConfigs(configs));
+    pending_configs_ = base::WrapUnique(new DemuxerConfigs(configs));
 }
 
 void MockDemuxerAndroid::PostInternalConfigs() {
   ASSERT_TRUE(audio_factory_ || video_factory_);
 
   if (audio_factory_ && video_factory_) {
     PostConfigs(
         CreateAudioVideoConfigs(audio_factory_.get(), video_factory_.get()));
   } else if (audio_factory_) {
     PostConfigs(audio_factory_->GetConfigs());
@@ skipping 36 matching lines @@
   // playback has passed the given position.
   bool WaitForPlaybackBeyondPosition(
       const base::TimeDelta& pts,
       const base::TimeDelta& timeout = kDefaultTimeout);
 
   // Helper method that starts video only stream. Waits till it actually
   // started.
   bool StartVideoPlayback(base::TimeDelta duration, const char* test_name);
 
   // Helper method that starts audio and video streams.
-  bool StartAVPlayback(scoped_ptr<AudioFactory> audio_factory,
-                       scoped_ptr<VideoFactory> video_factory,
+  bool StartAVPlayback(std::unique_ptr<AudioFactory> audio_factory,
+                       std::unique_ptr<VideoFactory> video_factory,
                        uint32_t flags,
                        const char* test_name);
 
   // Helper method that starts audio and video streams with preroll.
   // The preroll is achieved by setting significant video preroll interval
   // so video will have to catch up with audio. To make room for this interval
   // the Start() command is preceded by SeekTo().
-  bool StartAVSeekAndPreroll(scoped_ptr<AudioFactory> audio_factory,
-                             scoped_ptr<VideoFactory> video_factory,
+  bool StartAVSeekAndPreroll(std::unique_ptr<AudioFactory> audio_factory,
+                             std::unique_ptr<VideoFactory> video_factory,
                              base::TimeDelta seek_position,
                              uint32_t flags,
                              const char* test_name);
 
   // Callback sent when demuxer is being deleted.
   void OnDemuxerDeleted() { demuxer_ = nullptr; }
 
   bool IsDemuxerDeleted() const { return !demuxer_; }
 
   base::MessageLoop message_loop_;
@@ skipping 43 matching lines @@
   }
 }
 
 void MediaCodecPlayerTest::CreatePlayer() {
   DCHECK(demuxer_);
   player_ = new MediaCodecPlayer(
       0,  // player_id
       manager_.GetWeakPtr(),
       base::Bind(&MockMediaPlayerManager::OnMediaResourcesRequested,
                  base::Unretained(&manager_)),
-      scoped_ptr<MockDemuxerAndroid>(demuxer_), GURL(), kDefaultMediaSessionId);
+      base::WrapUnique(demuxer_), GURL(), kDefaultMediaSessionId);
 
   DCHECK(player_);
 }
 
 void MediaCodecPlayerTest::SetVideoSurface() {
   surface_texture_a_ = gfx::SurfaceTexture::Create(0);
   gfx::ScopedJavaSurface surface(surface_texture_a_.get());
 
   ASSERT_NE(nullptr, player_);
   player_->SetVideoSurface(std::move(surface));
@@ skipping 46 matching lines @@
   return WaitForCondition(
       base::Bind(&MockMediaPlayerManager::IsPlaybackBeyondPosition,
                  base::Unretained(&manager_), pts),
       timeout);
 }
 
 bool MediaCodecPlayerTest::StartVideoPlayback(base::TimeDelta duration,
                                               const char* test_name) {
   const base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
 
-  demuxer_->SetVideoFactory(
-      scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  demuxer_->SetVideoFactory(base::WrapUnique(new VideoFactory(duration)));
 
   CreatePlayer();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
                                           base::Unretained(demuxer_))));
 
   if (!demuxer_->IsInitialized()) {
     DVLOG(0) << test_name << ": demuxer is not initialized";
     return false;
@@ skipping 16 matching lines @@
 
   if (!manager_.IsPlaybackStarted()) {
     DVLOG(0) << test_name << ": playback did not start";
     return false;
   }
 
   return true;
 }
 
 bool MediaCodecPlayerTest::StartAVPlayback(
-    scoped_ptr<AudioFactory> audio_factory,
-    scoped_ptr<VideoFactory> video_factory,
+    std::unique_ptr<AudioFactory> audio_factory,
+    std::unique_ptr<VideoFactory> video_factory,
     uint32_t flags,
     const char* test_name) {
   demuxer_->SetAudioFactory(std::move(audio_factory));
   demuxer_->SetVideoFactory(std::move(video_factory));
 
   CreatePlayer();
   SetVideoSurface();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
@@ skipping 36 matching lines @@
 
   if (!manager_.IsPlaybackStarted()) {
     DVLOG(0) << test_name << ": playback did not start";
     return false;
   }
 
   return true;
 }
 
 bool MediaCodecPlayerTest::StartAVSeekAndPreroll(
-    scoped_ptr<AudioFactory> audio_factory,
-    scoped_ptr<VideoFactory> video_factory,
+    std::unique_ptr<AudioFactory> audio_factory,
+    std::unique_ptr<VideoFactory> video_factory,
     base::TimeDelta seek_position,
     uint32_t flags,
     const char* test_name) {
   // Initialize A/V playback
 
   demuxer_->SetAudioFactory(std::move(audio_factory));
   demuxer_->SetVideoFactory(std::move(video_factory));
 
   CreatePlayer();
   SetVideoSurface();
@@ skipping 115 matching lines @@
   EXPECT_EQ(320, manager_.media_metadata_.width);
   EXPECT_EQ(240, manager_.media_metadata_.height);
 }
 
 TEST_F(MediaCodecPlayerTest, DISABLED_AudioPlayTillCompletion) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(2000);
 
-  demuxer_->SetAudioFactory(
-      scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::WrapUnique(new AudioFactory(duration)));
 
   CreatePlayer();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
                                           base::Unretained(demuxer_))));
 
   // Post configuration after the player has been initialized.
   demuxer_->PostInternalConfigs();
 
@@ skipping 13 matching lines @@
 }
 
 TEST_F(MediaCodecPlayerTest, AudioNoPermission) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
 
   manager_.SetPlaybackAllowed(false);
 
-  demuxer_->SetAudioFactory(
-      scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::WrapUnique(new AudioFactory(duration)));
 
   CreatePlayer();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
                                           base::Unretained(demuxer_))));
 
   // Post configuration after the player has been initialized.
   demuxer_->PostInternalConfigs();
 
@@ skipping 26 matching lines @@
 }
 
 TEST_F(MediaCodecPlayerTest, VideoNoPermission) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
   const base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
 
   manager_.SetPlaybackAllowed(false);
 
-  demuxer_->SetVideoFactory(
-      scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  demuxer_->SetVideoFactory(base::WrapUnique(new VideoFactory(duration)));
 
   CreatePlayer();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
                                           base::Unretained(demuxer_))));
 
   SetVideoSurface();
 
   // Post configuration after the player has been initialized.
@@ skipping 12 matching lines @@
 
 // http://crbug.com/518900
 TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekAfterStop) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Play for 300 ms, then Pause, then Seek to beginning. The playback should
   // start from the beginning.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
 
-  demuxer_->SetAudioFactory(
-      scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::WrapUnique(new AudioFactory(duration)));
 
   CreatePlayer();
 
   // Post configuration.
   demuxer_->PostInternalConfigs();
 
   // Start the player.
   player_->Start();
 
   // Wait for playback to start.
@@ skipping 38 matching lines @@
 
 TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekThenPlay) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Issue Seek command immediately followed by Start. The playback should
   // start at the seek position.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(500);
 
-  demuxer_->SetAudioFactory(
-      scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::WrapUnique(new AudioFactory(duration)));
 
   CreatePlayer();
 
   // Post configuration.
   demuxer_->PostInternalConfigs();
 
   // Seek and immediately start.
   player_->SeekTo(seek_position);
   player_->Start();
 
@@ skipping 13 matching lines @@
 TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekThenPlayThenConfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Issue Seek command immediately followed by Start but without prior demuxer
   // configuration. Start should wait for configuration. After it has been
   // posted the playback should start at the seek position.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(500);
 
-  demuxer_->SetAudioFactory(
-      scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::WrapUnique(new AudioFactory(duration)));
 
   CreatePlayer();
 
   // Seek and immediately start.
   player_->SeekTo(seek_position);
   player_->Start();
 
   // Make sure the player is waiting.
   WaitForDelay(base::TimeDelta::FromMilliseconds(200));
   EXPECT_FALSE(player_->IsPlaying());
@@ skipping 20 matching lines @@
 
   // Play for 300 ms, then issue several Seek commands in the row.
   // The playback should continue at the last seek position.
 
   // To test this condition without analyzing the reported time details
   // and without introducing dependency on implementation I make a long (10s)
   // duration and test that the playback resumes after big time jump (5s) in a
   // short period of time (200 ms).
   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
 
-  demuxer_->SetAudioFactory(
-      scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::WrapUnique(new AudioFactory(duration)));
 
   CreatePlayer();
 
   // Post configuration.
   demuxer_->PostInternalConfigs();
 
   // Start the player.
   player_->Start();
 
   // Wait for playback to start.
@@ skipping 266 matching lines @@
   // they should not be rendered. We deduce which frame is rendered by looking
   // at the reported time progress.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(600);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
 
   // Tell demuxer to make the first frame 100ms earlier than the seek request.
   demuxer_->SetVideoPrerollInterval(base::TimeDelta::FromMilliseconds(100));
 
-  demuxer_->SetVideoFactory(
-      scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  demuxer_->SetVideoFactory(base::WrapUnique(new VideoFactory(duration)));
 
   CreatePlayer();
   SetVideoSurface();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
                                           base::Unretained(demuxer_))));
   if (!demuxer_->IsInitialized()) {
     DVLOG(0) << "VideoPrerollAfterSeek: demuxer is not initialized";
     return;
@@ skipping 36 matching lines @@
   // with a decoder PTS that is delivered by a test-only callback.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
 
   // Set significant preroll interval. 500 ms means 25 frames, at 10 ms
   // per frame it would take 250 ms to preroll.
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta preroll_intvl = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(1000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   demuxer_->SetVideoPrerollInterval(preroll_intvl);
 
   ASSERT_TRUE(StartAVSeekAndPreroll(std::move(audio_factory),
                                     std::move(video_factory), seek_position, 0,
                                     "AVPrerollAudioWaitsForVideo"));
 
   // Wait till preroll finishes and the real playback starts.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
@@ skipping 27 matching lines @@
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
 
   // Set significant preroll interval. 500 ms means 25 frames, at 10 ms
   // per frame it would take 250 ms to preroll.
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta preroll_intvl = base::TimeDelta::FromMilliseconds(500);
 
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(1000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   demuxer_->SetVideoPrerollInterval(preroll_intvl);
 
   ASSERT_TRUE(StartAVSeekAndPreroll(std::move(audio_factory),
                                     std::move(video_factory), seek_position, 0,
                                     "AVPrerollReleaseAndRestart"));
 
   // Issue Release().
   player_->Release();
 
@@ skipping 52 matching lines @@
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
 
   // Set significant preroll interval. 500 ms means 25 frames, at 10 ms
   // per frame it would take 250 ms to preroll.
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta preroll_intvl = base::TimeDelta::FromMilliseconds(500);
 
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(1000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   demuxer_->SetVideoPrerollInterval(preroll_intvl);
 
   ASSERT_TRUE(StartAVSeekAndPreroll(std::move(audio_factory),
                                     std::move(video_factory), seek_position, 0,
                                     "AVPrerollStopAndRestart"));
 
   // Video stream should be prerolling. Request to stop.
   EXPECT_FALSE(IsPaused());
   player_->Pause(true);
@@ skipping 74 matching lines @@
   base::TimeDelta audio_duration = base::TimeDelta::FromMilliseconds(1100);
   base::TimeDelta video_duration = base::TimeDelta::FromMilliseconds(900);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta video_preroll_intvl = base::TimeDelta::FromMilliseconds(200);
 
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(400);
 
   demuxer_->SetVideoPrerollInterval(video_preroll_intvl);
 
-  demuxer_->SetAudioFactory(
-      scoped_ptr<AudioFactory>(new AudioFactory(audio_duration)));
-  demuxer_->SetVideoFactory(
-      scoped_ptr<VideoFactory>(new VideoFactory(video_duration)));
+  demuxer_->SetAudioFactory(base::WrapUnique(new AudioFactory(audio_duration)));
+  demuxer_->SetVideoFactory(base::WrapUnique(new VideoFactory(video_duration)));
 
   CreatePlayer();
   SetVideoSurface();
 
   // Set special testing callback to receive PTS from decoders.
   player_->SetDecodersTimeCallbackForTests(
       base::Bind(&MockMediaPlayerManager::OnDecodersTimeUpdate,
                  base::Unretained(&manager_)));
 
   // Wait till the player is initialized on media thread.
@@ skipping 54 matching lines @@
   // Test that video only playback continues after video config change.
 
   // Initialize video playback
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(2000);
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
-  demuxer_->SetVideoFactory(
-      scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  demuxer_->SetVideoFactory(base::WrapUnique(new VideoFactory(duration)));
 
   demuxer_->video_factory()->RequestConfigChange(config_change_position);
 
   CreatePlayer();
   SetVideoSurface();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
                                           base::Unretained(demuxer_))));
 
@@ skipping 48 matching lines @@
 
   // Test that A/V playback continues after video config change.
 
   // Initialize A/V playback
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   video_factory->RequestConfigChange(config_change_position);
 
   ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
                               std::move(video_factory), kAlwaysReconfigVideo,
                               "AVVideoConfigChangeWhilePlaying"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
@@ skipping 24 matching lines @@
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that A/V playback continues after audio config change.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   audio_factory->RequestConfigChange(config_change_position);
 
   ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
                               std::move(video_factory), kAlwaysReconfigAudio,
                               "AVAudioConfigChangeWhilePlaying"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
@@ skipping 23 matching lines @@
 
   // Test that the playback continues if audio and video config changes happen
   // at the same time.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_audio = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   audio_factory->RequestConfigChange(config_change_audio);
   video_factory->RequestConfigChange(config_change_video);
 
   ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
                               std::move(video_factory),
                               kAlwaysReconfigAudio | kAlwaysReconfigVideo,
                               "AVSimultaneousConfigChange_1"));
 
   // Wait till completion
@@ skipping 26 matching lines @@
   // Test that the playback continues if audio and video config changes happen
   // at the same time. Move audio change moment slightly to make it drained
   // after video.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_audio = base::TimeDelta::FromMilliseconds(1020);
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   audio_factory->RequestConfigChange(config_change_audio);
   video_factory->RequestConfigChange(config_change_video);
 
   ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
                               std::move(video_factory),
                               kAlwaysReconfigAudio | kAlwaysReconfigVideo,
                               "AVSimultaneousConfigChange_2"));
 
   // Wait till completion
@@ skipping 24 matching lines @@
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that audio can end while video config change processing.
 
   base::TimeDelta audio_duration = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta video_duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(audio_duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(video_duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(audio_duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(video_duration));
 
   video_factory->RequestConfigChange(config_change_video);
 
   ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
                               std::move(video_factory), kAlwaysReconfigVideo,
                               "AVAudioEndsAcrossVideoConfigChange"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
@@ skipping 28 matching lines @@
 TEST_F(MediaCodecPlayerTest, DISABLED_AVVideoEndsAcrossAudioConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that video can end while audio config change processing.
   base::TimeDelta audio_duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta video_duration = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta config_change_audio = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(audio_duration));
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(video_duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(audio_duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(video_duration));
 
   audio_factory->RequestConfigChange(config_change_audio);
 
   ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
                               std::move(video_factory), kAlwaysReconfigAudio,
                               "AVVideoEndsAcrossAudioConfigChange"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
@@ skipping 21 matching lines @@
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta video_preroll_intvl = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   demuxer_->SetVideoPrerollInterval(video_preroll_intvl);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
 
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
   video_factory->RequestConfigChange(config_change_position);
 
   ASSERT_TRUE(StartAVSeekAndPreroll(
       std::move(audio_factory), std::move(video_factory), seek_position,
       kAlwaysReconfigVideo, "AVPrerollAcrossVideoConfigChange"));
 
   // Wait till preroll finishes and the real playback starts.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
@@ skipping 26 matching lines @@
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta audio_preroll_intvl = base::TimeDelta::FromMilliseconds(400);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   demuxer_->SetAudioPrerollInterval(audio_preroll_intvl);
 
-  scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
+  std::unique_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   audio_factory->RequestConfigChange(config_change_position);
 
-  scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
+  std::unique_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   ASSERT_TRUE(StartAVSeekAndPreroll(
       std::move(audio_factory), std::move(video_factory), seek_position,
       kAlwaysReconfigAudio, "AVPrerollAcrossAudioConfigChange"));
 
   // Wait till preroll finishes and the real playback starts.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
                        preroll_timeout));
@@ skipping 20 matching lines @@
   // TODO(timav): maybe we should not call the testing callback for
   // kRenderAfterPreroll for video (for audio we already do not call).
   // EXPECT_TRUE(AlmostEqual(manager_.FirstFrameTime(DemuxerStream::AUDIO),
   //                        manager_.FirstFrameTime(DemuxerStream::VIDEO), 50));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 25));
 }
 
 }  // namespace media