#ifndef SRC_NODE_HTTP2_H_

#define SRC_NODE_HTTP2_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

// FIXME(joyeecheung): nghttp2.h needs stdint.h to compile on Windows

#include <cstdint>

#include "nghttp2/nghttp2.h"

#include "node_http2_state.h"

#include "node_perf.h"

#include "stream_base-inl.h"

#include "string_bytes.h"

#include <algorithm>

#include <queue>

namespace node {

namespace http2 {

using v8::Array;

using v8::Context;

using v8::Isolate;

using v8::MaybeLocal;

using performance::PerformanceEntry;

// 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.

#define DEFAULT_MAX_PINGS 10

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

#define DEFAULT_MAX_SETTINGS 10

// Default maximum total memory cap for Http2Session.

#define DEFAULT_MAX_SESSION_MEMORY 1e7

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

#define DEFAULT_SETTINGS_HEADER_TABLE_SIZE 4096

#define DEFAULT_SETTINGS_ENABLE_PUSH 1

#define DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE 65535

#define DEFAULT_SETTINGS_MAX_FRAME_SIZE 16384

#define DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE 65535

#define MAX_MAX_FRAME_SIZE 16777215

#define MIN_MAX_FRAME_SIZE DEFAULT_SETTINGS_MAX_FRAME_SIZE

#define MAX_INITIAL_WINDOW_SIZE 2147483647

#define MAX_MAX_HEADER_LIST_SIZE 16777215u

#define DEFAULT_MAX_HEADER_LIST_PAIRS 128u

enum nghttp2_session_type {

  NGHTTP2_SESSION_SERVER,

  NGHTTP2_SESSION_CLIENT

};

enum nghttp2_stream_flags {

  NGHTTP2_STREAM_FLAG_NONE = 0x0,

  // Writable side has ended

  NGHTTP2_STREAM_FLAG_SHUT = 0x1,

  // Reading has started

  NGHTTP2_STREAM_FLAG_READ_START = 0x2,

  // Reading is paused

  NGHTTP2_STREAM_FLAG_READ_PAUSED = 0x4,

  // Stream is closed

  NGHTTP2_STREAM_FLAG_CLOSED = 0x8,

  // Stream is destroyed

  NGHTTP2_STREAM_FLAG_DESTROYED = 0x10,

  // Stream has trailers

  NGHTTP2_STREAM_FLAG_TRAILERS = 0x20,

  // Stream has received all the data it can

  NGHTTP2_STREAM_FLAG_EOS = 0x40

};

enum nghttp2_stream_options {

  // Stream is not going to have any DATA frames

  STREAM_OPTION_EMPTY_PAYLOAD = 0x1,

  // Stream might have trailing headers

  STREAM_OPTION_GET_TRAILERS = 0x2,

};

  WriteWrap* req_wrap = nullptr;

  uv_buf_t buf;

  void MemoryInfo(MemoryTracker* tracker) const override;

};

  nghttp2_rcbuf* name = nullptr;

  nghttp2_rcbuf* value = nullptr;

  uint8_t flags = 0;

  void MemoryInfo(MemoryTracker* tracker) const override;

};

// Unlike the HTTP/1 implementation, the HTTP/2 implementation is not limited

// to a fixed number of known supported HTTP methods. These constants, therefore

// are provided strictly as a convenience to users and are exposed via the

// require('http2').constants object.

