Add DFATALs to QuicFramer branches where packet creation fails.

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 "base/containers/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
@@ skipping 293 matching lines @@
 }
 
 SerializedPacket QuicFramer::BuildDataPacket(
     const QuicPacketHeader& header,
     const QuicFrames& frames,
     size_t packet_size) {
   QuicDataWriter writer(packet_size);
   const SerializedPacket kNoPacket(
       0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
   if (!AppendPacketHeader(header, &writer)) {
+    LOG(DFATAL) << "AppendPacketHeader failed";
     return kNoPacket;
   }
 
   for (size_t i = 0; i < frames.size(); ++i) {
     const QuicFrame& frame = frames[i];
 
     const bool last_frame_in_packet = i == (frames.size() - 1);
     if (!AppendTypeByte(frame, last_frame_in_packet, &writer)) {
+      LOG(DFATAL) << "AppendTypeByte failed";
       return kNoPacket;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         writer.WritePadding();
         break;
       case STREAM_FRAME:
         if (!AppendStreamFramePayload(
             *frame.stream_frame, last_frame_in_packet, &writer)) {
+          LOG(DFATAL) << "AppendStreamFramePayload failed";
           return kNoPacket;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFramePayloadAndTypeByte(
                 header, *frame.ack_frame, &writer)) {
+          LOG(DFATAL) << "AppendAckFramePayloadAndTypeByte failed";
           return kNoPacket;
         }
         break;
       case CONGESTION_FEEDBACK_FRAME:
         if (!AppendQuicCongestionFeedbackFramePayload(
                 *frame.congestion_feedback_frame, &writer)) {
+          LOG(DFATAL) << "AppendQuicCongestionFeedbackFramePayload failed";
           return kNoPacket;
         }
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFramePayload(*frame.rst_stream_frame, &writer)) {
+          LOG(DFATAL) << "AppendRstStreamFramePayload failed";
           return kNoPacket;
         }
         break;
       case CONNECTION_CLOSE_FRAME:
         if (!AppendConnectionCloseFramePayload(
                 *frame.connection_close_frame, &writer)) {
+          LOG(DFATAL) << "AppendConnectionCloseFramePayload failed";
           return kNoPacket;
         }
         break;
       case GOAWAY_FRAME:
         if (!AppendGoAwayFramePayload(*frame.goaway_frame, &writer)) {
+          LOG(DFATAL) << "AppendGoAwayFramePayload failed";
           return kNoPacket;
         }
         break;
       default:
         RaiseError(QUIC_INVALID_FRAME_DATA);
+        LOG(DFATAL) << "QUIC_INVALID_FRAME_DATA";
         return kNoPacket;
     }
   }
 
   // Save the length before writing, because take clears it.
   const size_t len = writer.length();
   // Less than or equal because truncated acks end up with max_plaintex_size
   // length, even though they're typically slightly shorter.
   DCHECK_LE(len, packet_size);
   QuicPacket* packet = QuicPacket::NewDataPacket(
@@ skipping 15 matching lines @@
                                             const QuicFecData& fec) {
   DCHECK_EQ(IN_FEC_GROUP, header.is_in_fec_group);
   DCHECK_NE(0u, header.fec_group);
   size_t len = GetPacketHeaderSize(header);
   len += fec.redundancy.length();
 
   QuicDataWriter writer(len);
   const SerializedPacket kNoPacket(
       0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
   if (!AppendPacketHeader(header, &writer)) {
+    LOG(DFATAL) << "AppendPacketHeader failed";
     return kNoPacket;
   }
 
   if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) {
+    LOG(DFATAL) << "Failed to add FEC";
     return kNoPacket;
   }
 
   return SerializedPacket(
       header.packet_sequence_number,
       header.public_header.sequence_number_length,
       QuicPacket::NewFecPacket(writer.take(), len, true,
                                header.public_header.guid_length,
                                header.public_header.version_flag,
                                header.public_header.sequence_number_length),
@@ skipping 1626 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net