Make QuicPacketCreator be able to serialize packet itself when it does not have room for next strea…

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 22 matching lines @@
 }  // namespace
 
 class QuicAckNotifier;
 
 QuicPacketGenerator::QuicPacketGenerator(QuicConnectionId connection_id,
                                          QuicFramer* framer,
                                          QuicRandom* random_generator,
                                          DelegateInterface* delegate)
     : delegate_(delegate),
       debug_delegate_(nullptr),
-      packet_creator_(connection_id, framer, random_generator),
+      packet_creator_(connection_id, framer, random_generator, this),
       batch_mode_(false),
       fec_timeout_(QuicTime::Delta::Zero()),
       rtt_multiplier_for_fec_timeout_(kRttMultiplierForFecTimeout),
       should_fec_protect_(false),
       fec_send_policy_(FEC_ANY_TRIGGER),
       should_send_ack_(false),
       should_send_stop_waiting_(false),
       ack_queued_(false),
       stop_waiting_queued_(false),
       max_packet_length_(kDefaultMaxPacketSize) {}
@@ skipping 78 matching lines @@
   // To make reasoning about crypto frames easier, we don't combine them with
   // other retransmittable frames in a single packet.
   const bool flush =
       has_handshake && packet_creator_.HasPendingRetransmittableFrames();
   SendQueuedFrames(flush, /*is_fec_timeout=*/false);
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   if (!packet_creator_.HasRoomForStreamFrame(id, offset)) {
-    SerializeAndSendPacket();
+    packet_creator_.Flush();
   }
 
   if (fec_protection == MUST_FEC_PROTECT) {
     MaybeStartFecProtection();
   }
 
   if (!fin && (iov.total_length == 0)) {
     LOG(DFATAL) << "Attempt to consume empty data without FIN.";
     return QuicConsumedData(0, false);
   }
 
   while (delegate_->ShouldGeneratePacket(
       HAS_RETRANSMITTABLE_DATA, has_handshake ? IS_HANDSHAKE : NOT_HANDSHAKE)) {
     QuicFrame frame;
     if (!packet_creator_.ConsumeData(id, iov, total_bytes_consumed,
                                      offset + total_bytes_consumed, fin,
                                      has_handshake, &frame)) {
-      LOG(DFATAL) << "Created but failed to add a stream frame.";
-      // Inability to add a STREAM frame creates an unrecoverable hole in a
-      // the stream, so it's best to close the connection.
-      delegate_->CloseConnection(QUIC_INTERNAL_ERROR, false);
-      return QuicConsumedData(0, false);
+      // Current packet is full and flushed.
+      continue;
     }
-    DCHECK(frame.stream_frame);
+
+    // A stream frame is created and added.
     size_t bytes_consumed = frame.stream_frame->data.length();
     if (debug_delegate_ != nullptr) {
       debug_delegate_->OnFrameAddedToPacket(frame);
     }
 
     if (listener != nullptr) {
       ack_listeners_.push_back(AckListenerWrapper(listener, bytes_consumed));
     }
 
     total_bytes_consumed += bytes_consumed;
     fin_consumed = fin && total_bytes_consumed == iov.total_length;
     DCHECK(total_bytes_consumed == iov.total_length ||
-           packet_creator_.BytesFree() == 0u);
+           (bytes_consumed > 0 && packet_creator_.HasPendingFrames()));
 
