Convert Pass()→std::move() in //media

media/base/pipeline_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.h"
+
 #include <stddef.h>
-
+#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"
 #include "media/base/fake_text_track_stream.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_filters.h"
-#include "media/base/pipeline.h"
 #include "media/base/test_helpers.h"
 #include "media/base/text_renderer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/time_delta_interpolator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::DeleteArg;
@@ skipping 131 matching lines @@
 
   void SetDemuxerExpectations(MockDemuxerStreamVector* streams) {
     // Initialize with a default non-zero duration.
     SetDemuxerExpectations(streams, base::TimeDelta::FromSeconds(10));
   }
 
   scoped_ptr<StrictMock<MockDemuxerStream> > CreateStream(
       DemuxerStream::Type type) {
     scoped_ptr<StrictMock<MockDemuxerStream> > stream(
         new StrictMock<MockDemuxerStream>(type));
-    return stream.Pass();
+    return stream;
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void SetRendererExpectations() {
     EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<3>(&buffering_state_cb_),
                         SaveArg<4>(&ended_cb_),
                         PostCallback<1>(PIPELINE_OK)));
     EXPECT_CALL(*renderer_, HasAudio()).WillRepeatedly(Return(audio_stream()));
     EXPECT_CALL(*renderer_, HasVideo()).WillRepeatedly(Return(video_stream()));
   }
 
   void AddTextStream() {
     EXPECT_CALL(*this, OnAddTextTrack(_,_))
         .WillOnce(Invoke(this, &PipelineTest::DoOnAddTextTrack));
     static_cast<DemuxerHost*>(pipeline_.get())->AddTextStream(text_stream(),
                               TextTrackConfig(kTextSubtitles, "", "", ""));
     message_loop_.RunUntilIdle();
   }
 
   void StartPipeline() {
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
     pipeline_->Start(
-        demuxer_.get(), scoped_renderer_.Pass(),
+        demuxer_.get(), std::move(scoped_renderer_),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnMetadata, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnBufferingStateChange,
                    base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnDurationChange,
                    base::Unretained(&callbacks_)),
         base::Bind(&PipelineTest::OnAddTextTrack, base::Unretained(this)),
         base::Bind(&PipelineTest::OnWaitingForDecryptionKey,
@@ skipping 24 matching lines @@
   }
 
   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());
     EXPECT_CALL(*text_stream, OnRead()).Times(AnyNumber());
-    text_stream_ = text_stream.Pass();
+    text_stream_ = std::move(text_stream);
   }
 
   MockDemuxerStream* audio_stream() {
     return audio_stream_.get();
   }
 
   MockDemuxerStream* video_stream() {
     return video_stream_.get();
   }
 
@@ skipping 56 matching lines @@
     EXPECT_CALL(*renderer_, SetVolume(_));
     EXPECT_CALL(*renderer_, StartPlayingFrom(seek_time))
         .WillOnce(
             SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(callbacks_, OnResume(PIPELINE_OK));
   }
 
   void DoResume(const base::TimeDelta& seek_time) {
     pipeline_->Resume(
-        scoped_renderer_.Pass(), seek_time,
+        std::move(scoped_renderer_), seek_time,
         base::Bind(&CallbackHelper::OnResume, base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
 
   void DestroyPipeline() {
     // In real code Pipeline could be destroyed on a different thread. All weak
     // pointers must have been invalidated before the stop callback returns.
     DCHECK(!pipeline_->HasWeakPtrsForTesting());
     pipeline_.reset();
   }
@@ skipping 10 matching lines @@
         .WillOnce(Invoke(this, &PipelineTest::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);
-    done_cb.Run(text_track.Pass());
+    done_cb.Run(std::move(text_track));
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestTickClock test_tick_clock_;
   base::MessageLoop message_loop_;
   scoped_ptr<Pipeline> pipeline_;
 
   scoped_ptr<StrictMock<MockDemuxer> > demuxer_;
   scoped_ptr<StrictMock<MockRenderer> > scoped_renderer_;
@@ skipping 794 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