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

media/mojo/services/mojo_decryptor_service.cc

 // Copyright 2015 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/mojo/services/mojo_decryptor_service.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor.h"
 #include "media/base/media_keys.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/mojo/interfaces/demuxer_stream.mojom.h"
 #include "media/mojo/services/media_type_converters.h"
 
 namespace media {
 
 MojoDecryptorService::MojoDecryptorService(
     const scoped_refptr<MediaKeys>& cdm,
     mojo::InterfaceRequest<interfaces::Decryptor> request,
     const mojo::Closure& error_handler)
-    : binding_(this, request.Pass()), cdm_(cdm), weak_factory_(this) {
+    : binding_(this, std::move(request)), cdm_(cdm), weak_factory_(this) {
   decryptor_ = cdm->GetCdmContext()->GetDecryptor();
   DCHECK(decryptor_);
   weak_this_ = weak_factory_.GetWeakPtr();
   binding_.set_connection_error_handler(error_handler);
 }
 
 MojoDecryptorService::~MojoDecryptorService() {}
 
 void MojoDecryptorService::Initialize(
     mojo::ScopedDataPipeConsumerHandle receive_pipe,
@@ skipping 102 matching lines @@
 }
 
 void MojoDecryptorService::OnAudioDecoded(
     const DecryptAndDecodeAudioCallback& callback,
     media::Decryptor::Status status,
     const media::Decryptor::AudioFrames& frames) {
   DVLOG(status != media::Decryptor::kSuccess ? 1 : 3) << __FUNCTION__ << "("
                                                       << status << ")";
   mojo::Array<interfaces::AudioBufferPtr> audio_buffers;
   for (const auto& frame : frames)
-    audio_buffers.push_back(interfaces::AudioBuffer::From(frame).Pass());
+    audio_buffers.push_back(interfaces::AudioBuffer::From(frame));
 
-  callback.Run(static_cast<Decryptor::Status>(status), audio_buffers.Pass());
+  callback.Run(static_cast<Decryptor::Status>(status),
+               std::move(audio_buffers));
 }
 
 void MojoDecryptorService::OnVideoDecoded(
     const DecryptAndDecodeVideoCallback& callback,
     media::Decryptor::Status status,
     const scoped_refptr<VideoFrame>& frame) {
   DVLOG(status != media::Decryptor::kSuccess ? 1 : 3) << __FUNCTION__ << "("
                                                       << status << ")";
   if (!frame) {
     DCHECK_NE(status, media::Decryptor::kSuccess);
     callback.Run(static_cast<Decryptor::Status>(status), nullptr);
     return;
   }
 
   callback.Run(static_cast<Decryptor::Status>(status),
-               interfaces::VideoFrame::From(frame).Pass());
+               interfaces::VideoFrame::From(frame));
 }
 
 interfaces::DecoderBufferPtr MojoDecryptorService::TransferDecoderBuffer(
     const scoped_refptr<DecoderBuffer>& encrypted) {
   interfaces::DecoderBufferPtr buffer =
       interfaces::DecoderBuffer::From(encrypted);
   if (encrypted->end_of_stream())
     return buffer;
 
   // Serialize the data section of the DecoderBuffer into our pipe.
@@ skipping 17 matching lines @@
   uint32_t num_bytes = media_buffer->data_size();
   DCHECK_GT(num_bytes, 0u);
   CHECK_EQ(ReadDataRaw(consumer_handle_.get(), media_buffer->writable_data(),
                        &num_bytes, MOJO_READ_DATA_FLAG_ALL_OR_NONE),
            MOJO_RESULT_OK);
   CHECK_EQ(num_bytes, static_cast<uint32_t>(media_buffer->data_size()));
   return media_buffer;
 }
 
 }  // namespace media