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

media/filters/decoder_selector.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 "decoder_selector.h"
+#include "media/filters/decoder_selector.h"
+
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
@@ skipping 36 matching lines @@
   }
   return false;
 }
 
 template <DemuxerStream::Type StreamType>
 DecoderSelector<StreamType>::DecoderSelector(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<Decoder> decoders,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
-      decoders_(decoders.Pass()),
+      decoders_(std::move(decoders)),
       media_log_(media_log),
       input_stream_(nullptr),
       weak_ptr_factory_(this) {}
 
 template <DemuxerStream::Type StreamType>
 DecoderSelector<StreamType>::~DecoderSelector() {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!select_decoder_cb_.is_null())
@@ skipping 62 matching lines @@
       output_cb_);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::DecryptingDecoderInitDone(bool success) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (success) {
     base::ResetAndReturn(&select_decoder_cb_)
-        .Run(decoder_.Pass(), scoped_ptr<DecryptingDemuxerStream>());
+        .Run(std::move(decoder_), scoped_ptr<DecryptingDemuxerStream>());
     return;
   }
 
   decoder_.reset();
 
   // When we get here decrypt-and-decode is not supported. Try to use
   // DecryptingDemuxerStream to do decrypt-only.
   InitializeDecryptingDemuxerStream();
 }
 #endif  // !defined(OS_ANDROID)
@@ skipping 57 matching lines @@
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!success) {
     decoder_.reset();
     InitializeDecoder();
     return;
   }
 
   base::ResetAndReturn(&select_decoder_cb_)
-      .Run(decoder_.Pass(), decrypted_stream_.Pass());
+      .Run(std::move(decoder_), std::move(decrypted_stream_));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::ReturnNullDecoder() {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::ResetAndReturn(&select_decoder_cb_)
       .Run(scoped_ptr<Decoder>(),
            scoped_ptr<DecryptingDemuxerStream>());
 }
 
 // These forward declarations tell the compiler that we will use
 // DecoderSelector with these arguments, allowing us to keep these definitions
 // in our .cc without causing linker errors. This also means if anyone tries to
 // instantiate a DecoderSelector with anything but these two specializations
 // they'll most likely get linker errors.
 template class DecoderSelector<DemuxerStream::AUDIO>;
 template class DecoderSelector<DemuxerStream::VIDEO>;
 
 }  // namespace media