Deprecate FLAGS_quic_record_send_time_before_write.

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 1426 matching lines @@
            << (packet->serialized_packet.is_fec_packet
                    ? "FEC "
                    : (IsRetransmittable(*packet) == HAS_RETRANSMITTABLE_DATA
                           ? "data bearing "
                           : " ack only ")) << ", encryption level: "
            << QuicUtils::EncryptionLevelToString(packet->encryption_level)
            << ", encrypted length:" << encrypted->length();
   DVLOG(2) << ENDPOINT << "packet(" << sequence_number << "): " << std::endl
            << QuicUtils::StringToHexASCIIDump(encrypted->AsStringPiece());
 
-  QuicTime packet_send_time = QuicTime::Zero();
-  if (FLAGS_quic_record_send_time_before_write) {
-    // Measure the RTT from before the write begins to avoid underestimating the
-    // min_rtt_, especially in cases where the thread blocks or gets swapped out
-    // during the WritePacket below.
-    packet_send_time = clock_->Now();
-  }
+  // Measure the RTT from before the write begins to avoid underestimating the
+  // min_rtt_, especially in cases where the thread blocks or gets swapped out
+  // during the WritePacket below.
+  QuicTime packet_send_time = clock_->Now();
   WriteResult result = writer_->WritePacket(encrypted->data(),
                                             encrypted->length(),
                                             self_address().address(),
                                             peer_address());
   if (result.error_code == ERR_IO_PENDING) {
     DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
   }
 
   if (result.status == WRITE_STATUS_BLOCKED) {
     visitor_->OnWriteBlocked();
     // If the socket buffers the the data, then the packet should not
     // be queued and sent again, which would result in an unnecessary
     // duplicate packet being sent.  The helper must call OnCanWrite
     // when the write completes, and OnWriteError if an error occurs.
     if (!writer_->IsWriteBlockedDataBuffered()) {
       return false;
     }
   }
-  if (!FLAGS_quic_record_send_time_before_write) {
-    packet_send_time = clock_->Now();
-  }
-  if (!packet_send_time.IsInitialized()) {
-    // TODO(jokulik): This is only needed because of the two code paths for
-    // initializing packet_send_time.  Once "quic_record_send_time_before_write"
-    // is deprecated, this check can be removed.
-    LOG(DFATAL) << "The packet send time should never be zero. "
-                << "This is a programming bug, please report it.";
-  }
   if (result.status != WRITE_STATUS_ERROR && debug_visitor_ != nullptr) {
     // Pass the write result to the visitor.
     debug_visitor_->OnPacketSent(packet->serialized_packet,
                                  packet->original_sequence_number,
                                  packet->encryption_level,
                                  packet->transmission_type,
                                  *encrypted,
                                  packet_send_time);
   }
   if (packet->transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = packet_send_time;
   }
   SetPingAlarm();
   MaybeSetFecAlarm(sequence_number);
-  DVLOG(1) << ENDPOINT << "time "
-           << (FLAGS_quic_record_send_time_before_write ?
-               "we began writing " : "we finished writing ")
-           << "last sent packet: "
+  DVLOG(1) << ENDPOINT << "time we began writing last sent packet: "
            << packet_send_time.ToDebuggingValue();
 
   // TODO(ianswett): Change the sequence 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_.least_packet_awaited_by_peer(),
       sent_packet_manager_.EstimateMaxPacketsInFlight(max_packet_length()));
 
   bool reset_retransmission_alarm = sent_packet_manager_.OnPacketSent(
@@ skipping 588 matching lines @@
   }
   for (const QuicFrame& frame : retransmittable_frames->frames()) {
     if (frame.type == CONNECTION_CLOSE_FRAME) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net