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/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
@@ skipping 50 matching lines @@
                                      bool is_server)
     : connection_id_(connection_id),
       encryption_level_(ENCRYPTION_NONE),
       framer_(framer),
       random_bool_source_(new QuicRandomBoolSource(random_generator)),
       sequence_number_(0),
       should_fec_protect_(false),
       fec_group_number_(0),
       is_server_(is_server),
       send_version_in_packet_(!is_server),
-      sequence_number_length_(options_.send_sequence_number_length),
+      max_packet_length_(kDefaultMaxPacketSize),
+      max_packets_per_fec_group_(0),
+      connection_id_length_(PACKET_8BYTE_CONNECTION_ID),
+      next_sequence_number_length_(PACKET_1BYTE_SEQUENCE_NUMBER),
+      sequence_number_length_(next_sequence_number_length_),
       packet_size_(0) {
   framer_->set_fec_builder(this);
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
 }
 
 void QuicPacketCreator::OnBuiltFecProtectedPayload(
     const QuicPacketHeader& header, StringPiece payload) {
   if (fec_group_.get()) {
     DCHECK_NE(0u, header.fec_group);
     fec_group_->Update(encryption_level_, 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);
+                      max_packets_per_fec_group_);
 }
 
 void QuicPacketCreator::StartFecProtectingPackets() {
   if (!IsFecEnabled()) {
     LOG(DFATAL) << "Cannot start FEC protection when FEC is not enabled.";
     return;
   }
   // TODO(jri): This currently requires that the generator flush out any
   // pending frames when FEC protection is turned on. If current packet can be
   // converted to an FEC protected packet, do it. This will require the
@@ skipping 15 matching lines @@
   DCHECK(should_fec_protect_);
   should_fec_protect_ = false;
   fec_group_number_ = 0;
 }
 
 bool QuicPacketCreator::IsFecProtected() const {
   return should_fec_protect_;
 }
 
 bool QuicPacketCreator::IsFecEnabled() const {
-  return options_.max_packets_per_fec_group > 0;
-}
-
-size_t QuicPacketCreator::max_packets_per_fec_group() const {
-  return options_.max_packets_per_fec_group;
-}
-
-void QuicPacketCreator::set_max_packets_per_fec_group(
-    size_t max_packets_per_fec_group) {
-  // To turn off FEC protection, use StopFecProtectingPackets().
-  DCHECK_NE(0u, max_packets_per_fec_group);
-  options_.max_packets_per_fec_group = max_packets_per_fec_group;
+  return max_packets_per_fec_group_ > 0;
 }
 
 InFecGroup QuicPacketCreator::MaybeUpdateLengthsAndStartFec() {
   if (fec_group_.get() != NULL) {
     // Don't update any lengths when an FEC group is open, to ensure same
     // packet header size in all packets within a group.
     return IN_FEC_GROUP;
   }
   if (!queued_frames_.empty()) {
     // Don't change creator state if there are frames queued.
     return fec_group_.get() == NULL ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
   }
-  // TODO(jri): Add max_packet_length and send_connection_id_length here too.
-  sequence_number_length_ = options_.send_sequence_number_length;
+
+  // Update sequence number length only on packet and FEC group boundaries.
+  sequence_number_length_ = next_sequence_number_length_;
 
   if (!should_fec_protect_) {
     return NOT_IN_FEC_GROUP;
   }
   // Start a new FEC group since protection is on. Set the fec group number to
   // the sequence number of the next packet.
   fec_group_number_ = sequence_number() + 1;
   fec_group_.reset(new QuicFecGroup());
   return IN_FEC_GROUP;
 }
