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

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"
@@ skipping 34 matching lines @@
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&ReleaseCdm, cdm_));
   }
 }
 
 void CdmSessionAdapter::CreateCdm(
     CdmFactory* cdm_factory,
     const std::string& key_system,
     const GURL& security_origin,
     const CdmConfig& cdm_config,
-    scoped_ptr<blink::WebContentDecryptionModuleResult> result) {
+    std::unique_ptr<blink::WebContentDecryptionModuleResult> result) {
   TRACE_EVENT_ASYNC_BEGIN0("media", "CdmSessionAdapter::CreateCdm",
                            ++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_ = 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) {
+    std::unique_ptr<SimpleCdmPromise> promise) {
   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) {
+    std::unique_ptr<NewSessionCdmPromise> promise) {
   cdm_->CreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
                                         std::move(promise));
 }
 
-void CdmSessionAdapter::LoadSession(MediaKeys::SessionType session_type,
-                                    const std::string& session_id,
-                                    scoped_ptr<NewSessionCdmPromise> promise) {
+void CdmSessionAdapter::LoadSession(
+    MediaKeys::SessionType session_type,
+    const std::string& session_id,
+    std::unique_ptr<NewSessionCdmPromise> promise) {
   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) {
+void CdmSessionAdapter::UpdateSession(
+    const std::string& session_id,
+    const std::vector<uint8_t>& response,
+    std::unique_ptr<SimpleCdmPromise> promise) {
   cdm_->UpdateSession(session_id, response, std::move(promise));
 }
 
-void CdmSessionAdapter::CloseSession(const std::string& session_id,
-                                     scoped_ptr<SimpleCdmPromise> promise) {
+void CdmSessionAdapter::CloseSession(
+    const std::string& session_id,
+    std::unique_ptr<SimpleCdmPromise> promise) {
   cdm_->CloseSession(session_id, std::move(promise));
 }
 
-void CdmSessionAdapter::RemoveSession(const std::string& session_id,
-                                      scoped_ptr<SimpleCdmPromise> promise) {
+void CdmSessionAdapter::RemoveSession(
+    const std::string& session_id,
+    std::unique_ptr<SimpleCdmPromise> promise) {
   cdm_->RemoveSession(session_id, std::move(promise));
 }
 
 CdmContext* CdmSessionAdapter::GetCdmContext() {
   return cdm_->GetCdmContext();
 }
 
 const std::string& CdmSessionAdapter::GetKeySystem() const {
   return key_system_;
 }
@@ skipping 100 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