#define HTTP_KNOWN_METHODS(V)                                                 \

  V(ACL, "ACL")                                                               \

  V(BASELINE_CONTROL, "BASELINE-CONTROL")                                     \

  V(BIND, "BIND")                                                             \

  V(CHECKIN, "CHECKIN")                                                       \

  V(CHECKOUT, "CHECKOUT")                                                     \

  V(CONNECT, "CONNECT")                                                       \

  V(COPY, "COPY")                                                             \

  V(DELETE, "DELETE")                                                         \

  V(GET, "GET")                                                               \

  V(HEAD, "HEAD")                                                             \

  V(LABEL, "LABEL")                                                           \

  V(LINK, "LINK")                                                             \

  V(LOCK, "LOCK")                                                             \

  V(MERGE, "MERGE")                                                           \

  V(MKACTIVITY, "MKACTIVITY")                                                 \

  V(MKCALENDAR, "MKCALENDAR")                                                 \

  V(MKCOL, "MKCOL")                                                           \

  V(MKREDIRECTREF, "MKREDIRECTREF")                                           \

  V(MKWORKSPACE, "MKWORKSPACE")                                               \

  V(MOVE, "MOVE")                                                             \

  V(OPTIONS, "OPTIONS")                                                       \

  V(ORDERPATCH, "ORDERPATCH")                                                 \

  V(PATCH, "PATCH")                                                           \

  V(POST, "POST")                                                             \

  V(PRI, "PRI")                                                               \

  V(PROPFIND, "PROPFIND")                                                     \

  V(PROPPATCH, "PROPPATCH")                                                   \

  V(PUT, "PUT")                                                               \

  V(REBIND, "REBIND")                                                         \

  V(REPORT, "REPORT")                                                         \

  V(SEARCH, "SEARCH")                                                         \

  V(TRACE, "TRACE")                                                           \

  V(UNBIND, "UNBIND")                                                         \

  V(UNCHECKOUT, "UNCHECKOUT")                                                 \

  V(UNLINK, "UNLINK")                                                         \

  V(UNLOCK, "UNLOCK")                                                         \

  V(UPDATE, "UPDATE")                                                         \

  V(UPDATEREDIRECTREF, "UPDATEREDIRECTREF")                                   \

  V(VERSION_CONTROL, "VERSION-CONTROL")

// These are provided strictly as a convenience to users and are exposed via the

// require('http2').constants objects

#define HTTP_KNOWN_HEADERS(V)                                                 \

  V(STATUS, ":status")                                                        \

  V(METHOD, ":method")                                                        \

  V(AUTHORITY, ":authority")                                                  \

  V(SCHEME, ":scheme")                                                        \

  V(PATH, ":path")                                                            \

  V(PROTOCOL, ":protocol")                                                    \

  V(ACCEPT_CHARSET, "accept-charset")                                         \

  V(ACCEPT_ENCODING, "accept-encoding")                                       \

  V(ACCEPT_LANGUAGE, "accept-language")                                       \

  V(ACCEPT_RANGES, "accept-ranges")                                           \

  V(ACCEPT, "accept")                                                         \

  V(ACCESS_CONTROL_ALLOW_CREDENTIALS, "access-control-allow-credentials")     \

  V(ACCESS_CONTROL_ALLOW_HEADERS, "access-control-allow-headers")             \

  V(ACCESS_CONTROL_ALLOW_METHODS, "access-control-allow-methods")             \

  V(ACCESS_CONTROL_ALLOW_ORIGIN, "access-control-allow-origin")               \

  V(ACCESS_CONTROL_EXPOSE_HEADERS, "access-control-expose-headers")           \

  V(ACCESS_CONTROL_MAX_AGE, "access-control-max-age")                         \

  V(ACCESS_CONTROL_REQUEST_HEADERS, "access-control-request-headers")         \

  V(ACCESS_CONTROL_REQUEST_METHOD, "access-control-request-method")           \

  V(AGE, "age")                                                               \

  V(ALLOW, "allow")                                                           \

  V(AUTHORIZATION, "authorization")                                           \

  V(CACHE_CONTROL, "cache-control")                                           \

  V(CONNECTION, "connection")                                                 \

  V(CONTENT_DISPOSITION, "content-disposition")                               \

  V(CONTENT_ENCODING, "content-encoding")                                     \

  V(CONTENT_LANGUAGE, "content-language")                                     \

  V(CONTENT_LENGTH, "content-length")                                         \

  V(CONTENT_LOCATION, "content-location")                                     \

  V(CONTENT_MD5, "content-md5")                                               \

  V(CONTENT_RANGE, "content-range")                                           \

  V(CONTENT_TYPE, "content-type")                                             \

  V(COOKIE, "cookie")                                                         \

  V(DATE, "date")                                                             \

  V(DNT, "dnt")                                                               \

  V(ETAG, "etag")                                                             \

  V(EXPECT, "expect")                                                         \

  V(EXPIRES, "expires")                                                       \

  V(FORWARDED, "forwarded")                                                   \

  V(FROM, "from")                                                             \

  V(HOST, "host")                                                             \

  V(IF_MATCH, "if-match")                                                     \

  V(IF_MODIFIED_SINCE, "if-modified-since")                                   \

  V(IF_NONE_MATCH, "if-none-match")                                           \

  V(IF_RANGE, "if-range")                                                     \

  V(IF_UNMODIFIED_SINCE, "if-unmodified-since")                               \

  V(LAST_MODIFIED, "last-modified")                                           \

  V(LINK, "link")                                                             \

  V(LOCATION, "location")                                                     \

  V(MAX_FORWARDS, "max-forwards")                                             \

  V(PREFER, "prefer")                                                         \

  V(PROXY_AUTHENTICATE, "proxy-authenticate")                                 \

  V(PROXY_AUTHORIZATION, "proxy-authorization")                               \

  V(RANGE, "range")                                                           \

  V(REFERER, "referer")                                                       \

  V(REFRESH, "refresh")                                                       \

  V(RETRY_AFTER, "retry-after")                                               \

  V(SERVER, "server")                                                         \

  V(SET_COOKIE, "set-cookie")                                                 \

  V(STRICT_TRANSPORT_SECURITY, "strict-transport-security")                   \

  V(TRAILER, "trailer")                                                       \

  V(TRANSFER_ENCODING, "transfer-encoding")                                   \

  V(TE, "te")                                                                 \

  V(TK, "tk")                                                                 \

  V(UPGRADE_INSECURE_REQUESTS, "upgrade-insecure-requests")                   \

  V(UPGRADE, "upgrade")                                                       \

  V(USER_AGENT, "user-agent")                                                 \

  V(VARY, "vary")                                                             \

  V(VIA, "via")                                                               \

  V(WARNING, "warning")                                                       \

  V(WWW_AUTHENTICATE, "www-authenticate")                                     \

  V(X_CONTENT_TYPE_OPTIONS, "x-content-type-options")                         \

  V(X_FRAME_OPTIONS, "x-frame-options")                                       \

  V(HTTP2_SETTINGS, "http2-settings")                                         \

  V(KEEP_ALIVE, "keep-alive")                                                 \

  V(PROXY_CONNECTION, "proxy-connection")

