QuicPacketCreator knows when to start FEC protection.

net/quic/quic_packet_generator.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_generator.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_flags.h"
@@ skipping 100 matching lines @@
       has_handshake && packet_creator_.HasPendingRetransmittableFrames();
   SendQueuedFrames(flush, /*is_fec_timeout=*/false);
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   if (!packet_creator_.HasRoomForStreamFrame(id, offset)) {
     packet_creator_.Flush();
   }
 
-  if (fec_protection == MUST_FEC_PROTECT) {
-    packet_creator_.set_should_fec_protect(true);
-    packet_creator_.MaybeStartFecProtection();
-  }
-
   if (!fin && (iov.total_length == 0)) {
     LOG(DFATAL) << "Attempt to consume empty data without FIN.";
     return QuicConsumedData(0, false);
   }
 
   while (delegate_->ShouldGeneratePacket(
       HAS_RETRANSMITTABLE_DATA, has_handshake ? IS_HANDSHAKE : NOT_HANDSHAKE)) {
     QuicFrame frame;
     if (!packet_creator_.ConsumeData(id, iov, total_bytes_consumed,
                                      offset + total_bytes_consumed, fin,
-                                     has_handshake, &frame)) {
+                                     has_handshake, &frame, fec_protection)) {
       // Current packet is full and flushed.
       continue;
     }
 
     // A stream frame is created and added.
     size_t bytes_consumed = frame.stream_frame->frame_length;
     if (debug_delegate_ != nullptr) {
       debug_delegate_->OnFrameAddedToPacket(frame);
     }
 
@@ skipping 13 matching lines @@
       packet_creator_.Flush();
     }
 
     if (total_bytes_consumed == iov.total_length) {
       // We're done writing the data. Exit the loop.
       // We don't make this a precondition because we could have 0 bytes of data
       // if we're simply writing a fin.
       if (fec_protection == MUST_FEC_PROTECT) {
         // Turn off FEC protection when we're done writing protected data.
         DVLOG(1) << "Turning FEC protection OFF";
-        packet_creator_.set_should_fec_protect(false);
+        packet_creator_.set_should_fec_protect_next_packet(false);
       }
       break;
     }
   }
 
   // Don't allow the handshake to be bundled with other retransmittable frames.
   if (has_handshake) {
     SendQueuedFrames(/*flush=*/true, /*is_fec_timeout=*/false);
   }
 
@@ skipping 220 matching lines @@
 void QuicPacketGenerator::SetEncrypter(EncryptionLevel level,
                                        QuicEncrypter* encrypter) {
   packet_creator_.SetEncrypter(level, encrypter);
 }
 
 void QuicPacketGenerator::OnSerializedPacket(
     SerializedPacket* serialized_packet) {
   if (serialized_packet->packet == nullptr) {
     LOG(DFATAL) << "Failed to SerializePacket. fec_policy:" << fec_send_policy()
                 << " should_fec_protect_:"
-                << packet_creator_.should_fec_protect();
+                << packet_creator_.should_fec_protect_next_packet();
     delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
     return;
   }
 
   // There may be AckListeners interested in this packet.
   serialized_packet->listeners.swap(ack_listeners_);
   ack_listeners_.clear();
 
   delegate_->OnSerializedPacket(*serialized_packet);
   packet_creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/false,
@@ skipping 22 matching lines @@
 
 FecSendPolicy QuicPacketGenerator::fec_send_policy() {
   return packet_creator_.fec_send_policy();
 }
 
 void QuicPacketGenerator::set_fec_send_policy(FecSendPolicy fec_send_policy) {
   packet_creator_.set_fec_send_policy(fec_send_policy);
 }
 
 }  // namespace net