Fixed a bug in QuicPacketCreator when FEC was used for unsupported

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 "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
@@ skipping 71 matching lines @@
   }
 }
 
 bool QuicPacketCreator::ShouldSendFec(bool force_close) const {
   return fec_group_.get() != NULL && fec_group_->NumReceivedPackets() > 0 &&
       (force_close ||
        fec_group_->NumReceivedPackets() >= options_.max_packets_per_fec_group);
 }
 
 InFecGroup QuicPacketCreator::MaybeStartFEC() {
-  // Don't send FEC until QUIC_VERSION_15.
-  if (framer_->version() != QUIC_VERSION_13 &&
-      options_.max_packets_per_fec_group > 0 && fec_group_.get() == NULL) {
+  if (IsFecEnabled() && fec_group_.get() == NULL) {
     DCHECK(queued_frames_.empty());
     // Set the fec group number to the sequence number of the next packet.
     fec_group_number_ = sequence_number() + 1;
     fec_group_.reset(new QuicFecGroup());
   }
   return fec_group_.get() == NULL ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
 }
 
 // Stops serializing version of the protocol in packets sent after this call.
 // A packet that is already open might send kQuicVersionSize bytes less than the
@@ skipping 21 matching lines @@
   const uint64 delta = max(current_delta, congestion_window_packets);
   options_.send_sequence_number_length =
       QuicFramer::GetMinSequenceNumberLength(delta * 4);
 }
 
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
                                               QuicStreamOffset offset) const {
   // TODO(jri): This is a simple safe decision for now, but make
   // is_in_fec_group a parameter. Same as with all public methods in
   // QuicPacketCreator.
-  InFecGroup is_in_fec_group = options_.max_packets_per_fec_group == 0 ?
-                               NOT_IN_FEC_GROUP : IN_FEC_GROUP;
   return BytesFree() >
       QuicFramer::GetMinStreamFrameSize(framer_->version(), id, offset, true,
-                                        is_in_fec_group);
+                                        IsFecEnabled());
 }
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
     QuicVersion version,
     QuicConnectionIdLength connection_id_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length,
     InFecGroup is_in_fec_group) {
   return GetPacketHeaderSize(connection_id_length, include_version,
@@ skipping 119 matching lines @@
 }
 
 size_t QuicPacketCreator::BytesFree() const {
   const size_t max_plaintext_size =
       framer_->GetMaxPlaintextSize(options_.max_packet_length);
   DCHECK_GE(max_plaintext_size, PacketSize());
   return max_plaintext_size - min(max_plaintext_size, PacketSize()
                                   + ExpansionOnNewFrame());
 }
 
+InFecGroup QuicPacketCreator::IsFecEnabled() const {
+  return (framer_->version() == QUIC_VERSION_13 ||
+          options_.max_packets_per_fec_group == 0) ?
+          NOT_IN_FEC_GROUP : IN_FEC_GROUP;
+}
+
 size_t QuicPacketCreator::PacketSize() const {
   if (queued_frames_.empty()) {
     // Only adjust the sequence number length when the FEC group is not open,
     // to ensure no packets in a group are too large.
     if (fec_group_.get() == NULL ||
         fec_group_->NumReceivedPackets() == 0) {
       sequence_number_length_ = options_.send_sequence_number_length;
     }
     packet_size_ = GetPacketHeaderSize(options_.send_connection_id_length,
                                        send_version_in_packet_,
                                        sequence_number_length_,
-                                       options_.max_packets_per_fec_group == 0 ?
-                                           NOT_IN_FEC_GROUP : IN_FEC_GROUP);
+                                       IsFecEnabled());
   }
   return packet_size_;
 }
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
   return AddFrame(frame, true);
 }
 
 SerializedPacket QuicPacketCreator::SerializePacket() {
   LOG_IF(DFATAL, queued_frames_.empty())
@@ skipping 23 matching lines @@
   if (!possibly_truncated)
     DCHECK_EQ(packet_size_, serialized.packet->length());
 
   packet_size_ = 0;
   queued_frames_.clear();
   serialized.retransmittable_frames = queued_retransmittable_frames_.release();
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec() {
-  DCHECK_LT(0u, fec_group_->NumReceivedPackets());
+  if (fec_group_.get() == NULL || fec_group_->NumReceivedPackets() <= 0) {
+    LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
+    // TODO(jri): Make this a public method of framer?
+    SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
+    return kNoPacket;
+  }
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_number_, true, &header);
   QuicFecData fec_data;
   fec_data.fec_group = fec_group_->min_protected_packet();
   fec_data.redundancy = fec_group_->payload_parity();
   SerializedPacket serialized = framer_->BuildFecPacket(header, fec_data);
   fec_group_.reset(NULL);
   fec_group_number_ = 0;
   packet_size_ = 0;
@@ skipping 100 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net