Add QuicSentPacketManagerInterface, and QuicSentPacketManager implements it. No functional change e…

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"
 #include "net/quic/congestion_control/general_loss_algorithm.h"
 #include "net/quic/congestion_control/pacing_sender.h"
 #include "net/quic/crypto/crypto_protocol.h"
-#include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils_chromium.h"
 
 using std::max;
 using std::min;
 using std::pair;
 
 namespace net {
 
 // The length of the recent min rtt window in seconds. Windowing is disabled for
 // values less than or equal to 0.
 int32_t FLAGS_quic_recent_min_rtt_window_s = 60;
 
 namespace {
 static const int64_t kDefaultRetransmissionTimeMs = 500;
-// TCP RFC calls for 1 second RTO however Linux differs from this default and
-// define the minimum RTO to 200ms, we will use the same until we have data to
-// support a higher or lower value.
-static const int64_t kMinRetransmissionTimeMs = 200;
 static const int64_t kMaxRetransmissionTimeMs = 60000;
 // Maximum number of exponential backoffs used for RTO timeouts.
 static const size_t kMaxRetransmissions = 10;
 // Maximum number of packets retransmitted upon an RTO.
 static const size_t kMaxRetransmissionsOnTimeout = 2;
 // Minimum number of consecutive RTOs before path is considered to be degrading.
 const size_t kMinTimeoutsBeforePathDegrading = 2;
 
 // Ensure the handshake timer isnt't faster than 10ms.
 // This limits the tenth retransmitted packet to 10s after the initial CHLO.
@@ skipping 166 matching lines @@
   }
 }
 
 void QuicSentPacketManager::SetMaxPacingRate(QuicBandwidth max_pacing_rate) {
   if (FLAGS_quic_max_pacing_rate && using_pacing_) {
     static_cast<PacingSender*>(send_algorithm_.get())
         ->SetMaxPacingRate(max_pacing_rate);
   }
 }
 
+void QuicSentPacketManager::SetHandshakeConfirmed() {
+  handshake_confirmed_ = true;
+}
+
 void QuicSentPacketManager::OnIncomingAck(const QuicAckFrame& ack_frame,
                                           QuicTime ack_receive_time) {
   DCHECK_LE(ack_frame.largest_observed, unacked_packets_.largest_sent_packet());
   QuicByteCount bytes_in_flight = unacked_packets_.bytes_in_flight();
   UpdatePacketInformationReceivedByPeer(ack_frame);
   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);
@@ skipping 39 matching lines @@
          pending_retransmissions_.front().first > largest_newly_acked_ &&
          pending_retransmissions_.front().second == LOSS_RETRANSMISSION) {
     // Cancel any pending retransmissions larger than largest_newly_acked_.
     unacked_packets_.RestoreToInFlight(pending_retransmissions_.front().first);
     pending_retransmissions_.erase(pending_retransmissions_.begin());
   }
 
   if (debug_delegate_ != nullptr) {
     debug_delegate_->OnIncomingAck(ack_frame, ack_receive_time,
                                    unacked_packets_.largest_observed(),
-                                   rtt_updated, GetLeastUnacked());
+                                   rtt_updated, GetLeastUnacked(path_id_));
   }
 }
 
 void QuicSentPacketManager::UpdatePacketInformationReceivedByPeer(
     const QuicAckFrame& ack_frame) {
   if (ack_frame.packets.Empty()) {
     least_packet_awaited_by_peer_ = ack_frame.largest_observed + 1;
   } else {
     least_packet_awaited_by_peer_ = ack_frame.packets.Min();
   }
@@ skipping 54 matching lines @@
       packets_acked_.push_back(std::make_pair(packet_number, it->bytes_sent));
     } else if (FLAGS_quic_loss_recovery_use_largest_acked &&
                !it->is_unackable) {
       largest_newly_acked_ = packet_number;
     }
     MarkPacketHandled(packet_number, &(*it), ack_delay_time);
   }
 }
 
 bool QuicSentPacketManager::HasRetransmittableFrames(
+    QuicPathId,
     QuicPacketNumber packet_number) const {
   return unacked_packets_.HasRetransmittableFrames(packet_number);
 }
 
 void QuicSentPacketManager::RetransmitUnackedPackets(
     TransmissionType retransmission_type) {
   DCHECK(retransmission_type == ALL_UNACKED_RETRANSMISSION ||
          retransmission_type == ALL_INITIAL_RETRANSMISSION);
   QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
@@ skipping 186 matching lines @@
     }
   }
 
   unacked_packets_.RemoveFromInFlight(info);
   unacked_packets_.RemoveRetransmittability(info);
   if (FLAGS_quic_loss_recovery_use_largest_acked) {
     info->is_unackable = true;
   }
 }
 
