Rollback of internal changelist 128865569.

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: ")
@@ skipping 27 matching lines @@
       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),
-      using_inline_pacing_(false),
       use_new_rto_(false),
       undo_pending_retransmits_(false),
       largest_newly_acked_(0),
       largest_mtu_acked_(0),
       handshake_confirmed_(false) {}
 
 QuicSentPacketManager::~QuicSentPacketManager() {}
 
 void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
   if (config.HasReceivedInitialRoundTripTimeUs() &&
@@ skipping 83 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_inline_pacing_) {
-    pacing_sender_.SetMaxPacingRate(max_pacing_rate);
-  } else if (using_pacing_) {
+  if (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,
@@ skipping 67 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;
   }
-  if (using_inline_pacing_) {
-    pacing_sender_.OnCongestionEvent(rtt_updated, bytes_in_flight,
+  send_algorithm_->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_;
   }
 
-  bool in_flight;
-  if (using_inline_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);
-  }
+  // 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);
 
   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 191 matching lines @@
 }
 
 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_inline_pacing_) {
-      delay =
-          pacing_sender_.TimeUntilSend(now, unacked_packets_.bytes_in_flight());
-    } else {
-      delay = send_algorithm_->TimeUntilSend(
-          now, unacked_packets_.bytes_in_flight());
-    }
+    delay =
+        send_algorithm_->TimeUntilSend(now, unacked_packets_.bytes_in_flight());
   }
   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.
@@ skipping 130 matching lines @@
   while (it != pending_retransmissions_.end()) {
     if (unacked_packets_.HasRetransmittableFrames(it->first)) {
       ++it;
       continue;
     }
     it = pending_retransmissions_.erase(it);
   }
 }
 
 void QuicSentPacketManager::EnablePacing() {
-  if (FLAGS_quic_use_inline_pacing) {
-    using_inline_pacing_ = true;
-    pacing_sender_.SetSender(send_algorithm_.get(), false);
-  } else {
-    // 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;
-    }
+  // 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;
-    PacingSender* pacing_sender = new PacingSender;
-    pacing_sender->SetSender(send_algorithm_.release(), true);
-    send_algorithm_.reset(pacing_sender);
-  }
+  // 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(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 46 matching lines @@
 TransmissionInfo* QuicSentPacketManager::GetMutableTransmissionInfo(
     QuicPacketNumber packet_number) {
   return unacked_packets_.GetMutableTransmissionInfo(packet_number);
 }
 
 void QuicSentPacketManager::RemoveObsoletePackets() {
   unacked_packets_.RemoveObsoletePackets();
 }
 
 }  // namespace net