@@ skipping 10 matching lines @@
   }
 }
 
 void QuicPacketCreator::UpdateSequenceNumberLength(
       QuicPacketSequenceNumber least_packet_awaited_by_peer,
       QuicByteCount congestion_window) {
   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
+      max_packets_per_fec_group_ + sequence_number_ + 1
       - least_packet_awaited_by_peer;
   const uint64 congestion_window_packets =
-      congestion_window / options_.max_packet_length;
+      congestion_window / max_packet_length_;
   const uint64 delta = max(current_delta, congestion_window_packets);
-  options_.send_sequence_number_length =
+  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,
@@ skipping 14 matching lines @@
       // Assumes this is a stream with a single lone packet.
       QuicFramer::GetMinStreamFrameSize(version, 1u, offset, true,
                                         is_in_fec_group);
 }
 
 size_t QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                             const IOVector& data,
                                             QuicStreamOffset offset,
                                             bool fin,
                                             QuicFrame* frame) {
-  DCHECK_GT(options_.max_packet_length,
-            StreamFramePacketOverhead(
+  DCHECK_GT(max_packet_length_, StreamFramePacketOverhead(
                 framer_->version(), 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);
@@ skipping 36 matching lines @@
   frame->stream_frame->notifier = notifier;
 
   return bytes_consumed;
 }
 
 SerializedPacket QuicPacketCreator::ReserializeAllFrames(
     const QuicFrames& frames,
     QuicSequenceNumberLength original_length) {
   DCHECK(fec_group_.get() == NULL);
   const QuicSequenceNumberLength saved_length = sequence_number_length_;
-  const QuicSequenceNumberLength saved_options_length =
-      options_.send_sequence_number_length;
+  const QuicSequenceNumberLength saved_next_length =
+      next_sequence_number_length_;
   const bool saved_should_fec_protect = should_fec_protect_;
 
   // Temporarily set the sequence number length and stop FEC protection.
   sequence_number_length_ = original_length;
-  options_.send_sequence_number_length = original_length;
+  next_sequence_number_length_ = original_length;
   should_fec_protect_ = false;
 
   // Serialize the packet and restore the FEC and sequence number length state.
   SerializedPacket serialized_packet = SerializeAllFrames(frames);
   sequence_number_length_ = saved_length;
-  options_.send_sequence_number_length = saved_options_length;
+  next_sequence_number_length_ = saved_next_length;
   should_fec_protect_ = saved_should_fec_protect;
 
   return serialized_packet;
 }
 
 SerializedPacket QuicPacketCreator::SerializeAllFrames(
     const QuicFrames& frames) {
   // TODO(satyamshekhar): Verify that this DCHECK won't fail. What about queued
   // frames from SendStreamData()[send_stream_should_flush_ == false &&
   // data.empty() == true] and retransmit due to RTO.
@@ skipping 20 matching lines @@
   }
   // If the last frame in the packet is a stream frame, then it will expand to
   // include the stream_length field when a new frame is added.
   bool has_trailing_stream_frame =
       !queued_frames_.empty() && queued_frames_.back().type == STREAM_FRAME;
   return has_trailing_stream_frame ? kQuicStreamPayloadLengthSize : 0;
 }
 
 size_t QuicPacketCreator::BytesFree() const {
   const size_t max_plaintext_size =
-      framer_->GetMaxPlaintextSize(options_.max_packet_length);
+      framer_->GetMaxPlaintextSize(max_packet_length_);
   DCHECK_GE(max_plaintext_size, PacketSize());
   return max_plaintext_size - min(max_plaintext_size, PacketSize()
                                   + ExpansionOnNewFrame());
 }
 
 size_t QuicPacketCreator::PacketSize() const {
-  if (queued_frames_.empty()) {
-    // Only adjust the sequence number length when the FEC group is not open,
-    // to ensure no packets in a group are too large.
-    if (fec_group_.get() == NULL ||
-        fec_group_->NumReceivedPackets() == 0) {
-      sequence_number_length_ = options_.send_sequence_number_length;
-    }
-    packet_size_ = GetPacketHeaderSize(options_.send_connection_id_length,
-                                       send_version_in_packet_,
-                                       sequence_number_length_,
-                                       should_fec_protect_ ? IN_FEC_GROUP :
-                                                             NOT_IN_FEC_GROUP);
+  if (!queued_frames_.empty()) {
+    return packet_size_;
   }
+  if (fec_group_.get() == NULL) {
+    // Update sequence number length on packet and FEC boundary.
+    sequence_number_length_ = next_sequence_number_length_;
+  }
+  packet_size_ = GetPacketHeaderSize(
+      connection_id_length_, send_version_in_packet_, sequence_number_length_,
+      should_fec_protect_ ? IN_FEC_GROUP : NOT_IN_FEC_GROUP);
   return packet_size_;
 }
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
   return AddFrame(frame, true);
 }
 
 SerializedPacket QuicPacketCreator::SerializePacket() {
   LOG_IF(DFATAL, queued_frames_.empty())
       << "Attempt to serialize empty packet";
   DCHECK_GE(sequence_number_ + 1, fec_group_number_);
   QuicPacketHeader header;
   FillPacketHeader(should_fec_protect_ ? fec_group_number_ : 0, false, &header);
 
   MaybeAddPadding();
 
   size_t max_plaintext_size =
-      framer_->GetMaxPlaintextSize(options_.max_packet_length);
+      framer_->GetMaxPlaintextSize(max_packet_length_);
   DCHECK_GE(max_plaintext_size, packet_size_);
   // ACK Frames will be truncated only if they're the only frame in the packet,
   // and if packet_size_ was set to max_plaintext_size. If truncation occurred,
   // then GetSerializedFrameLength will have returned all bytes free.
   bool possibly_truncated = packet_size_ == max_plaintext_size &&
                             queued_frames_.size() == 1 &&
                             queued_frames_.back().type == ACK_FRAME;
   SerializedPacket serialized =
       framer_->BuildDataPacket(header, queued_frames_, packet_size_);
   LOG_IF(DFATAL, !serialized.packet)
       << "Failed to serialize " << queued_frames_.size() << " frames.";
   // Because of possible truncation, we can't be confident that our
   // packet size calculation worked correctly.
   if (!possibly_truncated) {
     DCHECK_EQ(packet_size_, serialized.packet->length());
   }
-
   packet_size_ = 0;
   queued_frames_.clear();
   serialized.retransmittable_frames = queued_retransmittable_frames_.release();
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec() {
   if (fec_group_.get() == NULL || fec_group_->NumReceivedPackets() <= 0) {
     LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
     // TODO(jri): Make this a public method of framer?
     SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
     return kNoPacket;
   }
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_number_, true, &header);
   QuicFecData fec_data;
   fec_data.fec_group = fec_group_->min_protected_packet();
   fec_data.redundancy = fec_group_->payload_parity();
   SerializedPacket serialized = framer_->BuildFecPacket(header, fec_data);
   fec_group_.reset(NULL);
   packet_size_ = 0;
   LOG_IF(DFATAL, !serialized.packet)
       << "Failed to serialize fec packet for group:" << fec_data.fec_group;
-  DCHECK_GE(options_.max_packet_length, serialized.packet->length());
+  DCHECK_GE(max_packet_length_, serialized.packet->length());
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeConnectionClose(
     QuicConnectionCloseFrame* close_frame) {
   QuicFrames frames;
   frames.push_back(QuicFrame(close_frame));
   return SerializeAllFrames(frames);
 }
 
 QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   DCHECK(is_server_);
   QuicPacketPublicHeader header;
   header.connection_id = connection_id_;
   header.reset_flag = false;
   header.version_flag = true;
   header.versions = supported_versions;
   QuicEncryptedPacket* encrypted =
       framer_->BuildVersionNegotiationPacket(header, supported_versions);
   DCHECK(encrypted);
-  DCHECK_GE(options_.max_packet_length, encrypted->length());
+  DCHECK_GE(max_packet_length_, encrypted->length());
   return encrypted;
 }
 
 void QuicPacketCreator::FillPacketHeader(QuicFecGroupNumber fec_group,
                                          bool fec_flag,
                                          QuicPacketHeader* header) {
   header->public_header.connection_id = connection_id_;
   header->public_header.reset_flag = false;
   header->public_header.version_flag = send_version_in_packet_;
   header->fec_flag = fec_flag;
@@ skipping 66 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net