Add new certificateProvider extension API.

chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc

Index: chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc
diff --git a/chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc b/chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc
new file mode 100644
index 0000000000000000000000000000000000000000..161d299a8426b7fd1af1f08714f78ec2e81b5eb5
--- /dev/null
+++ b/chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc
@@ -0,0 +1,93 @@
+#include "chrome/browser/extensions/api/certificate_provider/certificate_provider_api.h"
+
+#include "base/memory/linked_ptr.h"
+#include "base/stl_util.h"
+#include "chrome/browser/chromeos/certificate_provider/certificate_provider_service.h"
+#include "chrome/browser/chromeos/certificate_provider/certificate_provider_service_factory.h"
+#include "chrome/common/extensions/api/certificate_provider.h"
+#include "net/cert/x509_certificate.h"
+
+namespace extensions {
+
+namespace api_cp = api::certificate_provider;
+
+namespace {
+
+const char kErrorInvalidX509Cert[] =
+    "Certificate is not a valid X.509 certificate.";
+
+}  // namespace
+
+CertificateProviderPublishClientCertificatesFunction::
+    ~CertificateProviderPublishClientCertificatesFunction() {}
+
+ExtensionFunction::ResponseAction
+CertificateProviderPublishClientCertificatesFunction::Run() {
+  scoped_ptr<api_cp::PublishClientCertificates::Params> params(
+      api_cp::PublishClientCertificates::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  chromeos::CertificateProviderService* service =
+      chromeos::CertificateProviderServiceFactory::GetForBrowserContext(
+          browser_context());
+  DCHECK(service);
+
+  chromeos::CertificateProviderService::CertificateInfos cert_infos;
+  for (linked_ptr<api_cp::CertificateInfo> input_cert_info :
+       params->certificates) {
+    chromeos::CertificateProviderService::CertificateInfo new_cert_info;
+
+    const std::vector<char>& cert_der = input_cert_info->certificate;
+    if (cert_der.empty())
+      return RespondNow(Error(kErrorInvalidX509Cert));
+
+    new_cert_info.certificate = net::X509Certificate::CreateFromBytes(
+        vector_as_array(&cert_der), cert_der.size());
+    if (!new_cert_info.certificate)
+      return RespondNow(Error(kErrorInvalidX509Cert));
+
+    for (auto hash : input_cert_info->supported_hashes) {
+      switch(hash) {
+        case api_cp::HASH_MD5_SHA1:
+          new_cert_info.supported_hashes.push_back(
+              net::SSLPrivateKey::Hash::MD5_SHA1);
+          break;
+        case api_cp::HASH_SHA1:
+          new_cert_info.supported_hashes.push_back(
+              net::SSLPrivateKey::Hash::SHA1);
+          break;
+        case api_cp::HASH_SHA256:
+          new_cert_info.supported_hashes.push_back(
+              net::SSLPrivateKey::Hash::SHA256);
+          break;
+        case api_cp::HASH_SHA384:
+          new_cert_info.supported_hashes.push_back(
+              net::SSLPrivateKey::Hash::SHA384);
+          break;
+        case api_cp::HASH_SHA512:
+          new_cert_info.supported_hashes.push_back(
+              net::SSLPrivateKey::Hash::SHA512);
+          break;
+        case api_cp::HASH_NONE:
+          return RespondNow(Error("Unknown hash function"));
+      }
+    }
+
+    cert_infos.push_back(new_cert_info);
+  }
+
+  service->SetCertificatesProvidedByExtension(extension_id(), cert_infos);
+
+  return RespondNow(NoArguments());
+//  return RespondNow(Error("Not implemented"));
+}
+
+CertificateProviderReplyToSignRequestFunction::
+    ~CertificateProviderReplyToSignRequestFunction() {}
+
+ExtensionFunction::ResponseAction
+CertificateProviderReplyToSignRequestFunction::Run() {
+  return RespondNow(Error("Not implemented"));
+}
+
+}  // namespace extensions