Queueing QUIC frames to be resent instead of packets and packing RST frames with acks and congestio…

net/quic/quic_connection.h

 // 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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 118 matching lines @@
 
 class NET_EXPORT_PRIVATE QuicConnection : public QuicFramerVisitorInterface {
  public:
   // Constructs a new QuicConnection for the specified |guid| and |address|.
   // |helper| will be owned by this connection.
   QuicConnection(QuicGuid guid,
                  IPEndPoint address,
                  QuicConnectionHelperInterface* helper);
   virtual ~QuicConnection();
 
+  static void DeleteEnclosedFrame(QuicFrame* frame);
 
   // Send the data payload to the peer.
   // Returns a pair with the number of bytes consumed from data, and a boolean
   // indicating if the fin bit was consumed.  This does not indicate the data
   // has been sent on the wire: it may have been turned into a packet and queued
   // if the socket was unexpectedly blocked.
   QuicConsumedData SendStreamData(QuicStreamId id,
                                   base::StringPiece data,
                                   QuicStreamOffset offset,
                                   bool fin,
@@ skipping 77 matching lines @@
   bool ShouldSimulateLostPacket();
 
   // Sets up a packet with an QuicAckFrame and sends it out.
   void SendAck();
 
  protected:
   // Send a packet to the peer.  If should_resend is true, this packet contains
   // data, and contents will be resent with a new sequence number if we don't
   // get an ack.  If force is true, then the packet will be sent immediately and
   // the send scheduler will not be consulted.  If is_retransmit is true, this
-  // packet is being retransmitted with a new sequence number.
+  // packet is being retransmitted with a new sequence number.  Always takes
+  // ownership of packet.
   // TODO(wtc): none of the callers check the return value.
   virtual bool SendPacket(QuicPacketSequenceNumber number,
                           QuicPacket* packet,
                           bool should_resend,
                           bool force,
                           bool is_retransmit);
 
   // Make sure an ack we got from our peer is sane.
   bool ValidateAckFrame(const QuicAckFrame& incoming_ack);
 
@@ skipping 31 matching lines @@
           retransmit(retransmit) {
     }
 
     QuicPacketSequenceNumber sequence_number;
     QuicPacket* packet;
     bool resend;
     bool retransmit;
   };
 
   struct UnackedPacket {
-    explicit UnackedPacket(QuicPacket* packet)
-        : packet(packet),
-          number_nacks(0) {
-    }
-    QuicPacket* packet;
+    explicit UnackedPacket(QuicFrames unacked_frames);
+    UnackedPacket(QuicFrames unacked_frames, std::string data);
+    ~UnackedPacket();
+
+    QuicFrames frames;
     uint8 number_nacks;
+    // Data referenced by the StringPiece of a QuicStreamFrame.
+    std::string data;
   };
 
   typedef std::list<QueuedPacket> QueuedPacketList;
   typedef base::hash_map<QuicPacketSequenceNumber,
-      UnackedPacket> UnackedPacketMap;
+      UnackedPacket*> UnackedPacketMap;
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
 
   // The amount of time we wait before resending a packet.
   static const QuicTime::Delta DefaultResendTime() {
     return QuicTime::Delta::FromMilliseconds(500);
   }
 
+  static void DeleteUnackedPacket(UnackedPacket* unacked);
+  static bool ShouldResend(const QuicFrame& frame);
+
   // Checks if a packet can be written now, and sets the timer if necessary.
   bool CanWrite(bool is_retransmit);
 
   // Writes as much queued data as possible.  The connection must not be
   // blocked when this is called.
   bool WriteData();
 
   // If a packet can be revived from the current FEC group, then
   // revive and process the packet.
   void MaybeProcessRevivedPacket();
@@ skipping 27 matching lines @@
   bool should_send_congestion_feedback_;
   QuicAckFrame outgoing_ack_;
   QuicCongestionFeedbackFrame outgoing_congestion_feedback_;
 
   // Track some client state so we can do less bookkeeping
   QuicPacketSequenceNumber largest_seen_packet_with_ack_;
   QuicPacketSequenceNumber peer_largest_observed_packet_;
   QuicPacketSequenceNumber peer_least_packet_awaiting_ack_;
 
   // When new packets are created which may be resent, they are added
-  // to this map, which contains owning pointers.
+  // to this map, which contains owning pointers to the contained frames.
   UnackedPacketMap unacked_packets_;
 
   // When packets could not be sent because the socket was not writable,
-  // they are added to this list.  For packets that are not resendable, this
-  // list contains owning pointers, since they are not added to
-  // unacked_packets_.
+  // they are added to this list.  All corresponding frames are in
+  // unacked_packets_ if they are to be resent.
   QueuedPacketList queued_packets_;
 
+  // Pending control frames, besides the ack and congestion control frames.
+  QuicFrames queued_control_frames_;
+
   // True when the socket becomes unwritable.
   bool write_blocked_;
 
   FecGroupMap group_map_;
   QuicPacketHeader revived_header_;
   scoped_array<char> revived_payload_;
 
   QuicConnectionVisitorInterface* visitor_;
   QuicPacketCreator packet_creator_;
 
@@ skipping 16 matching lines @@
   bool received_truncated_ack_;
 
   bool send_ack_in_response_to_packet_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_