Landing Recent QUIC changes until 01/28/2016 18:41 UTC

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/logging.h"
 #include "base/macros.h"
@@ skipping 76 matching lines @@
                                      DelegateInterface* delegate)
     : delegate_(delegate),
       debug_delegate_(nullptr),
       framer_(framer),
       random_bool_source_(new QuicRandomBoolSource(random_generator)),
       buffer_allocator_(buffer_allocator),
       send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
       send_path_id_in_packet_(false),
       next_packet_number_length_(PACKET_1BYTE_PACKET_NUMBER),
       max_packet_length_(0),
+      connection_id_length_(PACKET_8BYTE_CONNECTION_ID),
+      packet_size_(0),
       connection_id_(connection_id),
-      encryption_level_(ENCRYPTION_NONE),
-      has_ack_(false),
-      has_stop_waiting_(false),
-      current_path_(kDefaultPathId),
-      packet_number_(0),
-      connection_id_length_(PACKET_8BYTE_CONNECTION_ID),
-      packet_number_length_(next_packet_number_length_),
-      packet_size_(0),
-      needs_padding_(false),
-      has_crypto_handshake_(NOT_HANDSHAKE),
+      packet_(kDefaultPathId,
+              0,
+              next_packet_number_length_,
+              nullptr,
+              0,
+              false,
+              false),
       should_fec_protect_next_packet_(false),
       fec_protect_(false),
       max_packets_per_fec_group_(kDefaultMaxPacketsPerFecGroup),
       fec_send_policy_(FEC_ANY_TRIGGER),
       fec_timeout_(QuicTime::Delta::Zero()),
       rtt_multiplier_for_fec_timeout_(kRttMultiplierForFecTimeout) {
   SetMaxPacketLength(kDefaultMaxPacketSize);
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
-  if (queued_retransmittable_frames_.get() != nullptr) {
-    QuicUtils::DeleteFrames(queued_retransmittable_frames_.get());
+  QuicUtils::DeleteFrames(&packet_.retransmittable_frames);
+  if (packet_.packet != nullptr) {
+    delete packet_.packet;
   }
 }
 
 void QuicPacketCreator::OnBuiltFecProtectedPayload(
     const QuicPacketHeader& header,
     StringPiece payload) {
   if (fec_group_.get() != nullptr) {
     DCHECK_NE(0u, header.fec_group);
-    fec_group_->Update(encryption_level_, header, payload);
+    fec_group_->Update(packet_.encryption_level, header, payload);
   }
 }
 
 void QuicPacketCreator::SetEncrypter(EncryptionLevel level,
                                      QuicEncrypter* encrypter) {
   framer_->SetEncrypter(level, encrypter);
   max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
 }
 
 bool QuicPacketCreator::CanSetMaxPacketLength() const {
@@ skipping 73 matching lines @@
     // Don't update any lengths when an FEC group is open, to ensure same
     // packet header size in all packets within a group.
     return IN_FEC_GROUP;
   }
   if (!queued_frames_.empty()) {
     // Don't change creator state if there are frames queued.
     return NOT_IN_FEC_GROUP;
   }
 
   // Update packet number length only on packet and FEC group boundaries.
-  packet_number_length_ = next_packet_number_length_;
+  packet_.packet_number_length = next_packet_number_length_;
 
   if (!fec_protect_) {
     return NOT_IN_FEC_GROUP;
   }
   // Start a new FEC group since protection is on. Set the fec group number to
   // the packet number of the next packet.
-  fec_group_.reset(new QuicFecGroup(packet_number_ + 1));
+  fec_group_.reset(new QuicFecGroup(packet_.packet_number + 1));
   return IN_FEC_GROUP;
 }
 
 // Stops serializing version of the protocol in packets sent after this call.
 // A packet that is already open might send kQuicVersionSize bytes less than the
 // maximum packet size if we stop sending version before it is serialized.
 void QuicPacketCreator::StopSendingVersion() {
   DCHECK(send_version_in_packet_);
   send_version_in_packet_ = false;
   if (packet_size_ > 0) {
     DCHECK_LT(kQuicVersionSize, packet_size_);
     packet_size_ -= kQuicVersionSize;
   }
 }
 
 void QuicPacketCreator::UpdatePacketNumberLength(
     QuicPacketNumber least_packet_awaited_by_peer,
     QuicPacketCount max_packets_in_flight) {
-  DCHECK_LE(least_packet_awaited_by_peer, packet_number_ + 1);
+  DCHECK_LE(least_packet_awaited_by_peer, packet_.packet_number + 1);
   // Since the packet creator will not change packet number length mid FEC
   // group, include the size of an FEC group to be safe.
   const QuicPacketNumber current_delta = max_packets_per_fec_group_ +
-                                         packet_number_ + 1 -
+                                         packet_.packet_number + 1 -
                                          least_packet_awaited_by_peer;
   const uint64_t delta = max(current_delta, max_packets_in_flight);
   next_packet_number_length_ =
       QuicFramer::GetMinSequenceNumberLength(delta * 4);
 }
 
 bool QuicPacketCreator::ConsumeData(QuicStreamId id,
                                     QuicIOVector iov,
                                     size_t iov_offset,
                                     QuicStreamOffset offset,
                                     bool fin,
                                     bool needs_padding,
                                     QuicFrame* frame,
                                     FecProtection fec_protection) {
   if (!HasRoomForStreamFrame(id, offset)) {
     return false;
   }
   if (fec_protection == MUST_FEC_PROTECT) {
     should_fec_protect_next_packet_ = true;
     MaybeStartFecProtection();
   }
   CreateStreamFrame(id, iov, iov_offset, offset, fin, frame);
   if (!AddFrame(*frame, /*save_retransmittable_frames=*/true)) {
     // Fails if we try to write unencrypted stream data.
     delete frame->stream_frame;
     return false;
   }
   if (needs_padding) {
-    needs_padding_ = true;
+    packet_.needs_padding = true;
   }
   if (fec_protection == MUST_FEC_PROTECT &&
       iov_offset + frame->stream_frame->frame_length == iov.total_length) {
     // Turn off FEC protection when we're done writing protected data.
     DVLOG(1) << "Turning FEC protection OFF";
     should_fec_protect_next_packet_ = false;
   }
   return true;
 }
 
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
-                                              QuicStreamOffset offset) const {
+                                              QuicStreamOffset offset) {
   // TODO(jri): This is a simple safe decision for now, but make
   // is_in_fec_group a parameter. Same as with all public methods in
   // QuicPacketCreator.
   return BytesFree() >
          QuicFramer::GetMinStreamFrameSize(
              id, offset, true, fec_protect_ ? IN_FEC_GROUP : NOT_IN_FEC_GROUP);
 }
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
@@ skipping 101 matching lines @@
   }
   QUIC_BUG_IF(length > 0) << "Failed to copy entire length to buffer.";
 }
 
 SerializedPacket QuicPacketCreator::ReserializeAllFrames(
     const PendingRetransmission& retransmission,
     char* buffer,
     size_t buffer_len) {
   DCHECK(queued_frames_.empty());
   DCHECK(fec_group_.get() == nullptr);
-  DCHECK(!needs_padding_);
-  const QuicPacketNumberLength saved_length = packet_number_length_;
+  DCHECK(!packet_.needs_padding);
+  QUIC_BUG_IF(retransmission.retransmittable_frames.empty())
+      << "Attempt to serialize empty packet";
+  const QuicPacketNumberLength saved_length = packet_.packet_number_length;
   const QuicPacketNumberLength saved_next_length = next_packet_number_length_;
   const bool saved_should_fec_protect = fec_protect_;
-  const bool saved_needs_padding = needs_padding_;
-  const EncryptionLevel default_encryption_level = encryption_level_;
+  const bool saved_needs_padding = packet_.needs_padding;
+  const EncryptionLevel default_encryption_level = packet_.encryption_level;
 
   // Temporarily set the packet number length, stop FEC protection,
   // and change the encryption level.
-  packet_number_length_ = retransmission.packet_number_length;
+  packet_.packet_number_length = retransmission.packet_number_length;
   next_packet_number_length_ = retransmission.packet_number_length;
   fec_protect_ = false;
-  needs_padding_ = retransmission.needs_padding;
+  packet_.needs_padding = retransmission.needs_padding;
   // Only preserve the original encryption level if it's a handshake packet or
   // if we haven't gone forward secure.
   if (retransmission.has_crypto_handshake ||
-      encryption_level_ != ENCRYPTION_FORWARD_SECURE) {
-    encryption_level_ = retransmission.encryption_level;
+      packet_.encryption_level != ENCRYPTION_FORWARD_SECURE) {
+    packet_.encryption_level = retransmission.encryption_level;
   }
 
   // Serialize the packet and restore the FEC and packet number length state.
-  SerializedPacket serialized_packet = SerializeAllFrames(
-      retransmission.retransmittable_frames, buffer, buffer_len);
-  if (FLAGS_quic_retransmit_via_onserializedpacket) {
-    serialized_packet.original_packet_number = retransmission.packet_number;
-    serialized_packet.transmission_type = retransmission.transmission_type;
-  }
-
-  packet_number_length_ = saved_length;
-  next_packet_number_length_ = saved_next_length;
-  fec_protect_ = saved_should_fec_protect;
-  encryption_level_ = default_encryption_level;
-
-  if (FLAGS_quic_retransmit_via_onserializedpacket) {
-    OnSerializedPacket(&serialized_packet);
-    return NoPacket();
-  } else {
-    has_crypto_handshake_ = NOT_HANDSHAKE;
-    needs_padding_ = saved_needs_padding;
-    return serialized_packet;
-  }
-}
-
-SerializedPacket QuicPacketCreator::SerializeAllFrames(const QuicFrames& frames,
-                                                       char* buffer,
-                                                       size_t buffer_len) {
-  QUIC_BUG_IF(!queued_frames_.empty()) << "Frames already queued.";
-  QUIC_BUG_IF(frames.empty()) << "Attempt to serialize empty packet";
-  for (const QuicFrame& frame : frames) {
+  for (const QuicFrame& frame : retransmission.retransmittable_frames) {
     bool success = AddFrame(frame, false);
     DCHECK(success);
   }
-  SerializedPacket packet = SerializePacket(buffer, buffer_len);
-  DCHECK(packet.retransmittable_frames == nullptr);
-  return packet;
+  SerializePacket(buffer, buffer_len);
+  if (FLAGS_quic_retransmit_via_onserializedpacket) {
+    packet_.original_packet_number = retransmission.packet_number;
+    packet_.transmission_type = retransmission.transmission_type;
+    OnSerializedPacket();
+    // Restore old values.
+    packet_.packet_number_length = saved_length;
+    next_packet_number_length_ = saved_next_length;
+    fec_protect_ = saved_should_fec_protect;
+    packet_.encryption_level = default_encryption_level;
+    return NoPacket();
+  } else {
+    SerializedPacket packet_copy = packet_;
+    ClearPacket();
+    // Restore old values.
+    packet_.needs_padding = saved_needs_padding;
+    packet_.packet_number_length = saved_length;
+    next_packet_number_length_ = saved_next_length;
+    fec_protect_ = saved_should_fec_protect;
+    packet_.encryption_level = default_encryption_level;
+    return packet_copy;
+  }
 }
 
 void QuicPacketCreator::Flush() {
   if (!HasPendingFrames()) {
     return;
   }
 
   // TODO(rtenneti): Change the default 64 alignas value (used the default
   // value from CACHELINE_SIZE).
   ALIGNAS(64) char seralized_packet_buffer[kMaxPacketSize];
-  SerializedPacket serialized_packet =
-      SerializePacket(seralized_packet_buffer, kMaxPacketSize);
-  OnSerializedPacket(&serialized_packet);
+  SerializePacket(seralized_packet_buffer, kMaxPacketSize);
+  OnSerializedPacket();
 }
 
-void QuicPacketCreator::OnSerializedPacket(SerializedPacket* packet) {
-  if (packet->packet == nullptr) {
+void QuicPacketCreator::OnSerializedPacket() {
+  if (packet_.packet == nullptr) {
     QUIC_BUG << "Failed to SerializePacket. fec_policy:" << fec_send_policy()
              << " should_fec_protect_:" << should_fec_protect_next_packet_;
     delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
     return;
   }
-  // There may be AckListeners interested in this packet.
-  packet->listeners.swap(ack_listeners_);
-  DCHECK(ack_listeners_.empty());
-  delegate_->OnSerializedPacket(packet);
-  has_ack_ = false;
-  has_stop_waiting_ = false;
-  has_crypto_handshake_ = NOT_HANDSHAKE;
-  needs_padding_ = false;
+
+  delegate_->OnSerializedPacket(&packet_);
+  ClearPacket();
   MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/false,
                                   /*is_fec_timeout=*/false);
   // Maximum packet size may be only enacted while no packet is currently being
   // constructed, so here we have a good opportunity to actually change it.
   if (CanSetMaxPacketLength()) {
     SetMaxPacketLength(max_packet_length_);
   }
 }
 
+void QuicPacketCreator::ClearPacket() {
+  packet_.has_ack = false;
+  packet_.has_stop_waiting = false;
+  packet_.has_crypto_handshake = NOT_HANDSHAKE;
+  packet_.needs_padding = false;
+  packet_.is_fec_packet = false;
+  packet_.original_packet_number = 0;
+  packet_.transmission_type = NOT_RETRANSMISSION;
+  packet_.packet = nullptr;
+  DCHECK(packet_.retransmittable_frames.empty());
+  packet_.listeners.clear();
+}
+
 bool QuicPacketCreator::HasPendingFrames() const {
   return !queued_frames_.empty();
 }
 
 bool QuicPacketCreator::HasPendingRetransmittableFrames() const {
-  return queued_retransmittable_frames_.get() != nullptr &&
-         !queued_retransmittable_frames_->empty();
+  return !packet_.retransmittable_frames.empty();
 }
 
 size_t QuicPacketCreator::ExpansionOnNewFrame() const {
   // If packet is FEC protected, there's no expansion.
   if (fec_protect_) {
     return 0;
   }
   // If the last frame in the packet is a stream frame, then it will expand to
   // include the stream_length field when a new frame is added.
   bool has_trailing_stream_frame =
       !queued_frames_.empty() && queued_frames_.back().type == STREAM_FRAME;
   return has_trailing_stream_frame ? kQuicStreamPayloadLengthSize : 0;
 }
 
-size_t QuicPacketCreator::BytesFree() const {
+size_t QuicPacketCreator::BytesFree() {
   DCHECK_GE(max_plaintext_size_, PacketSize());
   return max_plaintext_size_ -
          min(max_plaintext_size_, PacketSize() + ExpansionOnNewFrame());
 }
 
-size_t QuicPacketCreator::PacketSize() const {
+size_t QuicPacketCreator::PacketSize() {
   if (!queued_frames_.empty()) {
     return packet_size_;
   }
   if (fec_group_.get() == nullptr) {
     // Update packet number length on packet and FEC boundary.
-    packet_number_length_ = next_packet_number_length_;
+    packet_.packet_number_length = next_packet_number_length_;
   }
-  packet_size_ = GetPacketHeaderSize(
-      connection_id_length_, send_version_in_packet_, send_path_id_in_packet_,
-      packet_number_length_, fec_protect_ ? IN_FEC_GROUP : NOT_IN_FEC_GROUP);
+  packet_size_ =
+      GetPacketHeaderSize(connection_id_length_, send_version_in_packet_,
+                          send_path_id_in_packet_, packet_.packet_number_length,
+                          fec_protect_ ? IN_FEC_GROUP : NOT_IN_FEC_GROUP);
   return packet_size_;
 }
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
   return AddFrame(frame, /*save_retransmittable_frames=*/true);
 }
 
 bool QuicPacketCreator::AddPaddedSavedFrame(const QuicFrame& frame) {
   if (AddFrame(frame, /*save_retransmittable_frames=*/true)) {
-    needs_padding_ = true;
+    packet_.needs_padding = true;
     return true;
   }
   return false;
 }
 
 void QuicPacketCreator::AddAckListener(QuicAckListenerInterface* listener,
                                        QuicPacketLength length) {
   DCHECK(!queued_frames_.empty());
-  ack_listeners_.push_back(AckListenerWrapper(listener, length));
+  packet_.listeners.push_back(AckListenerWrapper(listener, length));
 }
 
-SerializedPacket QuicPacketCreator::SerializePacket(
-    char* encrypted_buffer,
-    size_t encrypted_buffer_len) {
+void QuicPacketCreator::SerializePacket(char* encrypted_buffer,
+                                        size_t encrypted_buffer_len) {
   DCHECK_LT(0u, encrypted_buffer_len);
   QUIC_BUG_IF(queued_frames_.empty()) << "Attempt to serialize empty packet";
   if (fec_group_.get() != nullptr) {
-    DCHECK_GE(packet_number_ + 1, fec_group_->FecGroupNumber());
+    DCHECK_GE(packet_.packet_number + 1, fec_group_->FecGroupNumber());
   }
   QuicPacketHeader header;
   // FillPacketHeader increments packet_number_.
   FillPacketHeader(fec_group_ != nullptr ? fec_group_->FecGroupNumber() : 0,
                    false, &header);
 
   MaybeAddPadding();
 
   DCHECK_GE(max_plaintext_size_, packet_size_);
   // ACK Frames will be truncated due to length only if they're the only frame
   // in the packet, and if packet_size_ was set to max_plaintext_size_. If
   // truncation due to length occurred, then GetSerializedFrameLength will have
   // returned all bytes free.
   bool possibly_truncated_by_length = packet_size_ == max_plaintext_size_ &&
                                       queued_frames_.size() == 1 &&
                                       queued_frames_.back().type == ACK_FRAME;
   // Use the packet_size_ instead of the buffer size to ensure smaller
   // packet sizes are properly used.
   size_t length = framer_->BuildDataPacket(header, queued_frames_,
                                            encrypted_buffer, packet_size_);
   if (length == 0) {
     QUIC_BUG << "Failed to serialize " << queued_frames_.size() << " frames.";
-    return NoPacket();
+    return;
   }
 
   // TODO(ianswett) Consider replacing QuicPacket with something else, since
   // it's only used to provide convenience methods to FEC and encryption.
   QuicPacket packet(
       encrypted_buffer, length,
       /* owns_buffer */ false, header.public_header.connection_id_length,
       header.public_header.version_flag, header.public_header.multipath_flag,
       header.public_header.packet_number_length);
   OnBuiltFecProtectedPayload(header, packet.FecProtectedData());
 
   // Because of possible truncation, we can't be confident that our
   // packet size calculation worked correctly.
   if (!possibly_truncated_by_length) {
     DCHECK_EQ(packet_size_, length);
   }
   // Immediately encrypt the packet, to ensure we don't encrypt the same
   // packet number multiple times.
-  size_t encrypted_length =
-      framer_->EncryptPayload(encryption_level_, current_path_, packet_number_,
-                              packet, encrypted_buffer, encrypted_buffer_len);
+  size_t encrypted_length = framer_->EncryptPayload(
+      packet_.encryption_level, packet_.path_id, packet_.packet_number, packet,
+      encrypted_buffer, encrypted_buffer_len);
   if (encrypted_length == 0) {
-    QUIC_BUG << "Failed to encrypt packet number " << packet_number_;
-    return NoPacket();
+    QUIC_BUG << "Failed to encrypt packet number " << packet_.packet_number;
+    return;
   }
 
   packet_size_ = 0;
   queued_frames_.clear();
-  return SerializedPacket(
-      current_path_, header.packet_number,
-      header.public_header.packet_number_length, encrypted_buffer,
-      encrypted_length,
-      /* owns_buffer*/ false, QuicFramer::GetPacketEntropyHash(header),
-      queued_retransmittable_frames_.release(), needs_padding_,
-      has_crypto_handshake_, has_ack_, has_stop_waiting_, encryption_level_);
+  packet_.entropy_hash = QuicFramer::GetPacketEntropyHash(header);
+  packet_.packet =
+      new QuicEncryptedPacket(encrypted_buffer, encrypted_length, false);
 }
 
-SerializedPacket QuicPacketCreator::SerializeFec(char* buffer,
-                                                 size_t buffer_len) {
+void QuicPacketCreator::SerializeFec(char* buffer, size_t buffer_len) {
   DCHECK_LT(0u, buffer_len);
   if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
     QUIC_BUG << "SerializeFEC called but no group or zero packets in group.";
-    // TODO(jri): Make this a public method of framer?
-    return NoPacket();
+    return;
   }
-  if (FLAGS_quic_no_unencrypted_fec && encryption_level_ == ENCRYPTION_NONE) {
+  if (FLAGS_quic_no_unencrypted_fec &&
+      packet_.encryption_level == ENCRYPTION_NONE) {
     QUIC_BUG << "SerializeFEC must be called with encryption.";
     delegate_->CloseConnection(QUIC_UNENCRYPTED_FEC_DATA, false);
-    return NoPacket();
+    return;
   }
   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;
   QUIC_BUG_IF(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_, current_path_, packet_number_,
-                              *packet, buffer, buffer_len);
+  size_t encrypted_length = framer_->EncryptPayload(
+      packet_.encryption_level, packet_.path_id, packet_.packet_number, *packet,
+      buffer, buffer_len);
   if (encrypted_length == 0) {
-    QUIC_BUG << "Failed to encrypt packet number " << packet_number_;
-    return NoPacket();
+    QUIC_BUG << "Failed to encrypt packet number " << packet_.packet_number;
+    return;
   }
-  SerializedPacket serialized(
-      current_path_, header.packet_number,
-      header.public_header.packet_number_length, buffer, encrypted_length,
-      /* owns_buffer */ false, QuicFramer::GetPacketEntropyHash(header),
-      nullptr, false, NOT_HANDSHAKE, false, false, encryption_level_);
-  serialized.is_fec_packet = true;
-  return serialized;
+  packet_.entropy_hash = QuicFramer::GetPacketEntropyHash(header);
+  packet_.packet = new QuicEncryptedPacket(buffer, encrypted_length, false);
+  packet_.is_fec_packet = true;
 }
 
 QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
   QuicEncryptedPacket* encrypted = QuicFramer::BuildVersionNegotiationPacket(
       connection_id_, supported_versions);
   DCHECK(encrypted);
   DCHECK_GE(max_packet_length_, encrypted->length());
   return encrypted;
 }
 
+// TODO(jri): Make this a public method of framer?
 SerializedPacket QuicPacketCreator::NoPacket() {
   return SerializedPacket(kInvalidPathId, 0, PACKET_1BYTE_PACKET_NUMBER,
-                          nullptr, 0, nullptr, false, false);
+                          nullptr, 0, false, false);
 }
 
 void QuicPacketCreator::FillPacketHeader(QuicFecGroupNumber fec_group,
                                          bool fec_flag,
                                          QuicPacketHeader* header) {
   header->public_header.connection_id = connection_id_;
   header->public_header.connection_id_length = connection_id_length_;
   header->public_header.multipath_flag = send_path_id_in_packet_;
   header->public_header.reset_flag = false;
   header->public_header.version_flag = send_version_in_packet_;
   header->fec_flag = fec_flag;
-  header->path_id = current_path_;
-  header->packet_number = ++packet_number_;
-  header->public_header.packet_number_length = packet_number_length_;
+  header->path_id = packet_.path_id;
+  header->packet_number = ++packet_.packet_number;
+  header->public_header.packet_number_length = packet_.packet_number_length;
   header->entropy_flag = random_bool_source_->RandBool();
   header->is_in_fec_group = fec_group == 0 ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
   header->fec_group = fec_group;
 }
 
 bool QuicPacketCreator::ShouldRetransmit(const QuicFrame& frame) {
   switch (frame.type) {
     case ACK_FRAME:
     case PADDING_FRAME:
     case STOP_WAITING_FRAME:
     case MTU_DISCOVERY_FRAME:
       return false;
     default:
       return true;
   }
 }
 
 bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
                                  bool save_retransmittable_frames) {
   DVLOG(1) << "Adding frame: " << frame;
   if (FLAGS_quic_never_write_unencrypted_data && frame.type == STREAM_FRAME &&
       frame.stream_frame->stream_id != kCryptoStreamId &&
-      encryption_level_ == ENCRYPTION_NONE) {
+      packet_.encryption_level == ENCRYPTION_NONE) {
     QUIC_BUG << "Cannot send stream data without encryption.";
     delegate_->CloseConnection(QUIC_UNENCRYPTED_STREAM_DATA, false);
     return false;
   }
   InFecGroup is_in_fec_group = MaybeUpdateLengthsAndStartFec();
 
   size_t frame_len = framer_->GetSerializedFrameLength(
       frame, BytesFree(), queued_frames_.empty(), true, is_in_fec_group,
-      packet_number_length_);
+      packet_.packet_number_length);
   if (frame_len == 0) {
     // Current open packet is full.
     Flush();
     return false;
   }
   DCHECK_LT(0u, packet_size_);
   packet_size_ += ExpansionOnNewFrame() + frame_len;
 
   if (save_retransmittable_frames && ShouldRetransmit(frame)) {
-    if (queued_retransmittable_frames_.get() == nullptr) {
-      queued_retransmittable_frames_.reset(new QuicFrames());
-      queued_retransmittable_frames_->reserve(2);
+    if (packet_.retransmittable_frames.empty()) {
+      packet_.retransmittable_frames.reserve(2);
     }
-    queued_retransmittable_frames_->push_back(frame);
+    packet_.retransmittable_frames.push_back(frame);
     queued_frames_.push_back(frame);
     if (frame.type == STREAM_FRAME &&
         frame.stream_frame->stream_id == kCryptoStreamId) {
-      has_crypto_handshake_ = IS_HANDSHAKE;
+      packet_.has_crypto_handshake = IS_HANDSHAKE;
     }
   } else {
     queued_frames_.push_back(frame);
   }
 
   if (frame.type == ACK_FRAME) {
-    has_ack_ = true;
+    packet_.has_ack = true;
   }
   if (frame.type == STOP_WAITING_FRAME) {
-    has_stop_waiting_ = true;
+    packet_.has_stop_waiting = true;
   }
   if (debug_delegate_ != nullptr) {
     debug_delegate_->OnFrameAddedToPacket(frame);
   }
 
   return true;
 }
 
 void QuicPacketCreator::MaybeAddPadding() {
-  if (!needs_padding_) {
+  if (!packet_.needs_padding) {
     return;
   }
 
   if (BytesFree() == 0) {
     // Don't pad full packets.
     return;
   }
 
   bool success = AddFrame(QuicFrame(QuicPaddingFrame()), false);
   DCHECK(success);
@@ skipping 10 matching lines @@
   Flush();
 
   StartFecProtectingPackets();
   DCHECK(fec_protect_);
 }
 
 void QuicPacketCreator::MaybeSendFecPacketAndCloseGroup(bool force_send_fec,
                                                         bool is_fec_timeout) {
   if (ShouldSendFec(force_send_fec)) {
     if ((FLAGS_quic_no_unencrypted_fec &&
-         encryption_level_ == ENCRYPTION_NONE) ||
+         packet_.encryption_level == ENCRYPTION_NONE) ||
         (fec_send_policy_ == FEC_ALARM_TRIGGER && !is_fec_timeout)) {
       ResetFecGroup();
       delegate_->OnResetFecGroup();
     } else {
       // TODO(zhongyi): Change the default 64 alignas value (used the default
       // value from CACHELINE_SIZE).
       ALIGNAS(64) char seralized_fec_buffer[kMaxPacketSize];
-      SerializedPacket serialized_fec =
-          SerializeFec(seralized_fec_buffer, kMaxPacketSize);
-      OnSerializedPacket(&serialized_fec);
+      SerializeFec(seralized_fec_buffer, kMaxPacketSize);
+      OnSerializedPacket();
     }
   }
 
   if (!should_fec_protect_next_packet_ && fec_protect_ && !IsFecGroupOpen()) {
     StopFecProtectingPackets();
   }
 }
 
 QuicTime::Delta QuicPacketCreator::GetFecTimeout(
     QuicPacketNumber packet_number) {
@@ skipping 14 matching lines @@
 }
 
 void QuicPacketCreator::OnRttChange(QuicTime::Delta rtt) {
   fec_timeout_ = rtt.Multiply(rtt_multiplier_for_fec_timeout_);
 }
 
 void QuicPacketCreator::SetCurrentPath(
     QuicPathId path_id,
     QuicPacketNumber least_packet_awaited_by_peer,
     QuicPacketCount max_packets_in_flight) {
-  if (current_path_ == path_id) {
+  if (packet_.path_id == path_id) {
     return;
   }
 
   if (HasPendingFrames()) {
     QUIC_BUG << "Unable to change paths when a packet is under construction.";
     return;
   }
 
   // Send FEC packet and close FEC group.
   MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
                                   /*is_fec_timeout=*/false);
   // Save current packet number and load switching path's packet number.
-  multipath_packet_number_[current_path_] = packet_number_;
-  hash_map<QuicPathId, QuicPacketNumber>::iterator it =
+  multipath_packet_number_[packet_.path_id] = packet_.packet_number;
+  std::unordered_map<QuicPathId, QuicPacketNumber>::iterator it =
       multipath_packet_number_.find(path_id);
   // If path_id is not in the map, it's a new path. Set packet_number to 0.
-  packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
-  current_path_ = path_id;
-  DCHECK(current_path_ != kInvalidPathId);
+  packet_.packet_number = it == multipath_packet_number_.end() ? 0 : it->second;
+  packet_.path_id = path_id;
+  DCHECK(packet_.path_id != kInvalidPathId);
   // Send path in packet if current path is not the default path.
-  send_path_id_in_packet_ = current_path_ != kDefaultPathId ? true : false;
+  send_path_id_in_packet_ = packet_.path_id != kDefaultPathId ? true : false;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net