Move encryption_level from QueuedPacket into SerializedPacket. No functional change. Not flag pro…

net/quic/quic_packet_creator.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_packet_creator.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 582 matching lines @@
     has_stop_waiting |= frame.type == STOP_WAITING_FRAME;
   }
 
   packet_size_ = 0;
   queued_frames_.clear();
   needs_padding_ = false;
   return SerializedPacket(
       header.packet_number, header.public_header.packet_number_length,
       encrypted_buffer, encrypted_length, /* owns_buffer*/ false,
       QuicFramer::GetPacketEntropyHash(header),
-      queued_retransmittable_frames_.release(), has_ack, has_stop_waiting);
+      queued_retransmittable_frames_.release(), has_ack, has_stop_waiting,
+      encryption_level_);
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec(char* buffer,
                                                  size_t buffer_len) {
   DCHECK_LT(0u, buffer_len);
   if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
     LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
     // TODO(jri): Make this a public method of framer?
     return NoPacket();
   }
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_->FecGroupNumber(), true, &header);
   scoped_ptr<QuicPacket> packet(
       framer_->BuildFecPacket(header, fec_group_->PayloadParity()));
   fec_group_.reset(nullptr);
   packet_size_ = 0;
   LOG_IF(DFATAL, packet == nullptr)
       << "Failed to serialize fec packet for group:"
       << fec_group_->FecGroupNumber();
   DCHECK_GE(max_packet_length_, packet->length());
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // packet number multiple times.
   size_t encrypted_length = framer_->EncryptPayload(
       encryption_level_, packet_number_, *packet, buffer, buffer_len);
   if (encrypted_length == 0) {
     LOG(DFATAL) << "Failed to encrypt packet number " << packet_number_;
     return NoPacket();
   }
-  SerializedPacket serialized(
-      header.packet_number, header.public_header.packet_number_length, buffer,
-      encrypted_length, /* owns_buffer */ false,
-      QuicFramer::GetPacketEntropyHash(header), nullptr, false, false);
+  SerializedPacket serialized(header.packet_number,
+                              header.public_header.packet_number_length, buffer,
+                              encrypted_length, /* owns_buffer */ false,
+                              QuicFramer::GetPacketEntropyHash(header), nullptr,
+                              false, false, encryption_level_);
   serialized.is_fec_packet = true;
   return serialized;
 }
 
 QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
   QuicEncryptedPacket* encrypted = QuicFramer::BuildVersionNegotiationPacket(
       connection_id_, supported_versions);
   DCHECK(encrypted);
@@ skipping 134 matching lines @@
     QuicPacketCount max_packets_in_flight) {
   set_max_packets_per_fec_group(static_cast<size_t>(
       kMaxPacketsInFlightMultiplierForFecGroupSize * max_packets_in_flight));
 }
 
 void QuicPacketCreator::OnRttChange(QuicTime::Delta rtt) {
   fec_timeout_ = rtt.Multiply(rtt_multiplier_for_fec_timeout_);
 }
 
 }  // namespace net