Plumbing SSLPrivateKey

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
@@ skipping 34 matching lines @@
   // |certificate_map| must outlive this provider. |service| must be
   // dereferenceable on |service_task_runner|.
   // This provider may be accessed from any thread. Methods and destructor must
   // never be called concurrently.
   CertKeyProviderImpl(
       const scoped_refptr<base::SequencedTaskRunner>& service_task_runner,
       const base::WeakPtr<CertificateProviderService>& service,
       certificate_provider::ThreadSafeCertificateMap* certificate_map);
   ~CertKeyProviderImpl() override;
 
-  bool GetCertificateKey(const net::X509Certificate& cert,
-                         scoped_ptr<net::SSLPrivateKey>* private_key) override;
+  bool GetCertificateKey(
+      const net::X509Certificate& cert,
+      scoped_refptr<net::SSLPrivateKey>* private_key) override;
 
  private:
   const scoped_refptr<base::SequencedTaskRunner> service_task_runner_;
   // Must be dereferenced on |service_task_runner_| only.
   base::WeakPtr<CertificateProviderService> service_;
   certificate_provider::ThreadSafeCertificateMap* const certificate_map_;
 
   DISALLOW_COPY_AND_ASSIGN(CertKeyProviderImpl);
 };
 
@@ skipping 30 matching lines @@
 // Objects of this class must be used on a single thread. Any thread is allowed.
 class CertificateProviderService::SSLPrivateKey : public net::SSLPrivateKey {
  public:
   // Any calls back to |service| will be posted to |service_task_runner|.
   // |service| must be dereferenceable on |service_task_runner|.
   SSLPrivateKey(
       const std::string& extension_id,
       const CertificateInfo& cert_info,
       const scoped_refptr<base::SequencedTaskRunner>& service_task_runner,
       const base::WeakPtr<CertificateProviderService>& service);
-  ~SSLPrivateKey() override;
 
   // net::SSLPrivateKey:
   Type GetType() override;
   bool SupportsHash(Hash hash) override;
   size_t GetMaxSignatureLengthInBytes() override;
   void SignDigest(Hash hash,
                   const base::StringPiece& input,
                   const SignCallback& callback) override;
 
  private:
+  ~SSLPrivateKey() override;
+
   static void SignDigestOnServiceTaskRunner(
       const base::WeakPtr<CertificateProviderService>& service,
       const std::string& extension_id,
       const scoped_refptr<net::X509Certificate>& certificate,
       Hash hash,
       const std::string& input,
       const SignCallback& callback);
 
   void DidSignDigest(const SignCallback& callback,
                      net::Error error,
@@ skipping 15 matching lines @@
     const base::WeakPtr<CertificateProviderService>& service,
     certificate_provider::ThreadSafeCertificateMap* certificate_map)
     : service_task_runner_(service_task_runner),
       service_(service),
       certificate_map_(certificate_map) {}
 
 CertificateProviderService::CertKeyProviderImpl::~CertKeyProviderImpl() {}
 
 bool CertificateProviderService::CertKeyProviderImpl::GetCertificateKey(
     const net::X509Certificate& cert,
-    scoped_ptr<net::SSLPrivateKey>* private_key) {
+    scoped_refptr<net::SSLPrivateKey>* private_key) {
   bool is_currently_provided = false;
   CertificateInfo info;
   std::string extension_id;
   certificate_map_->LookUpCertificate(cert, &is_currently_provided, &info,
                                       &extension_id);
   if (!is_currently_provided)
     return false;
 
-  private_key->reset(
-      new SSLPrivateKey(extension_id, info, service_task_runner_, service_));
+  scoped_refptr<net::SSLPrivateKey> new_key =
+      new SSLPrivateKey(extension_id, info, service_task_runner_, service_);
+  private_key->swap(new_key);

[davidben, 2015/10/13 20:32:15]

private_key = new SSLPrivateKey(...)

[svaldez, 2015/10/14 15:06:18]

Done.

+
   return true;
 }
 
 CertificateProviderService::CertificateProviderImpl::CertificateProviderImpl(
     const scoped_refptr<base::SequencedTaskRunner>& service_task_runner,
     const base::WeakPtr<CertificateProviderService>& service)
     : service_task_runner_(service_task_runner), service_(service) {}
 
 CertificateProviderService::CertificateProviderImpl::
     ~CertificateProviderImpl() {}
@@ skipping 37 matching lines @@
     : extension_id_(extension_id),
       cert_info_(cert_info),
       service_task_runner_(service_task_runner),
       service_(service),
       weak_factory_(this) {
   // This constructor is called on |service_task_runner|. Only subsequent calls
   // to member functions have to be on a common thread.
   thread_checker_.DetachFromThread();
 }
 
-CertificateProviderService::SSLPrivateKey::~SSLPrivateKey() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
 CertificateProviderService::SSLPrivateKey::Type
 CertificateProviderService::SSLPrivateKey::GetType() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return cert_info_.type;
 }
 
 bool CertificateProviderService::SSLPrivateKey::SupportsHash(Hash hash) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return ContainsValue(cert_info_.supported_hashes, hash);
 }
@@ skipping 36 matching lines @@
                  // destroyed in the meantime.
                  base::Bind(&SSLPrivateKey::DidSignDigest,
                             weak_factory_.GetWeakPtr(), callback));
 
   service_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SSLPrivateKey::SignDigestOnServiceTaskRunner,
                             service_, extension_id_, cert_info_.certificate,
                             hash, input.as_string(), bound_callback));
 }
 
+CertificateProviderService::SSLPrivateKey::~SSLPrivateKey() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
 void CertificateProviderService::SSLPrivateKey::DidSignDigest(
     const SignCallback& callback,
     net::Error error,
     const std::vector<uint8_t>& signature) {
   DCHECK(thread_checker_.CalledOnValidThread());
   callback.Run(error, signature);
 }
 
 CertificateProviderService::CertificateProviderService()
     : weak_factory_(this) {}
@@ skipping 168 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