relnote: Moving many QUIC DFATALS over to QUIC_BUG

net/quic/quic_packet_generator.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_packet_generator.h"
 
 #include "base/logging.h"
+#include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 
 namespace net {
 
 class QuicAckNotifier;
 
@@ skipping 59 matching lines @@
   packet_creator_.OnRttChange(rtt);
 }
 
 void QuicPacketGenerator::SetShouldSendAck(bool also_send_stop_waiting) {
   if (packet_creator_.has_ack()) {
     // Ack already queued, nothing to do.
     return;
   }
 
   if (also_send_stop_waiting && packet_creator_.has_stop_waiting()) {
-    LOG(DFATAL) << "Should only ever be one pending stop waiting frame.";
+    QUIC_BUG << "Should only ever be one pending stop waiting frame.";
     return;
   }
 
   should_send_ack_ = true;
   should_send_stop_waiting_ = also_send_stop_waiting;
   SendQueuedFrames(/*flush=*/false, /*is_fec_timeout=*/false);
 }
 
 void QuicPacketGenerator::AddControlFrame(const QuicFrame& frame) {
   queued_control_frames_.push_back(frame);
@@ skipping 15 matching lines @@
   SendQueuedFrames(flush, /*is_fec_timeout=*/false);
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   if (!packet_creator_.HasRoomForStreamFrame(id, offset)) {
     packet_creator_.Flush();
   }
 
   if (!fin && (iov.total_length == 0)) {
-    LOG(DFATAL) << "Attempt to consume empty data without FIN.";
+    QUIC_BUG << "Attempt to consume empty data without FIN.";
     return QuicConsumedData(0, false);
   }
 
   while (delegate_->ShouldGeneratePacket(
       HAS_RETRANSMITTABLE_DATA, has_handshake ? IS_HANDSHAKE : NOT_HANDSHAKE)) {
     QuicFrame frame;
     if (!packet_creator_.ConsumeData(id, iov, total_bytes_consumed,
                                      offset + total_bytes_consumed, fin,
                                      has_handshake, &frame, fec_protection)) {
       // The creator is always flushed if there's not enough room for a new
       // stream frame before ConsumeData, so ConsumeData should always succeed.
-      LOG(DFATAL) << "Failed to ConsumeData, stream:" << id;
+      QUIC_BUG << "Failed to ConsumeData, stream:" << id;
       return QuicConsumedData(0, false);
     }
 
     // A stream frame is created and added.
     size_t bytes_consumed = frame.stream_frame->frame_length;
     if (listener != nullptr) {
       packet_creator_.AddAckListener(listener, bytes_consumed);
     }
     total_bytes_consumed += bytes_consumed;
     fin_consumed = fin && total_bytes_consumed == iov.total_length;
@@ skipping 78 matching lines @@
   }
   if (flush || !InBatchMode()) {
     packet_creator_.Flush();
   }
   packet_creator_.MaybeSendFecPacketAndCloseGroup(flush, is_fec_timeout);
 }
 
 void QuicPacketGenerator::OnFecTimeout() {
   DCHECK(!InBatchMode());
   if (!packet_creator_.ShouldSendFec(true)) {
-    LOG(DFATAL) << "No FEC packet to send on FEC timeout.";
+    QUIC_BUG << "No FEC packet to send on FEC timeout.";
     return;
   }
   // Flush out any pending frames in the generator and the creator, and then
   // send out FEC packet.
   SendQueuedFrames(/*flush=*/true, /*is_fec_timeout=*/true);
 }
 
 QuicTime::Delta QuicPacketGenerator::GetFecTimeout(
     QuicPacketNumber packet_number) {
   return packet_creator_.GetFecTimeout(packet_number);
@@ skipping 148 matching lines @@
 
 FecSendPolicy QuicPacketGenerator::fec_send_policy() {
   return packet_creator_.fec_send_policy();
 }
 
 void QuicPacketGenerator::set_fec_send_policy(FecSendPolicy fec_send_policy) {
   packet_creator_.set_fec_send_policy(fec_send_policy);
 }
 
 }  // namespace net