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

media/base/pipeline.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 <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 55 matching lines @@
   DCHECK(!error_cb.is_null());
   DCHECK(!seek_cb.is_null());
   DCHECK(!metadata_cb.is_null());
   DCHECK(!buffering_state_cb.is_null());
 
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
   running_ = true;
 
   demuxer_ = demuxer;
-  renderer_ = renderer.Pass();
+  renderer_ = std::move(renderer);
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   seek_cb_ = seek_cb;
   metadata_cb_ = metadata_cb;
   buffering_state_cb_ = buffering_state_cb;
   duration_change_cb_ = duration_change_cb;
   add_text_track_cb_ = add_text_track_cb;
   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
 
   task_runner_->PostTask(
@@ skipping 47 matching lines @@
 void Pipeline::Suspend(const PipelineStatusCB& suspend_cb) {
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&Pipeline::SuspendTask, weak_factory_.GetWeakPtr(),
                             suspend_cb));
 }
 
 void Pipeline::Resume(scoped_ptr<Renderer> renderer,
                       base::TimeDelta timestamp,
                       const PipelineStatusCB& seek_cb) {
   task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Pipeline::ResumeTask, weak_factory_.GetWeakPtr(),
-                            base::Passed(renderer.Pass()), timestamp, seek_cb));
+      FROM_HERE,
+      base::Bind(&Pipeline::ResumeTask, weak_factory_.GetWeakPtr(),
+                 base::Passed(std::move(renderer)), timestamp, seek_cb));
 }
 
 float Pipeline::GetVolume() const {
   base::AutoLock auto_lock(lock_);
   return volume_;
 }
 
 void Pipeline::SetVolume(float volume) {
   if (volume < 0.0f || volume > 1.0f)
     return;
@@ skipping 537 matching lines @@
   if (state_ != kSuspended) {
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive resume in unexpected state: " << state_;
     seek_cb.Run(PIPELINE_ERROR_INVALID_STATE);
     return;
   }
   DCHECK(!renderer_);
   DCHECK(!pending_callbacks_.get());
 
   SetState(kResuming);
-  renderer_ = renderer.Pass();
+  renderer_ = std::move(renderer);
 
   // Set up for a seek. (Matches setup in SeekTask().)
   // TODO(sandersd): Share implementation with SeekTask().
   seek_cb_ = seek_cb;
   renderer_ended_ = false;
   text_renderer_ended_ = false;
   start_timestamp_ = std::max(timestamp, demuxer_->GetStartTime());
 
   // Queue the asynchronous actions required to start playback. Unlike DoSeek(),
   // we need to initialize the renderer ourselves (we don't want to enter state
@@ skipping 140 matching lines @@
   metadata_cb_.Run(metadata);
 }
 
 void Pipeline::BufferingStateChanged(BufferingState new_buffering_state) {
   DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
   DCHECK(task_runner_->BelongsToCurrentThread());
   buffering_state_cb_.Run(new_buffering_state);
 }
 
 }  // namespace media