QUIC - disable QUIC if packet loss rate is bad for a connection.

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/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 153 matching lines @@
     NetLog* net_log)
     : QuicClientSessionBase(connection, config),
       require_confirmation_(false),
       stream_factory_(stream_factory),
       socket_(socket.Pass()),
       read_buffer_(new IOBufferWithSize(kMaxPacketSize)),
       transport_security_state_(transport_security_state),
       server_info_(server_info.Pass()),
       read_pending_(false),
       num_total_streams_(0),
+      number_of_handshakes_(0),
       task_runner_(task_runner),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
       dns_resolution_end_time_(dns_resolution_end_time),
       logger_(new QuicConnectionLogger(this, connection_description, net_log_)),
       num_packets_read_(0),
       going_away_(false),
       weak_factory_(this) {
   connection->set_debug_visitor(logger_.get());
   IPEndPoint address;
   if (socket && socket->GetLocalAddress(&address) == OK &&
@@ skipping 345 matching lines @@
     return ERR_QUIC_HANDSHAKE_FAILED;
 
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int QuicClientSession::GetNumSentClientHellos() const {
   return crypto_stream_->num_sent_client_hellos();
 }
 
+int QuicClientSession::PacketLossRate() const {
+  return logger_->PacketLossRate();
+}
+
 bool QuicClientSession::CanPool(const std::string& hostname,
                                 PrivacyMode privacy_mode) const {
   DCHECK(connection()->connected());
   if (privacy_mode != server_id_.privacy_mode()) {
     // Privacy mode must always match.
     return false;
   }
   SSLInfo ssl_info;
   if (!GetSSLInfo(&ssl_info) || !ssl_info.cert.get()) {
     // We can always pool with insecure QUIC sessions.
@@ skipping 64 matching lines @@
       // for reading of QUIC server information from disk cache. We could use
       // this data to compare total time taken if we were to cancel the disk
       // cache read vs waiting for the read to complete.
       base::TimeTicks wait_for_data_start_time =
           server_info_->wait_for_data_start_time();
       if (!wait_for_data_start_time.is_null()) {
         UMA_HISTOGRAM_TIMES(
             "Net.QuicServerInfo.WaitForDataReady.HandshakeConfirmedTime",
             base::TimeTicks::Now() - wait_for_data_start_time);
       }
+
+      // TODO(rtenneti): Handle ERROR condition from OnCryptoHandshakeCompleted.
+      ++number_of_handshakes_;

[Ryan Hamilton, 2015/03/21 00:04:46]

I'm not sure that I understand what this member does. Perhaps the factory should
be computing this?

[ramant (doing other things), 2015/03/21 03:46:05]

Done.

+      stream_factory_->OnCryptoHandshakeCompleted(this, server_id_,
+                                                  number_of_handshakes_);
     }
+
     // Track how long it has taken to finish handshake after we have finished
     // DNS host resolution.
     if (!dns_resolution_end_time_.is_null()) {
       UMA_HISTOGRAM_TIMES(
           "Net.QuicSession.HostResolution.HandshakeConfirmedTime",
           base::TimeTicks::Now() - dns_resolution_end_time_);
     }
 
     ObserverSet::iterator it = observers_.begin();
     while (it != observers_.end()) {
@@ skipping 305 matching lines @@
     stream_factory_->OnSessionClosed(this);
 }
 
 void QuicClientSession::OnConnectTimeout() {
   DCHECK(callback_.is_null());
   DCHECK(IsEncryptionEstablished());
 
   if (IsCryptoHandshakeConfirmed())
     return;
 
+  ++number_of_handshakes_;
+  stream_factory_->OnCryptoHandshakeCompleted(this, server_id_,
+                                              number_of_handshakes_);
   // 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