SSL Connect Job Waiting

net/socket/ssl_client_socket.h

 // 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.
 
 #ifndef NET_SOCKET_SSL_CLIENT_SOCKET_H_
 #define NET_SOCKET_SSL_CLIENT_SOCKET_H_
 
 #include <string>
 
 #include "base/gtest_prod_util.h"
@@ skipping 63 matching lines @@
     kNextProtoUnsupported = 0,  // The server doesn't support NPN.
     kNextProtoNegotiated = 1,   // We agreed on a protocol.
     kNextProtoNoOverlap = 2,    // No protocols in common. We requested
                                 // the first protocol in our list.
   };
 
   // StreamSocket:
   virtual bool WasNpnNegotiated() const OVERRIDE;
   virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
 
+  static bool InSessionCache(std::string cache_key);

[wtc, 2014/06/13 22:47:24]

The input parameter should be const reference.

Please document the method.

[Ryan Sleevi, 2014/06/13 23:24:22]

First reaction: I generally reaction negatively against new static methods,
because they imply global state (in this case, it tightly couples the interface
of SSLClientSocket to the idea of a 'global' SSL session cache)

However, what we 'want' is a per-profile SSL session cache, so that as profiles
are deleted, we evict old sessions. As currently implemented, we actually hold
on to the memory for these structures even after the Profile is deleted. The
only reason this hasn't killed us on memory usage (yet) is the eviction rate of
Chrome, but it's something we should fix.

As such, the idea of what session cache a given socket belongs to is likely
something that the SSLClientSocketPool would pass to the SSLConnectJob - the
Pool would get its value from Params (which would come from the ProfileIOData in
Chrome), would pass just that value to the Job, and the Job would pass that to
the Socket.

That would get rid of the |ssl_session_cache_shard_arg| in the
SSLClientSocketContext, in favor of the new structure.

The other "coupling smell" is that the computing of |cache_key| is done internal
to the SSLClientSocket, as part of Connect() [eg: when it has a host/port],
whereas this method expects callers to be able to recreate that same logic. We
would likely want to keep that centralized.

[mshelley1, 2014/06/16 19:02:49]

Done.

+
   // Gets the SSL CertificateRequest info of the socket after Connect failed
   // with ERR_SSL_CLIENT_AUTH_CERT_NEEDED.
   virtual void GetSSLCertRequestInfo(
       SSLCertRequestInfo* cert_request_info) = 0;
 
   // Get the application level protocol that we negotiated with the server.
   // *proto is set to the resulting protocol (n.b. that the string may have
   // embedded NULs).
   //   kNextProtoUnsupported: *proto is cleared.
   //   kNextProtoNegotiated:  *proto is set to the negotiated protocol.
@@ skipping 89 matching lines @@
   bool channel_id_sent_;
   // True if SCTs were received via a TLS extension.
   bool signed_cert_timestamps_received_;
   // True if a stapled OCSP response was received.
   bool stapled_ocsp_response_received_;
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SSL_CLIENT_SOCKET_H_