Use scoped_ptr::Pass instead of scoped_ptr::PassAs<T>.

content/renderer/pepper/content_decryptor_delegate.cc

 // Copyright (c) 2012 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 "content/renderer/pepper/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 345 matching lines @@
     uint32_t certificate_length,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   if (!certificate ||
       certificate_length < media::limits::kMinCertificateLength ||
       certificate_length > media::limits::kMaxCertificateLength) {
     promise->reject(
         media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect certificate.");
     return;
   }
 
-  uint32_t promise_id = SavePromise(promise.PassAs<CdmPromise>());
+  uint32_t promise_id = SavePromise(promise.Pass());
   PP_Var certificate_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           certificate_length, certificate);
   plugin_decryption_interface_->SetServerCertificate(
       pp_instance_, promise_id, certificate_array);
 }
 
 void ContentDecryptorDelegate::CreateSession(
     const std::string& init_data_type,
     const uint8* init_data,
     int init_data_length,
     MediaKeys::SessionType session_type,
     scoped_ptr<NewSessionCdmPromise> promise) {
-  uint32_t promise_id = SavePromise(promise.PassAs<CdmPromise>());
+  uint32_t promise_id = SavePromise(promise.Pass());
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data_length, init_data);
   plugin_decryption_interface_->CreateSession(
       pp_instance_,
       promise_id,
       StringVar::StringToPPVar(init_data_type),
       init_data_array,
       MediaSessionTypeToPpSessionType(session_type));
 }
 
 void ContentDecryptorDelegate::LoadSession(
     const std::string& web_session_id,
     scoped_ptr<NewSessionCdmPromise> promise) {
-  uint32_t promise_id = SavePromise(promise.PassAs<CdmPromise>());
+  uint32_t promise_id = SavePromise(promise.Pass());
   plugin_decryption_interface_->LoadSession(
       pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
 }
 
 void ContentDecryptorDelegate::UpdateSession(
     const std::string& web_session_id,
     const uint8* response,
     int response_length,
     scoped_ptr<SimpleCdmPromise> promise) {
-  uint32_t promise_id = SavePromise(promise.PassAs<CdmPromise>());
+  uint32_t promise_id = SavePromise(promise.Pass());
   PP_Var response_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           response_length, response);
   plugin_decryption_interface_->UpdateSession(
       pp_instance_,
       promise_id,
       StringVar::StringToPPVar(web_session_id),
       response_array);
 }
 
 void ContentDecryptorDelegate::CloseSession(
     const std::string& web_session_id,
     scoped_ptr<SimpleCdmPromise> promise) {
   if (web_session_id.length() > media::limits::kMaxWebSessionIdLength) {
     promise->reject(
         media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
     return;
   }
 
-  uint32_t promise_id = SavePromise(promise.PassAs<CdmPromise>());
+  uint32_t promise_id = SavePromise(promise.Pass());
   plugin_decryption_interface_->CloseSession(
       pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
 }
 
 void ContentDecryptorDelegate::RemoveSession(
     const std::string& web_session_id,
     scoped_ptr<SimpleCdmPromise> promise) {
   if (web_session_id.length() > media::limits::kMaxWebSessionIdLength) {
     promise->reject(
         media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
     return;
   }
 
-  uint32_t promise_id = SavePromise(promise.PassAs<CdmPromise>());
+  uint32_t promise_id = SavePromise(promise.Pass());
   plugin_decryption_interface_->RemoveSession(
       pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
 }
 
 void ContentDecryptorDelegate::GetUsableKeyIds(
     const std::string& web_session_id,
     scoped_ptr<media::KeyIdsPromise> promise) {
   if (web_session_id.length() > media::limits::kMaxWebSessionIdLength) {
     promise->reject(
         media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
     return;
   }
 
-  uint32_t promise_id = SavePromise(promise.PassAs<CdmPromise>());
+  uint32_t promise_id = SavePromise(promise.Pass());
   plugin_decryption_interface_->GetUsableKeyIds(
       pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
 }
 
 // TODO(xhwang): Remove duplication of code in Decrypt(),
 // DecryptAndDecodeAudio() and DecryptAndDecodeVideo().
 bool ContentDecryptorDelegate::Decrypt(
     Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const Decryptor::DecryptCB& decrypt_cb) {
@@ skipping 860 matching lines @@
 
 scoped_ptr<CdmPromise> ContentDecryptorDelegate::TakePromise(
     uint32_t promise_id) {
   PromiseMap::iterator it = promises_.find(promise_id);
   if (it == promises_.end())
     return scoped_ptr<CdmPromise>();
   return promises_.take_and_erase(it);
 }
 
 }  // namespace content