1 files changed, 29 insertions, 15 deletions

diff --git a/chromium/net/quic/core/quic_packet_creator.cc b/chromium/net/quic/core/quic_packet_creator.cc
index 27ed0b93401..0d05a8c2dee 100644
--- a/chromium/net/quic/core/quic_packet_creator.cc
+++ b/chromium/net/quic/core/quic_packet_creator.cc
@@ -54,8 +54,8 @@ QuicPacketCreator::~QuicPacketCreator() {
 }
 
 void QuicPacketCreator::SetEncrypter(EncryptionLevel level,
-                                     QuicEncrypter* encrypter) {
-  framer_->SetEncrypter(level, encrypter);
+                                     std::unique_ptr<QuicEncrypter> encrypter) {
+  framer_->SetEncrypter(level, std::move(encrypter));
   max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
 }
 
@@ -182,7 +182,7 @@ void QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                           QuicFrame* frame) {
   DCHECK_GT(max_packet_length_,
             StreamFramePacketOverhead(framer_->transport_version(),
-                                      connection_id_length_, kIncludeVersion,
+                                      GetConnectionIdLength(), kIncludeVersion,
                                       IncludeNonceInPublicHeader(),
                                       PACKET_6BYTE_PACKET_NUMBER, offset));
 
@@ -398,10 +398,10 @@ size_t QuicPacketCreator::PacketSize() {
   if (!queued_frames_.empty()) {
     return packet_size_;
   }
-  packet_size_ =
-      GetPacketHeaderSize(framer_->transport_version(), connection_id_length_,
-                          send_version_in_packet_, IncludeNonceInPublicHeader(),
-                          packet_.packet_number_length);
+  packet_size_ = GetPacketHeaderSize(
+      framer_->transport_version(), GetConnectionIdLength(),
+      IncludeVersionInHeader(), IncludeNonceInPublicHeader(),
+      GetPacketNumberLength());
   return packet_size_;
 }
 
@@ -467,10 +467,11 @@ void QuicPacketCreator::SerializePacket(char* encrypted_buffer,
 
 std::unique_ptr<QuicEncryptedPacket>
 QuicPacketCreator::SerializeVersionNegotiationPacket(
+    bool ietf_quic,
     const ParsedQuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
   std::unique_ptr<QuicEncryptedPacket> encrypted =
-      QuicFramer::BuildVersionNegotiationPacket(connection_id_,
+      QuicFramer::BuildVersionNegotiationPacket(connection_id_, ietf_quic,
                                                 supported_versions);
   DCHECK(encrypted);
   DCHECK_GE(max_packet_length_, encrypted->length());
@@ -504,17 +505,25 @@ QuicPacketCreator::SerializeConnectivityProbingPacket() {
   return serialize_packet;
 }
 
-// TODO(jri): Make this a public method of framer?
+// TODO(b/74062209): Make this a public method of framer?
 SerializedPacket QuicPacketCreator::NoPacket() {
   return SerializedPacket(0, PACKET_1BYTE_PACKET_NUMBER, nullptr, 0, false,
                           false);
 }
 
+QuicConnectionIdLength QuicPacketCreator::GetConnectionIdLength() const {
+  return connection_id_length_;
+}
+
+QuicPacketNumberLength QuicPacketCreator::GetPacketNumberLength() const {
+  return packet_.packet_number_length;
+}
+
 void QuicPacketCreator::FillPacketHeader(QuicPacketHeader* header) {
   header->connection_id = connection_id_;
-  header->connection_id_length = connection_id_length_;
+  header->connection_id_length = GetConnectionIdLength();
   header->reset_flag = false;
-  header->version_flag = send_version_in_packet_;
+  header->version_flag = IncludeVersionInHeader();
   if (IncludeNonceInPublicHeader()) {
     DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
     header->nonce = &diversification_nonce_;
@@ -553,7 +562,7 @@ bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
   }
   size_t frame_len = framer_->GetSerializedFrameLength(
       frame, BytesFree(), queued_frames_.empty(), true,
-      packet_.packet_number_length);
+      GetPacketNumberLength());
   if (frame_len == 0) {
     // Current open packet is full.
     Flush();
@@ -618,11 +627,15 @@ void QuicPacketCreator::MaybeAddPadding() {
   DCHECK(success);
 }
 
-bool QuicPacketCreator::IncludeNonceInPublicHeader() {
+bool QuicPacketCreator::IncludeNonceInPublicHeader() const {
   return have_diversification_nonce_ &&
          packet_.encryption_level == ENCRYPTION_INITIAL;
 }
 
+bool QuicPacketCreator::IncludeVersionInHeader() const {
+  return send_version_in_packet_;
+}
+
 void QuicPacketCreator::AddPendingPadding(QuicByteCount size) {
   pending_padding_bytes_ += size;
 }
@@ -644,8 +657,9 @@ void QuicPacketCreator::SetConnectionIdLength(QuicConnectionIdLength length) {
 
 void QuicPacketCreator::SetTransmissionType(TransmissionType type) {
   DCHECK(can_set_transmission_type_);
-  QUIC_DVLOG(1) << "Setting Transmission type to "
-                << QuicUtils::TransmissionTypeToString(type);
+  QUIC_DVLOG_IF(1, type != packet_.transmission_type)
+      << "Setting Transmission type to "
+      << QuicUtils::TransmissionTypeToString(type);
   packet_.transmission_type = type;
 }