API changes to Write path Session on down for 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_utils.h"
@@ skipping 75 matching lines @@
 
 void QuicPacketGenerator::AddControlFrame(const QuicFrame& frame) {
   queued_control_frames_.push_back(frame);
   SendQueuedFrames(false);
 }
 
 QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
                                                   const IOVector& data_to_write,
                                                   QuicStreamOffset offset,
                                                   bool fin,
+                                                  FecProtection fec_protection,
                                                   QuicAckNotifier* notifier) {
   IsHandshake handshake = id == kCryptoStreamId ? IS_HANDSHAKE : NOT_HANDSHAKE;
   SendQueuedFrames(false);
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   if (!packet_creator_->HasRoomForStreamFrame(id, offset)) {
     SerializeAndSendPacket();
   }
 
+  if (fec_protection == MUST_FEC_PROTECT) {
+    MaybeStartFecProtection();
+  }
+
   IOVector data = data_to_write;
   size_t data_size = data.TotalBufferSize();
   while (delegate_->ShouldGeneratePacket(NOT_RETRANSMISSION,
                                          HAS_RETRANSMITTABLE_DATA, handshake)) {
     QuicFrame frame;
     size_t bytes_consumed;
     if (notifier != NULL) {
       // We want to track which packet this stream frame ends up in.
       bytes_consumed = packet_creator_->CreateStreamFrameWithNotifier(
           id, data, offset + total_bytes_consumed, fin, notifier, &frame);
@@ skipping 16 matching lines @@
 
     // TODO(ianswett): Restore packet reordering.
     if (!InBatchMode() || !packet_creator_->HasRoomForStreamFrame(id, offset)) {
       SerializeAndSendPacket();
     }
 
     if (data.Empty()) {
       // 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";
+        should_fec_protect_ = false;
+      }
       break;
     }
   }
 
   // Try to close FEC group since we've either run out of data to send or we're
   // blocked. If not in batch mode, force close the group.
   MaybeSendFecPacketAndCloseGroup(!InBatchMode());
 
   DCHECK(InBatchMode() || !packet_creator_->HasPendingFrames());
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
@@ skipping 46 matching lines @@
     // 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.
     SendQueuedFrames(true);
   }
   packet_creator_->StartFecProtectingPackets();
   DCHECK(packet_creator_->IsFecProtected());
 }
 
-void QuicPacketGenerator::MaybeStopFecProtection(bool force) {
-  DVLOG(1) << "Turning FEC protection OFF";
-  // FEC protection will stop after the next FEC packet is transmitted.
-  should_fec_protect_ = false;
-  MaybeSendFecPacketAndCloseGroup(force);
-}
-
 void QuicPacketGenerator::MaybeSendFecPacketAndCloseGroup(bool force) {
   if (!packet_creator_->IsFecProtected() ||
       packet_creator_->HasPendingFrames()) {
     return;
   }
 
   if (packet_creator_->ShouldSendFec(force)) {
     // TODO(jri): SerializeFec can return a NULL packet, and this should
     // cause an early return, with a call to
     // delegate_->OnPacketGenerationError.
@@ skipping 85 matching lines @@
 }
 
 void QuicPacketGenerator::SerializeAndSendPacket() {
   SerializedPacket serialized_packet = packet_creator_->SerializePacket();
   DCHECK(serialized_packet.packet);
   delegate_->OnSerializedPacket(serialized_packet);
   MaybeSendFecPacketAndCloseGroup(false);
 }
 
 }  // namespace net