Land Recent QUIC Changes.

net/quic/quic_packet_creator.cc

Index: net/quic/quic_packet_creator.cc
diff --git a/net/quic/quic_packet_creator.cc b/net/quic/quic_packet_creator.cc
index 4b64ae503d572b494038a67514e08a56d9e92315..f7d2d14a13f9e54e5ea5dc8989539478abe37836 100644
--- a/net/quic/quic_packet_creator.cc
+++ b/net/quic/quic_packet_creator.cc
@@ -68,7 +68,11 @@ QuicPacketCreator::QuicPacketCreator(QuicConnectionId connection_id,
       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);
 }
@@ -87,7 +91,7 @@ void QuicPacketCreator::OnBuiltFecProtectedPayload(
 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() {
@@ -123,18 +127,7 @@ bool QuicPacketCreator::IsFecProtected() const {
 }
 
 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() {
@@ -147,8 +140,9 @@ InFecGroup QuicPacketCreator::MaybeUpdateLengthsAndStartFec() {
     // 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;
@@ -179,12 +173,12 @@ void QuicPacketCreator::UpdateSequenceNumberLength(
   // 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);
 }
 
@@ -219,8 +213,7 @@ size_t QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                             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));
 
@@ -277,19 +270,19 @@ SerializedPacket QuicPacketCreator::ReserializeAllFrames(
     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;
@@ -330,26 +323,23 @@ size_t QuicPacketCreator::ExpansionOnNewFrame() const {
 
 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_;
 }
 
@@ -367,7 +357,7 @@ SerializedPacket QuicPacketCreator::SerializePacket() {
   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,
@@ -384,7 +374,6 @@ SerializedPacket QuicPacketCreator::SerializePacket() {
   if (!possibly_truncated) {
     DCHECK_EQ(packet_size_, serialized.packet->length());
   }
-
   packet_size_ = 0;
   queued_frames_.clear();
   serialized.retransmittable_frames = queued_retransmittable_frames_.release();
@@ -409,7 +398,7 @@ SerializedPacket QuicPacketCreator::SerializeFec() {
   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;
 }
 
@@ -431,7 +420,7 @@ QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
   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;
 }