Re-write many calls to WrapUnique() with MakeUnique()

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>
 
@@ skipping 497 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_ = base::WrapUnique(new DemuxerConfigs(configs));
+    pending_configs_ = base::MakeUnique<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 177 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(base::WrapUnique(new VideoFactory(duration)));
+  demuxer_->SetVideoFactory(base::MakeUnique<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 211 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(base::WrapUnique(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::MakeUnique<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(base::WrapUnique(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::MakeUnique<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 32 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(base::WrapUnique(new VideoFactory(duration)));
+  demuxer_->SetVideoFactory(base::MakeUnique<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 71 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(base::WrapUnique(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::MakeUnique<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(base::WrapUnique(new AudioFactory(duration)));
+  demuxer_->SetAudioFactory(base::MakeUnique<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 586 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(base::WrapUnique(new AudioFactory(audio_duration)));
-  demuxer_->SetVideoFactory(base::WrapUnique(new VideoFactory(video_duration)));
+  demuxer_->SetAudioFactory(base::MakeUnique<AudioFactory>(audio_duration));
+  demuxer_->SetVideoFactory(base::MakeUnique<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(base::WrapUnique(new VideoFactory(duration)));
+  demuxer_->SetVideoFactory(base::MakeUnique<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 419 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