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"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/single_request_host_resolver.h"
 #include "net/http/http_server_properties.h"
 #include "net/quic/crypto/channel_id_chromium.h"
@@ skipping 508 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 max_number_of_lossy_connections,
+    float 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),
+      max_number_of_lossy_connections_(max_number_of_lossy_connections),
+      packet_loss_threshold_(packet_loss_threshold),
       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 180 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()));
 }
 
+bool QuicStreamFactory::IsQuicDisabled(uint16 port) {
+  return max_number_of_lossy_connections_ > 0 &&
+         number_of_lossy_connections_[port] >= max_number_of_lossy_connections_;
+}
+
+bool QuicStreamFactory::OnHandshakeConfirmed(QuicClientSession* session,
+                                             float packet_loss_rate) {
+  DCHECK(session);
+  uint16 port = session->server_id().port();
+  if (packet_loss_rate < packet_loss_threshold_) {
+    number_of_lossy_connections_[port] = 0;
+    return false;
+  }
+
+  if (http_server_properties_) {
+    // We mark it as recently broken, which means that 0-RTT will be disabled
+    // but we'll still race.
+    http_server_properties_->MarkAlternativeServiceRecentlyBroken(
+        AlternativeService(QUIC, session->server_id().host(), port));
+  }
+
+  // We abandon the connection if packet loss rate is too bad.
+  session->CloseSessionOnError(ERR_ABORTED, QUIC_BAD_PACKET_LOSS_RATE);
+
+  if (IsQuicDisabled(port))
+    return true;  // Exit if Quic is already disabled for this port.
+
+  if (++number_of_lossy_connections_[port] >=
+      max_number_of_lossy_connections_) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicStreamFactory.QuicIsDisabled", port, 0,

[Mark P, 2015/03/26 20:25:00]

Also, is there any way to get the information you need without creating a
histogram with ~1024 buckets?  That's a lot.

If most buckets with be zero AND this is not on the critical path, you can
consider using a SPARSE_HISTOGRAM as an alternative.  Note that this macro is
quite a bit slower than the regular histograms macros, so if you have a solution
that uses the regular macros with fewer buckets, you may want to consider that
first.

[ramant (doing other things), 2015/03/26 21:03:35]

Good point. Changed it to UMA_HISTOGRAM_SPARSE_SLOWLY.

+                                1024, 1025);
+  }
+
+  return true;
+}
+
 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 56 matching lines @@
 void QuicStreamFactory::CancelRequest(QuicStreamRequest* request) {
   DCHECK(ContainsKey(active_requests_, request));
   QuicServerId server_id = active_requests_[request];
   job_requests_map_[server_id].erase(request);
   active_requests_.erase(request);
 }
 
 void QuicStreamFactory::CloseAllSessions(int error) {
   while (!active_sessions_.empty()) {
     size_t initial_size = active_sessions_.size();
-    active_sessions_.begin()->second->CloseSessionOnError(error);
+    active_sessions_.begin()->second->CloseSessionOnError(error,
+                                                          QUIC_INTERNAL_ERROR);
     DCHECK_NE(initial_size, active_sessions_.size());
   }
   while (!all_sessions_.empty()) {
     size_t initial_size = all_sessions_.size();
-    all_sessions_.begin()->first->CloseSessionOnError(error);
+    all_sessions_.begin()->first->CloseSessionOnError(error,
+                                                      QUIC_INTERNAL_ERROR);
     DCHECK_NE(initial_size, all_sessions_.size());
   }
   DCHECK(all_sessions_.empty());
 }
 
 base::Value* QuicStreamFactory::QuicStreamFactoryInfoToValue() const {
   base::ListValue* list = new base::ListValue();
 
   for (SessionMap::const_iterator it = active_sessions_.begin();
        it != active_sessions_.end(); ++it) {
@@ skipping 303 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