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 208 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,
     QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
     QuicRandom* random_generator,
     QuicClock* clock)
-    : host_resolver_(host_resolver),
+    : require_confirmation_(true),
+      host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       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 33 matching lines @@
   }
   if (rv == OK) {
     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 72 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