Adds dynamic FEC on/off switch in packet creator. Tightens use of

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 46 matching lines @@
 
 QuicPacketCreator::QuicPacketCreator(QuicConnectionId connection_id,
                                      QuicFramer* framer,
                                      QuicRandom* random_generator,
                                      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),
       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);
+      (force_close || fec_group_->NumReceivedPackets() >=
+                      options_.max_packets_per_fec_group);
 }
 
-InFecGroup QuicPacketCreator::MaybeStartFEC() {
-  if (IsFecEnabled() && fec_group_.get() == NULL) {
+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
+  // generator to check if the resulting expansion still allows the incoming
+  // frame to be added to the packet.
+  if (HasPendingFrames()) {
+    LOG(DFATAL) << "Cannot start FEC protection with pending frames.";
+    return;
+  }
+  DCHECK(!should_fec_protect_);
+  should_fec_protect_ = true;
+}
+
+void QuicPacketCreator::StopFecProtectingPackets() {
+  if (fec_group_.get() != NULL) {
+    LOG(DFATAL) << "Cannot stop FEC protection with open FEC group.";
+    return;
+  }
+  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;
+}
+
+InFecGroup QuicPacketCreator::MaybeStartFec() {
+  if (should_fec_protect_ && 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());
   }
   return fec_group_.get() == NULL ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
 }
 
 // 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
@@ skipping 23 matching lines @@
       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,
-                                        IsFecEnabled());
+                                        should_fec_protect_ ? IN_FEC_GROUP :
+                                                              NOT_IN_FEC_GROUP);
 }
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
     QuicVersion version,
     QuicConnectionIdLength connection_id_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length,
     InFecGroup is_in_fec_group) {
   return GetPacketHeaderSize(connection_id_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, 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(
                 framer_->version(), PACKET_8BYTE_CONNECTION_ID, kIncludeVersion,
                 PACKET_6BYTE_SEQUENCE_NUMBER, IN_FEC_GROUP));
-  InFecGroup is_in_fec_group = MaybeStartFEC();
+
+  InFecGroup is_in_fec_group = MaybeStartFec();
 
   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);
 
   if (data.Empty()) {
     LOG_IF(DFATAL, !fin)
         << "Creating a stream frame with no data or fin.";
@@ skipping 30 matching lines @@
   // a packet. At that point the notifier is informed of the sequence number
   // of the packet that this frame was eventually sent in.
   frame->stream_frame->notifier = notifier;
 
   return bytes_consumed;
 }
 
 SerializedPacket QuicPacketCreator::ReserializeAllFrames(
     const QuicFrames& frames,
     QuicSequenceNumberLength original_length) {
-  const QuicSequenceNumberLength start_length = sequence_number_length_;
-  const QuicSequenceNumberLength start_options_length =
+  DCHECK(fec_group_.get() == NULL);
+  const QuicSequenceNumberLength saved_length = sequence_number_length_;
+  const QuicSequenceNumberLength saved_options_length =
       options_.send_sequence_number_length;
-  const QuicFecGroupNumber start_fec_group = fec_group_number_;
-  const size_t start_max_packets_per_fec_group =
-      options_.max_packets_per_fec_group;
+  const bool saved_should_fec_protect = should_fec_protect_;
 
-  // Temporarily set the sequence number length and disable FEC.
+  // Temporarily set the sequence number length and stop FEC protection.
   sequence_number_length_ = original_length;
   options_.send_sequence_number_length = original_length;
-  fec_group_number_ = 0;
-  options_.max_packets_per_fec_group = 0;
+  should_fec_protect_ = false;
 
-  // Serialize the packet and restore the fec and sequence number length state.
+  // Serialize the packet and restore the FEC and sequence number length state.
   SerializedPacket serialized_packet = SerializeAllFrames(frames);
-  sequence_number_length_ = start_length;
-  options_.send_sequence_number_length = start_options_length;
-  fec_group_number_ = start_fec_group;
-  options_.max_packets_per_fec_group = start_max_packets_per_fec_group;
+  sequence_number_length_ = saved_length;
+  options_.send_sequence_number_length = saved_options_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.
   DCHECK_EQ(0u, queued_frames_.size());
   LOG_IF(DFATAL, frames.empty())
       << "Attempt to serialize empty packet";
   for (size_t i = 0; i < frames.size(); ++i) {
     bool success = AddFrame(frames[i], false);
     DCHECK(success);
   }
   SerializedPacket packet = SerializePacket();
   DCHECK(packet.retransmittable_frames == NULL);
   return packet;
 }
 
 bool QuicPacketCreator::HasPendingFrames() {
   return !queued_frames_.empty();
 }
 
 size_t QuicPacketCreator::ExpansionOnNewFrame() const {
   // If packet is FEC protected, there's no expansion.
-  if (fec_group_.get() != NULL) {
+  if (should_fec_protect_) {
       return 0;
   }
   // 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);
   DCHECK_GE(max_plaintext_size, PacketSize());
   return max_plaintext_size - min(max_plaintext_size, PacketSize()
                                   + ExpansionOnNewFrame());
 }
 
-InFecGroup QuicPacketCreator::IsFecEnabled() const {
-  return (options_.max_packets_per_fec_group == 0) ?
-          NOT_IN_FEC_GROUP : IN_FEC_GROUP;
-}
-
 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_,
-                                       IsFecEnabled());
+                                       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(fec_group_number_, false, &header);
+  FillPacketHeader(should_fec_protect_ ? fec_group_number_ : 0, false, &header);
 
   MaybeAddPadding();
 
   size_t max_plaintext_size =
       framer_->GetMaxPlaintextSize(options_.max_packet_length);
   DCHECK_GE(max_plaintext_size, packet_size_);
   // ACK and CONNECTION_CLOSE Frames will be truncated only if they're
   // the first frame in the packet.  If truncation is to occur, then
   // GetSerializedFrameLength will have returned all bytes free.
   bool possibly_truncated =
@@ skipping 24 matching lines @@
     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);
-  fec_group_number_ = 0;
   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());
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeConnectionClose(
     QuicConnectionCloseFrame* close_frame) {
   QuicFrames frames;
@@ skipping 38 matching lines @@
     case STOP_WAITING_FRAME:
       return false;
     default:
       return true;
   }
 }
 
 bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
                                  bool save_retransmittable_frames) {
   DVLOG(1) << "Adding frame: " << frame;
-  InFecGroup is_in_fec_group = MaybeStartFEC();
+  InFecGroup is_in_fec_group = MaybeStartFec();
   size_t frame_len = framer_->GetSerializedFrameLength(
       frame, BytesFree(), queued_frames_.empty(), true, is_in_fec_group,
       options()->send_sequence_number_length);
   if (frame_len == 0) {
     return false;
   }
   DCHECK_LT(0u, packet_size_);
   packet_size_ += ExpansionOnNewFrame() + frame_len;
 
   if (save_retransmittable_frames && ShouldRetransmit(frame)) {
@@ skipping 32 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net