Mark QUIC broken when the network blackholes after the handshake

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_CHROMIUM_QUIC_STREAM_FACTORY_H_
 #define NET_QUIC_CHROMIUM_QUIC_STREAM_FACTORY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 43 matching lines @@
 class CTPolicyEnforcer;
 class CertVerifier;
 class ChannelIDService;
 class ClientSocketFactory;
 class CTVerifier;
 class HostResolver;
 class HttpServerProperties;
 class NetLog;
 class ProxyDelegate;
 class QuicClock;
-class QuicChromiumAlarmFactory;
+class QuicAlarmFactory;
 class QuicChromiumConnectionHelper;
 class QuicCryptoClientStreamFactory;
 class QuicRandom;
 class QuicServerInfo;
 class QuicServerInfoFactory;
 class QuicStreamFactory;
 class SocketPerformanceWatcherFactory;
 class TransportSecurityState;
 class BidirectionalStreamImpl;
 
@@ skipping 137 matching lines @@
       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 socket_receive_buffer_size,
       bool delay_tcp_race,
       int max_server_configs_stored_in_properties,
       bool close_sessions_on_ip_change,
+      bool mark_quic_broken_when_network_blackholes,
       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,
       bool allow_server_migration,
       bool force_hol_blocking,
       bool race_cert_verification,
       bool do_not_fragment,
       bool estimate_initial_rtt,
@@ skipping 31 matching lines @@
   // 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);
 
-  // Called by a session when it times out with open streams.
-  void OnTimeoutWithOpenStreams();
+  // Called by a session when it blackholes after the handshake is confirmed.
+  void OnBlackholeAfterHandshakeConfirmed(QuicChromiumClientSession* session);
 
   // Cancels a pending request.
   void CancelRequest(QuicStreamRequest* request);
 
   // Closes all current sessions with specified network and QUIC error codes.
   void CloseAllSessions(int error, QuicErrorCode quic_error);
 
   std::unique_ptr<base::Value> QuicStreamFactoryInfoToValue() const;
 
   // Delete cached state objects in |crypto_config_|. If |origin_filter| is not
@@ skipping 80 matching lines @@
 
   void set_require_confirmation(bool require_confirmation);
 
   bool ZeroRTTEnabledFor(const QuicServerId& server_id);
 
   // It returns the amount of time waiting job should be delayed.
   base::TimeDelta GetTimeDelayForWaitingJob(const QuicServerId& server_id);
 
   QuicChromiumConnectionHelper* helper() { return helper_.get(); }
 
-  QuicChromiumAlarmFactory* alarm_factory() { return alarm_factory_.get(); }
+  QuicAlarmFactory* alarm_factory() { return alarm_factory_.get(); }
 
   bool has_quic_server_info_factory() const {
     return quic_server_info_factory_.get() != nullptr;
   }
 
   QuicServerInfoFactory* quic_server_info_factory() const {
     return quic_server_info_factory_.get();
   }
 
   void set_quic_server_info_factory(
       QuicServerInfoFactory* quic_server_info_factory);
 
   void set_server_push_delegate(ServerPushDelegate* push_delegate) {
     push_delegate_ = push_delegate;
   }
 
   bool enable_connection_racing() const { return enable_connection_racing_; }
   void set_enable_connection_racing(bool enable_connection_racing) {
     enable_connection_racing_ = enable_connection_racing;
   }
 
   int socket_receive_buffer_size() const { return socket_receive_buffer_size_; }
 
   bool delay_tcp_race() const { return delay_tcp_race_; }
 
   bool migrate_sessions_on_network_change() const {
     return migrate_sessions_on_network_change_;
   }
 
+  bool mark_quic_broken_when_network_blackholes() const {
+    return mark_quic_broken_when_network_blackholes_;
+  }
+
   // Dumps memory allocation stats. |parent_dump_absolute_name| is the name
   // used by the parent MemoryAllocatorDump in the memory dump hierarchy.
   void DumpMemoryStats(base::trace_event::ProcessMemoryDump* pmd,
                        const std::string& parent_absolute_name) const;
 
  private:
   class Job;
   class CertVerifierJob;
   friend class test::QuicStreamFactoryPeer;
 
@@ skipping 113 matching lines @@
 
   // Factory which is used to create socket performance watcher. A new watcher
   // is created for every QUIC connection.
   // |socket_performance_watcher_factory_| may be null.
   SocketPerformanceWatcherFactory* socket_performance_watcher_factory_;
 
   // The helper used for all connections.
   std::unique_ptr<QuicChromiumConnectionHelper> helper_;
 
   // The alarm factory used for all connections.
-  std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_;
+  std::unique_ptr<QuicAlarmFactory> alarm_factory_;
 
   // Contains owning pointers to all sessions that currently exist.
   SessionIdMap all_sessions_;
   // Contains non-owning pointers to currently active session
   // (not going away session, once they're implemented).
   SessionMap active_sessions_;
   // Map from session to set of aliases that this session is known by.
   SessionAliasMap session_aliases_;
   // Map from IP address to sessions which are connected to this address.
   IPAliasMap ip_aliases_;
@@ skipping 34 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_;
 
+  // True if QUIC should be marked as broken when a connection blackholes after
+  // the handshake is confirmed.
+  bool mark_quic_broken_when_network_blackholes_;
+
   // 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 47 matching lines @@
   const scoped_refptr<SSLConfigService> ssl_config_service_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_STREAM_FACTORY_H_