Support for server session cache.

remoting/protocol/ssl_hmac_channel_authenticator.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 "remoting/protocol/ssl_hmac_channel_authenticator.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 133 matching lines @@
   }
 
  private:
   scoped_ptr<P2PStreamSocket> socket_;
   net::BoundNetLog net_log_;
 };
 
 // Implements P2PStreamSocket interface on top of net::StreamSocket.
 class P2PStreamSocketAdapter : public P2PStreamSocket {
  public:
-  P2PStreamSocketAdapter(scoped_ptr<net::StreamSocket> socket)
-      : socket_(std::move(socket)) {}
+  P2PStreamSocketAdapter(scoped_ptr<net::StreamSocket> socket,
+                         scoped_ptr<net::SSLServerContext> server_context)
+      : socket_(std::move(socket)),
+        server_context_(std::move(server_context)) {}
   ~P2PStreamSocketAdapter() override {}
 
   int Read(const scoped_refptr<net::IOBuffer>& buf, int buf_len,
            const net::CompletionCallback& callback) override {
     return socket_->Read(buf.get(), buf_len, callback);
   }
   int Write(const scoped_refptr<net::IOBuffer>& buf, int buf_len,
             const net::CompletionCallback& callback) override {
     return socket_->Write(buf.get(), buf_len, callback);
   }
 
  private:
   scoped_ptr<net::StreamSocket> socket_;
+  // The server_context_ will be a nullptr for client sockets.
+  scoped_ptr<net::SSLServerContext> server_context_;

[Sergey Ulanov, 2016/03/07 22:30:24]

move this above socket_. Otherwise it will be destroyed before socket_ and I
don't think you want that.

[ryanchung, 2016/03/07 22:44:06]

Done. Thanks!

 };
 
 }  // namespace
 
 // static
 scoped_ptr<SslHmacChannelAuthenticator>
 SslHmacChannelAuthenticator::CreateForClient(
       const std::string& remote_cert,
       const std::string& auth_key) {
   scoped_ptr<SslHmacChannelAuthenticator> result(
@@ skipping 31 matching lines @@
 
   int result;
   if (is_ssl_server()) {
 #if defined(OS_NACL)
     // Client plugin doesn't use server SSL sockets, and so SSLServerSocket
     // implementation is not compiled for NaCl as part of net_nacl.
     NOTREACHED();
     result = net::ERR_FAILED;
 #else
     scoped_refptr<net::X509Certificate> cert =
-        net::X509Certificate::CreateFromBytes(
-            local_cert_.data(), local_cert_.length());
+        net::X509Certificate::CreateFromBytes(local_cert_.data(),
+                                              local_cert_.length());
     if (!cert.get()) {
       LOG(ERROR) << "Failed to parse X509Certificate";
       NotifyError(net::ERR_FAILED);
       return;
     }
 
     net::SSLServerConfig ssl_config;
     ssl_config.require_ecdhe = true;
 
-    scoped_ptr<net::SSLServerSocket> server_socket = net::CreateSSLServerSocket(
-        make_scoped_ptr(new NetStreamSocketAdapter(std::move(socket))),
+    server_context_ = net::CreateSSLServerContext(
         cert.get(), *local_key_pair_->private_key(), ssl_config);
+
+    scoped_ptr<net::SSLServerSocket> server_socket =
+        server_context_->CreateSSLServerSocket(
+            make_scoped_ptr(new NetStreamSocketAdapter(std::move(socket))));
     net::SSLServerSocket* raw_server_socket = server_socket.get();
     socket_ = std::move(server_socket);
     result = raw_server_socket->Handshake(
         base::Bind(&SslHmacChannelAuthenticator::OnConnected,
                    base::Unretained(this)));
 #endif
   } else {
     transport_security_state_.reset(new net::TransportSecurityState);
     cert_verifier_.reset(new FailingCertVerifier);
 
@@ skipping 179 matching lines @@
                                 &(auth_bytes[0]), kAuthDigestLength);
 }
 
 void SslHmacChannelAuthenticator::CheckDone(bool* callback_called) {
   if (auth_write_buf_.get() == nullptr && auth_read_buf_.get() == nullptr) {
     DCHECK(socket_.get() != nullptr);
     if (callback_called)
       *callback_called = true;
 
     base::ResetAndReturn(&done_callback_)
-        .Run(net::OK,
-             make_scoped_ptr(new P2PStreamSocketAdapter(std::move(socket_))));
+        .Run(net::OK, make_scoped_ptr(new P2PStreamSocketAdapter(
+                          std::move(socket_), std::move(server_context_))));
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   base::ResetAndReturn(&done_callback_).Run(error, nullptr);
 }
 
 }  // namespace protocol
 }  // namespace remoting