relnote: Add a new class QuicBufferedPacketStore which is not in use yet.

net/quic/quic_buffered_packet_store.h

+// Copyright (c) 2016 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.
+
+#ifndef NET_QUIC_QUIC_BUFFERED_PACKET_STORE_H_
+#define NET_QUIC_QUIC_BUFFERED_PACKET_STORE_H_
+
+#include "net/base/ip_address.h"
+#include "net/base/linked_hash_map.h"
+#include "net/quic/quic_alarm.h"
+#include "net/quic/quic_alarm_factory.h"
+#include "net/quic/quic_clock.h"
+#include "net/quic/quic_protocol.h"
+#include "net/quic/quic_time.h"
+
+namespace net {
+
+namespace test {
+class QuicBufferedPacketStorePeer;
+}  // namespace test
+
+// This class buffers undeliverable packets for each connection until either
+// 1) They are requested to be delivered via DeliverPacket(), or
+// 2) They expire after exceeding their lifetime in the store.
+class NET_EXPORT_PRIVATE QuicBufferedPacketStore {
+ public:
+  enum EnqueuePacketResult {
+    SUCCESS = 0,
+    TOO_MANY_PACKETS,  // Too many packets stored up for a certain connection.
+    TOO_MANY_CONNECTIONS  // Too many connections stored up in the store.
+  };
+
+  // A packets with client/server address.
+  struct NET_EXPORT_PRIVATE BufferedPacket {
+    BufferedPacket(std::unique_ptr<QuicEncryptedPacket> packet,
+                   IPEndPoint server_address,
+                   IPEndPoint client_address);
+    BufferedPacket(BufferedPacket&& other);
+
+    BufferedPacket& operator=(BufferedPacket&& other);
+
+    ~BufferedPacket();
+
+    std::unique_ptr<QuicEncryptedPacket> packet;
+    IPEndPoint server_address;
+    IPEndPoint client_address;
+  };
+
+  // A queue of BufferedPackets for a connection.
+  struct NET_EXPORT_PRIVATE BufferedPacketList {
+    BufferedPacketList();
+    BufferedPacketList(BufferedPacketList&& other);
+
+    BufferedPacketList& operator=(BufferedPacketList&& other);
+
+    ~BufferedPacketList();
+
+    std::list<BufferedPacket> buffered_packets;
+    QuicTime creation_time;
+  };
+
+  typedef linked_hash_map<QuicConnectionId, BufferedPacketList>
+      BufferedPacketMap;
+
+  class NET_EXPORT_PRIVATE VisitorInterface {
+   public:
+    virtual ~VisitorInterface() {}
+
+    // Called for each expired connection when alarm fires.
+    virtual void OnExpiredPackets(QuicConnectionId connection_id,
+                                  BufferedPacketList early_arrived_packets) = 0;
+  };
+
+  QuicBufferedPacketStore(VisitorInterface* vistor,
+                          QuicClock* clock,
+                          QuicAlarmFactory* alarm_factory);
+
+  QuicBufferedPacketStore(const QuicBufferedPacketStore&) = delete;
+
+  ~QuicBufferedPacketStore();
+
+  QuicBufferedPacketStore& operator=(const QuicBufferedPacketStore&) = delete;
+
+  // Adds a copy of packet into packet queue for given connection.
+  EnqueuePacketResult EnqueuePacket(QuicConnectionId connection_id,
+                                    const QuicEncryptedPacket& packet,
+                                    IPEndPoint server_address,
+                                    IPEndPoint client_address);
+
+  // Returns the list of buffered packets for |connection_id| and removes them
+  // from the store. Returns an empty list if no early arrived packets for this
+  // connection are present.
+  std::list<BufferedPacket> DeliverPackets(QuicConnectionId connection_id);
+
+  // Examines how long packets have been buffered in the store for each
+  // connection. If they stay too long, removes them for new coming packets and
+  // calls |visitor_|'s OnPotentialConnectionExpire().
+  // Resets the alarm at the end.
+  void OnExpirationTimeout();
+
+ private:
+  friend class test::QuicBufferedPacketStorePeer;
+
+  // A map to store packet queues with creation time for each connection.
+  BufferedPacketMap undecryptable_packets_;
+
+  // The max time the packets of a connection can be buffer in the store.
+  QuicTime::Delta connection_life_span_;
+
+  VisitorInterface* visitor_;  // Unowned.
+
+  QuicClock* clock_;  // Unowned.
+
+  // This alarm fires every |connection_life_span_| to clean up
+  // packets staying in the store for too long.
+  std::unique_ptr<QuicAlarm> expiration_alarm_;
+};
+
+}  // namespace net
+
+#endif  // NET_QUIC_QUIC_BUFFERED_PACKET_STORE_H_