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/sign_requests.h"
 #include "chrome/browser/chromeos/certificate_provider/thread_safe_certificate_map.h"
+#include "chrome/browser/chromeos/options/request_pin_view.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;
 
 // A keyed service that manages registrations of extensions as certificate
 // providers. It exposes all certificates that are provided by extensions
@@ skipping 109 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);
 
+  // The user provided input to dialog. |closed| tells whether the dialog was
+  // closed by the user without providing any input.
+  void OnPinDialogInput(const std::string& extension_id, const bool closed);
+
+  // This callback function is called by the view when user closes the PIN
+  // dialog while the last input is still processing at extension side. |value|
+  // is not used, but checked that it's empty.
+  void OnFlowInterrupted(const base::string16& value);
+
+  // Returns whether the last PIN dialog from this extension was closed by the
+  // user.
+  bool LastPinDialogClosed(const std::string& extension_id);
+
+  // Creates a new RequestPinView object and displays it in a dialog or reuses
+  // the old dialog if active one exists just updating the parameters. Returns
+  // if the dialog is displayed and extension owns it.
+  bool ShowPinDialog(const std::string& extension_id,
+                     const std::string& extension_name,
+                     const std::string& dialog_type,
+                     const base::string16& error_message,
+                     const bool accept_input,
+                     const RequestPinView::UserInputCallback& callback);
+
+  // The active dialog is closed if the |extension_id| matches the
+  // |active_dialog_extension_id_|. Returns whether the dialog was closed.
+  bool CloseDialog(const std::string& extension_id);
+
+  RequestPinView* active_view_for_testing() { return active_pin_dialog_; }
+  views::Widget* active_window_for_testing() { return active_window_; }
+
  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 27 matching lines @@
   // An instance of net::ClientKeyStore::CertKeyProvider that is registered at
   // the net::ClientKeyStore singleton.
   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_;
 
+  // State about last response from user to the ShowPinDialog extension.
+  std::map<std::string, bool> last_rejected_;
+
+  // There can be only one active dialog to request PIN from this extension.
+  // Keeps the ownership.
+  chromeos::RequestPinView* active_pin_dialog_ = nullptr;
+  std::string active_dialog_extension_id_;
+  views::Widget* active_window_ = nullptr;
+
   // 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_