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/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 
 namespace net {
 
+namespace {
+
+// We want to put some space between a protected packet and the FEC packet to
+// avoid losing them both within the same loss episode. On the other hand,
+// we expect to be able to recover from any loss in about an RTT.
+// We resolve this tradeoff by sending an FEC packet atmost half an RTT,
+// or equivalently, half a cwnd, after the first protected packet. Since we
+// don't want to delay an FEC packet past half an RTT, we set the max FEC
+// group size to be half the current congestion window.
+const float kCongestionWindowMultiplierForFecGroupSize = 0.5;
+
+}  // namespace
+
 class QuicAckNotifier;
 
 QuicPacketGenerator::QuicPacketGenerator(QuicConnectionId connection_id,
                                          QuicFramer* framer,
                                          QuicRandom* random_generator,
                                          DelegateInterface* delegate)
     : delegate_(delegate),
       debug_delegate_(NULL),
       packet_creator_(connection_id, framer, random_generator),
       batch_mode_(false),
@@ skipping 39 matching lines @@
         break;
       case PING_FRAME:
         delete it->ping_frame;
         break;
       case NUM_FRAME_TYPES:
         DCHECK(false) << "Cannot delete type: " << it->type;
     }
   }
 }
 
+// NetworkChangeVisitor method.
+void QuicPacketGenerator::OnCongestionWindowChange(
+    QuicByteCount congestion_window) {
+  packet_creator_.set_max_packets_per_fec_group(
+      static_cast<size_t>(kCongestionWindowMultiplierForFecGroupSize *
+                          congestion_window / kDefaultTCPMSS));
+}
+
 void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback,
                                            bool also_send_stop_waiting) {
   should_send_ack_ = true;
   should_send_feedback_ = also_send_feedback;
   should_send_stop_waiting_ = also_send_stop_waiting;
   SendQueuedFrames(false);
 }
 
 void QuicPacketGenerator::SetShouldSendStopWaiting() {
   should_send_stop_waiting_ = true;
@@ skipping 74 matching lines @@
     }
   }
 
   // Don't allow the handshake to be bundled with other retransmittable frames.
   if (handshake == IS_HANDSHAKE) {
     SendQueuedFrames(true);
   }
 
   // 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.
+  // TODO(jri): This method should be called with flush=false here
+  // once the timer-based FEC sending is done, to separate FEC sending from
+  // the end of batch operations.
   MaybeSendFecPacketAndCloseGroup(!InBatchMode());
 
   DCHECK(InBatchMode() || !packet_creator_.HasPendingFrames());
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
 }
 
 bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
   DCHECK(HasPendingFrames());
   HasRetransmittableData retransmittable =
       (should_send_ack_ || should_send_feedback_ || should_send_stop_waiting_)
@@ skipping 42 matching lines @@
     // 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::MaybeSendFecPacketAndCloseGroup(bool force) {
   if (!packet_creator_.IsFecProtected() ||
-      packet_creator_.HasPendingFrames()) {
+      packet_creator_.HasPendingFrames() ||
+      !packet_creator_.ShouldSendFec(force)) {
     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.
-    SerializedPacket serialized_fec = packet_creator_.SerializeFec();
-    DCHECK(serialized_fec.packet);
-    delegate_->OnSerializedPacket(serialized_fec);
-  }
-
-  // Turn FEC protection off if the creator does not have an FEC group open.
+  // TODO(jri): SerializeFec can return a NULL packet, and this should
+  // cause an early return, with a call to delegate_->OnPacketGenerationError.
+  SerializedPacket serialized_fec = packet_creator_.SerializeFec();
+  DCHECK(serialized_fec.packet);
+  delegate_->OnSerializedPacket(serialized_fec);
+  // Turn FEC protection off if creator's protection is on and the creator
+  // does not have an open FEC group.
   // Note: We only wait until the frames queued in the creator are flushed;
   // pending frames in the generator will not keep us from turning FEC off.
   if (!should_fec_protect_ && !packet_creator_.IsFecGroupOpen()) {
     packet_creator_.StopFecProtectingPackets();
     DCHECK(!packet_creator_.IsFecProtected());
   }
 }
 
 bool QuicPacketGenerator::InBatchMode() {
   return batch_mode_;
@@ skipping 107 matching lines @@
       QuicByteCount congestion_window) {
   return packet_creator_.UpdateSequenceNumberLength(
       least_packet_awaited_by_peer, congestion_window);
 }
 
 void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
   packet_creator_.set_encryption_level(level);
 }
 
 }  // namespace net