QUIC - disable QUIC under recent pathological connection errors.

net/quic/quic_stream_factory.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_STREAM_FACTORY_H_
 #define NET_QUIC_QUIC_STREAM_FACTORY_H_
 
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/network_change_notifier.h"
 #include "net/cert/cert_database.h"
 #include "net/log/net_log.h"
 #include "net/proxy/proxy_server.h"
 #include "net/quic/network_connection.h"
 #include "net/quic/quic_config.h"
 #include "net/quic/quic_crypto_stream.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/quic_types.h"
 
 namespace net {
 
 class CertVerifier;
 class ChannelIDService;
 class ClientSocketFactory;
 class HostResolver;
 class HttpServerProperties;
 class QuicClock;
 class QuicClientSession;
@@ skipping 77 matching lines @@
       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_epitaphs,
+      int threshold_timeouts_with_streams_open,
+      int threshold_public_resets_post_handshake,
       int socket_receive_buffer_size,
       const QuicTagVector& connection_options);
   ~QuicStreamFactory() override;
 
   // Creates a new QuicHttpStream to |host_port_pair| which will be
   // owned by |request|. |is_https| specifies if the protocol is https or not.
   // If a matching session already exists, this method will return OK.  If no
   // matching session exists, this will return ERR_IO_PENDING and will invoke
   // OnRequestComplete asynchronously.
   int Create(const HostPortPair& host_port_pair,
@@ skipping 10 matching lines @@
   // |number_of_lossy_connections_| by port. If |number_of_lossy_connections_|
   // is greater than or equal to |max_number_of_lossy_connections_| then it
   // disables QUIC. If QUIC is disabled then it closes the connection.
   //
   // Returns true if QUIC is disabled for the port of the session.
   bool OnHandshakeConfirmed(QuicClientSession* session, float packet_loss_rate);
 
   // Returns true if QUIC is disabled for this port.
   bool IsQuicDisabled(uint16 port);
 
+  // Returns reason QUIC is disabled for this port, or QUIC_DISABLED_NOT if not.
+  QuicDisabledReason QuicDisabledReason(uint16 port);
+
+  // Returns reason QUIC is disabled as string for net-internals.
+  std::string QuicDisabledReasonString() const;

[Ryan Hamilton, 2015/07/06 18:25:41]

nit: const std::string& ? (Or if that doesn't work because it'd be returning a
ref to a temporary, how bout a const char*? I'm not entirely sure where this is
used. Perhaps it's not worth saving a copy...

[Buck, 2015/07/06 21:39:32]

going with const char*

fyi, it is used in HttpNetworkSession::QuicInfoToValue().

+
   // Called by a session when it becomes idle.
   void OnIdleSession(QuicClientSession* session);
 
   // Called by a session when it is going away and no more streams should be
   // created on it.
   void OnSessionGoingAway(QuicClientSession* session);
 
   // Called by a session after it shuts down.
   void OnSessionClosed(QuicClientSession* session);
 
@@ skipping 73 matching lines @@
   typedef std::set<QuicServerId> AliasSet;
   typedef std::map<QuicClientSession*, AliasSet> SessionAliasMap;
   typedef std::set<QuicClientSession*> SessionSet;
   typedef std::map<IpAliasKey, SessionSet> IPAliasMap;
   typedef std::map<QuicServerId, QuicCryptoClientConfig*> CryptoConfigMap;
   typedef std::set<Job*> JobSet;
   typedef std::map<QuicServerId, JobSet> JobMap;
   typedef std::map<QuicStreamRequest*, QuicServerId> RequestMap;
   typedef std::set<QuicStreamRequest*> RequestSet;
   typedef std::map<QuicServerId, RequestSet> ServerIDRequestsMap;
+  typedef std::deque<enum QuicDisabledReason> DisabledReasonsQueue;
 
   // Creates a job which doesn't wait for server config to be loaded from the
   // disk cache. This job is started via a PostTask.
   void CreateAuxilaryJob(const QuicServerId server_id,
                          int cert_verify_flags,
                          bool server_and_origin_have_same_host,
                          bool is_post,
                          const BoundNetLog& net_log);
 
   // Returns a newly created QuicHttpStream owned by the caller.
@@ skipping 27 matching lines @@
   // Initializes the cached state associated with |server_id| in
   // |crypto_config_| with the information in |server_info|.
   void InitializeCachedStateInCryptoConfig(
       const QuicServerId& server_id,
       const scoped_ptr<QuicServerInfo>& server_info);
 
   void ProcessGoingAwaySession(QuicClientSession* session,
                                const QuicServerId& server_id,
                                bool was_session_active);
 
+  // Collect stats from epitaphs, possibly disabling Quic.
+  void MaybeDisableQuic(QuicClientSession* session);
+
   bool require_confirmation_;
   HostResolver* host_resolver_;
   ClientSocketFactory* client_socket_factory_;
   base::WeakPtr<HttpServerProperties> http_server_properties_;
   TransportSecurityState* transport_security_state_;
   QuicServerInfoFactory* quic_server_info_factory_;
   QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory_;
   QuicRandom* random_generator_;
   scoped_ptr<QuicClock> clock_;
   const size_t max_packet_length_;
@@ skipping 58 matching lines @@
   // Set if we want to disable QUIC when there is high packet loss rate.
   // Specifies the maximum number of connections with high packet loss in a row
   // after which QUIC will be disabled.
   int max_number_of_lossy_connections_;
   // Specifies packet loss rate in fraction after which a connection is closed
   // and is considered as a lossy connection.
   float packet_loss_threshold_;
   // Count number of lossy connections by port.
   std::map<uint16, int> number_of_lossy_connections_;
 
+  // Keep track of stats for recently closed connections, using a
+  // bounded queue.
+  int max_disabled_reasons_;
+  DisabledReasonsQueue disabled_reasons_;
+  // Events that can trigger disabling QUIC
+  int num_public_resets_post_handshake_;
+  int num_timeouts_with_open_streams_;
+  // Keep track the largest values for UMA histograms, that will help
+  // determine good threshold values.
+  int max_public_resets_post_handshake_;
+  int max_timeouts_with_open_streams_;
+  // Thresholds if greater than zero, determine when to
+  int threshold_timeouts_with_open_streams_;
+  int threshold_public_resets_post_handshake_;
+
   // Size of the UDP receive buffer.
   int socket_receive_buffer_size_;
 
   // Each profile will (probably) have a unique port_seed_ value.  This value
   // is used to help seed a pseudo-random number generator (PortSuggester) so
   // that we consistently (within this profile) suggest the same ephemeral
   // port when we re-connect to any given server/port.  The differences between
   // profiles (probablistically) prevent two profiles from colliding in their
   // ephemeral port requests.
   uint64 port_seed_;
 
   // Local address of socket that was created in CreateSession.
   IPEndPoint local_address_;
   bool check_persisted_supports_quic_;
   std::set<HostPortPair> quic_supported_servers_at_startup_;
 
   NetworkConnection network_connection_;
 
   base::TaskRunner* task_runner_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_