relnote: Moving many QUIC DFATALS over to QUIC_BUG

net/quic/quic_framer.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_framer.h"
 
 #include <stdint.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
+#include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_socket_address_coder.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::map;
 using std::max;
 using std::min;
@@ skipping 89 matching lines @@
   switch (flags & PACKET_FLAGS_6BYTE_PACKET) {
     case PACKET_FLAGS_6BYTE_PACKET:
       return PACKET_6BYTE_PACKET_NUMBER;
     case PACKET_FLAGS_4BYTE_PACKET:
       return PACKET_4BYTE_PACKET_NUMBER;
     case PACKET_FLAGS_2BYTE_PACKET:
       return PACKET_2BYTE_PACKET_NUMBER;
     case PACKET_FLAGS_1BYTE_PACKET:
       return PACKET_1BYTE_PACKET_NUMBER;
     default:
-      LOG(DFATAL) << "Unreachable case statement.";
+      QUIC_BUG << "Unreachable case statement.";
       return PACKET_6BYTE_PACKET_NUMBER;
   }
 }
 
 }  // namespace
 
 QuicFramer::QuicFramer(const QuicVersionVector& supported_versions,
                        QuicTime creation_time,
                        Perspective perspective)
     : visitor_(nullptr),
@@ skipping 78 matching lines @@
 
 // static
 size_t QuicFramer::GetStreamIdSize(QuicStreamId stream_id) {
   // Sizes are 1 through 4 bytes.
   for (int i = 1; i <= 4; ++i) {
     stream_id >>= 8;
     if (stream_id == 0) {
       return i;
     }
   }
-  LOG(DFATAL) << "Failed to determine StreamIDSize.";
+  QUIC_BUG << "Failed to determine StreamIDSize.";
   return 4;
 }
 
 // static
 size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset) {
   // 0 is a special case.
   if (offset == 0) {
     return 0;
   }
   // 2 through 8 are the remaining sizes.
   offset >>= 8;
   for (int i = 2; i <= 8; ++i) {
     offset >>= 8;
     if (offset == 0) {
       return i;
     }
   }
-  LOG(DFATAL) << "Failed to determine StreamOffsetSize.";
+  QUIC_BUG << "Failed to determine StreamOffsetSize.";
   return 8;
 }
 
 // static
 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
   return kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID +
          number_versions * kQuicVersionSize;
 }
 
 bool QuicFramer::IsSupportedVersion(const QuicVersion version) const {
   for (size_t i = 0; i < supported_versions_.size(); ++i) {
     if (version == supported_versions_[i]) {
       return true;
     }
   }
   return false;
 }
 
 size_t QuicFramer::GetSerializedFrameLength(
     const QuicFrame& frame,
     size_t free_bytes,
     bool first_frame,
     bool last_frame,
     InFecGroup is_in_fec_group,
     QuicPacketNumberLength packet_number_length) {
   // Prevent a rare crash reported in b/19458523.
   if ((frame.type == STREAM_FRAME || frame.type == ACK_FRAME) &&
       frame.stream_frame == nullptr) {
-    LOG(DFATAL) << "Cannot compute the length of a null frame. "
-                << "type:" << frame.type << "free_bytes:" << free_bytes
-                << " first_frame:" << first_frame
-                << " last_frame:" << last_frame
-                << " is_in_fec:" << is_in_fec_group
-                << " seq num length:" << packet_number_length;
+    QUIC_BUG << "Cannot compute the length of a null frame. "
+             << "type:" << frame.type << "free_bytes:" << free_bytes
+             << " first_frame:" << first_frame << " last_frame:" << last_frame
+             << " is_in_fec:" << is_in_fec_group
+             << " seq num length:" << packet_number_length;
     set_error(QUIC_INTERNAL_ERROR);
     visitor_->OnError(this);
     return 0;
   }
   if (frame.type == PADDING_FRAME) {
     // PADDING implies end of packet.
     return free_bytes;
   }
   size_t frame_len = ComputeFrameLength(frame, last_frame, is_in_fec_group,
                                         packet_number_length);
@@ skipping 27 matching lines @@
     const QuicPacketHeader& header) {
   return header.entropy_flag << (header.packet_number % 8);
 }
 
 size_t QuicFramer::BuildDataPacket(const QuicPacketHeader& header,
                                    const QuicFrames& frames,
                                    char* buffer,
                                    size_t packet_length) {
   QuicDataWriter writer(packet_length, buffer);
   if (!AppendPacketHeader(header, &writer)) {
-    LOG(DFATAL) << "AppendPacketHeader failed";
+    QUIC_BUG << "AppendPacketHeader failed";
     return 0;
   }
 
   size_t i = 0;
   for (const QuicFrame& frame : frames) {
     // Determine if we should write stream frame length in header.
     const bool no_stream_frame_length =
         (header.is_in_fec_group == NOT_IN_FEC_GROUP) &&
         (i == frames.size() - 1);
     if (!AppendTypeByte(frame, no_stream_frame_length, &writer)) {
-      LOG(DFATAL) << "AppendTypeByte failed";
+      QUIC_BUG << "AppendTypeByte failed";
       return 0;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         writer.WritePadding();
         break;
       case STREAM_FRAME:
         if (!AppendStreamFrame(*frame.stream_frame, no_stream_frame_length,
                                &writer)) {
-          LOG(DFATAL) << "AppendStreamFrame failed";
+          QUIC_BUG << "AppendStreamFrame failed";
           return 0;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFrameAndTypeByte(header, *frame.ack_frame, &writer)) {
-          LOG(DFATAL) << "AppendAckFrameAndTypeByte failed";
+          QUIC_BUG << "AppendAckFrameAndTypeByte failed";
           return 0;
         }
         break;
       case STOP_WAITING_FRAME:
         if (!AppendStopWaitingFrame(header, *frame.stop_waiting_frame,
                                     &writer)) {
-          LOG(DFATAL) << "AppendStopWaitingFrame failed";
+          QUIC_BUG << "AppendStopWaitingFrame failed";
           return 0;
         }
         break;
       case MTU_DISCOVERY_FRAME:
       // MTU discovery frames are serialized as ping frames.
       case PING_FRAME:
         // Ping has no payload.
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) {
-          LOG(DFATAL) << "AppendRstStreamFrame failed";
+          QUIC_BUG << "AppendRstStreamFrame failed";
           return 0;
         }
         break;
       case CONNECTION_CLOSE_FRAME:
         if (!AppendConnectionCloseFrame(*frame.connection_close_frame,
                                         &writer)) {
-          LOG(DFATAL) << "AppendConnectionCloseFrame failed";
+          QUIC_BUG << "AppendConnectionCloseFrame failed";
           return 0;
         }
         break;
       case GOAWAY_FRAME:
         if (!AppendGoAwayFrame(*frame.goaway_frame, &writer)) {
-          LOG(DFATAL) << "AppendGoAwayFrame failed";
+          QUIC_BUG << "AppendGoAwayFrame failed";
           return 0;
         }
         break;
       case WINDOW_UPDATE_FRAME:
         if (!AppendWindowUpdateFrame(*frame.window_update_frame, &writer)) {
-          LOG(DFATAL) << "AppendWindowUpdateFrame failed";
+          QUIC_BUG << "AppendWindowUpdateFrame failed";
           return 0;
         }
         break;
       case BLOCKED_FRAME:
         if (!AppendBlockedFrame(*frame.blocked_frame, &writer)) {
-          LOG(DFATAL) << "AppendBlockedFrame failed";
+          QUIC_BUG << "AppendBlockedFrame failed";
           return 0;
         }
         break;
       default:
         RaiseError(QUIC_INVALID_FRAME_DATA);
-        LOG(DFATAL) << "QUIC_INVALID_FRAME_DATA";
+        QUIC_BUG << "QUIC_INVALID_FRAME_DATA";
         return 0;
     }
     ++i;
   }
 
   return writer.length();
 }
 
 QuicPacket* QuicFramer::BuildFecPacket(const QuicPacketHeader& header,
                                        StringPiece redundancy) {
   DCHECK_EQ(IN_FEC_GROUP, header.is_in_fec_group);
   DCHECK_NE(0u, header.fec_group);
   size_t len = GetPacketHeaderSize(header);
   len += redundancy.length();
 
   scoped_ptr<char[]> buffer(new char[len]);
   QuicDataWriter writer(len, buffer.get());
   if (!AppendPacketHeader(header, &writer)) {
-    LOG(DFATAL) << "AppendPacketHeader failed";
+    QUIC_BUG << "AppendPacketHeader failed";
     return nullptr;
   }
 
   if (!writer.WriteBytes(redundancy.data(), redundancy.length())) {
-    LOG(DFATAL) << "Failed to add FEC";
+    QUIC_BUG << "Failed to add FEC";
     return nullptr;
   }
 
   return new QuicPacket(buffer.release(), len, true,
                         header.public_header.connection_id_length,
                         header.public_header.version_flag,
                         header.public_header.packet_number_length);
 }
 
 // static
