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

media/base/audio_buffer_unittest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include <limits>
+#include <memory>
 
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 static const int kSampleRate = 48000;
 
@@ skipping 27 matching lines @@
                                                              channels,
                                                              kSampleRate,
                                                              0,
                                                              1,
                                                              frames,
                                                              timestamp);
   EXPECT_EQ(frames, buffer->frame_count());
   EXPECT_EQ(timestamp, buffer->timestamp());
   EXPECT_EQ(duration, buffer->duration());
 
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
 
   // Verify all frames before trimming.
   buffer->ReadFrames(frames, 0, 0, bus.get());
   VerifyBus(bus.get(), frames, 0, 1);
 
   // Trim 10ms of frames from the middle of the buffer.
   int trim_start = frames / 2;
   const int trim_length = kSampleRate / 100;
   const base::TimeDelta trim_duration = base::TimeDelta::FromMilliseconds(10);
   buffer->TrimRange(trim_start, trim_start + trim_length);
@@ skipping 141 matching lines @@
 }
 
 TEST(AudioBufferTest, ReadU8) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_4_0;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 10;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<uint8_t>(kSampleFormatU8, channel_layout, channels,
                                kSampleRate, 128, 1, frames, start_time);
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(frames, 0, 0, bus.get());
   VerifyBus(bus.get(), frames, 0, 1.0f / 127.0f);
 
   // Now read the same data one frame at a time.
   bus->Zero();
   for (int i = 0; i < frames; ++i)
     buffer->ReadFrames(1, i, i, bus.get());
   VerifyBus(bus.get(), frames, 0, 1.0f / 127.0f);
 }
 
 TEST(AudioBufferTest, ReadS16) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 10;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<int16_t>(kSampleFormatS16, channel_layout, channels,
                                kSampleRate, 1, 1, frames, start_time);
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(frames, 0, 0, bus.get());
   VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
             1.0f / std::numeric_limits<int16_t>::max());
 
   // Now read the same data one frame at a time.
   bus->Zero();
   for (int i = 0; i < frames; ++i)
     buffer->ReadFrames(1, i, i, bus.get());
   VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
             1.0f / std::numeric_limits<int16_t>::max());
 }
 
 TEST(AudioBufferTest, ReadS32) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 20;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<int32_t>(kSampleFormatS32, channel_layout, channels,
                                kSampleRate, 1, 1, frames, start_time);
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(frames, 0, 0, bus.get());
   VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int32_t>::max(),
             1.0f / std::numeric_limits<int32_t>::max());
 
   // Read second 10 frames.
   bus->Zero();
   buffer->ReadFrames(10, 10, 0, bus.get());
   VerifyBus(bus.get(), 10, 11.0f / std::numeric_limits<int32_t>::max(),
             1.0f / std::numeric_limits<int32_t>::max());
 }
 
 TEST(AudioBufferTest, ReadF32) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 20;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<float>(kSampleFormatF32,
                                                              channel_layout,
                                                              channels,
                                                              kSampleRate,
                                                              1.0f,
                                                              1.0f,
                                                              frames,
                                                              start_time);
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(10, 0, 0, bus.get());
   VerifyBus(bus.get(), 10, 1, 1);
 
   // Read second 10 frames.
   bus->Zero();
   buffer->ReadFrames(10, 10, 0, bus.get());
   VerifyBus(bus.get(), 10, 11, 1);
 }
 
 TEST(AudioBufferTest, ReadS16Planar) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 20;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<int16_t>(kSampleFormatPlanarS16, channel_layout, channels,
                                kSampleRate, 1, 1, frames, start_time);
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(10, 0, 0, bus.get());
   VerifyBus(bus.get(), 10, 1.0f / std::numeric_limits<int16_t>::max(),
             1.0f / std::numeric_limits<int16_t>::max());
 
   // Read all the frames backwards, one by one. ch[0] should be 20, 19, ...
   bus->Zero();
   for (int i = frames - 1; i >= 0; --i)
     buffer->ReadFrames(1, i, i, bus.get());
   VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
             1.0f / std::numeric_limits<int16_t>::max());
@@ skipping 22 matching lines @@
                              channels,
                              kSampleRate,
                              1.0f,
                              1.0f,
                              frames,
                              start_time);
 
   // Read all 100 frames from the buffer. F32 is planar, so ch[0] should be 1,
   // 2, 3, 4, ..., ch[1] should be 101, 102, 103, ..., and so on for all 4
   // channels.
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
   buffer->ReadFrames(frames, 0, 0, bus.get());
   VerifyBus(bus.get(), frames, 1, 1);
 
   // Now read 20 frames from the middle of the buffer.
   bus->Zero();
   buffer->ReadFrames(20, 50, 0, bus.get());
   VerifyBus(bus.get(), 20, 51, 1);
 }
 
 TEST(AudioBufferTest, EmptyBuffer) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_4_0;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = kSampleRate / 100;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer = AudioBuffer::CreateEmptyBuffer(
       channel_layout, channels, kSampleRate, frames, start_time);
   EXPECT_EQ(frames, buffer->frame_count());
   EXPECT_EQ(start_time, buffer->timestamp());
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(10), buffer->duration());
   EXPECT_FALSE(buffer->end_of_stream());
 
   // Read all 100 frames from the buffer. All data should be 0.
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(frames, 0, 0, bus.get());
   VerifyBus(bus.get(), frames, 0, 0);
 }
 
 TEST(AudioBufferTest, Trim) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_4_0;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = kSampleRate / 10;
   const base::TimeDelta start_time;
   const base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<float>(kSampleFormatPlanarF32,
                              channel_layout,
                              channels,
                              kSampleRate,
                              0.0f,
                              1.0f,
                              frames,
                              start_time);
   EXPECT_EQ(frames, buffer->frame_count());
   EXPECT_EQ(start_time, buffer->timestamp());
   EXPECT_EQ(duration, buffer->duration());
 
   const int ten_ms_of_frames = kSampleRate / 100;
   const base::TimeDelta ten_ms = base::TimeDelta::FromMilliseconds(10);
 
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(buffer->frame_count(), 0, 0, bus.get());
   VerifyBus(bus.get(), buffer->frame_count(), 0.0f, 1.0f);
 
   // Trim off 10ms of frames from the start.
   buffer->TrimStart(ten_ms_of_frames);
   EXPECT_EQ(start_time + ten_ms, buffer->timestamp());
   EXPECT_EQ(frames - ten_ms_of_frames, buffer->frame_count());
   EXPECT_EQ(duration - ten_ms, buffer->duration());
   buffer->ReadFrames(buffer->frame_count(), 0, 0, bus.get());
   VerifyBus(bus.get(), buffer->frame_count(), ten_ms_of_frames, 1.0f);
@@ skipping 143 matching lines @@
 
 TEST(AudioBufferTest, ReadFramesInterleavedS16FromPlanarS16) {
   ReadFramesInterleavedS16Test(kSampleFormatPlanarS16);
 }
 
 TEST(AudioBufferTest, ReadFramesInterleavedS16FromPlanarF32) {
   ReadFramesInterleavedS16Test(kSampleFormatPlanarF32);
 }
 
 }  // namespace media