Merge the QUIC unacked packet map with the unacked fec packet map and

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 341 matching lines @@
   // handshake finishes.
   void SetOverallConnectionTimeout(QuicTime::Delta timeout);
 
   // 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();
 
   // Sets up a packet with an QuicAckFrame and sends it out.
   void SendAck();
 
-  // Called when an RTO fires.  Returns the time when this alarm
-  // should next fire, or 0 if no retransmission alarm should be set.
+  // Called when an RTO fires.  Resets the retransmission alarm if there are
+  // remaining unacked packets.
   void OnRetransmissionTimeout();
 
-  // Called when an alarm to abandon sent FEC packets fires.  The alarm is set
-  // by the same policy as the RTO alarm, but is a separate alarm.
-  QuicTime OnAbandonFecTimeout();
-
   // Retransmits all unacked packets with retransmittable frames if
   // |retransmission_type| is ALL_PACKETS, otherwise retransmits only initially
   // encrypted packets. Used when the negotiated protocol version is different
   // from what was initially assumed and when the visitor wants to re-transmit
   // initially encrypted packets when the initial encrypter changes.
   void RetransmitUnackedPackets(RetransmissionType retransmission_type);
 
   // Changes the encrypter used for level |level| to |encrypter|. The function
   // takes ownership of |encrypter|.
   void SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter);
@@ skipping 192 matching lines @@
   typedef std::list<QueuedPacket> QueuedPacketList;
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
   typedef std::priority_queue<RetransmissionTime,
                               std::vector<RetransmissionTime>,
                               RetransmissionTimeComparator>
       RetransmissionTimeouts;
 
   // Sends a version negotiation packet to the peer.
   void SendVersionNegotiationPacket();
 
-  void SetupRetransmission(QuicPacketSequenceNumber sequence_number,
-                           EncryptionLevel level);
+  void SetupRetransmissionAlarm(QuicPacketSequenceNumber sequence_number);
   bool IsRetransmission(QuicPacketSequenceNumber sequence_number);
 
   void SetupAbandonFecTimer(QuicPacketSequenceNumber sequence_number);
 
   // Clears any accumulated frames from the last received packet.
   void ClearLastFrames();
 
   // Called from OnCanWrite and WriteIfNotBlocked to write queued packets.
   // Returns false if the socket has become blocked.
   bool DoWrite();
@@ skipping 107 matching lines @@
 
   FecGroupMap group_map_;
 
   QuicReceivedPacketManager received_packet_manager_;
   QuicSentEntropyManager sent_entropy_manager_;
 
   // An alarm that fires when an ACK should be sent to the peer.
   scoped_ptr<QuicAlarm> ack_alarm_;
   // An alarm that fires when a packet needs to be retransmitted.
   scoped_ptr<QuicAlarm> retransmission_alarm_;
-  // An alarm that fires when one or more FEC packets are to be discarded.
-  scoped_ptr<QuicAlarm> abandon_fec_alarm_;
   // An alarm that is scheduled when the sent scheduler requires a
   // a delay before sending packets and fires when the packet may be sent.
   scoped_ptr<QuicAlarm> send_alarm_;
   // An alarm that is scheduled when the connection can still write and there
   // may be more data to send.
   scoped_ptr<QuicAlarm> resume_writes_alarm_;
   // An alarm that fires when the connection may have timed out.
   scoped_ptr<QuicAlarm> timeout_alarm_;
 
   QuicConnectionVisitorInterface* visitor_;
@@ skipping 50 matching lines @@
   // If non-empty this contains the set of versions received in a
   // version negotiation packet.
   QuicVersionVector server_supported_versions_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_