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

chromecast/renderer/media/cma_renderer.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 "chromecast/renderer/media/cma_renderer.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chromecast/media/cma/base/balanced_media_task_runner_factory.h"
 #include "chromecast/media/cma/base/cma_logging.h"
 #include "chromecast/media/cma/pipeline/av_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/media_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/video_pipeline_client.h"
@@ skipping 22 matching lines @@
 void MediaPipelineClientDummyCallback() {
 }
 
 }  // namespace
 
 CmaRenderer::CmaRenderer(scoped_ptr<MediaPipelineProxy> media_pipeline,
                          ::media::VideoRendererSink* video_renderer_sink,
                          ::media::GpuVideoAcceleratorFactories* gpu_factories)
     : media_task_runner_factory_(
           new BalancedMediaTaskRunnerFactory(kMaxDeltaFetcher)),
-      media_pipeline_(media_pipeline.Pass()),
+      media_pipeline_(std::move(media_pipeline)),
       audio_pipeline_(media_pipeline_->GetAudioPipeline()),
       video_pipeline_(media_pipeline_->GetVideoPipeline()),
       video_renderer_sink_(video_renderer_sink),
       state_(kUninitialized),
       is_pending_transition_(false),
       has_audio_(false),
       has_video_(false),
       received_audio_eos_(false),
       received_video_eos_(false),
       initial_natural_size_(gfx::Size()),
@@ skipping 206 matching lines @@
       base::Bind(&CmaRenderer::OnStatisticsUpdated, weak_this_));
   audio_pipeline_->SetClient(av_pipeline_client);
 
   scoped_ptr<CodedFrameProvider> frame_provider(new DemuxerStreamAdapter(
       base::ThreadTaskRunnerHandle::Get(), media_task_runner_factory_, stream));
 
   const ::media::AudioDecoderConfig& config = stream->audio_decoder_config();
   if (config.codec() == ::media::kCodecAAC)
     stream->EnableBitstreamConverter();
 
-  media_pipeline_->InitializeAudio(
-      config, frame_provider.Pass(), audio_initialization_done_cb);
+  media_pipeline_->InitializeAudio(config, std::move(frame_provider),
+                                   audio_initialization_done_cb);
 }
 
 void CmaRenderer::OnAudioPipelineInitializeDone(
     bool audio_stream_present,
     ::media::PipelineStatus status) {
   CMALOG(kLogControl) << __FUNCTION__ << ": state=" << state_;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // OnError() may be fired at any time, even before initialization is complete.
   if (state_ == kError)
@@ skipping 46 matching lines @@
       base::ThreadTaskRunnerHandle::Get(), media_task_runner_factory_, stream));
 
   const ::media::VideoDecoderConfig& config = stream->video_decoder_config();
   if (config.codec() == ::media::kCodecH264)
     stream->EnableBitstreamConverter();
 
   initial_natural_size_ = config.natural_size();
 
   std::vector<::media::VideoDecoderConfig> configs;
   configs.push_back(config);
-  media_pipeline_->InitializeVideo(
-      configs, frame_provider.Pass(), video_initialization_done_cb);
+  media_pipeline_->InitializeVideo(configs, std::move(frame_provider),
+                                   video_initialization_done_cb);
 }
 
 void CmaRenderer::OnVideoPipelineInitializeDone(
     bool video_stream_present,
     ::media::PipelineStatus status) {
   CMALOG(kLogControl) << __FUNCTION__ << ": state=" << state_;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // OnError() may be fired at any time, even before initialization is complete.
   if (state_ == kError)
@@ skipping 127 matching lines @@
   is_pending_transition_ = true;
 }
 
 void CmaRenderer::CompleteStateTransition(State new_state) {
   state_ = new_state;
   is_pending_transition_ = false;
 }
 
 }  // namespace media
 }  // namespace chromecast