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>
@@ skipping 24 matching lines @@
 class QuicClock;
 class QuicClientSession;
 class QuicConnectionHelper;
 class QuicCryptoClientStreamFactory;
 class QuicRandom;
 class QuicServerInfoFactory;
 class QuicServerId;
 class QuicStreamFactory;
 class TransportSecurityState;
 
+enum QuicClientSessionEpitaph;
+
 namespace test {
 class QuicStreamFactoryPeer;
 }  // namespace test
 
 // Encapsulates a pending request for a QuicHttpStream.
 // If the request is still pending when it is destroyed, it will
 // cancel the request with the factory.
 class NET_EXPORT_PRIVATE QuicStreamRequest {
  public:
   explicit QuicStreamRequest(QuicStreamFactory* factory);
@@ skipping 59 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_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_NO_ERROR if not.
+  QuicErrorCode QuicDisabledReason(uint16 port);

[Ryan Hamilton, 2015/06/30 18:55:32]

Instead of QuicErrorCodes (which intended as on-the-wire error codes to
communicate problems with a peer) I recommend using a new enum with just the few
reasons. Something like: QuicStreamFactory::DisabledReason

[Buck, 2015/07/01 19:06:20]

I went with QuicDisabledReason in quic_types.h

+
   // 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::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<QuicClientSessionEpitaph> EpitaphsQueue;

[Ryan Hamilton, 2015/06/30 18:55:32]

nit: remove the newline before to be consistent with other typedefs.

[Buck, 2015/07/01 19:06:20]

Done.

+
   // 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.
   scoped_ptr<QuicHttpStream> CreateFromSession(QuicClientSession*);
@@ skipping 26 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 departed connections, using a

[Ryan Hamilton, 2015/06/30 18:55:32]

nit: instead of "departed", how about "closed" which matches usage elsewhere.

[Buck, 2015/07/01 19:06:20]

Done.

+  // bounded queue.
+  int max_epitaphs_;
+  EpitaphsQueue epitaphs_;
+  // Events that can trigger disaabling QUIC

[Ryan Hamilton, 2015/06/30 18:55:32]

nit: disaabling -> disabling

[Buck, 2015/07/01 19:06:19]

Done.

+  int public_resets_post_handshake_;

[Ryan Hamilton, 2015/06/30 18:55:32]

nit: num_public_resets_post_handshake_ and num_timeouts_with_open_streams_?

[Buck, 2015/07/01 19:06:20]

Done.

+  int timeouts_streams_open_;
+  // Keep track the largest values for UMA histograms, that will help
+  // determine good threshold values.
+  int max_public_resets_post_handshake_;
+  int max_timeouts_streams_open_;
+  // Thresholds if greater than zero, determine when to
+  int threshold_timeouts_streams_open_;
+  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_