QUIC: retransmit packets with the correct encryption.

net/quic/test_tools/crypto_test_utils.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/test_tools/crypto_test_utils.h"
 
 #include "base/strings/string_piece.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/crypto_server_config.h"
 #include "net/quic/crypto/quic_decrypter.h"
@@ skipping 91 matching lines @@
 
 }  // anonymous namespace
 
 // static
 void CryptoTestUtils::CommunicateHandshakeMessages(
     PacketSavingConnection* a_conn,
     QuicCryptoStream* a,
     PacketSavingConnection* b_conn,
     QuicCryptoStream* b) {
   size_t a_i = 0, b_i = 0;
-  while (!a->handshake_complete()) {
+  while (!a->handshake_confirmed()) {
     ASSERT_GT(a_conn->packets_.size(), a_i);
     LOG(INFO) << "Processing " << a_conn->packets_.size() - a_i
               << " packets a->b";
     MovePackets(a_conn, &a_i, b);
 
     ASSERT_GT(b_conn->packets_.size(), b_i);
     LOG(INFO) << "Processing " << b_conn->packets_.size() - b_i
               << " packets b->a";
     if (b_conn->packets_.size() - b_i == 2) {
       LOG(INFO) << "here";
@@ skipping 87 matching lines @@
   CryptoTagValueMap::const_iterator it = message.tag_value_map().find(tag);
   if (it == message.tag_value_map().end()) {
     return string();
   }
   return it->second;
 }
 
 void CryptoTestUtils::CompareClientAndServerKeys(
     QuicCryptoClientStream* client,
     QuicCryptoServerStream* server) {
-  StringPiece client_encrypter_key =
-      client->session()->connection()->encrypter()->GetKey();
-  StringPiece client_encrypter_iv =
-      client->session()->connection()->encrypter()->GetNoncePrefix();
-  StringPiece client_decrypter_key =
-      client->session()->connection()->decrypter()->GetKey();
-  StringPiece client_decrypter_iv =
-      client->session()->connection()->decrypter()->GetNoncePrefix();
-  StringPiece server_encrypter_key =
-      server->session()->connection()->encrypter()->GetKey();
-  StringPiece server_encrypter_iv =
-      server->session()->connection()->encrypter()->GetNoncePrefix();
-  StringPiece server_decrypter_key =
-      server->session()->connection()->decrypter()->GetKey();
-  StringPiece server_decrypter_iv =
-      server->session()->connection()->decrypter()->GetNoncePrefix();
+  const QuicEncrypter* client_encrypter(
+      client->session()->connection()->encrypter(ENCRYPTION_INITIAL));
+  // Normally we would expect the client's INITIAL decrypter to have latched
+  // from the receipt of the server hello. However, when using a
+  // PacketSavingConnection (at the tests do) we don't actually encrypt with
+  // the correct encrypter.
+  // TODO(agl): make the tests more realistic.
+  const QuicDecrypter* client_decrypter(
+      client->session()->connection()->alternative_decrypter());
+  const QuicEncrypter* server_encrypter(
+      server->session()->connection()->encrypter(ENCRYPTION_INITIAL));
+  const QuicDecrypter* server_decrypter(
+      server->session()->connection()->decrypter());
+
+  StringPiece client_encrypter_key = client_encrypter->GetKey();
+  StringPiece client_encrypter_iv = client_encrypter->GetNoncePrefix();
+  StringPiece client_decrypter_key = client_decrypter->GetKey();
+  StringPiece client_decrypter_iv = client_decrypter->GetNoncePrefix();
+  StringPiece server_encrypter_key = server_encrypter->GetKey();
+  StringPiece server_encrypter_iv = server_encrypter->GetNoncePrefix();
+  StringPiece server_decrypter_key = server_decrypter->GetKey();
+  StringPiece server_decrypter_iv = server_decrypter->GetNoncePrefix();
+
   CompareCharArraysWithHexError("client write key",
                                 client_encrypter_key.data(),
                                 client_encrypter_key.length(),
                                 server_decrypter_key.data(),
                                 server_decrypter_key.length());
   CompareCharArraysWithHexError("client write IV",
                                 client_encrypter_iv.data(),
                                 client_encrypter_iv.length(),
                                 server_decrypter_iv.data(),
                                 server_decrypter_iv.length());
   CompareCharArraysWithHexError("server write key",
                                 server_encrypter_key.data(),
                                 server_encrypter_key.length(),
                                 client_decrypter_key.data(),
                                 client_decrypter_key.length());
   CompareCharArraysWithHexError("server write IV",
                                 server_encrypter_iv.data(),
                                 server_encrypter_iv.length(),
                                 client_decrypter_iv.data(),
                                 client_decrypter_iv.length());
 }
 }  // namespace test
 }  // namespace net