-bool QuicSentPacketManager::IsUnacked(QuicPacketNumber packet_number) const {
+bool QuicSentPacketManager::IsUnacked(QuicPathId,
+                                      QuicPacketNumber packet_number) const {
   return unacked_packets_.IsUnacked(packet_number);
 }
 
 bool QuicSentPacketManager::HasUnackedPackets() const {
   return unacked_packets_.HasUnackedPackets();
 }
 
-QuicPacketNumber QuicSentPacketManager::GetLeastUnacked() const {
+QuicPacketNumber QuicSentPacketManager::GetLeastUnacked(QuicPathId) const {
   return unacked_packets_.GetLeastUnacked();
 }
 
 bool QuicSentPacketManager::OnPacketSent(
     SerializedPacket* serialized_packet,
     QuicPathId /*original_path_id*/,
     QuicPacketNumber original_packet_number,
     QuicTime sent_time,
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
@@ skipping 207 matching lines @@
 
   QuicTime::Delta send_delta =
       ack_receive_time.Subtract(transmission_info.sent_time);
   rtt_stats_.UpdateRtt(send_delta, ack_frame.ack_delay_time, ack_receive_time);
 
   return true;
 }
 
 QuicTime::Delta QuicSentPacketManager::TimeUntilSend(
     QuicTime now,
-    HasRetransmittableData retransmittable) {
+    HasRetransmittableData retransmittable,
+    QuicPathId* path_id) {
+  QuicTime::Delta delay = QuicTime::Delta::Infinite();
   // The TLP logic is entirely contained within QuicSentPacketManager, so the
   // send algorithm does not need to be consulted.
   if (pending_timer_transmission_count_ > 0) {
-    return QuicTime::Delta::Zero();
+    delay = QuicTime::Delta::Zero();
+  } else {
+    delay =
+        send_algorithm_->TimeUntilSend(now, unacked_packets_.bytes_in_flight());
   }
-  return send_algorithm_->TimeUntilSend(now,
-                                        unacked_packets_.bytes_in_flight());
-}
-
-// Uses a 25ms delayed ack timer. Also helps with better signaling
-// in low-bandwidth (< ~384 kbps), where an ack is sent per packet.
-// Ensures that the Delayed Ack timer is always set to a value lesser
-// than the retransmission timer's minimum value (MinRTO). We want the
-// delayed ack to get back to the QUIC peer before the sender's
-// retransmission timer triggers.  Since we do not know the
-// reverse-path one-way delay, we assume equal delays for forward and
-// reverse paths, and ensure that the timer is set to less than half
-// of the MinRTO.
-// There may be a value in making this delay adaptive with the help of
-// the sender and a signaling mechanism -- if the sender uses a
-// different MinRTO, we may get spurious retransmissions. May not have
-// any benefits, but if the delayed ack becomes a significant source
-// of (likely, tail) latency, then consider such a mechanism.
-const QuicTime::Delta QuicSentPacketManager::DelayedAckTime() const {
-  return QuicTime::Delta::FromMilliseconds(
-      min(kMaxDelayedAckTimeMs, kMinRetransmissionTimeMs / 2));
+  if (!delay.IsInfinite()) {
+    *path_id = path_id_;
+  }
+  return delay;
 }
 
 const QuicTime QuicSentPacketManager::GetRetransmissionTime() const {
   // Don't set the timer if there are no packets in flight or we've already
   // queued a tlp transmission and it hasn't been sent yet.
   if (!unacked_packets_.HasInFlightPackets() ||
       pending_timer_transmission_count_ > 0) {
     return QuicTime::Zero();
   }
   switch (GetRetransmissionMode()) {
@@ skipping 113 matching lines @@
 }
 
 void QuicSentPacketManager::CancelRetransmissionsForStream(
     QuicStreamId stream_id) {
   unacked_packets_.CancelRetransmissionsForStream(stream_id);
   if (delegate_ != nullptr) {
     return;
   }
   PendingRetransmissionMap::iterator it = pending_retransmissions_.begin();
   while (it != pending_retransmissions_.end()) {
-    if (HasRetransmittableFrames(it->first)) {
+    if (HasRetransmittableFrames(path_id_, it->first)) {
       ++it;
       continue;
     }
     it = pending_retransmissions_.erase(it);
   }
 }
 
 void QuicSentPacketManager::EnablePacing() {
   // TODO(ianswett): Replace with a method which wraps the send algorithm in a
   // pacer every time a new algorithm is set.
   if (using_pacing_) {
     return;
   }
 
   // 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));
 }
 
-void QuicSentPacketManager::OnConnectionMigration(PeerAddressChangeType type) {
+void QuicSentPacketManager::OnConnectionMigration(QuicPathId,
+                                                  PeerAddressChangeType type) {
   if (type == PORT_CHANGE || type == IPV4_SUBNET_CHANGE) {
     // Rtt and cwnd do not need to be reset when the peer address change is
     // considered to be caused by NATs.
     return;
   }
   consecutive_rto_count_ = 0;
   consecutive_tlp_count_ = 0;
   rtt_stats_.OnConnectionMigration();
   send_algorithm_->OnConnectionMigration();
 }
 
+bool QuicSentPacketManager::IsHandshakeConfirmed() const {
+  return handshake_confirmed_;
+}
+
+void QuicSentPacketManager::SetDebugDelegate(DebugDelegate* debug_delegate) {
+  debug_delegate_ = debug_delegate;
+}
+
+QuicPacketNumber QuicSentPacketManager::GetLargestObserved(QuicPathId) const {
+  return unacked_packets_.largest_observed();
+}
+
+QuicPacketNumber QuicSentPacketManager::GetLargestSentPacket(QuicPathId) const {
+  return unacked_packets_.largest_sent_packet();
+}
+
+QuicPacketNumber QuicSentPacketManager::GetLeastPacketAwaitedByPeer(
+    QuicPathId) const {
+  return least_packet_awaited_by_peer_;
+}
+
+void QuicSentPacketManager::SetNetworkChangeVisitor(
+    NetworkChangeVisitor* visitor) {
+  DCHECK(!network_change_visitor_);
+  DCHECK(visitor);
+  network_change_visitor_ = visitor;
+}
+
 bool QuicSentPacketManager::InSlowStart() const {
   return send_algorithm_->InSlowStart();
 }
 
+size_t QuicSentPacketManager::GetConsecutiveRtoCount() const {
+  return consecutive_rto_count_;
+}
+
+size_t QuicSentPacketManager::GetConsecutiveTlpCount() const {
+  return consecutive_tlp_count_;
+}
+
 TransmissionInfo* QuicSentPacketManager::GetMutableTransmissionInfo(
     QuicPacketNumber packet_number) {
   return unacked_packets_.GetMutableTransmissionInfo(packet_number);
 }
 
 void QuicSentPacketManager::RemoveObsoletePackets() {
   unacked_packets_.RemoveObsoletePackets();
 }
 
 }  // namespace net