Replace scoped_ptr with unique_ptr in webrtc/common_audio/

webrtc/common_audio/audio_converter_unittest.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <cmath>
 #include <algorithm>
+#include <memory>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/format_macros.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_audio/audio_converter.h"
 #include "webrtc/common_audio/channel_buffer.h"
 #include "webrtc/common_audio/resampler/push_sinc_resampler.h"
 
 namespace webrtc {
 
-typedef rtc::scoped_ptr<ChannelBuffer<float>> ScopedBuffer;
+typedef std::unique_ptr<ChannelBuffer<float>> ScopedBuffer;
 
 // Sets the signal value to increase by |data| with every sample.
 ScopedBuffer CreateBuffer(const std::vector<float>& data, size_t frames) {
   const size_t num_channels = data.size();
   ScopedBuffer sb(new ChannelBuffer<float>(frames, num_channels));
   for (size_t i = 0; i < num_channels; ++i)
     for (size_t j = 0; j < frames; ++j)
       sb->channels()[i][j] = data[i] * j;
   return sb;
 }
@@ skipping 89 matching lines @@
 
   // The sinc resampler has a known delay, which we compute here.
   const size_t delay_frames = src_sample_rate_hz == dst_sample_rate_hz ? 0 :
       static_cast<size_t>(
           PushSincResampler::AlgorithmicDelaySeconds(src_sample_rate_hz) *
           dst_sample_rate_hz);
   // SNR reported on the same line later.
   printf("(%" PRIuS ", %d Hz) -> (%" PRIuS ", %d Hz) ",
          src_channels, src_sample_rate_hz, dst_channels, dst_sample_rate_hz);
 
-  rtc::scoped_ptr<AudioConverter> converter = AudioConverter::Create(
+  std::unique_ptr<AudioConverter> converter = AudioConverter::Create(
       src_channels, src_frames, dst_channels, dst_frames);
   converter->Convert(src_buffer->channels(), src_buffer->size(),
                      dst_buffer->channels(), dst_buffer->size());
 
   EXPECT_LT(43.f,
             ComputeSNR(*ref_buffer.get(), *dst_buffer.get(), delay_frames));
 }
 
 TEST(AudioConverterTest, ConversionsPassSNRThreshold) {
   const int kSampleRates[] = {8000, 16000, 32000, 44100, 48000};
   const size_t kChannels[] = {1, 2};
   for (size_t src_rate = 0; src_rate < arraysize(kSampleRates); ++src_rate) {
     for (size_t dst_rate = 0; dst_rate < arraysize(kSampleRates); ++dst_rate) {
       for (size_t src_channel = 0; src_channel < arraysize(kChannels);
            ++src_channel) {
         for (size_t dst_channel = 0; dst_channel < arraysize(kChannels);
              ++dst_channel) {
           RunAudioConverterTest(kChannels[src_channel], kSampleRates[src_rate],
                                 kChannels[dst_channel], kSampleRates[dst_rate]);
         }
       }
     }
   }
 }
 
 }  // namespace webrtc