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

media/base/android/media_codec_decoder_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 <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 249 matching lines @@
       return true;
     }
     message_loop_.RunUntilIdle();
   } while (!is_timeout_expired());
 
   DCHECK(!timer.IsRunning());
   return false;
 }
 
 void MediaCodecDecoderTest::CreateAudioDecoder() {
-  decoder_ = base::WrapUnique(new AudioMediaCodecDecoder(
+  decoder_ = base::MakeUnique<AudioMediaCodecDecoder>(
       task_runner_, &frame_statistics_,
       base::Bind(&MediaCodecDecoderTest::OnDataRequested,
                  base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnStarvation, base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnDecoderDrained,
                  base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnStopDone, base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnKeyRequired, base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnError, base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnUpdateCurrentTime,
-                 base::Unretained(this))));
+                 base::Unretained(this)));
 
   data_available_cb_ = base::Bind(&MediaCodecDecoder::OnDemuxerDataAvailable,
                                   base::Unretained(decoder_.get()));
 }
 
 void MediaCodecDecoderTest::CreateVideoDecoder() {
-  decoder_ = base::WrapUnique(new VideoMediaCodecDecoder(
+  decoder_ = base::MakeUnique<VideoMediaCodecDecoder>(
       task_runner_, &frame_statistics_,
       base::Bind(&MediaCodecDecoderTest::OnDataRequested,
                  base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnStarvation, base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnDecoderDrained,
                  base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnStopDone, base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnKeyRequired, base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnError, base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnUpdateCurrentTime,
                  base::Unretained(this)),
       base::Bind(&MediaCodecDecoderTest::OnVideoSizeChanged,
-                 base::Unretained(this))));
+                 base::Unretained(this)));
 
   data_available_cb_ = base::Bind(&MediaCodecDecoder::OnDemuxerDataAvailable,
                                   base::Unretained(decoder_.get()));
 }
 
 void MediaCodecDecoderTest::OnDataRequested() {
   if (!data_factory_)
     return;
 
   DemuxerData data;
@@ skipping 11 matching lines @@
   ASSERT_NE(nullptr, decoder_.get());
   VideoMediaCodecDecoder* video_decoder =
       static_cast<VideoMediaCodecDecoder*>(decoder_.get());
   video_decoder->SetVideoSurface(std::move(surface));
 }
 
 TEST_F(MediaCodecDecoderTest, AudioPrefetch) {
   CreateAudioDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
-  SetDataFactory(base::WrapUnique(new AudioFactory(duration)));
+  SetDataFactory(base::MakeUnique<AudioFactory>(duration));
 
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 }
 
 TEST_F(MediaCodecDecoderTest, VideoPrefetch) {
   CreateVideoDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
-  SetDataFactory(base::WrapUnique(new VideoFactory(duration)));
+  SetDataFactory(base::MakeUnique<VideoFactory>(duration));
 
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 }
 
 TEST_F(MediaCodecDecoderTest, AudioConfigureNoParams) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
@@ skipping 18 matching lines @@
 
 TEST_F(MediaCodecDecoderTest, VideoConfigureNoParams) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateVideoDecoder();
 
   // decoder_->Configure() searches back for the key frame.
   // We have to prefetch decoder.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
-  SetDataFactory(base::WrapUnique(new VideoFactory(duration)));
+  SetDataFactory(base::MakeUnique<VideoFactory>(duration));
 
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 
   SetVideoSurface();
 
   // Cannot configure without config parameters.
   EXPECT_EQ(MediaCodecDecoder::kConfigFailure, decoder_->Configure(nullptr));
 }
 
 TEST_F(MediaCodecDecoderTest, VideoConfigureNoSurface) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateVideoDecoder();
 
   // decoder_->Configure() searches back for the key frame.
   // We have to prefetch decoder.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
-  SetDataFactory(base::WrapUnique(new VideoFactory(duration)));
+  SetDataFactory(base::MakeUnique<VideoFactory>(duration));
 
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 
   decoder_->SetDemuxerConfigs(GetConfigs());
 
   // Surface is not set, Configure() should fail.
 
   EXPECT_EQ(MediaCodecDecoder::kConfigFailure, decoder_->Configure(nullptr));
 }
 
 TEST_F(MediaCodecDecoderTest, VideoConfigureInvalidSurface) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateVideoDecoder();
 
   // decoder_->Configure() searches back for the key frame.
   // We have to prefetch decoder.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
-  SetDataFactory(base::WrapUnique(new VideoFactory(duration)));
+  SetDataFactory(base::MakeUnique<VideoFactory>(duration));
 
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 
   decoder_->SetDemuxerConfigs(GetConfigs());
 
   // Prepare the surface.
@@ skipping 13 matching lines @@
 
 TEST_F(MediaCodecDecoderTest, VideoConfigureValidParams) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateVideoDecoder();
 
   // decoder_->Configure() searches back for the key frame.
   // We have to prefetch decoder.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
-  SetDataFactory(base::WrapUnique(new VideoFactory(duration)));
+  SetDataFactory(base::MakeUnique<VideoFactory>(duration));
 
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 
   decoder_->SetDemuxerConfigs(GetConfigs());
 
   SetVideoSurface();
 
   // Now we can expect Configure() to succeed.
 
   EXPECT_EQ(MediaCodecDecoder::kConfigOk, decoder_->Configure(nullptr));
 }
 
 TEST_F(MediaCodecDecoderTest, AudioStartWithoutConfigure) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateAudioDecoder();
 
   // Decoder has to be prefetched and configured before the start.
 
   // Wrong state: not prefetched
   EXPECT_FALSE(decoder_->Start(base::TimeDelta::FromMilliseconds(0)));
 
   // Do the prefetch.
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
-  SetDataFactory(base::WrapUnique(new AudioFactory(duration)));
+  SetDataFactory(base::MakeUnique<AudioFactory>(duration));
 
   // Prefetch to avoid starvation at the beginning of playback.
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 
   // Still, decoder is not configured.
   EXPECT_FALSE(decoder_->Start(base::TimeDelta::FromMilliseconds(0)));
@@ skipping 51 matching lines @@
 TEST_F(MediaCodecDecoderTest, MAYBE_VideoPlayTillCompletion) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateVideoDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
   // The first output frame might come out with significant delay. Apparently
   // the codec does initial configuration at this time. We increase the timeout
   // to leave a room of 1 second for this initial configuration.
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(1500);
-  SetDataFactory(base::WrapUnique(new VideoFactory(duration)));
+  SetDataFactory(base::MakeUnique<VideoFactory>(duration));
 
   // Prefetch
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 
   decoder_->SetDemuxerConfigs(GetConfigs());
 
@@ skipping 183 matching lines @@
 
   EXPECT_TRUE(decoder_->IsStopped());
   EXPECT_TRUE(decoder_->IsCompleted());
   EXPECT_EQ(data_factory_->last_pts(), pts_stat_.max());
 
   // Check that the reported video size is the one from the in-stream configs.
   EXPECT_EQ(data_factory_->GetConfigs().video_size, video_size_);
 }
 
 }  // namespace media