Land Recent QUIC changes.

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 20 matching lines @@
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_alarm.h"
 #include "net/quic/quic_blocked_writer_interface.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_packet_generator.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_received_packet_manager.h"
 #include "net/quic/quic_sent_entropy_manager.h"
+#include "net/quic/quic_sent_packet_manager.h"
 
 namespace net {
 
 class QuicClock;
 class QuicConnection;
 class QuicFecGroup;
 class QuicRandom;
 
 namespace test {
 class QuicConnectionPeer;
 }  // namespace test
 
+// Class that receives callbacks from the connection when frames are received
+// and when other interesting events happen.
 class NET_EXPORT_PRIVATE QuicConnectionVisitorInterface {
  public:
   virtual ~QuicConnectionVisitorInterface() {}
 
   // A simple visitor interface for dealing with data frames.  The session
   // should determine if all frames will be accepted, and return true if so.
   // If any frames can't be processed or buffered, none of the data should
   // be used, and the callee should return false.
-  virtual bool OnPacket(const IPEndPoint& self_address,
-                        const IPEndPoint& peer_address,
-                        const QuicPacketHeader& header,
-                        const std::vector<QuicStreamFrame>& frame) = 0;
+  virtual bool OnStreamFrames(const std::vector<QuicStreamFrame>& frames) = 0;
 
   // Called when the stream is reset by the peer.
   virtual void OnRstStream(const QuicRstStreamFrame& frame) = 0;
 
   // Called when the connection is going away according to the peer.
   virtual void OnGoAway(const QuicGoAwayFrame& frame) = 0;
 
   // Called when the connection is closed either locally by the framer, or
   // remotely by the peer.
   virtual void ConnectionClose(QuicErrorCode error,
                                bool from_peer) = 0;
 
-  // Called when packets are acked by the peer.
-  virtual void OnAck(const SequenceNumberSet& acked_packets) = 0;
-
   // Called once a specific QUIC version is agreed by both endpoints.
   virtual void OnSuccessfulVersionNegotiation(const QuicVersion& version) = 0;
 
   // Called when a blocked socket becomes writable.  If all pending bytes for
   // this visitor are consumed by the connection successfully this should
   // return true, otherwise it should return false.
   virtual bool OnCanWrite() = 0;
+
+  // Called to ask if any handshake messages are pending in this visitor.
+  virtual bool HasPendingHandshake() const = 0;
 };
 
 // Interface which gets callbacks from the QuicConnection at interesting
 // points.  Implementations must not mutate the state of the connection
 // as a result of these callbacks.
 class NET_EXPORT_PRIVATE QuicConnectionDebugVisitorInterface
     : public QuicPacketGenerator::DebugDelegateInterface {
  public:
   virtual ~QuicConnectionDebugVisitorInterface() {}
 
@@ skipping 84 matching lines @@
 
   // Creates a new platform-specific alarm which will be configured to
   // notify |delegate| when the alarm fires.  Caller takes ownership
   // of the new alarm, which will not yet be "set" to fire.
   virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) = 0;
 };
 
 class NET_EXPORT_PRIVATE QuicConnection
     : public QuicFramerVisitorInterface,
       public QuicBlockedWriterInterface,
