Support for server session cache.

net/test/embedded_test_server/embedded_test_server.cc

 // Copyright (c) 2012 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/embedded_test_server/embedded_test_server.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 93 matching lines @@
     if (cert_ == CERT_MISMATCHED_NAME || cert_ == CERT_COMMON_NAME_IS_DOMAIN) {
       base_url_ = GURL(
           base::StringPrintf("https://localhost:%d", local_endpoint_.port()));
     }
   } else {
     base_url_ = GURL("http://" + local_endpoint_.ToString());
   }
   port_ = local_endpoint_.port();
 
   listen_socket_->DetachFromThread();
+
+  if (is_using_ssl_)
+    InitializeSSLServerContext();
   return true;
 }
 
+void EmbeddedTestServer::InitializeSSLServerContext() {
+  base::FilePath certs_dir(GetTestCertsDirectory());
+  std::string cert_name = GetCertificateName();
+
+  base::FilePath key_path = certs_dir.AppendASCII(cert_name);
+  std::string key_string;
+  CHECK(base::ReadFileToString(key_path, &key_string));
+  std::vector<std::string> headers;
+  headers.push_back("PRIVATE KEY");
+  PEMTokenizer pem_tokenizer(key_string, headers);
+  pem_tokenizer.GetNext();
+  std::vector<uint8_t> key_vector;
+  key_vector.assign(pem_tokenizer.data().begin(), pem_tokenizer.data().end());
+
+  scoped_ptr<crypto::RSAPrivateKey> server_key(
+      crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
+  context_ =
+      CreateSSLServerContext(GetCertificate().get(), *server_key, ssl_config_);
+}
+
 void EmbeddedTestServer::StartAcceptingConnections() {
   DCHECK(!io_thread_.get());
   base::Thread::Options thread_options;
   thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.reset(new base::Thread("EmbeddedTestServer IO Thread"));
   CHECK(io_thread_->StartWithOptions(thread_options));
   CHECK(io_thread_->WaitUntilThreadStarted());
 
   io_thread_->task_runner()->PostTask(
       FROM_HERE,
@@ skipping 142 matching lines @@
     const HandleRequestCallback& callback) {
   // TODO(svaldez): Add check to prevent RegisterHandler from being called
   // after the server has started. https://crbug.com/546060
   default_request_handlers_.push_back(callback);
 }
 
 scoped_ptr<StreamSocket> EmbeddedTestServer::DoSSLUpgrade(
     scoped_ptr<StreamSocket> connection) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
-  base::FilePath certs_dir(GetTestCertsDirectory());
-  std::string cert_name = GetCertificateName();
-
-  base::FilePath key_path = certs_dir.AppendASCII(cert_name);
-  std::string key_string;
-  CHECK(base::ReadFileToString(key_path, &key_string));

[davidben, 2016/02/24 21:01:26]

[ Oh hey, we won't have to read the file on every connection now! :-) ]

-  std::vector<std::string> headers;
-  headers.push_back("PRIVATE KEY");
-  PEMTokenizer pem_tokenizer(key_string, headers);
-  pem_tokenizer.GetNext();
-  std::vector<uint8_t> key_vector;
-  key_vector.assign(pem_tokenizer.data().begin(), pem_tokenizer.data().end());
-
-  scoped_ptr<crypto::RSAPrivateKey> server_key(
-      crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
-
-  return CreateSSLServerSocket(std::move(connection), GetCertificate().get(),
-                               *server_key, ssl_config_);
+  return context_->CreateSSLServerSocket(std::move(connection));
 }
 
 void EmbeddedTestServer::DoAcceptLoop() {
   int rv = OK;
   while (rv == OK) {
     rv = listen_socket_->Accept(
         &accepted_socket_, base::Bind(&EmbeddedTestServer::OnAcceptCompleted,
                                       base::Unretained(this)));
     if (rv == ERR_IO_PENDING)
       return;
@@ skipping 115 matching lines @@
                                                    run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net