Deprecate quic_respect_send_alarm2.

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 663 matching lines @@
     DVLOG(1) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
 
   const char* error = ValidateAckFrame(incoming_ack);
   if (error != nullptr) {
     SendConnectionCloseWithDetails(QUIC_INVALID_ACK_DATA, error);
     return false;
   }
 
-  if (FLAGS_quic_respect_send_alarm2 && send_alarm_->IsSet()) {
+  if (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 788 matching lines @@
 bool QuicConnection::CanWrite(HasRetransmittableData retransmittable) {
   if (!connected_) {
     return false;
   }
 
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     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;
-    }
+  // 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_alarm2) {
-    send_alarm_->Cancel();
-  }
   return true;
 }
 
 bool QuicConnection::WritePacket(SerializedPacket* packet) {
   if (packet->packet_number < sent_packet_manager_.largest_sent_packet()) {
     QUIC_BUG << "Attempt to write packet:" << packet->packet_number
              << " after:" << sent_packet_manager_.largest_sent_packet();
     SendConnectionCloseWithDetails(QUIC_INTERNAL_ERROR,
                                    "Packet written out of order.");
     return true;
@@ skipping 826 matching lines @@
 }
 
 StringPiece QuicConnection::GetCurrentPacket() {
   if (current_packet_data_ == nullptr) {
     return StringPiece();
   }
   return StringPiece(current_packet_data_, last_size_);
 }
 
 }  // namespace net