-      public QuicPacketGenerator::DelegateInterface {
+      public QuicPacketGenerator::DelegateInterface,
+      public QuicSentPacketManager::HelperInterface {
  public:
   enum Force {
     NO_FORCE,
     FORCE
   };
 
   enum RetransmissionType {
     INITIAL_ENCRYPTION_ONLY,
     ALL_PACKETS
   };
 
   // Constructs a new QuicConnection for the specified |guid| and |address|.
   // |helper| will be owned by this connection.
   QuicConnection(QuicGuid guid,
                  IPEndPoint address,
                  QuicConnectionHelperInterface* helper,
                  bool is_server,
                  QuicVersion version);
   virtual ~QuicConnection();
 
   // Send the data in |iov| to the peer in as few packets as possible.
   // 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 SendvStreamData(QuicStreamId id,
                                    const struct iovec* iov,
-                                   int count,
+                                   int iov_count,
                                    QuicStreamOffset offset,
                                    bool fin);
 
-  // Same as above, except that the provided delegate will be informed once ACKs
-  // have been received for all the packets written.
+  // Same as SendvStreamData, except the provided delegate will be informed
+  // once ACKs have been received for all the packets written.
   // The |delegate| is not owned by the QuicConnection and must outlive it.
-  QuicConsumedData SendStreamDataAndNotifyWhenAcked(
+  QuicConsumedData SendvStreamDataAndNotifyWhenAcked(
       QuicStreamId id,
-      base::StringPiece data,
+      const struct iovec* iov,
+      int iov_count,
       QuicStreamOffset offset,
       bool fin,
       QuicAckNotifier::DelegateInterface* delegate);
 
   // Send a stream reset frame to the peer.
   virtual void SendRstStream(QuicStreamId id,
                              QuicRstStreamErrorCode error);
 
   // Sends the connection close packet without affecting the state of the
   // connection.  This should only be called if the session is actively being
@@ skipping 63 matching lines @@
 
   // QuicPacketGenerator::DelegateInterface
   virtual bool CanWrite(
       Retransmission is_retransmission,
       HasRetransmittableData has_retransmittable_data,
       IsHandshake handshake) OVERRIDE;
   virtual QuicAckFrame* CreateAckFrame() OVERRIDE;
   virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() OVERRIDE;
   virtual bool OnSerializedPacket(const SerializedPacket& packet) OVERRIDE;
 
+  // QuicSentPacketManager::HelperInterface
+  virtual QuicPacketSequenceNumber GetPeerLargestObservedPacket() OVERRIDE;
+  virtual QuicPacketSequenceNumber GetNextPacketSequenceNumber() OVERRIDE;
+  virtual void OnPacketNacked(QuicPacketSequenceNumber sequence_number,
+                              size_t nack_count) OVERRIDE;
+
   // Accessors
   void set_visitor(QuicConnectionVisitorInterface* visitor) {
     visitor_ = visitor;
   }
   void set_debug_visitor(QuicConnectionDebugVisitorInterface* debug_visitor) {
     debug_visitor_ = debug_visitor;
     packet_generator_.set_debug_delegate(debug_visitor);
   }
   const IPEndPoint& self_address() const { return self_address_; }
   const IPEndPoint& peer_address() const { return peer_address_; }
@@ skipping 86 matching lines @@
 
   bool is_server() const { return is_server_; }
 
   static bool g_acks_do_not_instigate_acks;
 
  protected:
   // Send a packet to the peer using encryption |level|. If |sequence_number|
   // is present in the |retransmission_map_|, then contents of this packet will
   // be retransmitted with a new sequence number if it's not acked by the peer.
   // Deletes |packet| via WritePacket call or transfers ownership to
-  // QueuedPacket, ultimately deleted via WritePacket. Also, it updates the
+  // QueuedPacket, ultimately deleted via WritePacket. Updates the
   // entropy map corresponding to |sequence_number| using |entropy_hash|.
+  // |retransmittable| is supplied to the congestion manager, and when |forced|
+  // is true, it bypasses the congestion manager.
   // TODO(wtc): none of the callers check the return value.
   virtual bool SendOrQueuePacket(EncryptionLevel level,
                                  QuicPacketSequenceNumber sequence_number,
                                  QuicPacket* packet,
                                  QuicPacketEntropyHash entropy_hash,
-                                 HasRetransmittableData retransmittable);
+                                 HasRetransmittableData retransmittable,
+                                 Force forced);
 
   // Writes the given packet to socket, encrypted with |level|, with the help
   // of helper. Returns true on successful write, false otherwise. However,
   // behavior is undefined if connection is not established or broken. In any
   // circumstances, a return value of true implies that |packet| has been
   // deleted and should not be accessed. If |sequence_number| is present in
   // |retransmission_map_| it also sets up retransmission of the given packet
   // in case of successful write. If |force| is FORCE, then the packet will be
   // sent immediately and the send scheduler will not be consulted.
   bool WritePacket(EncryptionLevel level,
@@ skipping 15 matching lines @@
   // Selects and updates the version of the protocol being used by selecting a
   // version from |available_versions| which is also supported. Returns true if
   // such a version exists, false otherwise.
   bool SelectMutualVersion(const QuicVersionVector& available_versions);
 
   QuicFramer framer_;
 
  private:
   friend class test::QuicConnectionPeer;
 
+  // Inner helper function to SendvStreamData and
+  // SendvStreamDataAndNotifyWhenAcked.
+  QuicConsumedData SendvStreamDataInner(QuicStreamId id,
+                                        const struct iovec* iov,
+                                        int iov_count,
+                                        QuicStreamOffset offset,
+                                        bool fin,
+                                        QuicAckNotifier *notifier);
+
   // Packets which have not been written to the wire.
   // Owns the QuicPacket* packet.
   struct QueuedPacket {
     QueuedPacket(QuicPacketSequenceNumber sequence_number,
                  QuicPacket* packet,
                  EncryptionLevel level,
-                 HasRetransmittableData retransmittable)
+                 HasRetransmittableData retransmittable,
+                 Force forced)
         : sequence_number(sequence_number),
           packet(packet),
           encryption_level(level),
-          retransmittable(retransmittable) {
+          retransmittable(retransmittable),
+          forced(forced) {
     }
 
     QuicPacketSequenceNumber sequence_number;
     QuicPacket* packet;
     const EncryptionLevel encryption_level;
     HasRetransmittableData retransmittable;
+    Force forced;
   };
 
   struct RetransmissionInfo {
     RetransmissionInfo(QuicPacketSequenceNumber sequence_number,
                        QuicSequenceNumberLength sequence_number_length)
         : sequence_number(sequence_number),
           sequence_number_length(sequence_number_length),
           number_nacks(0),
           number_retransmissions(0) {
     }
@@ skipping 21 matching lines @@
    public:
     bool operator()(const RetransmissionTime& lhs,
                     const RetransmissionTime& rhs) const {
       DCHECK(lhs.scheduled_time.IsInitialized() &&
              rhs.scheduled_time.IsInitialized());
       return lhs.scheduled_time > rhs.scheduled_time;
     }
   };
 
   typedef std::list<QueuedPacket> QueuedPacketList;
-  typedef linked_hash_map<QuicPacketSequenceNumber,
-                          RetransmittableFrames*> UnackedPacketMap;
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
-  typedef base::hash_map<QuicPacketSequenceNumber,
-                         RetransmissionInfo> RetransmissionMap;
   typedef std::priority_queue<RetransmissionTime,
                               std::vector<RetransmissionTime>,
                               RetransmissionTimeComparator>
       RetransmissionTimeouts;
   typedef std::list<QuicAckNotifier*> AckNotifierList;
 
   // Sends a version negotiation packet to the peer.
   void SendVersionNegotiationPacket();
 
   void SetupRetransmission(QuicPacketSequenceNumber sequence_number,
@@ skipping 31 matching lines @@
 
   // Attempts to process any queued undecryptable packets.
   void MaybeProcessUndecryptablePackets();
 
   // If a packet can be revived from the current FEC group, then
   // revive and process the packet.
   void MaybeProcessRevivedPacket();
 
   void ProcessAckFrame(const QuicAckFrame& incoming_ack);
 
-  void HandleAckForSentPackets(const QuicAckFrame& incoming_ack,
-                               SequenceNumberSet* acked_packets);
-  void HandleAckForSentFecPackets(const QuicAckFrame& incoming_ack,
-                                  SequenceNumberSet* acked_packets);
-
   // Update the |sent_info| for an outgoing ack.
   void UpdateSentPacketInfo(SentPacketInfo* sent_info);
 
   // Checks if the last packet should instigate an ack.
   bool ShouldLastPacketInstigateAck();
 
   // Sends any packets which are a response to the last packet, including both
   // acks and pending writes if an ack opened the congestion window.
   void MaybeSendInResponseToPacket(bool last_packet_should_instigate_ack);
 
@@ skipping 18 matching lines @@
   IPEndPoint peer_address_;
 
   bool last_packet_revived_;  // True if the last packet was revived from FEC.
   size_t last_size_;  // Size of the last received packet.
   QuicPacketHeader last_header_;
   std::vector<QuicStreamFrame> last_stream_frames_;
   std::vector<QuicAckFrame> last_ack_frames_;
   std::vector<QuicCongestionFeedbackFrame> last_congestion_frames_;
   std::vector<QuicRstStreamFrame> last_rst_frames_;
   std::vector<QuicGoAwayFrame> last_goaway_frames_;
+  // Then number of packets retransmitted because of nacks
+  // while processed the current ack frame.
+  size_t retransmitted_nacked_packet_count_;
 
   QuicCongestionFeedbackFrame outgoing_congestion_feedback_;
 
   // Track some peer state so we can do less bookkeeping
   // Largest sequence sent by the peer which had an ack frame (latest ack info).
   QuicPacketSequenceNumber largest_seen_packet_with_ack_;
 
-  // When new packets are created which may be retransmitted, they are added
-  // to this map, which contains owning pointers to the contained frames.
-  UnackedPacketMap unacked_packets_;
-
-  // Pending fec packets that have not been acked yet. These packets need to be
-  // cleared out of the cgst_window after a timeout since FEC packets are never
-  // retransmitted.
-  // Ask: What should be the timeout for these packets?
-  UnackedPacketMap unacked_fec_packets_;
-
   // Collection of packets which were received before encryption was
   // established, but which could not be decrypted.  We buffer these on
   // the assumption that they could not be processed because they were
   // sent with the INITIAL encryption and the CHLO message was lost.
   std::deque<QuicEncryptedPacket*> undecryptable_packets_;
 
   // Heap of packets that we might need to retransmit, and the time at
   // which we should retransmit them. Every time a packet is sent it is added
   // to this heap which is O(log(number of pending packets to be retransmitted))
   // which might be costly. This should be optimized to O(1) by maintaining a
   // priority queue of lists of packets to be retransmitted, where list x
   // contains all packets that have been retransmitted x times.
   RetransmissionTimeouts retransmission_timeouts_;
 
-  // Map from sequence number to the retransmission info.
-  RetransmissionMap retransmission_map_;
-
   // True while OnRetransmissionTimeout is running to prevent
   // SetRetransmissionAlarm from being called erroneously.
   bool handling_retransmission_timeout_;
 
   // When packets could not be sent because the socket was not writable,
   // they are added to this list.  All corresponding frames are in
   // unacked_packets_ if they are to be retransmitted.
   QueuedPacketList queued_packets_;
 
   // True when the socket becomes unwritable.
@@ skipping 33 matching lines @@
   // This is used for timeouts, and does not indicate the packet was processed.
   QuicTime time_of_last_received_packet_;
 
   // The time that we last sent a packet for this connection.
   QuicTime time_of_last_sent_packet_;
 
   // Congestion manager which controls the rate the connection sends packets
   // as well as collecting and generating congestion feedback.
   QuicCongestionManager congestion_manager_;
 
+  // Sent packet manager which tracks the status of packets sent by this
+  // connection.
+  QuicSentPacketManager sent_packet_manager_;
+
   // The state of connection in version negotiation finite state machine.
   QuicVersionNegotiationState version_negotiation_state_;
 
   size_t max_packets_per_retransmission_alarm_;
 
   // Tracks if the connection was created by the server.
   bool is_server_;
 
   // True by default.  False if we've received or sent an explicit connection
   // close.
@@ skipping 13 matching lines @@
   // Once a given QuicAckNotifier has seen all the sequence numbers it is
   // interested in, it will be deleted, and removed from this list.
   AckNotifierList ack_notifiers_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_