QUIC - debugging code to find crash in net::QuicPacket::FecProtectedData.

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/basictypes.h"
 #include "base/logging.h"
@@ skipping 314 matching lines @@
     const QuicPacketHeader& header) {
   return header.entropy_flag << (header.packet_sequence_number % 8);
 }
 
 QuicPacket* 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";
+    // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+    CHECK(false) << "AppendPacketHeader failed";
     return nullptr;
   }
 
   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";
+      // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+      CHECK(false) << "AppendTypeByte failed";
       return nullptr;
     }
 
     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";
+          // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+          CHECK(false) << "AppendStreamFrame failed";
           return nullptr;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFrameAndTypeByte(
                 header, *frame.ack_frame, &writer)) {
-          LOG(DFATAL) << "AppendAckFrameAndTypeByte failed";
+          // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+          CHECK(false) << "AppendAckFrameAndTypeByte failed";
           return nullptr;
         }
         break;
       case STOP_WAITING_FRAME:
         if (!AppendStopWaitingFrame(
                 header, *frame.stop_waiting_frame, &writer)) {
-          LOG(DFATAL) << "AppendStopWaitingFrame failed";
+          // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+          CHECK(false) << "AppendStopWaitingFrame failed";
           return nullptr;
         }
         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";
+          // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+          CHECK(false) << "AppendRstStreamFrame failed";
           return nullptr;
         }
         break;
       case CONNECTION_CLOSE_FRAME:
         if (!AppendConnectionCloseFrame(
                 *frame.connection_close_frame, &writer)) {
-          LOG(DFATAL) << "AppendConnectionCloseFrame failed";
+          // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+          CHECK(false) << "AppendConnectionCloseFrame failed";
           return nullptr;
         }
         break;
       case GOAWAY_FRAME:
         if (!AppendGoAwayFrame(*frame.goaway_frame, &writer)) {
-          LOG(DFATAL) << "AppendGoAwayFrame failed";
+          // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+          CHECK(false) << "AppendGoAwayFrame failed";
           return nullptr;
         }
         break;
       case WINDOW_UPDATE_FRAME:
         if (!AppendWindowUpdateFrame(*frame.window_update_frame, &writer)) {
-          LOG(DFATAL) << "AppendWindowUpdateFrame failed";
+          // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+          CHECK(false) << "AppendWindowUpdateFrame failed";
           return nullptr;
         }
         break;
       case BLOCKED_FRAME:
         if (!AppendBlockedFrame(*frame.blocked_frame, &writer)) {
-          LOG(DFATAL) << "AppendBlockedFrame failed";
+          // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+          CHECK(false) << "AppendBlockedFrame failed";
           return nullptr;
         }
         break;
       default:
         RaiseError(QUIC_INVALID_FRAME_DATA);
-        LOG(DFATAL) << "QUIC_INVALID_FRAME_DATA";
+        // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
+        CHECK(false) << "QUIC_INVALID_FRAME_DATA";
         return nullptr;
     }
     ++i;
   }
 
   QuicPacket* packet =
       new QuicPacket(writer.data(), writer.length(), false,
                      header.public_header.connection_id_length,
                      header.public_header.version_flag,
                      header.public_header.sequence_number_length);
@@ skipping 1804 matching lines @@
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(nullptr);
   return false;
 }
 
 }  // namespace net