Move QuicServerInfo management from CachedState to the QuicStreamFactory

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/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 53 matching lines @@
 // Responsible for creating a new QUIC session to the specified server, and
 // for notifying any associated requests when complete.
 class QuicStreamFactory::Job {
  public:
   Job(QuicStreamFactory* factory,
       HostResolver* host_resolver,
       const HostPortPair& host_port_pair,
       bool is_https,
       base::StringPiece method,
       CertVerifier* cert_verifier,
+      QuicServerInfo* server_info,
       const BoundNetLog& net_log);
 
   ~Job();
 
   int Run(const CompletionCallback& callback);
 
   int DoLoop(int rv);
+  int DoLoadServerInfo();
+  int DoLoadServerInfoComplete(int rv);
   int DoResolveHost();
   int DoResolveHostComplete(int rv);
   int DoConnect();
   int DoConnectComplete(int rv);
 
   void OnIOComplete(int rv);
 
   CompletionCallback callback() {
     return callback_;
   }
 
   const QuicSessionKey session_key() const {
     return session_key_;
   }
 
  private:
   enum IoState {
     STATE_NONE,
+    STATE_LOAD_SERVER_INFO,
+    STATE_LOAD_SERVER_INFO_COMPLETE,
     STATE_RESOLVE_HOST,
     STATE_RESOLVE_HOST_COMPLETE,
     STATE_CONNECT,
     STATE_CONNECT_COMPLETE,
   };
   IoState io_state_;
 
   QuicStreamFactory* factory_;
   SingleRequestHostResolver host_resolver_;
   bool is_https_;
   QuicSessionKey session_key_;
   bool is_post_;
   CertVerifier* cert_verifier_;
+  scoped_ptr<QuicServerInfo> server_info_;
   const BoundNetLog net_log_;
   QuicClientSession* session_;
   CompletionCallback callback_;
   AddressList address_list_;
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 QuicStreamFactory::Job::Job(QuicStreamFactory* factory,
                             HostResolver* host_resolver,
                             const HostPortPair& host_port_pair,
                             bool is_https,
                             base::StringPiece method,
                             CertVerifier* cert_verifier,
+                            QuicServerInfo* server_info,
                             const BoundNetLog& net_log)
     : factory_(factory),
       host_resolver_(host_resolver),
       is_https_(is_https),
       session_key_(host_port_pair, is_https),
       is_post_(method == "POST"),
       cert_verifier_(cert_verifier),
+      server_info_(server_info),
       net_log_(net_log),
       session_(NULL) {}
 
 QuicStreamFactory::Job::~Job() {
 }
 
 int QuicStreamFactory::Job::Run(const CompletionCallback& callback) {
-  io_state_ = STATE_RESOLVE_HOST;
+  io_state_ = STATE_LOAD_SERVER_INFO;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv > 0 ? OK : rv;
 }
 
 int QuicStreamFactory::Job::DoLoop(int rv) {
   do {
     IoState state = io_state_;
     io_state_ = STATE_NONE;
     switch (state) {
+      case STATE_LOAD_SERVER_INFO:
+        CHECK_EQ(OK, rv);
+        rv = DoLoadServerInfo();
+        break;
+      case STATE_LOAD_SERVER_INFO_COMPLETE:
+        rv = DoLoadServerInfoComplete(rv);
+        break;
       case STATE_RESOLVE_HOST:
         CHECK_EQ(OK, rv);
         rv = DoResolveHost();
         break;
       case STATE_RESOLVE_HOST_COMPLETE:
         rv = DoResolveHostComplete(rv);
         break;
       case STATE_CONNECT:
         CHECK_EQ(OK, rv);
         rv = DoConnect();
@@ skipping 10 matching lines @@
 }
 
 void QuicStreamFactory::Job::OnIOComplete(int rv) {
   rv = DoLoop(rv);
 
   if (rv != ERR_IO_PENDING && !callback_.is_null()) {
     callback_.Run(rv);
   }
 }
 
+int QuicStreamFactory::Job::DoLoadServerInfo() {
+  io_state_ = STATE_LOAD_SERVER_INFO_COMPLETE;
+
+  if (server_info_)
+    server_info_->Start();
+
+  return OK;
+}
+
+int QuicStreamFactory::Job::DoLoadServerInfoComplete(int rv) {
+  if (rv != OK)
+    return rv;
+
+  io_state_ = STATE_RESOLVE_HOST;
+  return OK;
+}
+
 int QuicStreamFactory::Job::DoResolveHost() {
   io_state_ = STATE_RESOLVE_HOST_COMPLETE;
   return host_resolver_.Resolve(
       HostResolver::RequestInfo(session_key_.host_port_pair()),
       DEFAULT_PRIORITY,
       &address_list_,
       base::Bind(&QuicStreamFactory::Job::OnIOComplete, base::Unretained(this)),
       net_log_);
 }
 
@@ skipping 58 matching lines @@
 
 scoped_ptr<QuicHttpStream> QuicStreamRequest::ReleaseStream() {
   DCHECK(stream_);
   return stream_.Pass();
 }
 
 int QuicStreamFactory::Job::DoConnect() {
   io_state_ = STATE_CONNECT_COMPLETE;
 
   int rv = factory_->CreateSession(session_key_.host_port_pair(), is_https_,
-      cert_verifier_, address_list_, net_log_, &session_);
+                                   cert_verifier_, server_info_.Pass(),
+                                   address_list_, net_log_, &session_);
   if (rv != OK) {
     DCHECK(rv != ERR_IO_PENDING);
     DCHECK(!session_);
     return rv;
   }
 
   session_->StartReading();
   if (!session_->connection()->connected()) {
     return ERR_QUIC_PROTOCOL_ERROR;
   }
@@ skipping 77 matching lines @@
     return OK;
   }
 
   if (HasActiveJob(session_key)) {
     Job* job = active_jobs_[session_key];
     active_requests_[request] = job;
     job_requests_map_[job].insert(request);
     return ERR_IO_PENDING;
   }
 
-  // Create crypto config and start the process of loading QUIC server
-  // information from disk cache.
-  QuicCryptoClientConfig* crypto_config = GetOrCreateCryptoConfig(session_key);
-  DCHECK(crypto_config);
-
+  QuicServerInfo* quic_server_info = NULL;
+  if (quic_server_info_factory_) {
+    QuicCryptoClientConfig* crypto_config =
+        GetOrCreateCryptoConfig(session_key);
+    QuicCryptoClientConfig::CachedState* cached =
+        crypto_config->LookupOrCreate(session_key.host_port_pair().host());
+    DCHECK(cached);
+    if (cached->IsEmpty()) {
+      quic_server_info =
+          quic_server_info_factory_->GetForHost(host_port_pair.host());
+    }
+  }
   scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_pair,
-                              is_https, method, cert_verifier, net_log));
+                              is_https, method, cert_verifier,
+                              quic_server_info, 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_[session_key] = job.release();
   }
   if (rv == OK) {
     DCHECK(HasActiveSession(session_key));
@@ skipping 191 matching lines @@
 
 bool QuicStreamFactory::HasActiveSession(
     const QuicSessionKey& session_key) const {
   return ContainsKey(active_sessions_, session_key);
 }
 
 int QuicStreamFactory::CreateSession(
     const HostPortPair& host_port_pair,
     bool is_https,
     CertVerifier* cert_verifier,
+    scoped_ptr<QuicServerInfo> server_info,
     const AddressList& address_list,
     const BoundNetLog& net_log,
     QuicClientSession** session) {
   bool enable_port_selection = enable_port_selection_;
   QuicSessionKey session_key(host_port_pair, is_https);
   if (enable_port_selection &&
       ContainsKey(gone_away_aliases_, session_key)) {
     // Disable port selection when the server is going away.
     // There is no point in trying to return to the same server, if
     // that server is no longer handling requests.
@@ skipping 59 matching lines @@
   if (http_server_properties_) {
     const HttpServerProperties::NetworkStats* stats =
         http_server_properties_->GetServerNetworkStats(host_port_pair);
     if (stats != NULL) {
       config.set_initial_round_trip_time_us(stats->rtt.InMicroseconds(),
                                             stats->rtt.InMicroseconds());
     }
   }
 
   *session = new QuicClientSession(
-      connection, socket.Pass(), writer.Pass(), this,
+      connection, socket.Pass(), writer.Pass(), this, server_info.Pass(),
       quic_crypto_client_stream_factory_, host_port_pair.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));
   }
   return OK;
 }
 
