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

net/quic/quic_client_session.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_client_session.h"
 
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 71 matching lines @@
 QuicClientSession::QuicClientSession(
     QuicConnection* connection,
     scoped_ptr<DatagramClientSocket> socket,
     QuicStreamFactory* stream_factory,
     QuicCryptoClientStreamFactory* crypto_client_stream_factory,
     const string& server_hostname,
     const QuicConfig& config,
     QuicCryptoClientConfig* crypto_config,
     NetLog* net_log)
     : QuicSession(connection, config, false),
-      weak_factory_(this),
+      require_confirmation_(false),
       stream_factory_(stream_factory),
       socket_(socket.Pass()),
       read_buffer_(new IOBufferWithSize(kMaxPacketSize)),
       read_pending_(false),
       num_total_streams_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
-      logger_(net_log_) {
+      logger_(net_log_),
+      weak_factory_(this) {
   crypto_stream_.reset(
       crypto_client_stream_factory ?
           crypto_client_stream_factory->CreateQuicCryptoClientStream(
               server_hostname, this, crypto_config) :
           new QuicCryptoClientStream(server_hostname, this, crypto_config));
 
   connection->set_debug_visitor(&logger_);
   // TODO(rch): pass in full host port proxy pair
   net_log_.BeginEvent(
       NetLog::TYPE_QUIC_SESSION,
@@ skipping 92 matching lines @@
 
 QuicCryptoClientStream* QuicClientSession::GetCryptoStream() {
   return crypto_stream_.get();
 };
 
 bool QuicClientSession::GetSSLInfo(SSLInfo* ssl_info) {
   DCHECK(crypto_stream_.get());
   return crypto_stream_->GetSSLInfo(ssl_info);
 }
 
-int QuicClientSession::CryptoConnect(const CompletionCallback& callback) {
+int QuicClientSession::CryptoConnect(bool require_confirmation,
+                                     const CompletionCallback& callback) {
+  require_confirmation_ = require_confirmation;
   RecordHandshakeState(STATE_STARTED);
   if (!crypto_stream_->CryptoConnect()) {
     // TODO(wtc): change crypto_stream_.CryptoConnect() to return a
     // QuicErrorCode and map it to a net error code.
     return ERR_CONNECTION_FAILED;
   }
 
-  if (IsEncryptionEstablished()) {
+  bool can_notify = require_confirmation_ ?
+      IsCryptoHandshakeConfirmed() : IsEncryptionEstablished();
+  if (can_notify) {
     return OK;
   }
 
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 ReliableQuicStream* QuicClientSession::CreateIncomingReliableStream(
     QuicStreamId id) {
   DLOG(ERROR) << "Server push not supported";
@@ skipping 12 matching lines @@
     stream_requests_.pop_front();
     request->OnRequestCompleteSuccess(CreateOutgoingReliableStreamImpl());
   }
 
   if (GetNumOpenStreams() == 0) {
     stream_factory_->OnIdleSession(this);
   }
 }
 
 void QuicClientSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
-  if (!callback_.is_null()) {
+  if (!callback_.is_null() &&
+      (!require_confirmation_ || event == HANDSHAKE_CONFIRMED)) {
     // TODO(rtenneti): Currently for all CryptoHandshakeEvent events, callback_
     // could be called because there are no error events in CryptoHandshakeEvent
     // enum. If error events are added to CryptoHandshakeEvent, then the
     // following code needs to changed.
     base::ResetAndReturn(&callback_).Run(OK);
   }
   QuicSession::OnCryptoHandshakeEvent(event);

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

An unrelated question: have you thought about the order of running the
callback and calling QuicSession::OnCryptoHandshakeEvent()? Does the
order matter?

The reason I asked is that usually base::ResetAndReturn(&callback_).Run()
is the last thing we do in an OnXXXEvent method.

 }
 
 void QuicClientSession::OnCryptoHandshakeMessageSent(
     const CryptoHandshakeMessage& message) {
   logger_.OnCryptoHandshakeMessageSent(message);
 }
 
 void QuicClientSession::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& message) {
   logger_.OnCryptoHandshakeMessageReceived(message);
@@ skipping 112 matching lines @@
 }
 
 void QuicClientSession::NotifyFactoryOfSessionClose() {
   DCHECK_EQ(0u, GetNumOpenStreams());
   DCHECK(stream_factory_);
   // Will delete |this|.
   stream_factory_->OnSessionClose(this);
 }
 
 }  // namespace net