Add extra log when AppendAckFrameAndTypeByte failed. n/a logging only change.

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 <cstdint>
 #include <memory>
 #include <vector>
 
@@ skipping 364 matching lines @@
       case STREAM_FRAME:
         if (!AppendStreamFrame(*frame.stream_frame, no_stream_frame_length,
                                &writer)) {
           QUIC_BUG << "AppendStreamFrame failed";
           return 0;
         }
         break;
       case ACK_FRAME:
         if (quic_version_ <= QUIC_VERSION_33) {
           if (!AppendAckFrameAndTypeByte(header, *frame.ack_frame, &writer)) {
-            QUIC_BUG << "AppendAckFrameAndTypeByte failed";
+            QUIC_BUG << "AppendAckFrameAndTypeByte failed"
+                     << " header: " << header
+                     << " ack_fame: " << *frame.ack_frame;
             return 0;
           }
         } else {
           if (!AppendNewAckFrameAndTypeByte(*frame.ack_frame, &writer)) {
             QUIC_BUG << "AppendNewAckFrameAndTypeByte failed";
             return 0;
           }
         }
         break;
       case STOP_WAITING_FRAME:
@@ skipping 1785 matching lines @@
   type_byte <<= kQuicSequenceNumberLengthShift;
   type_byte |= GetSequenceNumberFlags(largest_observed_length);
 
   // Missing packet number length.
   type_byte <<= kQuicSequenceNumberLengthShift;
   type_byte |= GetSequenceNumberFlags(missing_packet_number_length);
 
   type_byte |= kQuicFrameTypeAckMask;
 
   if (!writer->WriteUInt8(type_byte)) {
+    QUIC_BUG << "type byte failed";
     return false;
   }
 
   QuicPacketEntropyHash ack_entropy_hash = frame.entropy_hash;
   NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin();
   if (truncated) {
     // Skip the nack ranges which the truncated ack won't include and set
     // a correct largest observed for the truncated ack.
     for (size_t i = 1; i < (ack_info.nack_ranges.size() - max_num_ranges);
          ++i) {
       ++ack_iter;
     }
     // If the last range is followed by acks, include them.
     // If the last range is followed by another range, specify the end of the
     // range as the largest_observed.
     ack_largest_observed = ack_iter->first - 1;
     // Also update the entropy so it matches the largest observed.
     ack_entropy_hash = entropy_calculator_->EntropyHash(ack_largest_observed);
     ++ack_iter;
   }
 
   if (!writer->WriteUInt8(ack_entropy_hash)) {
+    QUIC_BUG << "hash failed.";
     return false;
   }
 
   if (!AppendPacketSequenceNumber(largest_observed_length, ack_largest_observed,
                                   writer)) {
+    QUIC_BUG << "AppendPacketSequenceNumber failed. "
+             << "largest_observed_length: " << largest_observed_length
+             << " ack_largest_observed: " << ack_largest_observed;
     return false;
   }
 
   uint64_t ack_delay_time_us = kUFloat16MaxValue;
   if (!frame.ack_delay_time.IsInfinite()) {
     DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
     ack_delay_time_us = frame.ack_delay_time.ToMicroseconds();
   }
 
   if (!writer->WriteUFloat16(ack_delay_time_us)) {
+    QUIC_BUG << "ack delay time failed.";
     return false;
   }
 
   // Timestamp goes at the end of the required fields.
   if (!truncated) {
     if (!AppendTimestampToAckFrame(frame, writer)) {
+      QUIC_BUG << "AppendTimestampToAckFrame failed";
       return false;
     }
   }
 
   if (ack_info.nack_ranges.empty()) {
     return true;
   }
 
   const uint8_t num_missing_ranges =
       static_cast<uint8_t>(min(ack_info.nack_ranges.size(), max_num_ranges));
   if (!writer->WriteBytes(&num_missing_ranges, 1)) {
+    QUIC_BUG << "num_missing_ranges failed: "
+             << static_cast<uint32_t>(num_missing_ranges);
     return false;
   }
 
   int num_ranges_written = 0;
   QuicPacketNumber last_sequence_written = ack_largest_observed;
   for (; ack_iter != ack_info.nack_ranges.rend(); ++ack_iter) {
     // Calculate the delta to the last number in the range.
     QuicPacketNumber missing_delta =
         last_sequence_written - (ack_iter->first + ack_iter->second);
     if (!AppendPacketSequenceNumber(missing_packet_number_length, missing_delta,
                                     writer)) {
+      QUIC_BUG << "AppendPacketSequenceNumber failed: "
+               << "missing_packet_number_length: "
+               << missing_packet_number_length << " missing_delta "
+               << missing_delta;
       return false;
     }
     if (!AppendPacketSequenceNumber(PACKET_1BYTE_PACKET_NUMBER,
                                     ack_iter->second, writer)) {
+      QUIC_BUG << "AppendPacketSequenceNumber failed";
       return false;
     }
     // Subtract 1 so a missing_delta of 0 means an adjacent range.
     last_sequence_written = ack_iter->first - 1;
     ++num_ranges_written;
   }
   DCHECK_EQ(num_missing_ranges, num_ranges_written);
 
   if (quic_version_ > QUIC_VERSION_31) {
     return true;
   }
 
   // Append revived packets.
   // FEC is not supported.
   uint8_t num_revived_packets = 0;
   if (!writer->WriteBytes(&num_revived_packets, 1)) {
+    QUIC_BUG << "num_revived_packets failed: " << num_revived_packets;
     return false;
   }
 
   return true;
 }
 
 bool QuicFramer::AppendNewAckFrameAndTypeByte(const QuicAckFrame& frame,
                                               QuicDataWriter* writer) {
   NewAckFrameInfo new_ack_info = GetNewAckFrameInfo(frame);
   QuicPacketNumber largest_acked = frame.largest_observed;
@@ skipping 280 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