Landing Recent QUIC changes until 4AM, Aug 7, 2016 UTC-4

net/quic/core/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/core/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 
 #include <algorithm>
@@ skipping 672 matching lines @@
   }
 
   // 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_);
   // Do not migrate connection if the changed address packet is a reordered
   // packet.
   if (active_peer_migration_type_ == NO_CHANGE &&
       peer_migration_type != NO_CHANGE &&
-      (!FLAGS_quic_do_not_migrate_on_old_packet ||
-       header.packet_number > received_packet_manager_.GetLargestObserved())) {
+      header.packet_number > received_packet_manager_.GetLargestObserved()) {
     StartPeerMigration(header.path_id, peer_migration_type);
   }
 
   --stats_.packets_dropped;
   DVLOG(1) << ENDPOINT << "Received packet header: " << header;
   last_header_ = header;
   DCHECK(connected_);
   return true;
 }
 
@@ skipping 456 matching lines @@
   // 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_->Update(clock_->ApproximateNow(), QuicTime::Delta::Zero());
   } else {
     WriteAndBundleAcksIfNotBlocked();
   }
 }
 
 void QuicConnection::SendVersionNegotiationPacket() {
-  // TODO(alyssar): implement zero server state negotiation.
   pending_version_negotiation_packet_ = true;
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     return;
   }
   DVLOG(1) << ENDPOINT << "Sending version negotiation packet: {"
            << QuicVersionVectorToString(framer_.supported_versions()) << "}";
   std::unique_ptr<QuicEncryptedPacket> version_packet(
       packet_generator_.SerializeVersionNegotiationPacket(
           framer_.supported_versions()));
@@ skipping 1118 matching lines @@
 }
 
 QuicConnection::ScopedPacketBundler::~ScopedPacketBundler() {
   if (connection_ == nullptr) {
     return;
   }
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(2) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
+
+    // Once all transmissions are done, check if there is any outstanding data
+    // to send and notify the congestion controller if not.
+    //
+    // Note that this means that the application limited check will happen as
+    // soon as the last bundler gets destroyed, which is typically after a
+    // single stream write is finished.  This means that if all the data from a
+    // single write goes through the connection, the application-limited signal
+    // will fire even if the caller does a write operation immediately after.
+    // There are two important approaches to remedy this situation:
+    // (1) Instantiate ScopedPacketBundler before performing multiple subsequent
+    //     writes, thus deferring this check until all writes are done.
+    // (2) Write data in chunks sufficiently large so that they cause the
+    //     connection to be limited by the congestion control.  Typically, this
+    //     would mean writing chunks larger than the product of the current
+    //     pacing rate and the pacer granularity.  So, for instance, if the
+    //     pacing rate of the connection is 1 Gbps, and the pacer granularity is
+    //     1 ms, the caller should send at least 125k bytes in order to not
+    //     be marked as application-limited.
+    if (FLAGS_quic_enable_app_limited_check) {
+      connection_->CheckIfApplicationLimited();
+    }
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 QuicConnection::ScopedRetransmissionScheduler::ScopedRetransmissionScheduler(
     QuicConnection* connection)
     : connection_(connection),
       already_delayed_(connection_->delay_setting_retransmission_alarm_) {
   connection_->delay_setting_retransmission_alarm_ = true;
@@ skipping 196 matching lines @@
 // 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));
 }
 
+void QuicConnection::CheckIfApplicationLimited() {
+  if (queued_packets_.empty() &&
+      !sent_packet_manager_->HasPendingRetransmissions() &&
+      !visitor_->WillingAndAbleToWrite()) {
+    sent_packet_manager_->OnApplicationLimited();
+  }
+}
+
 }  // namespace net