Land Recent QUIC changes.

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 12 matching lines @@
                                      bool is_server)
     : guid_(guid),
       framer_(framer),
       random_generator_(random_generator),
       sequence_number_(0),
       fec_group_number_(0),
       is_server_(is_server),
       send_version_in_packet_(!is_server),
       packet_size_(GetPacketHeaderSize(options_.send_guid_length,
                                        send_version_in_packet_,
+                                       options_.send_sequence_number_length,
                                        NOT_IN_FEC_GROUP)) {
   framer_->set_fec_builder(this);
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
 }
 
 void QuicPacketCreator::OnBuiltFecProtectedPayload(
     const QuicPacketHeader& header, StringPiece payload) {
   if (fec_group_.get()) {
     fec_group_->Update(header, payload);
   }
 }
 
 bool QuicPacketCreator::ShouldSendFec(bool force_close) const {
   return fec_group_.get() != NULL && fec_group_->NumReceivedPackets() > 0 &&
       (force_close ||
        fec_group_->NumReceivedPackets() >= options_.max_packets_per_fec_group);
 }
 
 void QuicPacketCreator::MaybeStartFEC() {
   if (options_.max_packets_per_fec_group > 0 && fec_group_.get() == NULL) {
     DCHECK(queued_frames_.empty());
     // Set the fec group number to the sequence number of the next packet.
     fec_group_number_ = sequence_number() + 1;
     fec_group_.reset(new QuicFecGroup());
     packet_size_ = GetPacketHeaderSize(options_.send_guid_length,
                                        send_version_in_packet_,
+                                       options_.send_sequence_number_length,
                                        IN_FEC_GROUP);
     DCHECK_LE(packet_size_, options_.max_packet_length);
   }
 }
 
 // Stops serializing version of the protocol in packets sent after this call.
 // A packet that is already open might send kQuicVersionSize bytes less than the
 // maximum packet size if we stop sending version before it is serialized.
 void QuicPacketCreator::StopSendingVersion() {
   DCHECK(send_version_in_packet_);
   send_version_in_packet_ = false;
   if (packet_size_ > 0) {
     DCHECK_LT(kQuicVersionSize, packet_size_);
     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, is_in_fec_group) +
+  return GetPacketHeaderSize(guid_length, include_version,
+                             sequence_number_length, is_in_fec_group) +
       QuicFramer::GetMinStreamFrameSize() * num_frames;
 }
 
 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, IN_FEC_GROUP));
+                1, 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());
 
     bool set_fin = fin && bytes_consumed == data.size();  // Last frame.
@@ skipping 43 matching lines @@
 SerializedPacket QuicPacketCreator::SerializePacket() {
   DCHECK_EQ(false, queued_frames_.empty());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_number_, false, false, &header);
 
   SerializedPacket serialized = framer_->ConstructFrameDataPacket(
       header, queued_frames_, packet_size_);
   queued_frames_.clear();
   packet_size_ = GetPacketHeaderSize(options_.send_guid_length,
                                      send_version_in_packet_,
+                                     options_.send_sequence_number_length,
                                      fec_group_.get() != NULL ?
                                          IN_FEC_GROUP : NOT_IN_FEC_GROUP);
   serialized.retransmittable_frames = queued_retransmittable_frames_.release();
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec() {
   DCHECK_LT(0u, fec_group_->NumReceivedPackets());
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_number_, true,
                    fec_group_->entropy_parity(), &header);
   QuicFecData fec_data;
   fec_data.fec_group = fec_group_->min_protected_packet();
   fec_data.redundancy = fec_group_->payload_parity();
   SerializedPacket serialized = framer_->ConstructFecPacket(header, fec_data);
   fec_group_.reset(NULL);
   fec_group_number_ = 0;
   // Reset packet_size_, since the next packet may not have an FEC group.
   packet_size_ = GetPacketHeaderSize(options_.send_guid_length,
                                      send_version_in_packet_,
+                                     options_.send_sequence_number_length,
                                      NOT_IN_FEC_GROUP);
   DCHECK(serialized.packet);
   DCHECK_GE(options_.max_packet_length, serialized.packet->length());
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeConnectionClose(
     QuicConnectionCloseFrame* close_frame) {
   QuicFrames frames;
   frames.push_back(QuicFrame(close_frame));
@@ skipping 68 matching lines @@
       queued_frames_.push_back(
           queued_retransmittable_frames_->AddNonStreamFrame(frame));
     }
   } else {
     queued_frames_.push_back(frame);
   }
   return true;
 }
 
 }  // namespace net