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

chrome/browser/chromeos/attestation/platform_verification_flow.cc

 // Copyright 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/chromeos/attestation/platform_verification_flow.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 138 matching lines @@
 
 PlatformVerificationFlow::ChallengeContext::~ChallengeContext() {}
 
 PlatformVerificationFlow::PlatformVerificationFlow()
     : attestation_flow_(NULL),
       async_caller_(cryptohome::AsyncMethodCaller::GetInstance()),
       cryptohome_client_(DBusThreadManager::Get()->GetCryptohomeClient()),
       delegate_(NULL),
       timeout_delay_(base::TimeDelta::FromSeconds(kTimeoutInSeconds)) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  scoped_ptr<ServerProxy> attestation_ca_client(new AttestationCAClient());
+  std::unique_ptr<ServerProxy> attestation_ca_client(new AttestationCAClient());
   default_attestation_flow_.reset(new AttestationFlow(
       async_caller_, cryptohome_client_, std::move(attestation_ca_client)));
   attestation_flow_ = default_attestation_flow_.get();
   default_delegate_.reset(new DefaultDelegate());
   delegate_ = default_delegate_.get();
 }
 
 PlatformVerificationFlow::PlatformVerificationFlow(
     AttestationFlow* attestation_flow,
     cryptohome::AsyncMethodCaller* async_caller,
@@ skipping 80 matching lines @@
     return;
   }
 
   GetCertificate(context, user->GetAccountId(),
                  false /* Don't force a new key */);
 }
 
 void PlatformVerificationFlow::GetCertificate(const ChallengeContext& context,
                                               const AccountId& account_id,
                                               bool force_new_key) {
-  scoped_ptr<base::Timer> timer(new base::Timer(false,    // Don't retain.
-                                                false));  // Don't repeat.
+  std::unique_ptr<base::Timer> timer(new base::Timer(false,    // Don't retain.
+                                                     false));  // Don't repeat.
   base::Closure timeout_callback = base::Bind(
       &PlatformVerificationFlow::OnCertificateTimeout,
       this,
       context);
   timer->Start(FROM_HERE, timeout_delay_, timeout_callback);
 
   AttestationFlow::CertificateCallback certificate_callback =
       base::Bind(&PlatformVerificationFlow::OnCertificateReady, this, context,
                  account_id, base::Passed(&timer));
   attestation_flow_->GetCertificate(PROFILE_CONTENT_PROTECTION_CERTIFICATE,
                                     account_id, context.service_id,
                                     force_new_key, certificate_callback);
 }
 
 void PlatformVerificationFlow::OnCertificateReady(
     const ChallengeContext& context,
     const AccountId& account_id,
-    scoped_ptr<base::Timer> timer,
+    std::unique_ptr<base::Timer> timer,
     bool operation_success,
     const std::string& certificate_chain) {
   // Log failure before checking the timer so all failures are logged, even if
   // they took too long.
   if (!operation_success) {
     LOG(WARNING) << "PlatformVerificationFlow: Failed to certify platform.";
   }
   if (!timer->IsRunning()) {
     LOG(WARNING) << "PlatformVerificationFlow: Certificate ready but call has "
                  << "already timed out.";
@@ skipping 132 matching lines @@
   if (!operation_success) {
     LOG(WARNING) << "PlatformVerificationFlow: Failed to renew platform "
                     "certificate.";
     return;
   }
   VLOG(1) << "Certificate successfully renewed.";
 }
 
 }  // namespace attestation
 }  // namespace chromeos