Implement an event-based simulator for QuicConnection

net/quic/core/congestion_control/simulation/port.h

+#ifndef NET_QUIC_CORE_CONGESTION_CONTROL_SIMULATION_PORT_H_
+#define NET_QUIC_CORE_CONGESTION_CONTROL_SIMULATION_PORT_H_
+
+#include <std::string>
+#include <utility>
+
+#include "net/quic/core/congestion_control/simulation/actor.h"
+#include "net/quic/core/quic_protocol.h"
+
+namespace net {
+namespace simulation {
+
+struct Packet {
+  std::std::string source;
+  std::std::string destination;
+  QuicTime tx_timestamp;
+
+  std::std::string contents;
+  QuicByteCount size;
+
+  Packet();
+};
+
+// An interface for anything that accepts packets at arbitrary rate.
+class UnconstrainedPortInterface {
+ public:
+  virtual ~UnconstrainedPortInterface() {}
+  virtual void AcceptPacket(std::unique_ptr<Packet> packet) = 0;
+};
+
+// An interface for any device that accepts packets at a specific rate.
+// Typically one would use a Queue object in order to write into a constrained
+// port.
+class ConstrainedPortInterface {
+ public:
+  virtual ~ConstrainedPortInterface() {}
+
+  // Accept a packet for a port.  TimeUntilAvailable() must be zero before this
+  // method is called.
+  virtual void AcceptPacket(std::unique_ptr<Packet> packet) = 0;
+
+  // Time until write for the next port is available.  Cannot be infinite.
+  virtual QuicTime::Delta TimeUntilAvailable() = 0;
+};
+
+// A convenience class for any network endpoints, i.e. the objects which can
+// both accept and send packets.
+class Endpoint : public Actor {
+ public:
+  virtual UnconstrainedPortInterface* GetRxPort() = 0;
+  virtual void SetTxPort(ConstrainedPortInterface* port) = 0;
+
+ protected:
+  Endpoint(Simulator* simulator, std::std::string name);
+};
+
+}  // namespace simulation
+}  // namespace net
+
+#endif  // NET_QUIC_CORE_CONGESTION_CONTROL_SIMULATION_PORT_H_