Move QuicPacketCreator::SerializeAllFrames into QuicPacketCreatorPeer.

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 395 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_);
+  QUIC_BUG_IF(retransmission.retransmittable_frames.empty())
+      << "Attempt to serialize empty packet";
   const QuicPacketNumberLength saved_length = 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_;
 
   // Temporarily set the packet number length, stop FEC protection,
   // and change the encryption level.
   packet_number_length_ = retransmission.packet_number_length;
   next_packet_number_length_ = retransmission.packet_number_length;
   fec_protect_ = false;
   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;
   }
 
   // Serialize the packet and restore the FEC and packet number length state.
-  SerializedPacket serialized_packet = SerializeAllFrames(
-      retransmission.retransmittable_frames, buffer, buffer_len);
+  for (const QuicFrame& frame : retransmission.retransmittable_frames) {
+    bool success = AddFrame(frame, false);
+    DCHECK(success);
+  }
+  SerializedPacket serialized_packet = SerializePacket(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) {
-    bool success = AddFrame(frame, false);
-    DCHECK(success);
-  }
-  SerializedPacket packet = SerializePacket(buffer, buffer_len);
-  DCHECK(packet.retransmittable_frames == nullptr);
-  return packet;
-}
-
 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);
@@ skipping 383 matching lines @@
   packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
   current_path_ = path_id;
   DCHECK(current_path_ != kInvalidPathId);
   // Send path in packet if current path is not the default path.
   send_path_id_in_packet_ = current_path_ != kDefaultPathId ? true : false;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net