relnote: Moving many QUIC DFATALS over to QUIC_BUG

net/quic/quic_packet_creator.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_creator.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "net/quic/crypto/quic_random.h"
+#include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::max;
 using std::min;
 using std::pair;
@@ skipping 146 matching lines @@
   }
   fec_group_.reset(nullptr);
 }
 
 bool QuicPacketCreator::IsFecGroupOpen() const {
   return fec_group_.get() != nullptr;
 }
 
 void QuicPacketCreator::StartFecProtectingPackets() {
   if (max_packets_per_fec_group_ == 0) {
-    LOG(DFATAL) << "Cannot start FEC protection when FEC is not enabled.";
+    QUIC_BUG << "Cannot start FEC protection when FEC is not enabled.";
     return;
   }
   // TODO(jri): This currently requires that the generator flush out any
   // pending frames when FEC protection is turned on. If current packet can be
   // converted to an FEC protected packet, do it. This will require the
   // generator to check if the resulting expansion still allows the incoming
   // frame to be added to the packet.
   if (HasPendingFrames()) {
-    LOG(DFATAL) << "Cannot start FEC protection with pending frames.";
+    QUIC_BUG << "Cannot start FEC protection with pending frames.";
     return;
   }
   DCHECK(!fec_protect_);
   fec_protect_ = true;
 }
 
 void QuicPacketCreator::StopFecProtectingPackets() {
   if (fec_group_.get() != nullptr) {
-    LOG(DFATAL) << "Cannot stop FEC protection with open FEC group.";
+    QUIC_BUG << "Cannot stop FEC protection with open FEC group.";
     return;
   }
   DCHECK(fec_protect_);
   fec_protect_ = false;
 }
 
 InFecGroup QuicPacketCreator::MaybeUpdateLengthsAndStartFec() {
   if (fec_group_.get() != nullptr) {
     // Don't update any lengths when an FEC group is open, to ensure same
     // packet header size in all packets within a group.
@@ skipping 251 matching lines @@
   // TODO(rtenneti): Change the default 64 alignas value (used the default
   // value from CACHELINE_SIZE).
   ALIGNAS(64) char seralized_packet_buffer[kMaxPacketSize];
   SerializedPacket serialized_packet =
       SerializePacket(seralized_packet_buffer, kMaxPacketSize);
   OnSerializedPacket(&serialized_packet);
 }
 
 void QuicPacketCreator::OnSerializedPacket(SerializedPacket* packet) {
   if (packet->packet == nullptr) {
-    LOG(DFATAL) << "Failed to SerializePacket. fec_policy:" << fec_send_policy()
-                << " should_fec_protect_:" << should_fec_protect_next_packet_;
+
+    QUIC_BUG << "Failed to SerializePacket. fec_policy:" << fec_send_policy()
+             << " should_fec_protect_:" << should_fec_protect_next_packet_;
     delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
     return;
   }
   // There may be AckListeners interested in this packet.
   packet->listeners.swap(ack_listeners_);
   DCHECK(ack_listeners_.empty());
   delegate_->OnSerializedPacket(packet);
   has_ack_ = false;
   has_stop_waiting_ = false;
   MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/false,
@@ skipping 87 matching lines @@
   bool possibly_truncated_by_length = packet_size_ == max_plaintext_size_ &&
                                       queued_frames_.size() == 1 &&
                                       queued_frames_.back().type == ACK_FRAME;
   // Use the packet_size_ instead of the buffer size to ensure smaller
   // packet sizes are properly used.
   size_t encrypted_length = 0u;
   if (FLAGS_quic_inplace_encryption) {
     size_t length = framer_->BuildDataPacket(header, queued_frames_,
                                              encrypted_buffer, packet_size_);
     if (length == 0) {
-      LOG(DFATAL) << "Failed to serialize " << queued_frames_.size()
-                  << " frames.";
+      QUIC_BUG << "Failed to serialize " << queued_frames_.size() << " frames.";
       return NoPacket();
     }
 
     // TODO(ianswett) Consider replacing QuicPacket with something else, since
     // it's only used to provide convenience methods to FEC and encryption.
     QuicPacket packet(encrypted_buffer, length,
                       /* owns_buffer */ false,
                       header.public_header.connection_id_length,
                       header.public_header.version_flag,
                       header.public_header.packet_number_length);
@@ skipping 11 matching lines @@
                                 encrypted_buffer, encrypted_buffer_len);
   } else {
     // The optimized encryption algorithm implementations run faster when
     // operating on aligned memory.
     // TODO(rtenneti): Change the default 64 alignas value (used the default
     // value from CACHELINE_SIZE).
     ALIGNAS(64) char buffer[kMaxPacketSize];
     size_t length =
         framer_->BuildDataPacket(header, queued_frames_, buffer, packet_size_);
     if (length == 0) {
-      LOG(DFATAL) << "Failed to serialize " << queued_frames_.size()
-                  << " frames.";
+      QUIC_BUG << "Failed to serialize " << queued_frames_.size() << " frames.";
       return NoPacket();
     }
 
     // TODO(ianswett) Consider replacing QuicPacket with something else, since
     // it's only used to provide convenience methods to FEC and encryption.
     QuicPacket packet(buffer, length,
                       /* owns_buffer */ false,
                       header.public_header.connection_id_length,
                       header.public_header.version_flag,
                       header.public_header.packet_number_length);
     OnBuiltFecProtectedPayload(header, packet.FecProtectedData());
 
     // Because of possible truncation, we can't be confident that our
     // packet size calculation worked correctly.
     if (!possibly_truncated_by_length) {
       DCHECK_EQ(packet_size_, length);
     }
     // Immediately encrypt the packet, to ensure we don't encrypt the same
     // packet number multiple times.
     encrypted_length =
         framer_->EncryptPayload(encryption_level_, packet_number_, packet,
                                 encrypted_buffer, encrypted_buffer_len);
   }
   if (encrypted_length == 0) {
-    LOG(DFATAL) << "Failed to encrypt packet number " << packet_number_;
+    QUIC_BUG << "Failed to encrypt packet number " << packet_number_;
     return NoPacket();
   }
 
   // Update |needs_padding_| flag of |queued_retransmittable_frames_| here, and
   // not in AddFrame, because when the first padded frame is added to the queue,
   // it might not be retransmittable, and hence the flag would end up being not
   // set.
   if (queued_retransmittable_frames_.get() != nullptr) {
     queued_retransmittable_frames_->set_needs_padding(needs_padding_);
   }
 
   packet_size_ = 0;
   queued_frames_.clear();
   needs_padding_ = false;
   return SerializedPacket(current_path_, header.packet_number,
                           header.public_header.packet_number_length,
                           encrypted_buffer, encrypted_length,
                           /* owns_buffer*/ false,
                           QuicFramer::GetPacketEntropyHash(header),
                           queued_retransmittable_frames_.release(), has_ack_,
                           has_stop_waiting_, encryption_level_);
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec(char* buffer,
                                                  size_t buffer_len) {
   DCHECK_LT(0u, buffer_len);
   if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
-    LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
+    QUIC_BUG << "SerializeFEC called but no group or zero packets in group.";
     // TODO(jri): Make this a public method of framer?
     return NoPacket();
   }
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_->FecGroupNumber(), true, &header);
   scoped_ptr<QuicPacket> packet(
       framer_->BuildFecPacket(header, fec_group_->PayloadParity()));
   fec_group_.reset(nullptr);
   packet_size_ = 0;
   LOG_IF(DFATAL, packet == nullptr)
       << "Failed to serialize fec packet for group:"
       << fec_group_->FecGroupNumber();
   DCHECK_GE(max_packet_length_, packet->length());
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // packet number multiple times.
   size_t encrypted_length = framer_->EncryptPayload(
       encryption_level_, packet_number_, *packet, buffer, buffer_len);
   if (encrypted_length == 0) {
-    LOG(DFATAL) << "Failed to encrypt packet number " << packet_number_;
+    QUIC_BUG << "Failed to encrypt packet number " << packet_number_;
     return NoPacket();
   }
   SerializedPacket serialized(current_path_, header.packet_number,
                               header.public_header.packet_number_length, buffer,
                               encrypted_length, /* owns_buffer */ false,
                               QuicFramer::GetPacketEntropyHash(header), nullptr,
                               false, false, encryption_level_);
   serialized.is_fec_packet = true;
   return serialized;
 }
