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

media/cdm/cdm_adapter.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/cdm/cdm_adapter.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_initialized_promise.h"
 #include "media/base/cdm_key_information.h"
@@ skipping 321 matching lines @@
 
   scoped_refptr<CdmAdapter> cdm =
       new CdmAdapter(key_system, cdm_config, session_message_cb,
                      session_closed_cb, legacy_session_error_cb,
                      session_keys_change_cb, session_expiration_update_cb);
 
   // |cdm| ownership passed to the promise.
   scoped_ptr<CdmInitializedPromise> cdm_created_promise(
       new CdmInitializedPromise(cdm_created_cb, cdm));
 
-  cdm->Initialize(cdm_path, cdm_created_promise.Pass());
+  cdm->Initialize(cdm_path, std::move(cdm_created_promise));
 }
 
 CdmAdapter::CdmAdapter(
     const std::string& key_system,
     const CdmConfig& cdm_config,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb)
@@ skipping 66 matching lines @@
                                       scoped_ptr<SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (certificate.size() < limits::kMinCertificateLength ||
       certificate.size() > limits::kMaxCertificateLength) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0,
                     "Incorrect certificate.");
     return;
   }
 
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->SetServerCertificate(promise_id, certificate.data(),
                              certificate.size());
 }
 
 void CdmAdapter::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     scoped_ptr<NewSessionCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->CreateSessionAndGenerateRequest(
       promise_id, ToCdmSessionType(session_type),
       ToCdmInitDataType(init_data_type), init_data.data(), init_data.size());
 }
 
 void CdmAdapter::LoadSession(SessionType session_type,
                              const std::string& session_id,
                              scoped_ptr<NewSessionCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->LoadSession(promise_id, ToCdmSessionType(session_type),
                     session_id.data(), session_id.size());
 }
 
 void CdmAdapter::UpdateSession(const std::string& session_id,
                                const std::vector<uint8_t>& response,
                                scoped_ptr<SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!session_id.empty());
   DCHECK(!response.empty());
 
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->UpdateSession(promise_id, session_id.data(), session_id.size(),
                       response.data(), response.size());
 }
 
 void CdmAdapter::CloseSession(const std::string& session_id,
                               scoped_ptr<SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!session_id.empty());
 
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->CloseSession(promise_id, session_id.data(), session_id.size());
 }
 
 void CdmAdapter::RemoveSession(const std::string& session_id,
                                scoped_ptr<SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!session_id.empty());
 
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->RemoveSession(promise_id, session_id.data(), session_id.size());
 }
 
 CdmContext* CdmAdapter::GetCdmContext() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return this;
 }
 
 Decryptor* CdmAdapter::GetDecryptor() {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 137 matching lines @@
 
   const Decryptor::AudioFrames empty_frames;
   if (status != cdm::kSuccess) {
     DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
     audio_decode_cb.Run(ToMediaDecryptorStatus(status), empty_frames);
     return;
   }
 
   Decryptor::AudioFrames audio_frame_list;
   DCHECK(audio_frames->FrameBuffer());
-  if (!AudioFramesDataToAudioFrames(audio_frames.Pass(), &audio_frame_list)) {
+  if (!AudioFramesDataToAudioFrames(std::move(audio_frames),
+                                    &audio_frame_list)) {
     DVLOG(1) << __FUNCTION__ << " unable to convert Audio Frames";
     audio_decode_cb.Run(Decryptor::kError, empty_frames);
     return;
   }
 
   audio_decode_cb.Run(Decryptor::kSuccess, audio_frame_list);
 }
 
 void CdmAdapter::DecryptAndDecodeVideo(
     const scoped_refptr<DecoderBuffer>& encrypted,
@@ skipping 142 matching lines @@
   // TODO(jrummell): Handling resume playback should be done in the media
   // player, not in the Decryptors. http://crbug.com/413413.
   if (has_additional_usable_key) {
     if (!new_audio_key_cb_.is_null())
       new_audio_key_cb_.Run();
     if (!new_video_key_cb_.is_null())
       new_video_key_cb_.Run();
   }
 
   session_keys_change_cb_.Run(std::string(session_id, session_id_size),
-                              has_additional_usable_key, keys.Pass());
+                              has_additional_usable_key, std::move(keys));
 }
 
 void CdmAdapter::OnExpirationChange(const char* session_id,
                                     uint32_t session_id_size,
                                     cdm::Time new_expiry_time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   session_expiration_update_cb_.Run(std::string(session_id, session_id_size),
                                     base::Time::FromDoubleT(new_expiry_time));
 }
@@ skipping 127 matching lines @@
     result_frames->push_back(frame);
 
     data += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 }  // namespace media