Land Recent QUIC changes.

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/logging.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
@@ skipping 37 matching lines @@
         break;
       case NUM_FRAME_TYPES:
         DCHECK(false) << "Cannot delete type: " << it->type;
     }
   }
 }
 
 void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback) {
   should_send_ack_ = true;
   should_send_feedback_ = also_send_feedback;
-  SendQueuedData();
+  SendQueuedFrames();
 }
 
 
 void QuicPacketGenerator::AddControlFrame(const QuicFrame& frame) {
   queued_control_frames_.push_back(frame);
-  SendQueuedData();
+  SendQueuedFrames();
 }
 
 QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
                                                   StringPiece data,
                                                   QuicStreamOffset offset,
                                                   bool fin) {
-  SendQueuedData();
+  SendQueuedFrames();
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   while (delegate_->CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA)) {
-    // TODO(rch) figure out FEC.
-    // packet_creator_.MaybeStartFEC();
     QuicFrame frame;
     size_t bytes_consumed = packet_creator_->CreateStreamFrame(
         id, data, offset + total_bytes_consumed, fin, &frame);
     bool success = packet_creator_->AddSavedFrame(frame);
     DCHECK(success);
 
     total_bytes_consumed += bytes_consumed;
     fin_consumed = fin && bytes_consumed == data.size();
     data.remove_prefix(bytes_consumed);
     DCHECK(data.empty() || packet_creator_->BytesFree() == 0u);
@@ skipping 16 matching lines @@
   if (should_flush_ && packet_creator_->ShouldSendFec(true)) {
     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
     DCHECK(serialized_fec.packet);
     delegate_->OnSerializedPacket(serialized_fec);
   }
 
   DCHECK(!should_flush_ || !packet_creator_->HasPendingFrames());
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
 }
 
-void QuicPacketGenerator::SendQueuedData() {
-  while (HasPendingData() && delegate_->CanWrite(NOT_RETRANSMISSION,
+void QuicPacketGenerator::SendQueuedFrames() {
+  packet_creator_->MaybeStartFEC();
+  while (HasPendingFrames() && delegate_->CanWrite(NOT_RETRANSMISSION,
              packet_creator_->HasPendingFrames() ?
                  HAS_RETRANSMITTABLE_DATA : NO_RETRANSMITTABLE_DATA)) {
     if (!AddNextPendingFrame()) {
       // Packet was full, so serialize and send it.
       SerializeAndSendPacket();
     }
   }
 
   if (should_flush_) {
     if (packet_creator_->HasPendingFrames()) {
       SerializeAndSendPacket();
     }
 
     // Ensure the FEC group is closed at the end of this method unless other
     // writes are pending.
     if (packet_creator_->ShouldSendFec(true)) {
       SerializedPacket serialized_fec = packet_creator_->SerializeFec();
       DCHECK(serialized_fec.packet);
       delegate_->OnSerializedPacket(serialized_fec);
+      packet_creator_->MaybeStartFEC();
     }
   }
 }
 
 void QuicPacketGenerator::StartBatchOperations() {
   should_flush_ = false;
 }
 
 void QuicPacketGenerator::FinishBatchOperations() {
   should_flush_ = true;
-  SendQueuedData();
+  SendQueuedFrames();
 }
 
-bool QuicPacketGenerator::HasQueuedData() const {
-  return packet_creator_->HasPendingFrames() || HasPendingData();
+bool QuicPacketGenerator::HasQueuedFrames() const {
+  return packet_creator_->HasPendingFrames() || HasPendingFrames();
 }
 
-bool QuicPacketGenerator::HasPendingData() const {
+bool QuicPacketGenerator::HasPendingFrames() const {
   return should_send_ack_ || should_send_feedback_ ||
       !queued_control_frames_.empty();
 }
 
 bool QuicPacketGenerator::AddNextPendingFrame() {
   if (should_send_ack_) {
     pending_ack_frame_.reset(delegate_->CreateAckFrame());
     if (!packet_creator_->AddSavedFrame(QuicFrame(pending_ack_frame_.get()))) {
       // packet was full
       return false;
@@ skipping 16 matching lines @@
   DCHECK(!queued_control_frames_.empty());
   if (!packet_creator_->AddSavedFrame(queued_control_frames_.back())) {
     // packet was full
     return false;
   }
   queued_control_frames_.pop_back();
   return true;
 }
 
 void QuicPacketGenerator::SerializeAndSendPacket() {
-  packet_creator_->MaybeStartFEC();
   SerializedPacket serialized_packet = packet_creator_->SerializePacket();
   DCHECK(serialized_packet.packet);
   delegate_->OnSerializedPacket(serialized_packet);
 
   if (packet_creator_->ShouldSendFec(false)) {
     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
     DCHECK(serialized_fec.packet);
     delegate_->OnSerializedPacket(serialized_fec);
+    packet_creator_->MaybeStartFEC();
   }
 }
 
 }  // namespace net