QUIC: retransmit packets with the correct encryption.

net/quic/quic_client_session_test.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 <vector>
 
 #include "base/stl_util.h"
 #include "net/base/capturing_net_log.h"
@@ skipping 68 matching lines @@
     streams.push_back(stream);
   }
   EXPECT_FALSE(session_.CreateOutgoingReliableStream());
 
   // Close a stream and ensure I can now open a new one.
   session_.CloseStream(streams[0]->id());
   EXPECT_TRUE(session_.CreateOutgoingReliableStream());
 }
 
 TEST_F(QuicClientSessionTest, GoAwayReceived) {
-  // Initialize crypto before the client session will create a stream.
-  ASSERT_TRUE(session_.CryptoConnect(callback_.callback()));
-  // Simulate the server crypto handshake.
-  CryptoHandshakeMessage server_message;
-  server_message.set_tag(kSHLO);
-  session_.GetCryptoStream()->OnHandshakeMessage(server_message);
+  if (!Aes128GcmEncrypter::IsSupported()) {
+    LOG(INFO) << "AES GCM not supported. Test skipped.";
+    return;
+  }
+
+  CompleteCryptoHandshake();
 
   // After receiving a GoAway, I should no longer be able to create outgoing
   // streams.
   session_.OnGoAway(QuicGoAwayFrame(QUIC_PEER_GOING_AWAY, 1u, "Going away."));
   EXPECT_EQ(NULL, session_.CreateOutgoingReliableStream());
 }
 
 TEST_F(QuicClientSessionTest, Logging) {
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   CompleteCryptoHandshake();
 
   // TODO(rch): Add some helper methods to simplify packet creation in tests.
   // Receive a packet, and verify that it was logged.
-  QuicFramer framer(kQuicVersion1,
-                    QuicDecrypter::Create(kNULL),
-                    QuicEncrypter::Create(kNULL),
-                    QuicTime::Zero(),
-                    false);
+  QuicFramer framer(kQuicVersion1, QuicTime::Zero(), false);
   QuicRstStreamFrame frame;
   frame.stream_id = 2;
   frame.error_code = QUIC_STREAM_CONNECTION_ERROR;
   frame.error_details = "doh!";
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&frame));
   QuicPacketHeader header;
   header.public_header.guid = 1;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_sequence_number = 1;
   header.entropy_flag = false;
   header.fec_flag = false;
   header.fec_entropy_flag = false;
   header.fec_group = 0;
   scoped_ptr<QuicPacket> p(
       framer.ConstructFrameDataPacket(header, frames).packet);
-  scoped_ptr<QuicEncryptedPacket> packet(framer.EncryptPacket(1, *p));
+  scoped_ptr<QuicEncryptedPacket> packet(framer.EncryptPacket(
+      ENCRYPTION_NONE, 1, *p));
   IPAddressNumber ip;
   CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
   IPEndPoint peer_addr = IPEndPoint(ip, 443);
   IPEndPoint self_addr = IPEndPoint(ip, 8435);
 
   connection_->ProcessUdpPacketInternal(self_addr, peer_addr, *packet);
 
   // Check that the NetLog was filled reasonably.
   net::CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
@@ skipping 20 matching lines @@
   ASSERT_TRUE(entries[pos].GetIntegerValue("error_code", &error_code));
   EXPECT_EQ(frame.error_code, static_cast<QuicRstStreamErrorCode>(error_code));
   std::string details;
   ASSERT_TRUE(entries[pos].GetStringValue("details", &details));
   EXPECT_EQ(frame.error_details, details);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net