Replace scoped_ptr with std::unique_ptr in //media.

media/renderers/audio_renderer_impl_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/renderers/audio_renderer_impl.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/audio_buffer_converter.h"
@@ skipping 275 matching lines @@
     while (frames_remaining_in_buffer().value > 0) {
       SatisfyPendingRead(InputFrames(256));
     }
   }
 
   // Attempts to consume |requested_frames| frames from |renderer_|'s internal
   // buffer. Returns true if and only if all of |requested_frames| were able
   // to be consumed.
   bool ConsumeBufferedData(OutputFrames requested_frames,
                            uint32_t delay_frames) {
-    scoped_ptr<AudioBus> bus =
+    std::unique_ptr<AudioBus> bus =
         AudioBus::Create(kChannels, requested_frames.value);
     int frames_read = 0;
     EXPECT_TRUE(sink_->Render(bus.get(), delay_frames, &frames_read));
     return frames_read == requested_frames.value;
   }
 
   bool ConsumeBufferedData(OutputFrames requested_frames) {
     return ConsumeBufferedData(requested_frames, 0);
   }
 
@@ skipping 43 matching lines @@
   }
 
   base::TimeDelta CurrentMediaTime() {
     return renderer_->CurrentMediaTime();
   }
 
   bool ended() const { return ended_; }
 
   // Fixture members.
   base::MessageLoop message_loop_;
-  scoped_ptr<AudioRendererImpl> renderer_;
+  std::unique_ptr<AudioRendererImpl> renderer_;
   scoped_refptr<FakeAudioRendererSink> sink_;
   AudioHardwareConfig hardware_config_;
   base::SimpleTestTickClock* tick_clock_;
   PipelineStatistics last_statistics_;
 
  private:
   void DecodeDecoder(const scoped_refptr<DecoderBuffer>& buffer,
                      const AudioDecoder::DecodeCB& decode_cb) {
     // TODO(scherkus): Make this a DCHECK after threading semantics are fixed.
     if (base::MessageLoop::current() != &message_loop_) {
@@ skipping 41 matching lines @@
     ended_ = true;
   }
 
   MockDemuxerStream demuxer_stream_;
   MockAudioDecoder* decoder_;
 
   // Used for satisfying reads.
   AudioDecoder::OutputCB output_cb_;
   AudioDecoder::DecodeCB decode_cb_;
   base::Closure reset_cb_;
-  scoped_ptr<AudioTimestampHelper> next_timestamp_;
+  std::unique_ptr<AudioTimestampHelper> next_timestamp_;
 
   // Run during DecodeDecoder() to unblock WaitForPendingRead().
   base::Closure wait_for_pending_decode_cb_;
 
   AudioDecoder::InitCB init_decoder_cb_;
   bool ended_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererImplTest);
 };
 
@@ skipping 282 matching lines @@
   // through the desired output buffer; this allows for maximum test coverage.
   const double kBuffers = 4.5;
   const base::TimeDelta first_timestamp = base::TimeDelta::FromSecondsD(
       hardware_config_.GetOutputBufferSize() * kBuffers /
       hardware_config_.GetOutputSampleRate());
 
   Preroll(base::TimeDelta(), first_timestamp, PIPELINE_OK);
   StartTicking();
 
   // Verify the first few buffers are silent.
-  scoped_ptr<AudioBus> bus =
+  std::unique_ptr<AudioBus> bus =
       AudioBus::Create(hardware_config_.GetOutputConfig());
   int frames_read = 0;
   for (int i = 0; i < std::floor(kBuffers); ++i) {
     EXPECT_TRUE(sink_->Render(bus.get(), 0, &frames_read));
     EXPECT_EQ(frames_read, bus->frames());
     for (int j = 0; j < bus->frames(); ++j)
       ASSERT_FLOAT_EQ(0.0f, bus->channel(0)[j]);
     WaitForPendingRead();
     DeliverRemainingAudio();
   }
@@ skipping 195 matching lines @@
   // Advance far enough that we shouldn't be clamped to current time (tested
   // already above).
   tick_clock_->Advance(kOneSecond);
   EXPECT_EQ(
       current_time + timestamp_helper.GetFrameDuration(frames_to_consume.value),
       CurrentMediaWallClockTime(&is_time_moving));
   EXPECT_TRUE(is_time_moving);
 }
 
 }  // namespace media