QUIC - disable QUIC under recent pathological connection errors.

net/quic/quic_client_session.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_client_session.h"
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 166 matching lines @@
       socket_(socket.Pass()),
       transport_security_state_(transport_security_state),
       server_info_(server_info.Pass()),
       num_total_streams_(0),
       task_runner_(task_runner),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
       packet_reader_(socket_.get(), this, net_log_),
       dns_resolution_end_time_(dns_resolution_end_time),
       logger_(new QuicConnectionLogger(this, connection_description, net_log_)),
       going_away_(false),
+      epitaph_(QUIC_EPITAPH_RIP),
       weak_factory_(this) {
   crypto_stream_.reset(
       crypto_client_stream_factory
           ? crypto_client_stream_factory->CreateQuicCryptoClientStream(
                 server_id, this, crypto_config)
           : new QuicCryptoClientStream(
                 server_id, this,
                 new ProofVerifyContextChromium(cert_verify_flags, net_log_),
                 crypto_config));
   connection->set_debug_visitor(logger_.get());
@@ skipping 472 matching lines @@
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "Net.QuicSession.ConnectionCloseErrorCodeClient", error);
   }
 
   if (error == QUIC_CONNECTION_TIMED_OUT) {
     UMA_HISTOGRAM_COUNTS(
         "Net.QuicSession.ConnectionClose.NumOpenStreams.TimedOut",
         GetNumOpenStreams());
     if (IsCryptoHandshakeConfirmed()) {
       if (GetNumOpenStreams() > 0) {
+        epitaph_ = QUIC_EPITAPH_TIMEOUT_STREAMS_OPEN;
         UMA_HISTOGRAM_BOOLEAN(
             "Net.QuicSession.TimedOutWithOpenStreams.HasUnackedPackets",
             connection()->sent_packet_manager().HasUnackedPackets());
         UMA_HISTOGRAM_COUNTS(
             "Net.QuicSession.TimedOutWithOpenStreams.ConsecutiveRTOCount",
             connection()->sent_packet_manager().consecutive_rto_count());
         UMA_HISTOGRAM_COUNTS(
             "Net.QuicSession.TimedOutWithOpenStreams.ConsecutiveTLPCount",
             connection()->sent_packet_manager().consecutive_tlp_count());
       }
@@ skipping 12 matching lines @@
     } else {
       UMA_HISTOGRAM_COUNTS(
           "Net.QuicSession.ConnectionClose.NumOpenStreams.HandshakeTimedOut",
           GetNumOpenStreams());
       UMA_HISTOGRAM_COUNTS(
           "Net.QuicSession.ConnectionClose.NumTotalStreams.HandshakeTimedOut",
           num_total_streams_);
     }
   }
 
-  if (!IsCryptoHandshakeConfirmed()) {
+  bool crypto_handshake_confirmed = IsCryptoHandshakeConfirmed();
+  if (error == QUIC_PUBLIC_RESET && crypto_handshake_confirmed) {
+    epitaph_ = QUIC_EPITAPH_PUBLIC_RESET_POST_HANDSHAKE;
+  }
+  if (!crypto_handshake_confirmed) {
     if (error == QUIC_PUBLIC_RESET) {
       RecordHandshakeFailureReason(HANDSHAKE_FAILURE_PUBLIC_RESET);
     } else if (connection()->GetStats().packets_received == 0) {
       RecordHandshakeFailureReason(HANDSHAKE_FAILURE_BLACK_HOLE);
       UMA_HISTOGRAM_SPARSE_SLOWLY(
           "Net.QuicSession.ConnectionClose.HandshakeFailureBlackHole.QuicError",
           error);
     } else {
       RecordHandshakeFailureReason(HANDSHAKE_FAILURE_UNKNOWN);
       UMA_HISTOGRAM_SPARSE_SLOWLY(
           "Net.QuicSession.ConnectionClose.HandshakeFailureUnknown.QuicError",
           error);
     }
   }

[Ryan Hamilton, 2015/06/30 18:55:31]

Alternatively, you could do:

} else if (error == QUIC_PUBLIC_RESET) {
  epitaph_ = QUIC_EPITAPH_PUBLIC_RESET_POST_HANDSHAKE;
}

which would avoid the need to introduce the crypto_handshake_confirmed local
variable.

[Buck, 2015/07/01 19:06:19]

Done.

 
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.QuicVersion",
                               connection()->version());
   NotifyFactoryOfSessionGoingAway();
   if (!callback_.is_null()) {
     base::ResetAndReturn(&callback_).Run(ERR_QUIC_PROTOCOL_ERROR);
   }
   socket_->Close();
   QuicSession::OnConnectionClosed(error, from_peer);
   DCHECK(dynamic_streams().empty());
@@ skipping 194 matching lines @@
     return;
 
   // TODO(rch): re-enable this code once beta is cut.
   //  if (stream_factory_)
   //    stream_factory_->OnSessionConnectTimeout(this);
   //  CloseAllStreams(ERR_QUIC_HANDSHAKE_FAILED);
   //  DCHECK_EQ(0u, GetNumOpenStreams());
 }
 
 }  // namespace net