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_ack_notifier.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
+using std::max;
 using std::min;
 using std::pair;
 using std::vector;
 
 namespace net {
 
 QuicPacketCreator::QuicPacketCreator(QuicGuid guid,
                                      QuicFramer* framer,
                                      QuicRandom* random_generator,
                                      bool is_server)
@@ skipping 39 matching lines @@
 // 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;
   }
 }
 
+void QuicPacketCreator::UpdateSequenceNumberLength(
+      QuicPacketSequenceNumber least_packet_awaited_by_peer,
+      QuicByteCount bytes_per_second) {
+  DCHECK_LE(least_packet_awaited_by_peer, sequence_number_ + 1);
+  // Since the packet creator will not change sequence number length mid FEC
+  // group, include the size of an FEC group to be safe.
+  const QuicPacketSequenceNumber current_delta =
+      options_.max_packets_per_fec_group + sequence_number_ + 1
+      - least_packet_awaited_by_peer;
+  const uint64 congestion_window =
+      bytes_per_second / options_.max_packet_length;
+  const uint64 delta = max(current_delta, congestion_window);
+
+  if (delta < 1 << ((PACKET_1BYTE_SEQUENCE_NUMBER * 8) - 2)) {
+    options_.send_sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
+  } else if (delta < 1 << ((PACKET_2BYTE_SEQUENCE_NUMBER * 8) - 2)) {
+    options_.send_sequence_number_length = PACKET_2BYTE_SEQUENCE_NUMBER;
+  } else if (delta < 1 << ((PACKET_4BYTE_SEQUENCE_NUMBER * 8) - 2)) {
+    options_.send_sequence_number_length = PACKET_4BYTE_SEQUENCE_NUMBER;
+  } else {
+    options_.send_sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
+  }
+}
+
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
                                               QuicStreamOffset offset) const {
   return BytesFree() >
       QuicFramer::GetMinStreamFrameSize(framer_->version(), id, offset, true);
 }
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
     QuicVersion version,
     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) +
       // Assumes this is a stream with a single lone packet.
       QuicFramer::GetMinStreamFrameSize(version, 1u, 0u, true);
 }
 
 size_t QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                             StringPiece data,
                                             QuicStreamOffset offset,
                                             bool fin,
                                             QuicFrame* frame) {
   DCHECK_GT(options_.max_packet_length,
             StreamFramePacketOverhead(
                 framer_->version(), PACKET_8BYTE_GUID, kIncludeVersion,
                 PACKET_6BYTE_SEQUENCE_NUMBER, IN_FEC_GROUP));
-  DCHECK(HasRoomForStreamFrame(id, offset));
+  if (!HasRoomForStreamFrame(id, offset)) {
+    LOG(DFATAL) << "No room for Stream frame, BytesFree: " << BytesFree()
+                << " MinStreamFrameSize: "
+                << QuicFramer::GetMinStreamFrameSize(
+                    framer_->version(), id, offset, true);
+  }
 
   const size_t free_bytes = BytesFree();
   size_t bytes_consumed = 0;
 
   if (data.size() != 0) {
     // When a STREAM frame is the last frame in a packet, it consumes two fewer
     // bytes of framing overhead.
     // Anytime more data is available than fits in with the extra two bytes,
     // the frame will be the last, and up to two extra bytes are consumed.
     // TODO(ianswett): If QUIC pads, the 1 byte PADDING frame does not fit when
@@ skipping 234 matching lines @@
       queued_frames_.push_back(
           queued_retransmittable_frames_->AddNonStreamFrame(frame));
     }
   } else {
     queued_frames_.push_back(frame);
   }
   return true;
 }
 
 }  // namespace net