relnote: Moving many QUIC DFATALS over to QUIC_BUG

net/quic/quic_sent_packet_manager.cc

 // Copyright 2013 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_sent_packet_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/congestion_control/pacing_sender.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
+#include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils_chromium.h"
 
 using std::max;
 using std::min;
 
 namespace net {
 
 // The length of the recent min rtt window in seconds. Windowing is disabled for
@@ skipping 391 matching lines @@
     }
     return;
   }
   const PacketNumberList* all_transmissions = info.all_transmissions;
   for (PacketNumberList::const_reverse_iterator it =
            all_transmissions->rbegin();
        it != all_transmissions->rend() && *it > acked_packet_number; ++it) {
     // ianswett: Prevents crash in b/20552846.
     if (*it < unacked_packets_.GetLeastUnacked() ||
         *it > unacked_packets_.largest_sent_packet()) {
-      LOG(DFATAL) << "Retransmission out of range:" << *it
-                  << " least unacked:" << unacked_packets_.GetLeastUnacked()
-                  << " largest sent:" << unacked_packets_.largest_sent_packet();
+      QUIC_BUG << "Retransmission out of range:" << *it
+               << " least unacked:" << unacked_packets_.GetLeastUnacked()
+               << " largest sent:" << unacked_packets_.largest_sent_packet();
       return;
     }
     const TransmissionInfo& retransmit_info =
         unacked_packets_.GetTransmissionInfo(*it);
 
     RecordOneSpuriousRetransmission(retransmit_info);
   }
 }
 
 bool QuicSentPacketManager::HasPendingRetransmissions() const {
@@ skipping 124 matching lines @@
     QuicByteCount bytes,
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   QuicPacketNumber packet_number = serialized_packet->packet_number;
   DCHECK_LT(0u, packet_number);
   DCHECK(!unacked_packets_.IsUnacked(packet_number));
   LOG_IF(DFATAL, bytes == 0) << "Cannot send empty packets.";
 
   if (original_packet_number != 0) {
     if (!pending_retransmissions_.erase(original_packet_number)) {
-      DLOG(DFATAL) << "Expected packet number to be in "
-                   << "pending_retransmissions_.  packet_number: "
-                   << original_packet_number;
+      QUIC_BUG << "Expected packet number to be in "
+               << "pending_retransmissions_.  packet_number: "
+               << original_packet_number;
     }
   }
 
   if (pending_timer_transmission_count_ > 0) {
     --pending_timer_transmission_count_;
   }
 
   // Only track packets as in flight that the send algorithm wants us to track.
   // Since FEC packets should also be counted towards the congestion window,
   // consider them as retransmittable for the purposes of congestion control.
@@ skipping 195 matching lines @@
   // unacked, and may cause an RTT sample to be taken.
   if (!unacked_packets_.IsUnacked(ack_frame.largest_observed)) {
     return false;
   }
   // We calculate the RTT based on the highest ACKed packet number, the lower
   // packet numbers will include the ACK aggregation delay.
   const TransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(ack_frame.largest_observed);
   // Ensure the packet has a valid sent time.
   if (transmission_info.sent_time == QuicTime::Zero()) {
-    LOG(DFATAL) << "Acked packet has zero sent time, largest_observed:"
-                << ack_frame.largest_observed;
+    QUIC_BUG << "Acked packet has zero sent time, largest_observed:"
+             << ack_frame.largest_observed;
     return false;
   }
 
   QuicTime::Delta send_delta =
       ack_receive_time.Subtract(transmission_info.sent_time);
   rtt_stats_.UpdateRtt(send_delta, ack_frame.delta_time_largest_observed,
                        ack_receive_time);
 
   if (network_change_visitor_ != nullptr) {
     network_change_visitor_->OnRttChange();
@@ skipping 193 matching lines @@
     // Rtt and cwnd do not need to be reset when the peer address change is
     // considered to be caused by NATs.
     return;
   }
 
   rtt_stats_.OnConnectionMigration();
   send_algorithm_->OnConnectionMigration();
 }
 
 }  // namespace net