Implementation for chrome.certificateProvider.requestPin/stopPinRequest

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/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/pin_dialog_manager.h"

[stevenjb, 2016/09/12 21:16:39]

You can forward declare PinDialogManager in this header and move the #include to
the C++ file.

[igorcov, 2016/09/13 14:19:32]

It doesn't compile because there also a getter implementation here.

 #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"
 
 namespace chromeos {
 
 class CertificateProvider;
 
@@ skipping 111 matching lines @@
   // call its |GetCertificates()|. The returned provider is valid even after the
   // destruction of this service.
   // The returned provider can be used on any thread.
   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);
 
+  PinDialogManager* pin_dialog_manager() { return pin_dialog_manager_.get(); }
+
  private:
   class CertKeyProviderImpl;
   class CertificateProviderImpl;
   class SSLPrivateKey;
 
   // Requests the current list of certificates from every registered extension.
   // Once all extensions replied or a timeout was reached, the internal
   // |extension_to_certificates_| is updated and |callback| is run with the
   // retrieved list of certificates.
   void GetCertificatesFromExtensions(
@@ skipping 21 matching lines @@
       net::SSLPrivateKey::Hash hash,
       const std::string& digest,
       const net::SSLPrivateKey::SignCallback& callback);
 
   std::unique_ptr<Delegate> delegate_;
 
   // An instance of net::ClientKeyStore::CertKeyProvider that is registered at
   // the net::ClientKeyStore singleton.
   std::unique_ptr<CertKeyProviderImpl> cert_key_provider_;
 
+  // The object to manage the dialog displayed when requestPin is called by the
+  // extension.
+  std::unique_ptr<PinDialogManager> pin_dialog_manager_;
+
   // 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_