Project import generated by Copybara.
PiperOrigin-RevId: 237361882
Change-Id: I109a68f44db867b20f8c6a7732b0ce657133e52a
diff --git a/quic/quartc/quartc_packet_writer.h b/quic/quartc/quartc_packet_writer.h
new file mode 100644
index 0000000..f3eb885
--- /dev/null
+++ b/quic/quartc/quartc_packet_writer.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2017 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 QUICHE_QUIC_QUARTC_QUARTC_PACKET_WRITER_H_
+#define QUICHE_QUIC_QUARTC_QUARTC_PACKET_WRITER_H_
+
+#include "net/third_party/quiche/src/quic/core/quic_connection.h"
+#include "net/third_party/quiche/src/quic/core/quic_packet_writer.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+
+namespace quic {
+
+// Send and receive packets, like a virtual UDP socket. For example, this
+// could be implemented by WebRTC's IceTransport.
+class QuartcPacketTransport {
+ public:
+ // Additional metadata provided for each packet written.
+ struct PacketInfo {
+ QuicPacketNumber packet_number;
+ };
+
+ // Delegate for packet transport callbacks. Note that the delegate is not
+ // thread-safe. Packet transport implementations must ensure that callbacks
+ // are synchronized with all other work done by QUIC.
+ class Delegate {
+ public:
+ virtual ~Delegate() = default;
+
+ // Called whenever the transport can write.
+ virtual void OnTransportCanWrite() = 0;
+
+ // Called when the transport receives a packet.
+ virtual void OnTransportReceived(const char* data, size_t data_len) = 0;
+ };
+
+ virtual ~QuartcPacketTransport() {}
+
+ // Called by the QuartcPacketWriter when writing packets to the network.
+ // Return the number of written bytes. Return 0 if the write is blocked.
+ virtual int Write(const char* buffer,
+ size_t buf_len,
+ const PacketInfo& info) = 0;
+
+ // Sets the delegate which must be called when the transport can write or
+ // a packet is received. QUIC sets |delegate| to a nonnull pointer when it
+ // is ready to process incoming packets and sets |delegate| to nullptr before
+ // QUIC is deleted. Implementations may assume |delegate| remains valid until
+ // it is set to nullptr.
+ virtual void SetDelegate(Delegate* delegate) = 0;
+};
+
+struct QuartcPerPacketOptions : public PerPacketOptions {
+ std::unique_ptr<PerPacketOptions> Clone() const override;
+
+ // The connection which is sending this packet.
+ QuicConnection* connection = nullptr;
+};
+
+// Implements a QuicPacketWriter using a QuartcPacketTransport, which allows a
+// QuicConnection to use (for example), a WebRTC IceTransport.
+class QuartcPacketWriter : public QuicPacketWriter {
+ public:
+ QuartcPacketWriter(QuartcPacketTransport* packet_transport,
+ QuicByteCount max_packet_size);
+ ~QuartcPacketWriter() override {}
+
+ // The QuicConnection calls WritePacket and the QuicPacketWriter writes them
+ // to the QuartcSession::PacketTransport.
+ WriteResult WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) override;
+
+ // Whether the underneath |transport_| is blocked. If this returns true,
+ // outgoing QUIC packets are queued by QuicConnection until SetWritable() is
+ // called.
+ bool IsWriteBlocked() const override;
+
+ // Maximum size of the QUIC packet which can be written. Users such as WebRTC
+ // can set the value through the QuartcFactoryConfig without updating the QUIC
+ // code.
+ QuicByteCount GetMaxPacketSize(
+ const QuicSocketAddress& peer_address) const override;
+
+ // Sets the packet writer to a writable (non-blocked) state.
+ void SetWritable() override;
+
+ bool SupportsReleaseTime() const override;
+
+ bool IsBatchMode() const override;
+
+ char* GetNextWriteLocation(const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address) override;
+
+ WriteResult Flush() override;
+
+ void SetPacketTransportDelegate(QuartcPacketTransport::Delegate* delegate);
+
+ private:
+ // QuartcPacketWriter will not own the transport.
+ QuartcPacketTransport* packet_transport_;
+ // The maximum size of the packet can be written by this writer.
+ QuicByteCount max_packet_size_;
+
+ // Whether packets can be written.
+ bool writable_ = false;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_QUARTC_QUARTC_PACKET_WRITER_H_