enum http_known_headers {

  HTTP_KNOWN_HEADER_MIN,

#define V(name, value) HTTP_HEADER_##name,

  HTTP_KNOWN_HEADERS(V)

#undef V

  HTTP_KNOWN_HEADER_MAX

};

// While some of these codes are used within the HTTP/2 implementation in

// core, they are provided strictly as a convenience to users and are exposed

// via the require('http2').constants object.

#define HTTP_STATUS_CODES(V)                                                  \

  V(CONTINUE, 100)                                                            \

  V(SWITCHING_PROTOCOLS, 101)                                                 \

  V(PROCESSING, 102)                                                          \

  V(EARLY_HINTS, 103)                                                         \

  V(OK, 200)                                                                  \

  V(CREATED, 201)                                                             \

  V(ACCEPTED, 202)                                                            \

  V(NON_AUTHORITATIVE_INFORMATION, 203)                                       \

  V(NO_CONTENT, 204)                                                          \

  V(RESET_CONTENT, 205)                                                       \

  V(PARTIAL_CONTENT, 206)                                                     \

  V(MULTI_STATUS, 207)                                                        \

  V(ALREADY_REPORTED, 208)                                                    \

  V(IM_USED, 226)                                                             \

  V(MULTIPLE_CHOICES, 300)                                                    \

  V(MOVED_PERMANENTLY, 301)                                                   \

  V(FOUND, 302)                                                               \

  V(SEE_OTHER, 303)                                                           \

  V(NOT_MODIFIED, 304)                                                        \

  V(USE_PROXY, 305)                                                           \

  V(TEMPORARY_REDIRECT, 307)                                                  \

  V(PERMANENT_REDIRECT, 308)                                                  \

  V(BAD_REQUEST, 400)                                                         \

  V(UNAUTHORIZED, 401)                                                        \

  V(PAYMENT_REQUIRED, 402)                                                    \

  V(FORBIDDEN, 403)                                                           \

  V(NOT_FOUND, 404)                                                           \

  V(METHOD_NOT_ALLOWED, 405)                                                  \

  V(NOT_ACCEPTABLE, 406)                                                      \

  V(PROXY_AUTHENTICATION_REQUIRED, 407)                                       \

  V(REQUEST_TIMEOUT, 408)                                                     \

  V(CONFLICT, 409)                                                            \

  V(GONE, 410)                                                                \

  V(LENGTH_REQUIRED, 411)                                                     \

  V(PRECONDITION_FAILED, 412)                                                 \

  V(PAYLOAD_TOO_LARGE, 413)                                                   \

  V(URI_TOO_LONG, 414)                                                        \

  V(UNSUPPORTED_MEDIA_TYPE, 415)                                              \

  V(RANGE_NOT_SATISFIABLE, 416)                                               \

  V(EXPECTATION_FAILED, 417)                                                  \

  V(TEAPOT, 418)                                                              \

  V(MISDIRECTED_REQUEST, 421)                                                 \

  V(UNPROCESSABLE_ENTITY, 422)                                                \

  V(LOCKED, 423)                                                              \

  V(FAILED_DEPENDENCY, 424)                                                   \

  V(UNORDERED_COLLECTION, 425)                                                \

  V(UPGRADE_REQUIRED, 426)                                                    \

  V(PRECONDITION_REQUIRED, 428)                                               \

  V(TOO_MANY_REQUESTS, 429)                                                   \

  V(REQUEST_HEADER_FIELDS_TOO_LARGE, 431)                                     \

  V(UNAVAILABLE_FOR_LEGAL_REASONS, 451)                                       \

  V(INTERNAL_SERVER_ERROR, 500)                                               \

  V(NOT_IMPLEMENTED, 501)                                                     \

  V(BAD_GATEWAY, 502)                                                         \

  V(SERVICE_UNAVAILABLE, 503)                                                 \

  V(GATEWAY_TIMEOUT, 504)                                                     \

  V(HTTP_VERSION_NOT_SUPPORTED, 505)                                          \

  V(VARIANT_ALSO_NEGOTIATES, 506)                                             \

  V(INSUFFICIENT_STORAGE, 507)                                                \

  V(LOOP_DETECTED, 508)                                                       \

  V(BANDWIDTH_LIMIT_EXCEEDED, 509)                                            \

  V(NOT_EXTENDED, 510)                                                        \

  V(NETWORK_AUTHENTICATION_REQUIRED, 511)

