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/logging.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 
 namespace net {
 
+class QuicAckNotifier;
+
 QuicPacketGenerator::QuicPacketGenerator(DelegateInterface* delegate,
                                          DebugDelegateInterface* debug_delegate,
                                          QuicPacketCreator* creator)
     : delegate_(delegate),
       debug_delegate_(debug_delegate),
       packet_creator_(creator),
       batch_mode_(false),
       should_send_ack_(false),
       should_send_feedback_(false) {
 }
@@ skipping 28 matching lines @@
     }
   }
 }
 
 void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback) {
   should_send_ack_ = true;
   should_send_feedback_ = also_send_feedback;
   SendQueuedFrames();
 }
 
-
 void QuicPacketGenerator::AddControlFrame(const QuicFrame& frame) {
   queued_control_frames_.push_back(frame);
   SendQueuedFrames();
 }
 
 QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
                                                   StringPiece data,
                                                   QuicStreamOffset offset,
                                                   bool fin) {
+  return ConsumeData(id, data, offset, fin, NULL);
+}
+
+QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
+                                                  StringPiece data,
+                                                  QuicStreamOffset offset,
+                                                  bool fin,
+                                                  QuicAckNotifier* notifier) {
   IsHandshake handshake = id == kCryptoStreamId ? IS_HANDSHAKE : NOT_HANDSHAKE;
   // The caller should have flushed pending frames before sending handshake
   // messages.
   DCHECK(handshake == NOT_HANDSHAKE || !HasPendingFrames());
   SendQueuedFrames();
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   while (delegate_->CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
                              handshake)) {
     QuicFrame frame;
-    size_t bytes_consumed = packet_creator_->CreateStreamFrame(
+    size_t bytes_consumed;
+    if (notifier != NULL) {
+      // We want to track which packet this stream frame ends up in.
+      bytes_consumed = packet_creator_->CreateStreamFrameWithNotifier(
+        id, data, offset + total_bytes_consumed, fin, notifier, &frame);
+    } else {
+      bytes_consumed = packet_creator_->CreateStreamFrame(
         id, data, offset + total_bytes_consumed, fin, &frame);
+    }
     bool success = AddFrame(frame);
     DCHECK(success);
 
     total_bytes_consumed += bytes_consumed;
     fin_consumed = fin && bytes_consumed == data.size();
     data.remove_prefix(bytes_consumed);
     DCHECK(data.empty() || packet_creator_->BytesFree() == 0u);
 
     // TODO(ianswett): Restore packet reordering.
     if (!InBatchMode() || !packet_creator_->HasRoomForStreamFrame(id, offset)) {
@@ skipping 123 matching lines @@
 
   if (packet_creator_->ShouldSendFec(false)) {
     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
     DCHECK(serialized_fec.packet);
     delegate_->OnSerializedPacket(serialized_fec);
     packet_creator_->MaybeStartFEC();
   }
 }
 
 }  // namespace net