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

net/quic/quic_connection.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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 
 #include <algorithm>
@@ skipping 16 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_bandwidth.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_config.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_packet_generator.h"
+#include "net/quic/quic_sent_packet_manager.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using base::StringPrintf;
 using std::list;
 using std::make_pair;
 using std::max;
 using std::min;
 using std::numeric_limits;
 using std::set;
@@ skipping 238 matching lines @@
                         &framer_,
                         random_generator_,
                         helper->GetBufferAllocator(),
                         this),
       idle_network_timeout_(QuicTime::Delta::Infinite()),
       handshake_timeout_(QuicTime::Delta::Infinite()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_new_packet_(clock_->ApproximateNow()),
       last_send_for_timeout_(clock_->ApproximateNow()),
       packet_number_of_last_sent_packet_(0),
-      sent_packet_manager_(
+      sent_packet_manager_(new QuicSentPacketManager(
           perspective,
           kDefaultPathId,
           clock_,
           &stats_,
           FLAGS_quic_use_bbr_congestion_control ? kBBR : kCubic,
           FLAGS_quic_use_time_loss_detection ? kTime : kNack,
-          /*delegate=*/nullptr),
+          /*delegate=*/nullptr)),
       version_negotiation_state_(START_NEGOTIATION),
       perspective_(perspective),
       connected_(true),
       can_truncate_connection_ids_(true),
       mtu_discovery_target_(0),
       mtu_probe_count_(0),
       packets_between_mtu_probes_(kPacketsBetweenMtuProbesBase),
       next_mtu_probe_at_(kPacketsBetweenMtuProbesBase),
       largest_received_packet_size_(0),
       goaway_sent_(false),
       goaway_received_(false),
       multipath_enabled_(false) {
   DVLOG(1) << ENDPOINT
            << "Created connection with connection_id: " << connection_id;
   framer_.set_visitor(this);
   framer_.set_received_entropy_calculator(&received_packet_manager_);
   last_stop_waiting_frame_.least_unacked = 0;
   stats_.connection_creation_time = clock_->ApproximateNow();
-  sent_packet_manager_.set_network_change_visitor(this);
+  sent_packet_manager_->SetNetworkChangeVisitor(this);
   // Allow the packet writer to potentially reduce the packet size to a value
   // even smaller than kDefaultMaxPacketSize.
   SetMaxPacketLength(perspective_ == Perspective::IS_SERVER
                          ? kDefaultServerMaxPacketSize
                          : kDefaultMaxPacketSize);
   received_packet_manager_.SetVersion(version());
 }
 
 QuicConnection::~QuicConnection() {
   if (owns_writer_) {
@@ skipping 24 matching lines @@
           ConnectionCloseBehavior::SILENT_CLOSE;
     }
     if (FLAGS_quic_enable_multipath && config.MultipathEnabled()) {
       multipath_enabled_ = true;
     }
   } else {
     SetNetworkTimeouts(config.max_time_before_crypto_handshake(),
                        config.max_idle_time_before_crypto_handshake());
   }
 
-  sent_packet_manager_.SetFromConfig(config);
+  sent_packet_manager_->SetFromConfig(config);
   if (config.HasReceivedBytesForConnectionId() &&
       can_truncate_connection_ids_) {
     packet_generator_.SetConnectionIdLength(
         config.ReceivedBytesForConnectionId());
   }
   max_undecryptable_packets_ = config.max_undecryptable_packets();
 
   if (config.HasClientSentConnectionOption(kMTUH, perspective_)) {
     SetMtuDiscoveryTarget(kMtuDiscoveryTargetPacketSizeHigh);
   }
@@ skipping 32 matching lines @@
 void QuicConnection::OnReceiveConnectionState(
     const CachedNetworkParameters& cached_network_params) {
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnReceiveConnectionState(cached_network_params);
   }
 }
 
 void QuicConnection::ResumeConnectionState(
     const CachedNetworkParameters& cached_network_params,
     bool max_bandwidth_resumption) {
-  sent_packet_manager_.ResumeConnectionState(cached_network_params,
-                                             max_bandwidth_resumption);
+  sent_packet_manager_->ResumeConnectionState(cached_network_params,
+                                              max_bandwidth_resumption);
 }
 
 void QuicConnection::SetMaxPacingRate(QuicBandwidth max_pacing_rate) {
-  sent_packet_manager_.SetMaxPacingRate(max_pacing_rate);
+  sent_packet_manager_->SetMaxPacingRate(max_pacing_rate);
 }
 
 void QuicConnection::SetNumOpenStreams(size_t num_streams) {
-  sent_packet_manager_.SetNumOpenStreams(num_streams);
+  sent_packet_manager_->SetNumOpenStreams(num_streams);
 }
 
 bool QuicConnection::SelectMutualVersion(
     const QuicVersionVector& available_versions) {
   // Try to find the highest mutual version by iterating over supported
   // versions, starting with the highest, and breaking out of the loop once we
   // find a matching version in the provided available_versions vector.
   const QuicVersionVector& supported_versions = framer_.supported_versions();
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     const QuicVersion& version = supported_versions[i];
@@ skipping 228 matching lines @@
   if (!ProcessValidatedPacket(header)) {
     return false;
   }
 
   // Only migrate connection to a new peer address if a change is not underway.
   PeerAddressChangeType peer_migration_type =
       QuicUtils::DetermineAddressChangeType(peer_address_,
                                             last_packet_source_address_);
   if (active_peer_migration_type_ == NO_CHANGE &&
       peer_migration_type != NO_CHANGE) {
-    StartPeerMigration(peer_migration_type);
+    StartPeerMigration(header.path_id, peer_migration_type);
   }
 
   --stats_.packets_dropped;
   DVLOG(1) << ENDPOINT << "Received packet header: " << header;
   last_header_ = header;
   DCHECK(connected_);
   return true;
 }
 
 bool QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) {
@@ skipping 54 matching lines @@
   if (incoming_ack.is_truncated) {
     should_last_packet_instigate_acks_ = true;
   }
   // If the incoming ack's packets set expresses missing packets: peer is still
   // waiting for a packet lower than a packet that we are no longer planning to
   // send.
   // If the incoming ack's packets set expresses received packets: peer is still
   // acking packets which we never care about.
   // Send an ack to raise the high water mark.
   if (!incoming_ack.packets.Empty() &&
-      GetLeastUnacked() > incoming_ack.packets.Min()) {
+      GetLeastUnacked(incoming_ack.path_id) > incoming_ack.packets.Min()) {
     ++stop_waiting_count_;
   } else {
     stop_waiting_count_ = 0;
   }
 
   return connected_;
 }
 
 void QuicConnection::ProcessAckFrame(const QuicAckFrame& incoming_ack) {
   largest_seen_packet_with_ack_ = last_header_.packet_number;
-  sent_packet_manager_.OnIncomingAck(incoming_ack,
-                                     time_of_last_received_packet_);
+  sent_packet_manager_->OnIncomingAck(incoming_ack,
+                                      time_of_last_received_packet_);
   if (version() <= QUIC_VERSION_33) {
     sent_entropy_manager_.ClearEntropyBefore(
-        sent_packet_manager_.least_packet_awaited_by_peer() - 1);
+        sent_packet_manager_->GetLeastPacketAwaitedByPeer(
+            incoming_ack.path_id) -
+        1);
   }
   // Always reset the retransmission alarm when an ack comes in, since we now
   // have a better estimate of the current rtt than when it was set.
   SetRetransmissionAlarm();
 }
 
 void QuicConnection::ProcessStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
   largest_seen_packet_with_stop_waiting_ = last_header_.packet_number;
   received_packet_manager_.UpdatePacketInformationSentByPeer(stop_waiting);