enum http_status_codes {

#define V(name, code) HTTP_STATUS_##name = code,

  HTTP_STATUS_CODES(V)

#undef V

};

// 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 padding_strategy_type {

  // 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 session_state_flags {

  SESSION_STATE_NONE = 0x0,

  SESSION_STATE_HAS_SCOPE = 0x1,

  SESSION_STATE_WRITE_SCHEDULED = 0x2,

  SESSION_STATE_CLOSED = 0x4,

  SESSION_STATE_CLOSING = 0x8,

  SESSION_STATE_SENDING = 0x10,

  SESSION_STATE_WRITE_IN_PROGRESS = 0x20,

  SESSION_STATE_READING_STOPPED = 0x40,

  SESSION_STATE_NGHTTP2_RECV_PAUSED = 0x80

};

typedef uint32_t(*get_setting)(nghttp2_session* session,

                               nghttp2_settings_id id);

class Http2Session;

class Http2Stream;

// 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:

  Http2Session* session_ = nullptr;

  Local<Object> session_handle_;

};

// 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(Environment* env, nghttp2_session_type type);

  }

  }

  }

  }

  }

  }

 private:

  nghttp2_option* options_;

  uint64_t max_session_memory_ = DEFAULT_MAX_SESSION_MEMORY;

  uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;

  padding_strategy_type padding_strategy_ = PADDING_STRATEGY_NONE;

  size_t max_outstanding_pings_ = DEFAULT_MAX_PINGS;

  size_t max_outstanding_settings_ = DEFAULT_MAX_SETTINGS;

};

class Http2Priority {

 public:

