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

media/blink/cdm_session_adapter.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/blink/cdm_session_adapter.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/key_systems.h"
 #include "media/blink/webcontentdecryptionmodule_impl.h"
@@ skipping 21 matching lines @@
                            ++trace_id_);
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   // Note: WebContentDecryptionModuleImpl::Create() calls this method without
   // holding a reference to the CdmSessionAdapter. Bind OnCdmCreated() with
   // |this| instead of |weak_this| to prevent |this| from being destructed.
   base::WeakPtr<CdmSessionAdapter> weak_this = weak_ptr_factory_.GetWeakPtr();
 
   DCHECK(!cdm_created_result_);
-  cdm_created_result_ = result.Pass();
+  cdm_created_result_ = std::move(result);
 
   cdm_factory->Create(
       key_system, security_origin, cdm_config,
       base::Bind(&CdmSessionAdapter::OnSessionMessage, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionClosed, weak_this),
       base::Bind(&CdmSessionAdapter::OnLegacySessionError, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionKeysChange, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionExpirationUpdate, weak_this),
       base::Bind(&CdmSessionAdapter::OnCdmCreated, this, key_system,
                  start_time));
 }
 
 void CdmSessionAdapter::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     scoped_ptr<SimpleCdmPromise> promise) {
-  cdm_->SetServerCertificate(certificate, promise.Pass());
+  cdm_->SetServerCertificate(certificate, std::move(promise));
 }
 
 WebContentDecryptionModuleSessionImpl* CdmSessionAdapter::CreateSession() {
   return new WebContentDecryptionModuleSessionImpl(this);
 }
 
 bool CdmSessionAdapter::RegisterSession(
     const std::string& session_id,
     base::WeakPtr<WebContentDecryptionModuleSessionImpl> session) {
   // If this session ID is already registered, don't register it again.
   if (ContainsKey(sessions_, session_id))
     return false;
 
   sessions_[session_id] = session;
   return true;
 }
 
 void CdmSessionAdapter::UnregisterSession(const std::string& session_id) {
   DCHECK(ContainsKey(sessions_, session_id));
   sessions_.erase(session_id);
 }
 
 void CdmSessionAdapter::InitializeNewSession(
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     MediaKeys::SessionType session_type,
     scoped_ptr<NewSessionCdmPromise> promise) {
   cdm_->CreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
-                                        promise.Pass());
+                                        std::move(promise));
 }
 
 void CdmSessionAdapter::LoadSession(MediaKeys::SessionType session_type,
                                     const std::string& session_id,
                                     scoped_ptr<NewSessionCdmPromise> promise) {
-  cdm_->LoadSession(session_type, session_id, promise.Pass());
+  cdm_->LoadSession(session_type, session_id, std::move(promise));
 }
 
 void CdmSessionAdapter::UpdateSession(const std::string& session_id,
                                       const std::vector<uint8_t>& response,
                                       scoped_ptr<SimpleCdmPromise> promise) {
-  cdm_->UpdateSession(session_id, response, promise.Pass());
+  cdm_->UpdateSession(session_id, response, std::move(promise));
 }
 
 void CdmSessionAdapter::CloseSession(const std::string& session_id,
                                      scoped_ptr<SimpleCdmPromise> promise) {
-  cdm_->CloseSession(session_id, promise.Pass());
+  cdm_->CloseSession(session_id, std::move(promise));
 }
 
 void CdmSessionAdapter::RemoveSession(const std::string& session_id,
                                       scoped_ptr<SimpleCdmPromise> promise) {
-  cdm_->RemoveSession(session_id, promise.Pass());
+  cdm_->RemoveSession(session_id, std::move(promise));
 }
 
 CdmContext* CdmSessionAdapter::GetCdmContext() {
   return cdm_->GetCdmContext();
 }
 
 const std::string& CdmSessionAdapter::GetKeySystem() const {
   return key_system_;
 }
 
@@ skipping 48 matching lines @@
 }
 
 void CdmSessionAdapter::OnSessionKeysChange(const std::string& session_id,
                                             bool has_additional_usable_key,
                                             CdmKeysInfo keys_info) {
   // TODO(jrummell): Pass |keys_info| on.
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __FUNCTION__ << " for unknown session "
                              << session_id;
   if (session)
-    session->OnSessionKeysChange(has_additional_usable_key, keys_info.Pass());
+    session->OnSessionKeysChange(has_additional_usable_key,
+                                 std::move(keys_info));
 }
 
 void CdmSessionAdapter::OnSessionExpirationUpdate(
     const std::string& session_id,
     const base::Time& new_expiry_time) {
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __FUNCTION__ << " for unknown session "
                              << session_id;
   if (session)
     session->OnSessionExpirationUpdate(new_expiry_time);
@@ skipping 29 matching lines @@
   // Note: This leaks memory, which is expected behavior.
   base::HistogramBase* histogram = base::Histogram::FactoryTimeGet(
       GetKeySystemUMAPrefix() + kTimeToCreateCdmUMAName,
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromSeconds(10),
       50, base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram->AddTime(time);
 }
 
 }  // namespace media