QUIC - Start the process for reading crypto config data from disk cache

net/quic/quic_stream_factory.cc

 // 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.
 
 #include "net/quic/quic_stream_factory.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 309 matching lines @@
     return OK;
   }
 
   if (HasActiveJob(host_port_proxy_pair)) {
     Job* job = active_jobs_[host_port_proxy_pair];
     active_requests_[request] = job;
     job_requests_map_[job].insert(request);
     return ERR_IO_PENDING;
   }
 
+  QuicCryptoClientConfig* crypto_config =
+      GetOrCreateCryptoConfig(host_port_proxy_pair);
+  DCHECK(crypto_config);

[wtc, 2014/02/04 01:37:02]

Please add a comment to explain why we are doing this, because we ignore the
return value of GetOrCreateCryptoConfig.

[ramant (doing other things), 2014/02/04 19:23:53]

Added a comment about why we are starting this process early.

Done.

+
   scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_proxy_pair,
                               is_https, cert_verifier, net_log));
   int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
                                base::Unretained(this), job.get()));
 
   if (rv == ERR_IO_PENDING) {
     active_requests_[request] = job.get();
     job_requests_map_[job.get()].insert(request);
     active_jobs_[host_port_proxy_pair] = job.release();
   }
@@ skipping 217 matching lines @@
         base::MessageLoop::current()->message_loop_proxy().get(),
         clock_.get(), random_generator_));
   }
 
   QuicConnection* connection = new QuicConnection(guid, addr, helper_.get(),
                                                   writer.get(), false,
                                                   supported_versions_);
   writer->SetConnection(connection);
   connection->options()->max_packet_length = max_packet_length_;
 
+  DCHECK(ContainsKey(all_crypto_configs_, host_port_proxy_pair));
   QuicCryptoClientConfig* crypto_config =
-      GetOrCreateCryptoConfig(host_port_proxy_pair);
+      all_crypto_configs_[host_port_proxy_pair];

[ramant (doing other things), 2014/02/04 19:23:53]

Undid this change. GetOrCreateCryptoConfig is called when we create the Request
before we call CreateSession. The second call to GetOrCreateCryptoConfig
executes the same code as lines 571 through 573.

   DCHECK(crypto_config);
 
   *session = new QuicClientSession(
       connection, socket.Pass(), writer.Pass(), this,
       quic_crypto_client_stream_factory_, host_port_proxy_pair.first.host(),
       config_, crypto_config, net_log.net_log());
   all_sessions_.insert(*session);  // owning pointer
   if (is_https) {
     crypto_config->SetProofVerifier(
         new ProofVerifierChromium(cert_verifier, net_log));
@@ skipping 20 matching lines @@
 QuicCryptoClientConfig* QuicStreamFactory::GetOrCreateCryptoConfig(
     const HostPortProxyPair& host_port_proxy_pair) {
   QuicCryptoClientConfig* crypto_config;
 
   if (ContainsKey(all_crypto_configs_, host_port_proxy_pair)) {
     crypto_config = all_crypto_configs_[host_port_proxy_pair];
     DCHECK(crypto_config);
   } else {
     // TODO(rtenneti): if two quic_sessions for the same host_port_proxy_pair
     // share the same crypto_config, will it cause issues?
-    crypto_config = new QuicCryptoClientConfig(quic_server_info_factory_);
+    crypto_config = new QuicCryptoClientConfig();
+    if (quic_server_info_factory_) {
+      QuicCryptoClientConfig::CachedState* cached =
+          crypto_config->CreateCachedState(host_port_proxy_pair.first.host(),
+                                           quic_server_info_factory_);
+      DCHECK(cached);
+    }
     crypto_config->SetDefaults();
     all_crypto_configs_[host_port_proxy_pair] = crypto_config;
     PopulateFromCanonicalConfig(host_port_proxy_pair, crypto_config);
   }
   return crypto_config;
 }
 
 void QuicStreamFactory::PopulateFromCanonicalConfig(
     const HostPortProxyPair& host_port_proxy_pair,
     QuicCryptoClientConfig* crypto_config) {
@@ skipping 27 matching lines @@
   // Copy the CachedState for the canonical server from canonical_crypto_config
   // as the initial CachedState for the server_hostname in crypto_config.
   crypto_config->InitializeFrom(server_hostname,
                                 canonical_host_port_proxy_pair.first.host(),
                                 canonical_crypto_config);
   // Update canonical version to point at the "most recent" crypto_config.
   canonical_hostname_to_origin_map_[canonical_host_port] = host_port_proxy_pair;
 }
 
 }  // namespace net