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

chromecast/media/cdm/browser_cdm_cast.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 "chromecast/media/cdm/browser_cdm_cast.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/cdm/player_tracker_impl.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
 // media::CdmPromiseTemplate implementation that wraps a promise so as to
 // allow passing to other threads.
 template <typename... T>
 class CdmPromiseInternal : public ::media::CdmPromiseTemplate<T...> {
  public:
   CdmPromiseInternal(scoped_ptr<::media::CdmPromiseTemplate<T...>> promise)
       : task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        promise_(promise.Pass()) {
-  }
+        promise_(std::move(promise)) {}
 
   ~CdmPromiseInternal() final {
     // Promise must be resolved or rejected before destruction.
     DCHECK(!promise_);
   }
 
   // CdmPromiseTemplate<> implementation.
   void resolve(const T&... result) final;
 
   void reject(::media::MediaKeys::Exception exception,
@@ skipping 20 matching lines @@
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&::media::CdmPromiseTemplate<T...>::resolve,
                  base::Owned(promise_.release()),
                  result...));
 }
 
 template <typename... T>
 scoped_ptr<CdmPromiseInternal<T...>> BindPromiseToCurrentLoop(
     scoped_ptr<::media::CdmPromiseTemplate<T...>> promise) {
-  return make_scoped_ptr(new CdmPromiseInternal<T...>(promise.Pass()));
+  return make_scoped_ptr(new CdmPromiseInternal<T...>(std::move(promise)));
 }
 
 }  // namespace
 
 BrowserCdmCast::BrowserCdmCast() {
   thread_checker_.DetachFromThread();
 }
 
 BrowserCdmCast::~BrowserCdmCast() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 42 matching lines @@
                           destination_url);
 }
 
 void BrowserCdmCast::OnSessionClosed(const std::string& session_id) {
   session_closed_cb_.Run(session_id);
 }
 
 void BrowserCdmCast::OnSessionKeysChange(const std::string& session_id,
                                          bool newly_usable_keys,
                                          ::media::CdmKeysInfo keys_info) {
-  session_keys_change_cb_.Run(session_id, newly_usable_keys, keys_info.Pass());
+  session_keys_change_cb_.Run(session_id, newly_usable_keys,
+                              std::move(keys_info));
 
   if (newly_usable_keys)
     player_tracker_impl_->NotifyNewKey();
 }
 
 void BrowserCdmCast::KeyIdAndKeyPairsToInfo(
     const ::media::KeyIdAndKeyPairs& keys,
     ::media::CdmKeysInfo* keys_info) {
   DCHECK(keys_info);
   for (const std::pair<std::string, std::string>& key : keys) {
@@ skipping 27 matching lines @@
 BrowserCdmCast* BrowserCdmCastUi::browser_cdm_cast() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return browser_cdm_cast_.get();
 }
 
 void BrowserCdmCastUi::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     scoped_ptr<::media::SimpleCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
-      SetServerCertificate,
-      certificate,
-      base::Passed(BindPromiseToCurrentLoop(promise.Pass())));
+      SetServerCertificate, certificate,
+      base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::CreateSessionAndGenerateRequest(
     ::media::MediaKeys::SessionType session_type,
     ::media::EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     scoped_ptr<::media::NewSessionCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
-      CreateSessionAndGenerateRequest,
-      session_type,
-      init_data_type,
-      init_data,
-      base::Passed(BindPromiseToCurrentLoop(promise.Pass())));
+      CreateSessionAndGenerateRequest, session_type, init_data_type, init_data,
+      base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::LoadSession(
     ::media::MediaKeys::SessionType session_type,
     const std::string& session_id,
     scoped_ptr<::media::NewSessionCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
       LoadSession, session_type, session_id,
-      base::Passed(BindPromiseToCurrentLoop(promise.Pass())));
+      base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
     scoped_ptr<::media::SimpleCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
-      UpdateSession,
-      session_id,
-      response,
-      base::Passed(BindPromiseToCurrentLoop(promise.Pass())));
+      UpdateSession, session_id, response,
+      base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::CloseSession(
     const std::string& session_id,
     scoped_ptr<::media::SimpleCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  FORWARD_ON_CDM_THREAD(CloseSession, session_id,
-      base::Passed(BindPromiseToCurrentLoop(promise.Pass())));
+  FORWARD_ON_CDM_THREAD(
+      CloseSession, session_id,
+      base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::RemoveSession(
     const std::string& session_id,
     scoped_ptr<::media::SimpleCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  FORWARD_ON_CDM_THREAD(RemoveSession, session_id,
-      base::Passed(BindPromiseToCurrentLoop(promise.Pass())));
+  FORWARD_ON_CDM_THREAD(
+      RemoveSession, session_id,
+      base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 // A default empty implementation for subclasses that don't need to provide
 // any key system specific initialization.
 void BrowserCdmCast::InitializeInternal() {
 }
 
 }  // namespace media
 }  // namespace chromecast