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