Landing Recent QUIC changes until and including Mon Nov 16 14:15:48 2015

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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 51 matching lines @@
   // Stored random bits.
   uint64 bit_bucket_;
   // The next available bit has "1" in the mask. Zero means empty bucket.
   uint64 bit_mask_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicRandomBoolSource);
 };
 
 QuicPacketCreator::QuicPacketCreator(QuicConnectionId connection_id,
                                      QuicFramer* framer,
-                                     QuicRandom* random_generator)
-    : connection_id_(connection_id),
+                                     QuicRandom* random_generator,
+                                     DelegateInterface* delegate)
+    : delegate_(delegate),
+      connection_id_(connection_id),
       encryption_level_(ENCRYPTION_NONE),
       framer_(framer),
       random_bool_source_(new QuicRandomBoolSource(random_generator)),
       packet_number_(0),
       should_fec_protect_(false),
       send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
       max_packet_length_(0),
       max_packets_per_fec_group_(kDefaultMaxPacketsPerFecGroup),
       connection_id_length_(PACKET_8BYTE_CONNECTION_ID),
       next_packet_number_length_(PACKET_1BYTE_PACKET_NUMBER),
@@ skipping 146 matching lines @@
   // Since the packet creator will not change packet number length mid FEC
   // group, include the size of an FEC group to be safe.
   const QuicPacketNumber current_delta = max_packets_per_fec_group_ +
                                          packet_number_ + 1 -
                                          least_packet_awaited_by_peer;
   const uint64 delta = max(current_delta, max_packets_in_flight);
   next_packet_number_length_ =
       QuicFramer::GetMinSequenceNumberLength(delta * 4);
 }
 
+bool QuicPacketCreator::ConsumeData(QuicStreamId id,
+                                    QuicIOVector iov,
+                                    size_t iov_offset,
+                                    QuicStreamOffset offset,
+                                    bool fin,
+                                    bool needs_padding,
+                                    QuicFrame* frame) {
+  if (!HasRoomForStreamFrame(id, offset)) {
+    Flush();
+    return false;
+  }
+
+  UniqueStreamBuffer buffer;
+  CreateStreamFrame(id, iov, iov_offset, offset, fin, frame, &buffer);
+
+  bool success = AddFrame(*frame,
+                          /*save_retransmittable_frames=*/true, needs_padding,
+                          std::move(buffer));
+  DCHECK(success);
+  return true;
+}
+
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
                                               QuicStreamOffset offset) const {
   // TODO(jri): This is a simple safe decision for now, but make
   // is_in_fec_group a parameter. Same as with all public methods in
   // QuicPacketCreator.
   return BytesFree() >
       QuicFramer::GetMinStreamFrameSize(id, offset, true,
                                         should_fec_protect_ ? IN_FEC_GROUP :
                                                               NOT_IN_FEC_GROUP);
 }
@@ skipping 156 matching lines @@
       << "Attempt to serialize empty packet";
   for (const QuicFrame& frame : frames) {
     bool success = AddFrame(frame, false, false, nullptr);
     DCHECK(success);
   }
   SerializedPacket packet = SerializePacket(buffer, buffer_len);
   DCHECK(packet.retransmittable_frames == nullptr);
   return packet;
 }
 
+void QuicPacketCreator::Flush() {
+  if (!HasPendingFrames()) {
+    return;
+  }
+
+  // TODO(rtenneti): Change the default 64 alignas value (used the default
+  // value from CACHELINE_SIZE).
+  ALIGNAS(64) char seralized_packet_buffer[kMaxPacketSize];
+  SerializedPacket serialized_packet =
+      SerializePacket(seralized_packet_buffer, kMaxPacketSize);
+  delegate_->OnSerializedPacket(&serialized_packet);
+}
+
 bool QuicPacketCreator::HasPendingFrames() const {
   return !queued_frames_.empty();
 }
 
 bool QuicPacketCreator::HasPendingRetransmittableFrames() const {
   return queued_retransmittable_frames_.get() != nullptr &&
          !queued_retransmittable_frames_->frames().empty();
 }
 
 size_t QuicPacketCreator::ExpansionOnNewFrame() const {
@@ skipping 216 matching lines @@
                                  bool save_retransmittable_frames,
                                  bool needs_padding,
                                  UniqueStreamBuffer buffer) {
   DVLOG(1) << "Adding frame: " << frame;
   InFecGroup is_in_fec_group = MaybeUpdateLengthsAndStartFec();
 
   size_t frame_len = framer_->GetSerializedFrameLength(
       frame, BytesFree(), queued_frames_.empty(), true, is_in_fec_group,
       packet_number_length_);
   if (frame_len == 0) {
+    // Current open packet is full.
+    Flush();
     return false;
   }
   DCHECK_LT(0u, packet_size_);
   packet_size_ += ExpansionOnNewFrame() + frame_len;
 
   if (save_retransmittable_frames && ShouldRetransmit(frame)) {
     if (queued_retransmittable_frames_.get() == nullptr) {
       queued_retransmittable_frames_.reset(
           new RetransmittableFrames(encryption_level_));
     }
@@ skipping 18 matching lines @@
   if (BytesFree() == 0) {
     // Don't pad full packets.
     return;
   }
 
   bool success = AddFrame(QuicFrame(QuicPaddingFrame()), false, false, nullptr);
   DCHECK(success);
 }
 
 }  // namespace net