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

chrome/browser/chromeos/certificate_provider/certificate_provider_service.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/chromeos/certificate_provider/certificate_provider_service.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/certificate_provider/certificate_provider.h"
 #include "net/base/net_errors.h"
 #include "net/ssl/client_key_store.h"
 
 namespace chromeos {
 
@@ skipping 50 matching lines @@
   // |service| must be dereferenceable on |service_task_runner|.
   // This provider is not thread safe, but can be used on any thread.
   CertificateProviderImpl(
       const scoped_refptr<base::SequencedTaskRunner>& service_task_runner,
       const base::WeakPtr<CertificateProviderService>& service);
   ~CertificateProviderImpl() override;
 
   void GetCertificates(const base::Callback<void(const net::CertificateList&)>&
                            callback) override;
 
-  scoped_ptr<CertificateProvider> Copy() override;
+  std::unique_ptr<CertificateProvider> Copy() override;
 
  private:
   static void GetCertificatesOnServiceThread(
       const base::WeakPtr<CertificateProviderService>& service,
       const base::Callback<void(const net::CertificateList&)>& callback);
 
   const scoped_refptr<base::SequencedTaskRunner> service_task_runner_;
   // Must be dereferenced on |service_task_runner_| only.
   const base::WeakPtr<CertificateProviderService> service_;
 
@@ skipping 88 matching lines @@
       base::ThreadTaskRunnerHandle::Get();
   const base::Callback<void(const net::CertificateList&)>
       callback_from_service_thread = base::Bind(&PostCertificatesToTaskRunner,
                                                 source_task_runner, callback);
 
   service_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GetCertificatesOnServiceThread, service_,
                             callback_from_service_thread));
 }
 
-scoped_ptr<CertificateProvider>
+std::unique_ptr<CertificateProvider>
 CertificateProviderService::CertificateProviderImpl::Copy() {
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new CertificateProviderImpl(service_task_runner_, service_));
 }
 
 // static
 void CertificateProviderService::CertificateProviderImpl::
     GetCertificatesOnServiceThread(
         const base::WeakPtr<CertificateProviderService>& service,
         const base::Callback<void(const net::CertificateList&)>& callback) {
   if (!service) {
     callback.Run(net::CertificateList());
@@ skipping 94 matching lines @@
 
   // ClientKeyStore serializes access to |cert_key_provider_|.
   // Once RemoveProvider() returns, it is guaranteed that there are no more
   // accesses to |cert_key_provider_| in flight and no references to
   // |cert_key_provider_| are remaining. This service will hold the last
   // reference to |cert_key_provider_|.
   net::ClientKeyStore::GetInstance()->RemoveProvider(cert_key_provider_.get());
   cert_key_provider_.reset();
 }
 
-void CertificateProviderService::SetDelegate(scoped_ptr<Delegate> delegate) {
+void CertificateProviderService::SetDelegate(
+    std::unique_ptr<Delegate> delegate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!delegate_);
   DCHECK(delegate);
 
   delegate_ = std::move(delegate);
   cert_key_provider_.reset(
       new CertKeyProviderImpl(base::ThreadTaskRunnerHandle::Get(),
                               weak_factory_.GetWeakPtr(), &certificate_map_));
   net::ClientKeyStore::GetInstance()->AddProvider(cert_key_provider_.get());
 }
@@ skipping 42 matching lines @@
     const net::X509Certificate& cert,
     bool* has_extension,
     std::string* extension_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CertificateInfo unused_info;
   return certificate_map_.LookUpCertificate(cert, has_extension, &unused_info,
                                             extension_id);
 }
 
-scoped_ptr<CertificateProvider>
+std::unique_ptr<CertificateProvider>
 CertificateProviderService::CreateCertificateProvider() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  return make_scoped_ptr(new CertificateProviderImpl(
+  return base::WrapUnique(new CertificateProviderImpl(
       base::ThreadTaskRunnerHandle::Get(), weak_factory_.GetWeakPtr()));
 }
 
 void CertificateProviderService::OnExtensionUnloaded(
     const std::string& extension_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   for (const int cert_request_id :
        certificate_requests_.DropExtension(extension_id)) {
     std::map<std::string, CertificateInfoList> certificates;
@@ skipping 77 matching lines @@
   const int sign_request_id = sign_requests_.AddRequest(extension_id, callback);
   if (!delegate_->DispatchSignRequestToExtension(extension_id, sign_request_id,
                                                  hash, certificate, digest)) {
     sign_requests_.RemoveRequest(extension_id, sign_request_id,
                                  nullptr /* callback */);
     callback.Run(net::ERR_FAILED, std::vector<uint8_t>());
   }
 }
 
 }  // namespace chromeos