Implement the variable length changes necessary to easily accommodate

net/quic/quic_framer.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_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
@@ skipping 69 matching lines @@
   return false;
 }
 
 // static
 size_t QuicFramer::GetMinStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicStreamIdSize +
       kQuicStreamFinSize + kQuicStreamOffsetSize + kQuicStreamPayloadLengthSize;
 }
 
 // static
+size_t QuicFramer::GetMinStreamFrameSize(QuicStreamId stream_id,
+                                         QuicStreamOffset offset,
+                                         bool last_frame) {
+  // TODO(ianswett): Remove kQuicStreamFinSize for the next STREAM framing.
+  return kQuicFrameTypeSize + GetStreamIdSize(stream_id) +
+      GetStreamOffsetSize(offset) + kQuicStreamFinSize +
+      kQuicStreamPayloadLengthSize;
+}
+
+// static
 size_t QuicFramer::GetMinAckFrameSize() {
   return kQuicFrameTypeSize + kQuicEntropyHashSize +
       PACKET_6BYTE_SEQUENCE_NUMBER + kQuicEntropyHashSize +
       PACKET_6BYTE_SEQUENCE_NUMBER + kQuicDeltaTimeLargestObservedSize +
       kNumberOfMissingPacketsSize;
 }
 
 // static
 size_t QuicFramer::GetMinRstStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicStreamIdSize + kQuicErrorCodeSize +
@@ skipping 15 matching lines @@
 // static
 // TODO(satyamshekhar): 16 - Crypto hash for integrity. Not a static value. Use
 // QuicEncrypter::GetMaxPlaintextSize.
 // 16 is a conservative estimate in the case of AEAD_AES_128_GCM_12, which uses
 // 12-byte tags.
 size_t QuicFramer::GetMaxUnackedPackets(QuicPacketHeader header) {
   return (kMaxPacketSize - GetPacketHeaderSize(header) -
           GetMinAckFrameSize() - 16) / PACKET_6BYTE_SEQUENCE_NUMBER;
 }
 
+// static
+size_t QuicFramer::GetStreamIdSize(QuicStreamId stream_id) {
+  return 4;
+}
+
+// static
+size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset) {
+  return 8;
+}
+
 bool QuicFramer::IsSupportedVersion(QuicTag version) {
   return version == kQuicVersion1;
 }
 
 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
   return kPublicFlagsSize + PACKET_8BYTE_GUID +
       number_versions * kQuicVersionSize;
 }
 
 size_t QuicFramer::GetSerializedFrameLength(
     const QuicFrame& frame, size_t free_bytes, bool first_frame) {
   if (frame.type == PADDING_FRAME) {
     // PADDING implies end of packet.
     return free_bytes;
   }
-  size_t frame_len = ComputeFrameLength(frame);
+  // See if it fits as the non-last frame.
+  size_t frame_len = ComputeFrameLength(frame, false);
   if (frame_len > free_bytes) {
     // Only truncate the first frame in a packet, so if subsequent ones go
     // over, stop including more frames.
     if (!first_frame) {
       return 0;
     }
     if (CanTruncate(frame)) {
       // Truncate the frame so the packet will not exceed kMaxPacketSize.
       // Note that we may not use every byte of the writer in this case.
       if (free_bytes >= GetMinAckFrameSize()) {
@@ skipping 36 matching lines @@
     const QuicFrames& frames,
     size_t packet_size) {
   QuicDataWriter writer(packet_size);
   SerializedPacket kNoPacket = SerializedPacket(0, NULL, 0, NULL);
   if (!WritePacketHeader(header, &writer)) {
     return kNoPacket;
   }
 
   for (size_t i = 0; i < frames.size(); ++i) {
     const QuicFrame& frame = frames[i];
+
     if (!writer.WriteUInt8(frame.type)) {
       return kNoPacket;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         writer.WritePadding();
         break;
       case STREAM_FRAME:
-        if (!AppendStreamFramePayload(*frame.stream_frame, &writer)) {
+        if (!AppendStreamFramePayload(
+                *frame.stream_frame, &writer)) {
           return kNoPacket;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFramePayload(*frame.ack_frame, &writer)) {
           return kNoPacket;
         }
         break;
       case CONGESTION_FEEDBACK_FRAME:
         if (!AppendQuicCongestionFeedbackFramePayload(
@@ skipping 1104 matching lines @@
   }
 
   if  (decrypted_.get() == NULL) {
     return false;
   }
 
   reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length()));
   return true;
 }
 
-size_t QuicFramer::ComputeFrameLength(const QuicFrame& frame) {
+size_t QuicFramer::ComputeFrameLength(const QuicFrame& frame, bool last_frame) {
   switch (frame.type) {
     case STREAM_FRAME:
-      return GetMinStreamFrameSize() + frame.stream_frame->data.size();
+      return GetMinStreamFrameSize(frame.stream_frame->stream_id,
+                                   frame.stream_frame->offset,
+                                   last_frame) +
+          frame.stream_frame->data.size();
     case ACK_FRAME: {
       const QuicAckFrame& ack = *frame.ack_frame;
       return GetMinAckFrameSize() + PACKET_6BYTE_SEQUENCE_NUMBER *
           ack.received_info.missing_packets.size();
     }
     case CONGESTION_FEEDBACK_FRAME: {
       size_t len = kQuicFrameTypeSize;
       const QuicCongestionFeedbackFrame& congestion_feedback =
           *frame.congestion_feedback_frame;
       len += 1;  // Congestion feedback type.
@@ skipping 336 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net