Remove obsolete QUIC disabling code.

net/quic/chromium/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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 161 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_recent_disabled_reasons,
-      int threshold_timeouts_with_streams_open,
-      int threshold_public_resets_post_handshake,
       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 17 matching lines @@
   // matching session exists, this will return ERR_IO_PENDING and will invoke
   // OnRequestComplete asynchronously.
   int Create(const QuicServerId& server_id,
              const HostPortPair& destination,
              int cert_verify_flags,
              const GURL& url,
              base::StringPiece method,
              const BoundNetLog& net_log,
              QuicStreamRequest* request);
 
-  // If |packet_loss_rate| is greater than or equal to |packet_loss_threshold_|
-  // it marks QUIC as recently broken for the port of the session. Increments
-  // |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(QuicChromiumClientSession* session,
-                            float packet_loss_rate);
+  // Called when the handshake for |session| is confirmed. If QUIC is disabled
+  // currently disabled, then it closes the connection and returns true.
+  bool OnHandshakeConfirmed(QuicChromiumClientSession* session);
 
   // Called when a TCP job completes for an origin that QUIC potentially
   // could be used for.
   void OnTcpJobCompleted(bool succeeded);
 
-  // Returns true if QUIC is disabled for this port.
-  bool IsQuicDisabled(uint16_t port) const;
-
-  // Returns reason QUIC is disabled for this port, or QUIC_DISABLED_NOT if not.
-  QuicChromiumClientSession::QuicDisabledReason QuicDisabledReason(
-      uint16_t port) const;
-
-  // Returns reason QUIC is disabled as string for net-internals, or
-  // returns empty string if QUIC is not disabled.
-  const char* QuicDisabledReasonString() const;
+  // Returns true if QUIC is disabled.
+  bool IsQuicDisabled() const;
 
   // Called by a session when it becomes idle.
   void OnIdleSession(QuicChromiumClientSession* session);
 
   // Called by a session when it is going away and no more streams should be
   // created on it.
   void OnSessionGoingAway(QuicChromiumClientSession* session);
 
   // Called by a session after it shuts down.
   void OnSessionClosed(QuicChromiumClientSession* session);
@@ skipping 122 matching lines @@
   }
 
   int socket_receive_buffer_size() const { return socket_receive_buffer_size_; }
 
   bool delay_tcp_race() const { return delay_tcp_race_; }
 
  private:
   class Job;
   class CertVerifierJob;
   friend class test::QuicStreamFactoryPeer;
-  FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryTest, QuicLossyProxyMarkedAsBad);
 
   typedef std::map<QuicServerId, QuicChromiumClientSession*> SessionMap;
   typedef std::map<QuicChromiumClientSession*, QuicSessionKey> SessionIdMap;
   typedef std::set<QuicSessionKey> AliasSet;
   typedef std::map<QuicChromiumClientSession*, AliasSet> SessionAliasMap;
   typedef std::set<QuicChromiumClientSession*> SessionSet;
   typedef std::map<IPEndPoint, SessionSet> IPAliasMap;
   typedef std::map<QuicChromiumClientSession*, IPEndPoint> SessionPeerIPMap;
   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 QuicChromiumClientSession::QuicDisabledReason>
-      DisabledReasonsQueue;
   typedef std::map<QuicServerId, std::unique_ptr<CertVerifierJob>>
       CertVerifierJobMap;
 
   enum FactoryStatus {
     OPEN,     // New streams may be created.
     CLOSED,   // No new streams may be created temporarily.
     DISABLED  // No more streams may be created until the network changes.
   };
 
   // Creates a job which doesn't wait for server config to be loaded from the
@@ skipping 51 matching lines @@
 
   // Initialize |quic_supported_servers_at_startup_| with the list of servers
   // that supported QUIC at start up and also initialize in-memory cache of
   // QuicServerInfo objects from HttpServerProperties.
   void MaybeInitialize();
 
   void ProcessGoingAwaySession(QuicChromiumClientSession* session,
                                const QuicServerId& server_id,
                                bool was_session_active);
 
-  // Collect stats from recent connections, possibly disabling Quic.
-  void MaybeDisableQuic(QuicChromiumClientSession* session);
-
-  void MaybeDisableQuic(uint16_t port);
-
   // Internal method that migrates |session| over to using
   // |peer_address| and |network|. If |network| is kInvalidNetworkHandle,
   // default network is used. If |packet| is not null, it is sent
   // on the new network, else a PING frame is sent.
   void MigrateSession(QuicChromiumClientSession* session,
                       IPEndPoint peer_address,
                       NetworkChangeNotifier::NetworkHandle network,
                       bool close_session_on_error,
                       const BoundNetLog& bound_net_log,
                       scoped_refptr<StringIOBuffer> packet);
@@ skipping 73 matching lines @@
 
   // Set if experimental non-blocking IO should be used on windows sockets.
   bool enable_non_blocking_io_;
 
   // Set if we do not want to load server config from the disk cache.
   bool disable_disk_cache_;
 
   // Set if AES-GCM should be preferred, even if there is no hardware support.
   bool prefer_aes_;
 
-  // 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_t, 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_;
+  // True if QUIC should be disabled when there are timeouts with open
+  // streams.
+  bool disable_quic_on_timeout_with_open_streams_;

[ianswett, 2016/09/08 19:37:02]

Were you intending to keep this?  You removed the enum.

[Ryan Hamilton, 2016/09/08 19:42:02]

Yes, I want this. This is true if we want to try doing the disabling. It's set
via a field trial so we can measure performance. Sound reasonable? (It's used in
the .cc file)

 
   // Size of the UDP receive buffer.
   int socket_receive_buffer_size_;
 
   // Set if we do want to delay TCP connection when it is racing with QUIC.
   bool delay_tcp_race_;
 
   // PING timeout for connections.
   QuicTime::Delta ping_timeout_;
   QuicTime::Delta reduced_ping_timeout_;
@@ skipping 56 matching lines @@
   const scoped_refptr<SSLConfigService> ssl_config_service_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_