API changes to Write path Session on down for FEC protection.

net/quic/quic_connection.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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 971 matching lines @@
   }
 
   pending_version_negotiation_packet_ = false;
 }
 
 QuicConsumedData QuicConnection::SendStreamData(
     QuicStreamId id,
     const IOVector& data,
     QuicStreamOffset offset,
     bool fin,
+    FecProtection fec_protection,
     QuicAckNotifier::DelegateInterface* delegate) {
   if (!fin && data.Empty()) {
     LOG(DFATAL) << "Attempt to send empty stream frame";
   }
 
   // This notifier will be owned by the AckNotifierManager (or deleted below if
   // no data or FIN was consumed).
   QuicAckNotifier* notifier = NULL;
   if (delegate) {
     notifier = new QuicAckNotifier(delegate);
   }
 
   // Opportunistically bundle an ack with every outgoing packet.
   // Particularly, we want to bundle with handshake packets since we don't know
   // which decrypter will be used on an ack packet following a handshake
   // packet (a handshake packet from client to server could result in a REJ or a
   // SHLO from the server, leading to two different decrypters at the server.)
   //
   // TODO(jri): Note that ConsumeData may cause a response packet to be sent.
   // We may end up sending stale ack information if there are undecryptable
   // packets hanging around and/or there are revivable packets which may get
   // handled after this packet is sent. Change ScopedPacketBundler to do the
   // right thing: check ack_queued_, and then check undecryptable packets and
   // also if there is possibility of revival. Only bundle an ack if there's no
   // processing left that may cause received_info_ to change.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   QuicConsumedData consumed_data =
-      packet_generator_.ConsumeData(id, data, offset, fin, notifier);
+      packet_generator_.ConsumeData(id, data, offset, fin, fec_protection,
+                                    notifier);
 
   if (notifier &&
       (consumed_data.bytes_consumed == 0 && !consumed_data.fin_consumed)) {
     // No data was consumed, nor was a fin consumed, so delete the notifier.
     delete notifier;
   }
 
   return consumed_data;
 }
 
@@ skipping 533 matching lines @@
   if (retransmission_alarm_->IsSet()) {
     return;
   }
   if (version() <= QUIC_VERSION_17) {
     // TODO(rch): remove this when we remove version 17.
     // This is a horrible hideous hack which we should not support.
     IOVector data;
     char c_data[] = "C";
     data.Append(c_data, 1);
     QuicConsumedData consumed_data =
-        packet_generator_.ConsumeData(kCryptoStreamId, data, 0, false, NULL);
+        packet_generator_.ConsumeData(kCryptoStreamId, data, 0, false,
+                                      MAY_FEC_PROTECT, NULL);
     if (consumed_data.bytes_consumed == 0) {
       DLOG(ERROR) << "Unable to send ping!?";
     }
   } else {
     packet_generator_.AddControlFrame(QuicFrame(new QuicPingFrame));
   }
 }
 
 void QuicConnection::SendAck() {
   ack_alarm_->Cancel();
@@ skipping 378 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net