force_spdy_over_ssl_(force_spdy_over_ssl),
want_spdy_over_npn_(want_spdy_over_npn),
ignore_limits_(false) {
- if (direct_params_) {
- DCHECK(!socks_proxy_params_);
- DCHECK(!http_proxy_params_);
+ if (direct_params_.get()) {
+ DCHECK(!socks_proxy_params_.get());
+ DCHECK(!http_proxy_params_.get());
ignore_limits_ = direct_params_->ignore_limits();
- } else if (socks_proxy_params_) {
- DCHECK(!http_proxy_params_);
+ } else if (socks_proxy_params_.get()) {
+ DCHECK(!http_proxy_params_.get());
ignore_limits_ = socks_proxy_params_->ignore_limits();
} else {
- DCHECK(http_proxy_params_);
+ DCHECK(http_proxy_params_.get());
ignore_limits_ = http_proxy_params_->ignore_limits();
}
}
SSLSocketParams::~SSLSocketParams() {}
SSLSocketParams::ConnectionType SSLSocketParams::GetConnectionType() const {
- if (direct_params_) {
- DCHECK(!socks_proxy_params_);
- DCHECK(!http_proxy_params_);
+ if (direct_params_.get()) {
+ DCHECK(!socks_proxy_params_.get());
+ DCHECK(!http_proxy_params_.get());
return DIRECT;
}
- if (socks_proxy_params_) {
- DCHECK(!http_proxy_params_);
+ if (socks_proxy_params_.get()) {
+ DCHECK(!http_proxy_params_.get());
return SOCKS_PROXY;
}
- DCHECK(http_proxy_params_);
+ DCHECK(http_proxy_params_.get());
return HTTP_PROXY;
}
SSLConnectJobMessenger::SocketAndCallback::~SocketAndCallback() {
}
-SSLConnectJobMessenger::SSLConnectJobMessenger() : weak_factory_(this) {
+SSLConnectJobMessenger::SSLConnectJobMessenger(
+ const base::Closure& messenger_finished_callback)
+ : messenger_finished_callback_(messenger_finished_callback),
+ weak_factory_(this) {
}
SSLConnectJobMessenger::~SSLConnectJobMessenger() {
}
bool SSLConnectJobMessenger::CanProceed(SSLClientSocket* ssl_socket) {
- // If the session is in the session cache, or there are no connecting
- // sockets, allow the connection to proceed.
- return ssl_socket->InSessionCache() || connecting_sockets_.empty();
+ // If there are no connecting sockets, allow the connection to proceed.
+ return connecting_sockets_.empty();
}
void SSLConnectJobMessenger::MonitorConnectionResult(
connecting_sockets_.clear();
SSLPendingSocketsAndCallbacks temp_list;
temp_list.swap(pending_sockets_and_callbacks_);
+ base::Closure messenger_finished_callback = messenger_finished_callback_;
+ messenger_finished_callback.Run();
RunAllCallbacks(temp_list);
}
ClientSocketFactory* client_socket_factory,
HostResolver* host_resolver,
const SSLClientSocketContext& context,
- SSLConnectJobMessenger* messenger,
+ const GetMessengerCallback& get_messenger_callback,
Delegate* delegate,
NetLog* net_log)
: ConnectJob(group_name,
: context.ssl_session_cache_shard)),
io_callback_(
base::Bind(&SSLConnectJob::OnIOComplete, base::Unretained(this))),
- messenger_(messenger),
+ messenger_(NULL),
+ get_messenger_callback_(get_messenger_callback),
weak_factory_(this) {
}
params_->host_and_port(),
params_->ssl_config(),
context_);
+
+ if (!ssl_socket_->InSessionCache())
+ messenger_ = get_messenger_callback_.Run(ssl_socket_->GetSessionCacheKey());
+
return OK;
}
int SSLConnectJob::DoCheckForResume() {
next_state_ = STATE_SSL_CONNECT;
+
if (!messenger_)
return OK;
- // TODO(mshelley): Remove duplicate InSessionCache() calls.
if (messenger_->CanProceed(ssl_socket_.get())) {
- if (!ssl_socket_->InSessionCache())
- messenger_->MonitorConnectionResult(ssl_socket_.get());
+ messenger_->MonitorConnectionResult(ssl_socket_.get());
+ // The SSLConnectJob no longer needs access to the messenger after this
+ // point.
+ messenger_ = NULL;
return OK;
}
+
messenger_->AddPendingSocket(ssl_socket_.get(),
base::Bind(&SSLConnectJob::ResumeSSLConnection,
weak_factory_.GetWeakPtr()));
+
return ERR_IO_PENDING;
}
base::TimeDelta::FromMinutes(1),
100);
}
-#if defined(SPDY_PROXY_AUTH_ORIGIN)
- bool using_data_reduction_proxy = params_->host_and_port().Equals(
- HostPortPair::FromURL(GURL(SPDY_PROXY_AUTH_ORIGIN)));
- if (using_data_reduction_proxy) {
- UMA_HISTOGRAM_CUSTOM_TIMES(
- "Net.SSL_Connection_Latency_DataReductionProxy",
- connect_duration,
- base::TimeDelta::FromMilliseconds(1),
- base::TimeDelta::FromMinutes(1),
- 100);
- }
-#endif
UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_2",
connect_duration,
SSLConnectionStatusToCipherSuite(
ssl_info.connection_status));
+ UMA_HISTOGRAM_BOOLEAN(
+ "Net.RenegotiationExtensionSupported",
+ (ssl_info.connection_status &
+ SSL_CONNECTION_NO_RENEGOTIATION_EXTENSION) == 0);
+
if (ssl_info.handshake_type == SSLInfo::HANDSHAKE_RESUME) {
UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_Resume_Handshake",
connect_duration,
void SSLConnectJob::ResumeSSLConnection() {
DCHECK_EQ(next_state_, STATE_SSL_CONNECT);
+ messenger_ = NULL;
OnIOComplete(OK);
}
ClientSocketFactory* client_socket_factory,
HostResolver* host_resolver,
const SSLClientSocketContext& context,
- bool enable_ssl_connect_job_waiting,
+ const SSLConnectJob::GetMessengerCallback& get_messenger_callback,
NetLog* net_log)
: transport_pool_(transport_pool),
socks_pool_(socks_pool),
client_socket_factory_(client_socket_factory),
host_resolver_(host_resolver),
context_(context),
- enable_ssl_connect_job_waiting_(enable_ssl_connect_job_waiting),
- net_log_(net_log),
- messenger_map_(new MessengerMap) {
+ get_messenger_callback_(get_messenger_callback),
+ net_log_(net_log) {
base::TimeDelta max_transport_timeout = base::TimeDelta();
base::TimeDelta pool_timeout;
if (transport_pool_)
}
SSLClientSocketPool::SSLConnectJobFactory::~SSLConnectJobFactory() {
- STLDeleteValues(messenger_map_.get());
}
SSLClientSocketPool::SSLClientSocketPool(
transport_security_state,
cert_transparency_verifier,
ssl_session_cache_shard),
- enable_ssl_connect_job_waiting,
+ base::Bind(
+ &SSLClientSocketPool::GetOrCreateSSLConnectJobMessenger,
+ base::Unretained(this)),
net_log)),
- ssl_config_service_(ssl_config_service) {
+ ssl_config_service_(ssl_config_service),
+ enable_ssl_connect_job_waiting_(enable_ssl_connect_job_waiting) {
if (ssl_config_service_.get())
ssl_config_service_->AddObserver(this);
if (transport_pool_)
}
SSLClientSocketPool::~SSLClientSocketPool() {
+ STLDeleteContainerPairSecondPointers(messenger_map_.begin(),
+ messenger_map_.end());
if (ssl_config_service_.get())
ssl_config_service_->RemoveObserver(this);
}
-scoped_ptr<ConnectJob>
-SSLClientSocketPool::SSLConnectJobFactory::NewConnectJob(
+scoped_ptr<ConnectJob> SSLClientSocketPool::SSLConnectJobFactory::NewConnectJob(
const std::string& group_name,
const PoolBase::Request& request,
ConnectJob::Delegate* delegate) const {
- SSLConnectJobMessenger* messenger = NULL;
- if (enable_ssl_connect_job_waiting_) {
- std::string cache_key = SSLClientSocket::CreateSessionCacheKey(
- request.params()->host_and_port(), context_.ssl_session_cache_shard);
- MessengerMap::const_iterator it = messenger_map_->find(cache_key);
- if (it == messenger_map_->end()) {
- std::pair<MessengerMap::iterator, bool> iter = messenger_map_->insert(
- MessengerMap::value_type(cache_key, new SSLConnectJobMessenger()));
- it = iter.first;
- }
- messenger = it->second;
- }
-
return scoped_ptr<ConnectJob>(new SSLConnectJob(group_name,
request.priority(),
request.params(),
client_socket_factory_,
host_resolver_,
context_,
- messenger,
+ get_messenger_callback_,
delegate,
net_log_));
}
-base::TimeDelta
-SSLClientSocketPool::SSLConnectJobFactory::ConnectionTimeout() const {
+base::TimeDelta SSLClientSocketPool::SSLConnectJobFactory::ConnectionTimeout()
+ const {
return timeout_;
}
return base_.CloseOneIdleConnectionInHigherLayeredPool();
}
+SSLConnectJobMessenger* SSLClientSocketPool::GetOrCreateSSLConnectJobMessenger(
+ const std::string& cache_key) {
+ if (!enable_ssl_connect_job_waiting_)
+ return NULL;
+ MessengerMap::const_iterator it = messenger_map_.find(cache_key);
+ if (it == messenger_map_.end()) {
+ std::pair<MessengerMap::iterator, bool> iter =
+ messenger_map_.insert(MessengerMap::value_type(
+ cache_key,
+ new SSLConnectJobMessenger(
+ base::Bind(&SSLClientSocketPool::DeleteSSLConnectJobMessenger,
+ base::Unretained(this),
+ cache_key))));
+ it = iter.first;
+ }
+ return it->second;
+}
+
+void SSLClientSocketPool::DeleteSSLConnectJobMessenger(
+ const std::string& cache_key) {
+ MessengerMap::iterator it = messenger_map_.find(cache_key);
+ CHECK(it != messenger_map_.end());
+ delete it->second;
+ messenger_map_.erase(it);
+}
+
void SSLClientSocketPool::OnSSLConfigChanged() {
FlushWithError(ERR_NETWORK_CHANGED);
}
projects / platform / framework / web / crosswalk.git / blobdiff