Land Recent QUIC Changes.

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_utils.h"
 
 using base::StringPiece;
 
 namespace net {
 
 class QuicAckNotifier;
 
 QuicPacketGenerator::QuicPacketGenerator(DelegateInterface* delegate,
                                          DebugDelegateInterface* debug_delegate,
                                          QuicPacketCreator* creator)
     : delegate_(delegate),
       debug_delegate_(debug_delegate),
       packet_creator_(creator),
       batch_mode_(false),
       should_send_ack_(false),
-      should_send_feedback_(false) {
+      should_send_feedback_(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:
@@ skipping 13 matching lines @@
         break;
       case GOAWAY_FRAME:
         delete it->goaway_frame;
         break;
       case WINDOW_UPDATE_FRAME:
         delete it->window_update_frame;
         break;
       case BLOCKED_FRAME:
         delete it->blocked_frame;
         break;
+      case STOP_WAITING_FRAME:
+        delete it->stop_waiting_frame;
+        break;
       case NUM_FRAME_TYPES:
         DCHECK(false) << "Cannot delete type: " << it->type;
     }
   }
 }
 
-void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback) {
+void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback,
+                                           bool also_send_stop_waiting) {
   should_send_ack_ = true;
   should_send_feedback_ = also_send_feedback;
+  should_send_stop_waiting_ = also_send_stop_waiting;
   SendQueuedFrames(false);
 }
 
+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,
                                                   QuicAckNotifier* notifier) {
@@ skipping 58 matching lines @@
     delegate_->OnSerializedPacket(serialized_fec);
   }
 
   DCHECK(InBatchMode() || !packet_creator_->HasPendingFrames());
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
 }
 
 bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
   DCHECK(HasPendingFrames());
   HasRetransmittableData retransmittable =
-      (should_send_ack_ || should_send_feedback_) ? NO_RETRANSMITTABLE_DATA
-                                                  : HAS_RETRANSMITTABLE_DATA;
+      (should_send_ack_ || should_send_feedback_ || 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(NOT_RETRANSMISSION, retransmittable,
                                          NOT_HANDSHAKE);
 }
 
 void QuicPacketGenerator::SendQueuedFrames(bool flush) {
   // Only add pending frames if we are SURE we can then send the whole packet.
   while (HasPendingFrames() &&
@@ skipping 35 matching lines @@
 void QuicPacketGenerator::FlushAllQueuedFrames() {
   SendQueuedFrames(true);
 }
 
 bool QuicPacketGenerator::HasQueuedFrames() const {
   return packet_creator_->HasPendingFrames() || HasPendingFrames();
 }
 
 bool QuicPacketGenerator::HasPendingFrames() const {
   return should_send_ack_ || should_send_feedback_ ||
-      !queued_control_frames_.empty();
+      should_send_stop_waiting_ || !queued_control_frames_.empty();
 }
 
 bool QuicPacketGenerator::AddNextPendingFrame() {
   if (should_send_ack_) {
     pending_ack_frame_.reset(delegate_->CreateAckFrame());
     // If we can't this add the frame now, then we still need to do so later.
     should_send_ack_ = !AddFrame(QuicFrame(pending_ack_frame_.get()));
     // Return success if we have cleared out this flag (i.e., added the frame).
     // If we still need to send, then the frame is full, and we have failed.
     return !should_send_ack_;
   }
 
   if (should_send_feedback_) {
     pending_feedback_frame_.reset(delegate_->CreateFeedbackFrame());
     // If we can't this add the frame now, then we still need to do so later.
     should_send_feedback_ = !AddFrame(QuicFrame(pending_feedback_frame_.get()));
     // Return success if we have cleared out this flag (i.e., added the frame).
     // If we still need to send, then the frame is full, and we have failed.
     return !should_send_feedback_;
   }
 
-  if (queued_control_frames_.empty()) {
-    LOG(DFATAL) << "AddNextPendingFrame called with no queued control frames.";
+  if (should_send_stop_waiting_) {
+    pending_stop_waiting_frame_.reset(delegate_->CreateStopWaitingFrame());
+    // If we can't this add the frame now, then we still need to do so later.
+    should_send_stop_waiting_ =
+        !AddFrame(QuicFrame(pending_stop_waiting_frame_.get()));
+    // Return success if we have cleared out this flag (i.e., added the frame).
+    // If we still need to send, then the frame is full, and we have failed.
+    return !should_send_stop_waiting_;
   }
+
+  LOG_IF(DFATAL, queued_control_frames_.empty())
+      << "AddNextPendingFrame called with no queued control frames.";
   if (!AddFrame(queued_control_frames_.back())) {
     // Packet was full.
     return false;
   }
   queued_control_frames_.pop_back();
   return true;
 }
 
 bool QuicPacketGenerator::AddFrame(const QuicFrame& frame) {
   bool success = packet_creator_->AddSavedFrame(frame);
   if (success && debug_delegate_) {
     debug_delegate_->OnFrameAddedToPacket(frame);
   }
   return success;
 }
 
 void QuicPacketGenerator::SerializeAndSendPacket() {
   SerializedPacket serialized_packet = packet_creator_->SerializePacket();
   DCHECK(serialized_packet.packet);
   delegate_->OnSerializedPacket(serialized_packet);
 
   if (packet_creator_->ShouldSendFec(false)) {
     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
     DCHECK(serialized_fec.packet);
     delegate_->OnSerializedPacket(serialized_fec);
   }
 }
 
 }  // namespace net