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

media/renderers/renderer_impl_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 <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
@@ skipping 41 matching lines @@
    private:
     DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
   };
 
   RendererImplTest()
       : demuxer_(new StrictMock<MockDemuxer>()),
         video_renderer_(new StrictMock<MockVideoRenderer>()),
         audio_renderer_(new StrictMock<MockAudioRenderer>()),
         renderer_impl_(
             new RendererImpl(message_loop_.task_runner(),
-                             scoped_ptr<AudioRenderer>(audio_renderer_),
-                             scoped_ptr<VideoRenderer>(video_renderer_))),
+                             std::unique_ptr<AudioRenderer>(audio_renderer_),
+                             std::unique_ptr<VideoRenderer>(video_renderer_))),
         cdm_context_(new StrictMock<MockCdmContext>()),
         initialization_status_(PIPELINE_OK) {
     // SetDemuxerExpectations() adds overriding expectations for expected
     // non-NULL streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*demuxer_, GetStream(_))
         .WillRepeatedly(Return(null_pointer));
   }
 
   virtual ~RendererImplTest() { Destroy(); }
 
  protected:
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
 
   void Destroy() {
     renderer_impl_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
-  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 audio renderer to initialize.
   void SetAudioRendererInitializeExpectations(PipelineStatus status) {
     EXPECT_CALL(*audio_renderer_,
                 Initialize(audio_stream_.get(), _, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<4>(&audio_buffering_state_cb_),
                         SaveArg<5>(&audio_ended_cb_),
@@ skipping 162 matching lines @@
                            base::Bind(&CallbackHelper::OnCdmAttached,
                                       base::Unretained(&callbacks_)));
     base::RunLoop().RunUntilIdle();
   }
 
   // Fixture members.
   base::MessageLoop message_loop_;
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestTickClock test_tick_clock_;
 
-  scoped_ptr<StrictMock<MockDemuxer> > demuxer_;
+  std::unique_ptr<StrictMock<MockDemuxer>> demuxer_;
   StrictMock<MockVideoRenderer>* video_renderer_;
   StrictMock<MockAudioRenderer>* audio_renderer_;
-  scoped_ptr<RendererImpl> renderer_impl_;
-  scoped_ptr<StrictMock<MockCdmContext>> cdm_context_;
+  std::unique_ptr<RendererImpl> renderer_impl_;
+  std::unique_ptr<StrictMock<MockCdmContext>> cdm_context_;
 
   StrictMock<MockTimeSource> time_source_;
-  scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_;
-  scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
+  std::unique_ptr<StrictMock<MockDemuxerStream>> audio_stream_;
+  std::unique_ptr<StrictMock<MockDemuxerStream>> video_stream_;
   MockDemuxerStreamVector streams_;
   BufferingStateCB audio_buffering_state_cb_;
   BufferingStateCB video_buffering_state_cb_;
   base::Closure audio_ended_cb_;
   base::Closure video_ended_cb_;
   PipelineStatusCB audio_error_cb_;
   VideoDecoderConfig video_decoder_config_;
   PipelineStatus initialization_status_;
 
  private:
@@ skipping 425 matching lines @@
       .WillOnce(
           SetBufferingState(&audio_buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(*video_renderer_, StartPlayingFrom(kStartTime));
   renderer_impl_->StartPlayingFrom(kStartTime);
 
   // Nothing else should primed on the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media