Revert of Remove obsolete QUIC disabling code.

net/quic/chromium/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/chromium/quic_stream_factory.h"
 
 #include <openssl/aead.h>
 
 #include <algorithm>
 #include <tuple>
@@ skipping 708 matching lines @@
     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,
     bool prefer_aes,
+    int max_number_of_lossy_connections,
+    float packet_loss_threshold,
+    int max_disabled_reasons,
+    int threshold_public_resets_post_handshake,
+    int threshold_timeouts_with_open_streams,
     int socket_receive_buffer_size,
     bool delay_tcp_race,
     int max_server_configs_stored_in_properties,
     bool close_sessions_on_ip_change,
     bool disable_quic_on_timeout_with_open_streams,
     int idle_connection_timeout_seconds,
     int reduced_ping_timeout_seconds,
     int packet_reader_yield_after_duration_milliseconds,
     bool migrate_sessions_on_network_change,
     bool migrate_sessions_early,
@@ skipping 26 matching lines @@
       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),
       prefer_aes_(prefer_aes),
-      disable_quic_on_timeout_with_open_streams_(
-          disable_quic_on_timeout_with_open_streams),
+      max_number_of_lossy_connections_(max_number_of_lossy_connections),
+      packet_loss_threshold_(packet_loss_threshold),
+      max_disabled_reasons_(max_disabled_reasons),
+      num_public_resets_post_handshake_(0),
+      num_timeouts_with_open_streams_(0),
+      max_public_resets_post_handshake_(0),
+      max_timeouts_with_open_streams_(0),
+      threshold_timeouts_with_open_streams_(
+          threshold_timeouts_with_open_streams),
+      threshold_public_resets_post_handshake_(
+          threshold_public_resets_post_handshake),
       socket_receive_buffer_size_(socket_receive_buffer_size),
       delay_tcp_race_(delay_tcp_race),
       ping_timeout_(QuicTime::Delta::FromSeconds(kPingTimeoutSecs)),
       reduced_ping_timeout_(
           QuicTime::Delta::FromSeconds(reduced_ping_timeout_seconds)),
       yield_after_packets_(kQuicYieldAfterPacketsRead),
       yield_after_duration_(QuicTime::Delta::FromMilliseconds(
           packet_reader_yield_after_duration_milliseconds)),
       close_sessions_on_ip_change_(close_sessions_on_ip_change),
       migrate_sessions_on_network_change_(
           migrate_sessions_on_network_change &&
           NetworkChangeNotifier::AreNetworkHandlesSupported()),
       migrate_sessions_early_(migrate_sessions_early &&
                               migrate_sessions_on_network_change_),
       allow_server_migration_(allow_server_migration),
       force_hol_blocking_(force_hol_blocking),
       race_cert_verification_(race_cert_verification),
       quic_do_not_fragment_(quic_do_not_fragment),
       port_seed_(random_generator_->RandUint64()),
       check_persisted_supports_quic_(true),
       has_initialized_data_(false),
       num_push_streams_created_(0),
       status_(OPEN),
       task_runner_(nullptr),
       ssl_config_service_(ssl_config_service),
       weak_factory_(this) {
   if (ssl_config_service_.get())
     ssl_config_service_->AddObserver(this);
+  if (disable_quic_on_timeout_with_open_streams)
+    threshold_timeouts_with_open_streams_ = 1;
   DCHECK(transport_security_state_);
   DCHECK(http_server_properties_);
   crypto_config_.set_user_agent_id(user_agent_id);
   crypto_config_.AddCanonicalSuffix(".c.youtube.com");
   crypto_config_.AddCanonicalSuffix(".ggpht.com");
   crypto_config_.AddCanonicalSuffix(".googlevideo.com");
   crypto_config_.AddCanonicalSuffix(".googleusercontent.com");
   // TODO(rtenneti): http://crbug.com/487355. Temporary fix for b/20760730 until
   // channel_id_service is supported in cronet.
   if (channel_id_service) {
@@ skipping 315 matching lines @@
 void QuicStreamFactory::OnCertVerifyJobComplete(CertVerifierJob* job, int rv) {
   active_cert_verifier_jobs_.erase(job->server_id());
 }
 
 std::unique_ptr<QuicHttpStream> QuicStreamFactory::CreateFromSession(
     QuicChromiumClientSession* session) {
   return std::unique_ptr<QuicHttpStream>(
       new QuicHttpStream(session->GetWeakPtr()));
 }
 
-bool QuicStreamFactory::IsQuicDisabled() const {
+QuicChromiumClientSession::QuicDisabledReason
+QuicStreamFactory::QuicDisabledReason(uint16_t port) const {
+  if (max_number_of_lossy_connections_ > 0 &&
+      number_of_lossy_connections_.find(port) !=
+          number_of_lossy_connections_.end() &&
+      number_of_lossy_connections_.at(port) >=
+          max_number_of_lossy_connections_) {
+    return QuicChromiumClientSession::QUIC_DISABLED_BAD_PACKET_LOSS_RATE;
+  }
+  if (threshold_public_resets_post_handshake_ > 0 &&
+      num_public_resets_post_handshake_ >=
+          threshold_public_resets_post_handshake_) {
+    return QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE;
+  }
+  if (threshold_timeouts_with_open_streams_ > 0 &&
+      num_timeouts_with_open_streams_ >=
+          threshold_timeouts_with_open_streams_) {
+    return QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS;
+  }
+  return QuicChromiumClientSession::QUIC_DISABLED_NOT;
+}
+
+const char* QuicStreamFactory::QuicDisabledReasonString() const {
+  // TODO(ckrasic) - better solution for port/lossy connections?
+  const uint16_t port = 443;
+  switch (QuicDisabledReason(port)) {
+    case QuicChromiumClientSession::QUIC_DISABLED_BAD_PACKET_LOSS_RATE:
+      return "Bad packet loss rate.";
+    case QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE:
+      return "Public resets after successful handshakes.";
+    case QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS:
+      return "Connection timeouts with streams open.";
+    default:
+      return "";
+  }
+}
+
+bool QuicStreamFactory::IsQuicDisabled(uint16_t port) const {
   return status_ != OPEN;
 }
 
-bool QuicStreamFactory::OnHandshakeConfirmed(
-    QuicChromiumClientSession* session) {
-  if (!IsQuicDisabled())
+bool QuicStreamFactory::OnHandshakeConfirmed(QuicChromiumClientSession* session,
+                                             float packet_loss_rate) {
+  DCHECK(session);
+  uint16_t port = session->server_id().port();
+  if (packet_loss_rate < packet_loss_threshold_) {
+    number_of_lossy_connections_[port] = 0;
     return false;
+  }
 
-  session->CloseSessionOnErrorAndNotifyFactoryLater(
-      ERR_ABORTED, QUIC_TIMEOUTS_WITH_OPEN_STREAMS);
+  // 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));
 
-  return true;
+  bool was_quic_disabled = IsQuicDisabled(port);
+  ++number_of_lossy_connections_[port];
+
+  // Collect data for port 443 for packet loss events.
+  if (port == 443 && max_number_of_lossy_connections_ > 0) {
+    UMA_HISTOGRAM_SPARSE_SLOWLY(
+        base::StringPrintf("Net.QuicStreamFactory.BadPacketLossEvents%d",
+                           max_number_of_lossy_connections_),
+        std::min(number_of_lossy_connections_[port],
+                 max_number_of_lossy_connections_));
+  }
+
+  MaybeDisableQuic(port);
+
+  bool is_quic_disabled = IsQuicDisabled(port);
+  if (is_quic_disabled) {
+    // Close QUIC connection if Quic is disabled for this port.
+    session->CloseSessionOnErrorAndNotifyFactoryLater(
+        ERR_ABORTED, QUIC_BAD_PACKET_LOSS_RATE);
+
+    // If this bad packet loss rate disabled the QUIC, then record it.
+    if (!was_quic_disabled)
+      UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicStreamFactory.QuicIsDisabled", port);
+  }
+  return is_quic_disabled;
 }
 
 void QuicStreamFactory::OnTcpJobCompleted(bool succeeded) {
   if (status_ != CLOSED)
     return;
 
   // If QUIC connections are failing while TCP connections are working,
   // then stop using QUIC. On the other hand if both QUIC and TCP are
   // failing, then attempt to use QUIC again.
   if (succeeded) {
     status_ = DISABLED;
     return;
   }
 
   status_ = OPEN;
+  num_timeouts_with_open_streams_ = 0;
 }
 
 void QuicStreamFactory::OnIdleSession(QuicChromiumClientSession* session) {}
 
 void QuicStreamFactory::OnSessionGoingAway(QuicChromiumClientSession* session) {
   const AliasSet& aliases = session_aliases_[session];
   for (AliasSet::const_iterator it = aliases.begin(); it != aliases.end();
        ++it) {
     const QuicServerId& server_id = it->server_id();
     DCHECK(active_sessions_.count(server_id));
@@ skipping 11 matching lines @@
     DCHECK(base::ContainsKey(session_peer_ip_, session));
     const IPEndPoint peer_address = session_peer_ip_[session];
     ip_aliases_[peer_address].erase(session);
     if (ip_aliases_[peer_address].empty())
       ip_aliases_.erase(peer_address);
     session_peer_ip_.erase(session);
   }
   session_aliases_.erase(session);
 }
 
+void QuicStreamFactory::MaybeDisableQuic(QuicChromiumClientSession* session) {
+  DCHECK(session);
+  uint16_t port = session->server_id().port();
+  if (IsQuicDisabled(port))
+    return;
+
+  // Expire the oldest disabled_reason if appropriate.  This enforces that we
+  // only consider the max_disabled_reasons_ most recent sessions.
+  QuicChromiumClientSession::QuicDisabledReason disabled_reason;
+  if (static_cast<int>(disabled_reasons_.size()) == max_disabled_reasons_) {
+    disabled_reason = disabled_reasons_.front();
+    disabled_reasons_.pop_front();
+    if (disabled_reason ==
+        QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE) {
+      --num_public_resets_post_handshake_;
+    } else if (disabled_reason == QuicChromiumClientSession::
+                                      QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS) {
+      --num_timeouts_with_open_streams_;
+    }
+  }
+  disabled_reason = session->disabled_reason();
+  disabled_reasons_.push_back(disabled_reason);
+  if (disabled_reason ==
+      QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE) {
+    ++num_public_resets_post_handshake_;
+  } else if (disabled_reason == QuicChromiumClientSession::
+                                    QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS) {
+    ++num_timeouts_with_open_streams_;
+  }
+  if (num_timeouts_with_open_streams_ > max_timeouts_with_open_streams_) {
+    max_timeouts_with_open_streams_ = num_timeouts_with_open_streams_;
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicStreamFactory.TimeoutsWithOpenStreams",
+                                num_timeouts_with_open_streams_, 1, 20, 10);
+  }
+
+  if (num_public_resets_post_handshake_ > max_public_resets_post_handshake_) {
+    max_public_resets_post_handshake_ = num_public_resets_post_handshake_;
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "Net.QuicStreamFactory.PublicResetsPostHandshake",
+        num_public_resets_post_handshake_, 1, 20, 10);
+  }
+
+  MaybeDisableQuic(port);
+  if (IsQuicDisabled(port)) {
+    if (disabled_reason ==
+        QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE) {
+      session->CloseSessionOnErrorAndNotifyFactoryLater(
+          ERR_ABORTED, QUIC_PUBLIC_RESETS_POST_HANDSHAKE);
+    } else if (disabled_reason == QuicChromiumClientSession::
+                                      QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS) {
+      session->CloseSessionOnErrorAndNotifyFactoryLater(
+          ERR_ABORTED, QUIC_TIMEOUTS_WITH_OPEN_STREAMS);
+    }
+    UMA_HISTOGRAM_ENUMERATION("Net.QuicStreamFactory.DisabledReasons",
+                              disabled_reason,
+                              QuicChromiumClientSession::QUIC_DISABLED_MAX);
+  }
+}
+
+void QuicStreamFactory::MaybeDisableQuic(uint16_t port) {
+  if (status_ == DISABLED)
+    return;
+
+  QuicChromiumClientSession::QuicDisabledReason disabled_reason =
+      QuicDisabledReason(port);
+  if (disabled_reason == QuicChromiumClientSession::QUIC_DISABLED_NOT) {
+    DCHECK_EQ(OPEN, status_);
+    return;
+  }
+
+  if (disabled_reason ==
+      QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS) {
+    // When QUIC there are too many timeouts with open stream, the factory
+    // should be closed. When TCP jobs complete, they will move the factory
+    // to either fully disabled or back to open.
+    status_ = CLOSED;
+    DCHECK(IsQuicDisabled(port));
+    DCHECK_NE(QuicChromiumClientSession::QuicDisabledReason(port),
+              QuicChromiumClientSession::QUIC_DISABLED_NOT);
+    return;
+  }
+
+  status_ = DISABLED;
+  DCHECK(IsQuicDisabled(port));
+  DCHECK_NE(QuicChromiumClientSession::QuicDisabledReason(port),
+            QuicChromiumClientSession::QUIC_DISABLED_NOT);
+}
+
 void QuicStreamFactory::OnSessionClosed(QuicChromiumClientSession* session) {
   DCHECK_EQ(0u, session->GetNumActiveStreams());
+  MaybeDisableQuic(session);
   OnSessionGoingAway(session);
   delete session;
   all_sessions_.erase(session);
 }
 
 void QuicStreamFactory::OnTimeoutWithOpenStreams() {
   // Reduce PING timeout when connection times out with open stream.
   if (ping_timeout_ > reduced_ping_timeout_) {
     ping_timeout_ = reduced_ping_timeout_;
   }
-  if (disable_quic_on_timeout_with_open_streams_)
-    status_ = CLOSED;
 }
 
 void QuicStreamFactory::CancelRequest(QuicStreamRequest* request) {
   RequestMap::iterator request_it = active_requests_.find(request);
   DCHECK(request_it != active_requests_.end());
   const QuicServerId& server_id = request_it->second;
   job_requests_map_[server_id].erase(request);
   active_requests_.erase(request_it);
 }
 
@@ skipping 34 matching lines @@
   return std::move(list);
 }
 
 void QuicStreamFactory::ClearCachedStatesInCryptoConfig(
     const base::Callback<bool(const GURL&)>& origin_filter) {
   ServerIdOriginFilter filter(origin_filter);
   crypto_config_.ClearCachedStates(filter);
 }
 
 void QuicStreamFactory::OnIPAddressChanged() {
+  num_timeouts_with_open_streams_ = 0;
   status_ = OPEN;
   CloseAllSessions(ERR_NETWORK_CHANGED, QUIC_IP_ADDRESS_CHANGED);
   set_require_confirmation(true);
 }
 
 void QuicStreamFactory::OnNetworkConnected(NetworkHandle network) {
+  num_timeouts_with_open_streams_ = 0;
   status_ = OPEN;
 }
 
 void QuicStreamFactory::OnNetworkMadeDefault(NetworkHandle network) {
   ScopedConnectionMigrationEventLog scoped_event_log(net_log_,
                                                      "OnNetworkMadeDefault");
   DCHECK_NE(NetworkChangeNotifier::kInvalidNetworkHandle, network);
   MaybeMigrateOrCloseSessions(network, /*close_if_cannot_migrate=*/false,
                               scoped_event_log.net_log());
   set_require_confirmation(true);
@@ skipping 596 matching lines @@
   // Since the session was active, there's no longer an
   // 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.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net