QuicPacketCreator knows when to start FEC protection.

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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 73 matching lines @@
 QuicPacketCreator::QuicPacketCreator(QuicConnectionId connection_id,
                                      QuicFramer* framer,
                                      QuicRandom* random_generator,
                                      DelegateInterface* delegate)
     : delegate_(delegate),
       connection_id_(connection_id),
       encryption_level_(ENCRYPTION_NONE),
       framer_(framer),
       random_bool_source_(new QuicRandomBoolSource(random_generator)),
       packet_number_(0),
-      should_fec_protect_(false),
+      should_fec_protect_next_packet_(false),
       fec_protect_(false),
       send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
       max_packet_length_(0),
       max_packets_per_fec_group_(kDefaultMaxPacketsPerFecGroup),
       connection_id_length_(PACKET_8BYTE_CONNECTION_ID),
       next_packet_number_length_(PACKET_1BYTE_PACKET_NUMBER),
       packet_number_length_(next_packet_number_length_),
       packet_size_(0),
       needs_padding_(false),
       fec_send_policy_(FEC_ANY_TRIGGER),
@@ skipping 139 matching lines @@
   next_packet_number_length_ =
       QuicFramer::GetMinSequenceNumberLength(delta * 4);
 }
 
 bool QuicPacketCreator::ConsumeData(QuicStreamId id,
                                     QuicIOVector iov,
                                     size_t iov_offset,
                                     QuicStreamOffset offset,
                                     bool fin,
                                     bool needs_padding,
-                                    QuicFrame* frame) {
+                                    QuicFrame* frame,
+                                    FecProtection fec_protection) {
   if (!HasRoomForStreamFrame(id, offset)) {
     Flush();
     return false;
   }
 
   UniqueStreamBuffer buffer;
+  if (fec_protection == MUST_FEC_PROTECT) {
+    should_fec_protect_next_packet_ = true;
+    MaybeStartFecProtection();
+  }
   CreateStreamFrame(id, iov, iov_offset, offset, fin, frame);
-
   bool success = AddFrame(*frame,
                           /*save_retransmittable_frames=*/true, needs_padding,
                           std::move(buffer));
   DCHECK(success);
   return true;
 }
 
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
                                               QuicStreamOffset offset) const {
   // TODO(jri): This is a simple safe decision for now, but make
@@ skipping 482 matching lines @@
     } else {
       // TODO(zhongyi): Change the default 64 alignas value (used the default
       // value from CACHELINE_SIZE).
       ALIGNAS(64) char seralized_fec_buffer[kMaxPacketSize];
       SerializedPacket serialized_fec =
           SerializeFec(seralized_fec_buffer, kMaxPacketSize);
       delegate_->OnSerializedPacket(&serialized_fec);
     }
   }
 
-  if (!should_fec_protect_ && fec_protect_ && !IsFecGroupOpen()) {
+  if (!should_fec_protect_next_packet_ && fec_protect_ && !IsFecGroupOpen()) {
     StopFecProtectingPackets();
   }
 }
 
 QuicTime::Delta QuicPacketCreator::GetFecTimeout(
     QuicPacketNumber packet_number) {
   // Do not set up FEC alarm for |packet_number| it is not the first packet in
   // the current group.
   if (fec_group_.get() != nullptr &&
       (packet_number == fec_group_->FecGroupNumber())) {
     return QuicTime::Delta::Max(
         fec_timeout_, QuicTime::Delta::FromMilliseconds(kMinFecTimeoutMs));
   }
   return QuicTime::Delta::Infinite();
 }
 
 void QuicPacketCreator::OnCongestionWindowChange(
     QuicPacketCount max_packets_in_flight) {
   set_max_packets_per_fec_group(static_cast<size_t>(
       kMaxPacketsInFlightMultiplierForFecGroupSize * max_packets_in_flight));
 }
 
 void QuicPacketCreator::OnRttChange(QuicTime::Delta rtt) {
   fec_timeout_ = rtt.Multiply(rtt_multiplier_for_fec_timeout_);
 }
 
 }  // namespace net