Clear the connection's send alarm when a new ack is received. Flag protected by gfe2_reloadable_fl…

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 719 matching lines @@
   if (last_header_.packet_number <= largest_seen_packet_with_ack_) {
     DVLOG(1) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
 
   if (!ValidateAckFrame(incoming_ack)) {
     SendConnectionClose(QUIC_INVALID_ACK_DATA);
     return false;
   }
 
+  if (FLAGS_quic_respect_send_alarm &&
+      send_alarm_->IsSet()) {
+    send_alarm_->Cancel();
+  }
   ProcessAckFrame(incoming_ack);
   if (incoming_ack.is_truncated) {
     should_last_packet_instigate_acks_ = true;
   }
   // If the peer is still waiting for a packet that we are no longer planning to
   // send, send an ack to raise the high water mark.
   if (!incoming_ack.missing_packets.Empty() &&
       GetLeastUnacked() > incoming_ack.missing_packets.Min()) {
     ++stop_waiting_count_;
   } else {
@@ skipping 718 matching lines @@
   if (!connected_) {
     return false;
   }
 
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     return false;
   }
 
   // If the send alarm is set, wait for it to fire.
-  if (FLAGS_respect_send_alarm && send_alarm_->IsSet()) {
+  if (FLAGS_quic_respect_send_alarm &&
+      send_alarm_->IsSet()) {
     return false;
   }
 
   QuicTime now = clock_->Now();
   QuicTime::Delta delay = sent_packet_manager_.TimeUntilSend(
       now, retransmittable);
   if (delay.IsInfinite()) {
     send_alarm_->Cancel();
     return false;
   }
 
   // If the scheduler requires a delay, then we can not send this packet now.
   if (!delay.IsZero()) {
     send_alarm_->Update(now.Add(delay), QuicTime::Delta::FromMilliseconds(1));
     DVLOG(1) << ENDPOINT << "Delaying sending " << delay.ToMilliseconds()
              << "ms";
     return false;
   }
-  if (!FLAGS_respect_send_alarm) {
+  if (!FLAGS_quic_respect_send_alarm) {
     send_alarm_->Cancel();
   }
   return true;
 }
 
 bool QuicConnection::WritePacket(QueuedPacket* packet) {
   if (!WritePacketInner(packet)) {
     return false;
   }
   delete packet->serialized_packet.retransmittable_frames;
@@ skipping 843 matching lines @@
       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_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 }  // namespace net