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

media/base/pipeline_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/base/pipeline_impl.h"
 
 #include <stddef.h>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/simple_thread.h"
 #include "base/time/clock.h"
@@ skipping 140 matching lines @@
       EXPECT_CALL(*demuxer_, GetStream(stream->type()))
           .WillRepeatedly(Return(stream));
     }
   }
 
   void SetDemuxerExpectations(MockDemuxerStreamVector* streams) {
     // Initialize with a default non-zero duration.
     SetDemuxerExpectations(streams, base::TimeDelta::FromSeconds(10));
   }
 
-  scoped_ptr<StrictMock<MockDemuxerStream>> CreateStream(
+  std::unique_ptr<StrictMock<MockDemuxerStream>> CreateStream(
       DemuxerStream::Type type) {
-    scoped_ptr<StrictMock<MockDemuxerStream>> stream(
+    std::unique_ptr<StrictMock<MockDemuxerStream>> stream(
         new StrictMock<MockDemuxerStream>(type));
     return stream;
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void SetRendererExpectations() {
     EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<2>(&statistics_cb_),
                         SaveArg<3>(&buffering_state_cb_),
                         SaveArg<4>(&ended_cb_), PostCallback<1>(PIPELINE_OK)));
@@ skipping 49 matching lines @@
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
   }
 
   void CreateVideoStream() {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
     video_stream_->set_video_decoder_config(video_decoder_config_);
   }
 
   void CreateTextStream() {
-    scoped_ptr<FakeTextTrackStream> text_stream(new FakeTextTrackStream());
+    std::unique_ptr<FakeTextTrackStream> text_stream(new FakeTextTrackStream());
     EXPECT_CALL(*text_stream, OnRead()).Times(AnyNumber());
     text_stream_ = std::move(text_stream);
   }
 
   MockDemuxerStream* audio_stream() { return audio_stream_.get(); }
 
   MockDemuxerStream* video_stream() { return video_stream_.get(); }
 
   FakeTextTrackStream* text_stream() { return text_stream_.get(); }
 
@@ skipping 81 matching lines @@
     EXPECT_CALL(callbacks_, OnStop())
         .WillOnce(Invoke(this, &PipelineImplTest::DestroyPipeline));
   }
 
   MOCK_METHOD2(OnAddTextTrack,
                void(const TextTrackConfig&, const AddTextTrackDoneCB&));
   MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
 
   void DoOnAddTextTrack(const TextTrackConfig& config,
                         const AddTextTrackDoneCB& done_cb) {
-    scoped_ptr<TextTrack> text_track(new MockTextTrack);
+    std::unique_ptr<TextTrack> text_track(new MockTextTrack);
     done_cb.Run(std::move(text_track));
   }
 
   void RunBufferedTimeRangesTest(const base::TimeDelta duration) {
     EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
     EXPECT_FALSE(pipeline_->DidLoadingProgress());
     Ranges<base::TimeDelta> ranges;
     ranges.Add(base::TimeDelta(), duration);
     pipeline_->OnBufferedTimeRangesChanged(ranges);
     EXPECT_TRUE(pipeline_->DidLoadingProgress());
     EXPECT_FALSE(pipeline_->DidLoadingProgress());
     EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
     EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
     EXPECT_EQ(duration, pipeline_->GetBufferedTimeRanges().end(0));
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestTickClock test_tick_clock_;
   base::MessageLoop message_loop_;
-  scoped_ptr<PipelineImpl> pipeline_;
+  std::unique_ptr<PipelineImpl> pipeline_;
 
-  scoped_ptr<StrictMock<MockDemuxer>> demuxer_;
-  scoped_ptr<StrictMock<MockRenderer>> scoped_renderer_;
+  std::unique_ptr<StrictMock<MockDemuxer>> demuxer_;
+  std::unique_ptr<StrictMock<MockRenderer>> scoped_renderer_;
   StrictMock<MockRenderer>* renderer_;
   StrictMock<CallbackHelper> text_renderer_callbacks_;
   TextRenderer* text_renderer_;
-  scoped_ptr<StrictMock<MockDemuxerStream>> audio_stream_;
-  scoped_ptr<StrictMock<MockDemuxerStream>> video_stream_;
-  scoped_ptr<FakeTextTrackStream> text_stream_;
+  std::unique_ptr<StrictMock<MockDemuxerStream>> audio_stream_;
+  std::unique_ptr<StrictMock<MockDemuxerStream>> video_stream_;
+  std::unique_ptr<FakeTextTrackStream> text_stream_;
   BufferingStateCB buffering_state_cb_;
   base::Closure ended_cb_;
   StatisticsCB statistics_cb_;
   VideoDecoderConfig video_decoder_config_;
   PipelineMetadata metadata_;
   base::TimeDelta start_time_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineImplTest);
 };
@@ skipping 779 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 INSTANTIATE_TEARDOWN_TEST(Error, Suspending);
 INSTANTIATE_TEARDOWN_TEST(Error, Suspended);
 INSTANTIATE_TEARDOWN_TEST(Error, Resuming);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Suspended);
 
 }  // namespace media