Deprecate rolled back flag quic_only_one_sending_alarm.

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 1369 matching lines @@
     visitor_->PostProcessAfterData();
   }
 
   // After the visitor writes, it may have caused the socket to become write
   // blocked or the congestion manager to prohibit sending, so check again.
   if (visitor_->WillingAndAbleToWrite() && !resume_writes_alarm_->IsSet() &&
       CanWrite(HAS_RETRANSMITTABLE_DATA)) {
     // We're not write blocked, but some stream didn't write out all of its
     // bytes. Register for 'immediate' resumption so we'll keep writing after
     // other connections and events have had a chance to use the thread.
-    if (FLAGS_quic_only_one_sending_alarm) {
-      send_alarm_->Update(clock_->ApproximateNow(), QuicTime::Delta::Zero());
-    } else {
-      resume_writes_alarm_->Set(clock_->ApproximateNow());
-    }
+    resume_writes_alarm_->Set(clock_->ApproximateNow());
   }
 }
 
 void QuicConnection::WriteIfNotBlocked() {
   if (!writer_->IsWriteBlocked()) {
     OnCanWrite();
   }
 }
 
 void QuicConnection::WriteAndBundleAcksIfNotBlocked() {
@@ skipping 476 matching lines @@
   DCHECK(sent_packet_manager_->HasUnackedPackets());
 
   if (close_connection_after_five_rtos_ &&
       sent_packet_manager_->GetConsecutiveRtoCount() >= 4) {
     // Close on the 5th consecutive RTO, so after 4 previous RTOs have occurred.
     CloseConnection(QUIC_TOO_MANY_RTOS, "5 consecutive retransmission timeouts",
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
-  // Cancel the send alarm to ensure TimeUntilSend is re-evaluated.
-  if (FLAGS_quic_only_one_sending_alarm) {
-    send_alarm_->Cancel();
-  }
   sent_packet_manager_->OnRetransmissionTimeout();
   WriteIfNotBlocked();
 
   // A write failure can result in the connection being closed, don't attempt to
   // write further packets, or to set alarms.
   if (!connected_) {
     return;
   }
 
   // In the TLP case, the SentPacketManager gives the connection the opportunity
@@ skipping 305 matching lines @@
   QuicTime::Delta ping_timeout = QuicTime::Delta::FromSeconds(kPingTimeoutSecs);
   ping_alarm_->Update(clock_->ApproximateNow().Add(ping_timeout),
                       QuicTime::Delta::FromSeconds(1));
 }
 
 void QuicConnection::SetRetransmissionAlarm() {
   if (delay_setting_retransmission_alarm_) {
     pending_retransmission_alarm_ = true;
     return;
   }
-  // Once the handshake has been confirmed, the retransmission alarm should
-  // never fire before the send alarm.
-  if (FLAGS_quic_only_one_sending_alarm &&
-      sent_packet_manager_->IsHandshakeConfirmed() && send_alarm_->IsSet()) {
-    DCHECK(!sent_packet_manager_->GetRetransmissionTime().IsInitialized() ||
-           sent_packet_manager_->GetRetransmissionTime() >=
-               send_alarm_->deadline())
-        << " retransmission_time:"
-        << sent_packet_manager_->GetRetransmissionTime().ToDebuggingValue()
-        << " send_alarm:" << send_alarm_->deadline().ToDebuggingValue();
-    retransmission_alarm_->Cancel();
-    return;
-  }
   QuicTime retransmission_time = sent_packet_manager_->GetRetransmissionTime();
   retransmission_alarm_->Update(retransmission_time,
                                 QuicTime::Delta::FromMilliseconds(1));
 }
 
 void QuicConnection::MaybeSetMtuAlarm() {
   // Do not set the alarm if the target size is less than the current size.
   // This covers the case when |mtu_discovery_target_| is at its default value,
   // zero.
   if (mtu_discovery_target_ <= max_packet_length()) {
@@ skipping 270 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