Convert //remoting to use std::unique_ptr

remoting/codec/audio_encoder_opus_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 get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "remoting/codec/audio_encoder_opus.h"
 
 #include <math.h>
@@ skipping 49 matching lines @@
                                 double frequency_hz,
                                 double pos,
                                 int channel) {
     double angle = pos * 2 * M_PI * frequency_hz / rate +
         kChannelPhaseShift * channel;
     return static_cast<int>(sin(angle) * kMaxSampleValue + 0.5);
   }
 
   // Creates  audio packet filled with a test signal with the specified
   // |frequency_hz|.
-  scoped_ptr<AudioPacket> CreatePacket(
-      int samples,
-      AudioPacket::SamplingRate rate,
-      double frequency_hz,
-      int pos) {
+  std::unique_ptr<AudioPacket> CreatePacket(int samples,
+                                            AudioPacket::SamplingRate rate,
+                                            double frequency_hz,
+                                            int pos) {
     std::vector<int16_t> data(samples * kChannels);
     for (int i = 0; i < samples; ++i) {
       data[i * kChannels] = GetSampleValue(rate, frequency_hz, i + pos, 0);
       data[i * kChannels + 1] = GetSampleValue(rate, frequency_hz, i + pos, 1);
     }
 
-    scoped_ptr<AudioPacket> packet(new AudioPacket());
+    std::unique_ptr<AudioPacket> packet(new AudioPacket());
     packet->add_data(reinterpret_cast<char*>(&(data[0])),
                      samples * kChannels * sizeof(int16_t));
     packet->set_encoding(AudioPacket::ENCODING_RAW);
     packet->set_sampling_rate(rate);
     packet->set_bytes_per_sample(AudioPacket::BYTES_PER_SAMPLE_2);
     packet->set_channels(AudioPacket::CHANNELS_STEREO);
     return packet;
   }
 
   // Decoded data is normally shifted in phase relative to the original signal.
@@ skipping 40 matching lines @@
                           double frequency_hz,
                           AudioPacket::SamplingRate rate) {
     const int kTotalTestSamples = 24000;
 
     encoder_.reset(new AudioEncoderOpus());
     decoder_.reset(new AudioDecoderOpus());
 
     std::vector<int16_t> received_data;
     int pos = 0;
     for (; pos < kTotalTestSamples; pos += packet_size) {
-        scoped_ptr<AudioPacket> source_packet =
-            CreatePacket(packet_size, rate, frequency_hz, pos);
-        scoped_ptr<AudioPacket> encoded =
-            encoder_->Encode(std::move(source_packet));
-        if (encoded.get()) {
-          scoped_ptr<AudioPacket> decoded =
-              decoder_->Decode(std::move(encoded));
-          EXPECT_EQ(kDefaultSamplingRate, decoded->sampling_rate());
-          for (int i = 0; i < decoded->data_size(); ++i) {
-            const int16_t* data =
-                reinterpret_cast<const int16_t*>(decoded->data(i).data());
-            received_data.insert(
-                received_data.end(), data,
-                data + decoded->data(i).size() / sizeof(int16_t));
-          }
+      std::unique_ptr<AudioPacket> source_packet =
+          CreatePacket(packet_size, rate, frequency_hz, pos);
+      std::unique_ptr<AudioPacket> encoded =
+          encoder_->Encode(std::move(source_packet));
+      if (encoded.get()) {
+        std::unique_ptr<AudioPacket> decoded =
+            decoder_->Decode(std::move(encoded));
+        EXPECT_EQ(kDefaultSamplingRate, decoded->sampling_rate());
+        for (int i = 0; i < decoded->data_size(); ++i) {
+          const int16_t* data =
+              reinterpret_cast<const int16_t*>(decoded->data(i).data());
+          received_data.insert(
+              received_data.end(), data,
+              data + decoded->data(i).size() / sizeof(int16_t));
+        }
         }
     }
 
     // Verify that at most kMaxLatencyMs worth of samples is buffered inside
     // |encoder_| and |decoder_|.
     EXPECT_GE(static_cast<int>(received_data.size()) / kChannels,
               pos - rate * kMaxLatencyMs / 1000);
 
     ValidateReceivedData(packet_size, kDefaultSamplingRate,
                          frequency_hz, received_data);
   }
 
  protected:
-  scoped_ptr<AudioEncoderOpus> encoder_;
-  scoped_ptr<AudioDecoderOpus> decoder_;
+  std::unique_ptr<AudioEncoderOpus> encoder_;
+  std::unique_ptr<AudioDecoderOpus> decoder_;
 };
 
 TEST_F(OpusAudioEncoderTest, CreateAndDestroy) {
 }
 
 TEST_F(OpusAudioEncoderTest, NoResampling) {
   TestEncodeDecode(2000, 50, AudioPacket::SAMPLING_RATE_48000);
   TestEncodeDecode(2000, 3000, AudioPacket::SAMPLING_RATE_48000);
   TestEncodeDecode(2000, 10000, AudioPacket::SAMPLING_RATE_48000);
 }
 
 TEST_F(OpusAudioEncoderTest, Resampling) {
   TestEncodeDecode(2000, 50, AudioPacket::SAMPLING_RATE_44100);
   TestEncodeDecode(2000, 3000, AudioPacket::SAMPLING_RATE_44100);
   TestEncodeDecode(2000, 10000, AudioPacket::SAMPLING_RATE_44100);
 }
 
 TEST_F(OpusAudioEncoderTest, BufferSizeAndResampling) {
   TestEncodeDecode(500, 3000, AudioPacket::SAMPLING_RATE_44100);
   TestEncodeDecode(1000, 3000, AudioPacket::SAMPLING_RATE_44100);
   TestEncodeDecode(5000, 3000, AudioPacket::SAMPLING_RATE_44100);
 }
 
 }  // namespace remoting