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

media/base/audio_splicer_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.
 
+#include "media/base/audio_splicer.h"
+
+#include <memory>
+
 #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/audio_splicer.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/test_helpers.h"
 #include "media/base/timestamp_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 // Do not change this format.  AddInput() and GetValue() only work with float.
 static const SampleFormat kSampleFormat = kSampleFormatF32;
 static_assert(kSampleFormat == kSampleFormatF32, "invalid splice format");
@@ skipping 28 matching lines @@
     input_timestamp_helper_.AddFrames(frame_size);
     return buffer;
   }
 
   float GetValue(const scoped_refptr<AudioBuffer>& buffer) {
     return reinterpret_cast<const float*>(buffer->channel_data()[0])[0];
   }
 
   bool VerifyData(const scoped_refptr<AudioBuffer>& buffer, float value) {
     int frames = buffer->frame_count();
-    scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
+    std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
     buffer->ReadFrames(frames, 0, 0, bus.get());
     for (int ch = 0; ch < buffer->channel_count(); ++ch) {
       for (int i = 0; i < frames; ++i) {
         if (bus->channel(ch)[i] != value)
           return false;
       }
     }
     return true;
   }
 
@@ skipping 34 matching lines @@
 
     // The splice timestamp may be adjusted by a microsecond.
     EXPECT_NEAR(overlapping_buffer->timestamp().InMicroseconds(),
                 crossfade_output->timestamp().InMicroseconds(),
                 1);
 
     // Verify the actual crossfade.
     const int frames = crossfade_output->frame_count();
     float overlapped_value = GetValue(overlapped_buffer_1);
     const float overlapping_value = GetValue(overlapping_buffer);
-    scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
+    std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
     crossfade_output->ReadFrames(frames, 0, 0, bus.get());
     for (int ch = 0; ch < crossfade_output->channel_count(); ++ch) {
       float cf_ratio = 0;
       const float cf_increment = 1.0f / frames;
       for (int i = 0; i < frames; ++i, cf_ratio += cf_increment) {
         if (overlapped_buffer_2.get() && i >= second_overlap_index)
           overlapped_value = GetValue(overlapped_buffer_2);
         const float actual = bus->channel(ch)[i];
         const float expected =
             (1.0f - cf_ratio) * overlapped_value + cf_ratio * overlapping_value;
@@ skipping 635 matching lines @@
       second_buffer->timestamp() + second_buffer->duration();
   scoped_refptr<AudioBuffer> output = splicer_.GetNextBuffer();
   EXPECT_EQ(second_buffer_end_ts, output->timestamp());
   EXPECT_EQ(third_buffer->duration() -
                 (second_buffer_end_ts - third_buffer->timestamp()),
             output->duration());
   EXPECT_TRUE(VerifyData(output, GetValue(third_buffer)));
 }
 
 }  // namespace media