Convert //media/filters from scoped_ptr to std::unique_ptr

media/filters/audio_renderer_algorithm_unittest.cc

 // Copyright (c) 2012 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.
 //
 // The format of these tests are to enqueue a known amount of data and then
 // request the exact amount we expect in order to dequeue the known amount of
 // data.  This ensures that for any rate we are consuming input data at the
 // correct rate.  We always pass in a very large destination buffer with the
 // expectation that FillBuffer() will fill as much as it can but no more.
 
+#include "media/filters/audio_renderer_algorithm.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>  // For std::min().
 #include <cmath>
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/channel_layout.h"
 #include "media/base/test_helpers.h"
 #include "media/base/timestamp_constants.h"
-#include "media/filters/audio_renderer_algorithm.h"
 #include "media/filters/wsola_internals.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 const int kFrameSize = 250;
 const int kSamplesPerSecond = 3000;
 const int kOutputDurationInSec = 10;
 
 static void FillWithSquarePulseTrain(
@@ skipping 127 matching lines @@
     TestPlaybackRate(
         playback_rate, kDefaultBufferSize, kDefaultFramesRequested);
   }
 
   void TestPlaybackRate(double playback_rate,
                         int buffer_size_in_frames,
                         int total_frames_requested) {
     int initial_frames_enqueued = frames_enqueued_;
     int initial_frames_buffered = algorithm_.frames_buffered();
 
-    scoped_ptr<AudioBus> bus =
+    std::unique_ptr<AudioBus> bus =
         AudioBus::Create(channels_, buffer_size_in_frames);
     if (playback_rate == 0.0) {
       int frames_written = algorithm_.FillBuffer(
           bus.get(), 0, buffer_size_in_frames, playback_rate);
       EXPECT_EQ(0, frames_written);
       return;
     }
 
     bool expect_muted = (playback_rate < 0.5 || playback_rate > 4);
 
@@ skipping 54 matching lines @@
     channels_ = ChannelLayoutToChannelCount(kChannelLayout);
     AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
                            kSampleRateHz, kBytesPerSample * 8, kNumFrames);
     algorithm_.Initialize(params);
 
     // A pulse is 6 milliseconds (even number of samples).
     const int kPulseWidthSamples = 6 * kSampleRateHz / 1000;
     const int kHalfPulseWidthSamples = kPulseWidthSamples / 2;
 
     // For the ease of implementation get 1 frame every call to FillBuffer().
-    scoped_ptr<AudioBus> output = AudioBus::Create(channels_, 1);
+    std::unique_ptr<AudioBus> output = AudioBus::Create(channels_, 1);
 
     // Input buffer to inject pulses.
     scoped_refptr<AudioBuffer> input =
         AudioBuffer::CreateBuffer(kSampleFormatPlanarF32,
                                   kChannelLayout,
                                   channels_,
                                   kSampleRateHz,
                                   kPulseWidthSamples);
 
     const std::vector<uint8_t*>& channel_data = input->channel_data();
 
     // Fill |input| channels.
     FillWithSquarePulseTrain(kHalfPulseWidthSamples, 0, kPulseWidthSamples,
                              reinterpret_cast<float*>(channel_data[0]));
     FillWithSquarePulseTrain(kHalfPulseWidthSamples, kHalfPulseWidthSamples,
                              kPulseWidthSamples,
                              reinterpret_cast<float*>(channel_data[1]));
 
     // A buffer for the output until a complete pulse is created. Then
     // reference pulse is compared with this buffer.
