When QUIC is disabled because of timeouts with open streams, re-enable

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 170 matching lines @@
   // 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 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);
+  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;
 
   // Called by a session when it becomes idle.
@@ skipping 122 matching lines @@
   typedef std::map<IPEndPoint, 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 QuicChromiumClientSession::QuicDisabledReason>
       DisabledReasonsQueue;
 
+  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
   // 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(
@@ skipping 39 matching lines @@
   // 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);
+
   bool require_confirmation_;
   HostResolver* host_resolver_;
   ClientSocketFactory* client_socket_factory_;
   base::WeakPtr<HttpServerProperties> http_server_properties_;
   TransportSecurityState* transport_security_state_;
   CTVerifier* cert_transparency_verifier_;
   scoped_ptr<QuicServerInfoFactory> quic_server_info_factory_;
   QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory_;
   QuicRandom* random_generator_;
   scoped_ptr<QuicClock> clock_;
@@ skipping 122 matching lines @@
   bool check_persisted_supports_quic_;
   bool has_initialized_data_;
   std::set<HostPortPair> quic_supported_servers_at_startup_;
 
   NetworkConnection network_connection_;
 
   int num_push_streams_created_;
 
   QuicClientPushPromiseIndex push_promise_index_;
 
+  // Current status of the factory's ability to create streams.
+  FactoryStatus status_;
+
   base::TaskRunner* task_runner_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_