Inline the members of QUIC's ReceivedPacketInfo into QuicAckFrame now

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 "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
@@ skipping 189 matching lines @@
   next_sequence_number_length_ =
       QuicFramer::GetMinSequenceNumberLength(delta * 4);
 }
 
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
                                               QuicStreamOffset offset) const {
   // 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(framer_->version(), id, offset, true,
+      QuicFramer::GetMinStreamFrameSize(id, offset, true,
                                         should_fec_protect_ ? IN_FEC_GROUP :
                                                               NOT_IN_FEC_GROUP);
 }
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
-    QuicVersion version,
     QuicConnectionIdLength connection_id_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length,
     QuicStreamOffset offset,
     InFecGroup is_in_fec_group) {
   return GetPacketHeaderSize(connection_id_length, include_version,
                              sequence_number_length, is_in_fec_group) +
       // Assumes this is a stream with a single lone packet.
-      QuicFramer::GetMinStreamFrameSize(version, 1u, offset, true,
-                                        is_in_fec_group);
+      QuicFramer::GetMinStreamFrameSize(1u, offset, true, is_in_fec_group);
 }
 
 size_t QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                             const IOVector& data,
                                             QuicStreamOffset offset,
                                             bool fin,
                                             QuicFrame* frame) {
   DCHECK_GT(max_packet_length_, StreamFramePacketOverhead(
-                framer_->version(), PACKET_8BYTE_CONNECTION_ID, kIncludeVersion,
+                PACKET_8BYTE_CONNECTION_ID, kIncludeVersion,
                 PACKET_6BYTE_SEQUENCE_NUMBER, offset, IN_FEC_GROUP));
 
   InFecGroup is_in_fec_group = MaybeUpdateLengthsAndStartFec();
 
   LOG_IF(DFATAL, !HasRoomForStreamFrame(id, offset))
       << "No room for Stream frame, BytesFree: " << BytesFree()
       << " MinStreamFrameSize: "
-      << QuicFramer::GetMinStreamFrameSize(
-          framer_->version(), id, offset, true, is_in_fec_group);
+      << QuicFramer::GetMinStreamFrameSize(id, offset, true, is_in_fec_group);
 
   if (data.Empty()) {
     LOG_IF(DFATAL, !fin)
         << "Creating a stream frame with no data or fin.";
     // Create a new packet for the fin, if necessary.
     *frame = QuicFrame(new QuicStreamFrame(id, true, offset, data));
     return 0;
   }
 
   const size_t data_size = data.TotalBufferSize();
   size_t min_frame_size = QuicFramer::GetMinStreamFrameSize(
-      framer_->version(), id, offset, /*last_frame_in_packet=*/ true,
-      is_in_fec_group);
+      id, offset, /* last_frame_in_packet= */ true, is_in_fec_group);
   size_t bytes_consumed = min<size_t>(BytesFree() - min_frame_size, data_size);
 
   bool set_fin = fin && bytes_consumed == data_size;  // Last frame.
   IOVector frame_data;
   frame_data.AppendIovecAtMostBytes(data.iovec(), data.Size(),
                                     bytes_consumed);
   DCHECK_EQ(frame_data.TotalBufferSize(), bytes_consumed);
   *frame = QuicFrame(new QuicStreamFrame(id, set_fin, offset, frame_data));
   return bytes_consumed;
 }
@@ skipping 255 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net