Convert //media/blink from scoped_ptr to std::unique_ptr

media/blink/webcontentdecryptionmodulesession_impl.cc

 // Copyright 2013 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 "webcontentdecryptionmodulesession_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 282 matching lines @@
   //     (Done in constructor.)
 
   // 9.5 Let message be null.
   //     (Done by CDM.)
 
   // 9.6 Let cdm be the CDM instance represented by this object's cdm
   //     instance value.
   // 9.7 Use the cdm to execute the following steps:
   adapter_->InitializeNewSession(
       eme_init_data_type, sanitized_init_data, convertSessionType(session_type),
-      scoped_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
+      std::unique_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
           result, adapter_->GetKeySystemUMAPrefix() + kGenerateRequestUMAName,
           base::Bind(
               &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
               weak_ptr_factory_.GetWeakPtr()))));
 }
 
 void WebContentDecryptionModuleSessionImpl::load(
     const blink::WebString& session_id,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id.isEmpty());
   DCHECK(session_id_.empty());
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string sanitized_session_id;
   if (!SanitizeSessionId(session_id, &sanitized_session_id)) {
     result.completeWithError(
         blink::WebContentDecryptionModuleExceptionInvalidAccessError, 0,
         "Invalid session ID.");
     return;
   }
 
   // TODO(jrummell): Now that there are 2 types of persistent sessions, the
   // session type should be passed from blink. Type should also be passed in the
   // constructor (and removed from initializeNewSession()).
   adapter_->LoadSession(
       MediaKeys::PERSISTENT_LICENSE_SESSION, sanitized_session_id,
-      scoped_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
+      std::unique_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
           result, adapter_->GetKeySystemUMAPrefix() + kLoadSessionUMAName,
           base::Bind(
               &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
               weak_ptr_factory_.GetWeakPtr()))));
 }
 
 void WebContentDecryptionModuleSessionImpl::update(
     const uint8_t* response,
     size_t response_length,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(response);
   DCHECK(!session_id_.empty());
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<uint8_t> sanitized_response;
   if (!SanitizeResponse(adapter_->GetKeySystem(), response, response_length,
                         &sanitized_response)) {
     result.completeWithError(
         blink::WebContentDecryptionModuleExceptionInvalidAccessError, 0,
         "Invalid response.");
     return;
   }
 
   adapter_->UpdateSession(
       session_id_, sanitized_response,
-      scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
+      std::unique_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
           result, adapter_->GetKeySystemUMAPrefix() + kUpdateSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::close(
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id_.empty());
   DCHECK(thread_checker_.CalledOnValidThread());
   adapter_->CloseSession(
       session_id_,
-      scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
+      std::unique_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
           result, adapter_->GetKeySystemUMAPrefix() + kCloseSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::remove(
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id_.empty());
   DCHECK(thread_checker_.CalledOnValidThread());
   adapter_->RemoveSession(
       session_id_,
-      scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
+      std::unique_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
           result, adapter_->GetKeySystemUMAPrefix() + kRemoveSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionMessage(
     MediaKeys::MessageType message_type,
     const std::vector<uint8_t>& message) {
   DCHECK(client_) << "Client not set before message event";
   DCHECK(thread_checker_.CalledOnValidThread());
   client_->message(convertMessageType(message_type), message.data(),
                    message.size());
@@ skipping 44 matching lines @@
 
   DCHECK(session_id_.empty()) << "Session ID may not be changed once set.";
   session_id_ = session_id;
   *status =
       adapter_->RegisterSession(session_id_, weak_ptr_factory_.GetWeakPtr())
           ? SessionInitStatus::NEW_SESSION
           : SessionInitStatus::SESSION_ALREADY_EXISTS;
 }
 
 }  // namespace media