Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/audio_modem/audio_player_unittest.cc

 // Copyright 2015 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 "components/audio_modem/audio_player.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/test/test_message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/audio_modem/audio_player_impl.h"
 #include "components/audio_modem/public/audio_modem_types.h"
 #include "components/audio_modem/test/random_samples.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/audio_bus.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class TestAudioOutputStream : public media::AudioOutputStream {
  public:
   using GatherSamplesCallback =
-      base::Callback<void(scoped_ptr<media::AudioBus>, int frames)>;
+      base::Callback<void(std::unique_ptr<media::AudioBus>, int frames)>;
   TestAudioOutputStream(int default_frame_count,
                         int max_frame_count,
                         GatherSamplesCallback gather_callback)
       : default_frame_count_(default_frame_count),
         max_frame_count_(max_frame_count),
         gather_callback_(gather_callback),
         callback_(nullptr) {
     caller_loop_ = base::MessageLoop::current();
   }
 
   ~TestAudioOutputStream() override {}
 
   bool Open() override { return true; }
   void Start(AudioSourceCallback* callback) override {
     callback_ = callback;
     GatherPlayedSamples();
   }
   void Stop() override {}
   void SetVolume(double volume) override {}
   void GetVolume(double* volume) override {}
   void Close() override {}
 
  private:
   void GatherPlayedSamples() {
     int frames = 0, total_frames = 0;
     do {
       // Call back into the player to get samples that it wants us to play.
-      scoped_ptr<media::AudioBus> dest =
+      std::unique_ptr<media::AudioBus> dest =
           media::AudioBus::Create(1, default_frame_count_);
       frames = callback_->OnMoreData(dest.get(), 0, 0);
       total_frames += frames;
       // Send the samples given to us by the player to the gather callback.
       caller_loop_->task_runner()->PostTask(
           FROM_HERE, base::Bind(gather_callback_, base::Passed(&dest), frames));
     } while (frames && total_frames < max_frame_count_);
   }
 
   int default_frame_count_;
@@ skipping 52 matching lines @@
     int differences = 0;
     for (int i = 0; i < kMaxFrameCount; ++i) {
       differences += (buffer_->channel(0)[i] !=
                       samples->channel(0)[i % samples->frames()]);
     }
     ASSERT_EQ(0, differences);
 
     buffer_.reset();
   }
 
-  void GatherSamples(scoped_ptr<media::AudioBus> bus, int frames) {
+  void GatherSamples(std::unique_ptr<media::AudioBus> bus, int frames) {
     if (!buffer_.get())
       return;
     bus->CopyPartialFramesTo(0, frames, buffer_index_, buffer_.get());
     buffer_index_ += frames;
   }
 
  protected:
   bool IsPlaying() {
     base::RunLoop().RunUntilIdle();
     return player_->is_playing_;
   }
 
   static const int kDefaultFrameCount = 1024;
   static const int kMaxFrameCount = 1024 * 100;
 
   base::TestMessageLoop message_loop_;
   media::ScopedAudioManagerPtr audio_manager_;
-  scoped_ptr<media::AudioBus> buffer_;
+  std::unique_ptr<media::AudioBus> buffer_;
   int buffer_index_;
 
   // Deleted by calling Finalize() on the object.
   AudioPlayerImpl* player_;
 };
 
 TEST_F(AudioPlayerTest, BasicPlayAndStop) {
   CreatePlayer();
   scoped_refptr<media::AudioBusRefCounted> samples =
       media::AudioBusRefCounted::Create(1, 7331);
@@ skipping 57 matching lines @@
 
   PlayAndVerifySamples(
       CreateRandomAudioRefCounted(0x7331, 1, kNumSamples - 3123));
 
   PlayAndVerifySamples(CreateRandomAudioRefCounted(0xf00d, 1, kNumSamples * 2));
 
   DeletePlayer();
 }
 
 }  // namespace audio_modem