Revert of Remove the code to store and load QUIC server configs in the disk cache.

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 48 matching lines @@
 class HostResolver;
 class HttpServerProperties;
 class NetLog;
 class ProxyDelegate;
 class QuicClock;
 class QuicAlarmFactory;
 class QuicChromiumConnectionHelper;
 class QuicCryptoClientStreamFactory;
 class QuicRandom;
 class QuicServerInfo;
+class QuicServerInfoFactory;
 class QuicStreamFactory;
 class SocketPerformanceWatcherFactory;
 class TransportSecurityState;
 class BidirectionalStreamImpl;
 
 namespace test {
 class QuicStreamFactoryPeer;
 }  // namespace test
 
 // When a connection is idle for 30 seconds it will be closed.
@@ skipping 121 matching lines @@
       ChannelIDService* channel_id_service,
       TransportSecurityState* transport_security_state,
       CTVerifier* cert_transparency_verifier,
       SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
       QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
       QuicRandom* random_generator,
       QuicClock* clock,
       size_t max_packet_length,
       const std::string& user_agent_id,
       const QuicVersionVector& supported_versions,
+      float load_server_info_timeout_srtt_multiplier,
+      bool enable_connection_racing,
       bool enable_non_blocking_io,
-      bool store_server_configs_in_properties,
+      bool disable_disk_cache,
+      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,
@@ skipping 135 matching lines @@
 
   void set_require_confirmation(bool require_confirmation);
 
   // It returns the amount of time waiting job should be delayed.
   base::TimeDelta GetTimeDelayForWaitingJob(const QuicServerId& server_id);
 
   QuicChromiumConnectionHelper* helper() { return helper_.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;
+  }
+
   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.
@@ skipping 12 matching lines @@
   typedef std::set<QuicChromiumClientSession*> SessionSet;
   typedef std::map<IPEndPoint, SessionSet> IPAliasMap;
   typedef std::map<QuicChromiumClientSession*, IPEndPoint> SessionPeerIPMap;
   typedef std::map<Job*, std::unique_ptr<Job>> JobSet;
   typedef std::map<QuicServerId, JobSet> JobMap;
   typedef std::set<QuicStreamRequest*> RequestSet;
   typedef std::map<QuicServerId, RequestSet> ServerIDRequestsMap;
   typedef std::map<QuicServerId, std::unique_ptr<CertVerifierJob>>
       CertVerifierJobMap;
 
+  // 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 QuicSessionKey& key,
+                         int cert_verify_flags,
+                         const NetLogWithSource& net_log);
+
   // Returns a newly created QuicHttpStream owned by the caller.
   std::unique_ptr<QuicHttpStream> CreateFromSession(
       QuicChromiumClientSession* session);
 
   bool OnResolution(const QuicSessionKey& key, const AddressList& address_list);
   void OnJobComplete(Job* job, int rv);
   void OnCertVerifyJobComplete(CertVerifierJob* job, int rv);
   bool HasActiveSession(const QuicServerId& server_id) const;
   bool HasActiveJob(const QuicServerId& server_id) const;
   bool HasActiveCertVerifierJob(const QuicServerId& server_id) const;
   int CreateSession(const QuicSessionKey& key,
                     int cert_verify_flags,
+                    std::unique_ptr<QuicServerInfo> quic_server_info,
                     bool require_confirmation,
                     const AddressList& address_list,
                     base::TimeTicks dns_resolution_start_time,
                     base::TimeTicks dns_resolution_end_time,
                     const NetLogWithSource& net_log,
                     QuicChromiumClientSession** session);
   void ActivateSession(const QuicSessionKey& key,
                        QuicChromiumClientSession* session);
 
   void ConfigureInitialRttEstimate(const QuicServerId& server_id,
@@ skipping 25 matching lines @@
 
   // Initializes the cached state associated with |server_id| in
   // |crypto_config_| with the information in |server_info|. Populates
   // |connection_id| with the next server designated connection id,
   // if any, and otherwise leaves it unchanged.
   void InitializeCachedStateInCryptoConfig(
       const QuicServerId& server_id,
       const std::unique_ptr<QuicServerInfo>& server_info,
       QuicConnectionId* connection_id);
 
+  // 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);
 
   // Internal method that migrates |session| over to using
   // |peer_address| and |network|. If |network| is
   // kInvalidNetworkHandle, default network is used. If the migration
   // fails and |close_session_on_error| is true, connection is closed.
   MigrationResult MigrateSessionInner(
       QuicChromiumClientSession* session,
       IPEndPoint peer_address,
       NetworkChangeNotifier::NetworkHandle network,
       bool close_session_on_error,
       const NetLogWithSource& net_log);
 
   bool require_confirmation_;
   NetLog* net_log_;
   HostResolver* host_resolver_;
   ClientSocketFactory* client_socket_factory_;
   HttpServerProperties* http_server_properties_;
   ServerPushDelegate* push_delegate_;
   ProxyDelegate* proxy_delegate_;
   TransportSecurityState* transport_security_state_;
   CTVerifier* cert_transparency_verifier_;
+  std::unique_ptr<QuicServerInfoFactory> quic_server_info_factory_;
   QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory_;
   QuicRandom* random_generator_;  // Unowned.
   QuicClock* clock_;              // Unowned.
   const size_t max_packet_length_;
   QuicClockSkewDetector clock_skew_detector_;
 
   // 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_;
@@ skipping 24 matching lines @@
 
   JobMap active_jobs_;
   // Map from QuicServerId to a set of non-owning QuicStreamRequest pointers.
   ServerIDRequestsMap job_requests_map_;
 
   // Map of QuicServerId to owning CertVerifierJob.
   CertVerifierJobMap active_cert_verifier_jobs_;
 
   const QuicVersionVector supported_versions_;
 
+  // Specifies the ratio between time to load QUIC server information from disk
+  // cache to 'smoothed RTT'. This ratio is used to calculate the timeout in
+  // milliseconds to wait for loading of QUIC server information. If we don't
+  // want to timeout, set |load_server_info_timeout_srtt_multiplier_| to 0.
+  float load_server_info_timeout_srtt_multiplier_;
+
+  // Set if we want to race connections - one connection that sends
+  // INCHOATE_HELLO and another connection that sends CHLO after loading server
+  // config from the disk cache.
+  bool enable_connection_racing_;
+
   // 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_;
+
   // True if QUIC should be marked as broken when a connection blackholes after
   // the handshake is confirmed.
   bool mark_quic_broken_when_network_blackholes_;
 
-  // Set if QUIC server configs should be stored in HttpServerProperties.
-  bool store_server_configs_in_properties_;
-
   // PING timeout for connections.
   QuicTime::Delta ping_timeout_;
   QuicTime::Delta reduced_ping_timeout_;
 
   // If more than |yield_after_packets_| packets have been read or more than
   // |yield_after_duration_| time has passed, then
   // QuicChromiumPacketReader::StartReading() yields by doing a PostTask().
   int yield_after_packets_;
   QuicTime::Delta yield_after_duration_;
 
@@ skipping 20 matching lines @@
 
   // If set, configure QUIC sockets to not fragment packets.
   bool do_not_fragment_;
 
   // If true, estimate the initial RTT based on network type.
   bool estimate_initial_rtt;
 
   // Local address of socket that was created in CreateSession.
   IPEndPoint local_address_;
   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_;
 
   base::TaskRunner* task_runner_;
 
   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_