Convert //remoting to use std::unique_ptr

remoting/client/audio_player_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 "remoting/client/audio_player.h"
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const int kAudioSamplesPerFrame = 25;
 const int kAudioSampleBytes = 4;
 const int kAudioFrameBytes = kAudioSamplesPerFrame * kAudioSampleBytes;
 const int kPaddingBytes = 16;
 
 // TODO(garykac): Generate random audio data in the tests rather than having
@@ skipping 54 matching lines @@
   }
 
   int GetNumQueuedPackets() {
     return static_cast<int>(audio_->queued_packets_.size());
   }
 
   int GetBytesConsumed() {
     return static_cast<int>(audio_->bytes_consumed_);
   }
 
-  scoped_ptr<AudioPlayer> audio_;
-  scoped_ptr<char[]> buffer_;
+  std::unique_ptr<AudioPlayer> audio_;
+  std::unique_ptr<char[]> buffer_;
 };
 
-scoped_ptr<AudioPacket> CreatePacketWithSamplingRate(
-      AudioPacket::SamplingRate rate, int samples) {
-  scoped_ptr<AudioPacket> packet(new AudioPacket());
+std::unique_ptr<AudioPacket> CreatePacketWithSamplingRate(
+    AudioPacket::SamplingRate rate,
+    int samples) {
+  std::unique_ptr<AudioPacket> packet(new AudioPacket());
   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);
 
   // The data must be a multiple of 4 bytes (channels x bytes_per_sample).
   std::string data;
   data.resize(samples * kAudioSampleBytes, kDummyAudioData);
   packet->add_data(data);
 
   return packet;
 }
 
-scoped_ptr<AudioPacket> CreatePacket44100Hz(int samples) {
+std::unique_ptr<AudioPacket> CreatePacket44100Hz(int samples) {
   return CreatePacketWithSamplingRate(AudioPacket::SAMPLING_RATE_44100,
                                       samples);
 }
 
-scoped_ptr<AudioPacket> CreatePacket48000Hz(int samples) {
+std::unique_ptr<AudioPacket> CreatePacket48000Hz(int samples) {
   return CreatePacketWithSamplingRate(AudioPacket::SAMPLING_RATE_48000,
                                       samples);
 }
 
 TEST_F(AudioPlayerTest, Init) {
   ASSERT_EQ(0, GetNumQueuedPackets());
 
   audio_->ProcessAudioPacket(CreatePacket44100Hz(10));
   ASSERT_EQ(1, GetNumQueuedPackets());
 }
@@ skipping 182 matching lines @@
 
   // Attempt to consume a frame of 25 samples.
   ConsumeAudioFrame();
   ASSERT_EQ(0, GetNumQueuedSamples());
   ASSERT_EQ(0, GetNumQueuedPackets());
   ASSERT_EQ(0, GetBytesConsumed());
   CheckAudioFrameBytes(packet1_samples * kAudioSampleBytes);
 }
 
 }  // namespace remoting