@@ skipping 556 matching lines @@
   switch (packet_number_length) {
     case PACKET_1BYTE_PACKET_NUMBER:
       return PACKET_FLAGS_1BYTE_PACKET;
     case PACKET_2BYTE_PACKET_NUMBER:
       return PACKET_FLAGS_2BYTE_PACKET;
     case PACKET_4BYTE_PACKET_NUMBER:
       return PACKET_FLAGS_4BYTE_PACKET;
     case PACKET_6BYTE_PACKET_NUMBER:
       return PACKET_FLAGS_6BYTE_PACKET;
     default:
-      LOG(DFATAL) << "Unreachable case statement.";
+      QUIC_BUG << "Unreachable case statement.";
       return PACKET_FLAGS_6BYTE_PACKET;
   }
 }
 
 // static
 QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo(
     const QuicAckFrame& frame) {
   AckFrameInfo ack_info;
   if (frame.missing_packets.Empty()) {
     return ack_info;
@@ skipping 838 matching lines @@
   return 0;
 }
 
 bool QuicFramer::AppendTypeByte(const QuicFrame& frame,
                                 bool no_stream_frame_length,
                                 QuicDataWriter* writer) {
   uint8_t type_byte = 0;
   switch (frame.type) {
     case STREAM_FRAME: {
       if (frame.stream_frame == nullptr) {
-        LOG(DFATAL) << "Failed to append STREAM frame with no stream_frame.";
+        QUIC_BUG << "Failed to append STREAM frame with no stream_frame.";
       }
       // Fin bit.
       type_byte |= frame.stream_frame->fin ? kQuicStreamFinMask : 0;
 
       // Data Length bit.
       type_byte <<= kQuicStreamDataLengthShift;
       type_byte |= no_stream_frame_length ? 0 : kQuicStreamDataLengthMask;
 
       // Offset 3 bits.
       type_byte <<= kQuicStreamOffsetShift;
@@ skipping 47 matching lines @@
     default:
       DCHECK(false) << "packet_number_length: " << packet_number_length;
       return false;
   }
 }
 
 bool QuicFramer::AppendStreamFrame(const QuicStreamFrame& frame,
                                    bool no_stream_frame_length,
                                    QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) {
-    LOG(DFATAL) << "Writing stream id size failed.";
+    QUIC_BUG << "Writing stream id size failed.";
     return false;
   }
   if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) {
-    LOG(DFATAL) << "Writing offset size failed.";
+    QUIC_BUG << "Writing offset size failed.";
     return false;
   }
   if (!no_stream_frame_length) {
     if ((frame.frame_length > numeric_limits<uint16_t>::max()) ||
         !writer->WriteUInt16(static_cast<uint16_t>(frame.frame_length))) {
-      LOG(DFATAL) << "Writing stream frame length failed";
+      QUIC_BUG << "Writing stream frame length failed";
       return false;
     }
   }
 
   if (!writer->WriteBytes(frame.frame_buffer, frame.frame_length)) {
-    LOG(DFATAL) << "Writing frame data failed.";
+    QUIC_BUG << "Writing frame data failed.";
     return false;
   }
   return true;
 }
 
 void QuicFramer::set_version(const QuicVersion version) {
   DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version);
   quic_version_ = version;
 }
 
