Replace scoped_ptr with std::unique_ptr in //media.

media/cdm/ppapi/external_clear_key/clear_key_cdm.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 "media/cdm/ppapi/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <utility>
@@ skipping 87 matching lines @@
   scoped_refptr<media::DecoderBuffer> output_buffer =
       media::DecoderBuffer::CopyFrom(input_buffer.data, input_buffer.data_size);
 
   std::vector<media::SubsampleEntry> subsamples;
   for (uint32_t i = 0; i < input_buffer.num_subsamples; ++i) {
     subsamples.push_back(
         media::SubsampleEntry(input_buffer.subsamples[i].clear_bytes,
                               input_buffer.subsamples[i].cipher_bytes));
   }
 
-  scoped_ptr<media::DecryptConfig> decrypt_config(new media::DecryptConfig(
+  std::unique_ptr<media::DecryptConfig> decrypt_config(new media::DecryptConfig(
       std::string(reinterpret_cast<const char*>(input_buffer.key_id),
                   input_buffer.key_id_size),
       std::string(reinterpret_cast<const char*>(input_buffer.iv),
                   input_buffer.iv_size),
       subsamples));
 
   output_buffer->set_decrypt_config(std::move(decrypt_config));
   output_buffer->set_timestamp(
       base::TimeDelta::FromMicroseconds(input_buffer.timestamp));
 
@@ skipping 169 matching lines @@
 }
 
 void ClearKeyCdm::CreateSessionAndGenerateRequest(
     uint32_t promise_id,
     cdm::SessionType session_type,
     cdm::InitDataType init_data_type,
     const uint8_t* init_data,
     uint32_t init_data_size) {
   DVLOG(1) << __FUNCTION__;
 
-  scoped_ptr<media::NewSessionCdmPromise> promise(
+  std::unique_ptr<media::NewSessionCdmPromise> promise(
       new media::CdmCallbackPromise<std::string>(
-          base::Bind(&ClearKeyCdm::OnSessionCreated,
-                     base::Unretained(this),
+          base::Bind(&ClearKeyCdm::OnSessionCreated, base::Unretained(this),
                      promise_id),
-          base::Bind(&ClearKeyCdm::OnPromiseFailed,
-                     base::Unretained(this),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id)));
   decryptor_->CreateSessionAndGenerateRequest(
       ConvertSessionType(session_type), ConvertInitDataType(init_data_type),
       std::vector<uint8_t>(init_data, init_data + init_data_size),
       std::move(promise));
 
   if (key_system_ == kExternalClearKeyFileIOTestKeySystem)
     StartFileIOTest();
 }
 
 // Loads a emulated stored session. Currently only |kLoadableSessionId|
 // (containing a |kLoadableSessionKey| for |kLoadableSessionKeyId|) is
 // supported.
 void ClearKeyCdm::LoadSession(uint32_t promise_id,
                               cdm::SessionType session_type,
                               const char* session_id,
                               uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(session_type, cdm::kPersistentLicense);
 
   if (std::string(kLoadableSessionId) !=
       std::string(session_id, session_id_length)) {
     host_->OnResolveNewSessionPromise(promise_id, nullptr, 0);
     return;
   }
 
   // Only allowed to successfully load this session once.
   DCHECK(session_id_for_emulated_loadsession_.empty());
 
-  scoped_ptr<media::NewSessionCdmPromise> promise(
+  std::unique_ptr<media::NewSessionCdmPromise> promise(
       new media::CdmCallbackPromise<std::string>(
-          base::Bind(&ClearKeyCdm::OnSessionLoaded,
-                     base::Unretained(this),
+          base::Bind(&ClearKeyCdm::OnSessionLoaded, base::Unretained(this),
                      promise_id),
-          base::Bind(&ClearKeyCdm::OnPromiseFailed,
-                     base::Unretained(this),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id)));
   decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(), std::move(promise));
 }
 
 void ClearKeyCdm::UpdateSession(uint32_t promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length,
                                 const uint8_t* response,
                                 uint32_t response_size) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // If updating the loadable session, use the actual session id generated.
   if (web_session_str == std::string(kLoadableSessionId))
     web_session_str = session_id_for_emulated_loadsession_;
 
-  scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
-      base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
-                 promise_id),
-      base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
-                 promise_id)));
+  std::unique_ptr<media::SimpleCdmPromise> promise(
+      new media::CdmCallbackPromise<>(
+          base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
+                     promise_id),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
+                     promise_id)));
   decryptor_->UpdateSession(
       web_session_str, std::vector<uint8_t>(response, response + response_size),
       std::move(promise));
 
   if (!renewal_timer_set_) {
     ScheduleNextRenewal();
     renewal_timer_set_ = true;
   }
 }
 
 void ClearKeyCdm::CloseSession(uint32_t promise_id,
                                const char* session_id,
                                uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // If closing the loadable session, use the actual session id generated.
   if (web_session_str == std::string(kLoadableSessionId))
     web_session_str = session_id_for_emulated_loadsession_;
 
-  scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
-      base::Bind(
-          &ClearKeyCdm::OnPromiseResolved, base::Unretained(this), promise_id),
-      base::Bind(
-          &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
+  std::unique_ptr<media::SimpleCdmPromise> promise(
+      new media::CdmCallbackPromise<>(
+          base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
+                     promise_id),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
+                     promise_id)));
   decryptor_->CloseSession(web_session_str, std::move(promise));
 }
 
 void ClearKeyCdm::RemoveSession(uint32_t promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // RemoveSession only allowed for the loadable session.
   if (web_session_str == std::string(kLoadableSessionId)) {
     web_session_str = session_id_for_emulated_loadsession_;
   } else {
     // TODO(jrummell): This should be a DCHECK once blink does the proper
     // checks.
     std::string message("Not supported for non-persistent sessions.");
     host_->OnRejectPromise(promise_id,
                            cdm::kInvalidAccessError,
                            0,
                            message.data(),
                            message.length());
     return;
   }
 
-  scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
-      base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
-                 promise_id),
-      base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
-                 promise_id)));
+  std::unique_ptr<media::SimpleCdmPromise> promise(
+      new media::CdmCallbackPromise<>(
+          base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
+                     promise_id),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
+                     promise_id)));
   decryptor_->RemoveSession(web_session_str, std::move(promise));
 }
 
 void ClearKeyCdm::SetServerCertificate(uint32_t promise_id,
                                        const uint8_t* server_certificate_data,
                                        uint32_t server_certificate_data_size) {
   // ClearKey doesn't use a server certificate.
   host_->OnResolvePromise(promise_id);
 }
 
