QUIC: retransmit packets with the correct encryption.

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/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 37 matching lines @@
       NetLog::TYPE_QUIC_SESSION,
       NetLog::StringCallback("host", &server_hostname));
 }
 
 QuicClientSession::~QuicClientSession() {
   connection()->set_debug_visitor(NULL);
   net_log_.EndEvent(NetLog::TYPE_QUIC_SESSION);
 }
 
 QuicReliableClientStream* QuicClientSession::CreateOutgoingReliableStream() {
-  if (!crypto_stream_->handshake_complete()) {
-    DLOG(INFO) << "Crypto handshake not complete, no outgoing stream created.";
+  if (!crypto_stream_->encryption_established()) {
+    DLOG(INFO) << "Encryption not active so no outgoing stream created.";
     return NULL;
   }
   if (GetNumOpenStreams() >= get_max_open_streams()) {
     DLOG(INFO) << "Failed to create a new outgoing stream. "
                << "Already " << GetNumOpenStreams() << " open.";
     return NULL;
   }
   if (goaway_received()) {
     DLOG(INFO) << "Failed to create a new outgoing stream. "
                << "Already received goaway.";
@@ skipping 10 matching lines @@
   return crypto_stream_.get();
 };
 
 int QuicClientSession::CryptoConnect(const CompletionCallback& callback) {
   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 (IsCryptoHandshakeComplete()) {
+  if (IsCryptoHandshakeConfirmed()) {
     return OK;
   }
 
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 ReliableQuicStream* QuicClientSession::CreateIncomingReliableStream(
     QuicStreamId id) {
   DLOG(ERROR) << "Server push not supported";
   return NULL;
 }
 
 void QuicClientSession::CloseStream(QuicStreamId stream_id) {
   QuicSession::CloseStream(stream_id);
 
   if (GetNumOpenStreams() == 0) {
     stream_factory_->OnIdleSession(this);
   }
 }
 
-void QuicClientSession::OnCryptoHandshakeComplete(QuicErrorCode error) {
+void QuicClientSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   if (!callback_.is_null()) {
-    callback_.Run(error == QUIC_NO_ERROR ? OK : ERR_UNEXPECTED);
+    // TODO(rtenneti): how should we handle ENCRYPTION_FIRST_ESTABLISHED event?

[wtc, 2013/04/25 00:39:19]

I don't understand this TODO comment. Could you elaborate?

The internal version of this file doesn't have the
QuicClientSession::OnCryptoHandshakeEvent() method. So I
don't know what this method should look like.

[Ryan Hamilton, 2013/04/25 17:59:45]

I believe we should handle this even by executing the callback.  When encryption
is first established, we "pretend" that we are connected and allow for data to
be sent.  This is the 0RTT case, right?

Sounds like we perhaps need a unit test of QuicClientSession to demonstrate the
0RTT handshake, what do you think?

[ramant (doing other things), 2013/04/26 19:29:54]

Will upload a separate CL for unit test of 0RTT.
Done.

+    callback_.Run(event == ENCRYPTION_REESTABLISHED ? ERR_UNEXPECTED : OK);
   }
 }
 
 void QuicClientSession::StartReading() {
   if (read_pending_) {
     return;
   }
   read_pending_ = true;
   int rv = socket_->Read(read_buffer_, read_buffer_->size(),
                          base::Bind(&QuicClientSession::OnReadComplete,
@@ skipping 51 matching lines @@
     connection()->ProcessUdpPacket(local_address, peer_address, packet);
     if (!connection()->connected()) {
       stream_factory_->OnSessionClose(this);
       return;
     }
     StartReading();
   }
 }
 
 }  // namespace net