Set QuicPacketCreator's should_fec_protect_next_packet only within QuicPacketCreator. No functiona…

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 253 matching lines @@
   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);
   if (needs_padding) {
     needs_padding_ = true;
   }
   DCHECK(success);
+  if (fec_protection == MUST_FEC_PROTECT &&
+      iov_offset + frame->stream_frame->frame_length == iov.total_length) {
+    // Turn off FEC protection when we're done writing protected data.
+    DVLOG(1) << "Turning FEC protection OFF";
+    should_fec_protect_next_packet_ = false;
+  }
   return true;
 }
 
 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(
@@ skipping 168 matching lines @@
   // value from CACHELINE_SIZE).
   ALIGNAS(64) char seralized_packet_buffer[kMaxPacketSize];
   SerializedPacket serialized_packet =
       SerializePacket(seralized_packet_buffer, kMaxPacketSize);
   OnSerializedPacket(&serialized_packet);
 }
 
 void QuicPacketCreator::OnSerializedPacket(SerializedPacket* packet) {
   if (packet->packet == nullptr) {
     LOG(DFATAL) << "Failed to SerializePacket. fec_policy:" << fec_send_policy()
-                << " should_fec_protect_:" << should_fec_protect_next_packet();
+                << " should_fec_protect_:" << should_fec_protect_next_packet_;
     delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
     return;
   }
   // There may be AckListeners interested in this packet.
   packet->listeners.swap(ack_listeners_);
   DCHECK(ack_listeners_.empty());
   delegate_->OnSerializedPacket(packet);
   has_ack_ = false;
   has_stop_waiting_ = false;
   MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/false,
@@ skipping 355 matching lines @@
   hash_map<QuicPathId, QuicPacketNumber>::iterator it =
       multipath_packet_number_.find(path_id);
   // If path_id is not in the map, it's a new path. Set packet_number to 0.
   packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
   current_path_ = path_id;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net