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