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

media/mojo/services/mojo_cdm.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 "media/mojo/services/mojo_cdm.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 24 matching lines @@
     const GURL& security_origin,
     const media::CdmConfig& cdm_config,
     interfaces::ContentDecryptionModulePtr remote_cdm,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::LegacySessionErrorCB& legacy_session_error_cb,
     const media::SessionKeysChangeCB& session_keys_change_cb,
     const media::SessionExpirationUpdateCB& session_expiration_update_cb,
     const media::CdmCreatedCB& cdm_created_cb) {
   scoped_refptr<MojoCdm> mojo_cdm(
-      new MojoCdm(remote_cdm.Pass(), session_message_cb, session_closed_cb,
+      new MojoCdm(std::move(remote_cdm), session_message_cb, session_closed_cb,
                   legacy_session_error_cb, session_keys_change_cb,
                   session_expiration_update_cb));
 
   // |mojo_cdm| ownership is passed to the promise.
   scoped_ptr<CdmInitializedPromise> promise(
       new CdmInitializedPromise(cdm_created_cb, mojo_cdm));
 
   mojo_cdm->InitializeCdm(key_system, security_origin, cdm_config,
-                          promise.Pass());
+                          std::move(promise));
 }
 
 MojoCdm::MojoCdm(interfaces::ContentDecryptionModulePtr remote_cdm,
                  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)
-    : remote_cdm_(remote_cdm.Pass()),
+    : remote_cdm_(std::move(remote_cdm)),
       binding_(this),
       cdm_id_(CdmContext::kInvalidCdmId),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
       legacy_session_error_cb_(legacy_session_error_cb),
       session_keys_change_cb_(session_keys_change_cb),
       session_expiration_update_cb_(session_expiration_update_cb),
       weak_factory_(this) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
   DCHECK(!legacy_session_error_cb_.is_null());
   DCHECK(!session_keys_change_cb_.is_null());
   DCHECK(!session_expiration_update_cb_.is_null());
 
   interfaces::ContentDecryptionModuleClientPtr client_ptr;
   binding_.Bind(GetProxy(&client_ptr));
-  remote_cdm_->SetClient(client_ptr.Pass());
+  remote_cdm_->SetClient(std::move(client_ptr));
 }
 
 MojoCdm::~MojoCdm() {
   DVLOG(1) << __FUNCTION__;
 }
 
 void MojoCdm::InitializeCdm(const std::string& key_system,
                             const GURL& security_origin,
                             const media::CdmConfig& cdm_config,
                             scoped_ptr<CdmInitializedPromise> promise) {
@@ skipping 130 matching lines @@
   if (has_additional_usable_key && decryptor_)
     decryptor_->OnKeyAdded();
 
   media::CdmKeysInfo key_data;
   key_data.reserve(keys_info.size());
   for (size_t i = 0; i < keys_info.size(); ++i) {
     key_data.push_back(
         keys_info[i].To<scoped_ptr<media::CdmKeyInformation>>().release());
   }
   session_keys_change_cb_.Run(session_id, has_additional_usable_key,
-                              key_data.Pass());
+                              std::move(key_data));
 }
 
 void MojoCdm::OnSessionExpirationUpdate(const mojo::String& session_id,
                                         double new_expiry_time_sec) {
   DVLOG(2) << __FUNCTION__;
   session_expiration_update_cb_.Run(
       session_id, base::Time::FromDoubleT(new_expiry_time_sec));
 }
 
 void MojoCdm::OnCdmInitialized(scoped_ptr<CdmInitializedPromise> promise,
                                interfaces::CdmPromiseResultPtr result,
                                int cdm_id,
                                interfaces::DecryptorPtr decryptor) {
   DVLOG(2) << __FUNCTION__ << " cdm_id: " << cdm_id;
   if (!result->success) {
-    RejectPromise(promise.Pass(), result.Pass());
+    RejectPromise(std::move(promise), std::move(result));
     return;
   }
 
   DCHECK_NE(CdmContext::kInvalidCdmId, cdm_id);
   cdm_id_ = cdm_id;
   decryptor_ptr_ = std::move(decryptor);
   promise->resolve();
 }
 
 }  // namespace media