Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/platform_keys/platform_keys_api.cc

 // Copyright 2015 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/extensions/api/platform_keys/platform_keys_api.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
@@ skipping 106 matching lines @@
 }
 
 }  // namespace platform_keys
 
 PlatformKeysInternalGetPublicKeyFunction::
     ~PlatformKeysInternalGetPublicKeyFunction() {
 }
 
 ExtensionFunction::ResponseAction
 PlatformKeysInternalGetPublicKeyFunction::Run() {
-  scoped_ptr<api_pki::GetPublicKey::Params> params(
+  std::unique_ptr<api_pki::GetPublicKey::Params> params(
       api_pki::GetPublicKey::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const std::vector<char>& cert_der = params->certificate;
   if (cert_der.empty())
     return RespondNow(Error(platform_keys::kErrorInvalidX509Cert));
   scoped_refptr<net::X509Certificate> cert_x509 =
       net::X509Certificate::CreateFromBytes(cert_der.data(), cert_der.size());
   if (!cert_x509)
     return RespondNow(Error(platform_keys::kErrorInvalidX509Cert));
@@ skipping 23 matching lines @@
                         key_info.public_key_spki_der.end()),
       algorithm)));
 }
 
 PlatformKeysInternalSelectClientCertificatesFunction::
     ~PlatformKeysInternalSelectClientCertificatesFunction() {
 }
 
 ExtensionFunction::ResponseAction
 PlatformKeysInternalSelectClientCertificatesFunction::Run() {
-  scoped_ptr<api_pki::SelectClientCertificates::Params> params(
+  std::unique_ptr<api_pki::SelectClientCertificates::Params> params(
       api_pki::SelectClientCertificates::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   chromeos::PlatformKeysService* service =
       chromeos::PlatformKeysServiceFactory::GetForBrowserContext(
           browser_context());
   DCHECK(service);
 
   chromeos::platform_keys::ClientCertificateRequest request;
   for (const std::vector<char>& cert_authority :
@@ skipping 10 matching lines @@
         break;
       case api_pk::CLIENT_CERTIFICATE_TYPE_RSASIGN:
         request.certificate_key_types.push_back(
             net::X509Certificate::kPublicKeyTypeRSA);
         break;
       case api_pk::CLIENT_CERTIFICATE_TYPE_NONE:
         NOTREACHED();
     }
   }
 
-  scoped_ptr<net::CertificateList> client_certs;
+  std::unique_ptr<net::CertificateList> client_certs;
   if (params->details.client_certs) {
     client_certs.reset(new net::CertificateList);
     for (const std::vector<char>& client_cert_der :
          *params->details.client_certs) {
       if (client_cert_der.empty())
         return RespondNow(Error(platform_keys::kErrorInvalidX509Cert));
       scoped_refptr<net::X509Certificate> client_cert_x509 =
           net::X509Certificate::CreateFromBytes(client_cert_der.data(),
                                                 client_cert_der.size());
       if (!client_cert_x509)
@@ skipping 19 matching lines @@
       request, std::move(client_certs), params->details.interactive,
       extension_id(),
       base::Bind(&PlatformKeysInternalSelectClientCertificatesFunction::
                      OnSelectedCertificates,
                  this),
       web_contents);
   return RespondLater();
 }
 
 void PlatformKeysInternalSelectClientCertificatesFunction::
-    OnSelectedCertificates(scoped_ptr<net::CertificateList> matches,
+    OnSelectedCertificates(std::unique_ptr<net::CertificateList> matches,
                            const std::string& error_message) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!error_message.empty()) {
     Respond(Error(error_message));
     return;
   }
   DCHECK(matches);
   std::vector<api_pk::Match> result_matches;
   for (const scoped_refptr<net::X509Certificate>& match : *matches) {
@@ skipping 22 matching lines @@
     result_matches.push_back(std::move(result_match));
   }
   Respond(ArgumentList(
       api_pki::SelectClientCertificates::Results::Create(result_matches)));
 }
 
 PlatformKeysInternalSignFunction::~PlatformKeysInternalSignFunction() {
 }
 
 ExtensionFunction::ResponseAction PlatformKeysInternalSignFunction::Run() {
-  scoped_ptr<api_pki::Sign::Params> params(
+  std::unique_ptr<api_pki::Sign::Params> params(
       api_pki::Sign::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string platform_keys_token_id;
   if (!params->token_id.empty() &&
       !platform_keys::ValidateToken(params->token_id,
                                     &platform_keys_token_id)) {
     return RespondNow(Error(platform_keys::kErrorInvalidToken));
   }
 
   chromeos::PlatformKeysService* service =
@@ skipping 45 matching lines @@
 }
 
 PlatformKeysVerifyTLSServerCertificateFunction::
     ~PlatformKeysVerifyTLSServerCertificateFunction() {
 }
 
 ExtensionFunction::ResponseAction
 PlatformKeysVerifyTLSServerCertificateFunction::Run() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  scoped_ptr<api_pk::VerifyTLSServerCertificate::Params> params(
+  std::unique_ptr<api_pk::VerifyTLSServerCertificate::Params> params(
       api_pk::VerifyTLSServerCertificate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   VerifyTrustAPI::GetFactoryInstance()
       ->Get(browser_context())
       ->Verify(std::move(params), extension_id(),
                base::Bind(&PlatformKeysVerifyTLSServerCertificateFunction::
                               FinishedVerification,
                           this));
 
@@ skipping 22 matching lines @@
         result.debug_errors.push_back(kCertStatusErrors[i].name);
       }
     }
   }
 
   Respond(ArgumentList(
       api_pk::VerifyTLSServerCertificate::Results::Create(result)));
 }
 
 }  // namespace extensions