platformKeys: Hook up the certificate selection dialog to selectClientCertificates.

chrome/browser/chromeos/platform_keys/platform_keys_service.cc

 // 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.
 
 #include "chrome/browser/chromeos/platform_keys/platform_keys_service.h"
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/values.h"
@@ skipping 409 matching lines @@
   // This task determines all known client certs matching |request|. If
   // |interactive| is true, calls |service->select_delegate_->Select()| to
   // select a cert from all matches. The extension with |extension_id| will be
   // granted unlimited sign permission for the selected cert.
   // Finally, either the selection or, if |interactive| is false, matching certs
   // that the extension has permission for are passed to |callback|.
   SelectTask(const platform_keys::ClientCertificateRequest& request,
              bool interactive,
              const std::string& extension_id,
              const SelectCertificatesCallback& callback,
+             content::WebContents* web_contents,
              PlatformKeysService* service)
       : request_(request),
         interactive_(interactive),
         extension_id_(extension_id),
         callback_(callback),
+        web_contents_(web_contents),
         service_(service),
         weak_factory_(this) {}
   ~SelectTask() override {}
 
   void Start() override {
     CHECK(next_step_ == Step::GET_MATCHING_CERTS);
     DoStep();
   }
   bool IsDone() override { return next_step_ == Step::DONE; }
 
@@ skipping 60 matching lines @@
   // Will call back to |GotSelection()|.
   void SelectCerts() {
     CHECK(interactive_);
     if (matches_.empty()) {
       // Don't show a select dialog if no certificate is matching.
       DoStep();
       return;
     }
     service_->select_delegate_->Select(
         extension_id_, matches_,
-        base::Bind(&SelectTask::GotSelection, base::Unretained(this)));
+        base::Bind(&SelectTask::GotSelection, base::Unretained(this)),
+        web_contents_, service_->browser_context_);
   }
 
   // Will be called by |SelectCerts()| with the selected cert or null if no cert
   // was selected.
-  void GotSelection(scoped_refptr<net::X509Certificate> selected_cert) {
+  void GotSelection(const scoped_refptr<net::X509Certificate>& selected_cert) {
     selected_cert_ = selected_cert;
     DoStep();
   }
 
   // Updates the extension's state store about unlimited sign permission for the
   // selected cert. Does nothing if no cert was selected.
   // Will call back to |DidUpdatePermission()|.
   void UpdatePermission() {
     CHECK(interactive_);
     if (!selected_cert_) {
@@ skipping 63 matching lines @@
   Step next_step_ = Step::GET_MATCHING_CERTS;
   scoped_ptr<KeyEntries> platform_keys_;
   scoped_ptr<PermissionUpdateTask> permission_update_;
 
   net::CertificateList matches_;
   scoped_refptr<net::X509Certificate> selected_cert_;
   platform_keys::ClientCertificateRequest request_;
   const bool interactive_;
   const std::string extension_id_;
   const SelectCertificatesCallback callback_;
+  content::WebContents* const web_contents_;
   PlatformKeysService* const service_;
   base::WeakPtrFactory<SelectTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SelectTask);
 };
 
 PlatformKeysService::SelectDelegate::SelectDelegate() {
 }
 
 PlatformKeysService::SelectDelegate::~SelectDelegate() {
@@ skipping 63 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   StartOrQueueTask(make_scoped_ptr(new SignTask(
       token_id, data, public_key, true /* sign directly without hashing */,
       platform_keys::HASH_ALGORITHM_NONE, extension_id, callback, this)));
 }
 
 void PlatformKeysService::SelectClientCertificates(
     const platform_keys::ClientCertificateRequest& request,
     bool interactive,
     const std::string& extension_id,
-    const SelectCertificatesCallback& callback) {
+    const SelectCertificatesCallback& callback,
+    content::WebContents* web_contents) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  StartOrQueueTask(make_scoped_ptr(
-      new SelectTask(request, interactive, extension_id, callback, this)));
+  StartOrQueueTask(make_scoped_ptr(new SelectTask(
+      request, interactive, extension_id, callback, web_contents, this)));
 }
 
 void PlatformKeysService::StartOrQueueTask(scoped_ptr<Task> task) {
   tasks_.push(make_linked_ptr(task.release()));
   if (tasks_.size() == 1)
     tasks_.front()->Start();
 }
 
 void PlatformKeysService::TaskFinished(Task* task) {
   DCHECK(!tasks_.empty());
@@ skipping 55 matching lines @@
     const GetPlatformKeysCallback& callback,
     scoped_ptr<base::Value> value) {
   scoped_ptr<KeyEntries> key_entries(new KeyEntries);
   if (value)
     key_entries = KeyEntriesFromState(*value);
 
   callback.Run(key_entries.Pass());
 }
 
 }  // namespace chromeos