Implement the variable length changes necessary to easily accommodate

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/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
@@ skipping 65 matching lines @@
     packet_size_ -= kQuicVersionSize;
   }
 }
 
 bool QuicPacketCreator::HasRoomForStreamFrame() const {
   return BytesFree() > QuicFramer::GetMinStreamFrameSize();
 }
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
-    int num_frames,
     QuicGuidLength guid_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length,
     InFecGroup is_in_fec_group) {
   return GetPacketHeaderSize(guid_length, include_version,
                              sequence_number_length, is_in_fec_group) +
-      QuicFramer::GetMinStreamFrameSize() * num_frames;
+      // Assumes this is a stream with a single lone packet.
+      QuicFramer::GetMinStreamFrameSize(1, 0, true);
 }
 
 size_t QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                             StringPiece data,
                                             QuicStreamOffset offset,
                                             bool fin,
                                             QuicFrame* frame) {
   DCHECK_GT(options_.max_packet_length,
             StreamFramePacketOverhead(
-                1, PACKET_8BYTE_GUID, kIncludeVersion,
+                PACKET_8BYTE_GUID, kIncludeVersion,
                 PACKET_6BYTE_SEQUENCE_NUMBER, IN_FEC_GROUP));
   DCHECK(HasRoomForStreamFrame());
 
   const size_t free_bytes = BytesFree();
   size_t bytes_consumed = 0;
 
   if (data.size() != 0) {
-    size_t max_data_len = free_bytes - QuicFramer::GetMinStreamFrameSize();
-    bytes_consumed = min<size_t>(max_data_len, data.size());
+    size_t min_last_stream_frame_size =
+        QuicFramer::GetMinStreamFrameSize(id, offset, true);
+    // Comparing against the last stream frame size including the length
+    // guarantees that all the bytes will fit.  Otherwise there is a
+    // discontinuity where the packet goes one byte over due to the length data.
+    if (data.size() > free_bytes - min_last_stream_frame_size -
+        kQuicStreamPayloadLengthSize) {
+      // Its the last frame, put as much data as possible in.
+      bytes_consumed =
+          min<size_t>(free_bytes - min_last_stream_frame_size, data.size());
+    } else {
+      bytes_consumed = data.size();
+    }
 
     bool set_fin = fin && bytes_consumed == data.size();  // Last frame.
     StringPiece data_frame(data.data(), bytes_consumed);
     *frame = QuicFrame(new QuicStreamFrame(id, set_fin, offset, data_frame));
   } else {
     DCHECK(fin);
     // Create a new packet for the fin, if necessary.
     *frame = QuicFrame(new QuicStreamFrame(id, true, offset, ""));
   }
 
@@ skipping 146 matching lines @@
       queued_frames_.push_back(
           queued_retransmittable_frames_->AddNonStreamFrame(frame));
     }
   } else {
     queued_frames_.push_back(frame);
   }
   return true;
 }
 
 }  // namespace net