Landing recent QUIC changes until 6/24/2016 14:00 UTC

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 300 matching lines @@
       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();
+  // TODO(ianswett): Supply the NetworkChangeVisitor as a constructor argument
+  // and make it required non-null, because it's always used.
   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() {
@@ skipping 360 matching lines @@
   return true;
 }
 
 bool QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnStreamFrame(frame);
   }
   if (frame.stream_id != kCryptoStreamId &&
       last_decrypted_packet_level_ == ENCRYPTION_NONE) {
-    if (FLAGS_quic_detect_memory_corrpution &&
-        MaybeConsiderAsMemoryCorruption(frame)) {
+    if (MaybeConsiderAsMemoryCorruption(frame)) {
       CloseConnection(QUIC_MAYBE_CORRUPTED_MEMORY,
                       "Received crypto frame on non crypto stream.",
                       ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
       return false;
     }
 
     QUIC_BUG << ENDPOINT
              << "Received an unencrypted data frame: closing connection"
              << " packet_number:" << last_header_.packet_number
              << " stream_id:" << frame.stream_id
@@ skipping 960 matching lines @@
     if (IsRetransmittable(*packet) == HAS_RETRANSMITTABLE_DATA &&
         last_send_for_timeout_ <= time_of_last_received_packet_) {
       last_send_for_timeout_ = packet_send_time;
     }
   }
   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_->GetLeastPacketAwaitedByPeer(packet->path_id),
-      sent_packet_manager_->EstimateMaxPacketsInFlight(max_packet_length()));
+  if (!FLAGS_quic_simple_packet_number_length) {
+    // 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_->GetLeastPacketAwaitedByPeer(packet->path_id),
+        sent_packet_manager_->EstimateMaxPacketsInFlight(max_packet_length()));
+  }
 
   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();
   }
 
+  if (FLAGS_quic_simple_packet_number_length) {
+    // The packet number length must be updated after OnPacketSent, because it
+    // may change the packet number length in packet.
+    packet_generator_.UpdateSequenceNumberLength(
+        sent_packet_manager_->GetLeastPacketAwaitedByPeer(packet->path_id),
+        sent_packet_manager_->EstimateMaxPacketsInFlight(max_packet_length()));
+  }
+
   stats_.bytes_sent += result.bytes_written;
   ++stats_.packets_sent;
   if (packet->transmission_type != NOT_RETRANSMISSION) {
     stats_.bytes_retransmitted += result.bytes_written;
     ++stats_.packets_retransmitted;
   }
 
   if (result.status == WRITE_STATUS_ERROR) {
     OnWriteError(result.error_code);
     DLOG(ERROR) << ENDPOINT << "failed writing " << encrypted_length
@@ skipping 92 matching lines @@
   }
 
   if (debug_visitor_)
     debug_visitor_->OnRttChanged(rtt);
 }
 
 void QuicConnection::OnPathDegrading() {
   visitor_->OnPathDegrading();
 }
 
+void QuicConnection::OnPathMtuIncreased(QuicPacketLength packet_size) {
+  DCHECK(FLAGS_quic_no_mtu_discovery_ack_listener);
+  if (packet_size > max_packet_length()) {
+    SetMaxPacketLength(packet_size);
+  }
+}
+
 void QuicConnection::OnHandshakeComplete() {
   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());
   }
 }
@@ skipping 545 matching lines @@
 
   // Create a listener for the new probe.  The ownership of the listener is
   // transferred to the AckNotifierManager.  The notifier will get destroyed
   // before the connection (because it's stored in one of the connection's
   // subfields), hence |this| pointer is guaranteed to stay valid at all times.
   scoped_refptr<MtuDiscoveryAckListener> last_mtu_discovery_ack_listener(
       new MtuDiscoveryAckListener(this, target_mtu));
 
   // Send the probe.
   packet_generator_.GenerateMtuDiscoveryPacket(
-      target_mtu, last_mtu_discovery_ack_listener.get());
+      target_mtu, FLAGS_quic_no_mtu_discovery_ack_listener
+                      ? nullptr
+                      : last_mtu_discovery_ack_listener.get());
 }
 
 void QuicConnection::DiscoverMtu() {
   DCHECK(!mtu_discovery_alarm_->IsSet());
 
-  // Chcek if the MTU has been already increased.
+  // Check if the MTU has been already increased.
   if (mtu_discovery_target_ <= max_packet_length()) {
     return;
   }
 
-  // Schedule the next probe *before* sending the current one.  This is
-  // important, otherwise, when SendMtuDiscoveryPacket() is called,
+  // Calculate the packet number of the next probe *before* sending the current
+  // one.  Otherwise, when SendMtuDiscoveryPacket() is called,
   // MaybeSetMtuAlarm() will not realize that the probe has been just sent, and
   // will reschedule this probe again.
   packets_between_mtu_probes_ *= 2;
   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_);
 
@@ skipping 93 matching lines @@
 // 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