Fix memory corruption from SetMaxPacingRate by inlining PacingSender.

net/quic/core/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/core/quic_sent_packet_manager.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 24 matching lines @@
 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.
 static const int64_t kMinHandshakeTimeoutMs = 10;
 
 // Sends up to two tail loss probes before firing an RTO,
 // per draft RFC draft-dukkipati-tcpm-tcp-loss-probe.
 static const size_t kDefaultMaxTailLossProbes = 2;
 
-// Number of unpaced packets to send after quiescence.
-static const size_t kInitialUnpacedBurst = 10;
-
 bool HasCryptoHandshake(const TransmissionInfo& transmission_info) {
   DCHECK(!transmission_info.has_crypto_handshake ||
          !transmission_info.retransmittable_frames.empty());
   return transmission_info.has_crypto_handshake;
 }
 
 }  // namespace
 
 #define ENDPOINT \
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
 QuicSentPacketManager::QuicSentPacketManager(
     Perspective perspective,
     QuicPathId path_id,
     const QuicClock* clock,
     QuicConnectionStats* stats,
     CongestionControlType congestion_control_type,
     LossDetectionType loss_type,
     MultipathDelegateInterface* delegate)
     : unacked_packets_(),
       perspective_(perspective),
       path_id_(path_id),
       clock_(clock),
       stats_(stats),
       delegate_(delegate),
       debug_delegate_(nullptr),
       network_change_visitor_(nullptr),
       initial_congestion_window_(kInitialCongestionWindow),
-      send_algorithm_(
-          SendAlgorithmInterface::Create(clock,
-                                         &rtt_stats_,
-                                         congestion_control_type,
-                                         stats,
-                                         initial_congestion_window_)),
       loss_algorithm_(&general_loss_algorithm_),
       general_loss_algorithm_(loss_type),
       n_connection_simulation_(false),
       receive_buffer_bytes_(kDefaultSocketReceiveBuffer),
       least_packet_awaited_by_peer_(1),
       first_rto_transmission_(0),
       consecutive_rto_count_(0),
       consecutive_tlp_count_(0),
       consecutive_crypto_retransmission_count_(0),
       pending_timer_transmission_count_(0),
       max_tail_loss_probes_(kDefaultMaxTailLossProbes),
       enable_half_rtt_tail_loss_probe_(false),
       using_pacing_(false),
       use_new_rto_(false),
       undo_pending_retransmits_(false),
       largest_newly_acked_(0),
       largest_mtu_acked_(0),
-      handshake_confirmed_(false) {}
+      handshake_confirmed_(false) {
+  SetSendAlgorithm(congestion_control_type);
+}
 
 QuicSentPacketManager::~QuicSentPacketManager() {}
 
 void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
   if (config.HasReceivedInitialRoundTripTimeUs() &&
       config.ReceivedInitialRoundTripTimeUs() > 0) {
     rtt_stats_.set_initial_rtt_us(
         max(kMinInitialRoundTripTimeUs,
             min(kMaxInitialRoundTripTimeUs,
                 config.ReceivedInitialRoundTripTimeUs())));
   } else if (config.HasInitialRoundTripTimeUsToSend() &&
              config.GetInitialRoundTripTimeUsToSend() > 0) {
     rtt_stats_.set_initial_rtt_us(
         max(kMinInitialRoundTripTimeUs,
             min(kMaxInitialRoundTripTimeUs,
                 config.GetInitialRoundTripTimeUsToSend())));
   }
   // TODO(ianswett): BBR is currently a server only feature.
   if (FLAGS_quic_allow_bbr && config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kTBBR)) {
-    send_algorithm_.reset(SendAlgorithmInterface::Create(
-        clock_, &rtt_stats_, kBBR, stats_, initial_congestion_window_));
+    SetSendAlgorithm(kBBR);
   }
   if (config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kRENO)) {
     if (ContainsQuicTag(config.ReceivedConnectionOptions(), kBYTE)) {
-      send_algorithm_.reset(SendAlgorithmInterface::Create(
-          clock_, &rtt_stats_, kRenoBytes, stats_, initial_congestion_window_));
+      SetSendAlgorithm(kRenoBytes);
     } else {
-      send_algorithm_.reset(SendAlgorithmInterface::Create(
-          clock_, &rtt_stats_, kReno, stats_, initial_congestion_window_));
+      SetSendAlgorithm(kReno);
     }
   } else if (config.HasReceivedConnectionOptions() &&
              ContainsQuicTag(config.ReceivedConnectionOptions(), kBYTE)) {
-    send_algorithm_.reset(SendAlgorithmInterface::Create(
-        clock_, &rtt_stats_, kCubicBytes, stats_, initial_congestion_window_));
+    SetSendAlgorithm(kCubicBytes);
   }
-  if (!FLAGS_quic_disable_pacing_for_perf_tests) {
-    EnablePacing();
-  }
+  using_pacing_ = !FLAGS_quic_disable_pacing_for_perf_tests;
 
   if (config.HasClientSentConnectionOption(k1CON, perspective_)) {
     send_algorithm_->SetNumEmulatedConnections(1);
   }
   if (config.HasClientSentConnectionOption(kNCON, perspective_)) {
     n_connection_simulation_ = true;
   }
   if (config.HasClientSentConnectionOption(kNTLP, perspective_)) {
     max_tail_loss_probes_ = 0;
   }
