platformKeys: Hook up the certificate selection dialog to selectClientCertificates.

chrome/browser/chromeos/platform_keys/platform_keys_service.h

 // Copyright 2014 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_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_
 #define CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys.h"
 #include "components/keyed_service/core/keyed_service.h"
 
 namespace content {
 class BrowserContext;
+class WebContents;
 }
 
 namespace base {
 class ListValue;
 class Value;
 }
 
 namespace extensions {
 class StateStore;
 }
 
 namespace net {
 class X509Certificate;
 typedef std::vector<scoped_refptr<X509Certificate>> CertificateList;
 }
 
 namespace chromeos {
 
 class PlatformKeysService : public KeyedService {
  public:
   struct KeyEntry;
   using KeyEntries = std::vector<KeyEntry>;
 
   // The SelectDelegate is used to select a single certificate from all
   // certificates matching a request (see SelectClientCertificates). E.g. this
   // can happen by exposing UI to let the user select.
   class SelectDelegate {
    public:
-    // TODO(pneubeck): Handle if the selection was aborted, e.g. by the user.
-    using CertificateSelectedCallback =
-        base::Callback<void(scoped_refptr<net::X509Certificate> selection)>;
+    using CertificateSelectedCallback = base::Callback<void(
+        const scoped_refptr<net::X509Certificate>& selection)>;
 
     SelectDelegate();
     virtual ~SelectDelegate();
 
     // Called on an interactive SelectClientCertificates call with the list of
     // matching certificates, |certs|.
     // The certificate passed to |callback| will be forwarded to the
     // calling extension and the extension will get unlimited sign permission
     // for this cert. By passing null to |callback|, no cert will be selected.
     // Must eventually call |callback| or be destructed. |callback| must not be
     // called after this delegate is destructed.
+    // |web_contents| and |context| provide the context in which the
+    // certificates were requested and are not null.
     virtual void Select(const std::string& extension_id,
                         const net::CertificateList& certs,
-                        const CertificateSelectedCallback& callback) = 0;
+                        const CertificateSelectedCallback& callback,
+                        content::WebContents* web_contents,
+                        content::BrowserContext* context) = 0;
 
    private:
     DISALLOW_ASSIGN(SelectDelegate);
   };
 
   // Stores registration information in |state_store|, i.e. for each extension
   // the list of public keys that are valid to be used for signing. Each key can
   // be used for signing at most once.
   // The format written to |state_store| is:
   //   kStateStorePlatformKeys maps to a list of strings.
@@ skipping 81 matching lines @@
 
   // Returns a list of certificates matching |request|.
   // 1) all certificates that match the request (like being rooted in one of the
   // give CAs) are determined. 2) if |interactive| is true, the currently set
   // SelectDelegate is used to select a single certificate from these matches
   // which will the extension will also be granted access to. 3) only
   // certificates, that the extension has unlimited sign permission for, will be
   // returned.
   // |callback| will be invoked with these certificates or an error message.
   // Will only call back during the lifetime of this object.
+  // |web_contents| must not be null.
   void SelectClientCertificates(
       const platform_keys::ClientCertificateRequest& request,
       bool interactive,
       const std::string& extension_id,
-      const SelectCertificatesCallback& callback);
+      const SelectCertificatesCallback& callback,
+      content::WebContents* web_contents);
 
  private:
   using GetPlatformKeysCallback =
       base::Callback<void(scoped_ptr<KeyEntries> platform_keys)>;
 
   enum SignPermission { ONCE, UNLIMITED };
 
   class PermissionUpdateTask;
   class SelectTask;
   class SignTask;
@@ skipping 51 matching lines @@
   scoped_ptr<SelectDelegate> select_delegate_;
   std::queue<linked_ptr<Task>> tasks_;
   base::WeakPtrFactory<PlatformKeysService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformKeysService);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_