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

media/filters/audio_file_reader_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 "media/filters/audio_file_reader.h"
+
+#include <memory>
+
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/md5.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_hash.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
-#include "media/filters/audio_file_reader.h"
 #include "media/filters/in_memory_url_protocol.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 class AudioFileReaderTest : public testing::Test {
  public:
   AudioFileReaderTest() : packet_verification_disabled_(false) {}
   ~AudioFileReaderTest() override {}
 
   void Initialize(const char* filename) {
     data_ = ReadTestDataFile(filename);
     protocol_.reset(
         new InMemoryUrlProtocol(data_->data(), data_->data_size(), false));
     reader_.reset(new AudioFileReader(protocol_.get()));
   }
 
   // Reads and the entire file provided to Initialize().
   void ReadAndVerify(const char* expected_audio_hash, int expected_frames) {
-    scoped_ptr<AudioBus> decoded_audio_data =
+    std::unique_ptr<AudioBus> decoded_audio_data =
         AudioBus::Create(reader_->channels(), reader_->GetNumberOfFrames());
     int actual_frames = reader_->Read(decoded_audio_data.get());
     ASSERT_LE(actual_frames, decoded_audio_data->frames());
     ASSERT_EQ(expected_frames, actual_frames);
 
     AudioHash audio_hash;
     audio_hash.Update(decoded_audio_data.get(), actual_frames);
     EXPECT_EQ(expected_audio_hash, audio_hash.ToString());
   }
 
@@ skipping 54 matching lines @@
   }
 
   void RunTestFailingDemux(const char* fn) {
     Initialize(fn);
     EXPECT_FALSE(reader_->Open());
   }
 
   void RunTestFailingDecode(const char* fn) {
     Initialize(fn);
     EXPECT_TRUE(reader_->Open());
-    scoped_ptr<AudioBus> decoded_audio_data =
+    std::unique_ptr<AudioBus> decoded_audio_data =
         AudioBus::Create(reader_->channels(), reader_->GetNumberOfFrames());
     EXPECT_EQ(reader_->Read(decoded_audio_data.get()), 0);
   }
 
   void disable_packet_verification() {
     packet_verification_disabled_ = true;
   }
 
  protected:
   scoped_refptr<DecoderBuffer> data_;
-  scoped_ptr<InMemoryUrlProtocol> protocol_;
-  scoped_ptr<AudioFileReader> reader_;
+  std::unique_ptr<InMemoryUrlProtocol> protocol_;
+  std::unique_ptr<AudioFileReader> reader_;
   bool packet_verification_disabled_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioFileReaderTest);
 };
 
 TEST_F(AudioFileReaderTest, WithoutOpen) {
   Initialize("bear.ogv");
 }
 
 TEST_F(AudioFileReaderTest, InvalidFile) {
@@ skipping 102 matching lines @@
   RunTest("4ch.wav",
           "131.71,38.02,130.31,44.89,135.98,42.52,",
           4,
           44100,
           base::TimeDelta::FromMicroseconds(100001),
           4411,
           4410);
 }
 
 }  // namespace media