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

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"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "media/base/android/audio_media_codec_decoder.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/android/media_statistics.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/android/video_media_codec_decoder.h"
 #include "media/base/timestamp_constants.h"
@@ skipping 130 matching lines @@
  protected:
   typedef base::Callback<bool()> Predicate;
 
   typedef base::Callback<void(const DemuxerData&)> DataAvailableCallback;
 
   // Waits for condition to become true or for timeout to expire.
   // Returns true if the condition becomes true.
   bool WaitForCondition(const Predicate& condition,
                         const base::TimeDelta& timeout = kDefaultTimeout);
 
-  void SetDataFactory(scoped_ptr<TestDataFactory> factory) {
+  void SetDataFactory(std::unique_ptr<TestDataFactory> factory) {
     data_factory_ = std::move(factory);
   }
 
   DemuxerConfigs GetConfigs() const {
     // ASSERT_NE does not compile here because it expects void return value.
     EXPECT_NE(nullptr, data_factory_.get());
     return data_factory_->GetConfigs();
   }
 
   void CreateAudioDecoder();
@@ skipping 27 matching lines @@
       decoder_->RequestToStop();
     }
   }
 
   void OnVideoSizeChanged(const gfx::Size& video_size) {
     video_size_ = video_size;
   }
 
   void OnVideoCodecCreated() {}
 
-  scoped_ptr<MediaCodecDecoder> decoder_;
-  scoped_ptr<TestDataFactory> data_factory_;
+  std::unique_ptr<MediaCodecDecoder> decoder_;
+  std::unique_ptr<TestDataFactory> data_factory_;
   Minimax<base::TimeDelta> pts_stat_;
   gfx::Size video_size_;
 
  private:
   bool is_timeout_expired() const { return is_timeout_expired_; }
   void SetTimeoutExpired(bool value) { is_timeout_expired_ = value; }
 
   base::MessageLoop message_loop_;
   bool is_timeout_expired_;
 
@@ skipping 39 matching lines @@
       return true;
     }
     message_loop_.RunUntilIdle();
   } while (!is_timeout_expired());
 
   DCHECK(!timer.IsRunning());
   return false;
 }
 
 void MediaCodecDecoderTest::CreateAudioDecoder() {
-  decoder_ = scoped_ptr<MediaCodecDecoder>(new AudioMediaCodecDecoder(
+  decoder_ = base::WrapUnique(new 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))));
 
   data_available_cb_ = base::Bind(&MediaCodecDecoder::OnDemuxerDataAvailable,
                                   base::Unretained(decoder_.get()));
 }
 
 void MediaCodecDecoderTest::CreateVideoDecoder() {
-  decoder_ = scoped_ptr<MediaCodecDecoder>(new VideoMediaCodecDecoder(
+  decoder_ = base::WrapUnique(new 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,
@@ skipping 24 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(scoped_ptr<TestDataFactory>(new AudioFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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(scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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();
 
   CreateAudioDecoder();
 
   // Cannot configure without config parameters.
   EXPECT_EQ(MediaCodecDecoder::kConfigFailure, decoder_->Configure(nullptr));
 }
 
 TEST_F(MediaCodecDecoderTest, AudioConfigureValidParams) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateAudioDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
-  scoped_ptr<AudioFactory> factory(new AudioFactory(duration));
+  std::unique_ptr<AudioFactory> factory(new AudioFactory(duration));
   decoder_->SetDemuxerConfigs(factory->GetConfigs());
 
   EXPECT_EQ(MediaCodecDecoder::kConfigOk, decoder_->Configure(nullptr));
 }
 
 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(scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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(scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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(scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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(scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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(scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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)));
 }
 
 // http://crbug.com/518900
 TEST_F(MediaCodecDecoderTest, DISABLED_AudioPlayTillCompletion) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   DVLOG(0) << "AudioPlayTillCompletion started";
 
   CreateAudioDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(1500);
 
-  SetDataFactory(scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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))));
 
   decoder_->SetDemuxerConfigs(GetConfigs());
 
@@ skipping 21 matching lines @@
 TEST_F(MediaCodecDecoderTest, 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(scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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 17 matching lines @@
 
 TEST_F(MediaCodecDecoderTest, VideoStopAndResume) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateVideoDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta stop_request_time = base::TimeDelta::FromMilliseconds(200);
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(1000);
 
-  SetDataFactory(scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  SetDataFactory(base::WrapUnique(new 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 50 matching lines @@
 TEST_F(MediaCodecDecoderTest, DISABLED_AudioStarvationAndStop) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   CreateAudioDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(200);
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(400);
 
   AudioFactory* factory = new AudioFactory(duration);
   factory->SetStarvationMode(true);
-  SetDataFactory(scoped_ptr<AudioFactory>(factory));
+  SetDataFactory(base::WrapUnique(factory));
 
   // Prefetch.
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 
   // Configure.
   decoder_->SetDemuxerConfigs(GetConfigs());
@@ skipping 26 matching lines @@
 TEST_F(MediaCodecDecoderTest, VideoFirstUnitIsReconfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the kConfigChanged unit that comes before the first data unit
   // gets processed, i.e. is not lost.
 
   CreateVideoDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(200);
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(1000);
-  SetDataFactory(scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  SetDataFactory(base::WrapUnique(new VideoFactory(duration)));
 
   // Ask factory to produce initial configuration unit. The configuraton will
   // be factory.GetConfigs().
   data_factory_->RequestInitialConfigs();
 
   // Create am alternative configuration (we just alter video size).
   DemuxerConfigs alt_configs = data_factory_->GetConfigs();
   alt_configs.video_size = gfx::Size(100, 100);
 
   // Pass the alternative configuration to decoder.
@@ skipping 25 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