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

chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.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/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/values.h"
@@ skipping 29 matching lines @@
 }
 
 }  // namespace
 
 EnterprisePlatformKeysInternalGenerateKeyFunction::
     ~EnterprisePlatformKeysInternalGenerateKeyFunction() {
 }
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysInternalGenerateKeyFunction::Run() {
-  scoped_ptr<api_epki::GenerateKey::Params> params(
+  std::unique_ptr<api_epki::GenerateKey::Params> params(
       api_epki::GenerateKey::Params::Create(*args_));
   // TODO(pneubeck): Add support for unsigned integers to IDL.
   EXTENSION_FUNCTION_VALIDATE(params && params->modulus_length >= 0);
   std::string platform_keys_token_id;
   if (!platform_keys::ValidateToken(params->token_id, &platform_keys_token_id))
     return RespondNow(Error(platform_keys::kErrorInvalidToken));
 
   chromeos::PlatformKeysService* service =
       chromeos::PlatformKeysServiceFactory::GetForBrowserContext(
           browser_context());
@@ skipping 20 matching lines @@
     Respond(Error(error_message));
   }
 }
 
 EnterprisePlatformKeysGetCertificatesFunction::
     ~EnterprisePlatformKeysGetCertificatesFunction() {
 }
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysGetCertificatesFunction::Run() {
-  scoped_ptr<api_epk::GetCertificates::Params> params(
+  std::unique_ptr<api_epk::GetCertificates::Params> params(
       api_epk::GetCertificates::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string platform_keys_token_id;
   if (!platform_keys::ValidateToken(params->token_id, &platform_keys_token_id))
     return RespondNow(Error(platform_keys::kErrorInvalidToken));
 
   chromeos::platform_keys::GetCertificates(
       platform_keys_token_id,
       base::Bind(
           &EnterprisePlatformKeysGetCertificatesFunction::OnGotCertificates,
           this),
       browser_context());
   return RespondLater();
 }
 
 void EnterprisePlatformKeysGetCertificatesFunction::OnGotCertificates(
-    scoped_ptr<net::CertificateList> certs,
+    std::unique_ptr<net::CertificateList> certs,
     const std::string& error_message) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!error_message.empty()) {
     Respond(Error(error_message));
     return;
   }
 
-  scoped_ptr<base::ListValue> client_certs(new base::ListValue());
+  std::unique_ptr<base::ListValue> client_certs(new base::ListValue());
   for (net::CertificateList::const_iterator it = certs->begin();
        it != certs->end();
        ++it) {
     std::string der_encoding;
     net::X509Certificate::GetDEREncoded((*it)->os_cert_handle(), &der_encoding);
     client_certs->Append(base::BinaryValue::CreateWithCopiedBuffer(
         der_encoding.data(), der_encoding.size()));
   }
 
-  scoped_ptr<base::ListValue> results(new base::ListValue());
+  std::unique_ptr<base::ListValue> results(new base::ListValue());
   results->Append(client_certs.release());
   Respond(ArgumentList(std::move(results)));
 }
 
 EnterprisePlatformKeysImportCertificateFunction::
     ~EnterprisePlatformKeysImportCertificateFunction() {
 }
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysImportCertificateFunction::Run() {
-  scoped_ptr<api_epk::ImportCertificate::Params> params(
+  std::unique_ptr<api_epk::ImportCertificate::Params> params(
       api_epk::ImportCertificate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string platform_keys_token_id;
   if (!platform_keys::ValidateToken(params->token_id, &platform_keys_token_id))
     return RespondNow(Error(platform_keys::kErrorInvalidToken));
 
   const std::vector<char>& cert_der = params->certificate;
   scoped_refptr<net::X509Certificate> cert_x509 =
       net::X509Certificate::CreateFromBytes(cert_der.data(), cert_der.size());
   if (!cert_x509.get())
@@ skipping 17 matching lines @@
   else
     Respond(Error(error_message));
 }
 
 EnterprisePlatformKeysRemoveCertificateFunction::
     ~EnterprisePlatformKeysRemoveCertificateFunction() {
 }
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysRemoveCertificateFunction::Run() {
-  scoped_ptr<api_epk::RemoveCertificate::Params> params(
+  std::unique_ptr<api_epk::RemoveCertificate::Params> params(
       api_epk::RemoveCertificate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string platform_keys_token_id;
   if (!platform_keys::ValidateToken(params->token_id, &platform_keys_token_id))
     return RespondNow(Error(platform_keys::kErrorInvalidToken));
 
   const std::vector<char>& cert_der = params->certificate;
   scoped_refptr<net::X509Certificate> cert_x509 =
       net::X509Certificate::CreateFromBytes(cert_der.data(), cert_der.size());
   if (!cert_x509.get())
@@ skipping 27 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->empty());
 
   chromeos::platform_keys::GetTokens(
       base::Bind(&EnterprisePlatformKeysInternalGetTokensFunction::OnGotTokens,
                  this),
       browser_context());
   return RespondLater();
 }
 
 void EnterprisePlatformKeysInternalGetTokensFunction::OnGotTokens(
-    scoped_ptr<std::vector<std::string> > platform_keys_token_ids,
+    std::unique_ptr<std::vector<std::string>> platform_keys_token_ids,
     const std::string& error_message) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!error_message.empty()) {
     Respond(Error(error_message));
     return;
   }
 
   std::vector<std::string> token_ids;
   for (std::vector<std::string>::const_iterator it =
            platform_keys_token_ids->begin();
@@ skipping 17 matching lines @@
 EnterprisePlatformKeysChallengeMachineKeyFunction::
     EnterprisePlatformKeysChallengeMachineKeyFunction(
         EPKPChallengeMachineKey* impl_for_testing)
     : impl_(impl_for_testing) {}
 
 EnterprisePlatformKeysChallengeMachineKeyFunction::
     ~EnterprisePlatformKeysChallengeMachineKeyFunction() = default;
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysChallengeMachineKeyFunction::Run() {
-  scoped_ptr<api_epk::ChallengeMachineKey::Params> params(
+  std::unique_ptr<api_epk::ChallengeMachineKey::Params> params(
       api_epk::ChallengeMachineKey::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   ChallengeKeyCallback callback = base::Bind(
       &EnterprisePlatformKeysChallengeMachineKeyFunction::OnChallengedKey,
       this);
   // base::Unretained is safe on impl_ since its life-cycle matches |this| and
   // |callback| holds a reference to |this|.
   base::Closure task = base::Bind(
       &EPKPChallengeMachineKey::Run, base::Unretained(impl_),
       scoped_refptr<UIThreadExtensionFunction>(AsUIThreadExtensionFunction()),
@@ skipping 20 matching lines @@
 EnterprisePlatformKeysChallengeUserKeyFunction::
     EnterprisePlatformKeysChallengeUserKeyFunction(
         EPKPChallengeUserKey* impl_for_testing)
     : impl_(impl_for_testing) {}
 
 EnterprisePlatformKeysChallengeUserKeyFunction::
     ~EnterprisePlatformKeysChallengeUserKeyFunction() = default;
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysChallengeUserKeyFunction::Run() {
-  scoped_ptr<api_epk::ChallengeUserKey::Params> params(
+  std::unique_ptr<api_epk::ChallengeUserKey::Params> params(
       api_epk::ChallengeUserKey::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   ChallengeKeyCallback callback = base::Bind(
       &EnterprisePlatformKeysChallengeUserKeyFunction::OnChallengedKey, this);
   // base::Unretained is safe on impl_ since its life-cycle matches |this| and
   // |callback| holds a reference to |this|.
   base::Closure task = base::Bind(
       &EPKPChallengeUserKey::Run, base::Unretained(impl_),
       scoped_refptr<UIThreadExtensionFunction>(AsUIThreadExtensionFunction()),
       callback, StringFromVector(params->challenge), params->register_key);
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE, task);
   return RespondLater();
 }
 
 void EnterprisePlatformKeysChallengeUserKeyFunction::OnChallengedKey(
     bool success,
     const std::string& data) {
   if (success) {
     Respond(ArgumentList(
         api_epk::ChallengeUserKey::Results::Create(VectorFromString(data))));
   } else {
     Respond(Error(data));
   }
 }
 
 }  // namespace extensions