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

media/base/audio_converter_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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
+#include "media/base/audio_converter.h"
+
 #include <stddef.h>
 
 #include <cmath>
+#include <memory>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
-#include "media/base/audio_converter.h"
 #include "media/base/fake_audio_render_callback.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 // Parameters which control the many input case tests.
 static const int kConvertInputs = 8;
 static const int kConvertCycles = 3;
 
@@ skipping 137 matching lines @@
     SetVolume(1);
     float scale = inputs > 1 ? inputs / 2.0f : inputs;
     for (int i = 0; i < kConvertCycles; ++i)
       ASSERT_TRUE(RenderAndValidateAudioData(scale));
   }
 
  protected:
   virtual ~AudioConverterTest() {}
 
   // Converter under test.
-  scoped_ptr<AudioConverter> converter_;
+  std::unique_ptr<AudioConverter> converter_;
 
   // Input and output parameters used for AudioConverter construction.
   AudioParameters input_parameters_;
   AudioParameters output_parameters_;
 
   // Destination AudioBus for AudioConverter output.
-  scoped_ptr<AudioBus> audio_bus_;
+  std::unique_ptr<AudioBus> audio_bus_;
 
   // AudioBus containing expected results for comparison with |audio_bus_|.
-  scoped_ptr<AudioBus> expected_audio_bus_;
+  std::unique_ptr<AudioBus> expected_audio_bus_;
 
   // Vector of all input callbacks used to drive AudioConverter::Convert().
   ScopedVector<FakeAudioRenderCallback> fake_callbacks_;
 
   // Parallel input callback which generates the expected output.
-  scoped_ptr<FakeAudioRenderCallback> expected_callback_;
+  std::unique_ptr<FakeAudioRenderCallback> expected_callback_;
 
   // Epsilon value with which to perform comparisons between |audio_bus_| and
   // |expected_audio_bus_|.
   double epsilon_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioConverterTest);
 };
 
 // Ensure the buffer delay provided by AudioConverter is accurate.
 TEST(AudioConverterTest, AudioDelayAndDiscreteChannelCount) {
   // Choose input and output parameters such that the transform must make
   // multiple calls to fill the buffer.
   AudioParameters input_parameters(AudioParameters::AUDIO_PCM_LINEAR,
                                    CHANNEL_LAYOUT_DISCRETE, kSampleRate,
                                    kBitsPerChannel, kLowLatencyBufferSize);
   input_parameters.set_channels_for_discrete(10);
   AudioParameters output_parameters(AudioParameters::AUDIO_PCM_LINEAR,
                                     CHANNEL_LAYOUT_DISCRETE, kSampleRate * 2,
                                     kBitsPerChannel, kHighLatencyBufferSize);
   output_parameters.set_channels_for_discrete(5);
 
   AudioConverter converter(input_parameters, output_parameters, false);
   FakeAudioRenderCallback callback(0.2);
-  scoped_ptr<AudioBus> audio_bus = AudioBus::Create(output_parameters);
+  std::unique_ptr<AudioBus> audio_bus = AudioBus::Create(output_parameters);
   converter.AddInput(&callback);
   converter.Convert(audio_bus.get());
 
   // Calculate the expected buffer delay for given AudioParameters.
   double input_sample_rate = input_parameters.sample_rate();
   int fill_count =
       (output_parameters.frames_per_buffer() * input_sample_rate /
        output_parameters.sample_rate()) / input_parameters.frames_per_buffer();
 
   base::TimeDelta input_frame_duration = base::TimeDelta::FromMicroseconds(
@@ skipping 33 matching lines @@
         // No resampling. No channel mixing.
         std::tr1::make_tuple(44100, 44100, CHANNEL_LAYOUT_STEREO, 0.00000048),
 
         // Upsampling. Channel upmixing.
         std::tr1::make_tuple(44100, 48000, CHANNEL_LAYOUT_QUAD, 0.033),
 
         // Downsampling. Channel downmixing.
         std::tr1::make_tuple(48000, 41000, CHANNEL_LAYOUT_MONO, 0.042)));
 
 }  // namespace media