Use the CHLO packet size, not message size when determining how large a REJ can be. Protected by --…

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 <openssl/bn.h>
 #include <openssl/ec.h>
 #include <openssl/ecdsa.h>
 #include <openssl/evp.h>
@@ skipping 284 matching lines @@
                std::unique_ptr<ProofSource::Details> /* details */) override {
     QuicCryptoNegotiatedParameters params;
     string error_details;
     DiversificationNonce diversification_nonce;
     CryptoHandshakeMessage rej;
     crypto_config_->ProcessClientHello(
         result, /*reject_only=*/false, /*connection_id=*/1, server_ip_,
         client_addr_, QuicSupportedVersions().front(), QuicSupportedVersions(),
         /*use_stateless_rejects=*/true, /*server_designated_connection_id=*/0,
         clock_, QuicRandom::GetInstance(), compressed_certs_cache_, &params,
-        proof_, &rej, &diversification_nonce, &error_details);
+        proof_, /*total_framing_overhead=*/50, kDefaultMaxPacketSize, &rej,
+        &diversification_nonce, &error_details);
     // Verify output is a REJ or SREJ.
     EXPECT_THAT(rej.tag(),
                 testing::AnyOf(testing::Eq(kSREJ), testing::Eq(kREJ)));
 
     VLOG(1) << "Extract valid STK and SCID from\n" << rej.DebugString();
     StringPiece srct;
     ASSERT_TRUE(rej.GetStringPiece(kSourceAddressTokenTag, &srct));
 
     StringPiece scfg;
     ASSERT_TRUE(rej.GetStringPiece(kSCFG, &scfg));
@@ skipping 560 matching lines @@
       // The framer will be unable to decrypt forward-secure packets sent after
       // the handshake is complete. Don't treat them as handshake packets.
       break;
     }
 
     for (const QuicStreamFrame* stream_frame : framer.stream_frames()) {
       ASSERT_TRUE(crypto_framer.ProcessInput(
           StringPiece(stream_frame->data_buffer, stream_frame->data_length)));
       ASSERT_FALSE(crypto_visitor.error());
     }
+    QuicConnectionPeer::SetCurrentPacket(
+        dest_conn, source_conn->encrypted_packets_[index]->AsStringPiece());
   }
   *inout_packet_index = index;
 
   QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
 
   ASSERT_EQ(0u, crypto_framer.InputBytesRemaining());
 
   for (const CryptoHandshakeMessage& message : crypto_visitor.messages()) {
     dest_stream->OnHandshakeMessage(message);
   }
+  QuicConnectionPeer::SetCurrentPacket(dest_conn, StringPiece(nullptr, 0));
 }
 
 // static
 void CryptoTestUtils::GenerateFullCHLO(
     const CryptoHandshakeMessage& inchoate_chlo,
     QuicCryptoServerConfig* crypto_config,
     IPAddress server_ip,
     IPEndPoint client_addr,
     QuicVersion version,
     const QuicClock* clock,
     QuicCryptoProof* proof,
     QuicCompressedCertsCache* compressed_certs_cache,
     CryptoHandshakeMessage* out) {
   // Pass a inchoate CHLO.
   crypto_config->ValidateClientHello(
       inchoate_chlo, client_addr.address(), server_ip, version, clock, proof,
       new FullChloGenerator(crypto_config, server_ip, client_addr, clock, proof,
                             compressed_certs_cache, out));
 }
 
 }  // namespace test
 }  // namespace net