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
15namespace net {
16
17namespace test {
18class QuicConnectionPeer;
19class 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.
25class 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_
154