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

chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.cc

 // Copyright (c) 2013 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_private/enterprise_platform_keys_private_api.h"
 
 #include <string>
 #include <utility>
 
 #include "base/base64.h"
@@ skipping 66 matching lines @@
 EPKPChallengeKeyBase::PrepareKeyContext::~PrepareKeyContext() {
 }
 
 EPKPChallengeKeyBase::EPKPChallengeKeyBase()
     : cryptohome_client_(
           chromeos::DBusThreadManager::Get()->GetCryptohomeClient()),
       async_caller_(cryptohome::AsyncMethodCaller::GetInstance()),
       install_attributes_(g_browser_process->platform_part()
                               ->browser_policy_connector_chromeos()
                               ->GetInstallAttributes()) {
-  scoped_ptr<chromeos::attestation::ServerProxy> ca_client(
+  std::unique_ptr<chromeos::attestation::ServerProxy> ca_client(
       new chromeos::attestation::AttestationCAClient());
   default_attestation_flow_.reset(new chromeos::attestation::AttestationFlow(
       async_caller_, cryptohome_client_, std::move(ca_client)));
   attestation_flow_ = default_attestation_flow_.get();
 }
 
 EPKPChallengeKeyBase::EPKPChallengeKeyBase(
     chromeos::CryptohomeClient* cryptohome_client,
     cryptohome::AsyncMethodCaller* async_caller,
     chromeos::attestation::AttestationFlow* attestation_flow,
@@ skipping 461 matching lines @@
 EnterprisePlatformKeysPrivateChallengeMachineKeyFunction::
     EnterprisePlatformKeysPrivateChallengeMachineKeyFunction(
         EPKPChallengeMachineKey* impl_for_testing)
     : impl_(impl_for_testing) {}
 
 EnterprisePlatformKeysPrivateChallengeMachineKeyFunction::
     ~EnterprisePlatformKeysPrivateChallengeMachineKeyFunction() = default;
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysPrivateChallengeMachineKeyFunction::Run() {
-  scoped_ptr<api_epkp::ChallengeMachineKey::Params> params(
+  std::unique_ptr<api_epkp::ChallengeMachineKey::Params> params(
       api_epkp::ChallengeMachineKey::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   ChallengeKeyCallback callback =
       base::Bind(&EnterprisePlatformKeysPrivateChallengeMachineKeyFunction::
                      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::DecodeAndRun, base::Unretained(impl_),
@@ skipping 23 matching lines @@
 EnterprisePlatformKeysPrivateChallengeUserKeyFunction::
     EnterprisePlatformKeysPrivateChallengeUserKeyFunction(
         EPKPChallengeUserKey* impl_for_testing)
     : impl_(impl_for_testing) {}
 
 EnterprisePlatformKeysPrivateChallengeUserKeyFunction::
     ~EnterprisePlatformKeysPrivateChallengeUserKeyFunction() = default;
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysPrivateChallengeUserKeyFunction::Run() {
-  scoped_ptr<api_epkp::ChallengeUserKey::Params> params(
+  std::unique_ptr<api_epkp::ChallengeUserKey::Params> params(
       api_epkp::ChallengeUserKey::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   ChallengeKeyCallback callback = base::Bind(
       &EnterprisePlatformKeysPrivateChallengeUserKeyFunction::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::DecodeAndRun, base::Unretained(impl_),
       scoped_refptr<UIThreadExtensionFunction>(AsUIThreadExtensionFunction()),
       callback, params->challenge, params->register_key);
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE, task);
   return RespondLater();
 }
 
 void EnterprisePlatformKeysPrivateChallengeUserKeyFunction::OnChallengedKey(
     bool success,
     const std::string& data) {
   if (success) {
     std::string encoded_response;
     base::Base64Encode(data, &encoded_response);
     Respond(ArgumentList(
         api_epkp::ChallengeUserKey::Results::Create(encoded_response)));
   } else {
     Respond(Error(data));
   }
 }
 
 }  // namespace extensions