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

chrome/browser/chromeos/net/client_cert_store_chromeos.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/net/client_cert_store_chromeos.h"
 
 #include <cert.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 19 matching lines @@
     return !filter_->IsCertAllowed(cert);
   }
 
  private:
   const ClientCertStoreChromeOS::CertFilter* const filter_;
 };
 
 }  // namespace
 
 ClientCertStoreChromeOS::ClientCertStoreChromeOS(
-    scoped_ptr<CertificateProvider> cert_provider,
-    scoped_ptr<CertFilter> cert_filter,
+    std::unique_ptr<CertificateProvider> cert_provider,
+    std::unique_ptr<CertFilter> cert_filter,
     const PasswordDelegateFactory& password_delegate_factory)
     : cert_provider_(std::move(cert_provider)),
       cert_filter_(std::move(cert_filter)) {}
 
 ClientCertStoreChromeOS::~ClientCertStoreChromeOS() {}
 
 void ClientCertStoreChromeOS::GetClientCerts(
     const net::SSLCertRequestInfo& cert_request_info,
     net::CertificateList* selected_certs,
     const base::Closure& callback) {
@@ skipping 16 matching lines @@
 
   if (cert_filter_->Init(get_additional_certs_and_continue))
     get_additional_certs_and_continue.Run();
 }
 
 void ClientCertStoreChromeOS::GotAdditionalCerts(
     const net::SSLCertRequestInfo* request,
     net::CertificateList* selected_certs,
     const base::Closure& callback,
     const net::CertificateList& additional_certs) {
-  scoped_ptr<crypto::CryptoModuleBlockingPasswordDelegate> password_delegate;
+  std::unique_ptr<crypto::CryptoModuleBlockingPasswordDelegate>
+      password_delegate;
   if (!password_delegate_factory_.is_null()) {
     password_delegate.reset(
         password_delegate_factory_.Run(request->host_and_port));
   }
   if (base::WorkerPool::PostTaskAndReply(
           FROM_HERE,
           base::Bind(&ClientCertStoreChromeOS::GetAndFilterCertsOnWorkerThread,
                      base::Unretained(this), base::Passed(&password_delegate),
                      request, additional_certs, selected_certs),
           callback, true)) {
     return;
   }
   // If the task could not be posted, behave as if there were no certificates
   // which requires to clear |selected_certs|.
   selected_certs->clear();
   callback.Run();
 }
 
 void ClientCertStoreChromeOS::GetAndFilterCertsOnWorkerThread(
-    scoped_ptr<crypto::CryptoModuleBlockingPasswordDelegate> password_delegate,
+    std::unique_ptr<crypto::CryptoModuleBlockingPasswordDelegate>
+        password_delegate,
     const net::SSLCertRequestInfo* request,
     const net::CertificateList& additional_certs,
     net::CertificateList* selected_certs) {
   net::CertificateList unfiltered_certs;
   net::ClientCertStoreNSS::GetPlatformCertsOnWorkerThread(
       std::move(password_delegate), &unfiltered_certs);
 
   unfiltered_certs.erase(
       std::remove_if(unfiltered_certs.begin(), unfiltered_certs.end(),
                      CertNotAllowedPredicate(cert_filter_.get())),
       unfiltered_certs.end());
 
   unfiltered_certs.insert(unfiltered_certs.end(), additional_certs.begin(),
                           additional_certs.end());
 
   net::ClientCertStoreNSS::FilterCertsOnWorkerThread(unfiltered_certs, *request,
                                                      selected_certs);
 }
 
 }  // namespace chromeos