@@ skipping 38 matching lines @@
 
 void QuicSentPacketManager::SetNumOpenStreams(size_t num_streams) {
   if (n_connection_simulation_) {
     // Ensure the number of connections is between 1 and 5.
     send_algorithm_->SetNumEmulatedConnections(
         min<size_t>(5, max<size_t>(1, num_streams)));
   }
 }
 
 void QuicSentPacketManager::SetMaxPacingRate(QuicBandwidth max_pacing_rate) {
-  if (using_pacing_) {
-    static_cast<PacingSender*>(send_algorithm_.get())
-        ->SetMaxPacingRate(max_pacing_rate);
-  }
+  pacing_sender_.set_max_pacing_rate(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();
@@ skipping 64 matching lines @@
     least_packet_awaited_by_peer_ = ack_frame.packets.Min();
   }
 }
 
 void QuicSentPacketManager::MaybeInvokeCongestionEvent(
     bool rtt_updated,
     QuicByteCount bytes_in_flight) {
   if (!rtt_updated && packets_acked_.empty() && packets_lost_.empty()) {
     return;
   }
-  send_algorithm_->OnCongestionEvent(rtt_updated, bytes_in_flight,
+  if (using_pacing_) {
+    pacing_sender_.OnCongestionEvent(rtt_updated, bytes_in_flight,
                                      packets_acked_, packets_lost_);
+  } else {
+    send_algorithm_->OnCongestionEvent(rtt_updated, bytes_in_flight,
+                                       packets_acked_, packets_lost_);
+  }
   packets_acked_.clear();
   packets_lost_.clear();
   if (network_change_visitor_ != nullptr) {
     network_change_visitor_->OnCongestionChange();
   }
 }
 
 void QuicSentPacketManager::HandleAckForSentPackets(
     const QuicAckFrame& ack_frame) {
   // Go through the packets we have not received an ack for and see if this
@@ skipping 255 matching lines @@
       << "Cannot send empty packets.";
 
   if (delegate_ == nullptr && original_packet_number != 0) {
     pending_retransmissions_.erase(original_packet_number);
   }
 
   if (pending_timer_transmission_count_ > 0) {
     --pending_timer_transmission_count_;
   }
 
-  // TODO(ianswett): Remove sent_time, because it's unused.
-  const bool in_flight = send_algorithm_->OnPacketSent(
-      sent_time, unacked_packets_.bytes_in_flight(), packet_number,
-      serialized_packet->encrypted_length, has_retransmittable_data);
+  bool in_flight;
+  if (using_pacing_) {
+    in_flight = pacing_sender_.OnPacketSent(
+        sent_time, unacked_packets_.bytes_in_flight(), packet_number,
+        serialized_packet->encrypted_length, has_retransmittable_data);
+  } else {
+    in_flight = send_algorithm_->OnPacketSent(
+        sent_time, unacked_packets_.bytes_in_flight(), packet_number,
+        serialized_packet->encrypted_length, has_retransmittable_data);
+  }
 
   unacked_packets_.AddSentPacket(serialized_packet, original_packet_number,
                                  transmission_type, sent_time, in_flight);
   // Reset the retransmission timer anytime a pending packet is sent.
   return in_flight;
 }
 
 void QuicSentPacketManager::OnRetransmissionTimeout() {
   DCHECK(unacked_packets_.HasInFlightPackets());
   DCHECK_EQ(0u, pending_timer_transmission_count_);
@@ skipping 190 matching lines @@
   return true;
 }
 
 QuicTime::Delta QuicSentPacketManager::TimeUntilSend(QuicTime now,
                                                      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) {
     delay = QuicTime::Delta::Zero();
+  } else if (using_pacing_) {
+    delay =
+        pacing_sender_.TimeUntilSend(now, unacked_packets_.bytes_in_flight());
   } else {
     delay =
         send_algorithm_->TimeUntilSend(now, unacked_packets_.bytes_in_flight());
   }
   if (!delay.IsInfinite()) {
     *path_id = path_id_;
   }
   return delay;
 }
 
@@ skipping 132 matching lines @@
   PendingRetransmissionMap::iterator it = pending_retransmissions_.begin();
   while (it != pending_retransmissions_.end()) {
     if (unacked_packets_.HasRetransmittableFrames(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;
-  }
+void QuicSentPacketManager::SetSendAlgorithm(
+    CongestionControlType congestion_control_type) {
+  SetSendAlgorithm(SendAlgorithmInterface::Create(
+      clock_, &rtt_stats_, congestion_control_type, stats_,
+      initial_congestion_window_));
+}
 
-  // 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::SetSendAlgorithm(
+    SendAlgorithmInterface* send_algorithm) {
+  send_algorithm_.reset(send_algorithm);
+  pacing_sender_.set_sender(send_algorithm);
 }
 
 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;
@@ skipping 50 matching lines @@
 
 void QuicSentPacketManager::RemoveObsoletePackets() {
   unacked_packets_.RemoveObsoletePackets();
 }
 
 void QuicSentPacketManager::OnApplicationLimited() {
   send_algorithm_->OnApplicationLimited(unacked_packets_.bytes_in_flight());
 }
 
 }  // namespace net