Change from re-transmitting an packet with a retransmit number to sending a new packet with a new s…

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 168 matching lines @@
 
   // If the connection has timed out, this will close the connection and return
   // true.  Otherwise, it will return false and will reset the timeout alarm.
   bool CheckForTimeout();
 
   // Returns true of the next packet to be sent should be "lost" by
   // not actually writing it to the wire.
   bool ShouldSimulateLostPacket();
 
  protected:
-  // Send a packet to the peer.  If resend is true, this packet contains data,
-  // and will be resent 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.
+  // 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.
   virtual bool SendPacket(QuicPacketSequenceNumber number,
                           QuicPacket* packet,
-                          bool resend,
-                          bool force);
+                          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);
 
   // These two are called by OnAckFrame to update the appropriate internal
   // state.
   //
   // Updates internal state based on incoming_ack.received_info
   void UpdatePacketInformationReceivedByPeer(
       const QuicAckFrame& incoming_ack);
@@ skipping 46 matching lines @@
                          QuicPacket*> UnackedPacketMap;
   // When new packets are created which may be resent, they are added
   // to this map, which contains owning pointers.
   UnackedPacketMap unacked_packets_;
 
   // Packets which have not been written to the wire.
   struct QueuedPacket {
     QuicPacketSequenceNumber sequence_number;
     QuicPacket* packet;
     bool resend;
+    bool retransmit;
 
     QueuedPacket(QuicPacketSequenceNumber sequence_number,
                  QuicPacket* packet,
-                 bool resend) {
+                 bool resend,
+                 bool retransmit) {
       this->sequence_number = sequence_number;
       this->packet = packet;
       this->resend = resend;
+      this->retransmit = retransmit;
     }
   };
   typedef std::list<QueuedPacket> QueuedPacketList;
   // 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_.
   QueuedPacketList queued_packets_;
 
   // True when the socket becomes unwritable.
@@ skipping 22 matching lines @@
   scoped_ptr<QuicSendScheduler> scheduler_;
 
   // True by default.  False if we've received or sent an explicit connection
   // close.
   bool connected_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_