src/net/quic/quic_stream_factory.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/quic_stream_factory.h"
   6
   7 #include <set>
   8
   9 #include "base/cpu.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/message_loop/message_loop_proxy.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/rand_util.h"
  14 #include "base/stl_util.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/values.h"
  17 #include "net/base/net_errors.h"
  18 #include "net/cert/cert_verifier.h"
  19 #include "net/dns/host_resolver.h"
  20 #include "net/dns/single_request_host_resolver.h"
  21 #include "net/http/http_server_properties.h"
  22 #include "net/quic/congestion_control/tcp_receiver.h"
  23 #include "net/quic/crypto/channel_id_chromium.h"
  24 #include "net/quic/crypto/proof_verifier_chromium.h"
  25 #include "net/quic/crypto/quic_random.h"
  26 #include "net/quic/crypto/quic_server_info.h"
  27 #include "net/quic/port_suggester.h"
  28 #include "net/quic/quic_client_session.h"
  29 #include "net/quic/quic_clock.h"
  30 #include "net/quic/quic_connection.h"
  31 #include "net/quic/quic_connection_helper.h"
  32 #include "net/quic/quic_crypto_client_stream_factory.h"
  33 #include "net/quic/quic_default_packet_writer.h"
  34 #include "net/quic/quic_http_stream.h"
  35 #include "net/quic/quic_protocol.h"
  36 #include "net/quic/quic_server_id.h"
  37 #include "net/socket/client_socket_factory.h"
  38
  39 #if defined(OS_WIN)
  40 #include "base/win/windows_version.h"
  41 #endif
  42
  43 using std::string;
  44 using std::vector;
  45
  46 namespace net {
  47
  48 namespace {
  49
  50 enum CreateSessionFailure {
  51   CREATION_ERROR_CONNECTING_SOCKET,
  52   CREATION_ERROR_SETTING_RECEIVE_BUFFER,
  53   CREATION_ERROR_SETTING_SEND_BUFFER,
  54   CREATION_ERROR_MAX
  55 };
  56
  57 // When a connection is idle for 30 seconds it will be closed.
  58 const int kIdleConnectionTimeoutSeconds = 30;
  59
  60 // The initial receive window size for both streams and sessions.
  61 const int32 kInitialReceiveWindowSize = 10 * 1024 * 1024;  // 10MB
  62
  63 // The suggested initial congestion windows for a server to use.
  64 // TODO: This should be tested and optimized, and even better, suggest a window
  65 // that corresponds to historical bandwidth and min-RTT.
  66 // Larger initial congestion windows can, if we don't overshoot, reduce latency
  67 // by avoiding the RTT needed for slow start to double (and re-double) from a
  68 // default of 10.
  69 // We match SPDY's use of 32 when secure (since we'd compete with SPDY).
  70 const int32 kServerSecureInitialCongestionWindow = 32;
  71 // Be conservative, and just use double a typical TCP  ICWND for HTTP.
  72 const int32 kServerInecureInitialCongestionWindow = 20;
  73
  74 const char kDummyHostname[] = "quic.global.props";
  75 const uint16 kDummyPort = 0;
  76
  77 void HistogramCreateSessionFailure(enum CreateSessionFailure error) {
  78   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.CreationError", error,
  79                             CREATION_ERROR_MAX);
  80 }
  81
  82 bool IsEcdsaSupported() {
  83 #if defined(OS_WIN)
  84   if (base::win::GetVersion() < base::win::VERSION_VISTA)
  85     return false;
  86 #endif
  87
  88   return true;
  89 }
  90
  91 QuicConfig InitializeQuicConfig(bool enable_time_based_loss_detection,
  92                                 const QuicTagVector& connection_options) {
  93   QuicConfig config;
  94   config.SetDefaults();
  95   if (enable_time_based_loss_detection)
  96     config.SetLossDetectionToSend(kTIME);
  97   config.set_idle_connection_state_lifetime(
  98       QuicTime::Delta::FromSeconds(kIdleConnectionTimeoutSeconds),
  99       QuicTime::Delta::FromSeconds(kIdleConnectionTimeoutSeconds));
 100   config.SetConnectionOptionsToSend(connection_options);
 101   return config;
 102 }
 103
 104 class DefaultPacketWriterFactory : public QuicConnection::PacketWriterFactory {
 105  public:
 106   explicit DefaultPacketWriterFactory(DatagramClientSocket* socket)
 107       : socket_(socket) {}
 108   virtual ~DefaultPacketWriterFactory() {}
 109
 110   virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE;
 111
 112  private:
 113   DatagramClientSocket* socket_;
 114 };
 115
 116 QuicPacketWriter* DefaultPacketWriterFactory::Create(
 117     QuicConnection* connection) const {
 118   scoped_ptr<QuicDefaultPacketWriter> writer(
 119       new QuicDefaultPacketWriter(socket_));
 120   writer->SetConnection(connection);
 121   return writer.release();
 122 }
 123
 124 }  // namespace
 125
 126 QuicStreamFactory::IpAliasKey::IpAliasKey() {}
 127
 128 QuicStreamFactory::IpAliasKey::IpAliasKey(IPEndPoint ip_endpoint,
 129                                           bool is_https)
 130     : ip_endpoint(ip_endpoint),
 131       is_https(is_https) {}
 132
 133 QuicStreamFactory::IpAliasKey::~IpAliasKey() {}
 134
 135 bool QuicStreamFactory::IpAliasKey::operator<(
 136     const QuicStreamFactory::IpAliasKey& other) const {
 137   if (!(ip_endpoint == other.ip_endpoint)) {
 138     return ip_endpoint < other.ip_endpoint;
 139   }
 140   return is_https < other.is_https;
 141 }
 142
 143 bool QuicStreamFactory::IpAliasKey::operator==(
 144     const QuicStreamFactory::IpAliasKey& other) const {
 145   return is_https == other.is_https &&
 146       ip_endpoint == other.ip_endpoint;
 147 };
 148
 149 // Responsible for creating a new QUIC session to the specified server, and
 150 // for notifying any associated requests when complete.
 151 class QuicStreamFactory::Job {
 152  public:
 153   Job(QuicStreamFactory* factory,
 154       HostResolver* host_resolver,
 155       const HostPortPair& host_port_pair,
 156       bool is_https,
 157       bool was_alternate_protocol_recently_broken,
 158       PrivacyMode privacy_mode,
 159       base::StringPiece method,
 160       QuicServerInfo* server_info,
 161       const BoundNetLog& net_log);
 162
 163   // Creates a new job to handle the resumption of for connecting an
 164   // existing session.
 165   Job(QuicStreamFactory* factory,
 166       HostResolver* host_resolver,
 167       QuicClientSession* session,
 168       QuicServerId server_id);
 169
 170   ~Job();
 171
 172   int Run(const CompletionCallback& callback);
 173
 174   int DoLoop(int rv);
 175   int DoResolveHost();
 176   int DoResolveHostComplete(int rv);
 177   int DoLoadServerInfo();
 178   int DoLoadServerInfoComplete(int rv);
 179   int DoConnect();
 180   int DoResumeConnect();
 181   int DoConnectComplete(int rv);
 182
 183   void OnIOComplete(int rv);
 184
 185   CompletionCallback callback() {
 186     return callback_;
 187   }
 188
 189   const QuicServerId server_id() const {
 190     return server_id_;
 191   }
 192
 193  private:
 194   enum IoState {
 195     STATE_NONE,
 196     STATE_RESOLVE_HOST,
 197     STATE_RESOLVE_HOST_COMPLETE,
 198     STATE_LOAD_SERVER_INFO,
 199     STATE_LOAD_SERVER_INFO_COMPLETE,
 200     STATE_CONNECT,
 201     STATE_RESUME_CONNECT,
 202     STATE_CONNECT_COMPLETE,
 203   };
 204   IoState io_state_;
 205
 206   QuicStreamFactory* factory_;
 207   SingleRequestHostResolver host_resolver_;
 208   QuicServerId server_id_;
 209   bool is_post_;
 210   bool was_alternate_protocol_recently_broken_;
 211   scoped_ptr<QuicServerInfo> server_info_;
 212   const BoundNetLog net_log_;
 213   QuicClientSession* session_;
 214   CompletionCallback callback_;
 215   AddressList address_list_;
 216   base::TimeTicks disk_cache_load_start_time_;
 217   base::TimeTicks dns_resolution_start_time_;
 218   base::WeakPtrFactory<Job> weak_factory_;
 219   DISALLOW_COPY_AND_ASSIGN(Job);
 220 };
 221
 222 QuicStreamFactory::Job::Job(QuicStreamFactory* factory,
 223                             HostResolver* host_resolver,
 224                             const HostPortPair& host_port_pair,
 225                             bool is_https,
 226                             bool was_alternate_protocol_recently_broken,
 227                             PrivacyMode privacy_mode,
 228                             base::StringPiece method,
 229                             QuicServerInfo* server_info,
 230                             const BoundNetLog& net_log)
 231     : io_state_(STATE_RESOLVE_HOST),
 232       factory_(factory),
 233       host_resolver_(host_resolver),
 234       server_id_(host_port_pair, is_https, privacy_mode),
 235       is_post_(method == "POST"),
 236       was_alternate_protocol_recently_broken_(
 237           was_alternate_protocol_recently_broken),
 238       server_info_(server_info),
 239       net_log_(net_log),
 240       session_(NULL),
 241       weak_factory_(this) {}
 242
 243 QuicStreamFactory::Job::Job(QuicStreamFactory* factory,
 244                             HostResolver* host_resolver,
 245                             QuicClientSession* session,
 246                             QuicServerId server_id)
 247     : io_state_(STATE_RESUME_CONNECT),
 248       factory_(factory),
 249       host_resolver_(host_resolver),  // unused
 250       server_id_(server_id),
 251       is_post_(false),  // unused
 252       was_alternate_protocol_recently_broken_(false),  // unused
 253       net_log_(session->net_log()),  // unused
 254       session_(session),
 255       weak_factory_(this) {}
 256
 257 QuicStreamFactory::Job::~Job() {
 258 }
 259
 260 int QuicStreamFactory::Job::Run(const CompletionCallback& callback) {
 261   int rv = DoLoop(OK);
 262   if (rv == ERR_IO_PENDING)
 263     callback_ = callback;
 264
 265   return rv > 0 ? OK : rv;
 266 }
 267
 268 int QuicStreamFactory::Job::DoLoop(int rv) {
 269   do {
 270     IoState state = io_state_;
 271     io_state_ = STATE_NONE;
 272     switch (state) {
 273       case STATE_RESOLVE_HOST:
 274         CHECK_EQ(OK, rv);
 275         rv = DoResolveHost();
 276         break;
 277       case STATE_RESOLVE_HOST_COMPLETE:
 278         rv = DoResolveHostComplete(rv);
 279         break;
 280       case STATE_LOAD_SERVER_INFO:
 281         CHECK_EQ(OK, rv);
 282         rv = DoLoadServerInfo();
 283         break;
 284       case STATE_LOAD_SERVER_INFO_COMPLETE:
 285         rv = DoLoadServerInfoComplete(rv);
 286         break;
 287       case STATE_CONNECT:
 288         CHECK_EQ(OK, rv);
 289         rv = DoConnect();
 290         break;
 291       case STATE_RESUME_CONNECT:
 292         CHECK_EQ(OK, rv);
 293         rv = DoResumeConnect();
 294         break;
 295       case STATE_CONNECT_COMPLETE:
 296         rv = DoConnectComplete(rv);
 297         break;
 298       default:
 299         NOTREACHED() << "io_state_: " << io_state_;
 300         break;
 301     }
 302   } while (io_state_ != STATE_NONE && rv != ERR_IO_PENDING);
 303   return rv;
 304 }
 305
 306 void QuicStreamFactory::Job::OnIOComplete(int rv) {
 307   rv = DoLoop(rv);
 308
 309   if (rv != ERR_IO_PENDING && !callback_.is_null()) {
 310     callback_.Run(rv);
 311   }
 312 }
 313
 314 int QuicStreamFactory::Job::DoResolveHost() {
 315   // Start loading the data now, and wait for it after we resolve the host.
 316   if (server_info_) {
 317     disk_cache_load_start_time_ = base::TimeTicks::Now();
 318     server_info_->Start();
 319   }
 320
 321   io_state_ = STATE_RESOLVE_HOST_COMPLETE;
 322   dns_resolution_start_time_ = base::TimeTicks::Now();
 323   return host_resolver_.Resolve(
 324       HostResolver::RequestInfo(server_id_.host_port_pair()),
 325       DEFAULT_PRIORITY,
 326       &address_list_,
 327       base::Bind(&QuicStreamFactory::Job::OnIOComplete,
 328                  weak_factory_.GetWeakPtr()),
 329       net_log_);
 330 }
 331
 332 int QuicStreamFactory::Job::DoResolveHostComplete(int rv) {
 333   UMA_HISTOGRAM_TIMES("Net.QuicSession.HostResolutionTime",
 334                       base::TimeTicks::Now() - dns_resolution_start_time_);
 335   if (rv != OK)
 336     return rv;
 337
 338   DCHECK(!factory_->HasActiveSession(server_id_));
 339
 340   // Inform the factory of this resolution, which will set up
 341   // a session alias, if possible.
 342   if (factory_->OnResolution(server_id_, address_list_)) {
 343     return OK;
 344   }
 345
 346   io_state_ = STATE_LOAD_SERVER_INFO;
 347   return OK;
 348 }
 349
 350 int QuicStreamFactory::Job::DoLoadServerInfo() {
 351   io_state_ = STATE_LOAD_SERVER_INFO_COMPLETE;
 352
 353   if (!server_info_)
 354     return OK;
 355
 356   return server_info_->WaitForDataReady(
 357       base::Bind(&QuicStreamFactory::Job::OnIOComplete,
 358                  weak_factory_.GetWeakPtr()));
 359 }
 360
 361 int QuicStreamFactory::Job::DoLoadServerInfoComplete(int rv) {
 362   if (server_info_) {
 363     UMA_HISTOGRAM_TIMES("Net.QuicServerInfo.DiskCacheReadTime",
 364                         base::TimeTicks::Now() - disk_cache_load_start_time_);
 365   }
 366
 367   if (rv != OK) {
 368     server_info_.reset();
 369   }
 370
 371   io_state_ = STATE_CONNECT;
 372   return OK;
 373 }
 374
 375 int QuicStreamFactory::Job::DoConnect() {
 376   io_state_ = STATE_CONNECT_COMPLETE;
 377
 378   int rv = factory_->CreateSession(server_id_, server_info_.Pass(),
 379                                    address_list_, net_log_, &session_);
 380   if (rv != OK) {
 381     DCHECK(rv != ERR_IO_PENDING);
 382     DCHECK(!session_);
 383     return rv;
 384   }
 385
 386   if (!session_->connection()->connected()) {
 387     return ERR_CONNECTION_CLOSED;
 388   }
 389
 390   session_->StartReading();
 391   if (!session_->connection()->connected()) {
 392     return ERR_QUIC_PROTOCOL_ERROR;
 393   }
 394   bool require_confirmation =
 395       factory_->require_confirmation() || is_post_ ||
 396       was_alternate_protocol_recently_broken_;
 397   rv = session_->CryptoConnect(
 398       require_confirmation,
 399       base::Bind(&QuicStreamFactory::Job::OnIOComplete,
 400                  base::Unretained(this)));
 401   return rv;
 402 }
 403
 404 int QuicStreamFactory::Job::DoResumeConnect() {
 405   io_state_ = STATE_CONNECT_COMPLETE;
 406
 407   int rv = session_->ResumeCryptoConnect(
 408       base::Bind(&QuicStreamFactory::Job::OnIOComplete,
 409                  base::Unretained(this)));
 410
 411   return rv;
 412 }
 413
 414 int QuicStreamFactory::Job::DoConnectComplete(int rv) {
 415   if (rv != OK)
 416     return rv;
 417
 418   DCHECK(!factory_->HasActiveSession(server_id_));
 419   // There may well now be an active session for this IP.  If so, use the
 420   // existing session instead.
 421   AddressList address(session_->connection()->peer_address());
 422   if (factory_->OnResolution(server_id_, address)) {
 423     session_->connection()->SendConnectionClose(QUIC_CONNECTION_IP_POOLED);
 424     session_ = NULL;
 425     return OK;
 426   }
 427
 428   factory_->ActivateSession(server_id_, session_);
 429
 430   return OK;
 431 }
 432
 433 QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory)
 434     : factory_(factory) {}
 435
 436 QuicStreamRequest::~QuicStreamRequest() {
 437   if (factory_ && !callback_.is_null())
 438     factory_->CancelRequest(this);
 439 }
 440
 441 int QuicStreamRequest::Request(const HostPortPair& host_port_pair,
 442                                bool is_https,
 443                                PrivacyMode privacy_mode,
 444                                base::StringPiece method,
 445                                const BoundNetLog& net_log,
 446                                const CompletionCallback& callback) {
 447   DCHECK(!stream_);
 448   DCHECK(callback_.is_null());
 449   DCHECK(factory_);
 450   int rv = factory_->Create(host_port_pair, is_https, privacy_mode, method,
 451                             net_log, this);
 452   if (rv == ERR_IO_PENDING) {
 453     host_port_pair_ = host_port_pair;
 454     is_https_ = is_https;
 455     net_log_ = net_log;
 456     callback_ = callback;
 457   } else {
 458     factory_ = NULL;
 459   }
 460   if (rv == OK)
 461     DCHECK(stream_);
 462   return rv;
 463 }
 464
 465 void QuicStreamRequest::set_stream(scoped_ptr<QuicHttpStream> stream) {
 466   DCHECK(stream);
 467   stream_ = stream.Pass();
 468 }
 469
 470 void QuicStreamRequest::OnRequestComplete(int rv) {
 471   factory_ = NULL;
 472   callback_.Run(rv);
 473 }
 474
 475 scoped_ptr<QuicHttpStream> QuicStreamRequest::ReleaseStream() {
 476   DCHECK(stream_);
 477   return stream_.Pass();
 478 }
 479
 480 QuicStreamFactory::QuicStreamFactory(
 481     HostResolver* host_resolver,
 482     ClientSocketFactory* client_socket_factory,
 483     base::WeakPtr<HttpServerProperties> http_server_properties,
 484     CertVerifier* cert_verifier,
 485     ChannelIDService* channel_id_service,
 486     TransportSecurityState* transport_security_state,
 487     QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
 488     QuicRandom* random_generator,
 489     QuicClock* clock,
 490     size_t max_packet_length,
 491     const std::string& user_agent_id,
 492     const QuicVersionVector& supported_versions,
 493     bool enable_port_selection,
 494     bool enable_time_based_loss_detection,
 495     bool always_require_handshake_confirmation,
 496     bool disable_connection_pooling,
 497     const QuicTagVector& connection_options)
 498     : require_confirmation_(true),
 499       host_resolver_(host_resolver),
 500       client_socket_factory_(client_socket_factory),
 501       http_server_properties_(http_server_properties),
 502       transport_security_state_(transport_security_state),
 503       quic_server_info_factory_(NULL),
 504       quic_crypto_client_stream_factory_(quic_crypto_client_stream_factory),
 505       random_generator_(random_generator),
 506       clock_(clock),
 507       max_packet_length_(max_packet_length),
 508       config_(InitializeQuicConfig(enable_time_based_loss_detection,
 509                                    connection_options)),
 510       supported_versions_(supported_versions),
 511       enable_port_selection_(enable_port_selection),
 512       always_require_handshake_confirmation_(
 513           always_require_handshake_confirmation),
 514       disable_connection_pooling_(disable_connection_pooling),
 515       port_seed_(random_generator_->RandUint64()),
 516       check_persisted_supports_quic_(true),
 517       weak_factory_(this) {
 518   DCHECK(transport_security_state_);
 519   crypto_config_.SetDefaults();
 520   crypto_config_.set_user_agent_id(user_agent_id);
 521   crypto_config_.AddCanonicalSuffix(".c.youtube.com");
 522   crypto_config_.AddCanonicalSuffix(".googlevideo.com");
 523   crypto_config_.SetProofVerifier(
 524       new ProofVerifierChromium(cert_verifier, transport_security_state));
 525   crypto_config_.SetChannelIDSource(
 526       new ChannelIDSourceChromium(channel_id_service));
 527   base::CPU cpu;
 528   if (cpu.has_aesni() && cpu.has_avx())
 529     crypto_config_.PreferAesGcm();
 530   if (!IsEcdsaSupported())
 531     crypto_config_.DisableEcdsa();
 532 }
 533
 534 QuicStreamFactory::~QuicStreamFactory() {
 535   CloseAllSessions(ERR_ABORTED);
 536   while (!all_sessions_.empty()) {
 537     delete all_sessions_.begin()->first;
 538     all_sessions_.erase(all_sessions_.begin());
 539   }
 540   STLDeleteValues(&active_jobs_);
 541 }
 542
 543 void QuicStreamFactory::set_require_confirmation(bool require_confirmation) {
 544   require_confirmation_ = require_confirmation;
 545   if (http_server_properties_ && (!(local_address_ == IPEndPoint()))) {
 546     // TODO(rtenneti): Delete host_port_pair and persist data in globals.
 547     HostPortPair host_port_pair(kDummyHostname, kDummyPort);
 548     http_server_properties_->SetSupportsQuic(
 549         host_port_pair, !require_confirmation,
 550         local_address_.ToStringWithoutPort());
 551   }
 552 }
 553
 554 int QuicStreamFactory::Create(const HostPortPair& host_port_pair,
 555                               bool is_https,
 556                               PrivacyMode privacy_mode,
 557                               base::StringPiece method,
 558                               const BoundNetLog& net_log,
 559                               QuicStreamRequest* request) {
 560   QuicServerId server_id(host_port_pair, is_https, privacy_mode);
 561   if (HasActiveSession(server_id)) {
 562     request->set_stream(CreateIfSessionExists(server_id, net_log));
 563     return OK;
 564   }
 565
 566   if (HasActiveJob(server_id)) {
 567     Job* job = active_jobs_[server_id];
 568     active_requests_[request] = job;
 569     job_requests_map_[job].insert(request);
 570     return ERR_IO_PENDING;
 571   }
 572
 573   QuicServerInfo* quic_server_info = NULL;
 574   if (quic_server_info_factory_) {
 575     QuicCryptoClientConfig::CachedState* cached =
 576         crypto_config_.LookupOrCreate(server_id);
 577     DCHECK(cached);
 578     if (cached->IsEmpty()) {
 579       quic_server_info = quic_server_info_factory_->GetForServer(server_id);
 580     }
 581   }
 582   bool was_alternate_protocol_recently_broken =
 583       http_server_properties_ &&
 584       http_server_properties_->WasAlternateProtocolRecentlyBroken(
 585           server_id.host_port_pair());
 586   scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_pair, is_https,
 587                               was_alternate_protocol_recently_broken,
 588                               privacy_mode, method, quic_server_info, net_log));
 589   int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
 590                                base::Unretained(this), job.get()));
 591
 592   if (rv == ERR_IO_PENDING) {
 593     active_requests_[request] = job.get();
 594     job_requests_map_[job.get()].insert(request);
 595     active_jobs_[server_id] = job.release();
 596   }
 597   if (rv == OK) {
 598     DCHECK(HasActiveSession(server_id));
 599     request->set_stream(CreateIfSessionExists(server_id, net_log));
 600   }
 601   return rv;
 602 }
 603
 604 bool QuicStreamFactory::OnResolution(
 605     const QuicServerId& server_id,
 606     const AddressList& address_list) {
 607   DCHECK(!HasActiveSession(server_id));
 608   if (disable_connection_pooling_) {
 609     return false;
 610   }
 611   for (size_t i = 0; i < address_list.size(); ++i) {
 612     const IPEndPoint& address = address_list[i];
 613     const IpAliasKey ip_alias_key(address, server_id.is_https());
 614     if (!ContainsKey(ip_aliases_, ip_alias_key))
 615       continue;
 616
 617     const SessionSet& sessions = ip_aliases_[ip_alias_key];
 618     for (SessionSet::const_iterator i = sessions.begin();
 619          i != sessions.end(); ++i) {
 620       QuicClientSession* session = *i;
 621       if (!session->CanPool(server_id.host()))
 622         continue;
 623       active_sessions_[server_id] = session;
 624       session_aliases_[session].insert(server_id);
 625       return true;
 626     }
 627   }
 628   return false;
 629 }
 630
 631 void QuicStreamFactory::OnJobComplete(Job* job, int rv) {
 632   if (rv == OK) {
 633     if (!always_require_handshake_confirmation_)
 634       set_require_confirmation(false);
 635
 636     // Create all the streams, but do not notify them yet.
 637     for (RequestSet::iterator it = job_requests_map_[job].begin();
 638          it != job_requests_map_[job].end() ; ++it) {
 639       DCHECK(HasActiveSession(job->server_id()));
 640       (*it)->set_stream(CreateIfSessionExists(job->server_id(),
 641                                               (*it)->net_log()));
 642     }
 643   }
 644   while (!job_requests_map_[job].empty()) {
 645     RequestSet::iterator it = job_requests_map_[job].begin();
 646     QuicStreamRequest* request = *it;
 647     job_requests_map_[job].erase(it);
 648     active_requests_.erase(request);
 649     // Even though we're invoking callbacks here, we don't need to worry
 650     // about |this| being deleted, because the factory is owned by the
 651     // profile which can not be deleted via callbacks.
 652     request->OnRequestComplete(rv);
 653   }
 654   active_jobs_.erase(job->server_id());
 655   job_requests_map_.erase(job);
 656   delete job;
 657   return;
 658 }
 659
 660 // Returns a newly created QuicHttpStream owned by the caller, if a
 661 // matching session already exists.  Returns NULL otherwise.
 662 scoped_ptr<QuicHttpStream> QuicStreamFactory::CreateIfSessionExists(
 663     const QuicServerId& server_id,
 664     const BoundNetLog& net_log) {
 665   if (!HasActiveSession(server_id)) {
 666     DVLOG(1) << "No active session";
 667     return scoped_ptr<QuicHttpStream>();
 668   }
 669
 670   QuicClientSession* session = active_sessions_[server_id];
 671   DCHECK(session);
 672   return scoped_ptr<QuicHttpStream>(
 673       new QuicHttpStream(session->GetWeakPtr()));
 674 }
 675
 676 void QuicStreamFactory::OnIdleSession(QuicClientSession* session) {
 677 }
 678
 679 void QuicStreamFactory::OnSessionGoingAway(QuicClientSession* session) {
 680   const AliasSet& aliases = session_aliases_[session];
 681   for (AliasSet::const_iterator it = aliases.begin(); it != aliases.end();
 682        ++it) {
 683     DCHECK(active_sessions_.count(*it));
 684     DCHECK_EQ(session, active_sessions_[*it]);
 685     // Track sessions which have recently gone away so that we can disable
 686     // port suggestions.
 687     if (session->goaway_received()) {
 688       gone_away_aliases_.insert(*it);
 689     }
 690
 691     active_sessions_.erase(*it);
 692     ProcessGoingAwaySession(session, *it, true);
 693   }
 694   ProcessGoingAwaySession(session, all_sessions_[session], false);
 695   if (!aliases.empty()) {
 696     const IpAliasKey ip_alias_key(session->connection()->peer_address(),
 697                                   aliases.begin()->is_https());
 698     ip_aliases_[ip_alias_key].erase(session);
 699     if (ip_aliases_[ip_alias_key].empty()) {
 700       ip_aliases_.erase(ip_alias_key);
 701     }
 702   }
 703   session_aliases_.erase(session);
 704 }
 705
 706 void QuicStreamFactory::OnSessionClosed(QuicClientSession* session) {
 707   DCHECK_EQ(0u, session->GetNumOpenStreams());
 708   OnSessionGoingAway(session);
 709   delete session;
 710   all_sessions_.erase(session);
 711 }
 712
 713 void QuicStreamFactory::OnSessionConnectTimeout(
 714     QuicClientSession* session) {
 715   const AliasSet& aliases = session_aliases_[session];
 716   for (AliasSet::const_iterator it = aliases.begin(); it != aliases.end();
 717        ++it) {
 718     DCHECK(active_sessions_.count(*it));
 719     DCHECK_EQ(session, active_sessions_[*it]);
 720     active_sessions_.erase(*it);
 721   }
 722
 723   if (aliases.empty()) {
 724     return;
 725   }
 726
 727   const IpAliasKey ip_alias_key(session->connection()->peer_address(),
 728                                 aliases.begin()->is_https());
 729   ip_aliases_[ip_alias_key].erase(session);
 730   if (ip_aliases_[ip_alias_key].empty()) {
 731     ip_aliases_.erase(ip_alias_key);
 732   }
 733   QuicServerId server_id = *aliases.begin();
 734   session_aliases_.erase(session);
 735   Job* job = new Job(this, host_resolver_, session, server_id);
 736   active_jobs_[server_id] = job;
 737   int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
 738                                base::Unretained(this), job));
 739   DCHECK_EQ(ERR_IO_PENDING, rv);
 740 }
 741
 742 void QuicStreamFactory::CancelRequest(QuicStreamRequest* request) {
 743   DCHECK(ContainsKey(active_requests_, request));
 744   Job* job = active_requests_[request];
 745   job_requests_map_[job].erase(request);
 746   active_requests_.erase(request);
 747 }
 748
 749 void QuicStreamFactory::CloseAllSessions(int error) {
 750   while (!active_sessions_.empty()) {
 751     size_t initial_size = active_sessions_.size();
 752     active_sessions_.begin()->second->CloseSessionOnError(error);
 753     DCHECK_NE(initial_size, active_sessions_.size());
 754   }
 755   while (!all_sessions_.empty()) {
 756     size_t initial_size = all_sessions_.size();
 757     all_sessions_.begin()->first->CloseSessionOnError(error);
 758     DCHECK_NE(initial_size, all_sessions_.size());
 759   }
 760   DCHECK(all_sessions_.empty());
 761 }
 762
 763 base::Value* QuicStreamFactory::QuicStreamFactoryInfoToValue() const {
 764   base::ListValue* list = new base::ListValue();
 765
 766   for (SessionMap::const_iterator it = active_sessions_.begin();
 767        it != active_sessions_.end(); ++it) {
 768     const QuicServerId& server_id = it->first;
 769     QuicClientSession* session = it->second;
 770     const AliasSet& aliases = session_aliases_.find(session)->second;
 771     // Only add a session to the list once.
 772     if (server_id == *aliases.begin()) {
 773       std::set<HostPortPair> hosts;
 774       for (AliasSet::const_iterator alias_it = aliases.begin();
 775            alias_it != aliases.end(); ++alias_it) {
 776         hosts.insert(alias_it->host_port_pair());
 777       }
 778       list->Append(session->GetInfoAsValue(hosts));
 779     }
 780   }
 781   return list;
 782 }
 783
 784 void QuicStreamFactory::ClearCachedStatesInCryptoConfig() {
 785   crypto_config_.ClearCachedStates();
 786 }
 787
 788 void QuicStreamFactory::OnIPAddressChanged() {
 789   CloseAllSessions(ERR_NETWORK_CHANGED);
 790   set_require_confirmation(true);
 791 }
 792
 793 void QuicStreamFactory::OnCertAdded(const X509Certificate* cert) {
 794   CloseAllSessions(ERR_CERT_DATABASE_CHANGED);
 795 }
 796
 797 void QuicStreamFactory::OnCACertChanged(const X509Certificate* cert) {
 798   // We should flush the sessions if we removed trust from a
 799   // cert, because a previously trusted server may have become
 800   // untrusted.
 801   //
 802   // We should not flush the sessions if we added trust to a cert.
 803   //
 804   // Since the OnCACertChanged method doesn't tell us what
 805   // kind of change it is, we have to flush the socket
 806   // pools to be safe.
 807   CloseAllSessions(ERR_CERT_DATABASE_CHANGED);
 808 }
 809
 810 bool QuicStreamFactory::HasActiveSession(
 811     const QuicServerId& server_id) const {
 812   return ContainsKey(active_sessions_, server_id);
 813 }
 814
 815 int QuicStreamFactory::CreateSession(
 816     const QuicServerId& server_id,
 817     scoped_ptr<QuicServerInfo> server_info,
 818     const AddressList& address_list,
 819     const BoundNetLog& net_log,
 820     QuicClientSession** session) {
 821   bool enable_port_selection = enable_port_selection_;
 822   if (enable_port_selection &&
 823       ContainsKey(gone_away_aliases_, server_id)) {
 824     // Disable port selection when the server is going away.
 825     // There is no point in trying to return to the same server, if
 826     // that server is no longer handling requests.
 827     enable_port_selection = false;
 828     gone_away_aliases_.erase(server_id);
 829   }
 830
 831   QuicConnectionId connection_id = random_generator_->RandUint64();
 832   IPEndPoint addr = *address_list.begin();
 833   scoped_refptr<PortSuggester> port_suggester =
 834       new PortSuggester(server_id.host_port_pair(), port_seed_);
 835   DatagramSocket::BindType bind_type = enable_port_selection ?
 836       DatagramSocket::RANDOM_BIND :  // Use our callback.
 837       DatagramSocket::DEFAULT_BIND;  // Use OS to randomize.
 838   scoped_ptr<DatagramClientSocket> socket(
 839       client_socket_factory_->CreateDatagramClientSocket(
 840           bind_type,
 841           base::Bind(&PortSuggester::SuggestPort, port_suggester),
 842           net_log.net_log(), net_log.source()));
 843   int rv = socket->Connect(addr);
 844   if (rv != OK) {
 845     HistogramCreateSessionFailure(CREATION_ERROR_CONNECTING_SOCKET);
 846     return rv;
 847   }
 848   UMA_HISTOGRAM_COUNTS("Net.QuicEphemeralPortsSuggested",
 849                        port_suggester->call_count());
 850   if (enable_port_selection) {
 851     DCHECK_LE(1u, port_suggester->call_count());
 852   } else {
 853     DCHECK_EQ(0u, port_suggester->call_count());
 854   }
 855
 856   // We should adaptively set this buffer size, but for now, we'll use a size
 857   // that is more than large enough for a full receive window, and yet
 858   // does not consume "too much" memory.  If we see bursty packet loss, we may
 859   // revisit this setting and test for its impact.
 860   const int32 kSocketBufferSize(TcpReceiver::kReceiveWindowTCP);
 861   rv = socket->SetReceiveBufferSize(kSocketBufferSize);
 862   if (rv != OK) {
 863     HistogramCreateSessionFailure(CREATION_ERROR_SETTING_RECEIVE_BUFFER);
 864     return rv;
 865   }
 866   // Set a buffer large enough to contain the initial CWND's worth of packet
 867   // to work around the problem with CHLO packets being sent out with the
 868   // wrong encryption level, when the send buffer is full.
 869   rv = socket->SetSendBufferSize(kMaxPacketSize * 20);
 870   if (rv != OK) {
 871     HistogramCreateSessionFailure(CREATION_ERROR_SETTING_SEND_BUFFER);
 872     return rv;
 873   }
 874
 875   socket->GetLocalAddress(&local_address_);
 876   if (check_persisted_supports_quic_ && http_server_properties_) {
 877     check_persisted_supports_quic_ = false;
 878     // TODO(rtenneti): Delete host_port_pair and persist data in globals.
 879     HostPortPair host_port_pair(kDummyHostname, kDummyPort);
 880     SupportsQuic supports_quic(true, local_address_.ToStringWithoutPort());
 881     if (http_server_properties_->GetSupportsQuic(
 882             host_port_pair).Equals(supports_quic)) {
 883       require_confirmation_ = false;
 884     }
 885   }
 886
 887   DefaultPacketWriterFactory packet_writer_factory(socket.get());
 888
 889   if (!helper_.get()) {
 890     helper_.reset(new QuicConnectionHelper(
 891         base::MessageLoop::current()->message_loop_proxy().get(),
 892         clock_.get(), random_generator_));
 893   }
 894
 895   QuicConnection* connection = new QuicConnection(connection_id,
 896                                                   addr,
 897                                                   helper_.get(),
 898                                                   packet_writer_factory,
 899                                                   true  /* owns_writer */,
 900                                                   false  /* is_server */,
 901                                                   supported_versions_);
 902   connection->set_max_packet_length(max_packet_length_);
 903
 904   InitializeCachedStateInCryptoConfig(server_id, server_info);
 905
 906   QuicConfig config = config_;
 907   config.SetInitialCongestionWindowToSend(
 908       server_id.is_https() ? kServerSecureInitialCongestionWindow
 909                            : kServerInecureInitialCongestionWindow);
 910   config.SetInitialFlowControlWindowToSend(kInitialReceiveWindowSize);
 911   config.SetInitialStreamFlowControlWindowToSend(kInitialReceiveWindowSize);
 912   config.SetInitialSessionFlowControlWindowToSend(kInitialReceiveWindowSize);
 913   if (http_server_properties_) {
 914     const HttpServerProperties::NetworkStats* stats =
 915         http_server_properties_->GetServerNetworkStats(
 916             server_id.host_port_pair());
 917     if (stats != NULL) {
 918       config.SetInitialRoundTripTimeUsToSend(stats->srtt.InMicroseconds());
 919     }
 920   }
 921
 922   *session = new QuicClientSession(
 923       connection, socket.Pass(), this, transport_security_state_,
 924       server_info.Pass(), config,
 925       base::MessageLoop::current()->message_loop_proxy().get(),
 926       net_log.net_log());
 927   all_sessions_[*session] = server_id;  // owning pointer
 928   (*session)->InitializeSession(server_id,  &crypto_config_,
 929                                 quic_crypto_client_stream_factory_);
 930   bool closed_during_initialize =
 931       !ContainsKey(all_sessions_, *session) ||
 932       !(*session)->connection()->connected();
 933   UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ClosedDuringInitializeSession",
 934                         closed_during_initialize);
 935   if (closed_during_initialize) {
 936     DLOG(DFATAL) << "Session closed during initialize";
 937     *session = NULL;
 938     return ERR_CONNECTION_CLOSED;
 939   }
 940   return OK;
 941 }
 942
 943 bool QuicStreamFactory::HasActiveJob(const QuicServerId& key) const {
 944   return ContainsKey(active_jobs_, key);
 945 }
 946
 947 void QuicStreamFactory::ActivateSession(
 948     const QuicServerId& server_id,
 949     QuicClientSession* session) {
 950   DCHECK(!HasActiveSession(server_id));
 951   UMA_HISTOGRAM_COUNTS("Net.QuicActiveSessions", active_sessions_.size());
 952   active_sessions_[server_id] = session;
 953   session_aliases_[session].insert(server_id);
 954   const IpAliasKey ip_alias_key(session->connection()->peer_address(),
 955                                 server_id.is_https());
 956   DCHECK(!ContainsKey(ip_aliases_[ip_alias_key], session));
 957   ip_aliases_[ip_alias_key].insert(session);
 958 }
 959
 960 void QuicStreamFactory::InitializeCachedStateInCryptoConfig(
 961     const QuicServerId& server_id,
 962     const scoped_ptr<QuicServerInfo>& server_info) {
 963   if (!server_info)
 964     return;
 965
 966   QuicCryptoClientConfig::CachedState* cached =
 967       crypto_config_.LookupOrCreate(server_id);
 968   if (!cached->IsEmpty())
 969     return;
 970
 971   if (!cached->Initialize(server_info->state().server_config,
 972                           server_info->state().source_address_token,
 973                           server_info->state().certs,
 974                           server_info->state().server_config_sig,
 975                           clock_->WallNow()))
 976     return;
 977
 978   if (!server_id.is_https()) {
 979     // Don't check the certificates for insecure QUIC.
 980     cached->SetProofValid();
 981   }
 982 }
 983
 984 void QuicStreamFactory::ProcessGoingAwaySession(
 985     QuicClientSession* session,
 986     const QuicServerId& server_id,
 987     bool session_was_active) {
 988   if (!http_server_properties_)
 989     return;
 990
 991   const QuicConnectionStats& stats = session->connection()->GetStats();
 992   if (session->IsCryptoHandshakeConfirmed()) {
 993     HttpServerProperties::NetworkStats network_stats;
 994     network_stats.srtt = base::TimeDelta::FromMicroseconds(stats.srtt_us);
 995     network_stats.bandwidth_estimate = stats.estimated_bandwidth;
 996     http_server_properties_->SetServerNetworkStats(server_id.host_port_pair(),
 997                                                    network_stats);
 998     return;
 999   }
1000
1001   UMA_HISTOGRAM_COUNTS("Net.QuicHandshakeNotConfirmedNumPacketsReceived",
1002                        stats.packets_received);
1003
1004   if (!session_was_active)
1005     return;
1006
1007   const HostPortPair& server = server_id.host_port_pair();
1008   // Don't try to change the alternate-protocol state, if the
1009   // alternate-protocol state is unknown.
1010   if (!http_server_properties_->HasAlternateProtocol(server))
1011     return;
1012
1013   // TODO(rch):  In the special case where the session has received no
1014   // packets from the peer, we should consider blacklisting this
1015   // differently so that we still race TCP but we don't consider the
1016   // session connected until the handshake has been confirmed.
1017   HistogramBrokenAlternateProtocolLocation(
1018       BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY);
1019   AlternateProtocolInfo alternate =
1020       http_server_properties_->GetAlternateProtocol(server);
1021   DCHECK_EQ(QUIC, alternate.protocol);
1022
1023   // Since the session was active, there's no longer an
1024   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the
1025   // TCP job also fails. So to avoid not using QUIC when we otherwise could,
1026   // we mark it as broken, and then immediately re-enable it. This leaves
1027   // QUIC as "recently broken" which means that 0-RTT will be disabled but
1028   // we'll still race.
1029   http_server_properties_->SetBrokenAlternateProtocol(server);
1030   http_server_properties_->ClearAlternateProtocol(server);
1031   http_server_properties_->SetAlternateProtocol(
1032       server, alternate.port, alternate.protocol, 1);
1033   DCHECK_EQ(QUIC,
1034             http_server_properties_->GetAlternateProtocol(server).protocol);
1035   DCHECK(http_server_properties_->WasAlternateProtocolRecentlyBroken(
1036       server));
1037 }
1038
1039 }  // namespace net