blob: e0b6080bcf3745d56abcaf7880aa3618b9e56229 [file] [log] [blame]
// Copyright (c) 2011 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.
#pragma once
#include <string>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/time.h"
#include "base/timer.h"
#include "net/base/host_port_pair.h"
#include "net/base/host_resolver.h"
#include "net/base/single_request_host_resolver.h"
#include "net/socket/client_socket_pool_base.h"
#include "net/socket/client_socket_pool_histograms.h"
#include "net/socket/client_socket_pool.h"
namespace net {
class ClientSocketFactory;
class NET_EXPORT_PRIVATE TransportSocketParams
: public base::RefCounted<TransportSocketParams> {
TransportSocketParams(const HostPortPair& host_port_pair,
RequestPriority priority,
const GURL& referrer,
bool disable_resolver_cache,
bool ignore_limits);
const HostResolver::RequestInfo& destination() const { return destination_; }
bool ignore_limits() const { return ignore_limits_; }
friend class base::RefCounted<TransportSocketParams>;
void Initialize(RequestPriority priority, const GURL& referrer,
bool disable_resolver_cache);
HostResolver::RequestInfo destination_;
bool ignore_limits_;
// TransportConnectJob handles the host resolution necessary for socket creation
// and the transport (likely TCP) connect. TransportConnectJob also has fallback
// logic for IPv6 connect() timeouts (which may happen due to networks / routers
// with broken IPv6 support). Those timeouts take 20s, so rather than make the
// user wait 20s for the timeout to fire, we use a fallback timer
// (kIPv6FallbackTimerInMs) and start a connect() to a IPv4 address if the timer
// fires. Then we race the IPv4 connect() against the IPv6 connect() (which has
// a headstart) and return the one that completes first to the socket pool.
class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
TransportConnectJob(const std::string& group_name,
const scoped_refptr<TransportSocketParams>& params,
base::TimeDelta timeout_duration,
ClientSocketFactory* client_socket_factory,
HostResolver* host_resolver,
Delegate* delegate,
NetLog* net_log);
virtual ~TransportConnectJob();
// ConnectJob methods.
virtual LoadState GetLoadState() const;
// Makes |addrlist| start with an IPv4 address if |addrlist| contains any
// IPv4 address.
// WARNING: this method should only be used to implement the prefer-IPv4
// hack. It is a public method for the unit tests.
static void MakeAddrListStartWithIPv4(AddressList* addrlist);
static const int kIPv6FallbackTimerInMs;
enum State {
void OnIOComplete(int result);
// Runs the state transition loop.
int DoLoop(int result);
int DoResolveHost();
int DoResolveHostComplete(int result);
int DoTransportConnect();
int DoTransportConnectComplete(int result);
// Not part of the state machine.
void DoIPv6FallbackTransportConnect();
void DoIPv6FallbackTransportConnectComplete(int result);
// Begins the host resolution and the TCP connect. Returns OK on success
// and ERR_IO_PENDING if it cannot immediately service the request.
// Otherwise, it returns a net error code.
virtual int ConnectInternal();
scoped_refptr<TransportSocketParams> params_;
ClientSocketFactory* const client_socket_factory_;
CompletionCallbackImpl<TransportConnectJob> callback_;
SingleRequestHostResolver resolver_;
AddressList addresses_;
State next_state_;
// The time Connect() was called.
base::TimeTicks start_time_;
// The time the connect was started (after DNS finished).
base::TimeTicks connect_start_time_;
scoped_ptr<StreamSocket> transport_socket_;
scoped_ptr<StreamSocket> fallback_transport_socket_;
scoped_ptr<AddressList> fallback_addresses_;
CompletionCallbackImpl<TransportConnectJob> fallback_callback_;
base::TimeTicks fallback_connect_start_time_;
base::OneShotTimer<TransportConnectJob> fallback_timer_;
class NET_EXPORT_PRIVATE TransportClientSocketPool : public ClientSocketPool {
int max_sockets,
int max_sockets_per_group,
ClientSocketPoolHistograms* histograms,
HostResolver* host_resolver,
ClientSocketFactory* client_socket_factory,
NetLog* net_log);
virtual ~TransportClientSocketPool();
// ClientSocketPool methods:
virtual int RequestSocket(const std::string& group_name,
const void* resolve_info,
RequestPriority priority,
ClientSocketHandle* handle,
CompletionCallback* callback,
const BoundNetLog& net_log);
virtual void RequestSockets(const std::string& group_name,
const void* params,
int num_sockets,
const BoundNetLog& net_log);
virtual void CancelRequest(const std::string& group_name,
ClientSocketHandle* handle);
virtual void ReleaseSocket(const std::string& group_name,
StreamSocket* socket,
int id);
virtual void Flush();
virtual void CloseIdleSockets();
virtual int IdleSocketCount() const;
virtual int IdleSocketCountInGroup(const std::string& group_name) const;
virtual LoadState GetLoadState(const std::string& group_name,
const ClientSocketHandle* handle) const;
virtual base::DictionaryValue* GetInfoAsValue(
const std::string& name,
const std::string& type,
bool include_nested_pools) const;
virtual base::TimeDelta ConnectionTimeout() const;
virtual ClientSocketPoolHistograms* histograms() const;
typedef ClientSocketPoolBase<TransportSocketParams> PoolBase;
class TransportConnectJobFactory
: public PoolBase::ConnectJobFactory {
TransportConnectJobFactory(ClientSocketFactory* client_socket_factory,
HostResolver* host_resolver,
NetLog* net_log)
: client_socket_factory_(client_socket_factory),
net_log_(net_log) {}
virtual ~TransportConnectJobFactory() {}
// ClientSocketPoolBase::ConnectJobFactory methods.
virtual ConnectJob* NewConnectJob(
const std::string& group_name,
const PoolBase::Request& request,
ConnectJob::Delegate* delegate) const;
virtual base::TimeDelta ConnectionTimeout() const;
ClientSocketFactory* const client_socket_factory_;
HostResolver* const host_resolver_;
NetLog* net_log_;
PoolBase base_;
} // namespace net