Re-write many calls to WrapUnique() with MakeUnique()

media/mojo/services/mojo_cdm_service.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/mojo/services/mojo_cdm_service.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 108 matching lines @@
       base::Bind(&MojoCdmService::OnLegacySessionError, weak_this),
       base::Bind(&MojoCdmService::OnSessionKeysChange, weak_this),
       base::Bind(&MojoCdmService::OnSessionExpirationUpdate, weak_this),
       base::Bind(&MojoCdmService::OnCdmCreated, weak_this, callback));
 }
 
 void MojoCdmService::SetServerCertificate(
     mojo::Array<uint8_t> certificate_data,
     const SetServerCertificateCallback& callback) {
   DVLOG(2) << __FUNCTION__;
-  cdm_->SetServerCertificate(
-      certificate_data.storage(),
-      base::WrapUnique(new SimpleMojoCdmPromise(callback)));
+  cdm_->SetServerCertificate(certificate_data.storage(),
+                             base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::CreateSessionAndGenerateRequest(
     mojom::ContentDecryptionModule::SessionType session_type,
     mojom::ContentDecryptionModule::InitDataType init_data_type,
     mojo::Array<uint8_t> init_data,
     const CreateSessionAndGenerateRequestCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->CreateSessionAndGenerateRequest(
       static_cast<MediaKeys::SessionType>(session_type),
       static_cast<EmeInitDataType>(init_data_type), init_data.storage(),
-      base::WrapUnique(new NewSessionMojoCdmPromise(callback)));
+      base::MakeUnique<NewSessionMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::LoadSession(
     mojom::ContentDecryptionModule::SessionType session_type,
     const mojo::String& session_id,
     const LoadSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->LoadSession(static_cast<MediaKeys::SessionType>(session_type),
                     session_id.To<std::string>(),
-                    base::WrapUnique(new NewSessionMojoCdmPromise(callback)));
+                    base::MakeUnique<NewSessionMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::UpdateSession(const mojo::String& session_id,
                                    mojo::Array<uint8_t> response,
                                    const UpdateSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->UpdateSession(
       session_id.To<std::string>(), response.storage(),
       std::unique_ptr<SimpleCdmPromise>(new SimpleMojoCdmPromise(callback)));
 }
 
 void MojoCdmService::CloseSession(const mojo::String& session_id,
                                   const CloseSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->CloseSession(session_id.To<std::string>(),
-                     base::WrapUnique(new SimpleMojoCdmPromise(callback)));
+                     base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::RemoveSession(const mojo::String& session_id,
                                    const RemoveSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->RemoveSession(session_id.To<std::string>(),
-                      base::WrapUnique(new SimpleMojoCdmPromise(callback)));
+                      base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
 scoped_refptr<MediaKeys> MojoCdmService::GetCdm() {
   return cdm_;
 }
 
 void MojoCdmService::OnCdmCreated(const InitializeCallback& callback,
                                   const scoped_refptr<MediaKeys>& cdm,
                                   const std::string& error_message) {
   mojom::CdmPromiseResultPtr cdm_promise_result(mojom::CdmPromiseResult::New());
@@ skipping 81 matching lines @@
 
 void MojoCdmService::OnDecryptorConnectionError() {
   DVLOG(2) << __FUNCTION__;
 
   // MojoDecryptorService has lost connectivity to it's client, so it can be
   // freed.
   decryptor_.reset();
 }
 
 }  // namespace media