-    if (!InBatchMode() || !packet_creator_.HasRoomForStreamFrame(id, offset)) {
+    if (!InBatchMode()) {
       // TODO(rtenneti): remove MaybeSendFecPacketAndCloseGroup() from inside
       // SerializeAndSendPacket() and make it an explicit call here (and
       // elsewhere where we call SerializeAndSendPacket?).
-      SerializeAndSendPacket();
+      packet_creator_.Flush();
     }
 
     if (total_bytes_consumed == iov.total_length) {
       // We're done writing the data. Exit the loop.
       // We don't make this a precondition because we could have 0 bytes of data
       // 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;
@@ skipping 26 matching lines @@
   // serialized within this function.
   QuicMtuDiscoveryFrame mtu_discovery_frame;
   QuicFrame frame(mtu_discovery_frame);
 
   // Send the probe packet with the new length.
   SetMaxPacketLength(target_mtu, /*force=*/true);
   const bool success = AddFrame(frame, nullptr, /*needs_padding=*/true);
   if (listener != nullptr) {
     ack_listeners_.push_back(AckListenerWrapper(listener, 0));
   }
-  SerializeAndSendPacket();
+  packet_creator_.Flush();
   // The only reason AddFrame can fail is that the packet is too full to fit in
   // a ping.  This is not possible for any sane MTU.
   DCHECK(success);
 
   // Reset the packet length back.
   SetMaxPacketLength(current_mtu, /*force=*/true);
 }
 
 bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
   DCHECK(HasPendingFrames());
   HasRetransmittableData retransmittable =
       (should_send_ack_ || should_send_stop_waiting_)
           ? NO_RETRANSMITTABLE_DATA
           : HAS_RETRANSMITTABLE_DATA;
   if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
       DCHECK(!queued_control_frames_.empty());  // These are retransmittable.
   }
   return delegate_->ShouldGeneratePacket(retransmittable, NOT_HANDSHAKE);
 }
 
 void QuicPacketGenerator::SendQueuedFrames(bool flush, bool is_fec_timeout) {
   // Only add pending frames if we are SURE we can then send the whole packet.
   while (HasPendingFrames() &&
          (flush || CanSendWithNextPendingFrameAddition())) {
-    if (!AddNextPendingFrame()) {
-      // Packet was full, so serialize and send it.
-      SerializeAndSendPacket();
-    }
+    AddNextPendingFrame();
   }
-  if (packet_creator_.HasPendingFrames() && (flush || !InBatchMode())) {
-    SerializeAndSendPacket();
+  if (flush || !InBatchMode()) {
+    packet_creator_.Flush();
   }
   MaybeSendFecPacketAndCloseGroup(flush, is_fec_timeout);
 }
 
 void QuicPacketGenerator::MaybeStartFecProtection() {
   if (!packet_creator_.IsFecEnabled()) {
     return;
   }
   DVLOG(1) << "Turning FEC protection ON";
   should_fec_protect_ = true;
@@ skipping 144 matching lines @@
                                    bool needs_padding) {
   bool success = needs_padding
                      ? packet_creator_.AddPaddedSavedFrame(frame, buffer.Pass())
                      : packet_creator_.AddSavedFrame(frame, buffer.Pass());
   if (success && debug_delegate_) {
     debug_delegate_->OnFrameAddedToPacket(frame);
   }
   return success;
 }
 
-void QuicPacketGenerator::SerializeAndSendPacket() {
-  // The optimized encryption algorithm implementations run faster when
-  // operating on aligned memory.
-  //
-  // TODO(rtenneti): Change the default 64 alignas value (used the default
-  // value from CACHELINE_SIZE).
-  ALIGNAS(64) char buffer[kMaxPacketSize];
-  SerializedPacket serialized_packet =
-      packet_creator_.SerializePacket(buffer, kMaxPacketSize);
-  if (serialized_packet.packet == nullptr) {
-    LOG(DFATAL) << "Failed to SerializePacket. fec_policy:" << fec_send_policy_
-                << " should_fec_protect_:" << should_fec_protect_;
-    delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
-    return;
-  }
-
-  // There may be AckListeners interested in this packet.
-  serialized_packet.listeners.swap(ack_listeners_);
-  ack_listeners_.clear();
-
-  delegate_->OnSerializedPacket(serialized_packet);
-  MaybeSendFecPacketAndCloseGroup(/*force=*/false, /*is_fec_timeout=*/false);
-
-  // Maximum packet size may be only enacted while no packet is currently being
-  // constructed, so here we have a good opportunity to actually change it.
-  if (packet_creator_.CanSetMaxPacketLength()) {
-    packet_creator_.SetMaxPacketLength(max_packet_length_);
-  }
-
-  // The packet has now been serialized, so the frames are no longer queued.
-  ack_queued_ = false;
-  stop_waiting_queued_ = false;
-}
-
 void QuicPacketGenerator::StopSendingVersion() {
   packet_creator_.StopSendingVersion();
 }
 
 QuicPacketNumber QuicPacketGenerator::packet_number() const {
   return packet_creator_.packet_number();
 }
 
 QuicByteCount QuicPacketGenerator::GetMaxPacketLength() const {
   return max_packet_length_;
@@ skipping 54 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);
 }
 
+void QuicPacketGenerator::OnSerializedPacket(
+    SerializedPacket* serialized_packet) {
+  if (serialized_packet->packet == nullptr) {
+    LOG(DFATAL)
+        << "Failed to SerializePacket. fec_policy:" << fec_send_policy_
+        << " should_fec_protect_:" << should_fec_protect_;
+    delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
+    return;
+  }
+
+  // There may be AckListeners interested in this packet.
+  serialized_packet->listeners.swap(ack_listeners_);
+  ack_listeners_.clear();
+
+  delegate_->OnSerializedPacket(*serialized_packet);
+  MaybeSendFecPacketAndCloseGroup(/*force=*/false, /*is_fec_timeout=*/false);
+
+  // Maximum packet size may be only enacted while no packet is currently being
+  // constructed, so here we have a good opportunity to actually change it.
+  if (packet_creator_.CanSetMaxPacketLength()) {
+    packet_creator_.SetMaxPacketLength(max_packet_length_);
+  }
+
+  // The packet has now been serialized, so the frames are no longer queued.
+  ack_queued_ = false;
+  stop_waiting_queued_ = false;
+}
+
 }  // namespace net