Landing Recent QUIC changes until: Fri Oct 30 22:23:58 2015 +0000

net/quic/quic_packet_generator.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_generator.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_flags.h"
@@ skipping 270 matching lines @@
     // generator to check if the resulting expansion still allows the incoming
     // frame to be added to the packet.
     SendQueuedFrames(/*flush=*/true, /*is_fec_timeout=*/false);
   }
   packet_creator_.StartFecProtectingPackets();
   DCHECK(packet_creator_.IsFecProtected());
 }
 
 void QuicPacketGenerator::MaybeSendFecPacketAndCloseGroup(bool force,
                                                           bool is_fec_timeout) {
-  if (!ShouldSendFecPacket(force)) {
-    return;
+  if (ShouldSendFecPacket(force)) {
+    // If we want to send FEC packet only when FEC alaram goes off and if it is
+    // not a FEC timeout then close the group and dont send FEC packet.
+    if (fec_send_policy_ == FEC_ALARM_TRIGGER && !is_fec_timeout) {
+      ResetFecGroup();
+    } else {
+      // TODO(jri): SerializeFec can return a NULL packet, and this should cause
+      // an early return, with a call to delegate_->OnPacketGenerationError.
+      char buffer[kMaxPacketSize];
+      SerializedPacket serialized_fec =
+          packet_creator_.SerializeFec(buffer, kMaxPacketSize);
+      DCHECK(serialized_fec.packet);
+      delegate_->OnSerializedPacket(serialized_fec);
+    }
   }
 
-  // If we want to send FEC packet only when FEC alaram goes off and if it is
-  // not a FEC timeout then close the group and dont send FEC packet.
-  if (fec_send_policy_ == FEC_ALARM_TRIGGER && !is_fec_timeout) {
-    ResetFecGroup();
-  } else {
-    // TODO(jri): SerializeFec can return a NULL packet, and this should
-    // cause an early return, with a call to delegate_->OnPacketGenerationError.
-    char buffer[kMaxPacketSize];
-    SerializedPacket serialized_fec =
-        packet_creator_.SerializeFec(buffer, kMaxPacketSize);
-    DCHECK(serialized_fec.packet);
-    delegate_->OnSerializedPacket(serialized_fec);
-  }
   // Turn FEC protection off if creator's protection is on and the creator
   // does not have an open FEC group.
   // Note: We only wait until the frames queued in the creator are flushed;
   // pending frames in the generator will not keep us from turning FEC off.
-  if (!should_fec_protect_ && !packet_creator_.IsFecGroupOpen()) {
+  if (!should_fec_protect_ && packet_creator_.IsFecProtected() &&
+      !packet_creator_.IsFecGroupOpen()) {
     packet_creator_.StopFecProtectingPackets();
     DCHECK(!packet_creator_.IsFecProtected());
   }
 }
 
 bool QuicPacketGenerator::ShouldSendFecPacket(bool force) {
   return packet_creator_.IsFecProtected() &&
          !packet_creator_.HasPendingFrames() &&
          packet_creator_.ShouldSendFec(force);
 }
@@ skipping 203 matching lines @@
 void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
   packet_creator_.set_encryption_level(level);
 }
 
 void QuicPacketGenerator::SetEncrypter(EncryptionLevel level,
                                        QuicEncrypter* encrypter) {
   packet_creator_.SetEncrypter(level, encrypter);
 }
 
 }  // namespace net