#ifndef SRC_NODE_HTTP2_H_

#define SRC_NODE_HTTP2_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

// clang-format off

#include "node.h"  // nghttp2.h needs ssize_t

// clang-format on

#include "nghttp2/nghttp2.h"

#include "env.h"

#include "aliased_struct.h"

#include "node_http2_state.h"

#include "node_http_common.h"

#include "node_mem.h"

#include "node_perf.h"

#include "stream_base.h"

#include "string_bytes.h"

#include <algorithm>

#include <queue>

namespace node {

namespace http2 {

// Constants in all caps are exported as user-facing constants

// in JavaScript. Constants using the kName pattern are internal

// only.

// We strictly limit the number of outstanding unacknowledged PINGS a user

// may send in order to prevent abuse. The current default cap is 10. The

// user may set a different limit using a per Http2Session configuration

// option.

constexpr size_t kDefaultMaxPings = 10;

// Also strictly limit the number of outstanding SETTINGS frames a user sends

constexpr size_t kDefaultMaxSettings = 10;

// Default maximum total memory cap for Http2Session.

constexpr uint64_t kDefaultMaxSessionMemory = 10000000;

// These are the standard HTTP/2 defaults as specified by the RFC

constexpr uint32_t DEFAULT_SETTINGS_HEADER_TABLE_SIZE = 4096;

constexpr uint32_t DEFAULT_SETTINGS_ENABLE_PUSH = 1;

constexpr uint32_t DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS = 0xffffffffu;

constexpr uint32_t DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE = 65535;

constexpr uint32_t DEFAULT_SETTINGS_MAX_FRAME_SIZE = 16384;

constexpr uint32_t DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE = 65535;

constexpr uint32_t DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL = 0;

constexpr uint32_t MAX_MAX_FRAME_SIZE = 16777215;

constexpr uint32_t MIN_MAX_FRAME_SIZE = DEFAULT_SETTINGS_MAX_FRAME_SIZE;

constexpr uint32_t MAX_INITIAL_WINDOW_SIZE = 2147483647;

// Stream is not going to have any DATA frames

constexpr int STREAM_OPTION_EMPTY_PAYLOAD = 0x1;

// Stream might have trailing headers

constexpr int STREAM_OPTION_GET_TRAILERS = 0x2;

// Http2Stream internal states

constexpr int kStreamStateNone = 0x0;

constexpr int kStreamStateShut = 0x1;

constexpr int kStreamStateReadStart = 0x2;

constexpr int kStreamStateReadPaused = 0x4;

constexpr int kStreamStateClosed = 0x8;

constexpr int kStreamStateDestroyed = 0x10;

constexpr int kStreamStateTrailers = 0x20;

// Http2Session internal states

constexpr int kSessionStateNone = 0x0;

constexpr int kSessionStateHasScope = 0x1;

constexpr int kSessionStateWriteScheduled = 0x2;

constexpr int kSessionStateClosed = 0x4;

constexpr int kSessionStateClosing = 0x8;

constexpr int kSessionStateSending = 0x10;

constexpr int kSessionStateWriteInProgress = 0x20;

constexpr int kSessionStateReadingStopped = 0x40;

constexpr int kSessionStateReceivePaused = 0x80;

// The Padding Strategy determines the method by which extra padding is

// selected for HEADERS and DATA frames. These are configurable via the

// options passed in to a Http2Session object.

enum PaddingStrategy {

  // No padding strategy. This is the default.

  PADDING_STRATEGY_NONE,

  // Attempts to ensure that the frame is 8-byte aligned

  PADDING_STRATEGY_ALIGNED,

  // Padding will ensure all data frames are maxFrameSize

  PADDING_STRATEGY_MAX,

  // Removed and turned into an alias because it is unreasonably expensive for

  // very little benefit.

  PADDING_STRATEGY_CALLBACK = PADDING_STRATEGY_ALIGNED

};

enum SessionType {

  NGHTTP2_SESSION_SERVER,

  NGHTTP2_SESSION_CLIENT

};

template <typename T, void(*fn)(T*)>

struct Nghttp2Deleter {

};

using Nghttp2OptionPointer =

    std::unique_ptr<nghttp2_option,

                    Nghttp2Deleter<nghttp2_option, nghttp2_option_del>>;

using Nghttp2SessionPointer =

    std::unique_ptr<nghttp2_session,

                    Nghttp2Deleter<nghttp2_session, nghttp2_session_del>>;

using Nghttp2SessionCallbacksPointer =