@@ skipping 259 matching lines @@
     uint32_t link_mask,
     uint32_t output_protection_mask) {
   NOTIMPLEMENTED();
 };
 
 void ClearKeyCdm::LoadLoadableSession() {
   std::string jwk_set = GenerateJWKSet(kLoadableSessionKey,
                                        sizeof(kLoadableSessionKey),
                                        kLoadableSessionKeyId,
                                        sizeof(kLoadableSessionKeyId) - 1);
-  scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
-      base::Bind(&ClearKeyCdm::OnLoadSessionUpdated, base::Unretained(this)),
-      base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
-                 promise_id_for_emulated_loadsession_)));
+  std::unique_ptr<media::SimpleCdmPromise> promise(
+      new media::CdmCallbackPromise<>(
+          base::Bind(&ClearKeyCdm::OnLoadSessionUpdated,
+                     base::Unretained(this)),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
+                     promise_id_for_emulated_loadsession_)));
   decryptor_->UpdateSession(
       session_id_for_emulated_loadsession_,
       std::vector<uint8_t>(jwk_set.begin(), jwk_set.end()), std::move(promise));
 }
 
 void ClearKeyCdm::OnSessionMessage(const std::string& session_id,
                                    MediaKeys::MessageType message_type,
                                    const std::vector<uint8_t>& message,
                                    const GURL& legacy_destination_url) {
   DVLOG(1) << "OnSessionMessage: " << message.size();
@@ skipping 192 matching lines @@
 void ClearKeyCdm::OnFileIOTestComplete(bool success) {
   DVLOG(1) << __FUNCTION__ << ": " << success;
   std::string message = GetFileIOTestResultMessage(success);
   host_->OnSessionMessage(last_session_id_.data(), last_session_id_.length(),
                           cdm::kLicenseRequest, message.data(),
                           message.length(), NULL, 0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media