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

net/quic/crypto/quic_crypto_client_config.cc

 // Copyright 2013 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/crypto/quic_crypto_client_config.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/cert_compressor.h"
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
@@ skipping 11 matching lines @@
 #include "base/win/windows_version.h"
 #endif
 
 using base::StringPiece;
 using std::map;
 using std::string;
 using std::vector;
 
 namespace net {
 
-QuicCryptoClientConfig::QuicCryptoClientConfig()
-    : quic_server_info_factory_(NULL) {
-}
-
-QuicCryptoClientConfig::QuicCryptoClientConfig(
-    QuicServerInfoFactory* quic_server_info_factory)
-    : quic_server_info_factory_(quic_server_info_factory) {
+QuicCryptoClientConfig::QuicCryptoClientConfig() {
 }
 
 QuicCryptoClientConfig::~QuicCryptoClientConfig() {
   STLDeleteValues(&cached_states_);
 }
 
 QuicCryptoClientConfig::CachedState::CachedState()
     : server_config_valid_(false),
       generation_counter_(0) {}
 
+QuicCryptoClientConfig::CachedState::CachedState(
+    scoped_ptr<QuicServerInfo> quic_server_info)
+    : server_config_valid_(false),
+      generation_counter_(0),
+      quic_server_info_(quic_server_info.Pass()) {}
+
 QuicCryptoClientConfig::CachedState::~CachedState() {}
 
-void QuicCryptoClientConfig::CachedState::LoadFromDiskCache(
-    QuicServerInfoFactory* quic_server_info_factory,
-    const string& server_hostname) {
-  DCHECK(quic_server_info_factory);
-  quic_server_info_.reset(
-      quic_server_info_factory->GetForHost(server_hostname));
-
-  // TODO(rtenneti): Need to flesh out reading data from disk cache.
-}
-
 bool QuicCryptoClientConfig::CachedState::IsComplete(QuicWallTime now) const {
   if (server_config_.empty() || !server_config_valid_) {
     return false;
   }
 
   const CryptoHandshakeMessage* scfg = GetServerConfig();
   if (!scfg) {
     // Should be impossible short of cache corruption.
     DCHECK(false);
     return false;
@@ skipping 161 matching lines @@
   // Key exchange methods.
   kexs.resize(2);
   kexs[0] = kC255;
   kexs[1] = kP256;
 
   // Authenticated encryption algorithms.
   aead.resize(1);
   aead[0] = kAESG;
 }
 
+QuicCryptoClientConfig::CachedState* QuicCryptoClientConfig::Create(
+    const string& server_hostname,
+    QuicServerInfoFactory* quic_server_info_factory) {
+  DCHECK(cached_states_.find(server_hostname) == cached_states_.end());
+  scoped_ptr<QuicServerInfo> quic_server_info;
+  if (quic_server_info_factory) {
+    quic_server_info.reset(
+        quic_server_info_factory->GetForHost(server_hostname));
+    quic_server_info->Start();
+  }
+
+  CachedState* cached = new CachedState(quic_server_info.Pass());
+  cached_states_.insert(make_pair(server_hostname, cached));
+  return cached;
+}
+
 QuicCryptoClientConfig::CachedState* QuicCryptoClientConfig::LookupOrCreate(
     const string& server_hostname) {
   map<string, CachedState*>::const_iterator it =
       cached_states_.find(server_hostname);
   if (it != cached_states_.end()) {
     return it->second;
   }
-
-  CachedState* cached = new CachedState;
-  if (quic_server_info_factory_) {
-    cached->LoadFromDiskCache(quic_server_info_factory_, server_hostname);
-  }
-  cached_states_.insert(make_pair(server_hostname, cached));
-  return cached;
+  return Create(server_hostname, NULL);
 }
 
 void QuicCryptoClientConfig::FillInchoateClientHello(
     const string& server_hostname,
     const QuicVersion preferred_version,
     const CachedState* cached,
     QuicCryptoNegotiatedParameters* out_params,
     CryptoHandshakeMessage* out) const {
   out->set_tag(kCHLO);
   out->set_minimum_size(kClientHelloMinimumSize);
@@ skipping 401 matching lines @@
   CachedState* canonical_cached =
       canonical_crypto_config->LookupOrCreate(canonical_server_hostname);
   if (!canonical_cached->proof_valid()) {
     return;
   }
   CachedState* cached = LookupOrCreate(server_hostname);
   cached->InitializeFrom(*canonical_cached);
 }
 
 }  // namespace net