Update from https://crrev.com/303153

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;
+// or equivalently, half the max number of in-flight packets,  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 kMaxPacketsInFlightMultiplierForFecGroupSize = 0.5;
 
 }  // namespace
 
 class QuicAckNotifier;
 
 QuicPacketGenerator::QuicPacketGenerator(QuicConnectionId connection_id,
                                          QuicFramer* framer,
                                          QuicRandom* random_generator,
                                          DelegateInterface* delegate)
     : delegate_(delegate),
@@ skipping 42 matching lines @@
       case PING_FRAME:
         delete it->ping_frame;
         break;
       case NUM_FRAME_TYPES:
         DCHECK(false) << "Cannot delete type: " << it->type;
     }
   }
 }
 
 void QuicPacketGenerator::OnCongestionWindowChange(
-    QuicByteCount congestion_window) {
+    QuicPacketCount max_packets_in_flight) {
   packet_creator_.set_max_packets_per_fec_group(
-      static_cast<size_t>(kCongestionWindowMultiplierForFecGroupSize *
-                          congestion_window / kDefaultTCPMSS));
+      static_cast<size_t>(kMaxPacketsInFlightMultiplierForFecGroupSize *
+                          max_packets_in_flight));
 }
 
 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);
 }
 
@@ skipping 269 matching lines @@
 }
 
 SerializedPacket QuicPacketGenerator::ReserializeAllFrames(
     const QuicFrames& frames,
     QuicSequenceNumberLength original_length) {
   return packet_creator_.ReserializeAllFrames(frames, original_length);
 }
 
 void QuicPacketGenerator::UpdateSequenceNumberLength(
       QuicPacketSequenceNumber least_packet_awaited_by_peer,
-      QuicByteCount congestion_window) {
+      QuicPacketCount max_packets_in_flight) {
   return packet_creator_.UpdateSequenceNumberLength(
-      least_packet_awaited_by_peer, congestion_window);
+      least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 void QuicPacketGenerator::SetConnectionIdLength(uint32 length) {
   if (length == 0) {
     packet_creator_.set_connection_id_length(PACKET_0BYTE_CONNECTION_ID);
   } else if (length == 1) {
     packet_creator_.set_connection_id_length(PACKET_1BYTE_CONNECTION_ID);
   } else if (length <= 4) {
     packet_creator_.set_connection_id_length(PACKET_4BYTE_CONNECTION_ID);
   } else {
     packet_creator_.set_connection_id_length(PACKET_8BYTE_CONNECTION_ID);
   }
 }
 
 
 void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
   packet_creator_.set_encryption_level(level);
 }
 
 }  // namespace net