@@ skipping 39 matching lines @@
       return true;
   }
 }
 
 bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
                                  bool save_retransmittable_frames) {
   DVLOG(1) << "Adding frame: " << frame;
   if (FLAGS_quic_never_write_unencrypted_data && frame.type == STREAM_FRAME &&
       frame.stream_frame->stream_id != kCryptoStreamId &&
       encryption_level_ == ENCRYPTION_NONE) {
-    LOG(DFATAL) << "Cannot send stream data without encryption.";
+    QUIC_BUG << "Cannot send stream data without encryption.";
     delegate_->CloseConnection(QUIC_UNENCRYPTED_STREAM_DATA, false);
     return false;
   }
   InFecGroup is_in_fec_group = MaybeUpdateLengthsAndStartFec();
 
   size_t frame_len = framer_->GetSerializedFrameLength(
       frame, BytesFree(), queued_frames_.empty(), true, is_in_fec_group,
       packet_number_length_);
   if (frame_len == 0) {
     // Current open packet is full.
@@ skipping 98 matching lines @@
 
 void QuicPacketCreator::SetCurrentPath(
     QuicPathId path_id,
     QuicPacketNumber least_packet_awaited_by_peer,
     QuicPacketCount max_packets_in_flight) {
   if (current_path_ == path_id) {
     return;
   }
 
   if (HasPendingFrames()) {
-    LOG(DFATAL)
-        << "Unable to change paths when a packet is under construction.";
+    QUIC_BUG << "Unable to change paths when a packet is under construction.";
     return;
   }
 
   // Send FEC packet and close FEC group.
   MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
                                   /*is_fec_timeout=*/false);
   // Save current packet number and load switching path's packet number.
   multipath_packet_number_[current_path_] = packet_number_;
   hash_map<QuicPathId, QuicPacketNumber>::iterator it =
       multipath_packet_number_.find(path_id);
   // If path_id is not in the map, it's a new path. Set packet_number to 0.
   packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
   current_path_ = path_id;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net