Convert //media/cast from scoped_ptr to std::unique_ptr

media/cast/receiver/audio_decoder_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
@@ skipping 64 matching lines @@
 
     total_audio_feed_in_ = base::TimeDelta();
     total_audio_decoded_ = base::TimeDelta();
   }
 
   // Called from the unit test thread to create another EncodedFrame and push it
   // into the decoding pipeline.
   void FeedMoreAudio(const base::TimeDelta& duration,
                      int num_dropped_frames) {
     // Prepare a simulated EncodedFrame to feed into the AudioDecoder.
-    scoped_ptr<EncodedFrame> encoded_frame(
-        new EncodedFrame());
+    std::unique_ptr<EncodedFrame> encoded_frame(new EncodedFrame());
     encoded_frame->dependency = EncodedFrame::KEY;
     encoded_frame->frame_id = last_frame_id_ + 1 + num_dropped_frames;
     encoded_frame->referenced_frame_id = encoded_frame->frame_id;
     last_frame_id_ = encoded_frame->frame_id;
 
-    const scoped_ptr<AudioBus> audio_bus(
+    const std::unique_ptr<AudioBus> audio_bus(
         audio_bus_factory_->NextAudioBus(duration));
 
     // Encode |audio_bus| into |encoded_frame->data|.
     const int num_elements = audio_bus->channels() * audio_bus->frames();
     std::vector<int16_t> interleaved(num_elements);
     audio_bus->ToInterleaved(audio_bus->frames(), sizeof(int16_t),
                              &interleaved.front());
     if (GetParam().codec == CODEC_AUDIO_PCM16) {
       encoded_frame->data.resize(num_elements * sizeof(int16_t));
       int16_t* const pcm_data =
@@ skipping 39 matching lines @@
     base::AutoLock auto_lock(lock_);
     while (total_audio_decoded_ < total_audio_feed_in_)
       cond_.Wait();
     EXPECT_EQ(total_audio_feed_in_.InMicroseconds(),
               total_audio_decoded_.InMicroseconds());
   }
 
  private:
   // Called by |audio_decoder_| to deliver each frame of decoded audio.
   void OnDecodedFrame(bool should_be_continuous,
-                      scoped_ptr<AudioBus> audio_bus,
+                      std::unique_ptr<AudioBus> audio_bus,
                       bool is_continuous) {
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
     // A NULL |audio_bus| indicates a decode error, which we don't expect.
     ASSERT_TRUE(audio_bus);
 
     // Did the decoder detect whether frames were dropped?
     EXPECT_EQ(should_be_continuous, is_continuous);
 
     // Does the audio data seem to be intact?  For Opus, we have to ignore the
@@ skipping 15 matching lines @@
     }
 
     // Signal the main test thread that more audio was decoded.
     base::AutoLock auto_lock(lock_);
     total_audio_decoded_ += base::TimeDelta::FromSeconds(1) *
         audio_bus->frames() / GetParam().sampling_rate;
     cond_.Signal();
   }
 
   const scoped_refptr<StandaloneCastEnvironment> cast_environment_;
-  scoped_ptr<AudioDecoder> audio_decoder_;
-  scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
+  std::unique_ptr<AudioDecoder> audio_decoder_;
+  std::unique_ptr<TestAudioBusFactory> audio_bus_factory_;
   uint32_t last_frame_id_;
   bool seen_a_decoded_frame_;
-  scoped_ptr<uint8_t[]> opus_encoder_memory_;
+  std::unique_ptr<uint8_t[]> opus_encoder_memory_;
 
   base::Lock lock_;
   base::ConditionVariable cond_;
   base::TimeDelta total_audio_feed_in_;
   base::TimeDelta total_audio_decoded_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDecoderTest);
 };
 
 TEST_P(AudioDecoderTest, DecodesFramesWithSameDuration) {
@@ skipping 39 matching lines @@
     AudioDecoderTestScenarios,
     AudioDecoderTest,
     ::testing::Values(
          TestScenario(CODEC_AUDIO_PCM16, 1, 8000),
          TestScenario(CODEC_AUDIO_PCM16, 2, 48000),
          TestScenario(CODEC_AUDIO_OPUS, 1, 8000),
          TestScenario(CODEC_AUDIO_OPUS, 2, 48000)));
 
 }  // namespace cast
 }  // namespace media