-    scoped_ptr<AudioBus> pulse_buffer = AudioBus::Create(
-        channels_, kPulseWidthSamples);
+    std::unique_ptr<AudioBus> pulse_buffer =
+        AudioBus::Create(channels_, kPulseWidthSamples);
 
     const float kTolerance = 0.000001f;
     // Equivalent of 4 seconds.
     const int kNumRequestedPulses = kSampleRateHz * 4 / kPulseWidthSamples;
     for (int n = 0; n < kNumRequestedPulses; ++n) {
       int num_buffered_frames = 0;
       while (num_buffered_frames < kPulseWidthSamples) {
         int num_samples =
             algorithm_.FillBuffer(output.get(), 0, 1, playback_rate);
         ASSERT_LE(num_samples, 1);
@@ skipping 148 matching lines @@
   TestPlaybackRate(1.0);
   TestPlaybackRate(0.5);
   TestPlaybackRate(1.5);
 }
 
 TEST_F(AudioRendererAlgorithmTest, DotProduct) {
   const int kChannels = 3;
   const int kFrames = 20;
   const int kHalfPulseWidth = 2;
 
-  scoped_ptr<AudioBus> a = AudioBus::Create(kChannels, kFrames);
-  scoped_ptr<AudioBus> b = AudioBus::Create(kChannels, kFrames);
+  std::unique_ptr<AudioBus> a = AudioBus::Create(kChannels, kFrames);
+  std::unique_ptr<AudioBus> b = AudioBus::Create(kChannels, kFrames);
 
-  scoped_ptr<float[]> dot_prod(new float[kChannels]);
+  std::unique_ptr<float[]> dot_prod(new float[kChannels]);
 
   FillWithSquarePulseTrain(kHalfPulseWidth, 0, 0, a.get());
   FillWithSquarePulseTrain(kHalfPulseWidth, 1, 1, a.get());
   FillWithSquarePulseTrain(kHalfPulseWidth, 2, 2, a.get());
 
   FillWithSquarePulseTrain(kHalfPulseWidth, 0, 0, b.get());
   FillWithSquarePulseTrain(kHalfPulseWidth, 0, 1, b.get());
   FillWithSquarePulseTrain(kHalfPulseWidth, 0, 2, b.get());
 
   internal::MultiChannelDotProduct(a.get(), 0, b.get(), 0, kFrames,
                                    dot_prod.get());
 
   EXPECT_FLOAT_EQ(kFrames, dot_prod[0]);
   EXPECT_FLOAT_EQ(0, dot_prod[1]);
   EXPECT_FLOAT_EQ(-kFrames, dot_prod[2]);
 
   internal::MultiChannelDotProduct(a.get(), 4, b.get(), 8, kFrames / 2,
                                    dot_prod.get());
 
   EXPECT_FLOAT_EQ(kFrames / 2, dot_prod[0]);
   EXPECT_FLOAT_EQ(0, dot_prod[1]);
   EXPECT_FLOAT_EQ(-kFrames / 2, dot_prod[2]);
 }
 
 TEST_F(AudioRendererAlgorithmTest, MovingBlockEnergy) {
   const int kChannels = 2;
   const int kFrames = 20;
   const int kFramesPerBlock = 3;
   const int kNumBlocks = kFrames - (kFramesPerBlock - 1);
-  scoped_ptr<AudioBus> a = AudioBus::Create(kChannels, kFrames);
-  scoped_ptr<float[]> energies(new float[kChannels * kNumBlocks]);
+  std::unique_ptr<AudioBus> a = AudioBus::Create(kChannels, kFrames);
+  std::unique_ptr<float[]> energies(new float[kChannels * kNumBlocks]);
   float* ch_left = a->channel(0);
   float* ch_right = a->channel(1);
 
   // Fill up both channels.
   for (int n = 0; n < kFrames; ++n) {
     ch_left[n] = n;
     ch_right[n] = kFrames - 1 - n;
   }
 
   internal::MultiChannelMovingBlockEnergies(a.get(), kFramesPerBlock,
@@ skipping 20 matching lines @@
 TEST_F(AudioRendererAlgorithmTest, FullAndDecimatedSearch) {
   const int kFramesInSearchRegion = 12;
   const int kChannels = 2;
   float ch_0[] = {
       0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f };
   float ch_1[] = {
       0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.1f, 1.0f, 0.1f, 0.0f, 0.0f };
   ASSERT_EQ(sizeof(ch_0), sizeof(ch_1));
   ASSERT_EQ(static_cast<size_t>(kFramesInSearchRegion),
             sizeof(ch_0) / sizeof(*ch_0));
-  scoped_ptr<AudioBus> search_region = AudioBus::Create(kChannels,
-                                                        kFramesInSearchRegion);
+  std::unique_ptr<AudioBus> search_region =
+      AudioBus::Create(kChannels, kFramesInSearchRegion);
   float* ch = search_region->channel(0);
   memcpy(ch, ch_0, sizeof(float) * kFramesInSearchRegion);
   ch = search_region->channel(1);
   memcpy(ch, ch_1, sizeof(float) * kFramesInSearchRegion);
 
   const int kFramePerBlock = 4;
   float target_0[] = { 1.0f, 1.0f, 1.0f, 0.0f };
   float target_1[] = { 0.0f, 1.0f, 0.1f, 1.0f };
   ASSERT_EQ(sizeof(target_0), sizeof(target_1));
   ASSERT_EQ(static_cast<size_t>(kFramePerBlock),
             sizeof(target_0) / sizeof(*target_0));
 
-  scoped_ptr<AudioBus> target = AudioBus::Create(kChannels,
-                                                 kFramePerBlock);
+  std::unique_ptr<AudioBus> target =
+      AudioBus::Create(kChannels, kFramePerBlock);
   ch = target->channel(0);
   memcpy(ch, target_0, sizeof(float) * kFramePerBlock);
   ch = target->channel(1);
   memcpy(ch, target_1, sizeof(float) * kFramePerBlock);
 
-  scoped_ptr<float[]> energy_target(new float[kChannels]);
+  std::unique_ptr<float[]> energy_target(new float[kChannels]);
 
   internal::MultiChannelDotProduct(target.get(), 0, target.get(), 0,
                                    kFramePerBlock, energy_target.get());
 
   ASSERT_EQ(3.f, energy_target[0]);
   ASSERT_EQ(2.01f, energy_target[1]);
 
   const int kNumCandidBlocks = kFramesInSearchRegion - (kFramePerBlock - 1);
-  scoped_ptr<float[]> energy_candid_blocks(new float[kNumCandidBlocks *
-                                                     kChannels]);
+  std::unique_ptr<float[]> energy_candid_blocks(
+      new float[kNumCandidBlocks * kChannels]);
 
   internal::MultiChannelMovingBlockEnergies(
       search_region.get(), kFramePerBlock, energy_candid_blocks.get());
 
   // Check the energy of the candidate blocks of the first channel.
   ASSERT_FLOAT_EQ(0, energy_candid_blocks[0]);
   ASSERT_FLOAT_EQ(0, energy_candid_blocks[2]);
   ASSERT_FLOAT_EQ(1, energy_candid_blocks[4]);
   ASSERT_FLOAT_EQ(2, energy_candid_blocks[6]);
   ASSERT_FLOAT_EQ(3, energy_candid_blocks[8]);
@@ skipping 77 matching lines @@
   WsolaTest(0.6);
 }
 
 TEST_F(AudioRendererAlgorithmTest, WsolaSpeedup) {
   WsolaTest(1.6);
 }
 
 TEST_F(AudioRendererAlgorithmTest, FillBufferOffset) {
   Initialize();
 
-  scoped_ptr<AudioBus> bus = AudioBus::Create(channels_, kFrameSize);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(channels_, kFrameSize);
 
   // Verify that the first half of |bus| remains zero and the last half is
   // filled appropriately at normal, above normal, below normal, and muted
   // rates.
   const int kHalfSize = kFrameSize / 2;
   const float kAudibleRates[] = {1.0f, 2.0f, 0.5f};
   for (size_t i = 0; i < arraysize(kAudibleRates); ++i) {
     SCOPED_TRACE(kAudibleRates[i]);
     bus->Zero();
 
@@ skipping 14 matching lines @@
     const int frames_filled =
         algorithm_.FillBuffer(bus.get(), kHalfSize, kHalfSize, kMutedRates[i]);
     ASSERT_EQ(kHalfSize, frames_filled);
     ASSERT_FALSE(VerifyAudioData(bus.get(), 0, kHalfSize, 0));
     ASSERT_TRUE(VerifyAudioData(bus.get(), kHalfSize, kHalfSize, 0));
     FillAlgorithmQueue();
   }
 }
 
 }  // namespace media