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

net/quic/quic_stream_factory.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_stream_factory.h"
 
 #include <set>
 
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 418 matching lines @@
 
   if (!session_->connection()->connected()) {
     return ERR_CONNECTION_CLOSED;
   }
 
   session_->StartReading();
   if (!session_->connection()->connected()) {
     return ERR_QUIC_PROTOCOL_ERROR;
   }
   bool require_confirmation =
-      factory_->require_confirmation() || is_post_ ||
+      factory_->require_confirmation() ||
+      is_post_ ||
       was_alternate_protocol_recently_broken_;
 
   rv = session_->CryptoConnect(
       require_confirmation,
       base::Bind(&QuicStreamFactory::Job::OnIOComplete, GetWeakPtr()));
   return rv;
 }
 
 int QuicStreamFactory::Job::DoResumeConnect() {
   io_state_ = STATE_CONNECT_COMPLETE;
@@ skipping 82 matching lines @@
     size_t max_packet_length,
     const std::string& user_agent_id,
     const QuicVersionVector& supported_versions,
     bool enable_port_selection,
     bool always_require_handshake_confirmation,
     bool disable_connection_pooling,
     float load_server_info_timeout_srtt_multiplier,
     bool enable_connection_racing,
     bool enable_non_blocking_io,
     bool disable_disk_cache,
+    int number_of_lossy_handshakes,
+    int packet_loss_threshold,
     int socket_receive_buffer_size,
     const QuicTagVector& connection_options)
     : require_confirmation_(true),
       host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       http_server_properties_(http_server_properties),
       transport_security_state_(transport_security_state),
       quic_server_info_factory_(nullptr),
       quic_crypto_client_stream_factory_(quic_crypto_client_stream_factory),
       random_generator_(random_generator),
       clock_(clock),
       max_packet_length_(max_packet_length),
       config_(InitializeQuicConfig(connection_options)),
       supported_versions_(supported_versions),
       enable_port_selection_(enable_port_selection),
       always_require_handshake_confirmation_(
           always_require_handshake_confirmation),
       disable_connection_pooling_(disable_connection_pooling),
       load_server_info_timeout_srtt_multiplier_(
           load_server_info_timeout_srtt_multiplier),
       enable_connection_racing_(enable_connection_racing),
       enable_non_blocking_io_(enable_non_blocking_io),
       disable_disk_cache_(disable_disk_cache),
+      number_of_lossy_handshakes_(number_of_lossy_handshakes),
+      packet_loss_threshold_(packet_loss_threshold),
+      disable_zero_rtt_(number_of_lossy_handshakes_ > 0 &&
+                        packet_loss_threshold_ > 0),
       socket_receive_buffer_size_(socket_receive_buffer_size),
       port_seed_(random_generator_->RandUint64()),
       check_persisted_supports_quic_(true),
       task_runner_(nullptr),
       weak_factory_(this) {
   DCHECK(transport_security_state_);
   crypto_config_.set_user_agent_id(user_agent_id);
   crypto_config_.AddCanonicalSuffix(".c.youtube.com");
   crypto_config_.AddCanonicalSuffix(".googlevideo.com");
   crypto_config_.SetProofVerifier(
@@ skipping 46 matching lines @@
     return ERR_IO_PENDING;
   }
 
   // TODO(rtenneti): |task_runner_| is used by the Job. Initialize task_runner_
   // in the constructor after WebRequestActionWithThreadsTest.* tests are fixed.
   if (!task_runner_)
     task_runner_ = base::MessageLoop::current()->message_loop_proxy().get();
 
   QuicServerInfo* quic_server_info = nullptr;
   if (quic_server_info_factory_) {
-    bool load_from_disk_cache = !disable_disk_cache_;
+    bool load_from_disk_cache = !disable_disk_cache_ || !disable_zero_rtt_;
     if (http_server_properties_) {
       const AlternateProtocolMap& alternate_protocol_map =
           http_server_properties_->alternate_protocol_map();
       AlternateProtocolMap::const_iterator it =
           alternate_protocol_map.Peek(server_id.host_port_pair());
       if (it == alternate_protocol_map.end() || it->second.protocol != QUIC) {
         // If there is no entry for QUIC, consider that as a new server and
         // don't wait for Cache thread to load the data for that server.
         load_from_disk_cache = false;
       }
@@ skipping 114 matching lines @@
     DVLOG(1) << "No active session";
     return scoped_ptr<QuicHttpStream>();
   }
 
   QuicClientSession* session = active_sessions_[server_id];
   DCHECK(session);
   return scoped_ptr<QuicHttpStream>(
       new QuicHttpStream(session->GetWeakPtr()));
 }
 
+QuicErrorCode QuicStreamFactory::OnCryptoHandshakeCompleted(
+    QuicClientSession* session,
+    const QuicServerId& server_id,
+    int number_of_handshakes) {
+  DCHECK_LT(0, number_of_handshakes);
+  if (number_of_handshakes != number_of_lossy_handshakes_)
+    return QUIC_NO_ERROR;
+
+  bool bad_packet_loss_rate =
+      (session->PacketLossRate() / 10) > packet_loss_threshold_;
+
+  UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.HasBadPacketLossRate",
+                        bad_packet_loss_rate);
+
+  // It is not bad packet loss rate, enable 0-RTT.
+  if (!bad_packet_loss_rate) {
+    disable_zero_rtt_ = false;
+    return QUIC_NO_ERROR;
+  }
+
+  HistogramBrokenAlternateProtocolLocation(
+      BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY);
+
+  const HostPortPair& server = server_id.host_port_pair();
+  http_server_properties_->MarkAlternativeServiceRecentlyBroken(
+        AlternativeService(QUIC, server.host(), server.port()));
+  // TODO(rtenneti): Should we close the connection?
+  return QUIC_BAD_PACKET_LOSS_RATE;
+}
+
 void QuicStreamFactory::OnIdleSession(QuicClientSession* session) {
 }
 
 void QuicStreamFactory::OnSessionGoingAway(QuicClientSession* session) {
   const AliasSet& aliases = session_aliases_[session];
   for (AliasSet::const_iterator it = aliases.begin(); it != aliases.end();
        ++it) {
     DCHECK(active_sessions_.count(*it));
     DCHECK_EQ(session, active_sessions_[*it]);
     // Track sessions which have recently gone away so that we can disable
@@ skipping 382 matching lines @@
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   const HostPortPair& server = server_id.host_port_pair();
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       AlternativeService(QUIC, server.host(), server.port()));
 }
 
 }  // namespace net