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 63 matching lines @@
   // Sets |session_|.
   void SetSession(QuicChromiumClientSession* session);
 
   const QuicServerId& server_id() const { return server_id_; }
 
   const NetLogWithSource& net_log() const { return net_log_; }
 
  private:
   QuicStreamFactory* factory_;
   HttpServerProperties* http_server_properties_;
+  bool mark_quic_broken_when_network_suspected_;
   QuicServerId server_id_;
   NetLogWithSource net_log_;
   CompletionCallback callback_;
   base::WeakPtr<QuicChromiumClientSession> session_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamRequest);
 };
 
 // A factory for creating new QuicHttpStreams on top of a pool of
 // QuicChromiumClientSessions.
@@ skipping 55 matching lines @@
       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 disable_quic_on_timeout_with_open_streams,
+      bool mark_quic_broken_when_network_suspected,
       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 136 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_suspected() const {
+    return mark_quic_broken_when_network_suspected_;
+  }
+
   // 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 126 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 38 matching lines @@
   // 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 disabled when there are timeouts with open
   // streams.
   bool disable_quic_on_timeout_with_open_streams_;
 
+  // True if QUIC should be marked as broken when a stream is closed with
+  // a possibly network-caused error.
+  bool mark_quic_broken_when_network_suspected_;
+
   // Number of times in a row that QUIC has been disabled.
   int consecutive_disabled_count_;
   bool need_to_evaluate_consecutive_disabled_count_;
 
   // 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_;
 
@@ skipping 54 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_