  Http2Priority(Environment* env,

                Local<Value> parent,

                Local<Value> weight,

                Local<Value> exclusive);

  }

 private:

  nghttp2_priority_spec spec;

};

 public:

  uv_buf_t OnStreamAlloc(size_t suggested_size) override;

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

};

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*();

  void EmitStatistics();

  // Required for StreamBase

  int ReadStart() override;

  // Required for StreamBase

  int ReadStop() override;

  // Required for StreamBase

  int DoShutdown(ShutdownWrap* req_wrap) override;

  // Initiate a response on this stream.

  int SubmitResponse(nghttp2_nv* nva, size_t len, int options);

  // Submit informational headers for this stream

  int SubmitInfo(nghttp2_nv* nva, size_t len);

  // Submit trailing headers for this stream

  int SubmitTrailers(nghttp2_nv* nva, size_t len);

  void OnTrailers();

  // Submit a PRIORITY frame for this stream

  int SubmitPriority(nghttp2_priority_spec* prispec, 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(

      nghttp2_nv* nva,

      size_t len,

      int32_t* ret,

      int options = 0);

  void Close(int32_t code);

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

  void Destroy();

  }

  }

  inline bool IsPaused() const {

    return flags_ & NGHTTP2_STREAM_FLAG_READ_PAUSED;

  }

  inline bool IsClosed() const {

    return flags_ & NGHTTP2_STREAM_FLAG_CLOSED;

  }

  }

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

  // the NGHTTP2_STREAM_FLAG_READ_START flag has been set and the

  // NGHTTP2_STREAM_FLAG_READ_PAUSED flag is *not* set.

  }

  // Returns the RST_STREAM code used to close this stream

  inline int32_t code() const { return code_; }

  // Returns the stream identifier for this stream

  inline void IncrementAvailableOutboundLength(size_t amount);

  inline void DecrementAvailableOutboundLength(size_t amount);

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

  }

  }

  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;

  std::string diagnostic_name() const override;

  // JavaScript API

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

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

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

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

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

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

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

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

  static void RstStream(const FunctionCallbackInfo<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;

  };

  Statistics statistics_ = {};

 private:

  Http2Stream(Http2Session* session,

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

              int32_t id,

              nghttp2_headers_category category,

              int options);

  Http2Session* session_ = nullptr;             // 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_ = NGHTTP2_STREAM_FLAG_NONE;        // 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<nghttp2_header> 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<nghttp2_stream_write> 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;

};

 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);

};

// 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,  // See below

  kSessionPriorityListenerCount,

  kSessionFrameErrorListenerCount,

  kSessionUint8FieldCount

};

enum SessionBitfieldFlags {

  kSessionHasRemoteSettingsListeners,

  kSessionRemoteSettingsIsUpToDate,

  kSessionHasPingListeners,

  kSessionHasAltsvcListeners

};

class Http2Session : public AsyncWrap, public StreamListener {

 public:

  Http2Session(Environment* env,

               Local<Object> wrap,

               nghttp2_session_type type = NGHTTP2_SESSION_SERVER);

  ~Http2Session() override;

  class Http2Ping;

  class Http2Settings;

  class MemoryAllocatorInfo;

  void EmitStatistics();

  }

  void Close(uint32_t code = NGHTTP2_NO_ERROR,

             bool socket_closed = false);

  void Consume(Local<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(nghttp2_origin_entry* ov, size_t count);

  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(

      nghttp2_priority_spec* prispec,

      nghttp2_nv* nva,

      size_t len,

      int32_t* ret,

      int options = 0);

  inline nghttp2_session_type type() const { return session_type_; }

  inline const char* TypeName() const;

  }

  // 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

  inline Http2Stream* FindStream(int32_t id);

  inline bool CanAddStream();

  // Adds a stream instance to this session

  inline void AddStream(Http2Stream* stream);

  // Removes a stream instance from this session

  inline void RemoveStream(Http2Stream* stream);

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

  bool HasWritesOnSocketForStream(Http2Stream* stream);

  // Write data from stream_buf_ to the session

  ssize_t ConsumeHTTP2Data();

    tracker->TrackFieldWithSize("pending_rst_streams",

  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;

  // The JavaScript API

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

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

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

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

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

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

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

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

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

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

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

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

  template <get_setting fn>

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

  uv_loop_t* event_loop() const {

    return env()->event_loop();

  }

  std::unique_ptr<Http2Ping> PopPing();

  Http2Ping* AddPing(std::unique_ptr<Http2Ping> ping);

  std::unique_ptr<Http2Settings> PopSettings();

  Http2Settings* AddSettings(std::unique_ptr<Http2Settings> settings);

    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;

  };

  Statistics statistics_ = {};

 private:

  // 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);

  // 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 {

    inline explicit Callbacks(bool kHasGetPaddingCallback);

    inline ~Callbacks();

    nghttp2_session_callbacks* callbacks;

  };

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

  static const Callbacks callback_struct_saved[2];

  // The underlying nghttp2_session handle

  nghttp2_session* session_;

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

  uint8_t js_fields_[kSessionUint8FieldCount] = {};

  // The session type: client or server

  nghttp2_session_type 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_ = DEFAULT_MAX_SESSION_MEMORY;

  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, Http2Stream*> streams_;

  int flags_ = SESSION_STATE_NONE;

  // The StreamBase instance being used for i/o

  padding_strategy_type padding_strategy_ = PADDING_STRATEGY_NONE;