Populate cert_key_types on OpenSSL.

net/test/spawned_test_server/base_test_server.cc

 // Copyright 2013 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 "net/test/spawned_test_server/base_test_server.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 22 matching lines @@
       options.server_certificate ==
           BaseTestServer::SSLOptions::CERT_MISMATCHED_NAME) {
     // Return a different hostname string that resolves to the same hostname.
     return "localhost";
   }
 
   // Use the 127.0.0.1 as default.
   return BaseTestServer::kLocalhost;
 }
 
+std::string GetClientCertType(SSLClientCertType type) {
+  switch (type) {
+    case CLIENT_CERT_RSA_SIGN:
+      return "rsa_sign";
+    case CLIENT_CERT_DSS_SIGN:
+      return "dss_sign";
+    case CLIENT_CERT_ECDSA_SIGN:
+      return "ecdsa_sign";
+    default:
+      NOTREACHED();
+      return "";
+  }
+}
+
 void GetKeyExchangesList(int key_exchange, base::ListValue* values) {
   if (key_exchange & BaseTestServer::SSLOptions::KEY_EXCHANGE_RSA)
     values->Append(new base::StringValue("rsa"));
   if (key_exchange & BaseTestServer::SSLOptions::KEY_EXCHANGE_DHE_RSA)
     values->Append(new base::StringValue("dhe_rsa"));
 }
 
 void GetCiphersList(int cipher, base::ListValue* values) {
   if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_RC4)
     values->Append(new base::StringValue("rc4"));
@@ skipping 326 matching lines @@
       if (it->IsAbsolute() && !base::PathExists(*it)) {
         LOG(ERROR) << "Client authority path " << it->value()
                    << " doesn't exist. Can't launch https server.";
         return false;
       }
       ssl_client_certs->Append(new base::StringValue(it->value()));
     }
 
     if (ssl_client_certs->GetSize())
       arguments->Set("ssl-client-ca", ssl_client_certs.release());
+
+    scoped_ptr<base::ListValue> client_cert_types(new base::ListValue());
+    for (size_t i = 0; i < ssl_options_.client_cert_types.size(); i++) {
+      client_cert_types->Append(new base::StringValue(
+          GetClientCertType(ssl_options_.client_cert_types[i])));
+    }
+    if (client_cert_types->GetSize())
+      arguments->Set("ssl-client-cert-type", client_cert_types.release());
   }
 
   if (type_ == TYPE_HTTPS) {
     arguments->Set("https", base::Value::CreateNullValue());
 
     std::string ocsp_arg = ssl_options_.GetOCSPArgument();
     if (!ocsp_arg.empty())
       arguments->SetString("ocsp", ocsp_arg);
 
     if (ssl_options_.cert_serial != 0) {
@@ skipping 33 matching lines @@
 
   return GenerateAdditionalArguments(arguments);
 }
 
 bool BaseTestServer::GenerateAdditionalArguments(
     base::DictionaryValue* arguments) const {
   return true;
 }
 
 }  // namespace net