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

media/filters/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 <vector>
 
 #include "base/bind.h"
@@ skipping 278 matching lines @@
     EXPECT_FALSE(pending_decode_);
     pending_reset_ = false;
   }
 
   // Generates an MD5 hash of the audio signal.  Should not be used for checks
   // across platforms as audio varies slightly across platforms.
   std::string GetDecodedAudioMD5(size_t i) {
     CHECK_LT(i, decoded_audio_.size());
     const scoped_refptr<AudioBuffer>& buffer = decoded_audio_[i];
 
-    scoped_ptr<AudioBus> output =
+    std::unique_ptr<AudioBus> output =
         AudioBus::Create(buffer->channel_count(), buffer->frame_count());
     buffer->ReadFrames(buffer->frame_count(), 0, 0, output.get());
 
     base::MD5Context context;
     base::MD5Init(&context);
     for (int ch = 0; ch < output->channels(); ++ch) {
       base::MD5Update(
           &context,
           base::StringPiece(reinterpret_cast<char*>(output->channel(ch)),
                             output->frames() * sizeof(*output->channel(ch))));
@@ skipping 21 matching lines @@
 
     const DecodedBufferExpectations& sample_info = GetParam().expectations[i];
 
     // Android MediaCodec returns wrong timestamps (shifted one frame forward)
     // for AAC before Android L. Ignore sample_info.timestamp in this situation.
     if (!SkipBufferTimestampCheck())
       EXPECT_EQ(sample_info.timestamp, buffer->timestamp().InMicroseconds());
     EXPECT_EQ(sample_info.duration, buffer->duration().InMicroseconds());
     EXPECT_FALSE(buffer->end_of_stream());
 
-    scoped_ptr<AudioBus> output =
+    std::unique_ptr<AudioBus> output =
         AudioBus::Create(buffer->channel_count(), buffer->frame_count());
     buffer->ReadFrames(buffer->frame_count(), 0, 0, output.get());
 
     // Generate a lossy hash of the audio used for comparison across platforms.
     AudioHash audio_hash;
     audio_hash.Update(output.get(), output->frames());
     EXPECT_TRUE(audio_hash.IsEquivalent(sample_info.hash, 0.02))
         << "Audio hashes differ. Expected: " << sample_info.hash
         << " Actual: " << audio_hash.ToString();
 
@@ skipping 10 matching lines @@
   size_t decoded_audio_size() const { return decoded_audio_.size(); }
   base::TimeDelta start_timestamp() const { return start_timestamp_; }
   const scoped_refptr<AudioBuffer>& decoded_audio(size_t i) {
     return decoded_audio_[i];
   }
   DecodeStatus last_decode_status() const { return last_decode_status_; }
 
  private:
   base::MessageLoop message_loop_;
   scoped_refptr<DecoderBuffer> data_;
-  scoped_ptr<InMemoryUrlProtocol> protocol_;
-  scoped_ptr<AudioFileReader> reader_;
+  std::unique_ptr<InMemoryUrlProtocol> protocol_;
+  std::unique_ptr<AudioFileReader> reader_;
 
-  scoped_ptr<AudioDecoder> decoder_;
+  std::unique_ptr<AudioDecoder> decoder_;
   bool pending_decode_;
   bool pending_reset_;
   DecodeStatus last_decode_status_;
 
   std::deque<scoped_refptr<AudioBuffer> > decoded_audio_;
   base::TimeDelta start_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDecoderTest);
 };
 
@@ skipping 232 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderTest,
                         AudioDecoderTest,
                         testing::ValuesIn(kFFmpegTests));
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderBehavioralTest,
                         FFmpegAudioDecoderBehavioralTest,
                         testing::ValuesIn(kFFmpegBehavioralTest));
 
 }  // namespace media