Require handshake confirmation until a QUIC connection is created succesfully when using a new netw…

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 209 matching lines @@
   return stream_.Pass();
 }
 
 int QuicStreamFactory::Job::DoConnect() {
   io_state_ = STATE_CONNECT_COMPLETE;
 
   session_ = factory_->CreateSession(host_port_proxy_pair_, is_https_,
                                      cert_verifier_, address_list_, net_log_);
   session_->StartReading();
   int rv = session_->CryptoConnect(
+      factory_->require_confirmation(),
       base::Bind(&QuicStreamFactory::Job::OnIOComplete,
                  base::Unretained(this)));
   return rv;
 }
 
 int QuicStreamFactory::Job::DoConnectComplete(int rv) {
   if (rv != OK)
     return rv;
 
   DCHECK(!factory_->HasActiveSession(host_port_proxy_pair_));
   factory_->ActivateSession(host_port_proxy_pair_, session_);
 
   return OK;
 }
 
 QuicStreamFactory::QuicStreamFactory(
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
     base::WeakPtr<HttpServerProperties> http_server_properties,
     QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
     QuicRandom* random_generator,
     QuicClock* clock)
-    : host_resolver_(host_resolver),
+    : require_confirmation_(true),

[wtc, 2013/08/21 01:09:32]

Can you explain why require_confirmation_ should be initialized to true?

I guess it's because we require confirmation for the very first connect and
the first connect after each network change?

It would be nice to document this somewhere, which will make it easier to
understand where we should set require_confirmation_ to true or false.

+      host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       http_server_properties_(http_server_properties),
       quic_crypto_client_stream_factory_(quic_crypto_client_stream_factory),
       random_generator_(random_generator),
       clock_(clock),
       weak_factory_(this) {
   config_.SetDefaults();
   config_.set_idle_connection_state_lifetime(
       QuicTime::Delta::FromSeconds(30),
       QuicTime::Delta::FromSeconds(30));
@@ skipping 25 matching lines @@
   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();
   }
   if (rv == OK) {

[wtc, 2013/08/21 01:09:32]

Should we also set require_confirmation_ to false in this case, to match
the asynchronous completion case on line 309?

     DCHECK(HasActiveSession(host_port_proxy_pair));
     request->set_stream(CreateIfSessionExists(host_port_proxy_pair, net_log));
   }
   return rv;
 }
 
 void QuicStreamFactory::OnJobComplete(Job* job, int rv) {
   if (rv == OK) {
+    require_confirmation_ = false;
     // Create all the streams, but do not notify them yet.
     for (RequestSet::iterator it = job_requests_map_[job].begin();
          it != job_requests_map_[job].end() ; ++it) {
       DCHECK(HasActiveSession(job->host_port_proxy_pair()));
       (*it)->set_stream(CreateIfSessionExists(job->host_port_proxy_pair(),
                                               (*it)->net_log()));
     }
   }
   while (!job_requests_map_[job].empty()) {
     RequestSet::iterator it = job_requests_map_[job].begin();
@@ skipping 79 matching lines @@
     const HostPortProxyPair& pair = it->first;
     const QuicClientSession* session = it->second;
 
     list->Append(session->GetInfoAsValue(pair.first));
   }
   return list;
 }
 
 void QuicStreamFactory::OnIPAddressChanged() {
   CloseAllSessions(ERR_NETWORK_CHANGED);
+  require_confirmation_ = true;
 }
 
 bool QuicStreamFactory::HasActiveSession(
     const HostPortProxyPair& host_port_proxy_pair) {
   return ContainsKey(active_sessions_, host_port_proxy_pair);
 }
 
 QuicClientSession* QuicStreamFactory::CreateSession(
     const HostPortProxyPair& host_port_proxy_pair,
     bool is_https,
@@ skipping 74 matching lines @@
     DCHECK(crypto_config);
   } else {
     crypto_config = new QuicCryptoClientConfig();
     crypto_config->SetDefaults();
     all_crypto_configs_[host_port_proxy_pair] = crypto_config;
   }
   return crypto_config;
 }
 
 }  // namespace net