Move QuicServerInfo management from CachedState to the QuicStreamFactory

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"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/curve25519_key_exchange.h"
 #include "net/quic/crypto/key_exchange.h"
 #include "net/quic/crypto/p256_key_exchange.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/crypto/quic_encrypter.h"
-#include "net/quic/crypto/quic_server_info.h"
 #include "net/quic/quic_utils.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using base::StringPiece;
 using std::map;
 using std::string;
 using std::vector;
 
 namespace net {
 
 QuicCryptoClientConfig::QuicCryptoClientConfig() {}
 
 QuicCryptoClientConfig::~QuicCryptoClientConfig() {
   STLDeleteValues(&cached_states_);
 }
 
 QuicCryptoClientConfig::CachedState::CachedState()
     : server_config_valid_(false),
-      need_to_persist_(false),
       generation_counter_(0) {}
 
-QuicCryptoClientConfig::CachedState::CachedState(
-    scoped_ptr<QuicServerInfo> quic_server_info)
-    : server_config_valid_(false),
-      need_to_persist_(false),
-      generation_counter_(0),
-      quic_server_info_(quic_server_info.Pass()) {}
-
 QuicCryptoClientConfig::CachedState::~CachedState() {}
 
 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.
@@ skipping 56 matching lines @@
 
   if (now.ToUNIXSeconds() >= expiry_seconds) {
     *error_details = "SCFG has expired";
     return QUIC_CRYPTO_SERVER_CONFIG_EXPIRED;
   }
 
   if (!matches_existing) {
     server_config_ = server_config.as_string();
     SetProofInvalid();
     scfg_.reset(new_scfg_storage.release());
-    need_to_persist_ = true;
   }
   return QUIC_NO_ERROR;
 }
 
 void QuicCryptoClientConfig::CachedState::InvalidateServerConfig() {
   server_config_.clear();
   scfg_.reset();
   SetProofInvalid();
 }
 
@@ skipping 22 matching lines @@
 }
 
 void QuicCryptoClientConfig::CachedState::ClearProof() {
   SetProofInvalid();
   certs_.clear();
   server_config_sig_.clear();
 }
 
 void QuicCryptoClientConfig::CachedState::SetProofValid() {
   server_config_valid_ = true;
-  SaveQuicServerInfo();
 }
 
 void QuicCryptoClientConfig::CachedState::SetProofInvalid() {
   server_config_valid_ = false;
   ++generation_counter_;
 }
 
+bool QuicCryptoClientConfig::CachedState::Initialize(
+    StringPiece server_config,
+    StringPiece signature,
+    StringPiece source_address_token,
+    const vector<string>& certs,
+    QuicWallTime now) {
+  DCHECK(server_config_.empty());
+
+  if (server_config.empty()) {
+    return false;
+  }
+
+  string error_details;
+  QuicErrorCode error = SetServerConfig(server_config, now,
+                                        &error_details);
+  if (error != QUIC_NO_ERROR) {
+    DVLOG(1) << "SetServerConfig failed with " << error_details;
+    return false;
+  }
+
+  signature.CopyToString(&server_config_sig_);
+  source_address_token.CopyToString(&source_address_token_);
+  certs_ = certs;
+  return true;
+}
+
 const string& QuicCryptoClientConfig::CachedState::server_config() const {
   return server_config_;
 }
 
 const string&
 QuicCryptoClientConfig::CachedState::source_address_token() const {
   return source_address_token_;
 }
 
 const vector<string>& QuicCryptoClientConfig::CachedState::certs() const {
@@ skipping 10 matching lines @@
 
 uint64 QuicCryptoClientConfig::CachedState::generation_counter() const {
   return generation_counter_;
 }
 
 const ProofVerifyDetails*
 QuicCryptoClientConfig::CachedState::proof_verify_details() const {
   return proof_verify_details_.get();
 }
 
-QuicServerInfo* QuicCryptoClientConfig::CachedState::quic_server_info() const {
-  return quic_server_info_.get();
-}
-
 void QuicCryptoClientConfig::CachedState::set_source_address_token(
     StringPiece token) {
   source_address_token_ = token.as_string();
 }
 
 void QuicCryptoClientConfig::CachedState::SetProofVerifyDetails(
     ProofVerifyDetails* details) {
   proof_verify_details_.reset(details);
 }
 
 void QuicCryptoClientConfig::CachedState::InitializeFrom(
     const QuicCryptoClientConfig::CachedState& other) {
   DCHECK(server_config_.empty());
   DCHECK(!server_config_valid_);
   server_config_ = other.server_config_;
   source_address_token_ = other.source_address_token_;
   certs_ = other.certs_;
   server_config_sig_ = other.server_config_sig_;
   server_config_valid_ = other.server_config_valid_;
   ++generation_counter_;
 }
 
-// An issue to be solved: while we are loading the data from disk cache, it is
-// possible for another request for the same hostname update the CachedState
-// because that request has sent FillInchoateClientHello and got REJ message.
-// Loading of data from disk cache shouldn't blindly overwrite what is in
-// CachedState.
-bool QuicCryptoClientConfig::CachedState::LoadQuicServerInfo(QuicWallTime now) {
-  DCHECK(server_config_.empty());
-  DCHECK(quic_server_info_.get());
-  DCHECK(quic_server_info_->IsDataReady());
-
-  const QuicServerInfo::State& state(quic_server_info_->state());
-  if (state.server_config.empty()) {
-    return false;
-  }
-
-  string error_details;
-  QuicErrorCode error = SetServerConfig(state.server_config, now,
-                                        &error_details);
-  if (error != QUIC_NO_ERROR) {
-    DVLOG(1) << "SetServerConfig failed with " << error_details;
-    return false;
-  }
-
-  source_address_token_ = state.source_address_token;
-  server_config_sig_ = state.server_config_sig;
-  certs_ = state.certs;
-  need_to_persist_ = false;
-  return true;
-}
-
-void QuicCryptoClientConfig::CachedState::SaveQuicServerInfo() {
-  if (!quic_server_info_.get() || !need_to_persist_) {
-    return;
-  }
-  DCHECK(server_config_valid_);
-
-  // If the QuicServerInfo hasn't managed to load from disk yet then we can't
-  // save anything. TODO(rtenneti): we should fix this.
-  if (!quic_server_info_->IsDataReady()) {
-    return;
-  }
-
-  QuicServerInfo::State* state = quic_server_info_->mutable_state();
-
-  state->server_config = server_config_;
-  state->source_address_token = source_address_token_;
-  state->server_config_sig = server_config_sig_;
-  state->certs = certs_;
-
-  quic_server_info_->Persist();
-  need_to_persist_ = false;
-}
-
 void QuicCryptoClientConfig::SetDefaults() {
   // 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;
   }
-  return Create(server_hostname, NULL);
+
+  CachedState* cached = new CachedState;
+  cached_states_.insert(make_pair(server_hostname, cached));
+  return cached;
 }
 
 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 396 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