    std::unique_ptr<nghttp2_session_callbacks,

                    Nghttp2Deleter<nghttp2_session_callbacks,

                                   nghttp2_session_callbacks_del>>;

struct Http2HeadersTraits {

  typedef nghttp2_nv nv_t;

};

struct Http2RcBufferPointerTraits {

  typedef nghttp2_rcbuf rcbuf_t;

  typedef nghttp2_vec vector_t;

  }

  }

};

using Http2Headers = NgHeaders<Http2HeadersTraits>;

using Http2RcBufferPointer = NgRcBufPointer<Http2RcBufferPointerTraits>;

struct NgHttp2StreamWrite : public MemoryRetainer {

  BaseObjectPtr<AsyncWrap> req_wrap;

  uv_buf_t buf;

  void MemoryInfo(MemoryTracker* tracker) const override;

};

typedef uint32_t(*get_setting)(nghttp2_session* session,

                               nghttp2_settings_id id);

class Http2Ping;

class Http2Session;

class Http2Settings;

class Http2Stream;

class Origins;

// This scope should be present when any call into nghttp2 that may schedule

// data to be written to the underlying transport is made, and schedules

// such a write automatically once the scope is exited.

class Http2Scope {

 public:

  explicit Http2Scope(Http2Stream* stream);

  explicit Http2Scope(Http2Session* session);

  ~Http2Scope();

 private:

  BaseObjectPtr<Http2Session> session_;

};

// The Http2Options class is used to parse the options object passed in to

// a Http2Session object and convert those into an appropriate nghttp2_option

// struct. This is the primary mechanism by which the Http2Session object is

// configured.

class Http2Options {

 public:

  Http2Options(Http2State* http2_state,

               SessionType type);

  }

  }

  }

  }

  }

  }

 private:

  Nghttp2OptionPointer options_;

  uint64_t max_session_memory_ = kDefaultMaxSessionMemory;

  uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;

  PaddingStrategy padding_strategy_ = PADDING_STRATEGY_NONE;

  size_t max_outstanding_pings_ = kDefaultMaxPings;

  size_t max_outstanding_settings_ = kDefaultMaxSettings;

};

struct Http2Priority : public nghttp2_priority_spec {

  Http2Priority(Environment* env,

                v8::Local<v8::Value> parent,

                v8::Local<v8::Value> weight,

                v8::Local<v8::Value> exclusive);

};

class Http2StreamListener : public StreamListener {

 public:

  uv_buf_t OnStreamAlloc(size_t suggested_size) override;

  void OnStreamRead(ssize_t nread, const uv_buf_t& buf) override;

};

struct Http2HeaderTraits {

  typedef Http2RcBufferPointer rcbufferpointer_t;

  typedef Http2Session allocator_t;

  // HTTP/2 does not support identifying header names by token id.

  // HTTP/3 will, however, so we prepare for that now.

};

using Http2Header = NgHeader<Http2HeaderTraits>;

