Make a SerializedPacket a member variable of QuicPacketCreator to

net/quic/test_tools/quic_packet_creator_peer.cc

 // Copyright (c) 2013 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/quic_packet_creator_peer.h"
 
 #include "net/quic/quic_packet_creator.h"
 
 namespace net {
 namespace test {
@@ skipping 18 matching lines @@
 // static
 void QuicPacketCreatorPeer::SetSendPathIdInPacket(QuicPacketCreator* creator,
                                                   bool send_path_id_in_packet) {
   creator->send_path_id_in_packet_ = send_path_id_in_packet;
 }
 
 // static
 void QuicPacketCreatorPeer::SetPacketNumberLength(
     QuicPacketCreator* creator,
     QuicPacketNumberLength packet_number_length) {
-  creator->packet_number_length_ = packet_number_length;
+  creator->packet_.packet_number_length = packet_number_length;
 }
 
 // static
 void QuicPacketCreatorPeer::SetNextPacketNumberLength(
     QuicPacketCreator* creator,
     QuicPacketNumberLength next_packet_number_length) {
   creator->next_packet_number_length_ = next_packet_number_length;
 }
 
 // static
 QuicPacketNumberLength QuicPacketCreatorPeer::NextPacketNumberLength(
     QuicPacketCreator* creator) {
   return creator->next_packet_number_length_;
 }
 
 // static
 QuicPacketNumberLength QuicPacketCreatorPeer::GetPacketNumberLength(
     QuicPacketCreator* creator) {
-  return creator->packet_number_length_;
+  return creator->packet_.packet_number_length;
 }
 
 void QuicPacketCreatorPeer::SetPacketNumber(QuicPacketCreator* creator,
                                             QuicPacketNumber s) {
-  creator->packet_number_ = s;
+  creator->packet_.packet_number = s;
 }
 
 // static
 void QuicPacketCreatorPeer::FillPacketHeader(QuicPacketCreator* creator,
                                              QuicFecGroupNumber fec_group,
                                              bool fec_flag,
                                              QuicPacketHeader* header) {
   creator->FillPacketHeader(fec_group, fec_flag, header);
 }
 
@@ skipping 24 matching lines @@
   creator->StartFecProtectingPackets();
 }
 
 // static
 void QuicPacketCreatorPeer::StopFecProtectingPackets(
     QuicPacketCreator* creator) {
   creator->StopFecProtectingPackets();
 }
 
 // static
-SerializedPacket QuicPacketCreatorPeer::SerializeFec(QuicPacketCreator* creator,
-                                                     char* buffer,
-                                                     size_t buffer_len) {
-  return creator->SerializeFec(buffer, buffer_len);
+void QuicPacketCreatorPeer::SerializeFec(QuicPacketCreator* creator,
+                                         char* buffer,
+                                         size_t buffer_len) {
+  creator->SerializeFec(buffer, buffer_len);
 }
 
 // static
 SerializedPacket QuicPacketCreatorPeer::SerializeAllFrames(
     QuicPacketCreator* creator,
     const QuicFrames& frames,
     char* buffer,
     size_t buffer_len) {
   DCHECK(creator->queued_frames_.empty());
   DCHECK(!frames.empty());
   for (const QuicFrame& frame : frames) {
     bool success = creator->AddFrame(frame, false);
     DCHECK(success);
   }
-  SerializedPacket packet = creator->SerializePacket(buffer, buffer_len);
+  creator->SerializePacket(buffer, buffer_len);
+  SerializedPacket packet = creator->packet_;
+  // The caller takes ownership of the QuicEncryptedPacket.
+  creator->packet_.packet = nullptr;
   DCHECK(packet.retransmittable_frames == nullptr);
   return packet;
 }
 
 // static
 void QuicPacketCreatorPeer::ResetFecGroup(QuicPacketCreator* creator) {
   creator->ResetFecGroup();
 }
 
 // static
 QuicTime::Delta QuicPacketCreatorPeer::GetFecTimeout(
     QuicPacketCreator* creator) {
   return creator->fec_timeout_;
 }
 
 // static
 float QuicPacketCreatorPeer::GetRttMultiplierForFecTimeout(
     QuicPacketCreator* creator) {
   return creator->rtt_multiplier_for_fec_timeout_;
 }
 
 // static
 EncryptionLevel QuicPacketCreatorPeer::GetEncryptionLevel(
     QuicPacketCreator* creator) {
-  return creator->encryption_level_;
+  return creator->packet_.encryption_level;
 }
 
 // static
 QuicPathId QuicPacketCreatorPeer::GetCurrentPath(QuicPacketCreator* creator) {
-  return creator->current_path_;
+  return creator->packet_.path_id;
 }
 
 }  // namespace test
 }  // namespace net