QUIC - Race two connections. One connection which loads data from disk

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 <list>
 #include <map>
 #include <string>
@@ skipping 160 matching lines @@
   bool has_quic_server_info_factory() {
     return quic_server_info_factory_ != NULL;
   }
 
   void set_quic_server_info_factory(
       QuicServerInfoFactory* quic_server_info_factory) {
     DCHECK(!quic_server_info_factory_);
     quic_server_info_factory_ = quic_server_info_factory;
   }
 
+  bool enable_connection_racing() const { return enable_connection_racing_; }
+  void set_enable_connection_racing(bool enable_connection_racing) {
+    enable_connection_racing_ = enable_connection_racing;
+  }
+
  private:
   class Job;
   friend class test::QuicStreamFactoryPeer;
 
   // The key used to find session by ip. Includes
   // the ip address, port, and scheme.
   struct NET_EXPORT_PRIVATE IpAliasKey {
     IpAliasKey();
     IpAliasKey(IPEndPoint ip_endpoint, bool is_https);
     ~IpAliasKey();
 
     IPEndPoint ip_endpoint;
     bool is_https;
 
     // Needed to be an element of std::set.
     bool operator<(const IpAliasKey &other) const;
     bool operator==(const IpAliasKey &other) const;
   };
 
   typedef std::map<QuicServerId, QuicClientSession*> SessionMap;
   typedef std::map<QuicClientSession*, QuicServerId> SessionIdMap;
   typedef std::set<QuicServerId> AliasSet;
   typedef std::map<QuicClientSession*, AliasSet> SessionAliasMap;
   typedef std::set<QuicClientSession*> SessionSet;
   typedef std::map<IpAliasKey, SessionSet> IPAliasMap;
   typedef std::map<QuicServerId, QuicCryptoClientConfig*> CryptoConfigMap;
-  typedef std::map<QuicServerId, Job*> JobMap;
-  typedef std::map<QuicStreamRequest*, Job*> RequestMap;
+  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<Job*, RequestSet> JobRequestsMap;
+  typedef std::map<QuicServerId, RequestSet> ServerIDRequestsMap;
+
+  // 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,
+                         bool is_post,
+                         const BoundNetLog& net_log);
 
   // Returns a newly created QuicHttpStream owned by the caller, if a
   // matching session already exists.  Returns NULL otherwise.
   scoped_ptr<QuicHttpStream> CreateIfSessionExists(const QuicServerId& key,
                                                    const BoundNetLog& net_log);
 
   bool OnResolution(const QuicServerId& server_id,
                     const AddressList& address_list);
   void OnJobComplete(Job* job, int rv);
   bool HasActiveSession(const QuicServerId& server_id) const;
   bool HasActiveJob(const QuicServerId& server_id) const;
   int CreateSession(const QuicServerId& server_id,
                     scoped_ptr<QuicServerInfo> quic_server_info,
                     const AddressList& address_list,
                     const BoundNetLog& net_log,
                     QuicClientSession** session);
   void ActivateSession(const QuicServerId& key,
                        QuicClientSession* session);
 
   // Returns |srtt| in micro seconds from ServerNetworkStats. Returns 0 if there
   // is no |http_server_properties_| or if |http_server_properties_| doesn't
   // have ServerNetworkStats for the given |server_id|.
   int64 GetServerNetworkStatsSmoothedRttInMicroseconds(
       const QuicServerId& server_id) const;
 
+  // Helped methods.
+  bool WasAlternateProtocolRecentlyBroken(const QuicServerId& server_id) const;
+  bool CryptoConfigCacheIsEmpty(const QuicServerId& server_id);
+
   // Initializes the cached state associated with |server_id| in
   // |crypto_config_| with the information in |server_info|.
   void InitializeCachedStateInCryptoConfig(
       const QuicServerId& server_id,
       const scoped_ptr<QuicServerInfo>& server_info);
 
   void ProcessGoingAwaySession(QuicClientSession* session,
                                const QuicServerId& server_id,
                                bool was_session_active);
 
@@ skipping 21 matching lines @@
   // Map from IP address to sessions which are connected to this address.
   IPAliasMap ip_aliases_;
 
   // Origins which have gone away recently.
   AliasSet gone_away_aliases_;
 
   const QuicConfig config_;
   QuicCryptoClientConfig crypto_config_;
 
   JobMap active_jobs_;
-  JobRequestsMap job_requests_map_;
+  ServerIDRequestsMap job_requests_map_;
   RequestMap active_requests_;
 
   QuicVersionVector supported_versions_;
 
   // Determine if we should consistently select a client UDP port. If false,
   // then we will just let the OS select a random client port for each new
   // connection.
   bool enable_port_selection_;
 
   // Set if we always require handshake confirmation. If true, this will
@@ skipping 10 matching lines @@
 
   // 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 this for setting config's BytesForConnectionIdToSend (TCID param) to 0.
   bool enable_truncated_connection_ids_;
 
+  // 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_;
+
   // Each profile will (probably) have a unique port_seed_ value.  This value is
   // used to help seed a pseudo-random number generator (PortSuggester) so that
   // we consistently (within this profile) suggest the same ephemeral port when
   // we re-connect to any given server/port.  The differences between profiles
   // (probablistically) prevent two profiles from colliding in their ephemeral
   // port requests.
   uint64 port_seed_;
 
   // Local address of socket that was created in CreateSession.
   IPEndPoint local_address_;
   bool check_persisted_supports_quic_;
   std::set<HostPortPair> quic_supported_servers_at_startup_;
 
   base::TaskRunner* task_runner_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_