src/net/quic/quic_client_session.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_client_session.h"
   6
   7 #include "base/callback_helpers.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/metrics/sparse_histogram.h"
  11 #include "base/stl_util.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/values.h"
  14 #include "net/base/io_buffer.h"
  15 #include "net/base/net_errors.h"
  16 #include "net/quic/crypto/proof_verifier_chromium.h"
  17 #include "net/quic/crypto/quic_server_info.h"
  18 #include "net/quic/quic_connection_helper.h"
  19 #include "net/quic/quic_crypto_client_stream_factory.h"
  20 #include "net/quic/quic_default_packet_writer.h"
  21 #include "net/quic/quic_server_id.h"
  22 #include "net/quic/quic_stream_factory.h"
  23 #include "net/ssl/ssl_connection_status_flags.h"
  24 #include "net/ssl/ssl_info.h"
  25 #include "net/udp/datagram_client_socket.h"
  26
  27 namespace net {
  28
  29 namespace {
  30
  31 // The length of time to wait for a 0-RTT handshake to complete
  32 // before allowing the requests to possibly proceed over TCP.
  33 const int k0RttHandshakeTimeoutMs = 300;
  34
  35 // Histograms for tracking down the crashes from http://crbug.com/354669
  36 // Note: these values must be kept in sync with the corresponding values in:
  37 // tools/metrics/histograms/histograms.xml
  38 enum Location {
  39   DESTRUCTOR = 0,
  40   ADD_OBSERVER = 1,
  41   TRY_CREATE_STREAM = 2,
  42   CREATE_OUTGOING_RELIABLE_STREAM = 3,
  43   NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER = 4,
  44   NOTIFY_FACTORY_OF_SESSION_CLOSED = 5,
  45   NUM_LOCATIONS = 6,
  46 };
  47
  48 void RecordUnexpectedOpenStreams(Location location) {
  49   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.UnexpectedOpenStreams", location,
  50                             NUM_LOCATIONS);
  51 }
  52
  53 void RecordUnexpectedObservers(Location location) {
  54   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.UnexpectedObservers", location,
  55                             NUM_LOCATIONS);
  56 }
  57
  58 void RecordUnexpectedNotGoingAway(Location location) {
  59   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.UnexpectedNotGoingAway", location,
  60                             NUM_LOCATIONS);
  61 }
  62
  63 // Histogram for recording the different reasons that a QUIC session is unable
  64 // to complete the handshake.
  65 enum HandshakeFailureReason {
  66   HANDSHAKE_FAILURE_UNKNOWN = 0,
  67   HANDSHAKE_FAILURE_BLACK_HOLE = 1,
  68   HANDSHAKE_FAILURE_PUBLIC_RESET = 2,
  69   NUM_HANDSHAKE_FAILURE_REASONS = 3,
  70 };
  71
  72 void RecordHandshakeFailureReason(HandshakeFailureReason reason) {
  73   UMA_HISTOGRAM_ENUMERATION(
  74       "Net.QuicSession.ConnectionClose.HandshakeNotConfirmed.Reason",
  75       reason, NUM_HANDSHAKE_FAILURE_REASONS);
  76 }
  77
  78 // Note: these values must be kept in sync with the corresponding values in:
  79 // tools/metrics/histograms/histograms.xml
  80 enum HandshakeState {
  81   STATE_STARTED = 0,
  82   STATE_ENCRYPTION_ESTABLISHED = 1,
  83   STATE_HANDSHAKE_CONFIRMED = 2,
  84   STATE_FAILED = 3,
  85   NUM_HANDSHAKE_STATES = 4
  86 };
  87
  88 void RecordHandshakeState(HandshakeState state) {
  89   UMA_HISTOGRAM_ENUMERATION("Net.QuicHandshakeState", state,
  90                             NUM_HANDSHAKE_STATES);
  91 }
  92
  93 }  // namespace
  94
  95 QuicClientSession::StreamRequest::StreamRequest() : stream_(NULL) {}
  96
  97 QuicClientSession::StreamRequest::~StreamRequest() {
  98   CancelRequest();
  99 }
 100
 101 int QuicClientSession::StreamRequest::StartRequest(
 102     const base::WeakPtr<QuicClientSession>& session,
 103     QuicReliableClientStream** stream,
 104     const CompletionCallback& callback) {
 105   session_ = session;
 106   stream_ = stream;
 107   int rv = session_->TryCreateStream(this, stream_);
 108   if (rv == ERR_IO_PENDING) {
 109     callback_ = callback;
 110   }
 111
 112   return rv;
 113 }
 114
 115 void QuicClientSession::StreamRequest::CancelRequest() {
 116   if (session_)
 117     session_->CancelRequest(this);
 118   session_.reset();
 119   callback_.Reset();
 120 }
 121
 122 void QuicClientSession::StreamRequest::OnRequestCompleteSuccess(
 123     QuicReliableClientStream* stream) {
 124   session_.reset();
 125   *stream_ = stream;
 126   ResetAndReturn(&callback_).Run(OK);
 127 }
 128
 129 void QuicClientSession::StreamRequest::OnRequestCompleteFailure(int rv) {
 130   session_.reset();
 131   ResetAndReturn(&callback_).Run(rv);
 132 }
 133
 134 QuicClientSession::QuicClientSession(
 135     QuicConnection* connection,
 136     scoped_ptr<DatagramClientSocket> socket,
 137     scoped_ptr<QuicDefaultPacketWriter> writer,
 138     QuicStreamFactory* stream_factory,
 139     QuicCryptoClientStreamFactory* crypto_client_stream_factory,
 140     scoped_ptr<QuicServerInfo> server_info,
 141     const QuicServerId& server_id,
 142     const QuicConfig& config,
 143     QuicCryptoClientConfig* crypto_config,
 144     base::TaskRunner* task_runner,
 145     NetLog* net_log)
 146     : QuicClientSessionBase(connection,
 147                             config),
 148       require_confirmation_(false),
 149       stream_factory_(stream_factory),
 150       socket_(socket.Pass()),
 151       writer_(writer.Pass()),
 152       read_buffer_(new IOBufferWithSize(kMaxPacketSize)),
 153       server_info_(server_info.Pass()),
 154       read_pending_(false),
 155       num_total_streams_(0),
 156       task_runner_(task_runner),
 157       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
 158       logger_(net_log_),
 159       num_packets_read_(0),
 160       going_away_(false),
 161       weak_factory_(this) {
 162   crypto_stream_.reset(
 163       crypto_client_stream_factory ?
 164           crypto_client_stream_factory->CreateQuicCryptoClientStream(
 165               server_id, this, crypto_config) :
 166           new QuicCryptoClientStream(server_id, this,
 167                                      new ProofVerifyContextChromium(net_log_),
 168                                      crypto_config));
 169
 170   connection->set_debug_visitor(&logger_);
 171   // TODO(rch): pass in full host port proxy pair
 172   net_log_.BeginEvent(
 173       NetLog::TYPE_QUIC_SESSION,
 174       NetLog::StringCallback("host", &server_id.host()));
 175 }
 176
 177 QuicClientSession::~QuicClientSession() {
 178   if (!streams()->empty())
 179     RecordUnexpectedOpenStreams(DESTRUCTOR);
 180   if (!observers_.empty())
 181     RecordUnexpectedObservers(DESTRUCTOR);
 182   if (!going_away_)
 183     RecordUnexpectedNotGoingAway(DESTRUCTOR);
 184
 185   while (!streams()->empty() ||
 186          !observers_.empty() ||
 187          !stream_requests_.empty()) {
 188     // The session must be closed before it is destroyed.
 189     DCHECK(streams()->empty());
 190     CloseAllStreams(ERR_UNEXPECTED);
 191     DCHECK(observers_.empty());
 192     CloseAllObservers(ERR_UNEXPECTED);
 193
 194     connection()->set_debug_visitor(NULL);
 195     net_log_.EndEvent(NetLog::TYPE_QUIC_SESSION);
 196
 197     while (!stream_requests_.empty()) {
 198       StreamRequest* request = stream_requests_.front();
 199       stream_requests_.pop_front();
 200       request->OnRequestCompleteFailure(ERR_ABORTED);
 201     }
 202   }
 203
 204   if (connection()->connected()) {
 205     // Ensure that the connection is closed by the time the session is
 206     // destroyed.
 207     connection()->CloseConnection(QUIC_INTERNAL_ERROR, false);
 208   }
 209
 210   if (IsEncryptionEstablished())
 211     RecordHandshakeState(STATE_ENCRYPTION_ESTABLISHED);
 212   if (IsCryptoHandshakeConfirmed())
 213     RecordHandshakeState(STATE_HANDSHAKE_CONFIRMED);
 214   else
 215     RecordHandshakeState(STATE_FAILED);
 216
 217   UMA_HISTOGRAM_COUNTS("Net.QuicSession.NumTotalStreams", num_total_streams_);
 218   UMA_HISTOGRAM_COUNTS("Net.QuicNumSentClientHellos",
 219                        crypto_stream_->num_sent_client_hellos());
 220   if (!IsCryptoHandshakeConfirmed())
 221     return;
 222
 223   // Sending one client_hello means we had zero handshake-round-trips.
 224   int round_trip_handshakes = crypto_stream_->num_sent_client_hellos() - 1;
 225
 226   // Don't bother with these histogram during tests, which mock out
 227   // num_sent_client_hellos().
 228   if (round_trip_handshakes < 0 || !stream_factory_)
 229     return;
 230
 231   bool port_selected = stream_factory_->enable_port_selection();
 232   SSLInfo ssl_info;
 233   if (!GetSSLInfo(&ssl_info) || !ssl_info.cert) {
 234     if (port_selected) {
 235       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.ConnectSelectPortForHTTP",
 236                                   round_trip_handshakes, 0, 3, 4);
 237     } else {
 238       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.ConnectRandomPortForHTTP",
 239                                   round_trip_handshakes, 0, 3, 4);
 240     }
 241   } else {
 242     if (port_selected) {
 243       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.ConnectSelectPortForHTTPS",
 244                                   round_trip_handshakes, 0, 3, 4);
 245     } else {
 246       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.ConnectRandomPortForHTTPS",
 247                                   round_trip_handshakes, 0, 3, 4);
 248     }
 249   }
 250   const QuicConnectionStats stats = connection()->GetStats();
 251   if (stats.max_sequence_reordering == 0)
 252     return;
 253   const uint64 kMaxReordering = 100;
 254   uint64 reordering = kMaxReordering;
 255   if (stats.min_rtt_us > 0 ) {
 256     reordering =
 257         GG_UINT64_C(100) * stats.max_time_reordering_us / stats.min_rtt_us;
 258   }
 259   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.MaxReorderingTime",
 260                                 reordering, 0, kMaxReordering, 50);
 261   if (stats.min_rtt_us > 100 * 1000) {
 262     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.MaxReorderingTimeLongRtt",
 263                                 reordering, 0, kMaxReordering, 50);
 264   }
 265   UMA_HISTOGRAM_COUNTS("Net.QuicSession.MaxReordering",
 266                        stats.max_sequence_reordering);
 267 }
 268
 269 void QuicClientSession::OnStreamFrames(
 270     const std::vector<QuicStreamFrame>& frames) {
 271   // Record total number of stream frames.
 272   UMA_HISTOGRAM_COUNTS("Net.QuicNumStreamFramesInPacket", frames.size());
 273
 274   // Record number of frames per stream in packet.
 275   typedef std::map<QuicStreamId, size_t> FrameCounter;
 276   FrameCounter frames_per_stream;
 277   for (size_t i = 0; i < frames.size(); ++i) {
 278     frames_per_stream[frames[i].stream_id]++;
 279   }
 280   for (FrameCounter::const_iterator it = frames_per_stream.begin();
 281        it != frames_per_stream.end(); ++it) {
 282     UMA_HISTOGRAM_COUNTS("Net.QuicNumStreamFramesPerStreamInPacket",
 283                          it->second);
 284   }
 285
 286   return QuicSession::OnStreamFrames(frames);
 287 }
 288
 289 void QuicClientSession::AddObserver(Observer* observer) {
 290   if (going_away_) {
 291     RecordUnexpectedObservers(ADD_OBSERVER);
 292     observer->OnSessionClosed(ERR_UNEXPECTED);
 293     return;
 294   }
 295
 296   DCHECK(!ContainsKey(observers_, observer));
 297   observers_.insert(observer);
 298 }
 299
 300 void QuicClientSession::RemoveObserver(Observer* observer) {
 301   DCHECK(ContainsKey(observers_, observer));
 302   observers_.erase(observer);
 303 }
 304
 305 int QuicClientSession::TryCreateStream(StreamRequest* request,
 306                                        QuicReliableClientStream** stream) {
 307   if (!crypto_stream_->encryption_established()) {
 308     DLOG(DFATAL) << "Encryption not established.";
 309     return ERR_CONNECTION_CLOSED;
 310   }
 311
 312   if (goaway_received()) {
 313     DVLOG(1) << "Going away.";
 314     return ERR_CONNECTION_CLOSED;
 315   }
 316
 317   if (!connection()->connected()) {
 318     DVLOG(1) << "Already closed.";
 319     return ERR_CONNECTION_CLOSED;
 320   }
 321
 322   if (going_away_) {
 323     RecordUnexpectedOpenStreams(TRY_CREATE_STREAM);
 324     return ERR_CONNECTION_CLOSED;
 325   }
 326
 327   if (GetNumOpenStreams() < get_max_open_streams()) {
 328     *stream = CreateOutgoingReliableStreamImpl();
 329     return OK;
 330   }
 331
 332   stream_requests_.push_back(request);
 333   return ERR_IO_PENDING;
 334 }
 335
 336 void QuicClientSession::CancelRequest(StreamRequest* request) {
 337   // Remove |request| from the queue while preserving the order of the
 338   // other elements.
 339   StreamRequestQueue::iterator it =
 340       std::find(stream_requests_.begin(), stream_requests_.end(), request);
 341   if (it != stream_requests_.end()) {
 342     it = stream_requests_.erase(it);
 343   }
 344 }
 345
 346 QuicReliableClientStream* QuicClientSession::CreateOutgoingDataStream() {
 347   if (!crypto_stream_->encryption_established()) {
 348     DVLOG(1) << "Encryption not active so no outgoing stream created.";
 349     return NULL;
 350   }
 351   if (GetNumOpenStreams() >= get_max_open_streams()) {
 352     DVLOG(1) << "Failed to create a new outgoing stream. "
 353              << "Already " << GetNumOpenStreams() << " open.";
 354     return NULL;
 355   }
 356   if (goaway_received()) {
 357     DVLOG(1) << "Failed to create a new outgoing stream. "
 358              << "Already received goaway.";
 359     return NULL;
 360   }
 361   if (going_away_) {
 362     RecordUnexpectedOpenStreams(CREATE_OUTGOING_RELIABLE_STREAM);
 363     return NULL;
 364   }
 365   return CreateOutgoingReliableStreamImpl();
 366 }
 367
 368 QuicReliableClientStream*
 369 QuicClientSession::CreateOutgoingReliableStreamImpl() {
 370   DCHECK(connection()->connected());
 371   QuicReliableClientStream* stream =
 372       new QuicReliableClientStream(GetNextStreamId(), this, net_log_);
 373   ActivateStream(stream);
 374   ++num_total_streams_;
 375   UMA_HISTOGRAM_COUNTS("Net.QuicSession.NumOpenStreams", GetNumOpenStreams());
 376   return stream;
 377 }
 378
 379 QuicCryptoClientStream* QuicClientSession::GetCryptoStream() {
 380   return crypto_stream_.get();
 381 };
 382
 383 // TODO(rtenneti): Add unittests for GetSSLInfo which exercise the various ways
 384 // we learn about SSL info (sync vs async vs cached).
 385 bool QuicClientSession::GetSSLInfo(SSLInfo* ssl_info) const {
 386   ssl_info->Reset();
 387   if (!cert_verify_result_) {
 388     return false;
 389   }
 390
 391   ssl_info->cert_status = cert_verify_result_->cert_status;
 392   ssl_info->cert = cert_verify_result_->verified_cert;
 393
 394   // TODO(wtc): Define QUIC "cipher suites".
 395   // Report the TLS cipher suite that most closely resembles the crypto
 396   // parameters of the QUIC connection.
 397   QuicTag aead = crypto_stream_->crypto_negotiated_params().aead;
 398   int cipher_suite;
 399   int security_bits;
 400   switch (aead) {
 401     case kAESG:
 402       cipher_suite = 0xc02f;  // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
 403       security_bits = 128;
 404       break;
 405     case kCC12:
 406       cipher_suite = 0xcc13;  // TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
 407       security_bits = 256;
 408       break;
 409     default:
 410       NOTREACHED();
 411       return false;
 412   }
 413   int ssl_connection_status = 0;
 414   ssl_connection_status |=
 415       (cipher_suite & SSL_CONNECTION_CIPHERSUITE_MASK) <<
 416        SSL_CONNECTION_CIPHERSUITE_SHIFT;
 417   ssl_connection_status |=
 418       (SSL_CONNECTION_VERSION_QUIC & SSL_CONNECTION_VERSION_MASK) <<
 419        SSL_CONNECTION_VERSION_SHIFT;
 420
 421   ssl_info->public_key_hashes = cert_verify_result_->public_key_hashes;
 422   ssl_info->is_issued_by_known_root =
 423       cert_verify_result_->is_issued_by_known_root;
 424
 425   ssl_info->connection_status = ssl_connection_status;
 426   ssl_info->client_cert_sent = false;
 427   ssl_info->channel_id_sent = false;
 428   ssl_info->security_bits = security_bits;
 429   ssl_info->handshake_type = SSLInfo::HANDSHAKE_FULL;
 430   ssl_info->pinning_failure_log = pinning_failure_log_;
 431   return true;
 432 }
 433
 434 int QuicClientSession::CryptoConnect(bool require_confirmation,
 435                                      const CompletionCallback& callback) {
 436   require_confirmation_ = require_confirmation;
 437   handshake_start_ = base::TimeTicks::Now();
 438   RecordHandshakeState(STATE_STARTED);
 439   if (!crypto_stream_->CryptoConnect()) {
 440     // TODO(wtc): change crypto_stream_.CryptoConnect() to return a
 441     // QuicErrorCode and map it to a net error code.
 442     return ERR_CONNECTION_FAILED;
 443   }
 444
 445   if (IsCryptoHandshakeConfirmed())
 446     return OK;
 447
 448   // Unless we require handshake confirmation, activate the session if
 449   // we have established initial encryption.
 450   if (!require_confirmation_ && IsEncryptionEstablished()) {
 451     // To mitigate the effects of hanging 0-RTT connections, set up a timer to
 452     // cancel any requests, if the handshake takes too long.
 453     task_runner_->PostDelayedTask(
 454         FROM_HERE,
 455         base::Bind(&QuicClientSession::OnConnectTimeout,
 456                    weak_factory_.GetWeakPtr()),
 457         base::TimeDelta::FromMilliseconds(k0RttHandshakeTimeoutMs));
 458     return OK;
 459
 460   }
 461
 462   callback_ = callback;
 463   return ERR_IO_PENDING;
 464 }
 465
 466 int QuicClientSession::ResumeCryptoConnect(const CompletionCallback& callback) {
 467
 468   if (IsCryptoHandshakeConfirmed())
 469     return OK;
 470
 471   if (!connection()->connected())
 472     return ERR_QUIC_HANDSHAKE_FAILED;
 473
 474   callback_ = callback;
 475   return ERR_IO_PENDING;
 476 }
 477
 478 int QuicClientSession::GetNumSentClientHellos() const {
 479   return crypto_stream_->num_sent_client_hellos();
 480 }
 481
 482 bool QuicClientSession::CanPool(const std::string& hostname) const {
 483   // TODO(rch): When QUIC supports channel ID or client certificates, this
 484   // logic will need to be revised.
 485   DCHECK(connection()->connected());
 486   SSLInfo ssl_info;
 487   if (!GetSSLInfo(&ssl_info) || !ssl_info.cert) {
 488     // We can always pool with insecure QUIC sessions.
 489     return true;
 490   }
 491
 492   // Disable pooling for secure sessions.
 493   // TODO(rch): re-enable this.
 494   return false;
 495
 496 #if 0
 497   bool unused = false;
 498   // Only pool secure QUIC sessions if the cert matches the new hostname.
 499   return ssl_info.cert->VerifyNameMatch(hostname, &unused);
 500 #endif
 501 }
 502
 503 QuicDataStream* QuicClientSession::CreateIncomingDataStream(
 504     QuicStreamId id) {
 505   DLOG(ERROR) << "Server push not supported";
 506   return NULL;
 507 }
 508
 509 void QuicClientSession::CloseStream(QuicStreamId stream_id) {
 510   ReliableQuicStream* stream = GetStream(stream_id);
 511   if (stream) {
 512     logger_.UpdateReceivedFrameCounts(
 513         stream_id, stream->num_frames_received(),
 514         stream->num_duplicate_frames_received());
 515   }
 516   QuicSession::CloseStream(stream_id);
 517   OnClosedStream();
 518 }
 519
 520 void QuicClientSession::SendRstStream(QuicStreamId id,
 521                                       QuicRstStreamErrorCode error,
 522                                       QuicStreamOffset bytes_written) {
 523   QuicSession::SendRstStream(id, error, bytes_written);
 524   OnClosedStream();
 525 }
 526
 527 void QuicClientSession::OnClosedStream() {
 528   if (GetNumOpenStreams() < get_max_open_streams() &&
 529       !stream_requests_.empty() &&
 530       crypto_stream_->encryption_established() &&
 531       !goaway_received() &&
 532       !going_away_ &&
 533       connection()->connected()) {
 534     StreamRequest* request = stream_requests_.front();
 535     stream_requests_.pop_front();
 536     request->OnRequestCompleteSuccess(CreateOutgoingReliableStreamImpl());
 537   }
 538
 539   if (GetNumOpenStreams() == 0) {
 540     stream_factory_->OnIdleSession(this);
 541   }
 542 }
 543
 544 void QuicClientSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
 545   if (!callback_.is_null() &&
 546       (!require_confirmation_ || event == HANDSHAKE_CONFIRMED)) {
 547     // TODO(rtenneti): Currently for all CryptoHandshakeEvent events, callback_
 548     // could be called because there are no error events in CryptoHandshakeEvent
 549     // enum. If error events are added to CryptoHandshakeEvent, then the
 550     // following code needs to changed.
 551     base::ResetAndReturn(&callback_).Run(OK);
 552   }
 553   if (event == HANDSHAKE_CONFIRMED) {
 554     UMA_HISTOGRAM_TIMES("Net.QuicSession.HandshakeConfirmedTime",
 555                         base::TimeTicks::Now() - handshake_start_);
 556     ObserverSet::iterator it = observers_.begin();
 557     while (it != observers_.end()) {
 558       Observer* observer = *it;
 559       ++it;
 560       observer->OnCryptoHandshakeConfirmed();
 561     }
 562   }
 563   QuicSession::OnCryptoHandshakeEvent(event);
 564 }
 565
 566 void QuicClientSession::OnCryptoHandshakeMessageSent(
 567     const CryptoHandshakeMessage& message) {
 568   logger_.OnCryptoHandshakeMessageSent(message);
 569 }
 570
 571 void QuicClientSession::OnCryptoHandshakeMessageReceived(
 572     const CryptoHandshakeMessage& message) {
 573   logger_.OnCryptoHandshakeMessageReceived(message);
 574 }
 575
 576 void QuicClientSession::OnConnectionClosed(QuicErrorCode error,
 577                                            bool from_peer) {
 578   DCHECK(!connection()->connected());
 579   logger_.OnConnectionClosed(error, from_peer);
 580   if (from_peer) {
 581     UMA_HISTOGRAM_SPARSE_SLOWLY(
 582         "Net.QuicSession.ConnectionCloseErrorCodeServer", error);
 583   } else {
 584     UMA_HISTOGRAM_SPARSE_SLOWLY(
 585         "Net.QuicSession.ConnectionCloseErrorCodeClient", error);
 586   }
 587
 588   if (error == QUIC_CONNECTION_TIMED_OUT) {
 589     UMA_HISTOGRAM_COUNTS(
 590         "Net.QuicSession.ConnectionClose.NumOpenStreams.TimedOut",
 591         GetNumOpenStreams());
 592     if (!IsCryptoHandshakeConfirmed()) {
 593       UMA_HISTOGRAM_COUNTS(
 594           "Net.QuicSession.ConnectionClose.NumOpenStreams.HandshakeTimedOut",
 595           GetNumOpenStreams());
 596       UMA_HISTOGRAM_COUNTS(
 597           "Net.QuicSession.ConnectionClose.NumTotalStreams.HandshakeTimedOut",
 598           num_total_streams_);
 599     }
 600   }
 601
 602   if (!IsCryptoHandshakeConfirmed()) {
 603     if (error == QUIC_PUBLIC_RESET) {
 604       RecordHandshakeFailureReason(HANDSHAKE_FAILURE_PUBLIC_RESET);
 605     } else if (connection()->GetStats().packets_received == 0) {
 606       RecordHandshakeFailureReason(HANDSHAKE_FAILURE_BLACK_HOLE);
 607       UMA_HISTOGRAM_SPARSE_SLOWLY(
 608           "Net.QuicSession.ConnectionClose.HandshakeFailureBlackHole.QuicError",
 609           error);
 610     } else {
 611       RecordHandshakeFailureReason(HANDSHAKE_FAILURE_UNKNOWN);
 612       UMA_HISTOGRAM_SPARSE_SLOWLY(
 613           "Net.QuicSession.ConnectionClose.HandshakeFailureUnknown.QuicError",
 614           error);
 615     }
 616   }
 617
 618   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.QuicVersion",
 619                               connection()->version());
 620   NotifyFactoryOfSessionGoingAway();
 621   if (!callback_.is_null()) {
 622     base::ResetAndReturn(&callback_).Run(ERR_QUIC_PROTOCOL_ERROR);
 623   }
 624   socket_->Close();
 625   QuicSession::OnConnectionClosed(error, from_peer);
 626   DCHECK(streams()->empty());
 627   CloseAllStreams(ERR_UNEXPECTED);
 628   CloseAllObservers(ERR_UNEXPECTED);
 629   NotifyFactoryOfSessionClosedLater();
 630 }
 631
 632 void QuicClientSession::OnSuccessfulVersionNegotiation(
 633     const QuicVersion& version) {
 634   logger_.OnSuccessfulVersionNegotiation(version);
 635   QuicSession::OnSuccessfulVersionNegotiation(version);
 636 }
 637
 638 void QuicClientSession::OnProofValid(
 639     const QuicCryptoClientConfig::CachedState& cached) {
 640   DCHECK(cached.proof_valid());
 641
 642   if (!server_info_ || !server_info_->IsReadyToPersist()) {
 643     return;
 644   }
 645
 646   QuicServerInfo::State* state = server_info_->mutable_state();
 647
 648   state->server_config = cached.server_config();
 649   state->source_address_token = cached.source_address_token();
 650   state->server_config_sig = cached.signature();
 651   state->certs = cached.certs();
 652
 653   server_info_->Persist();
 654 }
 655
 656 void QuicClientSession::OnProofVerifyDetailsAvailable(
 657     const ProofVerifyDetails& verify_details) {
 658   const ProofVerifyDetailsChromium* verify_details_chromium =
 659       reinterpret_cast<const ProofVerifyDetailsChromium*>(&verify_details);
 660   CertVerifyResult* result_copy = new CertVerifyResult;
 661   result_copy->CopyFrom(verify_details_chromium->cert_verify_result);
 662   cert_verify_result_.reset(result_copy);
 663   pinning_failure_log_ = verify_details_chromium->pinning_failure_log;
 664 }
 665
 666 void QuicClientSession::StartReading() {
 667   if (read_pending_) {
 668     return;
 669   }
 670   read_pending_ = true;
 671   int rv = socket_->Read(read_buffer_.get(),
 672                          read_buffer_->size(),
 673                          base::Bind(&QuicClientSession::OnReadComplete,
 674                                     weak_factory_.GetWeakPtr()));
 675   if (rv == ERR_IO_PENDING) {
 676     num_packets_read_ = 0;
 677     return;
 678   }
 679
 680   if (++num_packets_read_ > 32) {
 681     num_packets_read_ = 0;
 682     // Data was read, process it.
 683     // Schedule the work through the message loop to 1) prevent infinite
 684     // recursion and 2) avoid blocking the thread for too long.
 685     base::MessageLoop::current()->PostTask(
 686         FROM_HERE,
 687         base::Bind(&QuicClientSession::OnReadComplete,
 688                    weak_factory_.GetWeakPtr(), rv));
 689   } else {
 690     OnReadComplete(rv);
 691   }
 692 }
 693
 694 void QuicClientSession::CloseSessionOnError(int error) {
 695   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.CloseSessionOnError", -error);
 696   CloseSessionOnErrorInner(error, QUIC_INTERNAL_ERROR);
 697   NotifyFactoryOfSessionClosed();
 698 }
 699
 700 void QuicClientSession::CloseSessionOnErrorInner(int net_error,
 701                                                  QuicErrorCode quic_error) {
 702   if (!callback_.is_null()) {
 703     base::ResetAndReturn(&callback_).Run(net_error);
 704   }
 705   CloseAllStreams(net_error);
 706   CloseAllObservers(net_error);
 707   net_log_.AddEvent(
 708       NetLog::TYPE_QUIC_SESSION_CLOSE_ON_ERROR,
 709       NetLog::IntegerCallback("net_error", net_error));
 710
 711   if (connection()->connected())
 712     connection()->CloseConnection(quic_error, false);
 713   DCHECK(!connection()->connected());
 714 }
 715
 716 void QuicClientSession::CloseAllStreams(int net_error) {
 717   while (!streams()->empty()) {
 718     ReliableQuicStream* stream = streams()->begin()->second;
 719     QuicStreamId id = stream->id();
 720     static_cast<QuicReliableClientStream*>(stream)->OnError(net_error);
 721     CloseStream(id);
 722   }
 723 }
 724
 725 void QuicClientSession::CloseAllObservers(int net_error) {
 726   while (!observers_.empty()) {
 727     Observer* observer = *observers_.begin();
 728     observers_.erase(observer);
 729     observer->OnSessionClosed(net_error);
 730   }
 731 }
 732
 733 base::Value* QuicClientSession::GetInfoAsValue(
 734     const std::set<HostPortPair>& aliases) {
 735   base::DictionaryValue* dict = new base::DictionaryValue();
 736   // TODO(rch): remove "host_port_pair" when Chrome 34 is stable.
 737   dict->SetString("host_port_pair", aliases.begin()->ToString());
 738   dict->SetString("version", QuicVersionToString(connection()->version()));
 739   dict->SetInteger("open_streams", GetNumOpenStreams());
 740   base::ListValue* stream_list = new base::ListValue();
 741   for (base::hash_map<QuicStreamId, QuicDataStream*>::const_iterator it
 742            = streams()->begin();
 743        it != streams()->end();
 744        ++it) {
 745     stream_list->Append(new base::StringValue(
 746         base::Uint64ToString(it->second->id())));
 747   }
 748   dict->Set("active_streams", stream_list);
 749
 750   dict->SetInteger("total_streams", num_total_streams_);
 751   dict->SetString("peer_address", peer_address().ToString());
 752   dict->SetString("connection_id", base::Uint64ToString(connection_id()));
 753   dict->SetBoolean("connected", connection()->connected());
 754   const QuicConnectionStats& stats = connection()->GetStats();
 755   dict->SetInteger("packets_sent", stats.packets_sent);
 756   dict->SetInteger("packets_received", stats.packets_received);
 757   dict->SetInteger("packets_lost", stats.packets_lost);
 758   SSLInfo ssl_info;
 759   dict->SetBoolean("secure", GetSSLInfo(&ssl_info) && ssl_info.cert);
 760
 761   base::ListValue* alias_list = new base::ListValue();
 762   for (std::set<HostPortPair>::const_iterator it = aliases.begin();
 763        it != aliases.end(); it++) {
 764     alias_list->Append(new base::StringValue(it->ToString()));
 765   }
 766   dict->Set("aliases", alias_list);
 767
 768   return dict;
 769 }
 770
 771 base::WeakPtr<QuicClientSession> QuicClientSession::GetWeakPtr() {
 772   return weak_factory_.GetWeakPtr();
 773 }
 774
 775 void QuicClientSession::OnReadComplete(int result) {
 776   read_pending_ = false;
 777   if (result == 0)
 778     result = ERR_CONNECTION_CLOSED;
 779
 780   if (result < 0) {
 781     DVLOG(1) << "Closing session on read error: " << result;
 782     UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.ReadError", -result);
 783     NotifyFactoryOfSessionGoingAway();
 784     CloseSessionOnErrorInner(result, QUIC_PACKET_READ_ERROR);
 785     NotifyFactoryOfSessionClosedLater();
 786     return;
 787   }
 788
 789   QuicEncryptedPacket packet(read_buffer_->data(), result);
 790   IPEndPoint local_address;
 791   IPEndPoint peer_address;
 792   socket_->GetLocalAddress(&local_address);
 793   socket_->GetPeerAddress(&peer_address);
 794   // ProcessUdpPacket might result in |this| being deleted, so we
 795   // use a weak pointer to be safe.
 796   connection()->ProcessUdpPacket(local_address, peer_address, packet);
 797   if (!connection()->connected()) {
 798     NotifyFactoryOfSessionClosedLater();
 799     return;
 800   }
 801   StartReading();
 802 }
 803
 804 void QuicClientSession::NotifyFactoryOfSessionGoingAway() {
 805   going_away_ = true;
 806   if (stream_factory_)
 807     stream_factory_->OnSessionGoingAway(this);
 808 }
 809
 810 void QuicClientSession::NotifyFactoryOfSessionClosedLater() {
 811   if (!streams()->empty())
 812     RecordUnexpectedOpenStreams(NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER);
 813
 814   if (!going_away_)
 815     RecordUnexpectedNotGoingAway(NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER);
 816
 817   going_away_ = true;
 818   DCHECK_EQ(0u, GetNumOpenStreams());
 819   DCHECK(!connection()->connected());
 820   base::MessageLoop::current()->PostTask(
 821       FROM_HERE,
 822       base::Bind(&QuicClientSession::NotifyFactoryOfSessionClosed,
 823                  weak_factory_.GetWeakPtr()));
 824 }
 825
 826 void QuicClientSession::NotifyFactoryOfSessionClosed() {
 827   if (!streams()->empty())
 828     RecordUnexpectedOpenStreams(NOTIFY_FACTORY_OF_SESSION_CLOSED);
 829
 830   if (!going_away_)
 831     RecordUnexpectedNotGoingAway(NOTIFY_FACTORY_OF_SESSION_CLOSED);
 832
 833   going_away_ = true;
 834   DCHECK_EQ(0u, GetNumOpenStreams());
 835   // Will delete |this|.
 836   if (stream_factory_)
 837     stream_factory_->OnSessionClosed(this);
 838 }
 839
 840 void QuicClientSession::OnConnectTimeout() {
 841   DCHECK(callback_.is_null());
 842   DCHECK(IsEncryptionEstablished());
 843
 844   if (IsCryptoHandshakeConfirmed())
 845     return;
 846
 847   // TODO(rch): re-enable this code once beta is cut.
 848   //  if (stream_factory_)
 849   //    stream_factory_->OnSessionConnectTimeout(this);
 850   //  CloseAllStreams(ERR_QUIC_HANDSHAKE_FAILED);
 851   //  DCHECK_EQ(0u, GetNumOpenStreams());
 852 }
 853
 854 }  // namespace net