Land Recent QUIC Changes.

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);
 }
 
 void QuicPacketCreator::MaybeStartFEC() {
-  if (options_.max_packets_per_fec_group > 0 && fec_group_.get() == NULL) {
+  // Don't send FEC until QUIC_VERSION_15.
+  if (framer_->version() > QUIC_VERSION_14 &&
+      options_.max_packets_per_fec_group > 0 && 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());
   }
 }
 
 // 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
 // maximum packet size if we stop sending version before it is serialized.
@@ skipping 205 matching lines @@
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
   return AddFrame(frame, true);
 }
 
 SerializedPacket QuicPacketCreator::SerializePacket() {
   if (queued_frames_.empty()) {
     LOG(DFATAL) << "Attempt to serialize empty packet";
   }
   QuicPacketHeader header;
-  FillPacketHeader(fec_group_number_, false, false, &header);
+  FillPacketHeader(fec_group_number_, false, &header);
 
   MaybeAddPadding();
 
   size_t max_plaintext_size =
       framer_->GetMaxPlaintextSize(options_.max_packet_length);
   DCHECK_GE(max_plaintext_size, packet_size_);
   // ACK and CONNECTION_CLOSE Frames will be truncated only if they're
   // the first frame in the packet.  If truncation is to occur, then
   // GetSerializedFrameLength will have returned all bytes free.
   bool possibly_truncated =
@@ skipping 15 matching lines @@
   packet_size_ = 0;
   queued_frames_.clear();
   serialized.retransmittable_frames = queued_retransmittable_frames_.release();
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec() {
   DCHECK_LT(0u, fec_group_->NumReceivedPackets());
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
-  FillPacketHeader(fec_group_number_, true,
-                   fec_group_->entropy_parity(), &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;
   if (!serialized.packet) {
     LOG(DFATAL) << "Failed to serialize fec packet for group:"
                 << fec_data.fec_group;
@@ skipping 19 matching lines @@
   header.versions = supported_versions;
   QuicEncryptedPacket* encrypted =
       framer_->BuildVersionNegotiationPacket(header, supported_versions);
   DCHECK(encrypted);
   DCHECK_GE(options_.max_packet_length, encrypted->length());
   return encrypted;
 }
 
 void QuicPacketCreator::FillPacketHeader(QuicFecGroupNumber fec_group,
                                          bool fec_flag,
-                                         bool fec_entropy_flag,
                                          QuicPacketHeader* header) {
   header->public_header.guid = guid_;
   header->public_header.reset_flag = false;
   header->public_header.version_flag = send_version_in_packet_;
   header->fec_flag = fec_flag;
   header->packet_sequence_number = ++sequence_number_;
   header->public_header.sequence_number_length = sequence_number_length_;
-
-  bool entropy_flag;
-  if (fec_flag) {
-    // FEC packets don't have an entropy of their own. Entropy flag for FEC
-    // packets is the XOR of entropy of previous packets.
-    entropy_flag = fec_entropy_flag;
-  } else {
-    entropy_flag = random_bool_source_->RandBool();
-  }
-  header->entropy_flag = entropy_flag;
+  header->entropy_flag = random_bool_source_->RandBool();
   header->is_in_fec_group = fec_group == 0 ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
   header->fec_group = fec_group;
 }
 
 bool QuicPacketCreator::ShouldRetransmit(const QuicFrame& frame) {
   return frame.type != ACK_FRAME && frame.type != CONGESTION_FEEDBACK_FRAME &&
       frame.type != PADDING_FRAME;
 }
 
 bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
@@ skipping 49 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net