@@ skipping 17 matching lines @@
     const QuicSessionKey& session_key) {
   QuicCryptoClientConfig* crypto_config;
 
   if (ContainsKey(all_crypto_configs_, session_key)) {
     crypto_config = all_crypto_configs_[session_key];
     DCHECK(crypto_config);
   } else {
     // TODO(rtenneti): if two quic_sessions for the same host_port_pair
     // share the same crypto_config, will it cause issues?
     crypto_config = new QuicCryptoClientConfig();
-    if (quic_server_info_factory_) {
-      QuicCryptoClientConfig::CachedState* cached =
-          crypto_config->Create(session_key.host_port_pair().host(),
-                                quic_server_info_factory_);
-      DCHECK(cached);
-    }
     crypto_config->SetDefaults();
     all_crypto_configs_[session_key] = crypto_config;
     PopulateFromCanonicalConfig(session_key, crypto_config);
   }
   return crypto_config;
 }
 
 void QuicStreamFactory::PopulateFromCanonicalConfig(
     const QuicSessionKey& session_key,
     QuicCryptoClientConfig* crypto_config) {
@@ skipping 30 matching lines @@
   // as the initial CachedState for the server_hostname in crypto_config.
   crypto_config->InitializeFrom(server_hostname,
                                 canonical_host_port_pair.host(),
                                 canonical_crypto_config);
   // Update canonical version to point at the "most recent" crypto_config.
   canonical_hostname_to_origin_map_[suffix_session_key] =
       canonical_session_key;
 }
 
 }  // namespace net