Roll Chrome into Mojo.

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 1052 matching lines @@
 
 QuicConsumedData QuicConnection::SendStreamData(
     QuicStreamId id,
     const IOVector& data,
     QuicStreamOffset offset,
     bool fin,
     FecProtection fec_protection,
     QuicAckNotifier::DelegateInterface* delegate) {
   if (!fin && data.Empty()) {
     LOG(DFATAL) << "Attempt to send empty stream frame";
-  }
-
-  // This notifier will be owned by the AckNotifierManager (or deleted below if
-  // no data or FIN was consumed).
-  QuicAckNotifier* notifier = nullptr;
-  if (delegate) {
-    notifier = new QuicAckNotifier(delegate);
+    if (FLAGS_quic_empty_data_no_fin_early_return) {
+      return QuicConsumedData(0, false);
+    }
   }
 
   // Opportunistically bundle an ack with every outgoing packet.
   // Particularly, we want to bundle with handshake packets since we don't know
   // which decrypter will be used on an ack packet following a handshake
   // packet (a handshake packet from client to server could result in a REJ or a
   // SHLO from the server, leading to two different decrypters at the server.)
   //
   // TODO(jri): Note that ConsumeData may cause a response packet to be sent.
   // We may end up sending stale ack information if there are undecryptable
   // packets hanging around and/or there are revivable packets which may get
   // handled after this packet is sent. Change ScopedPacketBundler to do the
   // right thing: check ack_queued_, and then check undecryptable packets and
   // also if there is possibility of revival. Only bundle an ack if there's no
   // processing left that may cause received_info_ to change.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
-  QuicConsumedData consumed_data =
-      packet_generator_.ConsumeData(id, data, offset, fin, fec_protection,
-                                    notifier);
-
-  if (notifier &&
-      (consumed_data.bytes_consumed == 0 && !consumed_data.fin_consumed)) {
-    // No data was consumed, nor was a fin consumed, so delete the notifier.
-    delete notifier;
-  }
-
-  return consumed_data;
+  return packet_generator_.ConsumeData(id, data, offset, fin, fec_protection,
+                                       delegate);
 }
 
 void QuicConnection::SendRstStream(QuicStreamId id,
                                    QuicRstStreamErrorCode error,
                                    QuicStreamOffset bytes_written) {
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   packet_generator_.AddControlFrame(QuicFrame(new QuicRstStreamFrame(
       id, AdjustErrorForVersion(error, version()), bytes_written)));
 }
 
 void QuicConnection::SendWindowUpdate(QuicStreamId id,
                                       QuicStreamOffset byte_offset) {
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicWindowUpdateFrame(id, byte_offset)));
 }
 
 void QuicConnection::SendBlocked(QuicStreamId id) {
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   packet_generator_.AddControlFrame(QuicFrame(new QuicBlockedFrame(id)));
 }
 
 const QuicConnectionStats& QuicConnection::GetStats() {
-  // Update rtt and estimated bandwidth.
-  stats_.min_rtt_us =
-      sent_packet_manager_.GetRttStats()->min_rtt().ToMicroseconds();
-  stats_.srtt_us =
-      sent_packet_manager_.GetRttStats()->smoothed_rtt().ToMicroseconds();
+  if (!FLAGS_quic_use_initial_rtt_for_stats) {
+    stats_.min_rtt_us =
+        sent_packet_manager_.GetRttStats()->min_rtt().ToMicroseconds();
+    stats_.srtt_us =
+        sent_packet_manager_.GetRttStats()->smoothed_rtt().ToMicroseconds();
+  } else {
+    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_.max_packet_size = packet_generator_.max_packet_length();
   return stats_;
 }
 
 void QuicConnection::ProcessUdpPacket(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet) {
   if (!connected_) {
     return;
@@ skipping 443 matching lines @@
   }
   SendOrQueuePacket(QueuedPacket(serialized_packet, encryption_level_));
 }
 
 void QuicConnection::OnCongestionWindowChange() {
   packet_generator_.OnCongestionWindowChange(
       sent_packet_manager_.EstimateMaxPacketsInFlight(max_packet_length()));
   visitor_->OnCongestionWindowChange(clock_->ApproximateNow());
 }
 
+void QuicConnection::OnRttChange() {
+  // Uses the connection's smoothed RTT. If zero, uses initial_rtt.
+  QuicTime::Delta rtt = sent_packet_manager_.GetRttStats()->smoothed_rtt();
+  if (rtt.IsZero()) {
+    rtt = QuicTime::Delta::FromMicroseconds(
+        sent_packet_manager_.GetRttStats()->initial_rtt_us());
+  }
+  packet_generator_.OnRttChange(rtt);
+}
+
 void QuicConnection::OnHandshakeComplete() {
   sent_packet_manager_.SetHandshakeConfirmed();
   // The client should immediately ack the SHLO to confirm the handshake is
   // complete with the server.
   if (!is_server_ && !ack_queued_) {
     ack_alarm_->Cancel();
     ack_alarm_->Set(clock_->ApproximateNow());
   }
 }
 
@@ skipping 481 matching lines @@
   }
   for (size_t i = 0; i < retransmittable_frames->frames().size(); ++i) {
     if (retransmittable_frames->frames()[i].type == CONNECTION_CLOSE_FRAME) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net