Roll Chrome into Mojo.

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_ack_notifier.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 
 namespace net {
 
 namespace {
 
 // We want to put some space between a protected packet and the FEC packet to
 // avoid losing them both within the same loss episode. On the other hand,
 // we expect to be able to recover from any loss in about an RTT.
 // We resolve this tradeoff by sending an FEC packet atmost half an RTT,
 // or equivalently, half the max number of in-flight packets,  the first
 // protected packet. Since we don't want to delay an FEC packet past half an
 // RTT, we set the max FEC group size to be half the current congestion window.
 const float kMaxPacketsInFlightMultiplierForFecGroupSize = 0.5;
+const float kRttMultiplierForFecTimeout = 0.5;
 
 }  // 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),
       batch_mode_(false),
+      fec_timeout_(QuicTime::Delta::Zero()),
       should_fec_protect_(false),
       should_send_ack_(false),
       should_send_feedback_(false),
-      should_send_stop_waiting_(false) {}
+      should_send_stop_waiting_(false) {
+}
 
 QuicPacketGenerator::~QuicPacketGenerator() {
   for (QuicFrames::iterator it = queued_control_frames_.begin();
        it != queued_control_frames_.end(); ++it) {
     switch (it->type) {
       case PADDING_FRAME:
         delete it->padding_frame;
         break;
       case STREAM_FRAME:
         delete it->stream_frame;
@@ skipping 31 matching lines @@
   }
 }
 
 void QuicPacketGenerator::OnCongestionWindowChange(
     QuicPacketCount max_packets_in_flight) {
   packet_creator_.set_max_packets_per_fec_group(
       static_cast<size_t>(kMaxPacketsInFlightMultiplierForFecGroupSize *
                           max_packets_in_flight));
 }
 
+void QuicPacketGenerator::OnRttChange(QuicTime::Delta rtt) {
+  fec_timeout_ = rtt.Multiply(kRttMultiplierForFecTimeout);
+}
+
 void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback,
                                            bool also_send_stop_waiting) {
   if (FLAGS_quic_disallow_multiple_pending_ack_frames) {
     if (pending_ack_frame_ != nullptr) {
       // Ack already queued, nothing to do.
       return;
     }
 
     if (also_send_feedback && pending_feedback_frame_ != nullptr) {
       LOG(DFATAL) << "Should only ever be one pending feedback frame.";
@@ skipping 15 matching lines @@
 void QuicPacketGenerator::SetShouldSendStopWaiting() {
   should_send_stop_waiting_ = true;
   SendQueuedFrames(false);
 }
 
 void QuicPacketGenerator::AddControlFrame(const QuicFrame& frame) {
   queued_control_frames_.push_back(frame);
   SendQueuedFrames(false);
 }
 
-QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
-                                                  const IOVector& data_to_write,
-                                                  QuicStreamOffset offset,
-                                                  bool fin,
-                                                  FecProtection fec_protection,
-                                                  QuicAckNotifier* notifier) {
+QuicConsumedData QuicPacketGenerator::ConsumeData(
+    QuicStreamId id,
+    const IOVector& data_to_write,
+    QuicStreamOffset offset,
+    bool fin,
+    FecProtection fec_protection,
+    QuicAckNotifier::DelegateInterface* delegate) {
   IsHandshake handshake = id == kCryptoStreamId ? IS_HANDSHAKE : NOT_HANDSHAKE;
   // 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();
   }
 
+  // This notifier will be owned by the AckNotifierManager (or deleted below) if
+  // not attached to a packet.
+  QuicAckNotifier* notifier = nullptr;
+  if (delegate != nullptr) {
+    notifier = new QuicAckNotifier(delegate);
+  }
+
   IOVector data = data_to_write;
   size_t data_size = data.TotalBufferSize();
+  if (FLAGS_quic_empty_data_no_fin_early_return && !fin && (data_size == 0)) {
+    LOG(DFATAL) << "Attempt to consume empty data without FIN.";
+    return QuicConsumedData(0, false);
+  }
+
+  int frames_created = 0;
   while (delegate_->ShouldGeneratePacket(NOT_RETRANSMISSION,
                                          HAS_RETRANSMITTABLE_DATA, handshake)) {
     QuicFrame frame;
-    size_t bytes_consumed;
-    if (notifier != nullptr) {
-      // 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);
-    }
+    size_t bytes_consumed = packet_creator_.CreateStreamFrame(
+        id, data, offset + total_bytes_consumed, fin, &frame);
+    ++frames_created;
+
+    // We want to track which packet this stream frame ends up in.
+    frame.stream_frame->notifier = notifier;
+
     if (!AddFrame(frame)) {
       LOG(DFATAL) << "Failed to add 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);
+      delete notifier;
       return QuicConsumedData(0, false);
     }
 
     total_bytes_consumed += bytes_consumed;
     fin_consumed = fin && total_bytes_consumed == data_size;
     data.Consume(bytes_consumed);
     DCHECK(data.Empty() || packet_creator_.BytesFree() == 0u);
 
     // TODO(ianswett): Restore packet reordering.
     if (!InBatchMode() || !packet_creator_.HasRoomForStreamFrame(id, offset)) {
       SerializeAndSendPacket();
     }
 
     if (data.Empty()) {
       // 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;
       }
       break;
     }
   }
 
+  if (notifier != nullptr && frames_created == 0) {
+    // Safe to delete the AckNotifer as it was never attached to a packet.
+    delete notifier;
+  }
+
   // 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.
   // TODO(jri): This method should be called with flush=false here
   // once the timer-based FEC sending is done, to separate FEC sending from
   // the end of batch operations.
@@ skipping 210 matching lines @@
     packet_creator_.set_connection_id_length(PACKET_8BYTE_CONNECTION_ID);
   }
 }
 
 
 void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
   packet_creator_.set_encryption_level(level);
 }
 
 }  // namespace net