Move QuicServerInfo management from CachedState to the QuicStreamFactory

net/quic/quic_crypto_client_stream.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_crypto_client_stream.h"
 
 #include "base/metrics/histogram.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/crypto_protocol.h"
@@ skipping 47 matching lines @@
   stream_->DoHandshakeLoop(NULL);
 
   // The ProofVerifier owns this object and will delete it when this method
   // returns.
 }
 
 void QuicCryptoClientStream::ProofVerifierCallbackImpl::Cancel() {
   stream_ = NULL;
 }
 
-
 QuicCryptoClientStream::QuicCryptoClientStream(
     const string& server_hostname,
     QuicSession* session,
     QuicCryptoClientConfig* crypto_config)
     : QuicCryptoStream(session),
       next_state_(STATE_IDLE),
       num_client_hellos_(0),
       crypto_config_(crypto_config),
       server_hostname_(server_hostname),
       generation_counter_(0),
@@ skipping 192 matching lines @@
             &crypto_negotiated_params_, &error_details);
         if (error != QUIC_NO_ERROR) {
           CloseConnectionWithDetails(error, error_details);
           return;
         }
         if (!cached->proof_valid()) {
           ProofVerifier* verifier = crypto_config_->proof_verifier();
           if (!verifier) {
             // If no verifier is set then we don't check the certificates.
             cached->SetProofValid();
+            SaveQuicServerInfo(*cached);
           } else if (!cached->signature().empty()) {
             next_state_ = STATE_VERIFY_PROOF;
             break;
           }
         }
         next_state_ = STATE_SEND_CHLO;
         break;
       case STATE_VERIFY_PROOF: {
         ProofVerifier* verifier = crypto_config_->proof_verifier();
         DCHECK(verifier);
@@ skipping 34 matching lines @@
               QUIC_PROOF_INVALID, "Proof invalid: " + verify_error_details_);
           return;
         }
         // Check if generation_counter has changed between STATE_VERIFY_PROOF
         // and STATE_VERIFY_PROOF_COMPLETE state changes.
         if (generation_counter_ != cached->generation_counter()) {
           next_state_ = STATE_VERIFY_PROOF;
         } else {
           cached->SetProofValid();
           cached->SetProofVerifyDetails(verify_details_.release());
+          SaveQuicServerInfo(*cached);
           next_state_ = STATE_SEND_CHLO;
         }
         break;
       case STATE_RECV_SHLO: {
         // We sent a CHLO that we expected to be accepted and now we're hoping
         // for a SHLO from the server to confirm that.
         if (in->tag() == kREJ) {
           // alternative_decrypter will be NULL if the original alternative
           // decrypter latched and became the primary decrypter. That happens
           // if we received a message encrypted with the INITIAL key.
@@ skipping 63 matching lines @@
   }
 }
 
 void QuicCryptoClientStream::OnIOComplete(int result) {
   DCHECK_EQ(STATE_LOAD_QUIC_SERVER_INFO_COMPLETE, next_state_);
   DCHECK_NE(ERR_IO_PENDING, result);
   disk_cache_load_result_ = result;
   DoHandshakeLoop(NULL);
 }
 
+void QuicCryptoClientStream::SetQuicServerInfo(
+    scoped_ptr<QuicServerInfo> server_info) {
+  quic_server_info_.reset(server_info.release());
+}
+
 int QuicCryptoClientStream::DoLoadQuicServerInfo(
     QuicCryptoClientConfig::CachedState* cached) {
   next_state_ = STATE_SEND_CHLO;
-  QuicServerInfo* quic_server_info = cached->quic_server_info();
-  if (!quic_server_info) {
+  if (!quic_server_info_) {
     return OK;
   }
 
   disk_cache_load_start_time_ = base::TimeTicks::Now();
   generation_counter_ = cached->generation_counter();
   next_state_ = STATE_LOAD_QUIC_SERVER_INFO_COMPLETE;
 
   // TODO(rtenneti): Use host:port to access QUIC server information from disk
   // cache. If multiple tabs load URLs with same hostname but different
   // ports, all requests except for the first request send InchoateClientHello.
   // Fix the code to handle multiple requests. A possible solution is to wait
   // for the first request to finish and use the data from the disk cache for
   // all requests.
   // We may need to call quic_server_info->Persist later.
   // quic_server_info->Persist requires quic_server_info to be ready, so we
   // always call WaitForDataReady, even though we might have initialized
   // |cached| config from the cached state for a canonical hostname.
-  int rv = quic_server_info->WaitForDataReady(
+  int rv = quic_server_info_->WaitForDataReady(
       base::Bind(&QuicCryptoClientStream::OnIOComplete,
                  weak_factory_.GetWeakPtr()));
 
   if (rv != ERR_IO_PENDING) {
     disk_cache_load_result_ = rv;
   }
   return rv;
 }
 
 void QuicCryptoClientStream::DoLoadQuicServerInfoComplete(
     QuicCryptoClientConfig::CachedState* cached) {
   LoadQuicServerInfo(cached);
-  QuicServerInfo::State* state = cached->quic_server_info()->mutable_state();
+  QuicServerInfo::State* state = quic_server_info_->mutable_state();
   state->Clear();
 }
 
 void QuicCryptoClientStream::LoadQuicServerInfo(
     QuicCryptoClientConfig::CachedState* cached) {
   next_state_ = STATE_SEND_CHLO;
 
   // If someone else already saved a server config, we don't want to overwrite
   // it. Also, if someone else saved a server config and then cleared it (so
   // cached->IsEmpty() is true), we still want to load from QuicServerInfo.
   if (!cached->IsEmpty()) {
     return;
   }
 
   UMA_HISTOGRAM_TIMES("Net.QuicServerInfo.DiskCacheReadTime",
                       base::TimeTicks::Now() - disk_cache_load_start_time_);
 
-  if (disk_cache_load_result_ != OK || !cached->LoadQuicServerInfo(
-          session()->connection()->clock()->WallNow())) {
+  if (disk_cache_load_result_ != OK ||
+      !cached->Initialize(quic_server_info_->state().server_config,
+                          quic_server_info_->state().source_address_token,
+                          quic_server_info_->state().certs,
+                          quic_server_info_->state().server_config_sig,
+                          session()->connection()->clock()->WallNow())) {
     // It is ok to proceed to STATE_SEND_CHLO when we cannot load QuicServerInfo
     // from the disk cache.
     DCHECK(cached->IsEmpty());
     DVLOG(1) << "Empty server_config";
     return;
   }
 
   ProofVerifier* verifier = crypto_config_->proof_verifier();
   if (!verifier) {
     // If no verifier is set then we don't check the certificates.
     cached->SetProofValid();
+    SaveQuicServerInfo(*cached);
   } else if (!cached->signature().empty()) {
     next_state_ = STATE_VERIFY_PROOF;
   }
 }
 
+void QuicCryptoClientStream::SaveQuicServerInfo(
+    const QuicCryptoClientConfig::CachedState& cached) {
+  DCHECK(cached.proof_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_ || !quic_server_info_->IsDataReady()) {
+    return;
+  }
+
+  QuicServerInfo::State* state = quic_server_info_->mutable_state();
+
+  state->server_config = cached.server_config();
+  state->source_address_token = cached.source_address_token();
+  state->server_config_sig = cached.signature();
+  state->certs = cached.certs();
+
+  quic_server_info_->Persist();
+}
+
 }  // namespace net