net/quic/quic_received_packet_manager.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // Manages the packet entropy calculation for both sent and received packets
   6 // for a connection.
   7
   8 #ifndef NET_QUIC_QUIC_RECEIVED_PACKET_MANAGER_H_
   9 #define NET_QUIC_QUIC_RECEIVED_PACKET_MANAGER_H_
  10
  11 #include "net/quic/congestion_control/receive_algorithm_interface.h"
  12 #include "net/quic/quic_framer.h"
  13 #include "net/quic/quic_protocol.h"
  14
  15 namespace net {
  16
  17 namespace test {
  18 class QuicConnectionPeer;
  19 class QuicReceivedPacketManagerPeer;
  20 }  // namespace test
  21
  22 // Records all received packets by a connection and tracks their entropy.
  23 // Also calculates the correct entropy for the framer when it truncates an ack
  24 // frame being serialized.
  25 class NET_EXPORT_PRIVATE QuicReceivedPacketManager :
  26     public QuicReceivedEntropyHashCalculatorInterface {
  27  public:
  28   explicit QuicReceivedPacketManager(CongestionFeedbackType congestion_type);
  29   virtual ~QuicReceivedPacketManager();
  30
  31   // Updates the internal state concerning which packets have been received.
  32   // bytes: the packet size in bytes including Quic Headers.
  33   // header: the packet header.
  34   // timestamp: the arrival time of the packet.
  35   // revived: true if the packet was lost and then recovered with help of a
  36   // FEC packet.
  37   void RecordPacketReceived(QuicByteCount bytes,
  38                             const QuicPacketHeader& header,
  39                             QuicTime receipt_time,
  40                             bool revived);
  41
  42   // Checks whether |sequence_number| is missing and less than largest observed.
  43   bool IsMissing(QuicPacketSequenceNumber sequence_number);
  44
  45   // Checks if we're still waiting for the packet with |sequence_number|.
  46   bool IsAwaitingPacket(QuicPacketSequenceNumber sequence_number);
  47
  48   // Update the |received_info| for an outgoing ack.
  49   void UpdateReceivedPacketInfo(ReceivedPacketInfo* received_info,
  50                                 QuicTime approximate_now);
  51
  52   // Should be called before sending an ACK packet, to decide if we need
  53   // to attach a QuicCongestionFeedbackFrame block.
  54   // Returns false if no QuicCongestionFeedbackFrame block is needed.
  55   // Otherwise fills in feedback and returns true.
  56   virtual bool GenerateCongestionFeedback(
  57       QuicCongestionFeedbackFrame* feedback);
  58
  59   // QuicReceivedEntropyHashCalculatorInterface
  60   // Called by QuicFramer, when the outgoing ack gets truncated, to recalculate
  61   // the received entropy hash for the truncated ack frame.
  62   virtual QuicPacketEntropyHash EntropyHash(
  63       QuicPacketSequenceNumber sequence_number) const OVERRIDE;
  64
  65   // These two are called by OnAckFrame.
  66   //
  67   // Updates internal state based on |incoming_ack.received_info|.
  68   void UpdatePacketInformationReceivedByPeer(const QuicAckFrame& incoming_ack);
  69   // Updates internal state based on |incoming_ack.sent_info|.
  70   void UpdatePacketInformationSentByPeer(const QuicAckFrame& incoming_ack);
  71
  72   // Returns whether the peer is missing packets.
  73   bool HasMissingPackets();
  74
  75   // Returns true when there are new missing packets to be reported within 3
  76   // packets of the largest observed.
  77   bool HasNewMissingPackets();
  78
  79   QuicPacketSequenceNumber peer_largest_observed_packet() {
  80     return peer_largest_observed_packet_;
  81   }
  82
  83   QuicPacketSequenceNumber least_packet_awaited_by_peer() {
  84     return least_packet_awaited_by_peer_;
  85   }
  86
  87   QuicPacketSequenceNumber peer_least_packet_awaiting_ack() {
  88     return peer_least_packet_awaiting_ack_;
  89   }
  90
  91  private:
  92   friend class test::QuicConnectionPeer;
  93   friend class test::QuicReceivedPacketManagerPeer;
  94
  95   typedef std::map<QuicPacketSequenceNumber,
  96                    QuicPacketEntropyHash> ReceivedEntropyMap;
  97
  98   // Record the received entropy hash against |sequence_number|.
  99   void RecordPacketEntropyHash(QuicPacketSequenceNumber sequence_number,
 100                                QuicPacketEntropyHash entropy_hash);
 101
 102   // Recalculate the entropy hash and clears old packet entropies,
 103   // now that the sender sent us the |entropy_hash| for packets up to,
 104   // but not including, |peer_least_unacked|.
 105   void RecalculateEntropyHash(QuicPacketSequenceNumber peer_least_unacked,
 106                               QuicPacketEntropyHash entropy_hash);
 107
 108   // Deletes all missing packets before least unacked. The connection won't
 109   // process any packets with sequence number before |least_unacked| that it
 110   // received after this call. Returns true if there were missing packets before
 111   // |least_unacked| unacked, false otherwise.
 112   bool DontWaitForPacketsBefore(QuicPacketSequenceNumber least_unacked);
 113
 114   // TODO(satyamshekhar): Can be optimized using an interval set like data
 115   // structure.
 116   // Map of received sequence numbers to their corresponding entropy.
 117   // Every received packet has an entry, and packets without the entropy bit set
 118   // have an entropy value of 0.
 119   // TODO(ianswett): When the entropy flag is off, the entropy should not be 0.
 120   ReceivedEntropyMap packets_entropy_;
 121
 122   // Cumulative hash of entropy of all received packets.
 123   QuicPacketEntropyHash packets_entropy_hash_;
 124
 125   // The largest sequence number cleared by RecalculateEntropyHash.
 126   // Received entropy cannot be calculated for numbers less than it.
 127   QuicPacketSequenceNumber largest_sequence_number_;
 128
 129
 130   // Track some peer state so we can do less bookkeeping.
 131   // Largest sequence number that the peer has observed. Mostly received,
 132   // missing in case of truncated acks.
 133   QuicPacketSequenceNumber peer_largest_observed_packet_;
 134   // Least sequence number which the peer is still waiting for.
 135   QuicPacketSequenceNumber least_packet_awaited_by_peer_;
 136   // Least sequence number of the the packet sent by the peer for which it
 137   // hasn't received an ack.
 138   QuicPacketSequenceNumber peer_least_packet_awaiting_ack_;
 139
 140   // Received packet information used to produce acks.
 141   ReceivedPacketInfo received_info_;
 142
 143   // The time we received the largest_observed sequence number, or zero if
 144   // no sequence numbers have been received since UpdateReceivedPacketInfo.
 145   // Needed for calculating delta_time_largest_observed.
 146   QuicTime time_largest_observed_;
 147
 148   scoped_ptr<ReceiveAlgorithmInterface> receive_algorithm_;
 149 };
 150
 151 }  // namespace net
 152
 153 #endif  // NET_QUIC_QUIC_RECEIVED_PACKET_MANAGER_H_