Update from https://crrev.com/308996

net/quic/quic_sent_packet_manager.cc

 // Copyright 2013 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_sent_packet_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 177 matching lines @@
     return true;
   }
   return false;
 }
 
 void QuicSentPacketManager::OnIncomingAck(const QuicAckFrame& ack_frame,
                                           QuicTime ack_receive_time) {
   QuicByteCount bytes_in_flight = unacked_packets_.bytes_in_flight();
 
   UpdatePacketInformationReceivedByPeer(ack_frame);
-  // We rely on delta_time_largest_observed to compute an RTT estimate, so
-  // we only update rtt when the largest observed gets acked.
-  bool largest_observed_acked = MaybeUpdateRTT(ack_frame, ack_receive_time);
+  bool rtt_updated = MaybeUpdateRTT(ack_frame, ack_receive_time);
   DCHECK_GE(ack_frame.largest_observed, unacked_packets_.largest_observed());
   unacked_packets_.IncreaseLargestObserved(ack_frame.largest_observed);
 
   HandleAckForSentPackets(ack_frame);
   InvokeLossDetection(ack_receive_time);
-  MaybeInvokeCongestionEvent(largest_observed_acked, bytes_in_flight);
+  MaybeInvokeCongestionEvent(rtt_updated, bytes_in_flight);
   unacked_packets_.RemoveObsoletePackets();
 
   sustained_bandwidth_recorder_.RecordEstimate(
       send_algorithm_->InRecovery(),
       send_algorithm_->InSlowStart(),
       send_algorithm_->BandwidthEstimate(),
       ack_receive_time,
       clock_->WallNow(),
       rtt_stats_.smoothed_rtt());
 
   // If we have received a truncated ack, then we need to clear out some
   // previous transmissions to allow the peer to actually ACK new packets.
   if (ack_frame.is_truncated) {
     unacked_packets_.ClearAllPreviousRetransmissions();
   }
 
   // Anytime we are making forward progress and have a new RTT estimate, reset
   // the backoff counters.
-  if (largest_observed_acked) {
+  if (rtt_updated) {
     // Reset all retransmit counters any time a new packet is acked.
     consecutive_rto_count_ = 0;
     consecutive_tlp_count_ = 0;
     consecutive_crypto_retransmission_count_ = 0;
   }
 
   if (debug_delegate_ != nullptr) {
-    debug_delegate_->OnIncomingAck(ack_frame,
-                                   ack_receive_time,
+    debug_delegate_->OnIncomingAck(ack_frame, ack_receive_time,
                                    unacked_packets_.largest_observed(),
-                                   largest_observed_acked,
-                                   GetLeastUnacked());
+                                   rtt_updated, GetLeastUnacked());
   }
 }
 
 void QuicSentPacketManager::UpdatePacketInformationReceivedByPeer(
     const QuicAckFrame& ack_frame) {
   if (ack_frame.missing_packets.empty()) {
     least_packet_awaited_by_peer_ = ack_frame.largest_observed + 1;
   } else {
     least_packet_awaited_by_peer_ = *(ack_frame.missing_packets.begin());
   }
@@ skipping 495 matching lines @@
       // a packet whose previous transmission has been acked, a packet that has
       // been TLP retransmitted, or an FEC packet.
       unacked_packets_.RemoveFromInFlight(sequence_number);
     }
   }
 }
 
 bool QuicSentPacketManager::MaybeUpdateRTT(
     const QuicAckFrame& ack_frame,
     const QuicTime& ack_receive_time) {
+  // We rely on delta_time_largest_observed to compute an RTT estimate, so we
+  // only update rtt when the largest observed gets acked.
+  // NOTE: If ack is a truncated ack, then the largest observed is in fact
+  // unacked, and may cause an RTT sample to be taken.
   if (!unacked_packets_.IsUnacked(ack_frame.largest_observed)) {
     return false;
   }
   // We calculate the RTT based on the highest ACKed sequence number, the lower
   // sequence numbers will include the ACK aggregation delay.
   const TransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(ack_frame.largest_observed);
   // Ensure the packet has a valid sent time.
   if (transmission_info.sent_time == QuicTime::Zero()) {
     LOG(DFATAL) << "Acked packet has zero sent time, largest_observed:"
@@ skipping 170 matching lines @@
   // Set up a pacing sender with a 1 millisecond alarm granularity, the same as
   // the default granularity of the Linux kernel's FQ qdisc.
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMilliseconds(1),
                        kInitialUnpacedBurst));
 }
 
 }  // namespace net