class Http2Stream : public AsyncWrap,

                    public StreamBase {

 public:

  static Http2Stream* New(

      Http2Session* session,

      int32_t id,

      nghttp2_headers_category category = NGHTTP2_HCAT_HEADERS,

      int options = 0);

  ~Http2Stream() override;

  nghttp2_stream* operator*() const;

  nghttp2_stream* stream() const;

  // Required for StreamBase

  int ReadStart() override;

  // Required for StreamBase

  int ReadStop() override;

  // Required for StreamBase

  ShutdownWrap* CreateShutdownWrap(v8::Local<v8::Object> object) override;

  int DoShutdown(ShutdownWrap* req_wrap) override;

  // Initiate a response on this stream.

  int SubmitResponse(const Http2Headers& headers, int options);

  // Submit informational headers for this stream

  int SubmitInfo(const Http2Headers& headers);

  // Submit trailing headers for this stream

  int SubmitTrailers(const Http2Headers& headers);

  void OnTrailers();

  // Submit a PRIORITY frame for this stream

  int SubmitPriority(const Http2Priority& priority, bool silent = false);

  // Submits an RST_STREAM frame using the given code

  void SubmitRstStream(const uint32_t code);

  void FlushRstStream();

  // Submits a PUSH_PROMISE frame with this stream as the parent.

  Http2Stream* SubmitPushPromise(

      const Http2Headers& headers,

      int32_t* ret,

      int options = 0);

  void Close(int32_t code);

  // Destroy this stream instance and free all held memory.

  void Destroy();

  }

  }

  }

  bool is_closed() const {

    return flags_ & kStreamStateClosed;

  }

  }

    else

    } else {}

    else

  // Returns true if this stream is in the reading state, which occurs when

  // the kStreamStateReadStart flag has been set and the

  // kStreamStateReadPaused flag is *not* set.

  }

  // Returns the RST_STREAM code used to close this stream

  int32_t code() const { return code_; }

  // Returns the stream identifier for this stream

  void IncrementAvailableOutboundLength(size_t amount);

  void DecrementAvailableOutboundLength(size_t amount);

  bool AddHeader(nghttp2_rcbuf* name, nghttp2_rcbuf* value, uint8_t flags);

  template <typename Fn>

  }

  }

  void StartHeaders(nghttp2_headers_category category);

  // Required for StreamBase

  }

  // Required for StreamBase

  }

  int DoWrite(WriteWrap* w, uv_buf_t* bufs, size_t count,

              uv_stream_t* send_handle) override;

  void MemoryInfo(MemoryTracker* tracker) const override;

  std::string diagnostic_name() const override;

  // JavaScript API

  static void GetID(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Priority(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void PushPromise(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void RefreshState(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Info(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Trailers(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Respond(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void RstStream(const v8::FunctionCallbackInfo<v8::Value>& args);

  class Provider;

  struct Statistics {

    uint64_t start_time;

    uint64_t end_time;

    uint64_t first_header;     // Time first header was received

    uint64_t first_byte;       // Time first DATA frame byte was received

    uint64_t first_byte_sent;  // Time first DATA frame byte was sent

    uint64_t sent_bytes;

    uint64_t received_bytes;

    uint64_t id;

  };

  Statistics statistics_ = {};

 private:

  Http2Stream(Http2Session* session,

              v8::Local<v8::Object> obj,

              int32_t id,

              nghttp2_headers_category category,

              int options);

  void EmitStatistics();

  BaseObjectWeakPtr<Http2Session> session_;     // The Parent HTTP/2 Session

  int32_t id_ = 0;                              // The Stream Identifier

  int32_t code_ = NGHTTP2_NO_ERROR;             // The RST_STREAM code (if any)

  int flags_ = kStreamStateNone;        // Internal state flags

  uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;

  uint32_t max_header_length_ = DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE;

  // The Current Headers block... As headers are received for this stream,

  // they are temporarily stored here until the OnFrameReceived is called

  // signalling the end of the HEADERS frame

  nghttp2_headers_category current_headers_category_ = NGHTTP2_HCAT_HEADERS;

  uint32_t current_headers_length_ = 0;  // total number of octets

  std::vector<Http2Header> current_headers_;

  // This keeps track of the amount of data read from the socket while the

  // socket was in paused mode. When `ReadStart()` is called (and not before

  // then), we tell nghttp2 that we consumed that data to get proper

  // backpressure handling.

  size_t inbound_consumed_data_while_paused_ = 0;

  // Outbound Data... This is the data written by the JS layer that is

  // waiting to be written out to the socket.

  std::queue<NgHttp2StreamWrite> queue_;

  size_t available_outbound_length_ = 0;

  Http2StreamListener stream_listener_;

  friend class Http2Session;

};

class Http2Stream::Provider {

 public:

  Provider(Http2Stream* stream, int options);

  explicit Provider(int options);

  virtual ~Provider();

  }

  class FD;

  class Stream;

 protected:

  nghttp2_data_provider provider_;

 private:

  bool empty_ = false;

};

class Http2Stream::Provider::Stream : public Http2Stream::Provider {

 public:

  Stream(Http2Stream* stream, int options);

  explicit Stream(int options);

  static ssize_t OnRead(nghttp2_session* session,

                        int32_t id,

                        uint8_t* buf,

                        size_t length,

                        uint32_t* flags,

                        nghttp2_data_source* source,

                        void* user_data);

};

struct SessionJSFields {

  uint8_t bitfield;

  uint8_t priority_listener_count;

  uint8_t frame_error_listener_count;

  uint32_t max_invalid_frames = 1000;

  uint32_t max_rejected_streams = 100;

};

// Indices for js_fields_, which serves as a way to communicate data with JS

// land fast. In particular, we store information about the number/presence

// of certain event listeners in JS, and skip calls from C++ into JS if they

// are missing.

enum SessionUint8Fields {

  kBitfield = offsetof(SessionJSFields, bitfield),  // See below

  kSessionPriorityListenerCount =

      offsetof(SessionJSFields, priority_listener_count),

  kSessionFrameErrorListenerCount =

      offsetof(SessionJSFields, frame_error_listener_count),

  kSessionMaxInvalidFrames = offsetof(SessionJSFields, max_invalid_frames),

  kSessionMaxRejectedStreams = offsetof(SessionJSFields, max_rejected_streams),

  kSessionUint8FieldCount = sizeof(SessionJSFields)

};

enum SessionBitfieldFlags {

  kSessionHasRemoteSettingsListeners,

  kSessionRemoteSettingsIsUpToDate,

  kSessionHasPingListeners,

  kSessionHasAltsvcListeners

};

class Http2Session : public AsyncWrap,

                     public StreamListener,

                     public mem::NgLibMemoryManager<Http2Session, nghttp2_mem> {

 public:

  Http2Session(Http2State* http2_state,

               v8::Local<v8::Object> wrap,

               SessionType type = NGHTTP2_SESSION_SERVER);

  ~Http2Session() override;

  }

  void Close(uint32_t code = NGHTTP2_NO_ERROR,

             bool socket_closed = false);

  void Consume(v8::Local<v8::Object> stream);

  void Goaway(uint32_t code, int32_t lastStreamID,

              const uint8_t* data, size_t len);

  void AltSvc(int32_t id,

              uint8_t* origin,

              size_t origin_len,

              uint8_t* value,

              size_t value_len);

  void Origin(const Origins& origins);

  uint8_t SendPendingData();

  // Submits a new request. If the request is a success, assigned

  // will be a pointer to the Http2Stream instance assigned.

  // This only works if the session is a client session.

  Http2Stream* SubmitRequest(

      const Http2Priority& priority,

      const Http2Headers& headers,

      int32_t* ret,

      int options = 0);

  SessionType type() const { return session_type_; }

  nghttp2_session* operator*() { return session_.get(); }

  const char* TypeName() const;

  }

#define IS_FLAG(name, flag)                                                    \

  bool is_##name() const { return flags_ & flag; }                             \

  void set_##name(bool on = true) {                                            \

    if (on)                                                                    \

      flags_ |= flag;                                                          \

    else                                                                       \

      flags_ &= ~flag;                                                         \

  }

#undef IS_FLAG

  // Schedule a write if nghttp2 indicates it wants to write to the socket.

  void MaybeScheduleWrite();

  // Stop reading if nghttp2 doesn't want to anymore.

  void MaybeStopReading();

  // Returns pointer to the stream, or nullptr if stream does not exist

  BaseObjectPtr<Http2Stream> FindStream(int32_t id);

  bool CanAddStream();

  // Adds a stream instance to this session

  void AddStream(Http2Stream* stream);

  // Removes a stream instance from this session

  BaseObjectPtr<Http2Stream> RemoveStream(int32_t id);

  // Indicates whether there currently exist outgoing buffers for this stream.

  bool HasWritesOnSocketForStream(Http2Stream* stream);

  // Write data from stream_buf_ to the session.

  // This will call the error callback if an error occurs.

  void ConsumeHTTP2Data();

  void MemoryInfo(MemoryTracker* tracker) const override;

  std::string diagnostic_name() const override;

  // Schedule an RstStream for after the current write finishes.

            pending_rst_streams_.end(),

  }

  // Handle reads/writes from the underlying network transport.

  uv_buf_t OnStreamAlloc(size_t suggested_size) override;

  void OnStreamRead(ssize_t nread, const uv_buf_t& buf) override;

  void OnStreamAfterWrite(WriteWrap* w, int status) override;

  // Implementation for mem::NgLibMemoryManager

  void CheckAllocatedSize(size_t previous_size) const;

  void IncreaseAllocatedSize(size_t size);

  void DecreaseAllocatedSize(size_t size);

  // The JavaScript API

  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Consume(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Receive(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Settings(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Request(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void SetNextStreamID(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void SetLocalWindowSize(

      const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Goaway(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void UpdateChunksSent(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void RefreshState(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Ping(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void AltSvc(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Origin(const v8::FunctionCallbackInfo<v8::Value>& args);

  template <get_setting fn>

  static void RefreshSettings(const v8::FunctionCallbackInfo<v8::Value>& args);

  uv_loop_t* event_loop() const {

    return env()->event_loop();

  }

  BaseObjectPtr<Http2Ping> PopPing();

  bool AddPing(const uint8_t* data, v8::Local<v8::Function> callback);

  BaseObjectPtr<Http2Settings> PopSettings();

  bool AddSettings(v8::Local<v8::Function> callback);

    DCHECK_LE(amount, current_session_memory_);

  // Tell our custom memory allocator that this rcbuf is independent of

  // this session now, and may outlive it.

  void StopTrackingRcbuf(nghttp2_rcbuf* buf);

  // Returns the current session memory including memory allocated by nghttp2,

  // the current outbound storage queue, and pending writes.

  }

  // Return true if current_session_memory + amount is less than the max

  }

  struct Statistics {

    uint64_t start_time;

    uint64_t end_time;

    uint64_t ping_rtt;

    uint64_t data_sent;

    uint64_t data_received;

    uint32_t frame_count;

    uint32_t frame_sent;

    int32_t stream_count;

    size_t max_concurrent_streams;

    double stream_average_duration;

    SessionType session_type;

  };

  Statistics statistics_ = {};

 private:

  void EmitStatistics();

  // Frame Padding Strategies

  ssize_t OnDWordAlignedPadding(size_t frameLength,

                                size_t maxPayloadLen);

  ssize_t OnMaxFrameSizePadding(size_t frameLength,

                                size_t maxPayloadLen);

  // Frame Handler

  int HandleDataFrame(const nghttp2_frame* frame);

  void HandleGoawayFrame(const nghttp2_frame* frame);

  void HandleHeadersFrame(const nghttp2_frame* frame);

  void HandlePriorityFrame(const nghttp2_frame* frame);

  void HandleSettingsFrame(const nghttp2_frame* frame);

  void HandlePingFrame(const nghttp2_frame* frame);

  void HandleAltSvcFrame(const nghttp2_frame* frame);

  void HandleOriginFrame(const nghttp2_frame* frame);

  void DecrefHeaders(const nghttp2_frame* frame);

  // nghttp2 callbacks

  static int OnBeginHeadersCallback(

      nghttp2_session* session,

      const nghttp2_frame* frame,

      void* user_data);

  static int OnHeaderCallback(

      nghttp2_session* session,

      const nghttp2_frame* frame,

      nghttp2_rcbuf* name,

      nghttp2_rcbuf* value,

      uint8_t flags,

      void* user_data);

  static int OnFrameReceive(

      nghttp2_session* session,

      const nghttp2_frame* frame,

      void* user_data);

  static int OnFrameNotSent(

      nghttp2_session* session,

      const nghttp2_frame* frame,

      int error_code,

      void* user_data);

  static int OnFrameSent(

      nghttp2_session* session,

      const nghttp2_frame* frame,

      void* user_data);

  static int OnStreamClose(

      nghttp2_session* session,

      int32_t id,

      uint32_t code,

      void* user_data);

  static int OnInvalidHeader(

      nghttp2_session* session,

      const nghttp2_frame* frame,

      nghttp2_rcbuf* name,

      nghttp2_rcbuf* value,

      uint8_t flags,

      void* user_data);

  static int OnDataChunkReceived(

      nghttp2_session* session,

      uint8_t flags,

      int32_t id,

      const uint8_t* data,

      size_t len,

      void* user_data);

  static ssize_t OnSelectPadding(

      nghttp2_session* session,

      const nghttp2_frame* frame,

      size_t maxPayloadLen,

      void* user_data);

  static int OnNghttpError(

      nghttp2_session* session,

      const char* message,

      size_t len,

      void* user_data);

  static int OnSendData(

      nghttp2_session* session,

      nghttp2_frame* frame,

      const uint8_t* framehd,

      size_t length,

      nghttp2_data_source* source,

      void* user_data);

  static int OnInvalidFrame(

      nghttp2_session* session,

      const nghttp2_frame* frame,

      int lib_error_code,

      void* user_data);

  struct Callbacks {

    explicit Callbacks(bool kHasGetPaddingCallback);

    Nghttp2SessionCallbacksPointer callbacks;

  };

  /* Use callback_struct_saved[kHasGetPaddingCallback ? 1 : 0] */

  static const Callbacks callback_struct_saved[2];

  // The underlying nghttp2_session handle

  Nghttp2SessionPointer session_;

  // JS-accessible numeric fields, as indexed by SessionUint8Fields.

  AliasedStruct<SessionJSFields> js_fields_;

  // The session type: client or server

  SessionType session_type_;

  // The maximum number of header pairs permitted for streams on this session

  uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;

  // The maximum amount of memory allocated for this session

  uint64_t max_session_memory_ = kDefaultMaxSessionMemory;

  uint64_t current_session_memory_ = 0;

  // The amount of memory allocated by nghttp2 internals

  uint64_t current_nghttp2_memory_ = 0;

  // The collection of active Http2Streams associated with this session

  std::unordered_map<int32_t, BaseObjectPtr<Http2Stream>> streams_;

  int flags_ = kSessionStateNone;

  // The StreamBase instance being used for i/o

  PaddingStrategy padding_strategy_ = PADDING_STRATEGY_NONE;

  // use this to allow timeout tracking during long-lasting writes

  uint32_t chunks_sent_since_last_write_ = 0;

  uv_buf_t stream_buf_ = uv_buf_init(nullptr, 0);

  // When processing input data, either stream_buf_ab_ or stream_buf_allocation_

  // will be set. stream_buf_ab_ is lazily created from stream_buf_allocation_.

  v8::Global<v8::ArrayBuffer> stream_buf_ab_;

  std::unique_ptr<v8::BackingStore> stream_buf_allocation_;

  size_t stream_buf_offset_ = 0;

  // Custom error code for errors that originated inside one of the callbacks

  // called by nghttp2_session_mem_recv.

  const char* custom_recv_error_code_ = nullptr;

  size_t max_outstanding_pings_ = kDefaultMaxPings;

  std::queue<BaseObjectPtr<Http2Ping>> outstanding_pings_;

  size_t max_outstanding_settings_ = kDefaultMaxSettings;

  std::queue<BaseObjectPtr<Http2Settings>> outstanding_settings_;

  std::vector<NgHttp2StreamWrite> outgoing_buffers_;

  std::vector<uint8_t> outgoing_storage_;

  size_t outgoing_length_ = 0;

  std::vector<int32_t> pending_rst_streams_;

  // Count streams that have been rejected while being opened. Exceeding a fixed

  // limit will result in the session being destroyed, as an indication of a

  // misbehaving peer. This counter is reset once new streams are being

  // accepted again.

  uint32_t rejected_stream_count_ = 0;

  // Also use the invalid frame count as a measure for rejecting input frames.

  uint32_t invalid_frame_count_ = 0;

  void PushOutgoingBuffer(NgHttp2StreamWrite&& write);

  BaseObjectPtr<Http2State> http2_state_;

  void CopyDataIntoOutgoing(const uint8_t* src, size_t src_length);

  void ClearOutgoing(int status);

  friend class Http2Scope;

  friend class Http2StreamListener;

};

struct Http2SessionPerformanceEntryTraits {

  static constexpr performance::PerformanceEntryType kType =

      performance::NODE_PERFORMANCE_ENTRY_TYPE_HTTP2;

  using Details = Http2Session::Statistics;

  static v8::MaybeLocal<v8::Object> GetDetails(

      Environment* env,

      const performance::PerformanceEntry<Http2SessionPerformanceEntryTraits>&

          entry);

};

struct Http2StreamPerformanceEntryTraits {

  static constexpr performance::PerformanceEntryType kType =

      performance::NODE_PERFORMANCE_ENTRY_TYPE_HTTP2;

  using Details = Http2Stream::Statistics;

  static v8::MaybeLocal<v8::Object> GetDetails(

      Environment* env,

      const performance::PerformanceEntry<Http2StreamPerformanceEntryTraits>&

          entry);

};

using Http2SessionPerformanceEntry =

    performance::PerformanceEntry<Http2SessionPerformanceEntryTraits>;

using Http2StreamPerformanceEntry =

    performance::PerformanceEntry<Http2StreamPerformanceEntryTraits>;

class Http2Ping : public AsyncWrap {

 public:

  explicit Http2Ping(

      Http2Session* session,

      v8::Local<v8::Object> obj,

      v8::Local<v8::Function> callback);

  void MemoryInfo(MemoryTracker* tracker) const override;

  void Send(const uint8_t* payload);

  void Done(bool ack, const uint8_t* payload = nullptr);

  void DetachFromSession();

  v8::Local<v8::Function> callback() const;

 private:

  BaseObjectWeakPtr<Http2Session> session_;

  v8::Global<v8::Function> callback_;