net/quic/quic_packet_generator.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/quic_packet_generator.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/logging.h"
   9 #include "net/quic/quic_fec_group.h"
  10 #include "net/quic/quic_utils.h"
  11
  12 using base::StringPiece;
  13
  14 namespace net {
  15
  16 class QuicAckNotifier;
  17
  18 QuicPacketGenerator::QuicPacketGenerator(DelegateInterface* delegate,
  19                                          DebugDelegateInterface* debug_delegate,
  20                                          QuicPacketCreator* creator)
  21     : delegate_(delegate),
  22       debug_delegate_(debug_delegate),
  23       packet_creator_(creator),
  24       batch_mode_(false),
  25       should_send_ack_(false),
  26       should_send_feedback_(false) {
  27 }
  28
  29 QuicPacketGenerator::~QuicPacketGenerator() {
  30   for (QuicFrames::iterator it = queued_control_frames_.begin();
  31        it != queued_control_frames_.end(); ++it) {
  32     switch (it->type) {
  33       case PADDING_FRAME:
  34         delete it->padding_frame;
  35         break;
  36       case STREAM_FRAME:
  37         delete it->stream_frame;
  38         break;
  39       case ACK_FRAME:
  40         delete it->ack_frame;
  41         break;
  42       case CONGESTION_FEEDBACK_FRAME:
  43         delete it->congestion_feedback_frame;
  44         break;
  45       case RST_STREAM_FRAME:
  46         delete it->rst_stream_frame;
  47         break;
  48       case CONNECTION_CLOSE_FRAME:
  49         delete it->connection_close_frame;
  50         break;
  51       case GOAWAY_FRAME:
  52         delete it->goaway_frame;
  53         break;
  54       case NUM_FRAME_TYPES:
  55         DCHECK(false) << "Cannot delete type: " << it->type;
  56     }
  57   }
  58 }
  59
  60 void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback) {
  61   should_send_ack_ = true;
  62   should_send_feedback_ = also_send_feedback;
  63   SendQueuedFrames(false);
  64 }
  65
  66 void QuicPacketGenerator::AddControlFrame(const QuicFrame& frame) {
  67   queued_control_frames_.push_back(frame);
  68   SendQueuedFrames(false);
  69 }
  70
  71 QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
  72                                                   const IOVector& data_to_write,
  73                                                   QuicStreamOffset offset,
  74                                                   bool fin,
  75                                                   QuicAckNotifier* notifier) {
  76   IsHandshake handshake = id == kCryptoStreamId ? IS_HANDSHAKE : NOT_HANDSHAKE;
  77   // The caller should have flushed pending frames before sending handshake
  78   // messages.
  79   DCHECK(handshake == NOT_HANDSHAKE || !HasPendingFrames());
  80   SendQueuedFrames(false);
  81
  82   size_t total_bytes_consumed = 0;
  83   bool fin_consumed = false;
  84
  85   if (!packet_creator_->HasRoomForStreamFrame(id, offset)) {
  86     SerializeAndSendPacket();
  87   }
  88
  89   IOVector data = data_to_write;
  90   size_t data_size = data.TotalBufferSize();
  91   while (delegate_->ShouldGeneratePacket(NOT_RETRANSMISSION,
  92                                          HAS_RETRANSMITTABLE_DATA, handshake)) {
  93     QuicFrame frame;
  94     size_t bytes_consumed;
  95     if (notifier != NULL) {
  96       // We want to track which packet this stream frame ends up in.
  97       bytes_consumed = packet_creator_->CreateStreamFrameWithNotifier(
  98           id, data, offset + total_bytes_consumed, fin, notifier, &frame);
  99     } else {
 100       bytes_consumed = packet_creator_->CreateStreamFrame(
 101           id, data, offset + total_bytes_consumed, fin, &frame);
 102     }
 103     if (!AddFrame(frame)) {
 104       LOG(DFATAL) << "Failed to add stream frame.";
 105       // Inability to add a STREAM frame creates an unrecoverable hole in a
 106       // the stream, so it's best to close the connection.
 107       delegate_->CloseConnection(QUIC_INTERNAL_ERROR, false);
 108       return QuicConsumedData(0, false);
 109     }
 110
 111     total_bytes_consumed += bytes_consumed;
 112     fin_consumed = fin && total_bytes_consumed == data_size;
 113     data.Consume(bytes_consumed);
 114     DCHECK(data.Empty() || packet_creator_->BytesFree() == 0u);
 115
 116     // TODO(ianswett): Restore packet reordering.
 117     if (!InBatchMode() || !packet_creator_->HasRoomForStreamFrame(id, offset)) {
 118       SerializeAndSendPacket();
 119     }
 120
 121     if (data.Empty()) {
 122       // We're done writing the data. Exit the loop.
 123       // We don't make this a precondition because we could have 0 bytes of data
 124       // if we're simply writing a fin.
 125       break;
 126     }
 127   }
 128
 129   // Ensure the FEC group is closed at the end of this method if not in batch
 130   // mode.
 131   if (!InBatchMode() && packet_creator_->ShouldSendFec(true)) {
 132     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
 133     DCHECK(serialized_fec.packet);
 134     delegate_->OnSerializedPacket(serialized_fec);
 135   }
 136
 137   DCHECK(InBatchMode() || !packet_creator_->HasPendingFrames());
 138   return QuicConsumedData(total_bytes_consumed, fin_consumed);
 139 }
 140
 141 bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
 142   DCHECK(HasPendingFrames());
 143   HasRetransmittableData retransmittable =
 144       (should_send_ack_ || should_send_feedback_) ? NO_RETRANSMITTABLE_DATA
 145                                                   : HAS_RETRANSMITTABLE_DATA;
 146   if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
 147       DCHECK(!queued_control_frames_.empty());  // These are retransmittable.
 148   }
 149   return delegate_->ShouldGeneratePacket(NOT_RETRANSMISSION, retransmittable,
 150                                          NOT_HANDSHAKE);
 151 }
 152
 153 void QuicPacketGenerator::SendQueuedFrames(bool flush) {
 154   // Only add pending frames if we are SURE we can then send the whole packet.
 155   while (HasPendingFrames() &&
 156          (flush || CanSendWithNextPendingFrameAddition())) {
 157     if (!AddNextPendingFrame()) {
 158       // Packet was full, so serialize and send it.
 159       SerializeAndSendPacket();
 160     }
 161   }
 162
 163   if (!InBatchMode() || flush) {
 164     if (packet_creator_->HasPendingFrames()) {
 165       SerializeAndSendPacket();
 166     }
 167
 168     // Ensure the FEC group is closed at the end of this method unless other
 169     // writes are pending.
 170     if (packet_creator_->ShouldSendFec(true)) {
 171       SerializedPacket serialized_fec = packet_creator_->SerializeFec();
 172       DCHECK(serialized_fec.packet);
 173       delegate_->OnSerializedPacket(serialized_fec);
 174     }
 175   }
 176 }
 177
 178 bool QuicPacketGenerator::InBatchMode() {
 179   return batch_mode_;
 180 }
 181
 182 void QuicPacketGenerator::StartBatchOperations() {
 183   batch_mode_ = true;
 184 }
 185
 186 void QuicPacketGenerator::FinishBatchOperations() {
 187   batch_mode_ = false;
 188   SendQueuedFrames(false);
 189 }
 190
 191 void QuicPacketGenerator::FlushAllQueuedFrames() {
 192   SendQueuedFrames(true);
 193 }
 194
 195 bool QuicPacketGenerator::HasQueuedFrames() const {
 196   return packet_creator_->HasPendingFrames() || HasPendingFrames();
 197 }
 198
 199 bool QuicPacketGenerator::HasPendingFrames() const {
 200   return should_send_ack_ || should_send_feedback_ ||
 201       !queued_control_frames_.empty();
 202 }
 203
 204 bool QuicPacketGenerator::AddNextPendingFrame() {
 205   if (should_send_ack_) {
 206     pending_ack_frame_.reset(delegate_->CreateAckFrame());
 207     // If we can't this add the frame now, then we still need to do so later.
 208     should_send_ack_ = !AddFrame(QuicFrame(pending_ack_frame_.get()));
 209     // Return success if we have cleared out this flag (i.e., added the frame).
 210     // If we still need to send, then the frame is full, and we have failed.
 211     return !should_send_ack_;
 212   }
 213
 214   if (should_send_feedback_) {
 215     pending_feedback_frame_.reset(delegate_->CreateFeedbackFrame());
 216     // If we can't this add the frame now, then we still need to do so later.
 217     should_send_feedback_ = !AddFrame(QuicFrame(pending_feedback_frame_.get()));
 218     // Return success if we have cleared out this flag (i.e., added the frame).
 219     // If we still need to send, then the frame is full, and we have failed.
 220     return !should_send_feedback_;
 221   }
 222
 223   if (queued_control_frames_.empty()) {
 224     LOG(DFATAL) << "AddNextPendingFrame called with no queued control frames.";
 225   }
 226   if (!AddFrame(queued_control_frames_.back())) {
 227     // Packet was full.
 228     return false;
 229   }
 230   queued_control_frames_.pop_back();
 231   return true;
 232 }
 233
 234 bool QuicPacketGenerator::AddFrame(const QuicFrame& frame) {
 235   bool success = packet_creator_->AddSavedFrame(frame);
 236   if (success && debug_delegate_) {
 237     debug_delegate_->OnFrameAddedToPacket(frame);
 238   }
 239   return success;
 240 }
 241
 242 void QuicPacketGenerator::SerializeAndSendPacket() {
 243   SerializedPacket serialized_packet = packet_creator_->SerializePacket();
 244   DCHECK(serialized_packet.packet);
 245   delegate_->OnSerializedPacket(serialized_packet);
 246
 247   if (packet_creator_->ShouldSendFec(false)) {
 248     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
 249     DCHECK(serialized_fec.packet);
 250     delegate_->OnSerializedPacket(serialized_fec);
 251   }
 252 }
 253
 254 }  // namespace net