Fix a bug protected by gfe2_reloadable_flag_quic_respect_send_alarm where acks would not be sent im…

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 692 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()) {
+  if (FLAGS_quic_respect_send_alarm2 && 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()) {
@@ skipping 780 matching lines @@
 bool QuicConnection::CanWrite(HasRetransmittableData retransmittable) {
   if (!connected_) {
     return false;
   }
 
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     return false;
   }
 
-  // If the send alarm is set, wait for it to fire.
-  if (FLAGS_quic_respect_send_alarm && send_alarm_->IsSet()) {
-    return false;
+  if (FLAGS_quic_respect_send_alarm2) {
+    // Allow acks to be sent immediately.
+    // TODO(ianswett): Remove retransmittable from
+    // SendAlgorithmInterface::TimeUntilSend.
+    if (retransmittable == NO_RETRANSMITTABLE_DATA) {
+      return true;
+    }
+    // If the send alarm is set, wait for it to fire.
+    if (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_quic_respect_send_alarm) {
+  if (!FLAGS_quic_respect_send_alarm2) {
     send_alarm_->Cancel();
   }
   return true;
 }
 
 bool QuicConnection::WritePacket(QueuedPacket* packet) {
   if (!WritePacketInner(packet)) {
     return false;
   }
   delete packet->serialized_packet.retransmittable_frames;
@@ skipping 714 matching lines @@
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Entering Batch Mode.";
     connection_->packet_generator_.StartBatchOperations();
   }
   // Bundle an ack if the alarm is set or with every second packet if we need to
   // raise the peer's least unacked.
   bool ack_pending =
       connection_->ack_alarm_->IsSet() || connection_->stop_waiting_count_ > 1;
   if (send_ack == SEND_ACK || (send_ack == BUNDLE_PENDING_ACK && ack_pending)) {
     DVLOG(1) << "Bundling ack with outgoing packet.";
-    DCHECK(send_ack == SEND_ACK || connection_->ack_frame_updated());
+    DCHECK(send_ack == SEND_ACK || connection_->ack_frame_updated() ||
+           connection_->stop_waiting_count_ > 1);
     connection_->SendAck();
   }
 }
 
 QuicConnection::ScopedPacketBundler::~ScopedPacketBundler() {
   if (connection_ == nullptr) {
     return;
   }
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
@@ skipping 118 matching lines @@
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 void QuicConnection::set_ack_frame_updated(bool updated) {
   received_packet_manager_.set_ack_frame_updated(updated);
 }
 
 }  // namespace net