@@ skipping 41 matching lines @@
 
 const char* QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
   if (incoming_ack.largest_observed > packet_generator_.packet_number()) {
     LOG(WARNING) << ENDPOINT << "Peer's observed unsent packet:"
                  << incoming_ack.largest_observed << " vs "
                  << packet_generator_.packet_number();
     // We got an error for data we have not sent.  Error out.
     return "Largest observed too high.";
   }
 
-  if (incoming_ack.largest_observed < sent_packet_manager_.largest_observed()) {
+  if (incoming_ack.largest_observed <
+      sent_packet_manager_->GetLargestObserved(incoming_ack.path_id)) {
     LOG(WARNING) << ENDPOINT << "Peer's largest_observed packet decreased:"
                  << incoming_ack.largest_observed << " vs "
-                 << sent_packet_manager_.largest_observed()
+                 << sent_packet_manager_->GetLargestObserved(
+                        incoming_ack.path_id)
                  << " packet_number:" << last_header_.packet_number
                  << " largest seen with ack:" << largest_seen_packet_with_ack_
                  << " connection_id: " << connection_id_;
     // A new ack has a diminished largest_observed value.  Error out.
     // If this was an old packet, we wouldn't even have checked.
     return "Largest observed too low.";
   }
 
   if (version() <= QUIC_VERSION_33) {
     if (!incoming_ack.packets.Empty() &&
         incoming_ack.packets.Max() > incoming_ack.largest_observed) {
       LOG(WARNING) << ENDPOINT
                    << "Peer sent missing packet: " << incoming_ack.packets.Max()
                    << " which is greater than largest observed: "
                    << incoming_ack.largest_observed;
       return "Missing packet higher than largest observed.";
     }
 
     if (!incoming_ack.packets.Empty() &&
         incoming_ack.packets.Min() <
-            sent_packet_manager_.least_packet_awaited_by_peer()) {
+            sent_packet_manager_->GetLeastPacketAwaitedByPeer(
+                incoming_ack.path_id)) {
       LOG(WARNING) << ENDPOINT
                    << "Peer sent missing packet: " << incoming_ack.packets.Min()
                    << " which is smaller than least_packet_awaited_by_peer_: "
-                   << sent_packet_manager_.least_packet_awaited_by_peer();
+                   << sent_packet_manager_->GetLeastPacketAwaitedByPeer(
+                          incoming_ack.path_id);
       return "Missing packet smaller than least awaited.";
     }
     if (!sent_entropy_manager_.IsValidEntropy(incoming_ack.largest_observed,
                                               incoming_ack.packets,
                                               incoming_ack.entropy_hash)) {
       LOG(WARNING) << ENDPOINT << "Peer sent invalid entropy."
                    << " largest_observed:" << incoming_ack.largest_observed
                    << " last_received:" << last_header_.packet_number;
       return "Invalid entropy.";
     }
@@ skipping 176 matching lines @@
     ++num_retransmittable_packets_received_since_last_ack_sent_;
     if (ack_mode_ != TCP_ACKING &&
         last_header_.packet_number > kMinReceivedBeforeAckDecimation) {
       // Ack up to 10 packets at once.
       if (num_retransmittable_packets_received_since_last_ack_sent_ >=
           kMaxRetransmittablePacketsBeforeAck) {
         ack_queued_ = true;
       } else if (!ack_alarm_->IsSet()) {
         // Wait the minimum of a quarter min_rtt and the delayed ack time.
         QuicTime::Delta ack_delay = QuicTime::Delta::Min(
-            sent_packet_manager_.DelayedAckTime(),
-            sent_packet_manager_.GetRttStats()->min_rtt().Multiply(
+            DelayedAckTime(),
+            sent_packet_manager_->GetRttStats()->min_rtt().Multiply(
                 ack_decimation_delay_));
         ack_alarm_->Set(clock_->ApproximateNow().Add(ack_delay));
       }
     } else {
       // Ack with a timer or every 2 packets by default.
       if (num_retransmittable_packets_received_since_last_ack_sent_ >=
           kDefaultRetransmittablePacketsBeforeAck) {
         ack_queued_ = true;
       } else if (!ack_alarm_->IsSet()) {
-        ack_alarm_->Set(clock_->ApproximateNow().Add(
-            sent_packet_manager_.DelayedAckTime()));
+        ack_alarm_->Set(clock_->ApproximateNow().Add(DelayedAckTime()));
       }
     }
 
     // If there are new missing packets to report, send an ack immediately.
     if (received_packet_manager_.HasNewMissingPackets()) {
       if (ack_mode_ == ACK_DECIMATION_WITH_REORDERING) {
         // Wait the minimum of an eighth min_rtt and the existing ack time.
         QuicTime ack_time = clock_->ApproximateNow().Add(
-            sent_packet_manager_.GetRttStats()->min_rtt().Multiply(0.125));
+            sent_packet_manager_->GetRttStats()->min_rtt().Multiply(0.125));
         if (!ack_alarm_->IsSet() || ack_alarm_->deadline() > ack_time) {
           ack_alarm_->Cancel();
           ack_alarm_->Set(ack_time);
         }
       } else {
         ack_queued_ = true;
       }
     }
   }
 
   if (ack_queued_) {
     ack_alarm_->Cancel();
   }
 }
 
 void QuicConnection::ClearLastFrames() {
   should_last_packet_instigate_acks_ = false;
   last_stop_waiting_frame_.least_unacked = 0;
 }
 
 void QuicConnection::MaybeCloseIfTooManyOutstandingPackets() {
   if (version() > QUIC_VERSION_33) {
     return;
   }
   // This occurs if we don't discard old packets we've sent fast enough.
   // It's possible largest observed is less than least unacked.
-  if (sent_packet_manager_.largest_observed() >
-      (sent_packet_manager_.GetLeastUnacked() + kMaxTrackedPackets)) {
+  if (sent_packet_manager_->GetLargestObserved(last_header_.path_id) >
+      (sent_packet_manager_->GetLeastUnacked(last_header_.path_id) +
+       kMaxTrackedPackets)) {
     CloseConnection(
         QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS,
         StringPrintf("More than %" PRIu64 " outstanding.", kMaxTrackedPackets),
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
   // This occurs if there are received packet gaps and the peer does not raise
   // the least unacked fast enough.
   if (received_packet_manager_.NumTrackedPackets() > kMaxTrackedPackets) {
     CloseConnection(
         QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS,
         StringPrintf("More than %" PRIu64 " outstanding.", kMaxTrackedPackets),
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 }
 
 const QuicFrame QuicConnection::GetUpdatedAckFrame() {
   return received_packet_manager_.GetUpdatedAckFrame(clock_->ApproximateNow());
 }
 
 void QuicConnection::PopulateStopWaitingFrame(
     QuicStopWaitingFrame* stop_waiting) {
-  stop_waiting->least_unacked = GetLeastUnacked();
+  stop_waiting->least_unacked = GetLeastUnacked(stop_waiting->path_id);
   if (version() <= QUIC_VERSION_33) {
     stop_waiting->entropy_hash = sent_entropy_manager_.GetCumulativeEntropy(
         stop_waiting->least_unacked - 1);
   }
 }
 
-QuicPacketNumber QuicConnection::GetLeastUnacked() const {
-  return sent_packet_manager_.GetLeastUnacked();
+QuicPacketNumber QuicConnection::GetLeastUnacked(QuicPathId path_id) const {
+  return sent_packet_manager_->GetLeastUnacked(path_id);
 }
 
 void QuicConnection::MaybeSendInResponseToPacket() {
   if (!connected_) {
     return;
   }
   // Now that we have received an ack, we might be able to send packets which
   // are queued locally, or drain streams which are blocked.
   if (defer_send_in_response_to_packets_) {
     send_alarm_->Cancel();
@@ skipping 70 matching lines @@
   ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   packet_generator_.AddControlFrame(QuicFrame(new QuicRstStreamFrame(
       id, AdjustErrorForVersion(error, version()), bytes_written)));
 
   if (error == QUIC_STREAM_NO_ERROR && version() > QUIC_VERSION_28) {
     // All data for streams which are reset with QUIC_STREAM_NO_ERROR must
     // be received by the peer.
     return;
   }
 
-  sent_packet_manager_.CancelRetransmissionsForStream(id);
+  sent_packet_manager_->CancelRetransmissionsForStream(id);
   // Remove all queued packets which only contain data for the reset stream.
   QueuedPacketList::iterator packet_iterator = queued_packets_.begin();
   while (packet_iterator != queued_packets_.end()) {
     QuicFrames* retransmittable_frames =
         &packet_iterator->retransmittable_frames;
     if (retransmittable_frames->empty()) {
       ++packet_iterator;
       continue;
     }
     QuicUtils::RemoveFramesForStream(retransmittable_frames, id);
@@ skipping 22 matching lines @@
 }
 
 void QuicConnection::SendPathClose(QuicPathId path_id) {
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   packet_generator_.AddControlFrame(QuicFrame(new QuicPathCloseFrame(path_id)));
   OnPathClosed(path_id);
 }
 
 const QuicConnectionStats& QuicConnection::GetStats() {
-  const RttStats* rtt_stats = sent_packet_manager_.GetRttStats();
+  const RttStats* rtt_stats = sent_packet_manager_->GetRttStats();
 
   // Update rtt and estimated bandwidth.
   QuicTime::Delta min_rtt = rtt_stats->min_rtt();
   if (min_rtt.IsZero()) {
     // If min RTT has not been set, use initial RTT instead.
     min_rtt = QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
   }
   stats_.min_rtt_us = min_rtt.ToMicroseconds();
 
   QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
   if (srtt.IsZero()) {
     // If SRTT has not been set, use initial RTT instead.
     srtt = QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
   }
   stats_.srtt_us = srtt.ToMicroseconds();
 
-  stats_.estimated_bandwidth = sent_packet_manager_.BandwidthEstimate();
+  stats_.estimated_bandwidth = sent_packet_manager_->BandwidthEstimate();
   stats_.max_packet_size = packet_generator_.GetCurrentMaxPacketLength();
   stats_.max_received_packet_size = largest_received_packet_size_;
   return stats_;
 }
 
 void QuicConnection::ProcessUdpPacket(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicReceivedPacket& packet) {
   if (!connected_) {
     return;
@@ skipping 33 matching lines @@
       }
     }
     DVLOG(1) << ENDPOINT << "Unable to process packet.  Last packet processed: "
              << last_header_.packet_number;
     current_packet_data_ = nullptr;
     return;
   }
 
   ++stats_.packets_processed;
   if (active_peer_migration_type_ != NO_CHANGE &&
-      sent_packet_manager_.largest_observed() >
+      sent_packet_manager_->GetLargestObserved(last_header_.path_id) >
           highest_packet_sent_before_peer_migration_) {
-    OnPeerMigrationValidated();
+    OnPeerMigrationValidated(last_header_.path_id);
   }
   MaybeProcessUndecryptablePackets();
   MaybeSendInResponseToPacket();
   SetPingAlarm();
   current_packet_data_ = nullptr;
 }
 
 void QuicConnection::OnCanWrite() {
   DCHECK(!writer_->IsWriteBlocked());
 
@@ skipping 129 matching lines @@
          WritePacket(&(*packet_iterator))) {
     delete[] packet_iterator->encrypted_buffer;
     QuicUtils::ClearSerializedPacket(&(*packet_iterator));
     packet_iterator = queued_packets_.erase(packet_iterator);
   }
 }
 
 void QuicConnection::WritePendingRetransmissions() {
   // Keep writing as long as there's a pending retransmission which can be
   // written.
-  while (sent_packet_manager_.HasPendingRetransmissions()) {
+  while (sent_packet_manager_->HasPendingRetransmissions()) {
     const PendingRetransmission pending =
-        sent_packet_manager_.NextPendingRetransmission();
+        sent_packet_manager_->NextPendingRetransmission();
     if (!CanWrite(HAS_RETRANSMITTABLE_DATA)) {
       break;
     }
 
     // Re-packetize the frames with a new packet number for retransmission.
     // Retransmitted packets use the same packet number length as the
     // original.
     // Flush the packet generator before making a new packet.
     // TODO(ianswett): Implement ReserializeAllFrames as a separate path that
     // does not require the creator to be flushed.
     packet_generator_.FlushAllQueuedFrames();
     char buffer[kMaxPacketSize];
     packet_generator_.ReserializeAllFrames(pending, buffer, kMaxPacketSize);
   }
 }
 
 void QuicConnection::RetransmitUnackedPackets(
     TransmissionType retransmission_type) {
-  sent_packet_manager_.RetransmitUnackedPackets(retransmission_type);
+  sent_packet_manager_->RetransmitUnackedPackets(retransmission_type);
 
   WriteIfNotBlocked();
 }
 
 void QuicConnection::NeuterUnencryptedPackets() {
-  sent_packet_manager_.NeuterUnencryptedPackets();
+  sent_packet_manager_->NeuterUnencryptedPackets();
   // This may have changed the retransmission timer, so re-arm it.
   SetRetransmissionAlarm();
 }
 
 bool QuicConnection::ShouldGeneratePacket(
     HasRetransmittableData retransmittable,
     IsHandshake handshake) {
   // We should serialize handshake packets immediately to ensure that they
   // end up sent at the right encryption level.
   if (handshake == IS_HANDSHAKE) {
@@ skipping 17 matching lines @@
   // TODO(ianswett): Remove retransmittable from
   // SendAlgorithmInterface::TimeUntilSend.
   if (retransmittable == NO_RETRANSMITTABLE_DATA) {
     return true;
   }
   // If the send alarm is set, wait for it to fire.
   if (send_alarm_->IsSet()) {
     return false;
   }
 
+  // TODO(fayang): If delay is not infinite, the next packet will be created and
+  // sent on path_id.
+  QuicPathId path_id = kInvalidPathId;
   QuicTime now = clock_->Now();
   QuicTime::Delta delay =
-      sent_packet_manager_.TimeUntilSend(now, retransmittable);
+      sent_packet_manager_->TimeUntilSend(now, retransmittable, &path_id);
   if (delay.IsInfinite()) {
+    DCHECK_EQ(kInvalidPathId, path_id);
     send_alarm_->Cancel();
     return false;
   }
 
+  DCHECK_NE(kInvalidPathId, path_id);
   // If the scheduler requires a delay, then we can not send this packet now.
   if (!delay.IsZero()) {
     send_alarm_->Update(now.Add(delay), QuicTime::Delta::FromMilliseconds(1));
     DVLOG(1) << ENDPOINT << "Delaying sending " << delay.ToMilliseconds()
              << "ms";
     return false;
   }
   return true;
 }
 
 bool QuicConnection::WritePacket(SerializedPacket* packet) {
-  if (packet->packet_number < sent_packet_manager_.largest_sent_packet()) {
-    QUIC_BUG << "Attempt to write packet:" << packet->packet_number
-             << " after:" << sent_packet_manager_.largest_sent_packet();
+  if (packet->packet_number <
+      sent_packet_manager_->GetLargestSentPacket(packet->path_id)) {
+    QUIC_BUG << "Attempt to write packet:" << packet->packet_number << " after:"
+             << sent_packet_manager_->GetLargestSentPacket(packet->path_id);
     CloseConnection(QUIC_INTERNAL_ERROR, "Packet written out of order.",
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return true;
   }
   if (ShouldDiscardPacket(*packet)) {
     ++stats_.packets_discarded;
     return true;
   }
   // Termination packets are encrypted and saved, so don't exit early.
   const bool is_termination_packet = IsTerminationPacket(*packet);
@@ skipping 74 matching lines @@
   }
   SetPingAlarm();
   MaybeSetMtuAlarm();
   DVLOG(1) << ENDPOINT << "time we began writing last sent packet: "
            << packet_send_time.ToDebuggingValue();
 
   // TODO(ianswett): Change the packet number length and other packet creator
   // options by a more explicit API than setting a struct value directly,
   // perhaps via the NetworkChangeVisitor.
   packet_generator_.UpdateSequenceNumberLength(
-      sent_packet_manager_.least_packet_awaited_by_peer(),
-      sent_packet_manager_.EstimateMaxPacketsInFlight(max_packet_length()));
+      sent_packet_manager_->GetLeastPacketAwaitedByPeer(packet->path_id),
+      sent_packet_manager_->EstimateMaxPacketsInFlight(max_packet_length()));
 
-  bool reset_retransmission_alarm = sent_packet_manager_.OnPacketSent(
+  bool reset_retransmission_alarm = sent_packet_manager_->OnPacketSent(
       packet, packet->original_path_id, packet->original_packet_number,
       packet_send_time, packet->transmission_type, IsRetransmittable(*packet));
 
   if (reset_retransmission_alarm || !retransmission_alarm_->IsSet()) {
     SetRetransmissionAlarm();
   }
 
   stats_.bytes_sent += result.bytes_written;
   ++stats_.packets_sent;
   if (packet->transmission_type != NOT_RETRANSMISSION) {
@@ skipping 27 matching lines @@
     // Drop packets that are NULL encrypted since the peer won't accept them
     // anymore.
     DVLOG(1) << ENDPOINT << "Dropping NULL encrypted packet: " << packet_number
              << " since the connection is forward secure.";
     return true;
   }
 
   // If a retransmission has been acked before sending, don't send it.
   // This occurs if a packet gets serialized, queued, then discarded.
   if (packet.transmission_type != NOT_RETRANSMISSION &&
-      (!sent_packet_manager_.IsUnacked(packet.original_packet_number) ||
-       !sent_packet_manager_.HasRetransmittableFrames(
-           packet.original_packet_number))) {
+      (!sent_packet_manager_->IsUnacked(packet.original_path_id,
+                                        packet.original_packet_number) ||
+       !sent_packet_manager_->HasRetransmittableFrames(
+           packet.original_path_id, packet.original_packet_number))) {
     DVLOG(1) << ENDPOINT << "Dropping unacked packet: " << packet_number
              << " A previous transmission was acked while write blocked.";
     return true;
   }
 
   return false;
 }
 
 void QuicConnection::OnWriteError(int error_code) {
   const string error_details = "Write failed with error: " +
@@ skipping 27 matching lines @@
                                           ConnectionCloseSource source) {
   // The packet creator or generator encountered an unrecoverable error: tear
   // down local connection state immediately.
   TearDownLocalConnectionState(error, error_details, source);
 }
 
 void QuicConnection::OnCongestionChange() {
   visitor_->OnCongestionWindowChange(clock_->ApproximateNow());
 
   // Uses the connection's smoothed RTT. If zero, uses initial_rtt.
-  QuicTime::Delta rtt = sent_packet_manager_.GetRttStats()->smoothed_rtt();
+  QuicTime::Delta rtt = sent_packet_manager_->GetRttStats()->smoothed_rtt();
   if (rtt.IsZero()) {
     rtt = QuicTime::Delta::FromMicroseconds(
-        sent_packet_manager_.GetRttStats()->initial_rtt_us());
+        sent_packet_manager_->GetRttStats()->initial_rtt_us());
   }
 
   if (debug_visitor_)
     debug_visitor_->OnRttChanged(rtt);
 }
 
 void QuicConnection::OnPathDegrading() {
   visitor_->OnPathDegrading();
 }
 
 void QuicConnection::OnHandshakeComplete() {
-  sent_packet_manager_.SetHandshakeConfirmed();
+  sent_packet_manager_->SetHandshakeConfirmed();
   // The client should immediately ack the SHLO to confirm the handshake is
   // complete with the server.
   if (perspective_ == Perspective::IS_CLIENT && !ack_queued_ &&
       ack_frame_updated()) {
     ack_alarm_->Cancel();
     ack_alarm_->Set(clock_->ApproximateNow());
   }
 }
 
 void QuicConnection::SendOrQueuePacket(SerializedPacket* packet) {
@@ skipping 44 matching lines @@
   ack_queued_ = false;
   stop_waiting_count_ = 0;
   num_retransmittable_packets_received_since_last_ack_sent_ = 0;
   last_ack_had_missing_packets_ = received_packet_manager_.HasMissingPackets();
   num_packets_received_since_last_ack_sent_ = 0;
 
   packet_generator_.SetShouldSendAck(true);
 }
 
 void QuicConnection::OnRetransmissionTimeout() {
-  DCHECK(sent_packet_manager_.HasUnackedPackets());
+  DCHECK(sent_packet_manager_->HasUnackedPackets());
 
   if (close_connection_after_five_rtos_ &&
-      sent_packet_manager_.consecutive_rto_count() >= 4) {
+      sent_packet_manager_->GetConsecutiveRtoCount() >= 4) {
     // Close on the 5th consecutive RTO, so after 4 previous RTOs have occurred.
     CloseConnection(QUIC_TOO_MANY_RTOS, "5 consecutive retransmission timeouts",
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
   // Cancel the send alarm to ensure TimeUntilSend is re-evaluated.
   if (FLAGS_quic_only_one_sending_alarm) {
     send_alarm_->Cancel();
   }
-  sent_packet_manager_.OnRetransmissionTimeout();
+  sent_packet_manager_->OnRetransmissionTimeout();
   WriteIfNotBlocked();
 
   // A write failure can result in the connection being closed, don't attempt to
   // write further packets, or to set alarms.
   if (!connected_) {
     return;
   }
 
   // In the TLP case, the SentPacketManager gives the connection the opportunity
   // to send new data before retransmitting.
-  if (sent_packet_manager_.MaybeRetransmitTailLossProbe()) {
+  if (sent_packet_manager_->MaybeRetransmitTailLossProbe()) {
     // Send the pending retransmission now that it's been queued.
     WriteIfNotBlocked();
   }
 
   // Ensure the retransmission alarm is always set if there are unacked packets
   // and nothing waiting to be sent.
   // This happens if the loss algorithm invokes a timer based loss, but the
   // packet doesn't need to be retransmitted.
   if (!HasQueuedData() && !retransmission_alarm_->IsSet()) {
     SetRetransmissionAlarm();
   }
 }
 
 void QuicConnection::SetEncrypter(EncryptionLevel level,
                                   QuicEncrypter* encrypter) {
   packet_generator_.SetEncrypter(level, encrypter);
   if (level == ENCRYPTION_FORWARD_SECURE) {
     has_forward_secure_encrypter_ = true;
     first_required_forward_secure_packet_ =
         packet_number_of_last_sent_packet_ +
         // 3 times the current congestion window (in slow start) should cover
         // about two full round trips worth of packets, which should be
         // sufficient.
         3 *
-            sent_packet_manager_.EstimateMaxPacketsInFlight(
+            sent_packet_manager_->EstimateMaxPacketsInFlight(
                 max_packet_length());
   }
 }
 
 void QuicConnection::SetDiversificationNonce(const DiversificationNonce nonce) {
   DCHECK_EQ(Perspective::IS_SERVER, perspective_);
   packet_generator_.SetDiversificationNonce(nonce);
 }
 
 void QuicConnection::SetDefaultEncryptionLevel(EncryptionLevel level) {
@@ skipping 267 matching lines @@
 }
 
 void QuicConnection::SetRetransmissionAlarm() {
   if (delay_setting_retransmission_alarm_) {
     pending_retransmission_alarm_ = true;
     return;
   }
   // Once the handshake has been confirmed, the retransmission alarm should
   // never fire before the send alarm.
   if (FLAGS_quic_only_one_sending_alarm &&
-      sent_packet_manager_.handshake_confirmed() && send_alarm_->IsSet()) {
-    DCHECK(!sent_packet_manager_.GetRetransmissionTime().IsInitialized() ||
-           sent_packet_manager_.GetRetransmissionTime() >=
+      sent_packet_manager_->IsHandshakeConfirmed() && send_alarm_->IsSet()) {
+    DCHECK(!sent_packet_manager_->GetRetransmissionTime().IsInitialized() ||
+           sent_packet_manager_->GetRetransmissionTime() >=
                send_alarm_->deadline())
         << " retransmission_time:"
-        << sent_packet_manager_.GetRetransmissionTime().ToDebuggingValue()
+        << sent_packet_manager_->GetRetransmissionTime().ToDebuggingValue()
         << " send_alarm:" << send_alarm_->deadline().ToDebuggingValue();
     retransmission_alarm_->Cancel();
     return;
   }
-  QuicTime retransmission_time = sent_packet_manager_.GetRetransmissionTime();
+  QuicTime retransmission_time = sent_packet_manager_->GetRetransmissionTime();
   retransmission_alarm_->Update(retransmission_time,
                                 QuicTime::Delta::FromMilliseconds(1));
 }
 
 void QuicConnection::MaybeSetMtuAlarm() {
   // Do not set the alarm if the target size is less than the current size.
   // This covers the case when |mtu_discovery_target_| is at its default value,
   // zero.
   if (mtu_discovery_target_ <= max_packet_length()) {
     return;
@@ skipping 169 matching lines @@
   next_mtu_probe_at_ =
       packet_number_of_last_sent_packet_ + packets_between_mtu_probes_ + 1;
   ++mtu_probe_count_;
 
   DVLOG(2) << "Sending a path MTU discovery packet #" << mtu_probe_count_;
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
-void QuicConnection::OnPeerMigrationValidated() {
+void QuicConnection::OnPeerMigrationValidated(QuicPathId path_id) {
   if (active_peer_migration_type_ == NO_CHANGE) {
     QUIC_BUG << "No migration underway.";
     return;
   }
   highest_packet_sent_before_peer_migration_ = 0;
   active_peer_migration_type_ = NO_CHANGE;
 }
 
 // TODO(jri): Modify method to start migration whenever a new IP address is seen
 // from a packet with sequence number > the one that triggered the previous
 // migration. This should happen even if a migration is underway, since the
 // most recent migration is the one that we should pay attention to.
 void QuicConnection::StartPeerMigration(
+    QuicPathId path_id,
     PeerAddressChangeType peer_migration_type) {
   // TODO(fayang): Currently, all peer address change type are allowed. Need to
   // add a method ShouldAllowPeerAddressChange(PeerAddressChangeType type) to
   // determine whether |type| is allowed.
   if (active_peer_migration_type_ != NO_CHANGE ||
       peer_migration_type == NO_CHANGE) {
     QUIC_BUG << "Migration underway or no new migration started.";
     return;
   }
   DVLOG(1) << ENDPOINT << "Peer's ip:port changed from "
            << peer_address_.ToString() << " to "
            << last_packet_source_address_.ToString()
            << ", migrating connection.";
 
   highest_packet_sent_before_peer_migration_ =
       packet_number_of_last_sent_packet_;
   peer_address_ = last_packet_source_address_;
   active_peer_migration_type_ = peer_migration_type;
 
   // TODO(jri): Move these calls to OnPeerMigrationValidated. Rename
   // OnConnectionMigration methods to OnPeerMigration.
   visitor_->OnConnectionMigration(peer_migration_type);
-  sent_packet_manager_.OnConnectionMigration(peer_migration_type);
+  sent_packet_manager_->OnConnectionMigration(path_id, peer_migration_type);
 }
 
 void QuicConnection::OnPathClosed(QuicPathId path_id) {
   // Stop receiving packets on this path.
   framer_.OnPathClosed(path_id);
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
@@ skipping 22 matching lines @@
   if (perspective_ == Perspective::IS_CLIENT &&
       frame.data_length >= sizeof(kREJ) &&
       strncmp(frame.data_buffer, reinterpret_cast<const char*>(&kREJ),
               sizeof(kREJ)) == 0) {
     return true;
   }
 
   return false;
 }
 
+// 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 QuicConnection::DelayedAckTime() {
+  return QuicTime::Delta::FromMilliseconds(
+      min(kMaxDelayedAckTimeMs, kMinRetransmissionTimeMs / 2));
+}
+
 }  // namespace net