First implementation of chrome.platformKeys.

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/values.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/state_store.h"
+#include "net/cert/x509_certificate.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
 const char kErrorKeyNotAllowedForSigning[] =
     "This key is not allowed for signing. Either it was used for signing "
     "before or it was not correctly generated.";
@@ skipping 44 matching lines @@
     extensions::StateStore* state_store)
     : browser_context_(browser_context),
       state_store_(state_store),
       weak_factory_(this) {
   DCHECK(state_store);
 }
 
 PlatformKeysService::~PlatformKeysService() {
 }
 
+void PlatformKeysService::DisablePermissionCheckForTesting() {
+  permission_check_enabled_ = false;
+}
+
 void PlatformKeysService::GenerateRSAKey(const std::string& token_id,
                                          unsigned int modulus_length,
                                          const std::string& extension_id,
                                          const GenerateKeyCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   platform_keys::subtle::GenerateRSAKey(
       token_id,
       modulus_length,
       base::Bind(&PlatformKeysService::GenerateRSAKeyCallback,
@@ skipping 14 matching lines @@
                                public_key_spki_der,
                                base::Bind(&CheckValidityAndSign,
                                           token_id,
                                           public_key_spki_der,
                                           hash_algorithm,
                                           data,
                                           callback,
                                           browser_context_));
 }
 
+void PlatformKeysService::SelectClientCertificates(
+    const platform_keys::ClientCertificateRequest& request,
+    const std::string& extension_id,
+    const SelectCertificatesCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  platform_keys::subtle::SelectClientCertificates(
+      request,
+      base::Bind(&PlatformKeysService::SelectClientCertificatesCallback,
+                 weak_factory_.GetWeakPtr(), extension_id, callback),
+      browser_context_);
+}
+
 void PlatformKeysService::RegisterPublicKey(
     const std::string& extension_id,
     const std::string& public_key_spki_der,
     const base::Closure& callback) {
   GetPlatformKeysOfExtension(
       extension_id,
       base::Bind(&PlatformKeysService::RegisterPublicKeyGotPlatformKeys,
                  weak_factory_.GetWeakPtr(),
                  extension_id,
                  public_key_spki_der,
@@ skipping 35 matching lines @@
     const std::string& error_message) {
   if (!error_message.empty()) {
     callback.Run(std::string() /* no public key */, error_message);
     return;
   }
   base::Closure wrapped_callback(
       base::Bind(&RunGenerateKeyCallback, callback, public_key_spki_der));
   RegisterPublicKey(extension_id, public_key_spki_der, wrapped_callback);
 }
 
+void PlatformKeysService::SelectClientCertificatesCallback(
+    const std::string& extension_id,
+    const SelectCertificatesCallback& callback,
+    scoped_ptr<net::CertificateList> matches,
+    const std::string& error_message) {
+  if (permission_check_enabled_)
+    matches->clear();
+
+  // TODO(pneubeck): Remove all certs that the extension doesn't have access to.
+  callback.Run(matches.Pass(), error_message);
+}
+
 void PlatformKeysService::RegisterPublicKeyGotPlatformKeys(
     const std::string& extension_id,
     const std::string& public_key_spki_der,
     const base::Closure& callback,
     scoped_ptr<base::ListValue> platform_keys) {
   scoped_ptr<base::StringValue> key_value(
       GetPublicKeyValue(public_key_spki_der));
 
   DCHECK(platform_keys->end() == platform_keys->Find(*key_value))
       << "Keys are assumed to be generated and not to be registered multiple "
@@ skipping 35 matching lines @@
 
     keys = new base::ListValue;
     value.reset(keys);
   }
 
   ignore_result(value.release());
   callback.Run(make_scoped_ptr(keys));
 }
 
 }  // namespace chromeos