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

chrome/browser/chromeos/platform_keys/platform_keys_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 "chrome/browser/chromeos/platform_keys/platform_keys_service.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 558 matching lines @@
 void PlatformKeysService::SetSelectDelegate(
     std::unique_ptr<SelectDelegate> delegate) {
   select_delegate_ = std::move(delegate);
 }
 
 void PlatformKeysService::GenerateRSAKey(const std::string& token_id,
                                          unsigned int modulus_length,
                                          const std::string& extension_id,
                                          const GenerateKeyCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  StartOrQueueTask(base::WrapUnique(
-      new GenerateRSAKeyTask(token_id, modulus_length, extension_id, callback,
-                             &key_permissions_, this, browser_context_)));
+  StartOrQueueTask(base::MakeUnique<GenerateRSAKeyTask>(
+      token_id, modulus_length, extension_id, callback, &key_permissions_, this,
+      browser_context_));
 }
 
 void PlatformKeysService::SignRSAPKCS1Digest(
     const std::string& token_id,
     const std::string& data,
     const std::string& public_key,
     platform_keys::HashAlgorithm hash_algorithm,
     const std::string& extension_id,
     const SignCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 15 matching lines @@
 }
 
 void PlatformKeysService::SelectClientCertificates(
     const platform_keys::ClientCertificateRequest& request,
     std::unique_ptr<net::CertificateList> client_certificates,
     bool interactive,
     const std::string& extension_id,
     const SelectCertificatesCallback& callback,
     content::WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  StartOrQueueTask(base::WrapUnique(new SelectTask(
+  StartOrQueueTask(base::MakeUnique<SelectTask>(
       request, std::move(client_certificates), interactive, extension_id,
-      callback, web_contents, &key_permissions_, this)));
+      callback, web_contents, &key_permissions_, this));
 }
 
 void PlatformKeysService::StartOrQueueTask(std::unique_ptr<Task> task) {
   tasks_.push(make_linked_ptr(task.release()));
   if (tasks_.size() == 1)
     tasks_.front()->Start();
 }
 
 void PlatformKeysService::TaskFinished(Task* task) {
   DCHECK(!tasks_.empty());
   DCHECK(task == tasks_.front().get());
   // Remove all finished tasks from the queue (should be at most one).
   while (!tasks_.empty() && tasks_.front()->IsDone())
     tasks_.pop();
 
   // Now either the queue is empty or the next task is not finished yet and it
   // can be started.
   if (!tasks_.empty())
     tasks_.front()->Start();
 }
 
 }  // namespace chromeos