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/logging.h"
 #include "net/quic/crypto/quic_random.h"
+#include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::min;
 using std::pair;
 using std::vector;
 
 namespace net {
 
 QuicPacketCreator::QuicPacketCreator(QuicGuid guid,
                                      QuicFramer* framer,
                                      QuicRandom* random_generator,
                                      bool is_server)
     : guid_(guid),
       framer_(framer),
       random_generator_(random_generator),
       sequence_number_(0),
       fec_group_number_(0),
       is_server_(is_server),
       send_version_in_packet_(!is_server),
       sequence_number_length_(options_.send_sequence_number_length),
       packet_size_(0) {
-  framer_->set_fec_builder(this);
+  framer_->set_fec_builder(reinterpret_cast<QuicFecBuilderInterface*>(this));
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
 }
 
 void QuicPacketCreator::OnBuiltFecProtectedPayload(
     const QuicPacketHeader& header, StringPiece payload) {
   if (fec_group_.get()) {
     fec_group_->Update(header, payload);
   }
@@ skipping 87 matching lines @@
     *frame = QuicFrame(new QuicStreamFrame(id, set_fin, offset, data_frame));
   } else {
     DCHECK(fin);
     // Create a new packet for the fin, if necessary.
     *frame = QuicFrame(new QuicStreamFrame(id, true, offset, ""));
   }
 
   return bytes_consumed;
 }
 
+size_t QuicPacketCreator::CreateStreamFrameWithNotifier(
+    QuicStreamId id,
+    StringPiece data,
+    QuicStreamOffset offset,
+    bool fin,
+    QuicAckNotifier* notifier,
+    QuicFrame* frame) {
+  size_t bytes_consumed = CreateStreamFrame(id, data, offset, fin, frame);
+
+  // The frame keeps track of the QuicAckNotifier until it is serialized into
+  // a packet. At that point the notifier is informed of the sequence number
+  // of the packet that this frame was eventually sent in.
+  frame->stream_frame->notifier = notifier;
+
+  return bytes_consumed;
+}
+
 SerializedPacket QuicPacketCreator::ReserializeAllFrames(
     const QuicFrames& frames,
     QuicSequenceNumberLength original_length) {
   // Temporarily set the sequence number length and disable FEC.
   const QuicSequenceNumberLength start_length = sequence_number_length_;
   const QuicSequenceNumberLength start_options_length =
       options_.send_sequence_number_length;
   const QuicFecGroupNumber start_fec_group = fec_group_number_;
   sequence_number_length_ = original_length;
   options_.send_sequence_number_length = original_length;
@@ skipping 57 matching lines @@
   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);
 
-  SerializedPacket serialized = framer_->BuildDataPacket(
-      header, queued_frames_, PacketSize());
+  SerializedPacket serialized =
+      framer_->BuildDataPacket(header, queued_frames_, packet_size_);
+
+  // Run through all the included frames and if any of them have an AckNotifier
+  // registered, then inform the AckNotifier that it should be interested in
+  // this packet's sequence number.
+  for (QuicFrames::iterator it = queued_frames_.begin();
+       it != queued_frames_.end(); ++it) {
+    if (it->type == STREAM_FRAME && it->stream_frame->notifier != NULL) {
+      it->stream_frame->notifier->AddSequenceNumber(serialized.sequence_number);
+    }
+  }
+
   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;
@@ skipping 88 matching lines @@
       queued_frames_.push_back(
           queued_retransmittable_frames_->AddNonStreamFrame(frame));
     }
   } else {
     queued_frames_.push_back(frame);
   }
   return true;
 }
 
 }  // namespace net