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

media/base/android/sdk_media_codec_bridge_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/sdk_media_codec_bridge.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "media/base/android/media_codec_util.h"
-#include "media/base/android/sdk_media_codec_bridge.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/test_data_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace {
 
 // The first frame of
 // http://www.html5rocks.com/en/tutorials/audio/quick/test.mp3
 unsigned char test_mp3[] = {
     0xff, 0xfb, 0xd2, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0x05, 0x00,
@@ skipping 119 matching lines @@
     // Output time stamp should not be smaller than old timestamp.
     ASSERT_TRUE(new_timestamp >= timestamp);
     input_pts += base::TimeDelta::FromMicroseconds(33000);
     timestamp = new_timestamp;
   }
 }
 
 TEST(SdkMediaCodecBridgeTest, Initialize) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
-  scoped_ptr<media::MediaCodecBridge> media_codec;
+  std::unique_ptr<media::MediaCodecBridge> media_codec;
   media_codec.reset(VideoCodecBridge::CreateDecoder(
       kCodecH264, false, gfx::Size(640, 480), nullptr, nullptr));
 }
 
 TEST(SdkMediaCodecBridgeTest, DoNormal) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
-  scoped_ptr<media::AudioCodecBridge> media_codec;
+  std::unique_ptr<media::AudioCodecBridge> media_codec;
   media_codec.reset(AudioCodecBridge::Create(kCodecMP3));
 
   ASSERT_TRUE(media_codec->ConfigureAndStart(kCodecMP3, 44100, 2, nullptr, 0, 0,
                                              0, false, nullptr));
 
   int input_buf_index = -1;
   MediaCodecStatus status =
       media_codec->DequeueInputBuffer(InfiniteTimeOut(), &input_buf_index);
   ASSERT_EQ(MEDIA_CODEC_OK, status);
   ASSERT_GE(input_buf_index, 0);
@@ skipping 38 matching lines @@
     EXPECT_LE(1u, size);
     total_size += size;
   }
   EXPECT_EQ(kDecodedAudioLengthInBytes, total_size);
   ASSERT_LE(input_pts, kMaxInputPts);
 }
 
 TEST(SdkMediaCodecBridgeTest, InvalidVorbisHeader) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
-  scoped_ptr<media::AudioCodecBridge> media_codec;
+  std::unique_ptr<media::AudioCodecBridge> media_codec;
   media_codec.reset(AudioCodecBridge::Create(kCodecVorbis));
 
   // The first byte of the header is not 0x02.
   uint8_t invalid_first_byte[] = {0x00, 0xff, 0xff, 0xff, 0xff};
   EXPECT_FALSE(media_codec->ConfigureAndStart(
       kCodecVorbis, 44100, 2, invalid_first_byte, sizeof(invalid_first_byte), 0,
       0, false, nullptr));
 
   // Size of the header does not match with the data we passed in.
   uint8_t invalid_size[] = {0x02, 0x01, 0xff, 0x01, 0xff};
@@ skipping 10 matching lines @@
   very_large_header[large_size - 1] = 0xfe;
   EXPECT_FALSE(media_codec->ConfigureAndStart(kCodecVorbis, 44100, 2,
                                               very_large_header, 0x80000000, 0,
                                               0, false, nullptr));
   delete[] very_large_header;
 }
 
 TEST(SdkMediaCodecBridgeTest, InvalidOpusHeader) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
-  scoped_ptr<media::AudioCodecBridge> media_codec;
+  std::unique_ptr<media::AudioCodecBridge> media_codec;
   media_codec.reset(AudioCodecBridge::Create(kCodecOpus));
   if (!media_codec)
     return;
 
   uint8_t dummy_extra_data[] = {0, 0};
 
   // Extra Data is NULL.
   EXPECT_FALSE(media_codec->ConfigureAndStart(kCodecOpus, 48000, 2, nullptr, 0,
                                               -1, 0, false, nullptr));
 
   // Codec Delay is < 0.
   EXPECT_FALSE(media_codec->ConfigureAndStart(
       kCodecOpus, 48000, 2, dummy_extra_data, sizeof(dummy_extra_data), -1, 0,
       false, nullptr));
 
   // Seek Preroll is < 0.
   EXPECT_FALSE(media_codec->ConfigureAndStart(
       kCodecOpus, 48000, 2, dummy_extra_data, sizeof(dummy_extra_data), 0, -1,
       false, nullptr));
 }
 
 TEST(SdkMediaCodecBridgeTest, PresentationTimestampsDoNotDecrease) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
-  scoped_ptr<VideoCodecBridge> media_codec(VideoCodecBridge::CreateDecoder(
+  std::unique_ptr<VideoCodecBridge> media_codec(VideoCodecBridge::CreateDecoder(
       kCodecVP8, false, gfx::Size(320, 240), nullptr, nullptr));
   EXPECT_TRUE(media_codec.get());
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vp8-I-frame-320x240");
   DecodeMediaFrame(media_codec.get(), buffer->data(), buffer->data_size(),
                    base::TimeDelta(), base::TimeDelta());
 
   // Simulate a seek to 10 seconds, and each chunk has 2 I-frames.
   std::vector<uint8_t> chunk(buffer->data(),
                              buffer->data() + buffer->data_size());
   chunk.insert(chunk.end(), buffer->data(),
@@ skipping 11 matching lines @@
 }
 
 TEST(SdkMediaCodecBridgeTest, CreateUnsupportedCodec) {
   EXPECT_EQ(nullptr, AudioCodecBridge::Create(kUnknownAudioCodec));
   EXPECT_EQ(nullptr, VideoCodecBridge::CreateDecoder(kUnknownVideoCodec, false,
                                                      gfx::Size(320, 240),
                                                      nullptr, nullptr));
 }
 
 }  // namespace media