@@ skipping 206 matching lines @@
 
 bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
                                         const QuicStopWaitingFrame& frame,
                                         QuicDataWriter* writer) {
   DCHECK_GE(header.packet_number, frame.least_unacked);
   const QuicPacketNumber least_unacked_delta =
       header.packet_number - frame.least_unacked;
   const QuicPacketNumber length_shift =
       header.public_header.packet_number_length * 8;
   if (!writer->WriteUInt8(frame.entropy_hash)) {
-    LOG(DFATAL) << " hash failed";
+    QUIC_BUG << " hash failed";
     return false;
   }
 
   if (least_unacked_delta >> length_shift > 0) {
-    LOG(DFATAL) << "packet_number_length "
-                << header.public_header.packet_number_length
-                << " is too small for least_unacked_delta: "
-                << least_unacked_delta;
+    QUIC_BUG << "packet_number_length "
+             << header.public_header.packet_number_length
+             << " is too small for least_unacked_delta: "
+             << least_unacked_delta;
     return false;
   }
   if (!AppendPacketSequenceNumber(header.public_header.packet_number_length,
                                   least_unacked_delta, writer)) {
-    LOG(DFATAL) << " seq failed: " << header.public_header.packet_number_length;
+    QUIC_BUG << " seq failed: " << header.public_header.packet_number_length;
     return false;
   }
 
   return true;
 }
 
 bool QuicFramer::AppendRstStreamFrame(const QuicRstStreamFrame& frame,
                                       QuicDataWriter* writer) {
   if (!writer->WriteUInt32(frame.stream_id)) {
     return false;
@@ skipping 63 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net