Land Recent QUIC Changes.

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_utils.h"
@@ skipping 79 matching lines @@
   SendQueuedFrames(false);
 }
 
 QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
                                                   const IOVector& data_to_write,
                                                   QuicStreamOffset offset,
                                                   bool fin,
                                                   FecProtection fec_protection,
                                                   QuicAckNotifier* notifier) {
   IsHandshake handshake = id == kCryptoStreamId ? IS_HANDSHAKE : NOT_HANDSHAKE;
-  SendQueuedFrames(false);
+  // To make reasoning about crypto frames easier, we don't combine them with
+  // other retransmittable frames in a single packet.
+  const bool flush = handshake == IS_HANDSHAKE &&
+      packet_creator_.HasPendingRetransmittableFrames();
+  SendQueuedFrames(flush);
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   if (!packet_creator_.HasRoomForStreamFrame(id, offset)) {
     SerializeAndSendPacket();
   }
 
   if (fec_protection == MUST_FEC_PROTECT) {
     MaybeStartFecProtection();
@@ skipping 37 matching lines @@
       // if we're simply writing a fin.
       if (fec_protection == MUST_FEC_PROTECT) {
         // Turn off FEC protection when we're done writing protected data.
         DVLOG(1) << "Turning FEC protection OFF";
         should_fec_protect_ = false;
       }
       break;
     }
   }
 
+  // Don't allow the handshake to be bundled with other retransmittable frames.
+  if (handshake == IS_HANDSHAKE) {
+    SendQueuedFrames(true);
+  }
+
   // Try to close FEC group since we've either run out of data to send or we're
   // blocked. If not in batch mode, force close the group.
   MaybeSendFecPacketAndCloseGroup(!InBatchMode());
 
   DCHECK(InBatchMode() || !packet_creator_.HasPendingFrames());
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
 }
 
 bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
   DCHECK(HasPendingFrames());
@@ skipping 185 matching lines @@
       QuicByteCount congestion_window) {
   return packet_creator_.UpdateSequenceNumberLength(
       least_packet_awaited_by_peer, congestion_window);
 }
 
 void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
   packet_creator_.set_encryption_level(level);
 }
 
 }  // namespace net