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

chrome/browser/chromeos/certificate_provider/certificate_provider_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_SERVICE_H_
 #define CHROME_BROWSER_CHROMEOS_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_SERVICE_H_
 
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/chromeos/certificate_provider/certificate_info.h"
 #include "chrome/browser/chromeos/certificate_provider/certificate_requests.h"
 #include "chrome/browser/chromeos/certificate_provider/sign_requests.h"
 #include "chrome/browser/chromeos/certificate_provider/thread_safe_certificate_map.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "net/cert/x509_certificate.h"
 #include "net/ssl/ssl_private_key.h"
 
@@ skipping 64 matching lines @@
   };
 
   // |SetDelegate| must be called exactly once directly after construction.
   CertificateProviderService();
   ~CertificateProviderService() override;
 
   // Must be called exactly once after construction and before other methods are
   // called. The delegate will be destroyed in the destructor of the service and
   // not before, which allows to unregister observers (e.g. for
   // OnExtensionUnloaded) in the delegate's destructor on behalf of the service.
-  void SetDelegate(scoped_ptr<Delegate> delegate);
+  void SetDelegate(std::unique_ptr<Delegate> delegate);
 
   // Must be called with the reply of an extension to a previous certificate
   // request. For each request, it is expected that every registered extension
   // replies exactly once with the latest list of certificates.
   // |cert_request_id| must refer to a previously broadcast certificate request.
   // Returns false and ignores the call if the request id is unknown or it was
   // called before with the same combination of request id and extension id.
   // E.g. the request could have timed out before an extension replies.
   bool SetCertificatesProvidedByExtension(
       const std::string& extension_id,
@@ skipping 23 matching lines @@
   bool LookUpCertificate(const net::X509Certificate& cert,
                          bool* is_currently_provided,
                          std::string* extension_id);
 
   // Returns a CertificateProvider that always returns the latest list of
   // certificates that are provided by all registered extensions. Therefore, it
   // is sufficient to create the CertificateProvider once and then repeatedly
   // call its |GetCertificates()|. The returned provider is valid even after the
   // destruction of this service.
   // The returned provider can be used on any thread.
-  scoped_ptr<CertificateProvider> CreateCertificateProvider();
+  std::unique_ptr<CertificateProvider> CreateCertificateProvider();
 
   // Must be called if extension with id |extension_id| is unloaded and cannot
   // serve certificates anymore. This should be called everytime the
   // corresponding notification of the ExtensionRegistry is triggered.
   void OnExtensionUnloaded(const std::string& extension_id);
 
  private:
   class CertKeyProviderImpl;
   class CertificateProviderImpl;
   class SSLPrivateKey;
@@ skipping 21 matching lines @@
   // Requests extension with |extension_id| to sign |digest| with the private
   // key certified by |certificate|. |hash| was used to create |digest|.
   // |callback| will be run with the reply of the extension or an error.
   void RequestSignatureFromExtension(
       const std::string& extension_id,
       const scoped_refptr<net::X509Certificate>& certificate,
       net::SSLPrivateKey::Hash hash,
       const std::string& digest,
       const net::SSLPrivateKey::SignCallback& callback);
 
-  scoped_ptr<Delegate> delegate_;
+  std::unique_ptr<Delegate> delegate_;
 
   // An instance of net::ClientKeyStore::CertKeyProvider that is registered at
   // the net::ClientKeyStore singleton.
-  scoped_ptr<CertKeyProviderImpl> cert_key_provider_;
+  std::unique_ptr<CertKeyProviderImpl> cert_key_provider_;
 
   // State about all pending sign requests.
   certificate_provider::SignRequests sign_requests_;
 
   // Contains all pending certificate requests.
   certificate_provider::CertificateRequests certificate_requests_;
 
   // Contains all certificates that the extensions returned during the lifetime
   // of this service. Each certificate is associated with the extension that
   // reported the certificate in response to the most recent certificate
   // request. If a certificate was reported previously but in the most recent
   // responses, it is still cached but not loses it's association with any
   // extension. This ensures that a certificate can't magically appear as
   // platform certificate (e.g. in the client certificate selection dialog)
   // after an extension doesn't report it anymore.
   certificate_provider::ThreadSafeCertificateMap certificate_map_;
 
   base::ThreadChecker thread_checker_;
   base::WeakPtrFactory<CertificateProviderService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CertificateProviderService);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_SERVICE_H_