| // Copyright 2018 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 THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_P2P_QUIC_STREAM_IMPL_H_ |
| #define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_P2P_QUIC_STREAM_IMPL_H_ |
| |
| #include "net/third_party/quic/core/quic_session.h" |
| #include "third_party/blink/renderer/modules/modules_export.h" |
| #include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream.h" |
| |
| namespace blink { |
| |
| class MODULES_EXPORT P2PQuicStreamImpl final : public P2PQuicStream, |
| public quic::QuicStream { |
| public: |
| P2PQuicStreamImpl(quic::QuicStreamId id, |
| quic::QuicSession* session, |
| uint32_t delegate_read_buffer_size, |
| uint32_t write_buffer_size); |
| ~P2PQuicStreamImpl() override; |
| // P2PQuicStream overrides |
| void SetDelegate(P2PQuicStream::Delegate* delegate) override; |
| |
| void Reset() override; |
| |
| void WriteData(std::vector<uint8_t> data, bool fin) override; |
| |
| void MarkReceivedDataConsumed(uint32_t amount) override; |
| |
| // For testing purposes. This is returns true after quic::QuicStream::OnClose |
| bool IsClosedForTesting(); |
| |
| // For testing purposes. This exposes the amount of received data that the |
| // P2PQuicStream is aware is buffered by the delegate. |
| uint32_t DelegateReadBufferedAmountForTesting(); |
| |
| // quic::QuicStream overrides. |
| // |
| // Right now this marks the data as consumed and drops it. |
| // TODO(https://crbug.com/874296): We need to update this function for |
| // reading and consuming data properly while the main JavaScript thread is |
| // busy. See: |
| // https://w3c.github.io/webrtc-quic/#dom-rtcquicstream-waitforreadable |
| void OnDataAvailable() override; |
| // Called by the quic::QuicSession when receiving a RST_STREAM frame from the |
| // remote side. This closes the stream for reading & writing (if not already |
| // closed), and sends a RST_STREAM frame if one has not been sent yet. |
| void OnStreamReset(const quic::QuicRstStreamFrame& frame) override; |
| // Called by the quic::QuicSession. This means the stream is closed for |
| // reading |
| // and writing, and can now be deleted by the quic::QuicSession. |
| void OnClose() override; |
| |
| protected: |
| // quic::QuicStream overrides. |
| // |
| // Called when written data (from WriteData()) is consumed by QUIC. This means |
| // the data has either been sent across the wire, or it has been turned into a |
| // packet and queued if the socket is unexpectedly blocked. |
| void OnStreamDataConsumed(size_t bytes_consumed) override; |
| |
| private: |
| using quic::QuicStream::Reset; |
| |
| // Outlives the P2PQuicStreamImpl. |
| Delegate* delegate_; |
| |
| // The read buffer size of the delegate. The |delegate_read_buffered_amount_| |
| // must never exceed this value (enforced by the P2PQuicStreamImpl). |
| const uint32_t delegate_read_buffer_size_; |
| // The maximum size allowed to be buffered write side. The |
| // |write_buffered_amount_| must never exceed this value, and it is up |
| // to the delegate to enforce this. |
| const uint32_t write_buffer_size_; |
| // How much total data has been received and given to the delegate, |
| // but not yet consumed by the delegate. This value gets increased when data |
| // is received from the QUIC library in OnDataAvailable() and and decreased |
| // when the delegate updates that data has been read with |
| // MarkReceivedDataConsumed(). |
| uint32_t delegate_read_buffered_amount_ = 0; |
| // How much data is buffered by the QUIC library, but has not yet |
| // been sent. This value gets increased when WriteData() is called |
| // and decreased when OnDataConsumed() gets called by the QUIC library, |
| // due to the data being sent. |
| uint32_t write_buffered_amount_ = 0; |
| |
| // Set after OnClose gets called. |
| bool closed_ = false; |
| |
| // This is set after the sequencer is closed due to the P2PQuicStream |
| // consuming all of the sequencer's data up to the FIN bit. |
| bool consumed_fin_ = false; |
| }; |
| |
| } // namespace blink |
| |
| #endif // THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_P2P_QUIC_STREAM_IMPL_H_ |