diff --git a/doc/api/errors.md b/doc/api/errors.md
index 776639d2e4cb3f..918cfa343136af 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -810,6 +810,11 @@ Status code was outside the regular status code range (100-999).
 The `Trailer` header was set even though the transfer encoding does not support
 that.
 
+<a id="ERR_HTTP2_ALREADY_SHUTDOWN"></a>
+### ERR_HTTP2_ALREADY_SHUTDOWN
+
+Occurs with multiple attempts to shutdown an HTTP/2 session.
+
 <a id="ERR_HTTP2_CONNECT_AUTHORITY"></a>
 ### ERR_HTTP2_CONNECT_AUTHORITY
 
@@ -833,6 +838,12 @@ forbidden.
 
 A failure occurred sending an individual frame on the HTTP/2 session.
 
+<a id="ERR_HTTP2_GOAWAY_SESSION"></a>
+### ERR_HTTP2_GOAWAY_SESSION
+
+New HTTP/2 Streams may not be opened after the `Http2Session` has received a
+`GOAWAY` frame from the connected peer.
+
 <a id="ERR_HTTP2_HEADER_REQUIRED"></a>
 ### ERR_HTTP2_HEADER_REQUIRED
 
@@ -972,6 +983,11 @@ client.
 An attempt was made to use the `Http2Stream.prototype.responseWithFile()` API to
 send something other than a regular file.
 
+<a id="ERR_HTTP2_SESSION_ERROR"></a>
+### ERR_HTTP2_SESSION_ERROR
+
+The `Http2Session` closed with a non-zero error code.
+
 <a id="ERR_HTTP2_SOCKET_BOUND"></a>
 ### ERR_HTTP2_SOCKET_BOUND
 
@@ -989,10 +1005,11 @@ Use of the `101` Informational status code is forbidden in HTTP/2.
 An invalid HTTP status code has been specified. Status codes must be an integer
 between `100` and `599` (inclusive).
 
-<a id="ERR_HTTP2_STREAM_CLOSED"></a>
-### ERR_HTTP2_STREAM_CLOSED
+<a id="ERR_HTTP2_STREAM_CANCEL"></a>
+### ERR_HTTP2_STREAM_CANCEL
 
-An action was performed on an HTTP/2 Stream that had already been closed.
+An `Http2Stream` was destroyed before any data was transmitted to the connected
+peer.
 
 <a id="ERR_HTTP2_STREAM_ERROR"></a>
 ### ERR_HTTP2_STREAM_ERROR
diff --git a/doc/api/http2.md b/doc/api/http2.md
index 6b92f76a1becf9..8facdf465b2db7 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -67,8 +67,8 @@ const fs = require('fs');
 const client = http2.connect('https://localhost:8443', {
   ca: fs.readFileSync('localhost-cert.pem')
 });
-client.on('socketError', (err) => console.error(err));
 client.on('error', (err) => console.error(err));
+client.on('socketError', (err) => console.error(err));
 
 const req = client.request({ ':path': '/' });
 
@@ -83,7 +83,7 @@ let data = '';
 req.on('data', (chunk) => { data += chunk; });
 req.on('end', () => {
   console.log(`\n${data}`);
-  client.destroy();
+  client.close();
 });
 req.end();
 ```
@@ -127,7 +127,7 @@ solely on the API of the `Http2Session`.
 added: v8.4.0
 -->
 
-The `'close'` event is emitted once the `Http2Session` has been terminated.
+The `'close'` event is emitted once the `Http2Session` has been destroyed.
 
 #### Event: 'connect'
 <!-- YAML
@@ -234,19 +234,13 @@ of the stream.
 
 ```js
 const http2 = require('http2');
-const {
-  HTTP2_HEADER_METHOD,
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_STATUS,
-  HTTP2_HEADER_CONTENT_TYPE
-} = http2.constants;
 session.on('stream', (stream, headers, flags) => {
-  const method = headers[HTTP2_HEADER_METHOD];
-  const path = headers[HTTP2_HEADER_PATH];
+  const method = headers[':method'];
+  const path = headers[':path'];
   // ...
   stream.respond({
-    [HTTP2_HEADER_STATUS]: 200,
-    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+    ':status': 200,
+    'content-type': 'text/plain'
   });
   stream.write('hello ');
   stream.end('world');
@@ -275,19 +269,6 @@ server.on('stream', (stream, headers) => {
 server.listen(80);
 ```
 
-#### Event: 'socketError'
-<!-- YAML
-added: v8.4.0
--->
-
-The `'socketError'` event is emitted when an `'error'` is emitted on the
-`Socket` instance bound to the `Http2Session`. If this event is not handled,
-the `'error'` event will be re-emitted on the `Socket`.
-
-For `ServerHttp2Session` instances, a `'socketError'` event listener is always
-registered that will, by default, forward the event on to the owning
-`Http2Server` instance if no additional handlers are registered.
-
 #### Event: 'timeout'
 <!-- YAML
 added: v8.4.0
@@ -302,16 +283,53 @@ session.setTimeout(2000);
 session.on('timeout', () => { /** .. **/ });
 ```
 
-#### http2session.destroy()
+#### http2session.close([callback])
+<!-- YAML
+added: REPLACEME
+-->
+
+* `callback` {Function}
+
+Gracefully closes the `Http2Session`, allowing any existing streams to
+complete on their own and preventing new `Http2Stream` instances from being
+created. Once closed, `http2session.destroy()` *might* be called if there
+are no open `Http2Stream` instances.
+
+If specified, the `callback` function is registered as a handler for the
+`'close'` event.
+
+#### http2session.closed
+<!-- YAML
+added: REPLACEME
+-->
+
+* Value: {boolean}
+
+Will be `true` if this `Http2Session` instance has been closed, otherwise
+`false`.
+
+#### http2session.destroy([error,][code])
 <!-- YAML
 added: v8.4.0
 -->
 
+* `error` {Error} An `Error` object if the `Http2Session` is being destroyed
+  due to an error.
+* `code` {number} The HTTP/2 error code to send in the final `GOAWAY` frame.
+  If unspecified, and `error` is not undefined, the default is `INTERNAL_ERROR`,
+  otherwise defaults to `NO_ERROR`.
 * Returns: {undefined}
 
 Immediately terminates the `Http2Session` and the associated `net.Socket` or
 `tls.TLSSocket`.
 
+Once destroyed, the `Http2Session` will emit the `'close'` event. If `error`
+is not undefined, an `'error'` event will be emitted immediately after the
+`'close'` event.
+
+If there are any remaining open `Http2Streams` associatd with the
+`Http2Session`, those will also be destroyed.
+
 #### http2session.destroyed
 <!-- YAML
 added: v8.4.0
@@ -322,6 +340,19 @@ added: v8.4.0
 Will be `true` if this `Http2Session` instance has been destroyed and must no
 longer be used, otherwise `false`.
 
+#### http2session.goaway([code, [lastStreamID, [opaqueData]]])
+<!-- YAML
+added: REPLACEME
+-->
+
+* `code` {number} An HTTP/2 error code
+* `lastStreamID` {number} The numeric ID of the last processed `Http2Stream`
+* `opaqueData` {Buffer|TypedArray|DataView} A `TypedArray` or `DataView`
+  instance containing additional data to be carried within the GOAWAY frame.
+
+Transmits a `GOAWAY` frame to the connected peer *without* shutting down the
+`Http2Session`.
+
 #### http2session.localSettings
 <!-- YAML
 added: v8.4.0
@@ -449,6 +480,12 @@ the trailing header fields to send to the peer.
 will be emitted if the `getTrailers` callback attempts to set such header
 fields.
 
+The the `:method` and `:path` pseudoheaders are not specified within `headers`,
+they respectively default to:
+
+* `:method` = `'GET'`
+* `:path` = `/`
+
 #### http2session.setTimeout(msecs, callback)
 <!-- YAML
 added: v8.4.0
@@ -462,19 +499,18 @@ Used to set a callback function that is called when there is no activity on
 the `Http2Session` after `msecs` milliseconds. The given `callback` is
 registered as a listener on the `'timeout'` event.
 
-#### http2session.shutdown(options[, callback])
+#### http2session.close(options[, callback])
 <!-- YAML
 added: v8.4.0
 -->
 
 * `options` {Object}
-  * `graceful` {boolean} `true` to attempt a polite shutdown of the
-    `Http2Session`.
   * `errorCode` {number} The HTTP/2 [error code][] to return. Note that this is
     *not* the same thing as an HTTP Response Status Code. **Default:** `0x00`
     (No Error).
   * `lastStreamID` {number} The Stream ID of the last successfully processed
-    `Http2Stream` on this `Http2Session`.
+    `Http2Stream` on this `Http2Session`. If unspecified, will default to the
+    ID of the most recently received stream.
   * `opaqueData` {Buffer|Uint8Array} A `Buffer` or `Uint8Array` instance
     containing arbitrary additional data to send to the peer upon disconnection.
     This is used, typically, to provide additional data for debugging failures,
@@ -487,19 +523,16 @@ Attempts to shutdown this `Http2Session` using HTTP/2 defined procedures.
 If specified, the given `callback` function will be invoked once the shutdown
 process has completed.
 
-Note that calling `http2session.shutdown()` does *not* destroy the session or
-tear down the `Socket` connection. It merely prompts both sessions to begin
-preparing to cease activity.
-
-During a "graceful" shutdown, the session will first send a `GOAWAY` frame to
-the connected peer identifying the last processed stream as 2<sup>32</sup>-1.
+If the `Http2Session` instance is a server-side session and the `errorCode`
+option is `0x00` (No Error), a "graceful" shutdown will be initiated. During a
+"graceful" shutdown, the session will first send a `GOAWAY` frame to
+the connected peer identifying the last processed stream as 2<sup>31</sup>-1.
 Then, on the next tick of the event loop, a second `GOAWAY` frame identifying
 the most recently processed stream identifier is sent. This process allows the
 remote peer to begin preparing for the connection to be terminated.
 
 ```js
-session.shutdown({
-  graceful: true,
+session.close({
   opaqueData: Buffer.from('add some debugging data here')
 }, () => session.destroy());
 ```
@@ -627,7 +660,7 @@ is not yet ready for use.
 All [`Http2Stream`][] instances are destroyed either when:
 
 * An `RST_STREAM` frame for the stream is received by the connected peer.
-* The `http2stream.rstStream()` methods is called.
+* The `http2stream.close()` method is called.
 * The `http2stream.destroy()` or `http2session.destroy()` methods are called.
 
 When an `Http2Stream` instance is destroyed, an attempt will be made to send an
@@ -720,6 +753,29 @@ added: v8.4.0
 Set to `true` if the `Http2Stream` instance was aborted abnormally. When set,
 the `'aborted'` event will have been emitted.
 
+#### http2stream.close(code[, callback])
+<!-- YAML
+added: v8.4.0
+-->
+
+* code {number} Unsigned 32-bit integer identifying the error code. **Default:**
+  `http2.constant.NGHTTP2_NO_ERROR` (`0x00`)
+* `callback` {Function} An optional function registered to listen for the
+  `'close'` event.
+* Returns: {undefined}
+
+Closes the `Http2Stream` instance by sending an `RST_STREAM` frame to the
+connected HTTP/2 peer.
+
+#### http2stream.closed
+<!-- YAML
+added: REPLACEME
+-->
+
+* Value: {boolean}
+
+Set to `true` if the `Http2Stream` instance has been closed.
+
 #### http2stream.destroyed
 <!-- YAML
 added: v8.4.0
@@ -730,6 +786,16 @@ added: v8.4.0
 Set to `true` if the `Http2Stream` instance has been destroyed and is no longer
 usable.
 
+#### http2stream.pending
+<!-- YAML
+added: REPLACEME
+-->
+
+* Value: {boolean}
+
+Set to `true` if the `Http2Stream` instance has not yet been assigned a
+numeric stream identifier.
+
 #### http2stream.priority(options)
 <!-- YAML
 added: v8.4.0
@@ -760,66 +826,9 @@ added: v8.4.0
 
 Set to the `RST_STREAM` [error code][] reported when the `Http2Stream` is
 destroyed after either receiving an `RST_STREAM` frame from the connected peer,
-calling `http2stream.rstStream()`, or `http2stream.destroy()`. Will be
+calling `http2stream.close()`, or `http2stream.destroy()`. Will be
 `undefined` if the `Http2Stream` has not been closed.
 
-#### http2stream.rstStream(code)
-<!-- YAML
-added: v8.4.0
--->
-
-* code {number} Unsigned 32-bit integer identifying the error code. **Default:**
-  `http2.constant.NGHTTP2_NO_ERROR` (`0x00`)
-* Returns: {undefined}
-
-Sends an `RST_STREAM` frame to the connected HTTP/2 peer, causing this
-`Http2Stream` to be closed on both sides using [error code][] `code`.
-
-#### http2stream.rstWithNoError()
-<!-- YAML
-added: v8.4.0
--->
-
-* Returns: {undefined}
-
-Shortcut for `http2stream.rstStream()` using error code `0x00` (No Error).
-
-#### http2stream.rstWithProtocolError()
-<!-- YAML
-added: v8.4.0
--->
-
-* Returns: {undefined}
-
-Shortcut for `http2stream.rstStream()` using error code `0x01` (Protocol Error).
-
-#### http2stream.rstWithCancel()
-<!-- YAML
-added: v8.4.0
--->
-
-* Returns: {undefined}
-
-Shortcut for `http2stream.rstStream()` using error code `0x08` (Cancel).
-
-#### http2stream.rstWithRefuse()
-<!-- YAML
-added: v8.4.0
--->
-
-* Returns: {undefined}
-
-Shortcut for `http2stream.rstStream()` using error code `0x07` (Refused Stream).
-
-#### http2stream.rstWithInternalError()
-<!-- YAML
-added: v8.4.0
--->
-
-* Returns: {undefined}
-
-Shortcut for `http2stream.rstStream()` using error code `0x02` (Internal Error).
-
 #### http2stream.session
 <!-- YAML
 added: v8.4.0
@@ -842,11 +851,11 @@ added: v8.4.0
 ```js
 const http2 = require('http2');
 const client = http2.connect('http://example.org:8000');
-
+const { NGHTTP2_CANCEL } = http2.constants;
 const req = client.request({ ':path': '/' });
 
 // Cancel the stream if there's no activity after 5 seconds
-req.setTimeout(5000, () => req.rstWithCancel());
+req.setTimeout(5000, () => req.rstStream(NGHTTP2_CANCEL));
 ```
 
 #### http2stream.state
@@ -1264,16 +1273,49 @@ added: v8.4.0
 
 In `Http2Server`, there is no `'clientError'` event as there is in
 HTTP1. However, there are `'socketError'`, `'sessionError'`,  and
-`'streamError'`, for error happened on the socket, session, or stream
-respectively.
+`'streamError'`, for errors emitted on the socket, `Http2Session`, or
+`Http2Stream`.
+
+#### Event: 'checkContinue'
+<!-- YAML
+added: v8.5.0
+-->
+
+* `request` {http2.Http2ServerRequest}
+* `response` {http2.Http2ServerResponse}
+
+If a [`'request'`][] listener is registered or [`http2.createServer()`][] is
+supplied a callback function, the `'checkContinue'` event is emitted each time
+a request with an HTTP `Expect: 100-continue` is received. If this event is
+not listened for, the server will automatically respond with a status
+`100 Continue` as appropriate.
 
-#### Event: 'socketError'
+Handling this event involves calling [`response.writeContinue()`][] if the client
+should continue to send the request body, or generating an appropriate HTTP
+response (e.g. 400 Bad Request) if the client should not continue to send the
+request body.
+
+Note that when this event is emitted and handled, the [`'request'`][] event will
+not be emitted.
+
+#### Event: 'request'
 <!-- YAML
 added: v8.4.0
 -->
 
-The `'socketError'` event is emitted when a `'socketError'` event is emitted by
-an `Http2Session` associated with the server.
+* `request` {http2.Http2ServerRequest}
+* `response` {http2.Http2ServerResponse}
+
+Emitted each time there is a request. Note that there may be multiple requests
+per session. See the [Compatibility API][].
+
+#### Event: 'session'
+<!-- YAML
+added: v8.4.0
+-->
+
+The `'session'` event is emitted when a new `Http2Session` is created by the
+`Http2Server`.
 
 #### Event: 'sessionError'
 <!-- YAML
@@ -1281,16 +1323,13 @@ added: v8.4.0
 -->
 
 The `'sessionError'` event is emitted when an `'error'` event is emitted by
-an `Http2Session` object. If no listener is registered for this event, an
-`'error'` event is emitted.
+an `Http2Session` object associated with the `Http2Server`.
 
 #### Event: 'streamError'
 <!-- YAML
 added: v8.5.0
 -->
 
-* `socket` {http2.ServerHttp2Stream}
-
 If an `ServerHttp2Stream` emits an `'error'` event, it will be forwarded here.
 The stream will already be destroyed when this event is triggered.
 
@@ -1325,17 +1364,6 @@ server.on('stream', (stream, headers, flags) => {
 });
 ```
 
-#### Event: 'request'
-<!-- YAML
-added: v8.4.0
--->
-
-* `request` {http2.Http2ServerRequest}
-* `response` {http2.Http2ServerResponse}
-
-Emitted each time there is a request. Note that there may be multiple requests
-per session. See the [Compatibility API][].
-
 #### Event: 'timeout'
 <!-- YAML
 added: v8.4.0
@@ -1344,28 +1372,6 @@ added: v8.4.0
 The `'timeout'` event is emitted when there is no activity on the Server for
 a given number of milliseconds set using `http2server.setTimeout()`.
 
-#### Event: 'checkContinue'
-<!-- YAML
-added: v8.5.0
--->
-
-* `request` {http2.Http2ServerRequest}
-* `response` {http2.Http2ServerResponse}
-
-If a [`'request'`][] listener is registered or [`http2.createServer()`][] is
-supplied a callback function, the `'checkContinue'` event is emitted each time
-a request with an HTTP `Expect: 100-continue` is received. If this event is
-not listened for, the server will automatically respond with a status
-`100 Continue` as appropriate.
-
-Handling this event involves calling [`response.writeContinue()`][] if the client
-should continue to send the request body, or generating an appropriate HTTP
-response (e.g. 400 Bad Request) if the client should not continue to send the
-request body.
-
-Note that when this event is emitted and handled, the [`'request'`][] event will
-not be emitted.
-
 ### Class: Http2SecureServer
 <!-- YAML
 added: v8.4.0
@@ -1379,16 +1385,7 @@ added: v8.4.0
 -->
 
 The `'sessionError'` event is emitted when an `'error'` event is emitted by
-an `Http2Session` object. If no listener is registered for this event, an
-`'error'` event is emitted on the `Http2Session` instance instead.
-
-#### Event: 'socketError'
-<!-- YAML
-added: v8.4.0
--->
-
-The `'socketError'` event is emitted when a `'socketError'` event is emitted by
-an `Http2Session` associated with the server.
+an `Http2Session` object associated with the `Http2SecureServer`.
 
 #### Event: 'unknownProtocol'
 <!-- YAML
@@ -1682,7 +1679,7 @@ const client = http2.connect('https://localhost:1234');
 
 /** use the client **/
 
-client.destroy();
+client.close();
 ```
 
 ### http2.constants
@@ -1938,6 +1935,7 @@ An HTTP/2 CONNECT proxy:
 
 ```js
 const http2 = require('http2');
+const { NGHTTP2_REFUSED_STREAM } = http2.constants;
 const net = require('net');
 const { URL } = require('url');
 
@@ -1945,7 +1943,7 @@ const proxy = http2.createServer();
 proxy.on('stream', (stream, headers) => {
   if (headers[':method'] !== 'CONNECT') {
     // Only accept CONNECT requests
-    stream.rstWithRefused();
+    stream.close(NGHTTP2_REFUSED_STREAM);
     return;
   }
   const auth = new URL(`tcp://${headers[':authority']}`);
@@ -1957,7 +1955,7 @@ proxy.on('stream', (stream, headers) => {
     stream.pipe(socket);
   });
   socket.on('error', (error) => {
-    stream.rstStream(http2.constants.NGHTTP2_CONNECT_ERROR);
+    stream.close(http2.constants.NGHTTP2_CONNECT_ERROR);
   });
 });
 
@@ -1986,7 +1984,7 @@ req.setEncoding('utf8');
 req.on('data', (chunk) => data += chunk);
 req.on('end', () => {
   console.log(`The server says: ${data}`);
-  client.destroy();
+  client.close();
 });
 req.end('Jane');
 ```
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index ab0d2fe54eb5da..7276bb6344a5bd 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -307,6 +307,8 @@ E('ERR_ENCODING_INVALID_ENCODED_DATA',
   'The encoded data was not valid for encoding %s');
 E('ERR_ENCODING_NOT_SUPPORTED', 'The "%s" encoding is not supported');
 E('ERR_FALSY_VALUE_REJECTION', 'Promise was rejected with falsy value');
+E('ERR_HTTP2_ALREADY_SHUTDOWN',
+  'Http2Session is already shutdown or destroyed');
 E('ERR_HTTP2_CONNECT_AUTHORITY',
   ':authority header is required for CONNECT requests');
 E('ERR_HTTP2_CONNECT_PATH',
@@ -321,6 +323,8 @@ E('ERR_HTTP2_FRAME_ERROR',
     msg += ` with code ${code}`;
     return msg;
   });
+E('ERR_HTTP2_GOAWAY_SESSION',
+  'New streams cannot be created after receiving a GOAWAY');
 E('ERR_HTTP2_HEADERS_AFTER_RESPOND',
   'Cannot specify additional headers after response initiated');
 E('ERR_HTTP2_HEADERS_OBJECT', 'Headers must be an object');
@@ -358,12 +362,13 @@ E('ERR_HTTP2_PING_LENGTH', 'HTTP2 ping payload must be 8 bytes');
 E('ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED', 'Cannot set HTTP/2 pseudo-headers');
 E('ERR_HTTP2_PUSH_DISABLED', 'HTTP/2 client has disabled push streams');
 E('ERR_HTTP2_SEND_FILE', 'Only regular files can be sent');
+E('ERR_HTTP2_SESSION_ERROR', 'Session closed with error code %s');
 E('ERR_HTTP2_SOCKET_BOUND',
   'The socket is already bound to an Http2Session');
 E('ERR_HTTP2_STATUS_101',
   'HTTP status code 101 (Switching Protocols) is forbidden in HTTP/2');
 E('ERR_HTTP2_STATUS_INVALID', 'Invalid status code: %s');
-E('ERR_HTTP2_STREAM_CLOSED', 'The stream is already closed');
+E('ERR_HTTP2_STREAM_CANCEL', 'The pending stream has been canceled');
 E('ERR_HTTP2_STREAM_ERROR', 'Stream closed with error code %s');
 E('ERR_HTTP2_STREAM_SELF_DEPENDENCY', 'A stream cannot depend on itself');
 E('ERR_HTTP2_UNSUPPORTED_PROTOCOL', 'protocol "%s" is unsupported.');
diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index ec1f0ba64eff0a..b5dd81c80f4038 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -126,14 +126,11 @@ function onStreamAbortedRequest() {
   const request = this[kRequest];
   if (request !== undefined && request[kState].closed === false) {
     request.emit('aborted');
-    request.emit('close');
   }
 }
 
 function onStreamAbortedResponse() {
-  const response = this[kResponse];
-  if (response !== undefined && response[kState].closed === false)
-    response.emit('close');
+  // non-op for now
 }
 
 function resumeStream(stream) {
@@ -234,9 +231,7 @@ class Http2ServerRequest extends Readable {
     stream.on('end', onStreamEnd);
     stream.on('error', onStreamError);
     stream.on('aborted', onStreamAbortedRequest);
-    const onfinish = this[kFinish].bind(this);
-    stream.on('close', onfinish);
-    stream.on('finish', onfinish);
+    stream.on('close', this[kFinish].bind(this));
     this.on('pause', onRequestPause);
     this.on('resume', onRequestResume);
   }
@@ -297,7 +292,7 @@ class Http2ServerRequest extends Readable {
       state.didRead = true;
       process.nextTick(resumeStream, this[kStream]);
     } else {
-      this.emit('error', new errors.Error('ERR_HTTP2_STREAM_CLOSED'));
+      this.emit('error', new errors.Error('ERR_HTTP2_INVALID_STREAM'));
     }
   }
 
@@ -345,6 +340,7 @@ class Http2ServerRequest extends Readable {
     // dump it for compatibility with http1
     if (!state.didRead && !this._readableState.resumeScheduled)
       this.resume();
+    this.emit('close');
   }
 }
 
@@ -366,9 +362,7 @@ class Http2ServerResponse extends Stream {
     this.writable = true;
     stream.on('drain', onStreamDrain);
     stream.on('aborted', onStreamAbortedResponse);
-    const onfinish = this[kFinish].bind(this);
-    stream.on('close', onfinish);
-    stream.on('finish', onfinish);
+    stream.on('close', this[kFinish].bind(this));
   }
 
   // User land modules such as finalhandler just check truthiness of this
@@ -520,7 +514,7 @@ class Http2ServerResponse extends Stream {
     const state = this[kState];
 
     if (state.closed)
-      throw new errors.Error('ERR_HTTP2_STREAM_CLOSED');
+      throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
     if (this[kStream].headersSent)
       throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
 
@@ -550,7 +544,7 @@ class Http2ServerResponse extends Stream {
     }
 
     if (this[kState].closed) {
-      const err = new errors.Error('ERR_HTTP2_STREAM_CLOSED');
+      const err = new errors.Error('ERR_HTTP2_INVALID_STREAM');
       if (typeof cb === 'function')
         process.nextTick(cb, err);
       else
@@ -620,12 +614,15 @@ class Http2ServerResponse extends Stream {
     if (typeof callback !== 'function')
       throw new errors.TypeError('ERR_INVALID_CALLBACK');
     if (this[kState].closed) {
-      process.nextTick(callback, new errors.Error('ERR_HTTP2_STREAM_CLOSED'));
+      process.nextTick(callback, new errors.Error('ERR_HTTP2_INVALID_STREAM'));
       return;
     }
-    this[kStream].pushStream(headers, {}, function(stream, headers, options) {
-      const response = new Http2ServerResponse(stream);
-      callback(null, response);
+    this[kStream].pushStream(headers, {}, (err, stream, headers, options) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+      callback(null, new Http2ServerResponse(stream));
     });
   }
 
@@ -649,6 +646,7 @@ class Http2ServerResponse extends Stream {
     this[kProxySocket] = null;
     stream[kResponse] = undefined;
     this.emit('finish');
+    this.emit('close');
   }
 
   // TODO doesn't support callbacks
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index 78446d2fb6e112..d047b394ba6b45 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -66,10 +66,10 @@ const TLSServer = tls.Server;
 const kInspect = require('internal/util').customInspectSymbol;
 
 const kAuthority = Symbol('authority');
-const kDestroySocket = Symbol('destroy-socket');
 const kHandle = Symbol('handle');
 const kID = Symbol('id');
 const kInit = Symbol('init');
+const kMaybeDestroy = Symbol('maybe-destroy');
 const kLocalSettings = Symbol('local-settings');
 const kOptions = Symbol('options');
 const kOwner = Symbol('owner');
@@ -84,7 +84,6 @@ const kType = Symbol('type');
 const kUpdateTimer = Symbol('update-timer');
 
 const kDefaultSocketTimeout = 2 * 60 * 1000;
-const kRenegTest = /TLS session renegotiation disabled for this socket/;
 
 const {
   paddingBuffer,
@@ -95,14 +94,13 @@ const {
 
 const {
   NGHTTP2_CANCEL,
+  NGHTTP2_REFUSED_STREAM,
   NGHTTP2_DEFAULT_WEIGHT,
   NGHTTP2_FLAG_END_STREAM,
   NGHTTP2_HCAT_PUSH_RESPONSE,
   NGHTTP2_HCAT_RESPONSE,
   NGHTTP2_INTERNAL_ERROR,
   NGHTTP2_NO_ERROR,
-  NGHTTP2_PROTOCOL_ERROR,
-  NGHTTP2_REFUSED_STREAM,
   NGHTTP2_SESSION_CLIENT,
   NGHTTP2_SESSION_SERVER,
   NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE,
@@ -139,6 +137,18 @@ const {
   STREAM_OPTION_GET_TRAILERS
 } = constants;
 
+const STREAM_FLAGS_PENDING = 0x0;
+const STREAM_FLAGS_READY = 0x1;
+const STREAM_FLAGS_CLOSED = 0x2;
+const STREAM_FLAGS_HEADERS_SENT = 0x4;
+const STREAM_FLAGS_HEAD_REQUEST = 0x8;
+const STREAM_FLAGS_ABORTED = 0x10;
+
+const SESSION_FLAGS_PENDING = 0x0;
+const SESSION_FLAGS_READY = 0x1;
+const SESSION_FLAGS_CLOSED = 0x2;
+const SESSION_FLAGS_DESTROYED = 0x4;
+
 // Top level to avoid creating a closure
 function emit(self, ...args) {
   self.emit(...args);
@@ -150,12 +160,15 @@ function emit(self, ...args) {
 // event. If the stream is not new, emit the 'headers' event to pass
 // the block of headers on.
 function onSessionHeaders(handle, id, cat, flags, headers) {
-  const owner = this[kOwner];
-  const type = owner[kType];
-  owner[kUpdateTimer]();
+  const session = this[kOwner];
+  if (session.destroyed)
+    return;
+
+  const type = session[kType];
+  session[kUpdateTimer]();
   debug(`Http2Stream ${id} [Http2Session ` +
         `${sessionName(type)}]: headers received`);
-  const streams = owner[kState].streams;
+  const streams = session[kState].streams;
 
   const endOfStream = !!(flags & NGHTTP2_FLAG_END_STREAM);
   let stream = streams.get(id);
@@ -164,21 +177,28 @@ function onSessionHeaders(handle, id, cat, flags, headers) {
   const obj = toHeaderObject(headers);
 
   if (stream === undefined) {
+    if (session.closed) {
+      // we are not accepting any new streams at this point. This callback
+      // should not be invoked at this point in time, but just in case it is,
+      // refuse the stream using an RST_STREAM and destroy the handle.
+      handle.rstStream(NGHTTP2_REFUSED_STREAM);
+      handle.destroy();
+      return;
+    }
     const opts = { readable: !endOfStream };
-    // owner[kType] can be only one of two possible values
+    // session[kType] can be only one of two possible values
     if (type === NGHTTP2_SESSION_SERVER) {
-      stream = new ServerHttp2Stream(owner, handle, id, opts, obj);
+      stream = new ServerHttp2Stream(session, handle, id, opts, obj);
       if (obj[HTTP2_HEADER_METHOD] === HTTP2_METHOD_HEAD) {
         // For head requests, there must not be a body...
         // end the writable side immediately.
         stream.end();
-        stream[kState].headRequest = true;
+        stream[kState].flags |= STREAM_FLAGS_HEAD_REQUEST;
       }
     } else {
-      stream = new ClientHttp2Stream(owner, handle, id, opts);
+      stream = new ClientHttp2Stream(session, handle, id, opts);
     }
-    streams.set(id, stream);
-    process.nextTick(emit, owner, 'stream', stream, obj, flags, headers);
+    process.nextTick(emit, session, 'stream', stream, obj, flags, headers);
   } else {
     let event;
     const status = obj[HTTP2_HEADER_STATUS];
@@ -208,6 +228,12 @@ function onSessionHeaders(handle, id, cat, flags, headers) {
   }
 }
 
+function tryClose(fd) {
+  // Try to close the file descriptor. If closing fails, assert because
+  // an error really should not happen at this point.
+  fs.close(fd, (err) => assert.ifError(err));
+}
+
 // Called to determine if there are trailers to be sent at the end of a
 // Stream. The 'getTrailers' callback is invoked and passed a holder object.
 // The trailers to return are set on that object by the handler. Once the
@@ -216,133 +242,167 @@ function onSessionHeaders(handle, id, cat, flags, headers) {
 // there are trailing headers to send.
 function onStreamTrailers() {
   const stream = this[kOwner];
+  if (stream.destroyed)
+    return [];
   const trailers = Object.create(null);
   stream[kState].getTrailers.call(stream, trailers);
   const headersList = mapToHeaders(trailers, assertValidPseudoHeaderTrailer);
   if (!Array.isArray(headersList)) {
-    process.nextTick(emit, stream, 'error', headersList);
-    return;
+    stream.destroy(headersList);
+    return [];
   }
   return headersList;
 }
 
-// Called when the stream is closed. The close event is emitted on the
-// Http2Stream instance
-function onStreamClose(code) {
+// Submit an RST-STREAM frame to be sent to the remote peer.
+// This will cause the Http2Stream to be closed.
+function submitRstStream(code) {
+  if (this[kHandle] !== undefined) {
+    this[kHandle].rstStream(code);
+  }
+}
+
+// Called when the stream is closed either by sending or receiving an
+// RST_STREAM frame, or through a natural end-of-stream.
+// If the writable and readable sides of the stream are still open at this
+// point, close them. If there is an open fd for file send, close that also.
+// At this point the underlying node::http2:Http2Stream handle is no
+// longer usable so destroy it also.
+function onStreamClose(code, hasData) {
   const stream = this[kOwner];
-  stream[kUpdateTimer]();
-  abort(stream);
+  if (stream.destroyed)
+    return;
+
   const state = stream[kState];
-  state.rst = true;
-  state.rstCode = code;
-  if (state.fd !== undefined)
-    fs.close(state.fd, afterFDClose.bind(stream));
 
-  setImmediate(stream.destroy.bind(stream));
-}
+  debug(`Http2Stream ${stream[kID]} [Http2Session ` +
+        `${sessionName(stream[kSession][kType])}]: closed with code ${code}` +
+        ` [has data? ${hasData}]`);
 
-function afterFDClose(err) {
-  if (err)
-    process.nextTick(emit, this, 'error', err);
-}
+  if (!stream.closed) {
+    // Unenroll from timeouts
+    unenroll(stream);
+    stream.removeAllListeners('timeout');
+
+    // Set the state flags
+    state.flags |= STREAM_FLAGS_CLOSED;
+    state.rstCode = code;
 
-// Called when an error event needs to be triggered
-function onSessionError(error) {
-  const owner = this[kOwner];
-  owner[kUpdateTimer]();
-  process.nextTick(emit, owner, 'error', error);
+    // Close the writable side of the stream
+    abort(stream);
+    stream.end();
+  }
+
+  if (state.fd !== undefined)
+    tryClose(state.fd);
+  stream[kMaybeDestroy](null, code, hasData);
 }
 
 // Receives a chunk of data for a given stream and forwards it on
 // to the Http2Stream Duplex for processing.
 function onStreamRead(nread, buf, handle) {
   const stream = handle[kOwner];
-  stream[kUpdateTimer]();
   if (nread >= 0 && !stream.destroyed) {
+    debug(`Http2Stream ${stream[kID]} [Http2Session ` +
+          `${sessionName(stream[kSession][kType])}]: receiving data chunk ` +
+          `of size ${nread}`);
+    stream[kUpdateTimer]();
     if (!stream.push(buf)) {
-      handle.readStop();
+      if (!stream.destroyed)  // we have to check a second time
+        handle.readStop();
     }
     return;
   }
   // Last chunk was received. End the readable side.
+  debug(`Http2Stream ${stream[kID]} [Http2Session ` +
+        `${sessionName(stream[kSession][kType])}]: ending readable.`);
   stream.push(null);
+  stream[kMaybeDestroy]();
 }
 
 // Called when the remote peer settings have been updated.
 // Resets the cached settings.
 function onSettings(ack) {
-  const owner = this[kOwner];
-  debug(`Http2Session ${sessionName(owner[kType])}: new settings received`);
-  owner[kUpdateTimer]();
+  const session = this[kOwner];
+  if (session.destroyed)
+    return;
+  session[kUpdateTimer]();
   let event = 'remoteSettings';
   if (ack) {
-    if (owner[kState].pendingAck > 0)
-      owner[kState].pendingAck--;
-    owner[kLocalSettings] = undefined;
+    debug(`Http2Session ${sessionName(session[kType])}: settings acknowledged`);
+    if (session[kState].pendingAck > 0)
+      session[kState].pendingAck--;
+    session[kLocalSettings] = undefined;
     event = 'localSettings';
   } else {
-    owner[kRemoteSettings] = undefined;
+    debug(`Http2Session ${sessionName(session[kType])}: new settings received`);
+    session[kRemoteSettings] = undefined;
   }
-  // Only emit the event if there are listeners registered
-  if (owner.listenerCount(event) > 0)
-    process.nextTick(emit, owner, event, owner[event]);
+  process.nextTick(emit, session, event, session[event]);
 }
 
 // If the stream exists, an attempt will be made to emit an event
 // on the stream object itself. Otherwise, forward it on to the
 // session (which may, in turn, forward it on to the server)
 function onPriority(id, parent, weight, exclusive) {
-  const owner = this[kOwner];
+  const session = this[kOwner];
+  if (session.destroyed)
+    return;
   debug(`Http2Stream ${id} [Http2Session ` +
-        `${sessionName(owner[kType])}]: priority [parent: ${parent}, ` +
+        `${sessionName(session[kType])}]: priority [parent: ${parent}, ` +
         `weight: ${weight}, exclusive: ${exclusive}]`);
-  owner[kUpdateTimer]();
-  const streams = owner[kState].streams;
-  const stream = streams.get(id);
-  const emitter = stream === undefined ? owner : stream;
-  process.nextTick(emit, emitter, 'priority', id, parent, weight, exclusive);
-}
-
-function emitFrameError(self, id, type, code) {
-  if (!self.emit('frameError', type, code, id)) {
-    const err = new errors.Error('ERR_HTTP2_FRAME_ERROR', type, code, id);
-    err.errno = code;
-    self.emit('error', err);
+  const emitter = session[kState].streams.get(id) || session;
+  if (!emitter.destroyed) {
+    emitter[kUpdateTimer]();
+    process.nextTick(emit, emitter, 'priority', id, parent, weight, exclusive);
   }
 }
 
 // Called by the native layer when an error has occurred sending a
 // frame. This should be exceedingly rare.
 function onFrameError(id, type, code) {
-  const owner = this[kOwner];
-  debug(`Http2Session ${sessionName(owner[kType])}: error sending frame type ` +
-        `${type} on stream ${id}, code: ${code}`);
-  owner[kUpdateTimer]();
-  const streams = owner[kState].streams;
-  const stream = streams.get(id);
-  const emitter = stream !== undefined ? stream : owner;
-  process.nextTick(emitFrameError, emitter, id, type, code);
-}
-
-function emitGoaway(self, code, lastStreamID, buf) {
-  self.emit('goaway', code, lastStreamID, buf);
-  // Tear down the session or destroy
-  const state = self[kState];
-  if (state.destroying || state.destroyed)
+  const session = this[kOwner];
+  if (session.destroyed)
     return;
-  if (!state.shuttingDown && !state.shutdown) {
-    self.shutdown({}, self.destroy.bind(self));
+  debug(`Http2Session ${sessionName(session[kType])}: error sending frame ` +
+        `type ${type} on stream ${id}, code: ${code}`);
+  const emitter = session[kState].streams.get(id) || session;
+  emitter[kUpdateTimer]();
+  process.nextTick(emit, emitter, 'frameError', type, code, id);
+}
+
+// Receiving a GOAWAY frame from the connected peer is a signal that no
+// new streams should be created. If the code === NGHTTP2_NO_ERROR, we
+// are going to send our our close, but allow existing frames to close
+// normally. If code !== NGHTTP2_NO_ERROR, we are going to send our own
+// close using the same code then destroy the session with an error.
+// The goaway event will be emitted on next tick.
+function onGoawayData(code, lastStreamID, buf) {
+  const session = this[kOwner];
+  if (session.destroyed)
     return;
+  debug(`Http2Session ${sessionName(session[kType])}: goaway ${code} ` +
+        `received [last stream id: ${lastStreamID}]`);
+
+  const state = session[kState];
+  state.goawayCode = code;
+  state.goawayLastStreamID = lastStreamID;
+
+  session.emit('goaway', code, lastStreamID, buf);
+  if (code === NGHTTP2_NO_ERROR) {
+    // If this is a no error goaway, begin shutting down.
+    // No new streams permitted, but existing streams may
+    // close naturally on their own.
+    session.close();
+  } else {
+    // However, if the code is not NGHTTP_NO_ERROR, destroy the
+    // session immediately. We destroy with an error but send a
+    // goaway using NGHTTP2_NO_ERROR because there was no error
+    // condition on this side of the session that caused the
+    // shutdown.
+    session.destroy(new errors.Error('ERR_HTTP2_SESSION_ERROR', code),
+                    { errorCode: NGHTTP2_NO_ERROR });
   }
-  self.destroy();
-}
-
-// Called by the native layer when a goaway frame has been received
-function onGoawayData(code, lastStreamID, buf) {
-  const owner = this[kOwner];
-  debug(`Http2Session ${sessionName(owner[kType])}: goaway ${code} received ` +
-        `[last stream id: ${lastStreamID}]`);
-  process.nextTick(emitGoaway, owner, code, lastStreamID, buf);
 }
 
 // Returns the padding to use per frame. The selectPadding callback is set
@@ -366,18 +426,23 @@ function onSelectPadding(fn) {
 // will be deferred until the socket is ready to go.
 function requestOnConnect(headers, options) {
   const session = this[kSession];
-  debug(`Http2Session ${sessionName(session[kType])}: connected, ` +
-        'initializing request');
-  const streams = session[kState].streams;
 
-  validatePriorityOptions(options);
+  // At this point, the stream should have already been destroyed during
+  // the session.destroy() method. Do nothing else.
+  if (session.destroyed)
+    return;
 
-  const headersList = mapToHeaders(headers);
-  if (!Array.isArray(headersList)) {
-    process.nextTick(emit, this, 'error', headersList);
+  // If the session was closed while waiting for for the connect, destroy
+  // the stream and do not continue with the request.
+  if (session.closed) {
+    const err = new errors.Error('ERR_HTTP2_GOAWAY_SESSION');
+    this.destroy(err);
     return;
   }
 
+  debug(`Http2Session ${sessionName(session[kType])}: connected, ` +
+        'initializing request');
+
   let streamOptions = 0;
   if (options.endStream)
     streamOptions |= STREAM_OPTION_EMPTY_PAYLOAD;
@@ -389,7 +454,7 @@ function requestOnConnect(headers, options) {
 
   // ret will be either the reserved stream ID (if positive)
   // or an error code (if negative)
-  const ret = session[kHandle].request(headersList,
+  const ret = session[kHandle].request(headers,
                                        streamOptions,
                                        options.parent | 0,
                                        options.weight | 0,
@@ -406,117 +471,82 @@ function requestOnConnect(headers, options) {
   // session if not handled.
   if (typeof ret === 'number') {
     let err;
-    let target = session;
     switch (ret) {
       case NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE:
         err = new errors.Error('ERR_HTTP2_OUT_OF_STREAMS');
-        target = this;
+        this.destroy(err);
         break;
       case NGHTTP2_ERR_INVALID_ARGUMENT:
         err = new errors.Error('ERR_HTTP2_STREAM_SELF_DEPENDENCY');
-        target = this;
+        this.destroy(err);
         break;
       default:
-        err = new NghttpError(ret);
+        session.destroy(new NghttpError(ret));
     }
-    process.nextTick(emit, target, 'error', err);
     return;
   }
-  const id = ret.id();
-  streams.set(id, this);
-  this[kInit](id, ret);
+  this[kInit](ret.id(), ret);
 }
 
+// Validates that priority options are correct, specifically:
+// 1. options.weight must be a number
+// 2. options.parent must be a positive number
+// 3. options.exclusive must be a boolean
+// 4. if specified, options.silent must be a boolean
+//
+// Also sets the default priority options if they are not set.
 function validatePriorityOptions(options) {
+  let err;
   if (options.weight === undefined) {
     options.weight = NGHTTP2_DEFAULT_WEIGHT;
   } else if (typeof options.weight !== 'number') {
-    const err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                     'weight',
-                                     options.weight);
-    Error.captureStackTrace(err, validatePriorityOptions);
-    throw err;
+    err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
+                               'weight',
+                               options.weight);
   }
 
   if (options.parent === undefined) {
     options.parent = 0;
   } else if (typeof options.parent !== 'number' || options.parent < 0) {
-    const err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                     'parent',
-                                     options.parent);
-    Error.captureStackTrace(err, validatePriorityOptions);
-    throw err;
+    err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
+                               'parent',
+                               options.parent);
   }
 
   if (options.exclusive === undefined) {
     options.exclusive = false;
   } else if (typeof options.exclusive !== 'boolean') {
-    const err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                     'exclusive',
-                                     options.exclusive);
-    Error.captureStackTrace(err, validatePriorityOptions);
-    throw err;
+    err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
+                               'exclusive',
+                               options.exclusive);
   }
 
   if (options.silent === undefined) {
     options.silent = false;
   } else if (typeof options.silent !== 'boolean') {
-    const err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                     'silent',
-                                     options.silent);
+    err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
+                               'silent',
+                               options.silent);
+  }
+
+  if (err) {
     Error.captureStackTrace(err, validatePriorityOptions);
     throw err;
   }
 }
 
+// When an error occurs internally at the binding level, immediately
+// destroy the session.
 function onSessionInternalError(code) {
-  const owner = this[kOwner];
-  const err = new NghttpError(code);
-  process.nextTick(emit, owner, 'error', err);
-}
-
-// Creates the internal binding.Http2Session handle for an Http2Session
-// instance. This occurs only after the socket connection has been
-// established. Note: the binding.Http2Session will take over ownership
-// of the socket. No other code should read from or write to the socket.
-function setupHandle(session, socket, type, options) {
-  return function() {
-    debug(`Http2Session ${sessionName(type)}: setting up session handle`);
-    session[kState].connecting = false;
-
-    updateOptionsBuffer(options);
-    const handle = new binding.Http2Session(type);
-    handle[kOwner] = session;
-    handle.error = onSessionInternalError;
-    handle.onpriority = onPriority;
-    handle.onsettings = onSettings;
-    handle.onheaders = onSessionHeaders;
-    handle.onerror = onSessionError;
-    handle.onframeerror = onFrameError;
-    handle.ongoawaydata = onGoawayData;
-
-    if (typeof options.selectPadding === 'function')
-      handle.ongetpadding = onSelectPadding(options.selectPadding);
-
-    assert(socket._handle !== undefined,
-           'Internal HTTP/2 Failure. The socket is not connected. Please ' +
-           'report this as a bug in Node.js');
-    handle.consume(socket._handle._externalStream);
-
-    session[kHandle] = handle;
-
-    const settings = typeof options.settings === 'object' ?
-      options.settings : Object.create(null);
-
-    session.settings(settings);
-    process.nextTick(emit, session, 'connect', session, socket);
-  };
+  if (this[kOwner] !== undefined)
+    this[kOwner].destroy(new NghttpError(code));
 }
 
 // Submits a SETTINGS frame to be sent to the remote peer.
 function submitSettings(settings) {
-  const type = this[kType];
-  debug(`Http2Session ${sessionName(type)}: submitting settings`);
+  if (this.destroyed)
+    return;
+  debug(`Http2Session ${sessionName(this[kType])}: submitting settings`);
   this[kUpdateTimer]();
   this[kLocalSettings] = undefined;
   updateSettingsBuffer(settings);
@@ -527,6 +557,8 @@ function submitSettings(settings) {
 // Note: If the silent option is true, the change will be made
 // locally with no PRIORITY frame sent.
 function submitPriority(options) {
+  if (this.destroyed)
+    return;
   this[kUpdateTimer]();
 
   // If the parent is the id, do nothing because a
@@ -540,74 +572,16 @@ function submitPriority(options) {
                          !!options.silent);
 }
 
-// Submit an RST-STREAM frame to be sent to the remote peer.
-// This will cause the Http2Stream to be closed.
-function submitRstStream(code) {
-  this[kUpdateTimer]();
-
-  const state = this[kState];
-  if (state.rst) return;
-  state.rst = true;
-  state.rstCode = code;
-
-  const ret = this[kHandle].rstStream(code);
-  if (ret < 0) {
-    const err = new NghttpError(ret);
-    process.nextTick(emit, this, 'error', err);
-    return;
-  }
-  this.destroy();
-}
-
-function doShutdown(options) {
-  const handle = this[kHandle];
-  const state = this[kState];
-  if (handle === undefined || state.shutdown)
-    return; // Nothing to do, possibly because the session shutdown already.
-  const ret = handle.goaway(options.errorCode | 0,
-                            options.lastStreamID | 0,
-                            options.opaqueData);
-  state.shuttingDown = false;
-  state.shutdown = true;
-  if (ret < 0) {
-    debug(`Http2Session ${sessionName(this[kType])}: shutdown failed`);
-    const err = new NghttpError(ret);
-    process.nextTick(emit, this, 'error', err);
+// Submit a GOAWAY frame to be sent to the remote peer.
+// If the lastStreamID is set to <= 0, then the lastProcStreamID will
+// be used. The opaqueData must either be a typed array or undefined
+// (which will be checked elsewhere).
+function submitGoaway(code, lastStreamID, opaqueData) {
+  if (this.destroyed)
     return;
-  }
-  process.nextTick(emit, this, 'shutdown', options);
-}
-
-// Submit a graceful or immediate shutdown request for the Http2Session.
-function submitShutdown(options) {
-  const type = this[kType];
-  debug(`Http2Session ${sessionName(type)}: submitting shutdown request`);
-  const shutdownFn = doShutdown.bind(this, options);
-  if (type === NGHTTP2_SESSION_SERVER && options.graceful === true) {
-    // first send a shutdown notice
-    this[kHandle].shutdownNotice();
-    // then, on flip of the event loop, do the actual shutdown
-    setImmediate(shutdownFn);
-    return;
-  }
-  shutdownFn();
-}
-
-function finishSessionDestroy(socket) {
-  if (!socket.destroyed)
-    socket.destroy();
-
-  const state = this[kState];
-  state.destroying = false;
-  state.destroyed = true;
-
-  // Destroy the handle
-  if (this[kHandle] !== undefined) {
-    this[kHandle].destroy(state.skipUnconsume);
-    this[kHandle] = undefined;
-  }
-
-  process.nextTick(emit, this, 'close');
+  debug(`Http2Session ${sessionName(this[kType])}: submitting goaway`);
+  this[kUpdateTimer]();
+  this[kHandle].goaway(code, lastStreamID, opaqueData);
 }
 
 const proxySocketHandler = {
@@ -652,13 +626,27 @@ const proxySocketHandler = {
   }
 };
 
+// pingCallback() returns a function that is invoked when an HTTP2 PING
+// frame acknowledgement is received. The ack is either true or false to
+// indicate if the ping was successful or not. The duration indicates the
+// number of milliseconds elapsed since the ping was sent and the ack
+// received. The payload is a Buffer containing the 8 bytes of payload
+// data received on the PING acknowlegement.
 function pingCallback(cb) {
-  return function(ack, duration, payload) {
+  return function pingCallback(ack, duration, payload) {
     const err = ack ? null : new errors.Error('ERR_HTTP2_PING_CANCEL');
     cb(err, duration, payload);
   };
 }
 
+// Validates the values in a settings object. Specifically:
+// 1. headerTableSize must be a number in the range 0 <= n <= kMaxInt
+// 2. initialWindowSize must be a number in the range 0 <= n <= kMaxInt
+// 3. maxFrameSize must be a number in the range 16384 <= n <= kMaxFrameSize
+// 4. maxConcurrentStreams must be a number in the range 0 <= n <= kMaxStreams
+// 5. maxHeaderListSize must be a number in the range 0 <= n <= kMaxInt
+// 6. enablePush must be a boolean
+// All settings are optional and may be left undefined
 function validateSettings(settings) {
   settings = Object.assign({}, settings);
   assertWithinRange('headerTableSize',
@@ -681,13 +669,98 @@ function validateSettings(settings) {
     const err = new errors.TypeError('ERR_HTTP2_INVALID_SETTING_VALUE',
                                      'enablePush', settings.enablePush);
     err.actual = settings.enablePush;
+    Error.captureStackTrace(err, 'validateSettings');
     throw err;
   }
   return settings;
 }
 
+// Creates the internal binding.Http2Session handle for an Http2Session
+// instance. This occurs only after the socket connection has been
+// established. Note: the binding.Http2Session will take over ownership
+// of the socket. No other code should read from or write to the socket.
+function setupHandle(socket, type, options) {
+  // If the session has been destroyed, go ahead and emit 'connect',
+  // but do nothing else. The various on('connect') handlers set by
+  // core will check for session.destroyed before progressing, this
+  // ensures that those at l`east get cleared out.
+  if (this.destroyed) {
+    process.nextTick(emit, this, 'connect', this, socket);
+    return;
+  }
+  debug(`Http2Session ${sessionName(type)}: setting up session handle`);
+  this[kState].flags |= SESSION_FLAGS_READY;
+
+  updateOptionsBuffer(options);
+  const handle = new binding.Http2Session(type);
+  handle[kOwner] = this;
+  handle.error = onSessionInternalError;
+  handle.onpriority = onPriority;
+  handle.onsettings = onSettings;
+  handle.onheaders = onSessionHeaders;
+  handle.onframeerror = onFrameError;
+  handle.ongoawaydata = onGoawayData;
+
+  if (typeof options.selectPadding === 'function')
+    handle.ongetpadding = onSelectPadding(options.selectPadding);
+
+  assert(socket._handle !== undefined,
+         'Internal HTTP/2 Failure. The socket is not connected. Please ' +
+         'report this as a bug in Node.js');
+  handle.consume(socket._handle._externalStream);
+
+  this[kHandle] = handle;
+
+  const settings = typeof options.settings === 'object' ?
+    options.settings : {};
+
+  this.settings(settings);
+  process.nextTick(emit, this, 'connect', this, socket);
+}
+
+// Emits a close event followed by an error event if err is truthy. Used
+// by Http2Session.prototype.destroy()
+function emitClose(self, error) {
+  if (error)
+    self.emit('error', error);
+  self.emit('close');
+}
+
 // Upon creation, the Http2Session takes ownership of the socket. The session
 // may not be ready to use immediately if the socket is not yet fully connected.
+// In that case, the Http2Session will wait for the socket to connect. Once
+// the Http2Session is ready, it will emit its own 'connect' event.
+//
+// The Http2Session.goaway() method will send a GOAWAY frame, signalling
+// to the connected peer that a shutdown is in progress. Sending a goaway
+// frame has no other effect, however.
+//
+// Receiving a GOAWAY frame will cause the Http2Session to first emit a 'goaway'
+// event notifying the user that a shutdown is in progress. If the goaway
+// error code equals 0 (NGHTTP2_NO_ERROR), session.close() will be called,
+// causing the Http2Session to send its own GOAWAY frame and switch itself
+// into a graceful closing state. In this state, new inbound or outbound
+// Http2Streams will be rejected. Existing *pending* streams (those created
+// but without an assigned stream ID or handle) will be destroyed with a
+// cancel error. Existing open streams will be permitted to complete on their
+// own. Once all existing streams close, session.destroy() will be called
+// automatically.
+//
+// Calling session.destroy() will tear down the Http2Session immediately,
+// making it no longer usable. Pending and existing streams will be destroyed.
+// The bound socket will be destroyed. Once all resources have been freed up,
+// the 'close' event will be emitted. Note that pending streams will be
+// destroyed using a specific "ERR_HTTP2_STREAM_CANCEL" error. Existing open
+// streams will be destroyed using the same error passed to session.destroy()
+//
+// If destroy is called with an error, an 'error' event will be emitted
+// immediately following the 'close' event.
+//
+// The socket and Http2Session lifecycles are tightly bound. Once one is
+// destroyed, the other should also be destroyed. When the socket is destroyed
+// with an error, session.destroy() will be called with that same error.
+// Likewise, when session.destroy() is called with an error, the same error
+// will be sent to the socket.
 class Http2Session extends EventEmitter {
   constructor(type, options, socket) {
     super();
@@ -708,10 +781,9 @@ class Http2Session extends EventEmitter {
     socket[kSession] = this;
 
     this[kState] = {
+      flags: SESSION_FLAGS_PENDING,
       streams: new Map(),
-      destroyed: false,
-      shutdown: false,
-      shuttingDown: false,
+      pendingStreams: new Set(),
       pendingAck: 0,
       maxPendingAck: Math.max(1, (options.maxPendingAck | 0) || 10),
       writeQueueSize: 0
@@ -729,12 +801,8 @@ class Http2Session extends EventEmitter {
     if (typeof socket.disableRenegotiation === 'function')
       socket.disableRenegotiation();
 
-    socket[kDestroySocket] = socket.destroy;
-    socket.destroy = socketDestroy;
-
-    const setupFn = setupHandle(this, socket, type, options);
+    const setupFn = setupHandle.bind(this, socket, type, options);
     if (socket.connecting) {
-      this[kState].connecting = true;
       const connectEvent =
         socket instanceof tls.TLSSocket ? 'secureConnect' : 'connect';
       socket.once(connectEvent, setupFn);
@@ -742,22 +810,38 @@ class Http2Session extends EventEmitter {
       setupFn();
     }
 
-    // Any individual session can have any number of active open
-    // streams, these may all need to be made aware of changes
-    // in state that occur -- such as when the associated socket
-    // is closed. To do so, we need to set the max listener count
-    // to something more reasonable because we may have any number
-    // of concurrent streams (2^31-1 is the upper limit on the number
-    // of streams)
-    this.setMaxListeners(kMaxStreams);
     debug(`Http2Session ${sessionName(type)}: created`);
   }
 
+  // True if the Http2Session is still waiting for the socket to connect
+  get connecting() {
+    return (this[kState].flags & SESSION_FLAGS_READY) === 0;
+  }
+
+  // True if Http2Session.prototype.close() has been called
+  get closed() {
+    return !!(this[kState].flags & SESSION_FLAGS_CLOSED);
+  }
+
+  // True if Http2Session.prototype.destroy() has been called
+  get destroyed() {
+    return !!(this[kState].flags & SESSION_FLAGS_DESTROYED);
+  }
+
+  // Resets the timeout counter
   [kUpdateTimer]() {
+    if (this.destroyed)
+      return;
     _unrefActive(this);
   }
 
+  // Sets the id of the next stream to be created by this Http2Session.
+  // The value must be a number in the range 0 <= n <= kMaxStreams. The
+  // value also needs to be larger than the current next stream ID.
   setNextStreamID(id) {
+    if (this.destroyed)
+      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+
     if (typeof id !== 'number')
       throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'id', 'number');
     if (id <= 0 || id > kMaxStreams)
@@ -765,10 +849,13 @@ class Http2Session extends EventEmitter {
     this[kHandle].setNextStreamID(id);
   }
 
+  // If ping is called while we are still connecting, or after close() has
+  // been called, the ping callback will be invoked immediately will a ping
+  // cancelled error and a duration of 0.0.
   ping(payload, callback) {
-    const state = this[kState];
-    if (state.destroyed || state.destroying)
+    if (this.destroyed)
       throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+
     if (typeof payload === 'function') {
       callback = payload;
       payload = undefined;
@@ -783,17 +870,21 @@ class Http2Session extends EventEmitter {
     }
     if (typeof callback !== 'function')
       throw new errors.TypeError('ERR_INVALID_CALLBACK');
-    return this[kHandle].ping(payload, pingCallback(callback));
+
+    const cb = pingCallback(callback);
+    if (this.connecting || this.closed) {
+      process.nextTick(cb, false, 0.0, payload);
+      return;
+    }
+
+    return this[kHandle].ping(payload, cb);
   }
 
   [kInspect](depth, opts) {
-    const state = this[kState];
     const obj = {
       type: this[kType],
-      destroyed: state.destroyed,
-      destroying: state.destroying,
-      shutdown: state.shutdown,
-      shuttingDown: state.shuttingDown,
+      closed: this.closed,
+      destroyed: this.destroyed,
       state: this.state,
       localSettings: this.localSettings,
       remoteSettings: this.remoteSettings
@@ -814,62 +905,60 @@ class Http2Session extends EventEmitter {
     return this[kType];
   }
 
+  // If a GOAWAY frame has been received, gives the error code specified
+  get goawayCode() {
+    return this[kState].goawayCode || NGHTTP2_NO_ERROR;
+  }
+
+  // If a GOAWAY frame has been received, gives the last stream ID reported
+  get goawayLastStreamID() {
+    return this[kState].goawayLastStreamID || 0;
+  }
+
   // true if the Http2Session is waiting for a settings acknowledgement
   get pendingSettingsAck() {
     return this[kState].pendingAck > 0;
   }
 
-  // true if the Http2Session has been destroyed
-  get destroyed() {
-    return this[kState].destroyed;
-  }
-
   // Retrieves state information for the Http2Session
   get state() {
-    const handle = this[kHandle];
-    return handle === undefined ? {} : getSessionState(handle);
+    return this.connecting || this.destroyed ?
+      {} : getSessionState(this[kHandle]);
   }
 
   // The settings currently in effect for the local peer. These will
   // be updated only when a settings acknowledgement has been received.
   get localSettings() {
-    let settings = this[kLocalSettings];
+    const settings = this[kLocalSettings];
     if (settings !== undefined)
       return settings;
 
-    const handle = this[kHandle];
-    if (handle === undefined)
+    if (this.destroyed || this.connecting)
       return {};
 
-    settings = getSettings(handle, false); // Local
-    this[kLocalSettings] = settings;
-    return settings;
+    return this[kLocalSettings] = getSettings(this[kHandle], false); // Local
   }
 
   // The settings currently in effect for the remote peer.
   get remoteSettings() {
-    let settings = this[kRemoteSettings];
+    const settings = this[kRemoteSettings];
     if (settings !== undefined)
       return settings;
 
-    const handle = this[kHandle];
-    if (handle === undefined)
+    if (this.destroyed || this.connecting)
       return {};
 
-    settings = getSettings(handle, true); // Remote
-    this[kRemoteSettings] = settings;
-    return settings;
+    return this[kRemoteSettings] = getSettings(this[kHandle], true); // Remote
   }
 
   // Submits a SETTINGS frame to be sent to the remote peer.
   settings(settings) {
-    const state = this[kState];
-    if (state.destroyed || state.destroying)
+    if (this.destroyed)
       throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
 
-    // Validate the input first
     assertIsObject(settings, 'settings');
     settings = validateSettings(settings);
+    const state = this[kState];
     if (state.pendingAck === state.maxPendingAck) {
       throw new errors.Error('ERR_HTTP2_MAX_PENDING_SETTINGS_ACK',
                              this[kState].pendingAck);
@@ -878,107 +967,144 @@ class Http2Session extends EventEmitter {
 
     state.pendingAck++;
     const settingsFn = submitSettings.bind(this, settings);
-    if (state.connecting) {
+    if (this.connecting) {
       this.once('connect', settingsFn);
       return;
     }
     settingsFn();
   }
 
-  // Destroy the Http2Session
-  destroy() {
-    const state = this[kState];
-    if (state.destroyed || state.destroying)
-      return;
-    debug(`Http2Session ${sessionName(this[kType])}: destroying`);
-    state.destroying = true;
-    state.destroyed = false;
-
-    // Unenroll the timer
-    this.setTimeout(0, sessionOnTimeout);
-
-    // Shut down any still open streams
-    const streams = state.streams;
-    streams.forEach((stream) => stream.destroy());
-
-    // Disassociate from the socket and server
-    const socket = this[kSocket];
-    // socket.pause();
-    delete this[kProxySocket];
-    delete this[kSocket];
-    delete this[kServer];
+  // Sumits a GOAWAY frame to be sent to the remote peer. Note that this
+  // is only a notification, and does not affect the usable state of the
+  // session with the notable exception that new incoming streams will
+  // be rejected automatically.
+  goaway(code = NGHTTP2_NO_ERROR, lastStreamID = 0, opaqueData) {
+    if (this.destroyed)
+      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
 
-    if (this[kHandle] !== undefined)
-      this[kHandle].destroying();
+    if (opaqueData !== undefined && !isArrayBufferView(opaqueData)) {
+      throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
+                                 'opaqueData',
+                                 ['Buffer', 'TypedArray', 'DataView']);
+    }
+    if (typeof code !== 'number') {
+      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'code', 'number');
+    }
+    if (typeof lastStreamID !== 'number') {
+      throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
+                                 'lastStreamID', 'number');
+    }
 
-    setImmediate(finishSessionDestroy.bind(this), socket);
+    const goawayFn = submitGoaway.bind(this, code, lastStreamID, opaqueData);
+    if (this.connecting) {
+      this.once('connect', goawayFn);
+      return;
+    }
+    goawayFn();
   }
 
-  // Graceful or immediate shutdown of the Http2Session. Graceful shutdown
-  // is only supported on the server-side
-  shutdown(options, callback) {
-    const state = this[kState];
-    if (state.destroyed || state.destroying)
-      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
-
-    if (state.shutdown || state.shuttingDown)
+  // Destroy the Http2Session, making it no longer usable and cancelling
+  // any pending activity.
+  destroy(error = NGHTTP2_NO_ERROR, code) {
+    if (this.destroyed)
       return;
+    debug(`Http2Session ${sessionName(this[kType])}: destroying`);
 
-    const type = this[kType];
-
-    if (typeof options === 'function') {
-      callback = options;
-      options = undefined;
+    if (typeof error === 'number') {
+      code = error;
+      error =
+        code !== NGHTTP2_NO_ERROR ?
+          new errors.Error('ERR_HTTP2_SESSION_ERROR', code) : undefined;
     }
+    if (code === undefined && error != null)
+      code = NGHTTP2_INTERNAL_ERROR;
 
-    assertIsObject(options, 'options');
-    options = Object.assign(Object.create(null), options);
+    const state = this[kState];
+    state.flags |= SESSION_FLAGS_DESTROYED;
 
-    if (options.opaqueData !== undefined &&
-        !isArrayBufferView(options.opaqueData)) {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'opaqueData',
-                                 options.opaqueData);
-    }
-    if (type === NGHTTP2_SESSION_SERVER &&
-        options.graceful !== undefined &&
-        typeof options.graceful !== 'boolean') {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'graceful',
-                                 options.graceful);
-    }
-    if (options.errorCode !== undefined &&
-        typeof options.errorCode !== 'number') {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'errorCode',
-                                 options.errorCode);
-    }
-    if (options.lastStreamID !== undefined &&
-        (typeof options.lastStreamID !== 'number' ||
-         options.lastStreamID < 0)) {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'lastStreamID',
-                                 options.lastStreamID);
-    }
+    // Clear timeout and remove timeout listeners
+    unenroll(this);
+    this.removeAllListeners('timeout');
+
+    // Destroy any pending and open streams
+    const cancel = new errors.Error('ERR_HTTP2_STREAM_CANCEL');
+    state.pendingStreams.forEach((stream) => stream.destroy(cancel));
+    state.streams.forEach((stream) => stream.destroy(error));
+
+    // Disassociate from the socket and server
+    const socket = this[kSocket];
+    const handle = this[kHandle];
 
-    debug(`Http2Session ${sessionName(type)}: initiating shutdown`);
-    state.shuttingDown = true;
+    // Destroy the handle if it exists at this point
+    if (handle !== undefined)
+      handle.destroy(code, socket.destroyed);
 
-    if (callback) {
-      this.on('shutdown', callback);
+    // If there is no error, use setImmediate to destroy the socket on the
+    // next iteration of the event loop in order to give data time to transmit.
+    // Otherwise, destroy immediately.
+    if (!socket.destroyed) {
+      if (!error) {
+        setImmediate(socket.end.bind(socket));
+      } else {
+        socket.destroy(error);
+      }
     }
 
-    const shutdownFn = submitShutdown.bind(this, options);
-    if (state.connecting) {
-      this.once('connect', shutdownFn);
+    this[kProxySocket] = undefined;
+    this[kSocket] = undefined;
+    this[kHandle] = undefined;
+    socket[kSession] = undefined;
+    socket[kServer] = undefined;
+
+    // Finally, emit the close and error events (if necessary) on next tick.
+    process.nextTick(emitClose, this, error);
+  }
+
+  // Closing the session will:
+  // 1. Send a goaway frame
+  // 2. Mark the session as closed
+  // 3. Prevent new inbound or outbound streams from being opened
+  // 4. Optionally register a 'close' event handler
+  // 5. Will cause the session to automatically destroy after the
+  //    last currently open Http2Stream closes.
+  //
+  // Close always assumes a good, non-error shutdown (NGHTTP_NO_ERROR)
+  //
+  // If the session has not connected yet, the closed flag will still be
+  // set but the goaway will not be sent until after the connect event
+  // is emitted.
+  close(callback) {
+    if (this.closed || this.destroyed)
       return;
+    debug(`Http2Session ${sessionName(this[kType])}: marking session closed`);
+    this[kState].flags |= SESSION_FLAGS_CLOSED;
+    if (typeof callback === 'function')
+      this.once('close', callback);
+    this.goaway();
+    this[kMaybeDestroy]();
+  }
+
+  // Destroy the session if:
+  // * error is not undefined/null
+  // * session is closed and there are no more pending or open streams
+  [kMaybeDestroy](error) {
+    if (error == null) {
+      const state = this[kState];
+      // Do not destroy if we're not closed and there are pending/open streams
+      if (!this.closed ||
+          state.streams.size > 0 ||
+          state.pendingStreams.size > 0) {
+        return;
+      }
     }
-
-    debug(`Http2Session ${sessionName(type)}: sending shutdown`);
-    shutdownFn();
+    this.destroy(error);
   }
 
   _onTimeout() {
+    // If the session is destroyed, this should never actually be invoked,
+    // but just in case...
+    if (this.destroyed)
+      return;
     // This checks whether a write is currently in progress and also whether
     // that write is actually sending data across the write. The kHandle
     // stored `chunksSentSinceLastWrite` is only updated when a timeout event
@@ -999,6 +1125,9 @@ class Http2Session extends EventEmitter {
   }
 }
 
+// ServerHttp2Session instances should never have to wait for the socket
+// to connect as they are always created after the socket has already been
+// established.
 class ServerHttp2Session extends Http2Session {
   constructor(options, socket, server) {
     super(NGHTTP2_SESSION_SERVER, options, socket);
@@ -1010,6 +1139,10 @@ class ServerHttp2Session extends Http2Session {
   }
 }
 
+// ClientHttp2Session instances have to wait for the socket to connect after
+// they have been created. Various operations such as request() may be used,
+// but the actual protocol communication will only occur after the socket
+// has been connected.
 class ClientHttp2Session extends Http2Session {
   constructor(options, socket) {
     super(NGHTTP2_SESSION_CLIENT, options, socket);
@@ -1018,11 +1151,14 @@ class ClientHttp2Session extends Http2Session {
   // Submits a new HTTP2 request to the connected peer. Returns the
   // associated Http2Stream instance.
   request(headers, options) {
-    const state = this[kState];
-    if (state.destroyed || state.destroying)
-      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
     debug(`Http2Session ${sessionName(this[kType])}: initiating request`);
 
+    if (this.destroyed)
+      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+
+    if (this.closed)
+      throw new errors.Error('ERR_HTTP2_GOAWAY_SESSION');
+
     this[kUpdateTimer]();
 
     assertIsObject(headers, 'headers');
@@ -1072,15 +1208,19 @@ class ClientHttp2Session extends Http2Session {
                                  options.getTrailers);
     }
 
+    const headersList = mapToHeaders(headers);
+    if (!Array.isArray(headersList))
+      throw headersList;
+
     const stream = new ClientHttp2Stream(this, undefined, undefined, {});
 
     // Close the writable side of the stream if options.endStream is set.
     if (options.endStream)
       stream.end();
 
-    const onConnect = requestOnConnect.bind(stream, headers, options);
-    if (state.connecting) {
-      stream.on('connect', onConnect);
+    const onConnect = requestOnConnect.bind(stream, headersList, options);
+    if (this.connecting) {
+      this.on('connect', onConnect);
     } else {
       onConnect();
     }
@@ -1128,60 +1268,45 @@ function afterDoStreamWrite(status, handle, req) {
 
   if (session !== undefined)
     session[kState].writeQueueSize -= bytes;
-
   if (typeof req.callback === 'function')
-    req.callback();
+    req.callback(null);
   req.handle = undefined;
 }
 
 function onHandleFinish() {
+  const handle = this[kHandle];
   if (this[kID] === undefined) {
     this.once('ready', onHandleFinish);
-  } else {
-    const handle = this[kHandle];
-    if (handle !== undefined) {
-      const req = new ShutdownWrap();
-      req.oncomplete = () => {};
-      req.handle = handle;
-      handle.shutdown(req);
-    }
+  } else if (handle !== undefined) {
+    const req = new ShutdownWrap();
+    req.oncomplete = () => {};
+    req.handle = handle;
+    handle.shutdown(req);
   }
 }
 
-function onSessionClose(hadError, code) {
-  abort(this);
-  this.push(null);  // Close the readable side
-  this.end();       // Close the writable side
-}
-
 function streamOnResume() {
-  if (this[kID] === undefined) {
-    this.once('ready', streamOnResume);
-    return;
-  }
-  this[kHandle].readStart();
+  if (!this.destroyed && !this.pending)
+    this[kHandle].readStart();
 }
 
 function streamOnPause() {
-  this[kHandle].readStop();
-}
-
-function handleFlushData(handle) {
-  handle.flushData();
+  // if (!this.destroyed && !this.pending)
+  //   this[kHandle].readStop();
 }
 
-function streamOnSessionConnect() {
-  const session = this[kSession];
-  debug(`Http2Session ${sessionName(session[kType])}: session connected`);
-  this[kState].connecting = false;
-  process.nextTick(emit, this, 'connect');
+function handleFlushData(self) {
+  if (!this.destroyed && !this.pending)
+    this[kHandle].flushData();
 }
 
+// If the writable side of the Http2Stream is still open, emit the
+// 'aborted' event and set the aborted flag.
 function abort(stream) {
-  if (!stream[kState].aborted &&
+  if (!stream.aborted &&
       !(stream._writableState.ended || stream._writableState.ending)) {
-    stream.emit('aborted');
-    stream[kState].aborted = true;
+    process.nextTick(emit, stream, 'aborted');
+    stream[kState].flags |= STREAM_FLAGS_ABORTED;
   }
 }
 
@@ -1193,37 +1318,41 @@ class Http2Stream extends Duplex {
     options.decodeStrings = false;
     super(options);
     this[async_id_symbol] = -1;
+
+    // Corking the stream automatically allows writes to happen
+    // but ensures that those are buffered until the handle has
+    // been assigned.
     this.cork();
     this[kSession] = session;
+    session[kState].pendingStreams.add(this);
 
-    const state = this[kState] = {
-      rst: false,
+    this[kState] = {
+      flags: STREAM_FLAGS_PENDING,
       rstCode: NGHTTP2_NO_ERROR,
-      headersSent: false,
-      headRequest: false,
-      aborted: false,
-      closeHandler: onSessionClose.bind(this),
       writeQueueSize: 0
     };
 
     this.once('finish', onHandleFinish);
     this.on('resume', streamOnResume);
     this.on('pause', streamOnPause);
-    session.once('close', state.closeHandler);
-
-    if (session[kState].connecting) {
-      state.connecting = true;
-      session.once('connect', streamOnSessionConnect.bind(this));
-    }
   }
 
   [kUpdateTimer]() {
+    if (this.destroyed)
+      return;
     _unrefActive(this);
     if (this[kSession])
       _unrefActive(this[kSession]);
   }
 
   [kInit](id, handle) {
+    const state = this[kState];
+    state.flags |= STREAM_FLAGS_READY;
+
+    const session = this[kSession];
+    session[kState].pendingStreams.delete(this);
+    session[kState].streams.set(id, this);
+
     this[kID] = id;
     this[async_id_symbol] = handle.getAsyncId();
     handle[kOwner] = this;
@@ -1237,7 +1366,9 @@ class Http2Stream extends Duplex {
 
   [kInspect](depth, opts) {
     const obj = {
-      id: this[kID],
+      id: this[kID] || '<pending>',
+      closed: this.closed,
+      destroyed: this.destroyed,
       state: this.state,
       readableState: this._readableState,
       writableState: this._writableState
@@ -1245,6 +1376,10 @@ class Http2Stream extends Duplex {
     return `Http2Stream ${util.format(obj)}`;
   }
 
+  get pending() {
+    return this[kID] === undefined;
+  }
+
   // The id of the Http2Stream, will be undefined if the socket is not
   // yet connected.
   get id() {
@@ -1257,6 +1392,8 @@ class Http2Stream extends Duplex {
   }
 
   _onTimeout() {
+    if (this.destroyed)
+      return;
     // This checks whether a write is currently in progress and also whether
     // that write is actually sending data across the write. The kHandle
     // stored `chunksSentSinceLastWrite` is only updated when a timeout event
@@ -1276,19 +1413,24 @@ class Http2Stream extends Duplex {
     process.nextTick(emit, this, 'timeout');
   }
 
+  // true if the HEADERS frame has been sent
+  get headersSent() {
+    return !!(this[kState].flags & STREAM_FLAGS_HEADERS_SENT);
+  }
+
   // true if the Http2Stream was aborted abornomally.
   get aborted() {
-    return this[kState].aborted;
+    return !!(this[kState].flags & STREAM_FLAGS_ABORTED);
   }
 
   // true if dealing with a HEAD request
   get headRequest() {
-    return this[kState].headRequest;
+    return !!(this[kState].flags & STREAM_FLAGS_HEAD_REQUEST);
   }
 
   // The error code reported when this Http2Stream was closed.
   get rstCode() {
-    return this[kState].rst ? this[kState].rstCode : undefined;
+    return this[kState].rstCode;
   }
 
   // State information for the Http2Stream
@@ -1306,14 +1448,26 @@ class Http2Stream extends Duplex {
   }
 
   _write(data, encoding, cb) {
-    if (this[kID] === undefined) {
+    // When the Http2Stream is first created, it is corked until the
+    // handle and the stream ID is assigned. However, if the user calls
+    // uncork() before that happens, the Duplex will attempt to pass
+    // writes through. Those need to be queued up here.
+    if (this.pending) {
       this.once('ready', this._write.bind(this, data, encoding, cb));
       return;
     }
 
-    this[kUpdateTimer]();
+    // If the stream has been destroyed, there's nothing else we can do
+    // because the handle has been destroyed. This should only be an
+    // issue if a write occurs before the 'ready' event in the case where
+    // the duplex is uncorked before the stream is ready to go. In that
+    // case, drop the data on the floor. An error should have already been
+    // emitted.
+    if (this.destroyed)
+      return;
 
-    if (!this[kState].headersSent)
+    this[kUpdateTimer]();
+    if (!this.headersSent)
       this[kProceed]();
 
     const handle = this[kHandle];
@@ -1330,14 +1484,27 @@ class Http2Stream extends Duplex {
   }
 
   _writev(data, cb) {
-    if (this[kID] === undefined) {
+    // When the Http2Stream is first created, it is corked until the
+    // handle and the stream ID is assigned. However, if the user calls
+    // uncork() before that happens, the Duplex will attempt to pass
+    // writes through. Those need to be queued up here.
+    if (this.pending) {
       this.once('ready', this._writev.bind(this, data, cb));
       return;
     }
 
+    // If the stream has been destroyed, there's nothing else we can do
+    // because the handle has been destroyed. This should only be an
+    // issue if a write occurs before the 'ready' event in the case where
+    // the duplex is uncorked before the stream is ready to go. In that
+    // case, drop the data on the floor. An error should have already been
+    // emitted.
+    if (this.destroyed)
+      return;
+
     this[kUpdateTimer]();
 
-    if (!this[kState].headersSent)
+    if (!this.headersSent)
       this[kProceed]();
 
     const handle = this[kHandle];
@@ -1364,47 +1531,12 @@ class Http2Stream extends Duplex {
       this.push(null);
       return;
     }
-    if (this[kHandle] !== undefined)
-      process.nextTick(handleFlushData, this[kHandle]);
-  }
-
-  // Submits an RST-STREAM frame to shutdown this stream.
-  // If the stream ID has not yet been allocated, the action will
-  // defer until the ready event is emitted.
-  // After sending the rstStream, this.destroy() will be called making
-  // the stream object no longer usable.
-  rstStream(code = NGHTTP2_NO_ERROR) {
-    if (typeof code !== 'number')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'code', 'number');
-    if (code < 0 || code > kMaxInt)
-      throw new errors.RangeError('ERR_OUT_OF_RANGE', 'code');
-
-    const rstStreamFn = submitRstStream.bind(this, code);
-    if (this[kID] === undefined) {
-      this.once('ready', rstStreamFn);
-      return;
+    const flushfn = handleFlushData.bind(this);
+    if (!this.pending) {
+      flushfn();
+    } else {
+      this.once('ready', flushfn);
     }
-    rstStreamFn();
-  }
-
-  rstWithNoError() {
-    this.rstStream(NGHTTP2_NO_ERROR);
-  }
-
-  rstWithProtocolError() {
-    this.rstStream(NGHTTP2_PROTOCOL_ERROR);
-  }
-
-  rstWithCancel() {
-    this.rstStream(NGHTTP2_CANCEL);
-  }
-
-  rstWithRefuse() {
-    this.rstStream(NGHTTP2_REFUSED_STREAM);
-  }
-
-  rstWithInternalError() {
-    this.rstStream(NGHTTP2_INTERNAL_ERROR);
   }
 
   priority(options) {
@@ -1416,86 +1548,144 @@ class Http2Stream extends Duplex {
     validatePriorityOptions(options);
 
     const priorityFn = submitPriority.bind(this, options);
-    if (this[kID] === undefined) {
+
+    // If the handle has not yet been assigned, queue up the priority
+    // frame to be sent as soon as the ready event is emitted.
+    if (this.pending) {
       this.once('ready', priorityFn);
       return;
     }
     priorityFn();
   }
 
-  // Called by this.destroy().
-  // * If called before the stream is allocated, will defer until the
-  //   ready event is emitted.
-  // * Will submit an RST stream to shutdown the stream if necessary.
-  //   This will cause the internal resources to be released.
-  // * Then cleans up the resources on the js side
-  _destroy(err, callback) {
-    const session = this[kSession];
-    if (this[kID] === undefined) {
-      this.once('ready', this._destroy.bind(this, err, callback));
-      return;
-    }
+  get closed() {
+    return !!(this[kState].flags & STREAM_FLAGS_CLOSED);
+  }
+
+  // Close initiates closing the Http2Stream instance by sending an RST_STREAM
+  // frame to the connected peer. The readable and writable sides of the
+  // Http2Stream duplex are closed and the timeout timer is unenrolled. If
+  // a callback is passed, it is registered to listen for the 'close' event.
+  //
+  // If the handle and stream ID have not been assigned yet, the close
+  // will be queued up to wait for the ready event. As soon as the stream ID
+  // is determined, the close will proceed.
+  //
+  // Submitting the RST_STREAM frame to the underlying handle will cause
+  // the Http2Stream to be closed and ultimately destroyed. After calling
+  // close, it is still possible to queue up PRIORITY and RST_STREAM frames,
+  // but no DATA and HEADERS frames may be sent.
+  close(code = NGHTTP2_NO_ERROR, callback) {
+    if (typeof code !== 'number')
+      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'code', 'number');
+    if (code < 0 || code > kMaxInt)
+      throw new errors.RangeError('ERR_OUT_OF_RANGE', 'code');
 
-    debug(`Http2Stream ${this[kID]} [Http2Session ` +
-          `${sessionName(session[kType])}]: destroying stream`);
+    // Unenroll the timeout.
+    unenroll(this);
+    this.removeAllListeners('timeout');
+
+    // Close the writable
+    abort(this);
+    this.end();
+
+    if (this.closed)
+      return;
 
     const state = this[kState];
-    session[kState].writeQueueSize -= state.writeQueueSize;
-    state.writeQueueSize = 0;
+    state.flags |= STREAM_FLAGS_CLOSED;
+    state.rstCode = code;
 
-    const server = session[kServer];
-    if (server !== undefined && err) {
-      server.emit('streamError', err, this);
+    if (callback !== undefined) {
+      if (typeof callback !== 'function')
+        throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      this.once('close', callback);
     }
 
-    process.nextTick(continueStreamDestroy.bind(this), err, callback);
-  }
-}
-
-function continueStreamDestroy(err, callback) {
-  const session = this[kSession];
-  const state = this[kState];
+    if (this[kHandle] === undefined)
+      return;
 
-  // Submit RST-STREAM frame if one hasn't been sent already and the
-  // stream hasn't closed normally...
-  const rst = state.rst;
-  let code = state.rstCode;
-  if (!rst && !session.destroyed) {
-    code = err instanceof Error ? NGHTTP2_INTERNAL_ERROR : NGHTTP2_NO_ERROR;
-    this.rstStream(code);
+    const rstStreamFn = submitRstStream.bind(this, code);
+    // If the handle has not yet been assigned, queue up the request to
+    // ensure that the RST_STREAM frame is sent after the stream ID has
+    // been determined.
+    if (this.pending) {
+      this.push(null);
+      this.once('ready', rstStreamFn);
+      return;
+    }
+    rstStreamFn();
   }
 
-  // Remove the close handler on the session
-  session.removeListener('close', state.closeHandler);
+  // Called by this.destroy().
+  // * Will submit an RST stream to shutdown the stream if necessary.
+  //   This will cause the internal resources to be released.
+  // * Then cleans up the resources on the js side
+  _destroy(err, callback) {
+    const session = this[kSession];
+    const handle = this[kHandle];
+    const id = this[kID];
 
-  // Unenroll the timer
-  this.setTimeout(0);
+    debug(`Http2Stream ${this[kID] || '<pending>'} [Http2Session ` +
+          `${sessionName(session[kType])}]: destroying stream`);
+    const state = this[kState];
+    const code = state.rstCode =
+      err != null ?
+        NGHTTP2_INTERNAL_ERROR :
+        state.rstCode || NGHTTP2_NO_ERROR;
+    if (handle !== undefined) {
+      // If the handle exists, we need to close, then destroy the handle
+      this.close(code);
+      if (!this._readableState.ended && !this._readableState.ending)
+        this.push(null);
+      handle.destroy();
+      session[kState].streams.delete(id);
+    } else {
+      unenroll(this);
+      this.removeAllListeners('timeout');
+      state.flags |= STREAM_FLAGS_CLOSED;
+      abort(this);
+      this.end();
+      this.push(null);
+      session[kState].pendingStreams.delete(this);
+    }
 
-  setImmediate(finishStreamDestroy.bind(this));
+    // Adjust the write queue size for accounting
+    session[kState].writeQueueSize -= state.writeQueueSize;
+    state.writeQueueSize = 0;
 
-  // RST code 8 not emitted as an error as its used by clients to signify
-  // abort and is already covered by aborted event, also allows more
-  // seamless compatibility with http1
-  if (code !== NGHTTP2_NO_ERROR && code !== NGHTTP2_CANCEL && !err) {
-    err = new errors.Error('ERR_HTTP2_STREAM_ERROR', code);
-  }
-  callback(err);
-  abort(this);
-  this.push(null);  // Close the readable side
-  this.end();       // Close the writable side
-  process.nextTick(emit, this, 'close', code);
-}
+    // RST code 8 not emitted as an error as its used by clients to signify
+    // abort and is already covered by aborted event, also allows more
+    // seamless compatibility with http1
+    if (err == null && code !== NGHTTP2_NO_ERROR && code !== NGHTTP2_CANCEL)
+      err = new errors.Error('ERR_HTTP2_STREAM_ERROR', code);
 
-function finishStreamDestroy() {
-  const id = this[kID];
-  this[kSession][kState].streams.delete(id);
-  this[kSession] = undefined;
-  const handle = this[kHandle];
-  if (handle !== undefined) {
+    this[kSession] = undefined;
     this[kHandle] = undefined;
-    handle.destroy();
+
+    // This notifies the session that this stream has been destroyed and
+    // gives the session the opportunity to clean itself up. The session
+    // will destroy if it has been closed and there are no other open or
+    // pending streams.
+    session[kMaybeDestroy]();
+    process.nextTick(emit, this, 'close', code);
+    callback(err);
+  }
+
+  // The Http2Stream can be destroyed if it has closed and if the readable
+  // side has received the final chunk.
+  [kMaybeDestroy](error, code = NGHTTP2_NO_ERROR, hasData = true) {
+    if (error == null) {
+      if (code === NGHTTP2_NO_ERROR &&
+          ((!this._readableState.ended && hasData) ||
+          !this._writableState.ended ||
+          this._writableState.pendingcb > 0 ||
+          !this.closed)) {
+        return;
+      }
+    }
+    this.destroy(error);
   }
-  this.emit('destroy');
 }
 
 function processHeaders(headers) {
@@ -1509,7 +1699,7 @@ function processHeaders(headers) {
   // This is intentionally stricter than the HTTP/1 implementation, which
   // allows values between 100 and 999 (inclusive) in order to allow for
   // backwards compatibility with non-spec compliant code. With HTTP/2,
-  // we have the opportunity to start fresh with stricter spec copmliance.
+  // we have the opportunity to start fresh with stricter spec compliance.
   // This will have an impact on the compatibility layer for anyone using
   // non-standard, non-compliant status codes.
   if (statusCode < 200 || statusCode > 599)
@@ -1519,36 +1709,47 @@ function processHeaders(headers) {
   return headers;
 }
 
-function processRespondWithFD(fd, headers, offset = 0, length = -1,
+function processRespondWithFD(self, fd, headers, offset = 0, length = -1,
                               streamOptions = 0) {
-  const state = this[kState];
-  state.headersSent = true;
+  const state = self[kState];
+  state.flags |= STREAM_FLAGS_HEADERS_SENT;
+
+  const headersList = mapToHeaders(headers, assertValidPseudoHeaderResponse);
+  if (!Array.isArray(headersList)) {
+    self.destroy(headersList);
+    return;
+  }
+
 
   // Close the writable side of the stream
-  this.end();
+  self.end();
 
-  const ret = this[kHandle].respondFD(fd, headers,
+  const ret = self[kHandle].respondFD(fd, headersList,
                                       offset, length,
                                       streamOptions);
 
   if (ret < 0) {
-    const err = new NghttpError(ret);
-    process.nextTick(emit, this, 'error', err);
+    self.destroy(new NghttpError(ret));
     return;
   }
   // exact length of the file doesn't matter here, since the
   // stream is closing anyway — just use 1 to signify that
   // a write does exist
-  trackWriteState(this, 1);
+  trackWriteState(self, 1);
 }
 
 function doSendFD(session, options, fd, headers, streamOptions, err, stat) {
-  if (this.destroyed || session.destroyed) {
-    abort(this);
+  if (err) {
+    this.destroy(err);
     return;
   }
-  if (err) {
-    process.nextTick(emit, this, 'error', err);
+
+  // This can happen if the stream is destroyed or closed while we are waiting
+  // for the file descriptor to be opened or the stat call to be completed.
+  // In either case, we do not want to continue because the we are shutting
+  // down and should not attempt to send any data.
+  if (this.destroyed || this.closed) {
+    this.destroy(new errors.Error('ERR_HTTP2_INVALID_STREAM'));
     return;
   }
 
@@ -1557,47 +1758,47 @@ function doSendFD(session, options, fd, headers, streamOptions, err, stat) {
     length: options.length !== undefined ? options.length : -1
   };
 
-  if (typeof options.statCheck === 'function' &&
-      options.statCheck.call(this, stat, headers, statOptions) === false) {
-    return;
-  }
-
-  const headersList = mapToHeaders(headers,
-                                   assertValidPseudoHeaderResponse);
-  if (!Array.isArray(headersList)) {
-    process.nextTick(emit, this, 'error', headersList);
+  // options.statCheck is a user-provided function that can be used to
+  // verify stat values, override or set headers, or even cancel the
+  // response operation. If statCheck explicitly returns false, the
+  // response is canceled. The user code may also send a separate type
+  // of response so check again for the HEADERS_SENT flag
+  if ((typeof options.statCheck === 'function' &&
+       options.statCheck.call(this, stat, headers, statOptions) === false) ||
+       (this[kState].flags & STREAM_FLAGS_HEADERS_SENT)) {
     return;
   }
 
-  processRespondWithFD.call(this, fd, headersList,
-                            statOptions.offset,
-                            statOptions.length,
-                            streamOptions);
+  processRespondWithFD(this, fd, headers,
+                       statOptions.offset | 0,
+                       statOptions.length | 0,
+                       streamOptions);
 }
 
 function doSendFileFD(session, options, fd, headers, streamOptions, err, stat) {
-  if (this.destroyed || session.destroyed) {
-    abort(this);
-    return;
-  }
   const onError = options.onError;
 
   if (err) {
-    if (onError) {
+    tryClose(fd);
+    if (onError)
       onError(err);
-    } else {
+    else
       this.destroy(err);
-    }
     return;
   }
 
   if (!stat.isFile()) {
-    err = new errors.Error('ERR_HTTP2_SEND_FILE');
-    if (onError) {
+    const err = new errors.Error('ERR_HTTP2_SEND_FILE');
+    if (onError)
       onError(err);
-    } else {
+    else
       this.destroy(err);
-    }
+    return;
+  }
+
+  if (this.destroyed || this.closed) {
+    tryClose(fd);
+    this.destroy(new errors.Error('ERR_HTTP2_INVALID_STREAM'));
     return;
   }
 
@@ -1606,9 +1807,14 @@ function doSendFileFD(session, options, fd, headers, streamOptions, err, stat) {
     length: options.length !== undefined ? options.length : -1
   };
 
-  // Set the content-length by default
-  if (typeof options.statCheck === 'function' &&
-      options.statCheck.call(this, stat, headers) === false) {
+  // options.statCheck is a user-provided function that can be used to
+  // verify stat values, override or set headers, or even cancel the
+  // response operation. If statCheck explicitly returns false, the
+  // response is canceled. The user code may also send a separate type
+  // of response so check again for the HEADERS_SENT flag
+  if ((typeof options.statCheck === 'function' &&
+       options.statCheck.call(this, stat, headers) === false) ||
+       (this[kState].flags & STREAM_FLAGS_HEADERS_SENT)) {
     return;
   }
 
@@ -1617,35 +1823,27 @@ function doSendFileFD(session, options, fd, headers, streamOptions, err, stat) {
       Math.min(stat.size - (+statOptions.offset),
                statOptions.length);
 
-  if (headers[HTTP2_HEADER_CONTENT_LENGTH] === undefined)
-    headers[HTTP2_HEADER_CONTENT_LENGTH] = statOptions.length;
+  headers[HTTP2_HEADER_CONTENT_LENGTH] = statOptions.length;
 
-  const headersList = mapToHeaders(headers,
-                                   assertValidPseudoHeaderResponse);
-  if (!Array.isArray(headersList)) {
-    process.nextTick(emit, this, 'error', headersList);
-    return;
-  }
-
-  processRespondWithFD.call(this, fd, headersList,
-                            options.offset,
-                            options.length,
-                            streamOptions);
+  processRespondWithFD(this, fd, headers,
+                       options.offset | 0,
+                       statOptions.length | 0,
+                       streamOptions);
 }
 
 function afterOpen(session, options, headers, streamOptions, err, fd) {
   const state = this[kState];
   const onError = options.onError;
-  if (this.destroyed || session.destroyed) {
-    abort(this);
-    return;
-  }
   if (err) {
-    if (onError) {
+    if (onError)
       onError(err);
-    } else {
+    else
       this.destroy(err);
-    }
+    return;
+  }
+  if (this.destroyed || this.closed) {
+    tryClose(fd);
+    abort(this);
     return;
   }
   state.fd = fd;
@@ -1658,8 +1856,6 @@ function afterOpen(session, options, headers, streamOptions, err, fd) {
 function streamOnError(err) {
   // we swallow the error for parity with HTTP1
   // all the errors that ends here are not critical for the project
-  debug(`Http2Stream ${this[kID]} [Http2Session ` +
-        `${this[kSession][kType]}: error`, err);
 }
 
 
@@ -1672,25 +1868,22 @@ class ServerHttp2Stream extends Http2Stream {
     this.on('error', streamOnError);
   }
 
-  // true if the HEADERS frame has been sent
-  get headersSent() {
-    return this[kState].headersSent;
-  }
-
   // true if the remote peer accepts push streams
   get pushAllowed() {
-    return this[kSession].remoteSettings.enablePush;
+    return !this.destroyed &&
+           !this.closed &&
+           !this.session.closed &&
+           !this.session.destroyed &&
+           this[kSession].remoteSettings.enablePush;
   }
 
   // create a push stream, call the given callback with the created
   // Http2Stream for the push stream.
   pushStream(headers, options, callback) {
-    if (this.destroyed)
-      throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
+    if (!this.pushAllowed)
+      throw new errors.Error('ERR_HTTP2_PUSH_DISABLED');
 
     const session = this[kSession];
-    if (!session.remoteSettings.enablePush)
-      throw new errors.Error('ERR_HTTP2_PUSH_DISABLED');
 
     debug(`Http2Stream ${this[kID]} [Http2Session ` +
           `${sessionName(session[kType])}]: initiating push stream`);
@@ -1740,44 +1933,45 @@ class ServerHttp2Stream extends Http2Stream {
           err = new errors.Error('ERR_HTTP2_OUT_OF_STREAMS');
           break;
         case NGHTTP2_ERR_STREAM_CLOSED:
-          err = new errors.Error('ERR_HTTP2_STREAM_CLOSED');
+          err = new errors.Error('ERR_HTTP2_INVALID_STREAM');
           break;
         default:
           err = new NghttpError(ret);
           break;
       }
-      process.nextTick(emit, this, 'error', err);
+      process.nextTick(callback, err);
       return;
     }
 
     const id = ret.id();
     const stream = new ServerHttp2Stream(session, ret, id, options, headers);
-    session[kState].streams.set(id, stream);
 
     if (options.endStream)
       stream.end();
 
     if (headRequest)
-      stream[kState].headRequest = true;
+      stream[kState].flags |= STREAM_FLAGS_HEAD_REQUEST;
 
-    process.nextTick(callback, stream, headers, 0);
+    process.nextTick(callback, null, stream, headers, 0);
   }
 
   // Initiate a response on this Http2Stream
   respond(headers, options) {
-    const session = this[kSession];
-    if (this.destroyed)
+    if (this.destroyed || this.closed)
       throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
-    debug(`Http2Stream ${this[kID]} [Http2Session ` +
-          `${sessionName(session[kType])}]: initiating response`);
-    this[kUpdateTimer]();
-    const state = this[kState];
-
-    if (state.headersSent)
+    if (this.headersSent)
       throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
 
+    const state = this[kState];
+
     assertIsObject(options, 'options');
     options = Object.assign({}, options);
+
+    const session = this[kSession];
+    debug(`Http2Stream ${this[kID]} [Http2Session ` +
+          `${sessionName(session[kType])}]: initiating response`);
+    this[kUpdateTimer]();
+
     options.endStream = !!options.endStream;
 
     let streamOptions = 0;
@@ -1803,7 +1997,7 @@ class ServerHttp2Stream extends Http2Stream {
     if (statusCode === HTTP_STATUS_NO_CONTENT ||
         statusCode === HTTP_STATUS_RESET_CONTENT ||
         statusCode === HTTP_STATUS_NOT_MODIFIED ||
-        state.headRequest === true) {
+        this.headRequest === true) {
       options.endStream = true;
     }
 
@@ -1811,17 +2005,15 @@ class ServerHttp2Stream extends Http2Stream {
     if (!Array.isArray(headersList))
       throw headersList;
 
-    state.headersSent = true;
+    state.flags |= STREAM_FLAGS_HEADERS_SENT;
 
     // Close the writable side if the endStream option is set
     if (options.endStream)
       this.end();
 
     const ret = this[kHandle].respond(headersList, streamOptions);
-    if (ret < 0) {
-      const err = new NghttpError(ret);
-      process.nextTick(emit, this, 'error', err);
-    }
+    if (ret < 0)
+      this.destroy(new NghttpError(ret));
   }
 
   // Initiate a response using an open FD. Note that there are fewer
@@ -1831,19 +2023,15 @@ class ServerHttp2Stream extends Http2Stream {
   // mechanism is not able to read from the fd, then the stream will be
   // reset with an error code.
   respondWithFD(fd, headers, options) {
-    const session = this[kSession];
-    if (this.destroyed)
+    if (this.destroyed || this.closed)
       throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
-    debug(`Http2Stream ${this[kID]} [Http2Session ` +
-          `${sessionName(session[kType])}]: initiating response`);
-    this[kUpdateTimer]();
-    const state = this[kState];
-
-    if (state.headersSent)
+    if (this.headersSent)
       throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
 
+    const session = this[kSession];
+
     assertIsObject(options, 'options');
-    options = Object.assign(Object.create(null), options);
+    options = Object.assign({}, options);
 
     if (options.offset !== undefined && typeof options.offset !== 'number')
       throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
@@ -1870,13 +2058,17 @@ class ServerHttp2Stream extends Http2Stream {
                                    options.getTrailers);
       }
       streamOptions |= STREAM_OPTION_GET_TRAILERS;
-      state.getTrailers = options.getTrailers;
+      this[kState].getTrailers = options.getTrailers;
     }
 
     if (typeof fd !== 'number')
       throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
                                  'fd', 'number');
 
+    debug(`Http2Stream ${this[kID]} [Http2Session ` +
+          `${sessionName(session[kType])}]: initiating response`);
+    this[kUpdateTimer]();
+
     headers = processHeaders(headers);
     const statusCode = headers[HTTP2_HEADER_STATUS] |= 0;
     // Payload/DATA frames are not permitted in these cases
@@ -1893,17 +2085,10 @@ class ServerHttp2Stream extends Http2Stream {
       return;
     }
 
-    const headersList = mapToHeaders(headers,
-                                     assertValidPseudoHeaderResponse);
-    if (!Array.isArray(headersList)) {
-      process.nextTick(emit, this, 'error', headersList);
-      return;
-    }
-
-    processRespondWithFD.call(this, fd, headersList,
-                              options.offset,
-                              options.length,
-                              streamOptions);
+    processRespondWithFD(this, fd, headers,
+                         options.offset,
+                         options.length,
+                         streamOptions);
   }
 
   // Initiate a file response on this Http2Stream. The path is passed to
@@ -1914,19 +2099,13 @@ class ServerHttp2Stream extends Http2Stream {
   // headers. If statCheck returns false, the operation is aborted and no
   // file details are sent.
   respondWithFile(path, headers, options) {
-    const session = this[kSession];
-    if (this.destroyed)
+    if (this.destroyed || this.closed)
       throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
-    debug(`Http2Stream ${this[kID]} [Http2Session ` +
-          `${sessionName(session[kType])}]: initiating response`);
-    this[kUpdateTimer]();
-    const state = this[kState];
-
-    if (state.headersSent)
+    if (this.headersSent)
       throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
 
     assertIsObject(options, 'options');
-    options = Object.assign(Object.create(null), options);
+    options = Object.assign({}, options);
 
     if (options.offset !== undefined && typeof options.offset !== 'number')
       throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
@@ -1953,9 +2132,15 @@ class ServerHttp2Stream extends Http2Stream {
                                    options.getTrailers);
       }
       streamOptions |= STREAM_OPTION_GET_TRAILERS;
-      state.getTrailers = options.getTrailers;
+      this[kState].getTrailers = options.getTrailers;
     }
 
+    const session = this[kSession];
+    debug(`Http2Stream ${this[kID]} [Http2Session ` +
+          `${sessionName(session[kType])}]: initiating response`);
+    this[kUpdateTimer]();
+
+
     headers = processHeaders(headers);
     const statusCode = headers[HTTP2_HEADER_STATUS] |= 0;
     // Payload/DATA frames are not permitted in these cases
@@ -1977,18 +2162,18 @@ class ServerHttp2Stream extends Http2Stream {
   // a 1xx informational code and it MUST be sent before the request/response
   // headers are sent, or an error will be thrown.
   additionalHeaders(headers) {
-    if (this.destroyed)
+    if (this.destroyed || this.closed)
       throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
-
-    if (this[kState].headersSent)
+    if (this.headersSent)
       throw new errors.Error('ERR_HTTP2_HEADERS_AFTER_RESPOND');
 
+    assertIsObject(headers, 'headers');
+    headers = Object.assign(Object.create(null), headers);
+
     const session = this[kSession];
     debug(`Http2Stream ${this[kID]} [Http2Session ` +
-          `${sessionName(session[kType])}]: sending additional headers`);
+    `${sessionName(session[kType])}]: sending additional headers`);
 
-    assertIsObject(headers, 'headers');
-    headers = Object.assign(Object.create(null), headers);
     if (headers[HTTP2_HEADER_STATUS] != null) {
       const statusCode = headers[HTTP2_HEADER_STATUS] |= 0;
       if (statusCode === HTTP_STATUS_SWITCHING_PROTOCOLS)
@@ -2001,17 +2186,13 @@ class ServerHttp2Stream extends Http2Stream {
 
     this[kUpdateTimer]();
 
-    const headersList = mapToHeaders(headers,
-                                     assertValidPseudoHeaderResponse);
-    if (!Array.isArray(headersList)) {
+    const headersList = mapToHeaders(headers, assertValidPseudoHeaderResponse);
+    if (!Array.isArray(headersList))
       throw headersList;
-    }
 
     const ret = this[kHandle].info(headersList);
-    if (ret < 0) {
-      const err = new NghttpError(ret);
-      process.nextTick(emit, this, 'error', err);
-    }
+    if (ret < 0)
+      this.destroy(new NghttpError(ret));
   }
 }
 
@@ -2020,7 +2201,7 @@ ServerHttp2Stream.prototype[kProceed] = ServerHttp2Stream.prototype.respond;
 class ClientHttp2Stream extends Http2Stream {
   constructor(session, handle, id, options) {
     super(session, options);
-    this[kState].headersSent = true;
+    this[kState].flags |= STREAM_FLAGS_HEADERS_SENT;
     if (id !== undefined)
       this[kInit](id, handle);
     this.on('headers', handleHeaderContinue);
@@ -2028,9 +2209,8 @@ class ClientHttp2Stream extends Http2Stream {
 }
 
 function handleHeaderContinue(headers) {
-  if (headers[HTTP2_HEADER_STATUS] === HTTP_STATUS_CONTINUE) {
+  if (headers[HTTP2_HEADER_STATUS] === HTTP_STATUS_CONTINUE)
     this.emit('continue');
-  }
 }
 
 const setTimeout = {
@@ -2038,6 +2218,8 @@ const setTimeout = {
   enumerable: true,
   writable: true,
   value: function(msecs, callback) {
+    if (this.destroyed)
+      return;
     if (typeof msecs !== 'number') {
       throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
                                  'msecs',
@@ -2065,91 +2247,44 @@ const setTimeout = {
 Object.defineProperty(Http2Stream.prototype, 'setTimeout', setTimeout);
 Object.defineProperty(Http2Session.prototype, 'setTimeout', setTimeout);
 
-// --------------------------------------------------------------------
 
-// Set as a replacement for socket.prototype.destroy upon the
-// establishment of a new connection.
-function socketDestroy(error) {
-  const session = this[kSession];
-  const type = session[kType];
-  debug(`Http2Session ${sessionName(type)}: socket destroy called`);
-  delete this[kServer];
-  // destroy the session first so that it will stop trying to
-  // send data while we close the socket.
-  session.destroy();
-  this.destroy = this[kDestroySocket];
-  this.destroy(error);
-}
-
-// When an Http2Session emits an error, first try to forward it to the
-// server as a sessionError; failing that, forward it to the socket as
-// a sessionError; failing that, destroy, remove the error listener, and
-// re-emit the error event
-function sessionOnError(error) {
-  debug(`Http2Session ${sessionName(this[kType])}: session error: ` +
-        `${error.message}`);
-  if (this[kServer] !== undefined && this[kServer].emit('sessionError', error))
-    return;
-  if (this[kSocket] !== undefined && this[kSocket].emit('sessionError', error))
-    return;
-  this.destroy();
-  this.removeListener('error', sessionOnError);
-  this.emit('error', error);
-}
-
-// When a Socket emits an error, forward it to the session as a
-// socketError; failing that, remove the listener and call destroy
+// When the socket emits an error, destroy the associated Http2Session and
+// foward it the same error.
 function socketOnError(error) {
   const session = this[kSession];
-  const type = session && session[kType];
-  debug(`Http2Session ${sessionName(type)}: socket error: ${error.message}`);
-  if (kRenegTest.test(error.message))
-    return this.destroy();
-  if (session !== undefined &&
-      session.emit('socketError', error, this))
-    return;
-  this.removeListener('error', socketOnError);
-  this.destroy(error);
+  if (session !== undefined) {
+    debug(`Http2Session ${sessionName(session[kType])}: socket error [` +
+          `${error.message}]`);
+    session.destroy(error);
+  }
 }
 
 // Handles the on('stream') event for a session and forwards
 // it on to the server object.
 function sessionOnStream(stream, headers, flags, rawHeaders) {
-  this[kServer].emit('stream', stream, headers, flags, rawHeaders);
+  if (this[kServer] !== undefined)
+    this[kServer].emit('stream', stream, headers, flags, rawHeaders);
 }
 
 function sessionOnPriority(stream, parent, weight, exclusive) {
-  debug(`Http2Session ${sessionName(this[kType])}: priority change received`);
-  this[kServer].emit('priority', stream, parent, weight, exclusive);
+  if (this[kServer] !== undefined)
+    this[kServer].emit('priority', stream, parent, weight, exclusive);
 }
 
-function sessionOnSocketError(error, socket) {
-  if (this.listenerCount('socketError') <= 1 && this[kServer] !== undefined)
-    this[kServer].emit('socketError', error, socket, this);
+function sessionOnError(error) {
+  if (this[kServer])
+    this[kServer].emit('sessionError', error, this);
 }
 
-// When the session times out on the server, attempt a graceful shutdown
+// When the session times out on the server, try emitting a timeout event.
+// If no handler is registered, destroy the session.
 function sessionOnTimeout() {
-  process.nextTick(() => {
-    const state = this[kState];
-    // if destroyed or destryoing, do nothing
-    if (state.destroyed || state.destroying)
-      return;
-    const server = this[kServer];
-    const socket = this[kSocket];
-    // If server or socket are undefined, then we're already in the process of
-    // shutting down, do nothing.
-    if (server === undefined || socket === undefined)
-      return;
-    if (!server.emit('timeout', this)) {
-      this.shutdown(
-        {
-          graceful: true,
-          errorCode: NGHTTP2_NO_ERROR
-        },
-        socket.destroy.bind(socket));
-    }
-  });
+  // if destroyed or closed already, do nothing
+  if (this.destroyed || this.closed)
+    return;
+  const server = this[kServer];
+  if (!server.emit('timeout', this))
+    this.destroy();  // No error code, just things down.
 }
 
 function connectionListener(socket) {
@@ -2161,10 +2296,9 @@ function connectionListener(socket) {
     if (options.allowHTTP1 === true)
       return httpConnectionListener.call(this, socket);
     // Let event handler deal with the socket
-    if (this.emit('unknownProtocol', socket))
-      return;
-    // Reject non-HTTP/2 client
-    return socket.destroy();
+    if (!this.emit('unknownProtocol', socket))
+      socket.destroy();
+    return;
   }
 
   socket.on('error', socketOnError);
@@ -2173,27 +2307,24 @@ function connectionListener(socket) {
   // Set up the Session
   const session = new ServerHttp2Session(options, socket, this);
 
-  session.on('error', sessionOnError);
   session.on('stream', sessionOnStream);
   session.on('priority', sessionOnPriority);
-  session.on('socketError', sessionOnSocketError);
+  session.on('error', sessionOnError);
 
-  if (this.timeout) {
-    session.setTimeout(this.timeout);
-    session.on('timeout', sessionOnTimeout);
-  }
+  if (this.timeout)
+    session.setTimeout(this.timeout, sessionOnTimeout);
 
   socket[kServer] = this;
 
-  process.nextTick(emit, this, 'session', session);
+  this.emit('session', session);
 }
 
 function initializeOptions(options) {
   assertIsObject(options, 'options');
-  options = Object.assign(Object.create(null), options);
+  options = Object.assign({}, options);
   options.allowHalfOpen = true;
   assertIsObject(options.settings, 'options.settings');
-  options.settings = Object.assign(Object.create(null), options.settings);
+  options.settings = Object.assign({}, options.settings);
   return options;
 }
 
@@ -2207,9 +2338,9 @@ function initializeTLSOptions(options, servername) {
   return options;
 }
 
-function onErrorSecureServerSession(err, conn) {
-  if (!this.emit('clientError', err, conn))
-    conn.destroy(err);
+function onErrorSecureServerSession(err, socket) {
+  if (!this.emit('clientError', err, socket))
+    socket.destroy(err);
 }
 
 class Http2SecureServer extends TLSServer {
@@ -2265,25 +2396,18 @@ function setupCompat(ev) {
 
 function socketOnClose() {
   const session = this[kSession];
-  if (session !== undefined && !session.destroyed) {
-    // Skip unconsume because the socket is destroyed.
-    session[kState].skipUnconsume = true;
-    session.destroy();
+  if (session !== undefined) {
+    debug(`Http2Session ${sessionName(session[kType])}: socket closed`);
+    const err = session.connecting ?
+      new errors.Error('ERR_SOCKET_CLOSED') : null;
+    const state = session[kState];
+    state.streams.forEach((stream) => stream.close(NGHTTP2_CANCEL));
+    state.pendingStreams.forEach((stream) => stream.close(NGHTTP2_CANCEL));
+    session.close();
+    session[kMaybeDestroy](err);
   }
 }
 
-// If the session emits an error, forward it to the socket as a sessionError;
-// failing that, destroy the session, remove the listener and re-emit the error
-function clientSessionOnError(error) {
-  debug(`Http2Session ${sessionName(this[kType])}]: session error: ` +
-        `${error.message}`);
-  if (this[kSocket] !== undefined && this[kSocket].emit('sessionError', error))
-    return;
-  this.destroy();
-  this.removeListener('error', socketOnError);
-  this.removeListener('error', clientSessionOnError);
-}
-
 function connect(authority, options, listener) {
   if (typeof options === 'function') {
     listener = options;
@@ -2291,7 +2415,7 @@ function connect(authority, options, listener) {
   }
 
   assertIsObject(options, 'options');
-  options = Object.assign(Object.create(null), options);
+  options = Object.assign({}, options);
 
   if (typeof authority === 'string')
     authority = new URL(authority);
@@ -2324,8 +2448,6 @@ function connect(authority, options, listener) {
 
   const session = new ClientHttp2Session(options, socket);
 
-  session.on('error', clientSessionOnError);
-
   session[kAuthority] = `${options.servername || host}:${port}`;
   session[kProtocol] = protocol;
 
@@ -2346,19 +2468,16 @@ Object.defineProperty(connect, promisify.custom, {
 });
 
 function createSecureServer(options, handler) {
-  if (options == null || typeof options !== 'object') {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                               'options',
-                               'Object');
-  }
+  assertIsObject(options, 'options');
   return new Http2SecureServer(options, handler);
 }
 
 function createServer(options, handler) {
   if (typeof options === 'function') {
     handler = options;
-    options = Object.create(null);
+    options = {};
   }
+  assertIsObject(options, 'options');
   return new Http2Server(options, handler);
 }
 
diff --git a/src/node_http2.cc b/src/node_http2.cc
index 1ce3c5cb46e231..ac785de4cd3196 100644
--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -23,13 +23,30 @@ using v8::Undefined;
 
 namespace http2 {
 
+// These configure the callbacks required by nghttp2 itself. There are
+// two sets of callback functions, one that is used if a padding callback
+// is set, and other that does not include the padding callback.
 const Http2Session::Callbacks Http2Session::callback_struct_saved[2] = {
     Callbacks(false),
     Callbacks(true)};
 
+// The Http2Scope object is used to queue a write to the i/o stream. It is
+// used whenever any action is take on the underlying nghttp2 API that may
+// push data into nghttp2 outbound data queue.
+//
+// For example:
+//
+// Http2Scope h2scope(session);
+// nghttp2_submit_ping(**session, ... );
+//
+// When the Http2Scope passes out of scope and is deconstructed, it will
+// call Http2Session::MaybeScheduleWrite().
 Http2Scope::Http2Scope(Http2Stream* stream) : Http2Scope(stream->session()) {}
 
 Http2Scope::Http2Scope(Http2Session* session) {
+  if (session == nullptr)
+    return;
+
   if (session->flags_ & (SESSION_STATE_HAS_SCOPE |
                          SESSION_STATE_WRITE_SCHEDULED)) {
     // There is another scope further below on the stack, or it is already
@@ -48,9 +65,19 @@ Http2Scope::~Http2Scope() {
   session_->MaybeScheduleWrite();
 }
 
+// The Http2Options object is used during the construction of Http2Session
+// instances to configure an appropriate nghttp2_options struct. The class
+// uses a single TypedArray instance that is shared with the JavaScript side
+// to more efficiently pass values back and forth.
 Http2Options::Http2Options(Environment* env) {
   nghttp2_option_new(&options_);
 
+  // We manually handle flow control within a session in order to
+  // implement backpressure -- that is, we only send WINDOW_UPDATE
+  // frames to the remote peer as data is actually consumed by user
+  // code. This ensures that the flow of data over the connection
+  // does not move too quickly and limits the amount of data we
+  // are required to buffer.
   nghttp2_option_set_no_auto_window_update(options_, 1);
 
   AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =
@@ -83,6 +110,10 @@ Http2Options::Http2Options(Environment* env) {
         buffer[IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS]);
   }
 
+  // The padding strategy sets the mechanism by which we determine how much
+  // additional frame padding to apply to DATA and HEADERS frames. Currently
+  // this is set on a per-session basis, but eventually we may switch to
+  // a per-stream setting, giving users greater control
   if (flags & (1 << IDX_OPTIONS_PADDING_STRATEGY)) {
     padding_strategy_type strategy =
         static_cast<padding_strategy_type>(
@@ -90,16 +121,27 @@ Http2Options::Http2Options(Environment* env) {
     SetPaddingStrategy(strategy);
   }
 
+  // The max header list pairs option controls the maximum number of
+  // header pairs the session may accept. This is a hard limit.. that is,
+  // if the remote peer sends more than this amount, the stream will be
+  // automatically closed with an RST_STREAM.
   if (flags & (1 << IDX_OPTIONS_MAX_HEADER_LIST_PAIRS)) {
     SetMaxHeaderPairs(buffer[IDX_OPTIONS_MAX_HEADER_LIST_PAIRS]);
   }
 
+  // The HTTP2 specification places no limits on the number of HTTP2
+  // PING frames that can be sent. In order to prevent PINGS from being
+  // abused as an attack vector, however, we place a strict upper limit
+  // on the number of unacknowledged PINGS that can be sent at any given
+  // time.
   if (flags & (1 << IDX_OPTIONS_MAX_OUTSTANDING_PINGS)) {
     SetMaxOutstandingPings(buffer[IDX_OPTIONS_MAX_OUTSTANDING_PINGS]);
   }
 }
 
-
+// The Http2Settings class is used to configure a SETTINGS frame that is
+// to be sent to the connected peer. The settings are set using a TypedArray
+// that is shared with the JavaScript side.
 Http2Settings::Http2Settings(Environment* env) : env_(env) {
   entries_.AllocateSufficientStorage(IDX_SETTINGS_COUNT);
   AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =
@@ -160,6 +202,9 @@ Http2Settings::Http2Settings(Environment* env) : env_(env) {
 }
 
 
+// Generates a Buffer that contains the serialized payload of a SETTINGS
+// frame. This can be used, for instance, to create the Base64-encoded
+// content of an Http2-Settings header field.
 inline Local<Value> Http2Settings::Pack() {
   const size_t len = count_ * 6;
   Local<Value> buf = Buffer::New(env_, len).ToLocalChecked();
@@ -173,27 +218,28 @@ inline Local<Value> Http2Settings::Pack() {
     return Undefined(env_->isolate());
 }
 
-
+// Updates the shared TypedArray with the current remote or local settings for
+// the session.
 inline void Http2Settings::Update(Environment* env,
                                   Http2Session* session,
                                   get_setting fn) {
   AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =
       env->http2_state()->settings_buffer;
   buffer[IDX_SETTINGS_HEADER_TABLE_SIZE] =
-      fn(session->session(), NGHTTP2_SETTINGS_HEADER_TABLE_SIZE);
+      fn(**session, NGHTTP2_SETTINGS_HEADER_TABLE_SIZE);
   buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS] =
-      fn(session->session(), NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);
+      fn(**session, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);
   buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE] =
-      fn(session->session(), NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE);
+      fn(**session, NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE);
   buffer[IDX_SETTINGS_MAX_FRAME_SIZE] =
-      fn(session->session(), NGHTTP2_SETTINGS_MAX_FRAME_SIZE);
+      fn(**session, NGHTTP2_SETTINGS_MAX_FRAME_SIZE);
   buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE] =
-      fn(session->session(), NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE);
+      fn(**session, NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE);
   buffer[IDX_SETTINGS_ENABLE_PUSH] =
-      fn(session->session(), NGHTTP2_SETTINGS_ENABLE_PUSH);
+      fn(**session, NGHTTP2_SETTINGS_ENABLE_PUSH);
 }
 
-
+// Initializes the shared TypedArray with the default settings values.
 inline void Http2Settings::RefreshDefaults(Environment* env) {
   AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =
       env->http2_state()->settings_buffer;
@@ -217,6 +263,9 @@ inline void Http2Settings::RefreshDefaults(Environment* env) {
 }
 
 
+// The Http2Priority class initializes an appropriate nghttp2_priority_spec
+// struct used when either creating a stream or updating its priority
+// settings.
 Http2Priority::Http2Priority(Environment* env,
                              Local<Value> parent,
                              Local<Value> weight,
@@ -241,7 +290,8 @@ inline const char* Http2Session::TypeName() {
   }
 }
 
-
+// The Headers class initializes a proper array of nghttp2_nv structs
+// containing the header name value pairs.
 Headers::Headers(Isolate* isolate,
                  Local<Context> context,
                  Local<Array> headers) {
@@ -299,8 +349,11 @@ Headers::Headers(Isolate* isolate,
 }
 
 
+// Sets the various callback functions that nghttp2 will use to notify us
+// about significant events while processing http2 stuff.
 Http2Session::Callbacks::Callbacks(bool kHasGetPaddingCallback) {
   CHECK_EQ(nghttp2_session_callbacks_new(&callbacks), 0);
+
   nghttp2_session_callbacks_set_on_begin_headers_callback(
     callbacks, OnBeginHeadersCallback);
   nghttp2_session_callbacks_set_on_header_callback2(
@@ -329,7 +382,6 @@ Http2Session::Callbacks::~Callbacks() {
   nghttp2_session_callbacks_del(callbacks);
 }
 
-
 Http2Session::Http2Session(Environment* env,
                            Local<Object> wrap,
                            nghttp2_session_type type)
@@ -337,6 +389,7 @@ Http2Session::Http2Session(Environment* env,
       session_type_(type) {
   MakeWeak<Http2Session>(this);
 
+  // Capture the configuration options for this session
   Http2Options opts(env);
 
   int32_t maxHeaderPairs = opts.GetMaxHeaderPairs();
@@ -368,37 +421,64 @@ Http2Session::Http2Session(Environment* env,
   CHECK_EQ(fn(&session_, callbacks, this, *opts), 0);
 }
 
+void Http2Session::Unconsume() {
+  if (stream_ != nullptr) {
+    DEBUG_HTTP2SESSION(this, "unconsuming the i/o stream");
+    stream_->set_destruct_cb({ nullptr, nullptr });
+    stream_->set_alloc_cb({ nullptr, nullptr });
+    stream_->set_read_cb({ nullptr, nullptr });
+    stream_->Unconsume();
+    stream_ = nullptr;
+  }
+}
 
 Http2Session::~Http2Session() {
+  if (!object().IsEmpty())
+    ClearWrap(object());
+  persistent().Reset();
   CHECK(persistent().IsEmpty());
-  Close();
+  Unconsume();
+  DEBUG_HTTP2SESSION(this, "freeing nghttp2 session");
+  nghttp2_session_del(session_);
 }
 
-
-void Http2Session::Close() {
+// Closes the session and frees the associated resources
+void Http2Session::Close(uint32_t code, bool socket_closed) {
   DEBUG_HTTP2SESSION(this, "closing session");
-  if (!object().IsEmpty())
-    ClearWrap(object());
-  persistent().Reset();
 
-  if (session_ == nullptr)
+  if (flags_ & SESSION_STATE_CLOSED)
     return;
+  flags_ |= SESSION_STATE_CLOSED;
+
+  // Stop reading on the i/o stream
+  if (stream_ != nullptr)
+    stream_->ReadStop();
+
+  // If the socket is not closed, then attempt to send a closing GOAWAY
+  // frame. There is no guarantee that this GOAWAY will be received by
+  // the peer but the HTTP/2 spec recommends sendinng it anyway. We'll
+  // make a best effort.
+  if (!socket_closed) {
+    Http2Scope h2scope(this);
+    DEBUG_HTTP2SESSION2(this, "terminating session with code %d", code);
+    CHECK_EQ(nghttp2_session_terminate_session(session_, code), 0);
+  } else {
+    Unconsume();
+  }
 
-  CHECK_EQ(nghttp2_session_terminate_session(session_, NGHTTP2_NO_ERROR), 0);
-  nghttp2_session_del(session_);
-  session_ = nullptr;
-
+  // If there are outstanding pings, those will need to be canceled, do
+  // so on the next iteration of the event loop to avoid calling out into
+  // javascript since this may be called during garbage collection.
   while (!outstanding_pings_.empty()) {
     Http2Session::Http2Ping* ping = PopPing();
-    // Since this method may be called from GC, calling into JS directly
-    // is not allowed.
     env()->SetImmediate([](Environment* env, void* data) {
       static_cast<Http2Session::Http2Ping*>(data)->Done(false);
     }, static_cast<void*>(ping));
   }
 }
 
-
+// Locates an existing known stream by ID. nghttp2 has a similar method
+// but this is faster and does not fail if the stream is not found.
 inline Http2Stream* Http2Session::FindStream(int32_t id) {
   auto s = streams_.find(id);
   return s != streams_.end() ? s->second : nullptr;
@@ -414,14 +494,18 @@ inline void Http2Session::RemoveStream(int32_t id) {
   streams_.erase(id);
 }
 
-
+// Used as one of the Padding Strategy functions. Uses the maximum amount
+// of padding allowed for the current frame.
 inline ssize_t Http2Session::OnMaxFrameSizePadding(size_t frameLen,
                                                    size_t maxPayloadLen) {
   DEBUG_HTTP2SESSION2(this, "using max frame size padding: %d", maxPayloadLen);
   return maxPayloadLen;
 }
 
-
+// Used as one of the Padding Strategy functions. Uses a callback to JS land
+// to determine the amount of padding for the current frame. This option is
+// rather more expensive because of the JS boundary cross. It generally should
+// not be the preferred option.
 inline ssize_t Http2Session::OnCallbackPadding(size_t frameLen,
                                                size_t maxPayloadLen) {
   DEBUG_HTTP2SESSION(this, "using callback to determine padding");
@@ -448,20 +532,10 @@ inline ssize_t Http2Session::OnCallbackPadding(size_t frameLen,
 }
 
 
-// Submits a graceful shutdown notice to nghttp
-// See: https://nghttp2.org/documentation/nghttp2_submit_shutdown_notice.html
-inline void Http2Session::SubmitShutdownNotice() {
-  // Only an HTTP2 Server is permitted to send a shutdown notice
-  if (session_type_ == NGHTTP2_SESSION_CLIENT)
-    return;
-  DEBUG_HTTP2SESSION(this, "sending shutdown notice");
-  // The only situation where this should fail is if the system is
-  // out of memory, which will cause other problems. Go ahead and crash
-  // in that case.
-  CHECK_EQ(nghttp2_submit_shutdown_notice(session_), 0);
-}
-
-
+// Sends a SETTINGS frame to the connected peer. This has the side effect of
+// changing the settings state within the nghttp2_session, but those will
+// only be considered active once the connected peer acknowledges the SETTINGS
+// frame.
 // Note: This *must* send a SETTINGS frame even if niv == 0
 inline void Http2Session::Settings(const nghttp2_settings_entry iv[],
                                    size_t niv) {
@@ -475,25 +549,40 @@ inline void Http2Session::Settings(const nghttp2_settings_entry iv[],
 
 
 // Write data received from the i/o stream to the underlying nghttp2_session.
+// On each call to nghttp2_session_mem_recv, nghttp2 will begin calling the
+// various callback functions. Each of these will typically result in a call
+// out to JavaScript so this particular function is rather hot and can be
+// quite expensive. This is a potential performance optimization target later.
 inline ssize_t Http2Session::Write(const uv_buf_t* bufs, size_t nbufs) {
   size_t total = 0;
   // Note that nghttp2_session_mem_recv is a synchronous operation that
   // will trigger a number of other callbacks. Those will, in turn have
   // multiple side effects.
   for (size_t n = 0; n < nbufs; n++) {
+    DEBUG_HTTP2SESSION2(this, "receiving %d bytes [wants data? %d]",
+                        bufs[n].len,
+                        nghttp2_session_want_read(session_));
     ssize_t ret =
       nghttp2_session_mem_recv(session_,
                                reinterpret_cast<uint8_t*>(bufs[n].base),
                                bufs[n].len);
     CHECK_NE(ret, NGHTTP2_ERR_NOMEM);
 
-    if (ret < 0)
+    // If there is an error calling any of the callbacks, ret will be a
+    // negative number identifying the error code. This can happen, for
+    // instance, if the session is destroyed during any of the JS callbacks
+    // Note: if ssize_t is not defined (e.g. on Win32), nghttp2 will typedef
+    // ssize_t to int. Cast here so that the < 0 check actually works on
+    // Windows.
+    if (static_cast<int>(ret) < 0)
       return ret;
 
     total += ret;
   }
   // Send any data that was queued up while processing the received data.
-  SendPendingData();
+  if (!IsDestroyed()) {
+    SendPendingData();
+  }
   return total;
 }
 
@@ -506,6 +595,10 @@ inline int32_t GetFrameID(const nghttp2_frame* frame) {
 }
 
 
+// Called by nghttp2 at the start of receiving a HEADERS frame. We use this
+// callback to determine if a new stream is being created or if we are simply
+// adding a new block of headers to an existing stream. The header pairs
+// themselves are set in the OnHeaderCallback
 inline int Http2Session::OnBeginHeadersCallback(nghttp2_session* handle,
                                                 const nghttp2_frame* frame,
                                                 void* user_data) {
@@ -517,12 +610,17 @@ inline int Http2Session::OnBeginHeadersCallback(nghttp2_session* handle,
   if (stream == nullptr) {
     new Http2Stream(session, id, frame->headers.cat);
   } else {
+    // If the stream has already been destroyed, ignore.
+    if (stream->IsDestroyed())
+      return 0;
     stream->StartHeaders(frame->headers.cat);
   }
   return 0;
 }
 
-
+// Called by nghttp2 for each header name/value pair in a HEADERS block.
+// This had to have been preceeded by a call to OnBeginHeadersCallback so
+// the Http2Stream is guaranteed to already exist.
 inline int Http2Session::OnHeaderCallback(nghttp2_session* handle,
                                           const nghttp2_frame* frame,
                                           nghttp2_rcbuf* name,
@@ -532,6 +630,10 @@ inline int Http2Session::OnHeaderCallback(nghttp2_session* handle,
   Http2Session* session = static_cast<Http2Session*>(user_data);
   int32_t id = GetFrameID(frame);
   Http2Stream* stream = session->FindStream(id);
+  CHECK_NE(stream, nullptr);
+  // If the stream has already been destroyed, ignore.
+  if (stream->IsDestroyed())
+    return 0;
   if (!stream->AddHeader(name, value, flags)) {
     // This will only happen if the connected peer sends us more
     // than the allowed number of header items at any given time
@@ -542,6 +644,8 @@ inline int Http2Session::OnHeaderCallback(nghttp2_session* handle,
 }
 
 
+// Called by nghttp2 when a complete HTTP2 frame has been received. There are
+// only a handful of frame types tha we care about handling here.
 inline int Http2Session::OnFrameReceive(nghttp2_session* handle,
                                         const nghttp2_frame* frame,
                                         void* user_data) {
@@ -575,6 +679,12 @@ inline int Http2Session::OnFrameReceive(nghttp2_session* handle,
 }
 
 
+// If nghttp2 is unable to send a queued up frame, it will call this callback
+// to let us know. If the failure occurred because we are in the process of
+// closing down the session or stream, we go ahead and ignore it. We don't
+// really care about those and there's nothing we can reasonably do about it
+// anyway. Other types of failures are reported up to JavaScript. This should
+// be exceedingly rare.
 inline int Http2Session::OnFrameNotSent(nghttp2_session* handle,
                                         const nghttp2_frame* frame,
                                         int error_code,
@@ -602,7 +712,7 @@ inline int Http2Session::OnFrameNotSent(nghttp2_session* handle,
   return 0;
 }
 
-
+// Called by nghttp2 when a stream closes.
 inline int Http2Session::OnStreamClose(nghttp2_session* handle,
                                        int32_t id,
                                        uint32_t code,
@@ -615,17 +725,24 @@ inline int Http2Session::OnStreamClose(nghttp2_session* handle,
   Context::Scope context_scope(context);
   DEBUG_HTTP2SESSION2(session, "stream %d closed with code: %d", id, code);
   Http2Stream* stream = session->FindStream(id);
-  // Intentionally ignore the callback if the stream does not exist
-  if (stream != nullptr) {
+  // Intentionally ignore the callback if the stream does not exist or has
+  // already been destroyed
+  if (stream != nullptr && !stream->IsDestroyed()) {
+    stream->AddChunk(nullptr, 0);
     stream->Close(code);
     // It is possible for the stream close to occur before the stream is
     // ever passed on to the javascript side. If that happens, skip straight
-    // to destroying the stream
+    // to destroying the stream. We can check this by looking for the
+    // onstreamclose function. If it exists, then the stream has already
+    // been passed on to javascript.
     Local<Value> fn =
         stream->object()->Get(context, env->onstreamclose_string())
             .ToLocalChecked();
     if (fn->IsFunction()) {
-      Local<Value> argv[1] = { Integer::NewFromUnsigned(isolate, code) };
+      Local<Value> argv[2] = {
+        Integer::NewFromUnsigned(isolate, code),
+        Boolean::New(isolate, stream->HasDataChunks(true))
+      };
       stream->MakeCallback(fn.As<Function>(), arraysize(argv), argv);
     } else {
       stream->Destroy();
@@ -634,7 +751,10 @@ inline int Http2Session::OnStreamClose(nghttp2_session* handle,
   return 0;
 }
 
-
+// Called by nghttp2 when an invalid header has been received. For now, we
+// ignore these. If this callback was not provided, nghttp2 would handle
+// invalid headers strictly and would shut down the stream. We are intentionally
+// being more lenient here although we may want to revisit this choice later.
 inline int Http2Session::OnInvalidHeader(nghttp2_session* session,
                                          const nghttp2_frame* frame,
                                          nghttp2_rcbuf* name,
@@ -645,7 +765,10 @@ inline int Http2Session::OnInvalidHeader(nghttp2_session* session,
   return 0;
 }
 
-
+// When nghttp2 receives a DATA frame, it will deliver the data payload to
+// us in discrete chunks. We push these into a linked list stored in the
+// Http2Sttream which is flushed out to JavaScript as quickly as possible.
+// This can be a particularly hot path.
 inline int Http2Session::OnDataChunkReceived(nghttp2_session* handle,
                                              uint8_t flags,
                                              int32_t id,
@@ -658,30 +781,39 @@ inline int Http2Session::OnDataChunkReceived(nghttp2_session* handle,
   // We should never actually get a 0-length chunk so this check is
   // only a precaution at this point.
   if (len > 0) {
+    // Notify nghttp2 that we've consumed a chunk of data on the connection
+    // so that it can send a WINDOW_UPDATE frame. This is a critical part of
+    // the flow control process in http2
     CHECK_EQ(nghttp2_session_consume_connection(handle, len), 0);
     Http2Stream* stream = session->FindStream(id);
+    // If the stream has been destroyed, ignore this chunk
+    if (stream->IsDestroyed())
+      return 0;
     stream->AddChunk(data, len);
   }
   return 0;
 }
 
-
-inline ssize_t Http2Session::OnSelectPadding(nghttp2_session* session,
+// Called by nghttp2 when it needs to determine how much padding to use in
+// a DATA or HEADERS frame.
+inline ssize_t Http2Session::OnSelectPadding(nghttp2_session* handle,
                                              const nghttp2_frame* frame,
                                              size_t maxPayloadLen,
                                              void* user_data) {
-  Http2Session* handle = static_cast<Http2Session*>(user_data);
+  Http2Session* session = static_cast<Http2Session*>(user_data);
   ssize_t padding = frame->hd.length;
 
-  return handle->padding_strategy_ == PADDING_STRATEGY_MAX
-    ? handle->OnMaxFrameSizePadding(padding, maxPayloadLen)
-    : handle->OnCallbackPadding(padding, maxPayloadLen);
+  return session->padding_strategy_ == PADDING_STRATEGY_MAX
+    ? session->OnMaxFrameSizePadding(padding, maxPayloadLen)
+    : session->OnCallbackPadding(padding, maxPayloadLen);
 }
 
 #define BAD_PEER_MESSAGE "Remote peer returned unexpected data while we "     \
                          "expected SETTINGS frame.  Perhaps, peer does not "  \
                          "support HTTP/2 properly."
 
+// We use this currently to determine when an attempt is made to use the http2
+// protocol with a non-http2 peer.
 inline int Http2Session::OnNghttpError(nghttp2_session* handle,
                                        const char* message,
                                        size_t len,
@@ -705,9 +837,11 @@ inline int Http2Session::OnNghttpError(nghttp2_session* handle,
   return 0;
 }
 
-
+// Once all of the DATA frames for a Stream have been sent, the GetTrailers
+// method calls out to JavaScript to fetch the trailing headers that need
+// to be sent.
 inline void Http2Session::GetTrailers(Http2Stream* stream, uint32_t* flags) {
-  if (stream->HasTrailers()) {
+  if (!stream->IsDestroyed() && stream->HasTrailers()) {
     Http2Stream::SubmitTrailers submit_trailers{this, stream, flags};
     stream->OnTrailers(submit_trailers);
   }
@@ -734,6 +868,9 @@ inline void Http2Stream::SubmitTrailers::Submit(nghttp2_nv* trailers,
 }
 
 
+// Called by OnFrameReceived to notify JavaScript land that a complete
+// HEADERS frame has been received and processed. This method converts the
+// received headers into a JavaScript array and pushes those out to JS.
 inline void Http2Session::HandleHeadersFrame(const nghttp2_frame* frame) {
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
@@ -744,6 +881,10 @@ inline void Http2Session::HandleHeadersFrame(const nghttp2_frame* frame) {
   DEBUG_HTTP2SESSION2(this, "handle headers frame for stream %d", id);
   Http2Stream* stream = FindStream(id);
 
+  // If the stream has already been destroyed, ignore.
+  if (stream->IsDestroyed())
+    return;
+
   nghttp2_header* headers = stream->headers();
   size_t count = stream->headers_count();
 
@@ -795,6 +936,10 @@ inline void Http2Session::HandleHeadersFrame(const nghttp2_frame* frame) {
 }
 
 
+// Called by OnFrameReceived when a complete PRIORITY frame has been
+// received. Notifies JS land about the priority change. Note that priorities
+// are considered advisory only, so this has no real effect other than to
+// simply let user code know that the priority has changed.
 inline void Http2Session::HandlePriorityFrame(const nghttp2_frame* frame) {
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
@@ -817,11 +962,19 @@ inline void Http2Session::HandlePriorityFrame(const nghttp2_frame* frame) {
 }
 
 
+// Called by OnFrameReceived when a complete DATA frame has been received.
+// If we know that this is the last DATA frame (because the END_STREAM flag
+// is set), then we'll terminate the readable side of the StreamBase. If
+// the StreamBase is flowing, we'll push the chunks of data out to JS land.
 inline void Http2Session::HandleDataFrame(const nghttp2_frame* frame) {
   int32_t id = GetFrameID(frame);
   DEBUG_HTTP2SESSION2(this, "handling data frame for stream %d", id);
   Http2Stream* stream = FindStream(id);
 
+  // If the stream has already been destroyed, do nothing
+  if (stream->IsDestroyed())
+    return;
+
   if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
     stream->AddChunk(nullptr, 0);
   }
@@ -831,6 +984,7 @@ inline void Http2Session::HandleDataFrame(const nghttp2_frame* frame) {
 }
 
 
+// Called by OnFrameReceived when a complete GOAWAY frame has been received.
 inline void Http2Session::HandleGoawayFrame(const nghttp2_frame* frame) {
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
@@ -856,6 +1010,7 @@ inline void Http2Session::HandleGoawayFrame(const nghttp2_frame* frame) {
   MakeCallback(env()->ongoawaydata_string(), arraysize(argv), argv);
 }
 
+// Called by OnFrameReceived when a complete PING frame has been received.
 inline void Http2Session::HandlePingFrame(const nghttp2_frame* frame) {
   bool ack = frame->hd.flags & NGHTTP2_FLAG_ACK;
   if (ack) {
@@ -865,7 +1020,7 @@ inline void Http2Session::HandlePingFrame(const nghttp2_frame* frame) {
   }
 }
 
-
+// Called by OnFrameReceived when a complete SETTINGS frame has been received.
 inline void Http2Session::HandleSettingsFrame(const nghttp2_frame* frame) {
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
@@ -878,6 +1033,10 @@ inline void Http2Session::HandleSettingsFrame(const nghttp2_frame* frame) {
   MakeCallback(env()->onsettings_string(), arraysize(argv), argv);
 }
 
+// If the underlying nghttp2_session struct has data pending in its outbound
+// queue, MaybeScheduleWrite will schedule a SendPendingData() call to occcur
+// on the next iteration of the Node.js event loop (using the SetImmediate
+// queue), but only if a write has not already been scheduled.
 void Http2Session::MaybeScheduleWrite() {
   CHECK_EQ(flags_ & SESSION_STATE_WRITE_SCHEDULED, 0);
   if (session_ != nullptr && nghttp2_session_want_write(session_)) {
@@ -900,16 +1059,24 @@ void Http2Session::MaybeScheduleWrite() {
   }
 }
 
-
+// Prompts nghttp2 to begin serializing it's pending data and pushes each
+// chunk out to the i/o socket to be sent. This is a particularly hot method
+// that will generally be called at least twice be event loop iteration.
+// This is a potential performance optimization target later.
 void Http2Session::SendPendingData() {
   DEBUG_HTTP2SESSION(this, "sending pending data");
   // Do not attempt to send data on the socket if the destroying flag has
   // been set. That means everything is shutting down and the socket
   // will not be usable.
-  if (IsDestroying())
+  if (IsDestroyed())
     return;
   flags_ &= ~SESSION_STATE_WRITE_SCHEDULED;
 
+  // SendPendingData should not be called recursively.
+  if (flags_ & SESSION_STATE_SENDING)
+    return;
+  flags_ |= SESSION_STATE_SENDING;
+
   WriteWrap* req = nullptr;
   char* dest = nullptr;
   size_t destRemaining = 0;
@@ -958,14 +1125,17 @@ void Http2Session::SendPendingData() {
     }
   }
   CHECK_NE(srcLength, NGHTTP2_ERR_NOMEM);
-
-  if (destLength > 0) {
+  if (destLength > 0 && srcLength >= 0) {
     DEBUG_HTTP2SESSION2(this, "pushing %d bytes to the socket", destLength);
     Send(req, dest, destLength);
   }
-}
+  DEBUG_HTTP2SESSION2(this, "wants data in return? %d",
+                      nghttp2_session_want_read(session_));
 
+  flags_ &= ~SESSION_STATE_SENDING;
+}
 
+// Creates a new Http2Stream and submits a new http2 request.
 inline Http2Stream* Http2Session::SubmitRequest(
     nghttp2_priority_spec* prispec,
     nghttp2_nv* nva,
@@ -987,7 +1157,7 @@ inline void Http2Session::SetChunksSinceLastWrite(size_t n) {
   chunks_sent_since_last_write_ = n;
 }
 
-
+// Allocates the data buffer used to pass outbound data to the i/o stream.
 WriteWrap* Http2Session::AllocateSend() {
   HandleScope scope(env()->isolate());
   Local<Object> obj =
@@ -1002,12 +1172,11 @@ WriteWrap* Http2Session::AllocateSend() {
   return WriteWrap::New(env(), obj, stream_, size + 9);
 }
 
+// Pushes chunks of data to the i/o stream.
 void Http2Session::Send(WriteWrap* req, char* buf, size_t length) {
-  DEBUG_HTTP2SESSION(this, "attempting to send data");
-  if (stream_ == nullptr || !stream_->IsAlive() || stream_->IsClosing()) {
+  DEBUG_HTTP2SESSION2(this, "attempting to send %d bytes", length);
+  if (stream_ == nullptr)
     return;
-  }
-
   chunks_sent_since_last_write_++;
   uv_buf_t actual = uv_buf_init(buf, length);
   if (stream_->DoWrite(req, &actual, 1, nullptr)) {
@@ -1015,7 +1184,7 @@ void Http2Session::Send(WriteWrap* req, char* buf, size_t length) {
   }
 }
 
-
+// Allocates the data buffer used to receive inbound data from the i/o stream
 void Http2Session::OnStreamAllocImpl(size_t suggested_size,
                                      uv_buf_t* buf,
                                      void* ctx) {
@@ -1024,13 +1193,14 @@ void Http2Session::OnStreamAllocImpl(size_t suggested_size,
   buf->len = kAllocBufferSize;
 }
 
-
+// Callback used to receive inbound data from the i/o stream
 void Http2Session::OnStreamReadImpl(ssize_t nread,
                                     const uv_buf_t* bufs,
                                     uv_handle_type pending,
                                     void* ctx) {
   Http2Session* session = static_cast<Http2Session*>(ctx);
   Http2Scope h2scope(session);
+  DEBUG_HTTP2SESSION2(session, "receiving %d bytes", nread);
   if (nread < 0) {
     uv_buf_t tmp_buf;
     tmp_buf.base = nullptr;
@@ -1041,19 +1211,42 @@ void Http2Session::OnStreamReadImpl(ssize_t nread,
                               session->prev_read_cb_.ctx);
     return;
   }
-  if (nread > 0) {
+  if (bufs->len > 0) {
     // Only pass data on if nread > 0
     uv_buf_t buf[] { uv_buf_init((*bufs).base, nread) };
     ssize_t ret = session->Write(buf, 1);
-    if (ret < 0) {
+
+    // Note: if ssize_t is not defined (e.g. on Win32), nghttp2 will typedef
+    // ssize_t to int. Cast here so that the < 0 check actually works on
+    // Windows.
+    if (static_cast<int>(ret) < 0) {
       DEBUG_HTTP2SESSION2(session, "fatal error receiving data: %d", ret);
-      CHECK_EQ(nghttp2_session_terminate_session(session->session(),
-                                                 NGHTTP2_PROTOCOL_ERROR), 0);
+      Environment* env = session->env();
+      Isolate* isolate = env->isolate();
+      HandleScope scope(isolate);
+      Local<Context> context = env->context();
+      Context::Scope context_scope(context);
+
+      Local<Value> argv[1] = {
+        Integer::New(isolate, ret),
+      };
+      session->MakeCallback(env->error_string(), arraysize(argv), argv);
+    } else {
+      DEBUG_HTTP2SESSION2(session, "processed %d bytes. wants more? %d", ret,
+                          nghttp2_session_want_read(**session));
     }
   }
 }
 
+void Http2Session::OnStreamDestructImpl(void* ctx) {
+  Http2Session* session = static_cast<Http2Session*>(ctx);
+  session->stream_ = nullptr;
+}
 
+// Every Http2Session session is tightly bound to a single i/o StreamBase
+// (typically a net.Socket or tls.TLSSocket). The lifecycle of the two is
+// tightly coupled with all data transfer between the two happening at the
+// C++ layer via the StreamBase API.
 void Http2Session::Consume(Local<External> external) {
   StreamBase* stream = static_cast<StreamBase*>(external->Value());
   stream->Consume();
@@ -1062,24 +1255,11 @@ void Http2Session::Consume(Local<External> external) {
   prev_read_cb_ = stream->read_cb();
   stream->set_alloc_cb({ Http2Session::OnStreamAllocImpl, this });
   stream->set_read_cb({ Http2Session::OnStreamReadImpl, this });
+  stream->set_destruct_cb({ Http2Session::OnStreamDestructImpl, this });
   DEBUG_HTTP2SESSION(this, "i/o stream consumed");
 }
 
 
-void Http2Session::Unconsume() {
-  if (prev_alloc_cb_.is_empty())
-    return;
-  stream_->set_alloc_cb(prev_alloc_cb_);
-  stream_->set_read_cb(prev_read_cb_);
-  prev_alloc_cb_.clear();
-  prev_read_cb_.clear();
-  stream_ = nullptr;
-  DEBUG_HTTP2SESSION(this, "i/o stream unconsumed");
-}
-
-
-
-
 Http2Stream::Http2Stream(
     Http2Session* session,
     int32_t id,
@@ -1119,26 +1299,37 @@ Http2Stream::Http2Stream(
 
 
 Http2Stream::~Http2Stream() {
-  CHECK(persistent().IsEmpty());
+  if (session_ != nullptr) {
+    session_->RemoveStream(id_);
+    session_ = nullptr;
+  }
+
   if (!object().IsEmpty())
     ClearWrap(object());
   persistent().Reset();
+  CHECK(persistent().IsEmpty());
 }
 
+// Notify the Http2Stream that a new block of HEADERS is being processed.
 void Http2Stream::StartHeaders(nghttp2_headers_category category) {
   DEBUG_HTTP2STREAM2(this, "starting headers, category: %d", id_, category);
+  CHECK(!this->IsDestroyed());
   current_headers_length_ = 0;
   current_headers_.clear();
   current_headers_category_ = category;
 }
 
+
 nghttp2_stream* Http2Stream::operator*() {
   return nghttp2_session_find_stream(**session_, id_);
 }
 
 
+// Calls out to JavaScript land to fetch the actual trailer headers to send
+// for this stream.
 void Http2Stream::OnTrailers(const SubmitTrailers& submit_trailers) {
   DEBUG_HTTP2STREAM(this, "prompting for trailers");
+  CHECK(!this->IsDestroyed());
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
   Local<Context> context = env()->context();
@@ -1146,7 +1337,7 @@ void Http2Stream::OnTrailers(const SubmitTrailers& submit_trailers) {
 
   Local<Value> ret =
       MakeCallback(env()->ontrailers_string(), 0, nullptr).ToLocalChecked();
-  if (!ret.IsEmpty()) {
+  if (!ret.IsEmpty() && !IsDestroyed()) {
     if (ret->IsArray()) {
       Local<Array> headers = ret.As<Array>();
       if (headers->Length() > 0) {
@@ -1157,21 +1348,36 @@ void Http2Stream::OnTrailers(const SubmitTrailers& submit_trailers) {
   }
 }
 
+inline bool Http2Stream::HasDataChunks(bool ignore_eos) {
+  return data_chunks_.size() > (ignore_eos ? 1 : 0);
+}
 
+// Appends a chunk of received DATA frame data to this Http2Streams internal
+// queue. Note that we must memcpy each chunk because of the way that nghttp2
+// handles it's internal memory`.
 inline void Http2Stream::AddChunk(const uint8_t* data, size_t len) {
+  CHECK(!this->IsDestroyed());
+  if (flags_ & NGHTTP2_STREAM_FLAG_EOS)
+    return;
   char* buf = nullptr;
-  if (len > 0) {
+  if (len > 0 && data != nullptr) {
     buf = Malloc<char>(len);
     memcpy(buf, data, len);
+  } else if (data == nullptr) {
+    flags_ |= NGHTTP2_STREAM_FLAG_EOS;
   }
   data_chunks_.emplace(uv_buf_init(buf, len));
 }
 
-
+// The Http2Stream class is a subclass of StreamBase. The DoWrite method
+// receives outbound chunks of data to send as outbound DATA frames. These
+// are queued in an internal linked list of uv_buf_t structs that are sent
+// when nghttp2 is ready to serialize the data frame.
 int Http2Stream::DoWrite(WriteWrap* req_wrap,
                          uv_buf_t* bufs,
                          size_t count,
                          uv_stream_t* send_handle) {
+  CHECK(!this->IsDestroyed());
   session_->SetChunksSinceLastWrite();
 
   nghttp2_stream_write_t* req = new nghttp2_stream_write_t;
@@ -1189,6 +1395,7 @@ int Http2Stream::DoWrite(WriteWrap* req_wrap,
 
 
 inline void Http2Stream::Close(int32_t code) {
+  CHECK(!this->IsDestroyed());
   flags_ |= NGHTTP2_STREAM_FLAG_CLOSED;
   code_ = code;
   DEBUG_HTTP2STREAM2(this, "closed with code %d", code);
@@ -1196,6 +1403,7 @@ inline void Http2Stream::Close(int32_t code) {
 
 
 inline void Http2Stream::Shutdown() {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
   flags_ |= NGHTTP2_STREAM_FLAG_SHUT;
   CHECK_NE(nghttp2_session_resume_data(session_->session(), id_),
@@ -1204,26 +1412,23 @@ inline void Http2Stream::Shutdown() {
 }
 
 int Http2Stream::DoShutdown(ShutdownWrap* req_wrap) {
+  CHECK(!this->IsDestroyed());
   req_wrap->Dispatched();
   Shutdown();
   req_wrap->Done(0);
   return 0;
 }
 
+// Destroy the Http2Stream and render it unusable. Actual resources for the
+// Stream will not be freed until the next tick of the Node.js event loop
+// using the SetImmediate queue.
 inline void Http2Stream::Destroy() {
-  Http2Scope h2scope(this);
-  DEBUG_HTTP2STREAM(this, "destroying stream");
   // Do nothing if this stream instance is already destroyed
   if (IsDestroyed())
     return;
-
   flags_ |= NGHTTP2_STREAM_FLAG_DESTROYED;
-  Http2Session* session = this->session_;
 
-  if (session != nullptr) {
-    session_->RemoveStream(id_);
-    session_ = nullptr;
-  }
+  DEBUG_HTTP2STREAM(this, "destroying stream");
 
   // Free any remaining incoming data chunks.
   while (!data_chunks_.empty()) {
@@ -1232,24 +1437,30 @@ inline void Http2Stream::Destroy() {
     data_chunks_.pop();
   }
 
-  // Free any remaining outgoing data chunks.
-  while (!queue_.empty()) {
-    nghttp2_stream_write* head = queue_.front();
-    head->cb(head->req, UV_ECANCELED);
-    delete head;
-    queue_.pop();
-  }
-
-  if (!object().IsEmpty())
-    ClearWrap(object());
-  persistent().Reset();
+  // Wait until the start of the next loop to delete because there
+  // may still be some pending operations queued for this stream.
+  env()->SetImmediate([](Environment* env, void* data) {
+    Http2Stream* stream = static_cast<Http2Stream*>(data);
+
+    // Free any remaining outgoing data chunks here. This should be done
+    // here because it's possible for destroy to have been called while
+    // we still have qeueued outbound writes.
+    while (!stream->queue_.empty()) {
+      nghttp2_stream_write* head = stream->queue_.front();
+      head->cb(head->req, UV_ECANCELED);
+      delete head;
+      stream->queue_.pop();
+    }
 
-  delete this;
+    delete stream;
+  }, this, this->object());
 }
 
 
-void Http2Stream::OnDataChunk(
-    uv_buf_t* chunk) {
+// Uses the StreamBase API to push a single chunk of queued inbound DATA
+// to JS land.
+void Http2Stream::OnDataChunk(uv_buf_t* chunk) {
+  CHECK(!this->IsDestroyed());
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
   ssize_t len = -1;
@@ -1263,6 +1474,7 @@ void Http2Stream::OnDataChunk(
 
 
 inline void Http2Stream::FlushDataChunks() {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
   if (!data_chunks_.empty()) {
     uv_buf_t buf = data_chunks_.front();
@@ -1278,9 +1490,12 @@ inline void Http2Stream::FlushDataChunks() {
 }
 
 
+// Initiates a response on the Http2Stream using data provided via the
+// StreamBase Streams API.
 inline int Http2Stream::SubmitResponse(nghttp2_nv* nva,
                                        size_t len,
                                        int options) {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
   DEBUG_HTTP2STREAM(this, "submitting response");
   if (options & STREAM_OPTION_GET_TRAILERS)
@@ -1302,6 +1517,7 @@ inline int Http2Stream::SubmitFile(int fd,
                                    int64_t offset,
                                    int64_t length,
                                    int options) {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
   DEBUG_HTTP2STREAM(this, "submitting file");
   if (options & STREAM_OPTION_GET_TRAILERS)
@@ -1319,6 +1535,7 @@ inline int Http2Stream::SubmitFile(int fd,
 
 // Submit informational headers for a stream.
 inline int Http2Stream::SubmitInfo(nghttp2_nv* nva, size_t len) {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
   DEBUG_HTTP2STREAM2(this, "sending %d informational headers", len);
   int ret = nghttp2_submit_headers(session_->session(),
@@ -1329,9 +1546,10 @@ inline int Http2Stream::SubmitInfo(nghttp2_nv* nva, size_t len) {
   return ret;
 }
 
-
+// Submit a PRIORITY frame to the connected peer.
 inline int Http2Stream::SubmitPriority(nghttp2_priority_spec* prispec,
                                        bool silent) {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
   DEBUG_HTTP2STREAM(this, "sending priority spec");
   int ret = silent ?
@@ -1344,27 +1562,28 @@ inline int Http2Stream::SubmitPriority(nghttp2_priority_spec* prispec,
   return ret;
 }
 
-
-inline int Http2Stream::SubmitRstStream(const uint32_t code) {
+// Closes the Http2Stream by submitting an RST_STREAM frame to the connected
+// peer.
+inline void Http2Stream::SubmitRstStream(const uint32_t code) {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
-  DEBUG_HTTP2STREAM2(this, "sending rst-stream with code %d", code);
+  // Force a purge of any currently pending data here to make sure
+  // it is sent before closing the stream.
   session_->SendPendingData();
-  CHECK_EQ(nghttp2_submit_rst_stream(session_->session(),
-                                     NGHTTP2_FLAG_NONE,
-                                     id_,
-                                     code), 0);
-  return 0;
+  CHECK_EQ(nghttp2_submit_rst_stream(**session_, NGHTTP2_FLAG_NONE,
+                                     id_, code), 0);
 }
 
 
-// Submit a push promise.
+// Submit a push promise and create the associated Http2Stream if successful.
 inline Http2Stream* Http2Stream::SubmitPushPromise(nghttp2_nv* nva,
                                                    size_t len,
                                                    int32_t* ret,
                                                    int options) {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
   DEBUG_HTTP2STREAM(this, "sending push promise");
-  *ret = nghttp2_submit_push_promise(session_->session(), NGHTTP2_FLAG_NONE,
+  *ret = nghttp2_submit_push_promise(**session_, NGHTTP2_FLAG_NONE,
                                      id_, nva, len, nullptr);
   CHECK_NE(*ret, NGHTTP2_ERR_NOMEM);
   Http2Stream* stream = nullptr;
@@ -1374,7 +1593,10 @@ inline Http2Stream* Http2Stream::SubmitPushPromise(nghttp2_nv* nva,
   return stream;
 }
 
+// Switch the StreamBase into flowing mode to begin pushing chunks of data
+// out to JS land.
 inline int Http2Stream::ReadStart() {
+  CHECK(!this->IsDestroyed());
   flags_ |= NGHTTP2_STREAM_FLAG_READ_START;
   flags_ &= ~NGHTTP2_STREAM_FLAG_READ_PAUSED;
 
@@ -1384,8 +1606,9 @@ inline int Http2Stream::ReadStart() {
   return 0;
 }
 
-
+// Switch the StreamBase into paused mode.
 inline int Http2Stream::ReadStop() {
+  CHECK(!this->IsDestroyed());
   if (!IsReading())
     return 0;
   flags_ |= NGHTTP2_STREAM_FLAG_READ_PAUSED;
@@ -1402,6 +1625,7 @@ inline int Http2Stream::Write(nghttp2_stream_write_t* req,
                               const uv_buf_t bufs[],
                               unsigned int nbufs,
                               nghttp2_stream_write_cb cb) {
+  CHECK(!this->IsDestroyed());
   Http2Scope h2scope(this);
   if (!IsWritable()) {
     if (cb != nullptr)
@@ -1424,9 +1648,15 @@ inline size_t GetBufferLength(nghttp2_rcbuf* buf) {
   return nghttp2_rcbuf_get_buf(buf).len;
 }
 
+// Ads a header to the Http2Stream. Note that the header name and value are
+// provided using a buffer structure provided by nghttp2 that allows us to
+// avoid unnecessary memcpy's. Those buffers are ref counted. The ref count
+// is incremented here and are decremented when the header name and values
+// are garbage collected later.
 inline bool Http2Stream::AddHeader(nghttp2_rcbuf* name,
                                    nghttp2_rcbuf* value,
                                    uint8_t flags) {
+  CHECK(!this->IsDestroyed());
   size_t length = GetBufferLength(name) + GetBufferLength(value) + 32;
   if (current_headers_.size() == max_header_pairs_ ||
       current_headers_length_ + length > max_header_length_) {
@@ -1455,7 +1685,9 @@ Http2Stream* GetStream(Http2Session* session,
   return stream;
 }
 
+// A Provider is the thing that provides outbound DATA frame data.
 Http2Stream::Provider::Provider(Http2Stream* stream, int options) {
+  CHECK(!stream->IsDestroyed());
   provider_.source.ptr = stream;
   empty_ = options & STREAM_OPTION_EMPTY_PAYLOAD;
 }
@@ -1469,8 +1701,12 @@ Http2Stream::Provider::~Provider() {
   provider_.source.ptr = nullptr;
 }
 
+// The FD Provider pulls data from a file descriptor using libuv. All of the
+// data transfer occurs in C++, without any chunks being passed through JS
+// land.
 Http2Stream::Provider::FD::FD(Http2Stream* stream, int options, int fd)
     : Http2Stream::Provider(stream, options) {
+  CHECK(!stream->IsDestroyed());
   provider_.source.fd = fd;
   provider_.read_callback = Http2Stream::Provider::FD::OnRead;
 }
@@ -1490,6 +1726,7 @@ ssize_t Http2Stream::Provider::FD::OnRead(nghttp2_session* handle,
                                           void* user_data) {
   Http2Session* session = static_cast<Http2Session*>(user_data);
   Http2Stream* stream = session->FindStream(id);
+
   DEBUG_HTTP2SESSION2(session, "reading outbound file data for stream %d", id);
   CHECK_EQ(id, stream->id());
 
@@ -1524,16 +1761,26 @@ ssize_t Http2Stream::Provider::FD::OnRead(nghttp2_session* handle,
   stream->fd_offset_ += numchars;
   stream->fd_length_ -= numchars;
 
+  DEBUG_HTTP2SESSION2(session, "sending %d bytes", numchars);
+
   // if numchars < length, assume that we are done.
   if (static_cast<size_t>(numchars) < length || length <= 0) {
     DEBUG_HTTP2SESSION2(session, "no more data for stream %d", id);
     *flags |= NGHTTP2_DATA_FLAG_EOF;
     session->GetTrailers(stream, flags);
+    // If the stream or session gets destroyed during the GetTrailers
+    // callback, check that here and close down the stream
+    if (stream->IsDestroyed())
+      return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
+    if (session->IsDestroyed())
+      return NGHTTP2_ERR_CALLBACK_FAILURE;
   }
 
   return numchars;
 }
 
+// The Stream Provider pulls data from a linked list of uv_buf_t structs
+// built via the StreamBase API and the Streams js API.
 Http2Stream::Provider::Stream::Stream(int options)
     : Http2Stream::Provider(options) {
   provider_.read_callback = Http2Stream::Provider::Stream::OnRead;
@@ -1593,10 +1840,14 @@ ssize_t Http2Stream::Provider::Stream::OnRead(nghttp2_session* handle,
   if (stream->queue_.empty() && !stream->IsWritable()) {
     DEBUG_HTTP2SESSION2(session, "no more data for stream %d", id);
     *flags |= NGHTTP2_DATA_FLAG_EOF;
-
     session->GetTrailers(stream, flags);
+    // If the stream or session gets destroyed during the GetTrailers
+    // callback, check that here and close down the stream
+    if (stream->IsDestroyed())
+      return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
+    if (session->IsDestroyed())
+      return NGHTTP2_ERR_CALLBACK_FAILURE;
   }
-
   return amount;
 }
 
@@ -1604,6 +1855,8 @@ ssize_t Http2Stream::Provider::Stream::OnRead(nghttp2_session* handle,
 
 // Implementation of the JavaScript API
 
+// Fetches the string description of a nghttp2 error code and passes that
+// back to JS land
 void HttpErrorString(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   uint32_t val = args[0]->Uint32Value(env->context()).ToChecked();
@@ -1624,13 +1877,15 @@ void PackSettings(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(settings.Pack());
 }
 
-
+// A TypedArray instance is shared between C++ and JS land to contain the
+// default SETTINGS. RefreshDefaultSettings updates that TypedArray with the
+// default values.
 void RefreshDefaultSettings(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Http2Settings::RefreshDefaults(env);
 }
 
-
+// Sets the next stream ID the Http2Session. If successful, returns true.
 void Http2Session::SetNextStreamID(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Http2Session* session;
@@ -1644,7 +1899,9 @@ void Http2Session::SetNextStreamID(const FunctionCallbackInfo<Value>& args) {
   DEBUG_HTTP2SESSION2(session, "set next stream id to %d", id);
 }
 
-
+// A TypedArray instance is shared between C++ and JS land to contain the
+// SETTINGS (either remote or local). RefreshSettings updates the current
+// values established for each of the settings so those can be read in JS land.
 template <get_setting fn>
 void Http2Session::RefreshSettings(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1654,7 +1911,9 @@ void Http2Session::RefreshSettings(const FunctionCallbackInfo<Value>& args) {
   DEBUG_HTTP2SESSION(session, "settings refreshed for session");
 }
 
-
+// A TypedArray instance is shared between C++ and JS land to contain state
+// information of the current Http2Session. This updates the values in the
+// TypedRray so those can be read in JS land.
 void Http2Session::RefreshState(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Http2Session* session;
@@ -1687,6 +1946,7 @@ void Http2Session::RefreshState(const FunctionCallbackInfo<Value>& args) {
 }
 
 
+// Constructor for new Http2Session instances.
 void Http2Session::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK(args.IsConstructCall());
@@ -1698,6 +1958,7 @@ void Http2Session::New(const FunctionCallbackInfo<Value>& args) {
 }
 
 
+// Binds the Http2Session with a StreamBase used for i/o
 void Http2Session::Consume(const FunctionCallbackInfo<Value>& args) {
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
@@ -1705,31 +1966,21 @@ void Http2Session::Consume(const FunctionCallbackInfo<Value>& args) {
   session->Consume(args[0].As<External>());
 }
 
-
+// Destroys the Http2Session instance and renders it unusable
 void Http2Session::Destroy(const FunctionCallbackInfo<Value>& args) {
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
   DEBUG_HTTP2SESSION(session, "destroying session");
-
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
 
-  bool skipUnconsume = args[0]->BooleanValue(context).ToChecked();
-
-  if (!skipUnconsume)
-    session->Unconsume();
-  session->Close();
-}
-
+  uint32_t code = args[0]->Uint32Value(context).ToChecked();
+  bool socketDestroyed = args[1]->BooleanValue(context).ToChecked();
 
-void Http2Session::Destroying(const FunctionCallbackInfo<Value>& args) {
-  Http2Session* session;
-  ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
-  session->MarkDestroying();
-  DEBUG_HTTP2SESSION(session, "preparing to destroy session");
+  session->Close(code, socketDestroyed);
 }
 
-
+// Submits a SETTINGS frame for the Http2Session
 void Http2Session::Settings(const FunctionCallbackInfo<Value>& args) {
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
@@ -1740,7 +1991,8 @@ void Http2Session::Settings(const FunctionCallbackInfo<Value>& args) {
   DEBUG_HTTP2SESSION(session, "settings submitted");
 }
 
-
+// Submits a new request on the Http2Session and returns either an error code
+// or the Http2Stream object.
 void Http2Session::Request(const FunctionCallbackInfo<Value>& args) {
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
@@ -1772,49 +2024,50 @@ void Http2Session::Request(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(stream->object());
 }
 
+// Submits a GOAWAY frame to signal that the Http2Session is in the process
+// of shutting down. Note that this function does not actually alter the
+// state of the Http2Session, it's simply a notification.
+void Http2Session::Goaway(uint32_t code,
+                          int32_t lastStreamID,
+                          uint8_t* data,
+                          size_t len) {
+  if (IsDestroyed())
+    return;
 
-void Http2Session::ShutdownNotice(const FunctionCallbackInfo<Value>& args) {
-  Http2Session* session;
-  ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
-  session->SubmitShutdownNotice();
-  DEBUG_HTTP2SESSION(session, "shutdown notice sent");
+  Http2Scope h2scope(this);
+  // the last proc stream id is the most recently created Http2Stream.
+  if (lastStreamID <= 0)
+    lastStreamID = nghttp2_session_get_last_proc_stream_id(session_);
+  DEBUG_HTTP2SESSION(this, "submitting goaway");
+  nghttp2_submit_goaway(session_, NGHTTP2_FLAG_NONE,
+                        lastStreamID, code, data, len);
 }
 
-
+// Submits a GOAWAY frame to signal that the Http2Session is in the process
+// of shutting down. The opaque data argument is an optional TypedArray that
+// can be used to send debugging data to the connected peer.
 void Http2Session::Goaway(const FunctionCallbackInfo<Value>& args) {
-  Http2Session* session;
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
+  Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
-  Http2Scope h2scope(session);
 
-  uint32_t errorCode = args[0]->Uint32Value(context).ToChecked();
+  uint32_t code = args[0]->Uint32Value(context).ToChecked();
   int32_t lastStreamID = args[1]->Int32Value(context).ToChecked();
   Local<Value> opaqueData = args[2];
-
   uint8_t* data = nullptr;
   size_t length = 0;
 
-  if (opaqueData->BooleanValue(context).ToChecked()) {
-    THROW_AND_RETURN_UNLESS_BUFFER(env, opaqueData);
-    SPREAD_BUFFER_ARG(opaqueData, buf);
-    data = reinterpret_cast<uint8_t*>(buf_data);
-    length = buf_length;
+  if (Buffer::HasInstance(opaqueData)) {
+    data = reinterpret_cast<uint8_t*>(Buffer::Data(opaqueData));
+    length = Buffer::Length(opaqueData);
   }
 
-  int status = nghttp2_submit_goaway(session->session(),
-                                     NGHTTP2_FLAG_NONE,
-                                     lastStreamID,
-                                     errorCode,
-                                     data, length);
-  CHECK_NE(status, NGHTTP2_ERR_NOMEM);
-  args.GetReturnValue().Set(status);
-  DEBUG_HTTP2SESSION2(session, "immediate shutdown initiated with "
-                      "last stream id %d, code %d, and opaque-data length %d",
-                      lastStreamID, errorCode, length);
+  session->Goaway(code, lastStreamID, data, length);
 }
 
-
+// Update accounting of data chunks. This is used primarily to manage timeout
+// logic when using the FD Provider.
 void Http2Session::UpdateChunksSent(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Isolate* isolate = env->isolate();
@@ -1831,18 +2084,21 @@ void Http2Session::UpdateChunksSent(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(length);
 }
 
-
+// Submits an RST_STREAM frame effectively closing the Http2Stream. Note that
+// this *WILL* alter the state of the stream, causing the OnStreamClose
+// callback to the triggered.
 void Http2Stream::RstStream(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
   uint32_t code = args[0]->Uint32Value(context).ToChecked();
-  args.GetReturnValue().Set(stream->SubmitRstStream(code));
-  DEBUG_HTTP2STREAM2(stream, "rst_stream code %d sent", code);
+  DEBUG_HTTP2STREAM2(stream, "sending rst_stream with code %d", code);
+  stream->SubmitRstStream(code);
 }
 
-
+// Initiates a response on the Http2Stream using the StreamBase API to provide
+// outbound DATA frames.
 void Http2Stream::Respond(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
@@ -1860,7 +2116,8 @@ void Http2Stream::Respond(const FunctionCallbackInfo<Value>& args) {
   DEBUG_HTTP2STREAM(stream, "response submitted");
 }
 
-
+// Initiates a response on the Http2Stream using a file descriptor to provide
+// outbound DATA frames.
 void Http2Stream::RespondFD(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
@@ -1883,7 +2140,7 @@ void Http2Stream::RespondFD(const FunctionCallbackInfo<Value>& args) {
   DEBUG_HTTP2STREAM2(stream, "file response submitted for fd %d", fd);
 }
 
-
+// Submits informational headers on the Http2Stream
 void Http2Stream::Info(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
@@ -1899,14 +2156,14 @@ void Http2Stream::Info(const FunctionCallbackInfo<Value>& args) {
                      headers->Length());
 }
 
-
+// Grab the numeric id of the Http2Stream
 void Http2Stream::GetID(const FunctionCallbackInfo<Value>& args) {
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
   args.GetReturnValue().Set(stream->id());
 }
 
-
+// Destroy the Http2Stream, rendering it no longer usable
 void Http2Stream::Destroy(const FunctionCallbackInfo<Value>& args) {
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
@@ -1914,7 +2171,7 @@ void Http2Stream::Destroy(const FunctionCallbackInfo<Value>& args) {
   stream->Destroy();
 }
 
-
+// Prompt the Http2Stream to begin sending data to the JS land.
 void Http2Stream::FlushData(const FunctionCallbackInfo<Value>& args) {
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
@@ -1922,7 +2179,7 @@ void Http2Stream::FlushData(const FunctionCallbackInfo<Value>& args) {
   DEBUG_HTTP2STREAM(stream, "data flushed to js");
 }
 
-
+// Initiate a Push Promise and create the associated Http2Stream
 void Http2Stream::PushPromise(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
@@ -1948,7 +2205,7 @@ void Http2Stream::PushPromise(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(stream->object());
 }
 
-
+// Send a PRIORITY frame
 void Http2Stream::Priority(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
@@ -1962,7 +2219,9 @@ void Http2Stream::Priority(const FunctionCallbackInfo<Value>& args) {
   DEBUG_HTTP2STREAM(stream, "priority submitted");
 }
 
-
+// A TypedArray shared by C++ and JS land is used to communicate state
+// information about the Http2Stream. This updates the values in that
+// TypedArray so that the state can be read by JS.
 void Http2Stream::RefreshState(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Http2Stream* stream;
@@ -1999,11 +2258,14 @@ void Http2Stream::RefreshState(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+// Submits a PING frame to be sent to the connected peer.
 void Http2Session::Ping(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
 
+  // A PING frame may have exactly 8 bytes of payload data. If not provided,
+  // then the current hrtime will be used as the payload.
   uint8_t* payload = nullptr;
   if (Buffer::HasInstance(args[0])) {
     payload = reinterpret_cast<uint8_t*>(Buffer::Data(args[0]));
@@ -2014,11 +2276,18 @@ void Http2Session::Ping(const FunctionCallbackInfo<Value>& args) {
   Local<Object> obj = ping->object();
   obj->Set(env->context(), env->ondone_string(), args[1]).FromJust();
 
+  // To prevent abuse, we strictly limit the number of unacknowledged PING
+  // frames that may be sent at any given time. This is configurable in the
+  // Options when creating a Http2Session.
   if (!session->AddPing(ping)) {
     ping->Done(false);
     return args.GetReturnValue().Set(false);
   }
 
+  // The Ping itself is an Async resource. When the acknowledgement is recieved,
+  // the callback will be invoked and a notification sent out to JS land. The
+  // notification will include the duration of the ping, allowing the round
+  // trip to be measured.
   ping->Send(payload);
   args.GetReturnValue().Set(true);
 }
@@ -2039,6 +2308,7 @@ bool Http2Session::AddPing(Http2Session::Http2Ping* ping) {
   return true;
 }
 
+
 Http2Session::Http2Ping::Http2Ping(
     Http2Session* session)
         : AsyncWrap(session->env(),
@@ -2086,6 +2356,8 @@ void Http2Session::Http2Ping::Done(bool ack, const uint8_t* payload) {
   delete this;
 }
 
+
+// Set up the process.binding('http2') binding.
 void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context,
@@ -2164,8 +2436,6 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(session, "ping", Http2Session::Ping);
   env->SetProtoMethod(session, "consume", Http2Session::Consume);
   env->SetProtoMethod(session, "destroy", Http2Session::Destroy);
-  env->SetProtoMethod(session, "destroying", Http2Session::Destroying);
-  env->SetProtoMethod(session, "shutdownNotice", Http2Session::ShutdownNotice);
   env->SetProtoMethod(session, "goaway", Http2Session::Goaway);
   env->SetProtoMethod(session, "settings", Http2Session::Settings);
   env->SetProtoMethod(session, "request", Http2Session::Request);
diff --git a/src/node_http2.h b/src/node_http2.h
index 5a61e465a40ce3..8318a8ee5be8fd 100644
--- a/src/node_http2.h
+++ b/src/node_http2.h
@@ -70,7 +70,13 @@ void inline debug_vfprintf(const char* format, ...) {
 #define DEBUG_HTTP2STREAM2(...) do {} while (0)
 #endif
 
+// 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
+
+// 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
@@ -83,10 +89,10 @@ void inline debug_vfprintf(const char* format, ...) {
 #define MAX_MAX_HEADER_LIST_SIZE 16777215u
 #define DEFAULT_MAX_HEADER_LIST_PAIRS 128u
 
-struct nghttp2_stream_write_t;
-
 #define MAX_BUFFER_COUNT 16
 
+struct nghttp2_stream_write_t;
+
 enum nghttp2_session_type {
   NGHTTP2_SESSION_SERVER,
   NGHTTP2_SESSION_CLIENT
@@ -109,11 +115,15 @@ enum nghttp2_stream_flags {
   // Stream is destroyed
   NGHTTP2_STREAM_FLAG_DESTROYED = 0x10,
   // Stream has trailers
-  NGHTTP2_STREAM_FLAG_TRAILERS = 0x20
+  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,
 };
 
@@ -136,7 +146,6 @@ struct nghttp2_header {
 };
 
 
-
 struct nghttp2_stream_write_t {
   void* data;
   int status;
@@ -417,9 +426,10 @@ const char* nghttp2_errname(int rv) {
 
 enum session_state_flags {
   SESSION_STATE_NONE = 0x0,
-  SESSION_STATE_DESTROYING = 0x1,
-  SESSION_STATE_HAS_SCOPE = 0x2,
-  SESSION_STATE_WRITE_SCHEDULED = 0x4
+  SESSION_STATE_HAS_SCOPE = 0x1,
+  SESSION_STATE_WRITE_SCHEDULED = 0x2,
+  SESSION_STATE_CLOSED = 0x4,
+  SESSION_STATE_SENDING = 0x8,
 };
 
 // This allows for 4 default-sized frames with their frame headers
@@ -555,6 +565,8 @@ class Http2Stream : public AsyncWrap,
       unsigned int nbufs,
       nghttp2_stream_write_cb cb);
 
+  inline bool HasDataChunks(bool ignore_eos = false);
+
   inline void AddChunk(const uint8_t* data, size_t len);
 
   inline void FlushDataChunks();
@@ -592,7 +604,7 @@ class Http2Stream : public AsyncWrap,
                             bool silent = false);
 
   // Submits an RST_STREAM frame using the given code
-  inline int SubmitRstStream(const uint32_t code);
+  inline void SubmitRstStream(const uint32_t code);
 
   // Submits a PUSH_PROMISE frame with this stream as the parent.
   inline Http2Stream* SubmitPushPromise(
@@ -799,9 +811,11 @@ class Http2Session : public AsyncWrap {
 
   void Start();
   void Stop();
-  void Close();
+  void Close(uint32_t code = NGHTTP2_NO_ERROR,
+             bool socket_closed = false);
   void Consume(Local<External> external);
   void Unconsume();
+  void Goaway(uint32_t code, int32_t lastStreamID, uint8_t* data, size_t len);
 
   bool Ping(v8::Local<v8::Function> function);
 
@@ -827,8 +841,9 @@ class Http2Session : public AsyncWrap {
 
   inline const char* TypeName();
 
-  inline void MarkDestroying() { flags_ |= SESSION_STATE_DESTROYING; }
-  inline bool IsDestroying() { return flags_ & SESSION_STATE_DESTROYING; }
+  inline bool IsDestroyed() {
+    return (flags_ & SESSION_STATE_CLOSED) || session_ == nullptr;
+  }
 
   // Schedule a write if nghttp2 indicates it wants to write to the socket.
   void MaybeScheduleWrite();
@@ -842,9 +857,6 @@ class Http2Session : public AsyncWrap {
   // Removes a stream instance from this session
   inline void RemoveStream(int32_t id);
 
-  // Sends a notice to the connected peer that the session is shutting down.
-  inline void SubmitShutdownNotice();
-
   // Submits a SETTINGS frame to the connected peer.
   inline void Settings(const nghttp2_settings_entry iv[], size_t niv);
 
@@ -868,6 +880,7 @@ class Http2Session : public AsyncWrap {
                                const uv_buf_t* bufs,
                                uv_handle_type pending,
                                void* ctx);
+  static void OnStreamDestructImpl(void* ctx);
 
   // The JavaScript API
   static void New(const FunctionCallbackInfo<Value>& args);
@@ -878,7 +891,6 @@ class Http2Session : public AsyncWrap {
   static void Settings(const FunctionCallbackInfo<Value>& args);
   static void Request(const FunctionCallbackInfo<Value>& args);
   static void SetNextStreamID(const FunctionCallbackInfo<Value>& args);
-  static void ShutdownNotice(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);
diff --git a/test/parallel/test-http2-client-data-end.js b/test/parallel/test-http2-client-data-end.js
index 43665029630c12..2f251692d5c412 100644
--- a/test/parallel/test-http2-client-data-end.js
+++ b/test/parallel/test-http2-client-data-end.js
@@ -5,53 +5,37 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
+const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
 server.on('stream', common.mustCall((stream, headers, flags) => {
-  const port = server.address().port;
   if (headers[':path'] === '/') {
-    stream.pushStream({
-      ':scheme': 'http',
-      ':path': '/foobar',
-      ':authority': `localhost:${port}`,
-    }, (push, headers) => {
+    stream.pushStream({ ':path': '/foobar' }, (err, push, headers) => {
+      assert.ifError(err);
       push.respond({
         'content-type': 'text/html',
-        ':status': 200,
         'x-push-data': 'pushed by server',
       });
       push.write('pushed by server ');
-      // Sending in next immediate ensures that a second data frame
-      // will be sent to the client, which will cause the 'data' event
-      // to fire multiple times.
-      setImmediate(() => {
-        push.end('data');
-      });
+      setImmediate(() => push.end('data'));
       stream.end('st');
     });
   }
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
+  stream.respond({ 'content-type': 'text/html' });
   stream.write('te');
 }));
 
 
 server.listen(0, common.mustCall(() => {
   const port = server.address().port;
-  const headers = { ':path': '/' };
   const client = http2.connect(`http://localhost:${port}`);
 
-  const req = client.request(headers);
+  const req = client.request();
 
-  let expected = 2;
-  function maybeClose() {
-    if (--expected === 0) {
-      server.close();
-      client.destroy();
-    }
-  }
+  const countdown = new Countdown(2, () => {
+    server.close();
+    client.close();
+  });
 
   req.on('response', common.mustCall((headers) => {
     assert.strictEqual(headers[':status'], 200);
@@ -70,13 +54,11 @@ server.listen(0, common.mustCall(() => {
 
     stream.setEncoding('utf8');
     let pushData = '';
-    stream.on('data', common.mustCall((d) => {
-      pushData += d;
-    }, 2));
+    stream.on('data', (d) => pushData += d);
     stream.on('end', common.mustCall(() => {
       assert.strictEqual(pushData, 'pushed by server data');
-      maybeClose();
     }));
+    stream.on('close', () => countdown.dec());
   }));
 
   let data = '';
@@ -85,7 +67,6 @@ server.listen(0, common.mustCall(() => {
   req.on('data', common.mustCallAtLeast((d) => data += d));
   req.on('end', common.mustCall(() => {
     assert.strictEqual(data, 'test');
-    maybeClose();
   }));
-  req.end();
+  req.on('close', () => countdown.dec());
 }));
diff --git a/test/parallel/test-http2-client-destroy.js b/test/parallel/test-http2-client-destroy.js
index bb93366247aef7..fab8a4fc24d652 100644
--- a/test/parallel/test-http2-client-destroy.js
+++ b/test/parallel/test-http2-client-destroy.js
@@ -8,139 +8,115 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const h2 = require('http2');
 const { kSocket } = require('internal/http2/util');
+const Countdown = require('../common/countdown');
 
 {
   const server = h2.createServer();
-  server.listen(
-    0,
-    common.mustCall(() => {
-      const destroyCallbacks = [
-        (client) => client.destroy(),
-        (client) => client[kSocket].destroy()
-      ];
-
-      let remaining = destroyCallbacks.length;
-
-      destroyCallbacks.forEach((destroyCallback) => {
-        const client = h2.connect(`http://localhost:${server.address().port}`);
-        client.on(
-          'connect',
-          common.mustCall(() => {
-            const socket = client[kSocket];
-
-            assert(socket, 'client session has associated socket');
-            assert(
-              !client.destroyed,
-              'client has not been destroyed before destroy is called'
-            );
-            assert(
-              !socket.destroyed,
-              'socket has not been destroyed before destroy is called'
-            );
-
-            // Ensure that 'close' event is emitted
-            client.on('close', common.mustCall());
-
-            destroyCallback(client);
-
-            assert(
-              !client[kSocket],
-              'client.socket undefined after destroy is called'
-            );
-
-            // Must must be closed
-            client.on(
-              'close',
-              common.mustCall(() => {
-                assert(client.destroyed);
-              })
-            );
-
-            // socket will close on process.nextTick
-            socket.on(
-              'close',
-              common.mustCall(() => {
-                assert(socket.destroyed);
-              })
-            );
-
-            if (--remaining === 0) {
-              server.close();
-            }
-          })
+  server.listen(0, common.mustCall(() => {
+    const destroyCallbacks = [
+      (client) => client.destroy(),
+      (client) => client[kSocket].destroy()
+    ];
+
+    const countdown = new Countdown(destroyCallbacks.length, () => {
+      server.close();
+    });
+
+    destroyCallbacks.forEach((destroyCallback) => {
+      const client = h2.connect(`http://localhost:${server.address().port}`);
+      client.on('connect', common.mustCall(() => {
+        const socket = client[kSocket];
+
+        assert(socket, 'client session has associated socket');
+        assert(
+          !client.destroyed,
+          'client has not been destroyed before destroy is called'
         );
-      });
-    })
-  );
+        assert(
+          !socket.destroyed,
+          'socket has not been destroyed before destroy is called'
+        );
+
+        destroyCallback(client);
+
+        client.on('close', common.mustCall(() => {
+          assert(client.destroyed);
+        }));
+
+        countdown.dec();
+      }));
+    });
+  }));
 }
 
 // test destroy before client operations
 {
   const server = h2.createServer();
-  server.listen(
-    0,
-    common.mustCall(() => {
-      const client = h2.connect(`http://localhost:${server.address().port}`);
-      const req = client.request();
-      client.destroy();
-
-      req.on('response', common.mustNotCall());
-      req.resume();
-
-      const sessionError = {
-        type: Error,
-        code: 'ERR_HTTP2_INVALID_SESSION',
-        message: 'The session has been destroyed'
-      };
-
+  server.listen(0, common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const socket = client[kSocket];
+    socket.on('close', common.mustCall(() => {
+      assert(socket.destroyed);
+    }));
+
+
+    const req = client.request();
+    req.on('error', common.expectsError({
+      code: 'ERR_HTTP2_STREAM_CANCEL',
+      type: Error,
+      message: 'The pending stream has been canceled'
+    }));
+
+    client.destroy();
+
+    req.on('response', common.mustNotCall());
+
+    const sessionError = {
+      type: Error,
+      code: 'ERR_HTTP2_INVALID_SESSION',
+      message: 'The session has been destroyed'
+    };
+
+    common.expectsError(() => client.request(), sessionError);
+    common.expectsError(() => client.settings({}), sessionError);
+    client.close();  // should be a non-op at this point
+
+    // Wait for setImmediate call from destroy() to complete
+    // so that state.destroyed is set to true
+    setImmediate(() => {
       common.expectsError(() => client.request(), sessionError);
       common.expectsError(() => client.settings({}), sessionError);
-      common.expectsError(() => client.shutdown(), sessionError);
-
-      // Wait for setImmediate call from destroy() to complete
-      // so that state.destroyed is set to true
-      setImmediate(() => {
-        common.expectsError(() => client.request(), sessionError);
-        common.expectsError(() => client.settings({}), sessionError);
-        common.expectsError(() => client.shutdown(), sessionError);
-      });
-
-      req.on(
-        'end',
-        common.mustCall(() => {
-          server.close();
-        })
-      );
-      req.end();
-    })
-  );
+      client.close();  // should be a non-op at this point
+    });
+
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => server.close()));
+  }));
 }
 
 // test destroy before goaway
 {
   const server = h2.createServer();
-  server.on(
-    'stream',
-    common.mustCall((stream) => {
-      stream.on('error', common.mustCall());
-      stream.session.shutdown();
-    })
-  );
-  server.listen(
-    0,
-    common.mustCall(() => {
-      const client = h2.connect(`http://localhost:${server.address().port}`);
+  server.on('stream', common.mustCall((stream) => {
+    stream.session.destroy();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    // On some platforms (e.g. windows), an ECONNRESET may occur at this
+    // point -- or it may not. Do not make this a mustCall
+    client.on('error', () => {});
+
+    client.on('close', () => {
+      server.close();
+      // calling destroy in here should not matter
+      client.destroy();
+    });
 
-      client.on(
-        'goaway',
-        common.mustCall(() => {
-          // We ought to be able to destroy the client in here without an error
-          server.close();
-          client.destroy();
-        })
-      );
-
-      client.request();
-    })
-  );
+    const req = client.request();
+    // On some platforms (e.g. windows), an ECONNRESET may occur at this
+    // point -- or it may not. Do not make this a mustCall
+    req.on('error', () => {});
+  }));
 }
diff --git a/test/parallel/test-http2-client-http1-server.js b/test/parallel/test-http2-client-http1-server.js
index 53f7bf42c465e1..616427b3904e16 100644
--- a/test/parallel/test-http2-client-http1-server.js
+++ b/test/parallel/test-http2-client-http1-server.js
@@ -7,6 +7,7 @@ if (!common.hasCrypto)
 const http = require('http');
 const http2 = require('http2');
 
+// Creating an http1 server here...
 const server = http.createServer(common.mustNotCall());
 
 server.listen(0, common.mustCall(() => {
@@ -15,13 +16,17 @@ server.listen(0, common.mustCall(() => {
   const req = client.request();
   req.on('close', common.mustCall());
 
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_ERROR',
+    type: Error,
+    message: 'Protocol error'
+  }));
+
   client.on('error', common.expectsError({
     code: 'ERR_HTTP2_ERROR',
     type: Error,
     message: 'Protocol error'
   }));
 
-  client.on('close', (...args) => {
-    server.close();
-  });
+  client.on('close', common.mustCall(() => server.close()));
 }));
diff --git a/test/parallel/test-http2-client-onconnect-errors.js b/test/parallel/test-http2-client-onconnect-errors.js
index 08007753654878..44fe6875602187 100644
--- a/test/parallel/test-http2-client-onconnect-errors.js
+++ b/test/parallel/test-http2-client-onconnect-errors.js
@@ -1,13 +1,14 @@
 'use strict';
 
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
 const {
   constants,
   Http2Session,
   nghttp2ErrorString
 } = process.binding('http2');
-const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
 const http2 = require('http2');
 
 // tests error handling within requestOnConnect
@@ -69,6 +70,8 @@ server.listen(0, common.mustCall(() => runTest(tests.shift())));
 
 function runTest(test) {
   const client = http2.connect(`http://localhost:${server.address().port}`);
+  client.on('close', common.mustCall());
+
   const req = client.request({ ':method': 'POST' });
 
   currentError = test.ngError;
@@ -83,15 +86,15 @@ function runTest(test) {
   if (test.type === 'stream') {
     client.on('error', errorMustNotCall);
     req.on('error', errorMustCall);
-    req.on('error', common.mustCall(() => {
-      client.destroy();
-    }));
   } else {
     client.on('error', errorMustCall);
-    req.on('error', errorMustNotCall);
+    req.on('error', common.expectsError({
+      code: 'ERR_HTTP2_STREAM_CANCEL'
+    }));
   }
 
-  req.on('end', common.mustCall(() => {
+  req.on('end', common.mustCall());
+  req.on('close', common.mustCall(() => {
     client.destroy();
 
     if (!tests.length) {
diff --git a/test/parallel/test-http2-client-port-80.js b/test/parallel/test-http2-client-port-80.js
index a9d19eb5b9f008..fc82e231f6af8f 100644
--- a/test/parallel/test-http2-client-port-80.js
+++ b/test/parallel/test-http2-client-port-80.js
@@ -16,4 +16,10 @@ net.connect = common.mustCall((...args) => {
 });
 
 const client = http2.connect('http://localhost:80');
-client.destroy();
+
+// A socket error may or may not occur depending on whether there is something
+// currently listening on port 80. Keep this as a non-op and not a mustCall or
+// mustNotCall.
+client.on('error', () => {});
+
+client.close();
diff --git a/test/parallel/test-http2-client-priority-before-connect.js b/test/parallel/test-http2-client-priority-before-connect.js
index b062107e4ab7f7..a9615d2cd69f12 100644
--- a/test/parallel/test-http2-client-priority-before-connect.js
+++ b/test/parallel/test-http2-client-priority-before-connect.js
@@ -8,31 +8,21 @@ const h2 = require('http2');
 const server = h2.createServer();
 
 // we use the lower-level API here
-server.on('stream', common.mustCall(onStream));
-
-function onStream(stream, headers, flags) {
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
-  stream.end('hello world');
-}
-
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
+server.on('stream', common.mustCall((stream) => {
+  stream.respond();
+  stream.end('ok');
+}));
 
+server.listen(0, common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const req = client.request({ ':path': '/' });
+  const req = client.request();
   req.priority({});
 
   req.on('response', common.mustCall());
   req.resume();
-  req.on('end', common.mustCall(() => {
+  req.on('end', common.mustCall());
+  req.on('close', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
-  req.end();
-
 }));
diff --git a/test/parallel/test-http2-client-promisify-connect.js b/test/parallel/test-http2-client-promisify-connect.js
index b66827c1507302..2eb7da3b9cfd85 100644
--- a/test/parallel/test-http2-client-promisify-connect.js
+++ b/test/parallel/test-http2-client-promisify-connect.js
@@ -15,7 +15,6 @@ server.on('stream', common.mustCall((stream) => {
   stream.end('ok');
 }));
 server.listen(0, common.mustCall(() => {
-
   const connect = util.promisify(http2.connect);
 
   connect(`http://localhost:${server.address().port}`)
@@ -28,7 +27,7 @@ server.listen(0, common.mustCall(() => {
       req.on('data', (chunk) => data += chunk);
       req.on('end', common.mustCall(() => {
         assert.strictEqual(data, 'ok');
-        client.destroy();
+        client.close();
         server.close();
       }));
     }));
diff --git a/test/parallel/test-http2-client-request-options-errors.js b/test/parallel/test-http2-client-request-options-errors.js
index 4b146a1bc8c2e4..3ad808cb1fbe23 100644
--- a/test/parallel/test-http2-client-request-options-errors.js
+++ b/test/parallel/test-http2-client-request-options-errors.js
@@ -33,29 +33,27 @@ server.listen(0, common.mustCall(() => {
   const port = server.address().port;
   const client = http2.connect(`http://localhost:${port}`);
 
-  Object.keys(optionsToTest).forEach((option) => {
-    Object.keys(types).forEach((type) => {
-      if (type === optionsToTest[option]) {
-        return;
-      }
-
-      common.expectsError(
-        () => client.request({
-          ':method': 'CONNECT',
-          ':authority': `localhost:${port}`
-        }, {
-          [option]: types[type]
-        }),
-        {
-          type: TypeError,
-          code: 'ERR_INVALID_OPT_VALUE',
-          message: `The value "${String(types[type])}" is invalid ` +
-                   `for option "${option}"`
-        }
-      );
+  client.on('connect', () => {
+    Object.keys(optionsToTest).forEach((option) => {
+      Object.keys(types).forEach((type) => {
+        if (type === optionsToTest[option])
+          return;
+
+        common.expectsError(
+          () => client.request({
+            ':method': 'CONNECT',
+            ':authority': `localhost:${port}`
+          }, {
+            [option]: types[type]
+          }), {
+            type: TypeError,
+            code: 'ERR_INVALID_OPT_VALUE',
+            message: `The value "${String(types[type])}" is invalid ` +
+                    `for option "${option}"`
+          });
+      });
     });
+    server.close();
+    client.close();
   });
-
-  server.close();
-  client.destroy();
 }));
diff --git a/test/parallel/test-http2-client-rststream-before-connect.js b/test/parallel/test-http2-client-rststream-before-connect.js
index eb3a0087d7893c..b0faaa5de2a398 100644
--- a/test/parallel/test-http2-client-rststream-before-connect.js
+++ b/test/parallel/test-http2-client-rststream-before-connect.js
@@ -8,33 +8,37 @@ const h2 = require('http2');
 
 const server = h2.createServer();
 server.on('stream', (stream) => {
+  stream.on('close', common.mustCall());
   stream.respond();
   stream.end('ok');
 });
 
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
-
+server.listen(0, common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const req = client.request({ ':path': '/' });
-  req.rstStream(0);
+  const req = client.request();
+  req.close(1);
+  assert.strictEqual(req.closed, true);
 
   // make sure that destroy is called
   req._destroy = common.mustCall(req._destroy.bind(req));
 
   // second call doesn't do anything
-  assert.doesNotThrow(() => req.rstStream(8));
+  assert.doesNotThrow(() => req.close(8));
 
   req.on('close', common.mustCall((code) => {
     assert.strictEqual(req.destroyed, true);
-    assert.strictEqual(code, 0);
+    assert.strictEqual(code, 1);
     server.close();
-    client.destroy();
+    client.close();
+  }));
+
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code 1'
   }));
 
-  req.on('response', common.mustNotCall());
+  req.on('response', common.mustCall());
   req.resume();
   req.on('end', common.mustCall());
   req.end();
diff --git a/test/parallel/test-http2-client-set-priority.js b/test/parallel/test-http2-client-set-priority.js
index f3e1d7afa50d7e..64b7b56dfa2543 100644
--- a/test/parallel/test-http2-client-set-priority.js
+++ b/test/parallel/test-http2-client-set-priority.js
@@ -10,26 +10,20 @@ const checkWeight = (actual, expect) => {
   const server = http2.createServer();
   server.on('stream', common.mustCall((stream, headers, flags) => {
     assert.strictEqual(stream.state.weight, expect);
-    stream.respond({
-      'content-type': 'text/html',
-      ':status': 200
-    });
+    stream.respond();
     stream.end('test');
   }));
 
   server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const client = http2.connect(`http://localhost:${port}`);
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({}, { weight: actual });
 
-    const headers = { ':path': '/' };
-    const req = client.request(headers, { weight: actual });
-
-    req.on('data', common.mustCall(() => {}));
-    req.on('end', common.mustCall(() => {
+    req.on('data', common.mustCall());
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => {
       server.close();
-      client.destroy();
+      client.close();
     }));
-    req.end();
   }));
 };
 
diff --git a/test/parallel/test-http2-client-settings-before-connect.js b/test/parallel/test-http2-client-settings-before-connect.js
index 27caa9e601897b..4642bf5220f554 100644
--- a/test/parallel/test-http2-client-settings-before-connect.js
+++ b/test/parallel/test-http2-client-settings-before-connect.js
@@ -3,62 +3,53 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
-const assert = require('assert');
 const h2 = require('http2');
 
 const server = h2.createServer();
 
 // we use the lower-level API here
-server.on('stream', common.mustCall(onStream));
-
-function onStream(stream, headers, flags) {
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
-  stream.end('hello world');
-}
-
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
+server.on('stream', common.mustCall((stream, headers, flags) => {
+  stream.respond();
+  stream.end('ok');
+}));
+server.on('session', common.mustCall((session) => {
+  session.on('remoteSettings', common.mustCall(2));
+}));
 
+server.listen(0, common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
 
-  assert.throws(() => client.settings({ headerTableSize: -1 }),
-                RangeError);
-  assert.throws(() => client.settings({ headerTableSize: 2 ** 32 }),
-                RangeError);
-  assert.throws(() => client.settings({ initialWindowSize: -1 }),
-                RangeError);
-  assert.throws(() => client.settings({ initialWindowSize: 2 ** 32 }),
-                RangeError);
-  assert.throws(() => client.settings({ maxFrameSize: 1 }),
-                RangeError);
-  assert.throws(() => client.settings({ maxFrameSize: 2 ** 24 }),
-                RangeError);
-  assert.throws(() => client.settings({ maxConcurrentStreams: -1 }),
-                RangeError);
-  assert.throws(() => client.settings({ maxConcurrentStreams: 2 ** 31 }),
-                RangeError);
-  assert.throws(() => client.settings({ maxHeaderListSize: -1 }),
-                RangeError);
-  assert.throws(() => client.settings({ maxHeaderListSize: 2 ** 32 }),
-                RangeError);
-  ['a', 1, 0, null, {}].forEach((i) => {
-    assert.throws(() => client.settings({ enablePush: i }), TypeError);
+  [
+    ['headerTableSize', -1, RangeError],
+    ['headerTableSize', 2 ** 32, RangeError],
+    ['initialWindowSize', -1, RangeError],
+    ['initialWindowSize', 2 ** 32, RangeError],
+    ['maxFrameSize', 1, RangeError],
+    ['maxFrameSize', 2 ** 24, RangeError],
+    ['maxConcurrentStreams', -1, RangeError],
+    ['maxConcurrentStreams', 2 ** 31, RangeError],
+    ['maxHeaderListSize', -1, RangeError],
+    ['maxHeaderListSize', 2 ** 32, RangeError],
+    ['enablePush', 'a', TypeError],
+    ['enablePush', 1, TypeError],
+    ['enablePush', 0, TypeError],
+    ['enablePush', null, TypeError],
+    ['enablePush', {}, TypeError]
+  ].forEach((i) => {
+    common.expectsError(
+      () => client.settings({ [i[0]]: i[1] }),
+      {
+        code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+        type: i[2] });
   });
 
   client.settings({ maxFrameSize: 1234567 });
 
-  const req = client.request({ ':path': '/' });
-
+  const req = client.request();
   req.on('response', common.mustCall());
   req.resume();
-  req.on('end', common.mustCall(() => {
+  req.on('close', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
-  req.end();
-
 }));
diff --git a/test/parallel/test-http2-client-shutdown-before-connect.js b/test/parallel/test-http2-client-shutdown-before-connect.js
index 4fed0ee3ad0703..bd971ebf7de69c 100644
--- a/test/parallel/test-http2-client-shutdown-before-connect.js
+++ b/test/parallel/test-http2-client-shutdown-before-connect.js
@@ -10,15 +10,7 @@ const server = h2.createServer();
 // we use the lower-level API here
 server.on('stream', common.mustNotCall());
 
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
-
+server.listen(0, common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  client.shutdown({ graceful: true }, common.mustCall(() => {
-    server.close();
-    client.destroy();
-  }));
-
+  client.close(common.mustCall(() => server.close()));
 }));
diff --git a/test/parallel/test-http2-client-socket-destroy.js b/test/parallel/test-http2-client-socket-destroy.js
index faf4643b0304e3..3eb7e898edcfc1 100644
--- a/test/parallel/test-http2-client-socket-destroy.js
+++ b/test/parallel/test-http2-client-socket-destroy.js
@@ -14,38 +14,27 @@ const body =
 const server = h2.createServer();
 
 // we use the lower-level API here
-server.on('stream', common.mustCall(onStream));
-
-function onStream(stream) {
-  // The stream aborted event must have been triggered
+server.on('stream', common.mustCall((stream) => {
   stream.on('aborted', common.mustCall());
-
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
+  stream.on('close', common.mustCall());
+  stream.respond();
   stream.write(body);
-}
-
-server.listen(0);
+  // purposefully do not end()
+}));
 
-server.on('listening', common.mustCall(function() {
+server.listen(0, common.mustCall(function() {
   const client = h2.connect(`http://localhost:${this.address().port}`);
-
-  const req = client.request({ ':path': '/' });
+  const req = client.request();
 
   req.on('response', common.mustCall(() => {
     // send a premature socket close
     client[kSocket].destroy();
   }));
-  req.on('data', common.mustNotCall());
 
-  req.on('end', common.mustCall(() => {
-    server.close();
-  }));
+  req.resume();
+  req.on('end', common.mustCall());
+  req.on('close', common.mustCall(() => server.close()));
 
   // On the client, the close event must call
   client.on('close', common.mustCall());
-  req.end();
-
 }));
diff --git a/test/parallel/test-http2-client-stream-destroy-before-connect.js b/test/parallel/test-http2-client-stream-destroy-before-connect.js
index 06afbf3ce8ceb2..a2412b9f1d646a 100644
--- a/test/parallel/test-http2-client-stream-destroy-before-connect.js
+++ b/test/parallel/test-http2-client-stream-destroy-before-connect.js
@@ -20,36 +20,29 @@ server.on('stream', (stream) => {
     assert.strictEqual(err.code, 'ERR_HTTP2_STREAM_ERROR');
     assert.strictEqual(err.message, 'Stream closed with error code 2');
   });
-  stream.respond({});
+  stream.respond();
   stream.end();
 });
 
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
-
+server.listen(0, common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
 
-  const req = client.request({ ':path': '/' });
-  const err = new Error('test');
-  req.destroy(err);
+  const req = client.request();
+  req.destroy(new Error('test'));
 
-  req.on('error', common.mustCall((err) => {
-    common.expectsError({
-      type: Error,
-      message: 'test'
-    })(err);
+  req.on('error', common.expectsError({
+    type: Error,
+    message: 'test'
   }));
 
   req.on('close', common.mustCall((code) => {
     assert.strictEqual(req.rstCode, NGHTTP2_INTERNAL_ERROR);
     assert.strictEqual(code, NGHTTP2_INTERNAL_ERROR);
     server.close();
-    client.destroy();
+    client.close();
   }));
 
   req.on('response', common.mustNotCall());
   req.resume();
   req.on('end', common.mustCall());
-
 }));
diff --git a/test/parallel/test-http2-client-unescaped-path.js b/test/parallel/test-http2-client-unescaped-path.js
index adfbd61fe762b4..190f8ce75e8917 100644
--- a/test/parallel/test-http2-client-unescaped-path.js
+++ b/test/parallel/test-http2-client-unescaped-path.js
@@ -4,6 +4,7 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 const http2 = require('http2');
+const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
 
@@ -13,14 +14,12 @@ const count = 32;
 
 server.listen(0, common.mustCall(() => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
+  client.setMaxListeners(33);
 
-  let remaining = count + 1;
-  function maybeClose() {
-    if (--remaining === 0) {
-      server.close();
-      client.destroy();
-    }
-  }
+  const countdown = new Countdown(count + 1, () => {
+    server.close();
+    client.close();
+  });
 
   // nghttp2 will catch the bad header value for us.
   function doTest(i) {
@@ -30,7 +29,7 @@ server.listen(0, common.mustCall(() => {
       type: Error,
       message: 'Stream closed with error code 1'
     }));
-    req.on('close', common.mustCall(maybeClose));
+    req.on('close', common.mustCall(() => countdown.dec()));
   }
 
   for (let i = 0; i <= count; i += 1)
diff --git a/test/parallel/test-http2-client-upload.js b/test/parallel/test-http2-client-upload.js
index 8fb5f369ca4cb7..70a8ff3ced01c6 100644
--- a/test/parallel/test-http2-client-upload.js
+++ b/test/parallel/test-http2-client-upload.js
@@ -9,6 +9,7 @@ const assert = require('assert');
 const http2 = require('http2');
 const fs = require('fs');
 const fixtures = require('../common/fixtures');
+const Countdown = require('../common/countdown');
 
 const loc = fixtures.path('person.jpg');
 let fileData;
@@ -34,20 +35,21 @@ fs.readFile(loc, common.mustCall((err, data) => {
   server.listen(0, common.mustCall(() => {
     const client = http2.connect(`http://localhost:${server.address().port}`);
 
-    let remaining = 2;
-    function maybeClose() {
-      if (--remaining === 0) {
-        server.close();
-        client.shutdown();
-      }
-    }
+    const countdown = new Countdown(2, () => {
+      server.close();
+      client.close();
+    });
 
     const req = client.request({ ':method': 'POST' });
     req.on('response', common.mustCall());
+
     req.resume();
-    req.on('end', common.mustCall(maybeClose));
+    req.on('end', common.mustCall());
+
+    req.on('finish', () => countdown.dec());
     const str = fs.createReadStream(loc);
-    req.on('finish', common.mustCall(maybeClose));
+    str.on('end', common.mustCall());
+    str.on('close', () => countdown.dec());
     str.pipe(req);
   }));
 }));
diff --git a/test/parallel/test-http2-client-write-before-connect.js b/test/parallel/test-http2-client-write-before-connect.js
index 26674dcad369e3..6588d7dccd139d 100644
--- a/test/parallel/test-http2-client-write-before-connect.js
+++ b/test/parallel/test-http2-client-write-before-connect.js
@@ -8,47 +8,30 @@ const h2 = require('http2');
 
 const server = h2.createServer();
 
-const {
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_METHOD,
-  HTTP2_METHOD_POST
-} = h2.constants;
-
 // we use the lower-level API here
-server.on('stream', common.mustCall(onStream));
-
-function onStream(stream, headers, flags) {
+server.on('stream', common.mustCall((stream, headers, flags) => {
   let data = '';
   stream.setEncoding('utf8');
   stream.on('data', (chunk) => data += chunk);
   stream.on('end', common.mustCall(() => {
     assert.strictEqual(data, 'some data more data');
   }));
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
-  stream.end('hello world');
-}
-
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
+  stream.respond();
+  stream.end('ok');
+}));
 
+server.listen(0, common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
 
-  const req = client.request({
-    [HTTP2_HEADER_PATH]: '/',
-    [HTTP2_HEADER_METHOD]: HTTP2_METHOD_POST });
+  const req = client.request({ ':method': 'POST' });
   req.write('some data ');
-  req.write('more data');
+  req.end('more data');
 
   req.on('response', common.mustCall());
   req.resume();
-  req.on('end', common.mustCall(() => {
+  req.on('end', common.mustCall());
+  req.on('close', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
-  req.end();
-
 }));
diff --git a/test/parallel/test-http2-compat-errors.js b/test/parallel/test-http2-compat-errors.js
index 5774d1a922bd52..c84318bad68e35 100644
--- a/test/parallel/test-http2-compat-errors.js
+++ b/test/parallel/test-http2-compat-errors.js
@@ -4,9 +4,7 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
-const assert = require('assert');
 const h2 = require('http2');
-const { Http2Stream } = require('internal/http2/core');
 
 // Errors should not be reported both in Http2ServerRequest
 // and Http2ServerResponse
@@ -14,6 +12,7 @@ const { Http2Stream } = require('internal/http2/core');
 let expected = null;
 
 const server = h2.createServer(common.mustCall(function(req, res) {
+  res.stream.on('error', common.mustCall());
   req.on('error', common.mustNotCall());
   res.on('error', common.mustNotCall());
   req.on('aborted', common.mustCall());
@@ -26,27 +25,12 @@ const server = h2.createServer(common.mustCall(function(req, res) {
   server.close();
 }));
 
-server.on('streamError', common.mustCall(function(err, stream) {
-  assert.strictEqual(err, expected);
-  assert.strictEqual(stream instanceof Http2Stream, true);
-}));
-
 server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/foobar',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`,
-    };
-    const request = client.request(headers);
-    request.on('data', common.mustCall(function(chunk) {
-      // cause an error on the server side
+  const url = `http://localhost:${server.address().port}`;
+  const client = h2.connect(url, common.mustCall(() => {
+    const request = client.request();
+    request.on('data', common.mustCall((chunk) => {
       client.destroy();
     }));
-    request.end();
   }));
 }));
diff --git a/test/parallel/test-http2-compat-expect-continue-check.js b/test/parallel/test-http2-compat-expect-continue-check.js
index 800df1c432944f..6aded8b52935c1 100644
--- a/test/parallel/test-http2-compat-expect-continue-check.js
+++ b/test/parallel/test-http2-compat-expect-continue-check.js
@@ -12,74 +12,47 @@ const testResBody = 'other stuff!\n';
 // through server receiving it, triggering 'checkContinue' custom handler,
 // writing the rest of the request to finally the client receiving to.
 
-function handler(req, res) {
-  console.error('Server sent full response');
+const server = http2.createServer(
+  common.mustNotCall('Full request received before 100 Continue')
+);
 
-  res.writeHead(200, {
-    'content-type': 'text/plain',
-    'abcd': '1'
-  });
+server.on('checkContinue', common.mustCall((req, res) => {
+  res.writeContinue();
+  res.writeHead(200, {});
   res.end(testResBody);
   // should simply return false if already too late to write
   assert.strictEqual(res.writeContinue(), false);
   res.on('finish', common.mustCall(
     () => process.nextTick(() => assert.strictEqual(res.writeContinue(), false))
   ));
-}
-
-const server = http2.createServer(
-  common.mustNotCall('Full request received before 100 Continue')
-);
-
-server.on('checkContinue', common.mustCall((req, res) => {
-  console.error('Server received Expect: 100-continue');
-
-  res.writeContinue();
-
-  // timeout so that we allow the client to receive continue first
-  setTimeout(
-    common.mustCall(() => handler(req, res)),
-    common.platformTimeout(100)
-  );
 }));
 
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
+server.listen(0, common.mustCall(() => {
   let body = '';
 
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
+  const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request({
     ':method': 'POST',
-    ':path': '/world',
     expect: '100-continue'
   });
-  console.error('Client sent request');
 
   let gotContinue = false;
   req.on('continue', common.mustCall(() => {
-    console.error('Client received 100-continue');
     gotContinue = true;
   }));
 
   req.on('response', common.mustCall((headers) => {
-    console.error('Client received response headers');
-
     assert.strictEqual(gotContinue, true);
     assert.strictEqual(headers[':status'], 200);
-    assert.strictEqual(headers['abcd'], '1');
+    req.end();
   }));
 
   req.setEncoding('utf-8');
   req.on('data', common.mustCall((chunk) => { body += chunk; }));
 
   req.on('end', common.mustCall(() => {
-    console.error('Client received full response');
-
     assert.strictEqual(body, testResBody);
-
-    client.destroy();
+    client.close();
     server.close();
   }));
 }));
diff --git a/test/parallel/test-http2-compat-expect-continue.js b/test/parallel/test-http2-compat-expect-continue.js
index 6f08e813ef385a..42fa80ae4e8620 100644
--- a/test/parallel/test-http2-compat-expect-continue.js
+++ b/test/parallel/test-http2-compat-expect-continue.js
@@ -17,8 +17,6 @@ const server = http2.createServer();
 let sentResponse = false;
 
 server.on('request', common.mustCall((req, res) => {
-  console.error('Server sent full response');
-
   res.end(testResBody);
   sentResponse = true;
 }));
@@ -28,38 +26,29 @@ server.listen(0);
 server.on('listening', common.mustCall(() => {
   let body = '';
 
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
+  const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request({
     ':method': 'POST',
-    ':path': '/world',
     expect: '100-continue'
   });
-  console.error('Client sent request');
 
   let gotContinue = false;
   req.on('continue', common.mustCall(() => {
-    console.error('Client received 100-continue');
     gotContinue = true;
   }));
 
   req.on('response', common.mustCall((headers) => {
-    console.error('Client received response headers');
-
     assert.strictEqual(gotContinue, true);
     assert.strictEqual(sentResponse, true);
     assert.strictEqual(headers[':status'], 200);
+    req.end();
   }));
 
   req.setEncoding('utf8');
   req.on('data', common.mustCall((chunk) => { body += chunk; }));
-
   req.on('end', common.mustCall(() => {
-    console.error('Client received full response');
-
     assert.strictEqual(body, testResBody);
-
-    client.destroy();
+    client.close();
     server.close();
   }));
 }));
diff --git a/test/parallel/test-http2-compat-expect-handling.js b/test/parallel/test-http2-compat-expect-handling.js
index 0a5de368c6cfff..f36032c972fc45 100644
--- a/test/parallel/test-http2-compat-expect-handling.js
+++ b/test/parallel/test-http2-compat-expect-handling.js
@@ -39,7 +39,7 @@ function nextTest(testsToRun) {
   }));
 
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     nextTest(testsToRun - 1);
   }));
 }
diff --git a/test/parallel/test-http2-compat-method-connect.js b/test/parallel/test-http2-compat-method-connect.js
index 1f43b3891b24ed..21ad23e92ba65b 100644
--- a/test/parallel/test-http2-compat-method-connect.js
+++ b/test/parallel/test-http2-compat-method-connect.js
@@ -33,7 +33,7 @@ function testMethodConnect(testsToRun) {
   }));
   req.resume();
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     testMethodConnect(testsToRun - 1);
   }));
   req.end();
diff --git a/test/parallel/test-http2-compat-serverrequest-end.js b/test/parallel/test-http2-compat-serverrequest-end.js
index b6bfd04089a103..d34372118582db 100644
--- a/test/parallel/test-http2-compat-serverrequest-end.js
+++ b/test/parallel/test-http2-compat-serverrequest-end.js
@@ -31,18 +31,11 @@ server.listen(0, common.mustCall(function() {
   }));
 
   const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/foobar',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
+  const client = h2.connect(url, common.mustCall(() => {
+    const request = client.request();
     request.resume();
-    request.on('end', common.mustCall(function() {
-      client.destroy();
+    request.on('end', common.mustCall(() => {
+      client.close();
     }));
-    request.end();
   }));
 }));
diff --git a/test/parallel/test-http2-compat-serverrequest-headers.js b/test/parallel/test-http2-compat-serverrequest-headers.js
index 58cc52c64f6c91..5843104c019189 100644
--- a/test/parallel/test-http2-compat-serverrequest-headers.js
+++ b/test/parallel/test-http2-compat-serverrequest-headers.js
@@ -79,7 +79,7 @@ server.listen(0, common.mustCall(function() {
     };
     const request = client.request(headers);
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverrequest-pause.js b/test/parallel/test-http2-compat-serverrequest-pause.js
index f8494bb0ddee39..62a23997c75bd8 100644
--- a/test/parallel/test-http2-compat-serverrequest-pause.js
+++ b/test/parallel/test-http2-compat-serverrequest-pause.js
@@ -46,7 +46,7 @@ server.listen(0, common.mustCall(() => {
   request.resume();
   request.end(testStr);
   request.on('end', common.mustCall(function() {
-    client.destroy();
+    client.close();
     server.close();
   }));
 }));
diff --git a/test/parallel/test-http2-compat-serverrequest-pipe.js b/test/parallel/test-http2-compat-serverrequest-pipe.js
index 04c8cfe546f329..becc62c6621e7f 100644
--- a/test/parallel/test-http2-compat-serverrequest-pipe.js
+++ b/test/parallel/test-http2-compat-serverrequest-pipe.js
@@ -35,7 +35,7 @@ server.listen(0, common.mustCall(() => {
   function maybeClose() {
     if (--remaining === 0) {
       server.close();
-      client.destroy();
+      client.close();
     }
   }
 
diff --git a/test/parallel/test-http2-compat-serverrequest-settimeout.js b/test/parallel/test-http2-compat-serverrequest-settimeout.js
index 460eb576bfd4f6..f7189161802301 100644
--- a/test/parallel/test-http2-compat-serverrequest-settimeout.js
+++ b/test/parallel/test-http2-compat-serverrequest-settimeout.js
@@ -12,7 +12,6 @@ const server = http2.createServer();
 server.on('request', (req, res) => {
   req.setTimeout(msecs, common.mustCall(() => {
     res.end();
-    req.setTimeout(msecs, common.mustNotCall());
   }));
   res.on('finish', common.mustCall(() => {
     req.setTimeout(msecs, common.mustNotCall());
@@ -35,7 +34,7 @@ server.listen(0, common.mustCall(() => {
     ':authority': `localhost:${port}`
   });
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
   }));
   req.resume();
   req.end();
diff --git a/test/parallel/test-http2-compat-serverrequest-trailers.js b/test/parallel/test-http2-compat-serverrequest-trailers.js
index b4d90281918d9e..285178cab66816 100644
--- a/test/parallel/test-http2-compat-serverrequest-trailers.js
+++ b/test/parallel/test-http2-compat-serverrequest-trailers.js
@@ -62,7 +62,7 @@ server.listen(0, common.mustCall(function() {
     request.resume();
     request.on('end', common.mustCall(function() {
       server.close();
-      client.destroy();
+      client.close();
     }));
     request.write('test\n');
     request.end('test');
diff --git a/test/parallel/test-http2-compat-serverrequest.js b/test/parallel/test-http2-compat-serverrequest.js
index edcd7a8f8cdea4..d92da61d943cb7 100644
--- a/test/parallel/test-http2-compat-serverrequest.js
+++ b/test/parallel/test-http2-compat-serverrequest.js
@@ -46,7 +46,7 @@ server.listen(0, common.mustCall(function() {
     };
     const request = client.request(headers);
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-close.js b/test/parallel/test-http2-compat-serverresponse-close.js
index 35e39b9670868e..0ff6bd3a83f600 100644
--- a/test/parallel/test-http2-compat-serverresponse-close.js
+++ b/test/parallel/test-http2-compat-serverresponse-close.js
@@ -16,26 +16,17 @@ const server = h2.createServer(common.mustCall((req, res) => {
 
   req.on('close', common.mustCall());
   res.on('close', common.mustCall());
+  req.on('error', common.mustNotCall());
 }));
 server.listen(0);
 
-server.on('listening', function() {
-  const port = server.address().port;
-
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/foobar',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`,
-    };
-    const request = client.request(headers);
+server.on('listening', () => {
+  const url = `http://localhost:${server.address().port}`;
+  const client = h2.connect(url, common.mustCall(() => {
+    const request = client.request();
     request.on('data', common.mustCall(function(chunk) {
-      // cause an error on the server side
       client.destroy();
       server.close();
     }));
-    request.end();
   }));
 });
diff --git a/test/parallel/test-http2-compat-serverresponse-createpushresponse.js b/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
index bd9d5c1399792a..b168c3563c32e2 100644
--- a/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
+++ b/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
@@ -43,7 +43,7 @@ const server = h2.createServer((request, response) => {
         ':path': '/pushed',
         ':method': 'GET'
       }, common.mustCall((error) => {
-        assert.strictEqual(error.code, 'ERR_HTTP2_STREAM_CLOSED');
+        assert.strictEqual(error.code, 'ERR_HTTP2_INVALID_STREAM');
       }));
     });
   }));
@@ -61,7 +61,7 @@ server.listen(0, common.mustCall(() => {
     let remaining = 2;
     function maybeClose() {
       if (--remaining === 0) {
-        client.destroy();
+        client.close();
         server.close();
       }
     }
diff --git a/test/parallel/test-http2-compat-serverresponse-destroy.js b/test/parallel/test-http2-compat-serverresponse-destroy.js
index 77e761b6227702..54214737840061 100644
--- a/test/parallel/test-http2-compat-serverresponse-destroy.js
+++ b/test/parallel/test-http2-compat-serverresponse-destroy.js
@@ -5,6 +5,7 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
+const Countdown = require('../common/countdown');
 
 // Check that destroying the Http2ServerResponse stream produces
 // the expected result, including the ability to throw an error
@@ -30,63 +31,54 @@ const server = http2.createServer(common.mustCall((req, res) => {
   if (req.url !== '/') {
     nextError = errors.shift();
   }
+
   res.destroy(nextError);
 }, 3));
 
-server.on(
-  'streamError',
-  common.mustCall((err) => assert.strictEqual(err, nextError), 2)
-);
-
 server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
-  const req = client.request({
-    ':path': '/',
-    ':method': 'GET',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  });
+  const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  req.on('response', common.mustNotCall());
-  req.on('error', common.mustNotCall());
-  req.on('end', common.mustCall());
+  const countdown = new Countdown(3, () => {
+    server.close();
+    client.close();
+  });
 
-  req.resume();
-  req.end();
+  {
+    const req = client.request();
+    req.on('response', common.mustNotCall());
+    req.on('error', common.mustNotCall());
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => countdown.dec()));
+    req.resume();
+  }
 
-  const req2 = client.request({
-    ':path': '/error',
-    ':method': 'GET',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  });
+  {
+    const req = client.request({ ':path': '/error' });
 
-  req2.on('response', common.mustNotCall());
-  req2.on('error', common.mustNotCall());
-  req2.on('end', common.mustCall());
+    req.on('response', common.mustNotCall());
+    req.on('error', common.expectsError({
+      code: 'ERR_HTTP2_STREAM_ERROR',
+      type: Error,
+      message: 'Stream closed with error code 2'
+    }));
+    req.on('close', common.mustCall(() => countdown.dec()));
 
-  req2.resume();
-  req2.end();
+    req.resume();
+    req.on('end', common.mustCall());
+  }
 
-  const req3 = client.request({
-    ':path': '/error',
-    ':method': 'GET',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  });
+  {
+    const req = client.request({ ':path': '/error' });
 
-  req3.on('response', common.mustNotCall());
-  req3.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code 2'
-  }));
-  req3.on('end', common.mustCall(() => {
-    server.close();
-    client.destroy();
-  }));
+    req.on('response', common.mustNotCall());
+    req.on('error', common.expectsError({
+      code: 'ERR_HTTP2_STREAM_ERROR',
+      type: Error,
+      message: 'Stream closed with error code 2'
+    }));
+    req.on('close', common.mustCall(() => countdown.dec()));
 
-  req3.resume();
-  req3.end();
+    req.resume();
+    req.on('end', common.mustCall());
+  }
 }));
diff --git a/test/parallel/test-http2-compat-serverresponse-drain.js b/test/parallel/test-http2-compat-serverresponse-drain.js
index e2465cfa00d1f6..7ccbb1f4d21209 100644
--- a/test/parallel/test-http2-compat-serverresponse-drain.js
+++ b/test/parallel/test-http2-compat-serverresponse-drain.js
@@ -37,7 +37,7 @@ server.listen(0, common.mustCall(() => {
 
   request.on('end', common.mustCall(function() {
     assert.strictEqual(data, testString.repeat(2));
-    client.destroy();
+    client.close();
     server.close();
   }));
 }));
diff --git a/test/parallel/test-http2-compat-serverresponse-end.js b/test/parallel/test-http2-compat-serverresponse-end.js
index 366d52321554fe..0e846a5948e3cc 100644
--- a/test/parallel/test-http2-compat-serverresponse-end.js
+++ b/test/parallel/test-http2-compat-serverresponse-end.js
@@ -52,7 +52,7 @@ const {
       request.on('data', (chunk) => (data += chunk));
       request.on('end', mustCall(() => {
         strictEqual(data, 'end');
-        client.destroy();
+        client.close();
       }));
       request.end();
       request.resume();
@@ -83,7 +83,7 @@ const {
       request.on('data', (chunk) => (data += chunk));
       request.on('end', mustCall(() => {
         strictEqual(data, 'test\uD83D\uDE00');
-        client.destroy();
+        client.close();
       }));
       request.end();
       request.resume();
@@ -110,7 +110,7 @@ const {
       };
       const request = client.request(headers);
       request.on('data', mustNotCall());
-      request.on('end', mustCall(() => client.destroy()));
+      request.on('end', mustCall(() => client.close()));
       request.end();
       request.resume();
     }));
@@ -143,7 +143,7 @@ const {
       }));
       request.on('data', mustNotCall());
       request.on('end', mustCall(() => {
-        client.destroy();
+        client.close();
         server.close();
       }));
       request.end();
@@ -172,7 +172,7 @@ const {
       const request = client.request(headers);
       request.on('data', mustNotCall());
       request.on('end', mustCall(() => {
-        client.destroy();
+        client.close();
         server.close();
       }));
       request.end();
@@ -208,7 +208,7 @@ const {
       }));
       request.on('data', mustNotCall());
       request.on('end', mustCall(() => {
-        client.destroy();
+        client.close();
         server.close();
       }));
       request.end();
@@ -243,7 +243,7 @@ const {
       }));
       request.on('data', mustNotCall());
       request.on('end', mustCall(() => {
-        client.destroy();
+        client.close();
         server.close();
       }));
       request.end();
@@ -283,7 +283,7 @@ const {
       }));
       request.on('data', mustNotCall());
       request.on('end', mustCall(() => {
-        client.destroy();
+        client.close();
         server.close();
       }));
       request.end();
@@ -315,7 +315,7 @@ const {
       }));
       request.on('data', mustNotCall());
       request.on('end', mustCall(() => {
-        client.destroy();
+        client.close();
         server.close();
       }));
       request.end();
diff --git a/test/parallel/test-http2-compat-serverresponse-finished.js b/test/parallel/test-http2-compat-serverresponse-finished.js
index b816b922202dd6..ceaa6eb5c3cf2c 100644
--- a/test/parallel/test-http2-compat-serverresponse-finished.js
+++ b/test/parallel/test-http2-compat-serverresponse-finished.js
@@ -39,7 +39,7 @@ server.listen(0, common.mustCall(function() {
     };
     const request = client.request(headers);
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-flushheaders.js b/test/parallel/test-http2-compat-serverresponse-flushheaders.js
index 68d4789f69be53..d155b07863d26c 100644
--- a/test/parallel/test-http2-compat-serverresponse-flushheaders.js
+++ b/test/parallel/test-http2-compat-serverresponse-flushheaders.js
@@ -51,7 +51,7 @@ server.listen(0, common.mustCall(function() {
       serverResponse.end();
     }, 1));
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-headers-after-destroy.js b/test/parallel/test-http2-compat-serverresponse-headers-after-destroy.js
index fb1e369f786bf0..99e3ccc948184e 100644
--- a/test/parallel/test-http2-compat-serverresponse-headers-after-destroy.js
+++ b/test/parallel/test-http2-compat-serverresponse-headers-after-destroy.js
@@ -13,8 +13,6 @@ const server = h2.createServer();
 server.listen(0, common.mustCall(function() {
   const port = server.address().port;
   server.once('request', common.mustCall(function(request, response) {
-    response.destroy();
-
     response.on('finish', common.mustCall(() => {
       assert.strictEqual(response.headersSent, false);
       assert.doesNotThrow(() => response.setHeader('test', 'value'));
@@ -27,6 +25,8 @@ server.listen(0, common.mustCall(function() {
         server.close();
       });
     }));
+
+    response.destroy();
   }));
 
   const url = `http://localhost:${port}`;
@@ -39,7 +39,7 @@ server.listen(0, common.mustCall(function() {
     };
     const request = client.request(headers);
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-headers.js b/test/parallel/test-http2-compat-serverresponse-headers.js
index 6da74307e0d340..7b5313b8e7b037 100644
--- a/test/parallel/test-http2-compat-serverresponse-headers.js
+++ b/test/parallel/test-http2-compat-serverresponse-headers.js
@@ -179,7 +179,7 @@ server.listen(0, common.mustCall(function() {
     };
     const request = client.request(headers);
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-settimeout.js b/test/parallel/test-http2-compat-serverresponse-settimeout.js
index 6d06d07f7dc0ab..bb09633727ccf7 100644
--- a/test/parallel/test-http2-compat-serverresponse-settimeout.js
+++ b/test/parallel/test-http2-compat-serverresponse-settimeout.js
@@ -12,7 +12,6 @@ const server = http2.createServer();
 server.on('request', (req, res) => {
   res.setTimeout(msecs, common.mustCall(() => {
     res.end();
-    res.setTimeout(msecs, common.mustNotCall());
   }));
   res.on('finish', common.mustCall(() => {
     res.setTimeout(msecs, common.mustNotCall());
@@ -35,7 +34,7 @@ server.listen(0, common.mustCall(() => {
     ':authority': `localhost:${port}`
   });
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
   }));
   req.resume();
   req.end();
diff --git a/test/parallel/test-http2-compat-serverresponse-statuscode.js b/test/parallel/test-http2-compat-serverresponse-statuscode.js
index 6a573da88f9858..ecb6da5df68c11 100644
--- a/test/parallel/test-http2-compat-serverresponse-statuscode.js
+++ b/test/parallel/test-http2-compat-serverresponse-statuscode.js
@@ -69,7 +69,7 @@ server.listen(0, common.mustCall(function() {
     };
     const request = client.request(headers);
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-statusmessage-property-set.js b/test/parallel/test-http2-compat-serverresponse-statusmessage-property-set.js
index 45a876d674313b..87e172402899f2 100644
--- a/test/parallel/test-http2-compat-serverresponse-statusmessage-property-set.js
+++ b/test/parallel/test-http2-compat-serverresponse-statusmessage-property-set.js
@@ -42,7 +42,7 @@ server.listen(0, common.mustCall(function() {
       assert.strictEqual(headers[':status'], 200);
     }, 1));
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-statusmessage-property.js b/test/parallel/test-http2-compat-serverresponse-statusmessage-property.js
index 21a5b6ea4e2820..8a083cf3ba1638 100644
--- a/test/parallel/test-http2-compat-serverresponse-statusmessage-property.js
+++ b/test/parallel/test-http2-compat-serverresponse-statusmessage-property.js
@@ -41,7 +41,7 @@ server.listen(0, common.mustCall(function() {
       assert.strictEqual(headers[':status'], 200);
     }, 1));
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-statusmessage.js b/test/parallel/test-http2-compat-serverresponse-statusmessage.js
index 841bafe724a7a8..dee916d1aeef54 100644
--- a/test/parallel/test-http2-compat-serverresponse-statusmessage.js
+++ b/test/parallel/test-http2-compat-serverresponse-statusmessage.js
@@ -45,7 +45,7 @@ server.listen(0, common.mustCall(function() {
       assert.strictEqual(headers['foo-bar'], 'abc123');
     }, 1));
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-serverresponse-trailers.js b/test/parallel/test-http2-compat-serverresponse-trailers.js
index 7332f9e8d0b63d..66ad8843fa33b9 100644
--- a/test/parallel/test-http2-compat-serverresponse-trailers.js
+++ b/test/parallel/test-http2-compat-serverresponse-trailers.js
@@ -68,7 +68,7 @@ server.listen(0, common.mustCall(() => {
     }));
     request.resume();
     request.on('end', common.mustCall(() => {
-      client.destroy();
+      client.close();
       server.close();
     }));
   }));
diff --git a/test/parallel/test-http2-compat-serverresponse-write-no-cb.js b/test/parallel/test-http2-compat-serverresponse-write-no-cb.js
index 58a4ca053d222c..a62bb1b0ac78f1 100644
--- a/test/parallel/test-http2-compat-serverresponse-write-no-cb.js
+++ b/test/parallel/test-http2-compat-serverresponse-write-no-cb.js
@@ -6,44 +6,33 @@ const { mustCall,
         hasCrypto, skip } = require('../common');
 if (!hasCrypto)
   skip('missing crypto');
-const { throws } = require('assert');
 const { createServer, connect } = require('http2');
 
 // Http2ServerResponse.write does not imply there is a callback
 
-const expectedError = expectsError({
-  code: 'ERR_HTTP2_STREAM_CLOSED',
-  message: 'The stream is already closed'
-}, 2);
-
 {
   const server = createServer();
   server.listen(0, mustCall(() => {
     const port = server.address().port;
     const url = `http://localhost:${port}`;
     const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'GET',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.end();
+      const request = client.request();
       request.resume();
+      request.on('end', mustCall());
+      request.on('close', mustCall(() => {
+        client.close();
+      }));
     }));
 
     server.once('request', mustCall((request, response) => {
       client.destroy();
       response.stream.session.on('close', mustCall(() => {
         response.on('error', mustNotCall());
-        throws(
+        expectsError(
           () => { response.write('muahaha'); },
-          expectsError({
-            code: 'ERR_HTTP2_STREAM_CLOSED',
-            type: Error,
-            message: 'The stream is already closed'
-          })
+          {
+            code: 'ERR_HTTP2_INVALID_STREAM'
+          }
         );
         server.close();
       }));
@@ -57,21 +46,21 @@ const expectedError = expectsError({
     const port = server.address().port;
     const url = `http://localhost:${port}`;
     const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'get',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.end();
+      const request = client.request();
       request.resume();
+      request.on('end', mustCall());
+      request.on('close', mustCall(() => client.close()));
     }));
 
     server.once('request', mustCall((request, response) => {
       client.destroy();
       response.stream.session.on('close', mustCall(() => {
-        response.write('muahaha', mustCall(expectedError));
+        expectsError(
+          () => response.write('muahaha'),
+          {
+            code: 'ERR_HTTP2_INVALID_STREAM'
+          }
+        );
         server.close();
       }));
     }));
@@ -84,20 +73,20 @@ const expectedError = expectsError({
     const port = server.address().port;
     const url = `http://localhost:${port}`;
     const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'get',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.end();
+      const request = client.request();
       request.resume();
+      request.on('end', mustCall());
+      request.on('close', mustCall(() => client.close()));
     }));
 
     server.once('request', mustCall((request, response) => {
       response.stream.session.on('close', mustCall(() => {
-        response.write('muahaha', 'utf8', mustCall(expectedError));
+        expectsError(
+          () => response.write('muahaha', 'utf8'),
+          {
+            code: 'ERR_HTTP2_INVALID_STREAM'
+          }
+        );
         server.close();
       }));
       client.destroy();
diff --git a/test/parallel/test-http2-compat-serverresponse-writehead.js b/test/parallel/test-http2-compat-serverresponse-writehead.js
index 704f199ca27e99..5fd787e100350c 100644
--- a/test/parallel/test-http2-compat-serverresponse-writehead.js
+++ b/test/parallel/test-http2-compat-serverresponse-writehead.js
@@ -23,7 +23,7 @@ server.listen(0, common.mustCall(function() {
       server.close();
       process.nextTick(common.mustCall(() => {
         common.expectsError(() => { response.writeHead(300); }, {
-          code: 'ERR_HTTP2_STREAM_CLOSED'
+          code: 'ERR_HTTP2_INVALID_STREAM'
         });
       }));
     }));
@@ -44,7 +44,7 @@ server.listen(0, common.mustCall(function() {
       assert.strictEqual(headers[':status'], 418);
     }, 1));
     request.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-compat-socket-set.js b/test/parallel/test-http2-compat-socket-set.js
index ff53d998f4d207..05beb09d548e91 100644
--- a/test/parallel/test-http2-compat-socket-set.js
+++ b/test/parallel/test-http2-compat-socket-set.js
@@ -98,7 +98,7 @@ server.listen(0, common.mustCall(function() {
     };
     const request = client.request(headers);
     request.on('end', common.mustCall(() => {
-      client.destroy();
+      client.close();
       server.close();
     }));
     request.end();
diff --git a/test/parallel/test-http2-compat-socket.js b/test/parallel/test-http2-compat-socket.js
index d30b2f2a11613b..80c8b1d30d10b3 100644
--- a/test/parallel/test-http2-compat-socket.js
+++ b/test/parallel/test-http2-compat-socket.js
@@ -81,7 +81,7 @@ server.listen(0, common.mustCall(function() {
     };
     const request = client.request(headers);
     request.on('end', common.mustCall(() => {
-      client.destroy();
+      client.close();
     }));
     request.end();
     request.resume();
diff --git a/test/parallel/test-http2-connect-method.js b/test/parallel/test-http2-connect-method.js
index 4d443d5c217421..0ddbc60433cf85 100644
--- a/test/parallel/test-http2-connect-method.js
+++ b/test/parallel/test-http2-connect-method.js
@@ -13,7 +13,8 @@ const {
   HTTP2_HEADER_AUTHORITY,
   HTTP2_HEADER_SCHEME,
   HTTP2_HEADER_PATH,
-  NGHTTP2_CONNECT_ERROR
+  NGHTTP2_CONNECT_ERROR,
+  NGHTTP2_REFUSED_STREAM
 } = http2.constants;
 
 const server = net.createServer(common.mustCall((socket) => {
@@ -34,7 +35,7 @@ server.listen(0, common.mustCall(() => {
   const proxy = http2.createServer();
   proxy.on('stream', common.mustCall((stream, headers) => {
     if (headers[HTTP2_HEADER_METHOD] !== 'CONNECT') {
-      stream.rstWithRefused();
+      stream.close(NGHTTP2_REFUSED_STREAM);
       return;
     }
     const auth = new URL(`tcp://${headers[HTTP2_HEADER_AUTHORITY]}`);
@@ -47,7 +48,7 @@ server.listen(0, common.mustCall(() => {
     });
     socket.on('close', common.mustCall());
     socket.on('error', (error) => {
-      stream.rstStream(NGHTTP2_CONNECT_ERROR);
+      stream.close(NGHTTP2_CONNECT_ERROR);
     });
   }));
 
@@ -99,7 +100,7 @@ server.listen(0, common.mustCall(() => {
     req.on('data', (chunk) => data += chunk);
     req.on('end', common.mustCall(() => {
       assert.strictEqual(data, 'hello');
-      client.destroy();
+      client.close();
       proxy.close();
       server.close();
     }));
diff --git a/test/parallel/test-http2-connect.js b/test/parallel/test-http2-connect.js
index e5a4e429907090..894c51fe3d9330 100644
--- a/test/parallel/test-http2-connect.js
+++ b/test/parallel/test-http2-connect.js
@@ -20,7 +20,7 @@ const { createServer, connect } = require('http2');
 
     for (const client of clients) {
       client.once('connect', mustCall((headers) => {
-        client.destroy();
+        client.close();
         clients.delete(client);
         if (clients.size === 0) {
           server.close();
@@ -33,7 +33,11 @@ const { createServer, connect } = require('http2');
 // check for https as protocol
 {
   const authority = 'https://localhost';
-  doesNotThrow(() => connect(authority));
+  doesNotThrow(() => {
+    // A socket error may or may not be reported, keep this as a non-op
+    // instead of a mustCall or mustNotCall
+    connect(authority).on('error', () => {});
+  });
 }
 
 // check for error for an invalid protocol (not http or https)
diff --git a/test/parallel/test-http2-cookies.js b/test/parallel/test-http2-cookies.js
index 48b08b6367b4b3..cf763915389287 100644
--- a/test/parallel/test-http2-cookies.js
+++ b/test/parallel/test-http2-cookies.js
@@ -54,7 +54,7 @@ server.on('listening', common.mustCall(() => {
 
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end();
 
diff --git a/test/parallel/test-http2-create-client-connect.js b/test/parallel/test-http2-create-client-connect.js
index cd7d8b4fc8c3f9..fa9711fe1b28a7 100644
--- a/test/parallel/test-http2-create-client-connect.js
+++ b/test/parallel/test-http2-create-client-connect.js
@@ -30,7 +30,7 @@ const URL = url.URL;
                                       () => setImmediate(() => server.close()));
 
     const maybeClose = common.mustCall((client) => {
-      client.destroy();
+      client.close();
       serverClose.dec();
     }, items.length);
 
@@ -42,7 +42,7 @@ const URL = url.URL;
 
     // Will fail because protocol does not match the server.
     h2.connect({ port: port, protocol: 'https:' })
-      .on('socketError', common.mustCall(() => serverClose.dec()));
+      .on('error', common.mustCall(() => serverClose.dec()));
   }));
 }
 
@@ -55,10 +55,8 @@ const URL = url.URL;
   };
 
   const server = h2.createSecureServer(options);
-  server.listen(0);
-
-  server.on('listening', common.mustCall(function() {
-    const port = this.address().port;
+  server.listen(0, common.mustCall(() => {
+    const port = server.address().port;
 
     const opts = { rejectUnauthorized: false };
 
@@ -74,7 +72,7 @@ const URL = url.URL;
                                       () => setImmediate(() => server.close()));
 
     const maybeClose = common.mustCall((client) => {
-      client.destroy();
+      client.close();
       serverClose.dec();
     }, items.length);
 
diff --git a/test/parallel/test-http2-create-client-session.js b/test/parallel/test-http2-create-client-session.js
index 149b5164231a21..c5e9468f9bd15b 100644
--- a/test/parallel/test-http2-create-client-session.js
+++ b/test/parallel/test-http2-create-client-session.js
@@ -5,6 +5,8 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
+const Countdown = require('../common/countdown');
+
 const body =
   '<html><head></head><body><h1>this is some data</h2></body></html>';
 
@@ -23,21 +25,26 @@ function onStream(stream, headers, flags) {
     'content-type': 'text/html',
     ':status': 200
   });
-  stream.end(body);
+  stream.write(body.slice(0, 20));
+  stream.end(body.slice(20));
 }
 
 server.listen(0);
 
-let expected = count;
+server.on('listening', common.mustCall(() => {
 
-server.on('listening', common.mustCall(function() {
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+  client.setMaxListeners(100);
 
-  const client = h2.connect(`http://localhost:${this.address().port}`);
+  client.on('goaway', console.log);
 
-  const headers = { ':path': '/' };
+  const countdown = new Countdown(count, () => {
+    client.close();
+    server.close();
+  });
 
   for (let n = 0; n < count; n++) {
-    const req = client.request(headers);
+    const req = client.request();
 
     req.on('response', common.mustCall(function(headers) {
       assert.strictEqual(headers[':status'], 200, 'status code is set');
@@ -51,12 +58,7 @@ server.on('listening', common.mustCall(function() {
     req.on('data', (d) => data += d);
     req.on('end', common.mustCall(() => {
       assert.strictEqual(body, data);
-      if (--expected === 0) {
-        server.close();
-        client.destroy();
-      }
     }));
-    req.end();
+    req.on('close', common.mustCall(() => countdown.dec()));
   }
-
 }));
diff --git a/test/parallel/test-http2-createsecureserver-nooptions.js b/test/parallel/test-http2-createsecureserver-nooptions.js
index 8ff7f22e3ffcf6..71764f5783e404 100644
--- a/test/parallel/test-http2-createsecureserver-nooptions.js
+++ b/test/parallel/test-http2-createsecureserver-nooptions.js
@@ -6,7 +6,7 @@ if (!common.hasCrypto)
 
 const http2 = require('http2');
 
-const invalidOptions = [() => {}, 1, 'test', null, undefined];
+const invalidOptions = [() => {}, 1, 'test', null];
 const invalidArgTypeError = {
   type: TypeError,
   code: 'ERR_INVALID_ARG_TYPE',
@@ -14,9 +14,9 @@ const invalidArgTypeError = {
 };
 
 // Error if options are not passed to createSecureServer
-invalidOptions.forEach((invalidOption) =>
+invalidOptions.forEach((invalidOption) => {
   common.expectsError(
     () => http2.createSecureServer(invalidOption),
     invalidArgTypeError
-  )
-);
+  );
+});
diff --git a/test/parallel/test-http2-createwritereq.js b/test/parallel/test-http2-createwritereq.js
index ca394a5d425470..40d0ddc117c5ad 100644
--- a/test/parallel/test-http2-createwritereq.js
+++ b/test/parallel/test-http2-createwritereq.js
@@ -54,7 +54,7 @@ server.listen(0, common.mustCall(function() {
     req.resume();
 
     req.on('end', common.mustCall(function() {
-      client.destroy();
+      client.close();
       testsFinished++;
 
       if (testsFinished === testsToRun) {
diff --git a/test/parallel/test-http2-date-header.js b/test/parallel/test-http2-date-header.js
index ab0654e64cbcd7..2b63e1b7899a2e 100644
--- a/test/parallel/test-http2-date-header.js
+++ b/test/parallel/test-http2-date-header.js
@@ -24,6 +24,6 @@ server.listen(0, common.mustCall(() => {
   req.resume();
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
 }));
diff --git a/test/parallel/test-http2-dont-lose-data.js b/test/parallel/test-http2-dont-lose-data.js
new file mode 100644
index 00000000000000..eb85277b7b124c
--- /dev/null
+++ b/test/parallel/test-http2-dont-lose-data.js
@@ -0,0 +1,58 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer();
+
+server.on('stream', (s) => {
+  assert(s.pushAllowed);
+
+  s.pushStream({ ':path': '/file' }, common.mustCall((err, pushStream) => {
+    assert.ifError(err);
+    pushStream.respond();
+    pushStream.end('a push stream');
+  }));
+
+  s.respond();
+  s.end('hello world');
+});
+
+server.listen(0, () => {
+  server.unref();
+
+  const url = `http://localhost:${server.address().port}`;
+
+  const client = http2.connect(url);
+  const req = client.request();
+
+  let pushStream;
+
+  client.on('stream', common.mustCall((s, headers) => {
+    assert.strictEqual(headers[':path'], '/file');
+    pushStream = s;
+  }));
+
+  req.on('response', common.mustCall((headers) => {
+    let pushData = '';
+    pushStream.setEncoding('utf8');
+    pushStream.on('data', (d) => pushData += d);
+    pushStream.on('end', common.mustCall(() => {
+      assert.strictEqual(pushData, 'a push stream');
+
+      // removing the setImmediate causes the test to pass
+      setImmediate(function() {
+        let data = '';
+        req.setEncoding('utf8');
+        req.on('data', (d) => data += d);
+        req.on('end', common.mustCall(() => {
+          assert.strictEqual(data, 'hello world');
+          client.close();
+        }));
+      });
+    }));
+  }));
+});
diff --git a/test/parallel/test-http2-dont-override.js b/test/parallel/test-http2-dont-override.js
index cc60a2fe802a82..b45713deb3ca60 100644
--- a/test/parallel/test-http2-dont-override.js
+++ b/test/parallel/test-http2-dont-override.js
@@ -44,6 +44,6 @@ server.listen(0, common.mustCall(() => {
   req.resume();
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
 }));
diff --git a/test/parallel/test-http2-generic-streams-sendfile.js b/test/parallel/test-http2-generic-streams-sendfile.js
index 1054574a8b1ca2..b752b0fdcb815a 100644
--- a/test/parallel/test-http2-generic-streams-sendfile.js
+++ b/test/parallel/test-http2-generic-streams-sendfile.js
@@ -20,7 +20,7 @@ const makeDuplexPair = require('../common/duplexpair');
     createConnection: common.mustCall(() => clientSide)
   });
 
-  const req = client.request({ ':path': '/' });
+  const req = client.request();
 
   req.on('response', common.mustCall((headers) => {
     assert.strictEqual(headers[':status'], 200);
@@ -28,9 +28,7 @@ const makeDuplexPair = require('../common/duplexpair');
 
   req.setEncoding('utf8');
   let data = '';
-  req.on('data', (chunk) => {
-    data += chunk;
-  });
+  req.on('data', (chunk) => data += chunk);
   req.on('end', common.mustCall(() => {
     assert.strictEqual(data, fs.readFileSync(__filename, 'utf8'));
     clientSide.destroy();
diff --git a/test/parallel/test-http2-goaway-opaquedata.js b/test/parallel/test-http2-goaway-opaquedata.js
index d8895a82edf464..3f1fb4d7954414 100644
--- a/test/parallel/test-http2-goaway-opaquedata.js
+++ b/test/parallel/test-http2-goaway-opaquedata.js
@@ -10,32 +10,23 @@ const server = http2.createServer();
 const data = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
 
 server.on('stream', common.mustCall((stream) => {
-  stream.session.shutdown({
-    errorCode: 1,
-    opaqueData: data
-  });
+  stream.session.goaway(0, 0, data);
+  stream.respond();
   stream.end();
-  stream.on('error', common.mustCall(common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code 7'
-  })));
 }));
 
 server.listen(0, () => {
 
   const client = http2.connect(`http://localhost:${server.address().port}`);
-  client.on('goaway', common.mustCall((code, lastStreamID, buf) => {
-    assert.deepStrictEqual(code, 1);
-    assert.deepStrictEqual(lastStreamID, 0);
+  client.once('goaway', common.mustCall((code, lastStreamID, buf) => {
+    assert.deepStrictEqual(code, 0);
+    assert.deepStrictEqual(lastStreamID, 1);
     assert.deepStrictEqual(data, buf);
-    // Call shutdown() here so that emitGoaway calls destroy()
-    client.shutdown();
     server.close();
   }));
-  const req = client.request({ ':path': '/' });
+  const req = client.request();
   req.resume();
   req.on('end', common.mustCall());
+  req.on('close', common.mustCall());
   req.end();
-
 });
diff --git a/test/parallel/test-http2-head-request.js b/test/parallel/test-http2-head-request.js
index d15665624ac192..a56abf3c9006f3 100644
--- a/test/parallel/test-http2-head-request.js
+++ b/test/parallel/test-http2-head-request.js
@@ -54,6 +54,6 @@ server.listen(0, () => {
   req.on('data', common.mustNotCall());
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
 });
diff --git a/test/parallel/test-http2-https-fallback.js b/test/parallel/test-http2-https-fallback.js
index 04e9ca480c9099..01b694e586dd49 100644
--- a/test/parallel/test-http2-https-fallback.js
+++ b/test/parallel/test-http2-https-fallback.js
@@ -52,7 +52,7 @@ function onSession(session) {
     strictEqual(alpnProtocol, 'h2');
     strictEqual(httpVersion, '2.0');
 
-    session.destroy();
+    session.close();
     this.cleanup();
   }));
   request.end();
diff --git a/test/parallel/test-http2-info-headers-errors.js b/test/parallel/test-http2-info-headers-errors.js
index b671bece4f76fc..1df76334558529 100644
--- a/test/parallel/test-http2-info-headers-errors.js
+++ b/test/parallel/test-http2-info-headers-errors.js
@@ -48,10 +48,6 @@ server.on('stream', common.mustCall((stream, headers) => {
   if (currentError.type === 'stream') {
     stream.session.on('error', errorMustNotCall);
     stream.on('error', errorMustCall);
-    stream.on('error', common.mustCall(() => {
-      stream.respond();
-      stream.end();
-    }));
   } else {
     stream.session.once('error', errorMustCall);
     stream.on('error', errorMustNotCall);
@@ -63,24 +59,21 @@ server.on('stream', common.mustCall((stream, headers) => {
 server.listen(0, common.mustCall(() => runTest(tests.shift())));
 
 function runTest(test) {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const headers = {
-    ':path': '/',
-    ':method': 'POST',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  };
-
-  const client = http2.connect(url);
-  const req = client.request(headers);
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request({ ':method': 'POST' });
 
   currentError = test;
   req.resume();
   req.end();
 
-  req.on('end', common.mustCall(() => {
-    client.destroy();
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code 2'
+  }));
+
+  req.on('close', common.mustCall(() => {
+    client.close();
 
     if (!tests.length) {
       server.close();
diff --git a/test/parallel/test-http2-info-headers.js b/test/parallel/test-http2-info-headers.js
index 332c688429c37e..2313040de12a97 100644
--- a/test/parallel/test-http2-info-headers.js
+++ b/test/parallel/test-http2-info-headers.js
@@ -88,7 +88,7 @@ server.on('listening', common.mustCall(() => {
 
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end();
 
diff --git a/test/parallel/test-http2-invalidargtypes-errors.js b/test/parallel/test-http2-invalidargtypes-errors.js
index 3471e46fdf4ca4..ff189a2977559f 100644
--- a/test/parallel/test-http2-invalidargtypes-errors.js
+++ b/test/parallel/test-http2-invalidargtypes-errors.js
@@ -7,29 +7,25 @@ const http2 = require('http2');
 
 const server = http2.createServer();
 
-server.on(
-  'stream',
-  common.mustCall((stream) => {
-    const invalidArgTypeError = (param, type) => ({
-      type: TypeError,
+server.on('stream', common.mustCall((stream) => {
+  common.expectsError(
+    () => stream.close('string'),
+    {
       code: 'ERR_INVALID_ARG_TYPE',
-      message: `The "${param}" argument must be of type ${type}`
-    });
-    common.expectsError(
-      () => stream.rstStream('string'),
-      invalidArgTypeError('code', 'number')
-    );
-    stream.session.destroy();
-  })
-);
+      type: TypeError,
+      message: 'The "code" argument must be of type number'
+    }
+  );
+  stream.respond();
+  stream.end('ok');
+}));
 
-server.listen(
-  0,
-  common.mustCall(() => {
-    const client = http2.connect(`http://localhost:${server.address().port}`);
-    const req = client.request();
-    req.resume();
-    req.on('end', common.mustCall(() => server.close()));
-    req.end();
-  })
-);
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+  req.resume();
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+}));
diff --git a/test/parallel/test-http2-max-concurrent-streams.js b/test/parallel/test-http2-max-concurrent-streams.js
index a65ac90c535b03..ffc04e98f134b2 100644
--- a/test/parallel/test-http2-max-concurrent-streams.js
+++ b/test/parallel/test-http2-max-concurrent-streams.js
@@ -5,64 +5,52 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
-
-const {
-  HTTP2_HEADER_METHOD,
-  HTTP2_HEADER_STATUS,
-  HTTP2_HEADER_PATH,
-  HTTP2_METHOD_POST
-} = h2.constants;
+const Countdown = require('../common/countdown');
 
 // Only allow one stream to be open at a time
 const server = h2.createServer({ settings: { maxConcurrentStreams: 1 } });
 
 // The stream handler must be called only once
 server.on('stream', common.mustCall((stream) => {
-  stream.respond({ [HTTP2_HEADER_STATUS]: 200 });
+  stream.respond();
   stream.end('hello world');
 }));
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
 
+server.listen(0, common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
 
-  let reqs = 2;
-  function onEnd() {
-    if (--reqs === 0) {
-      server.close();
-      client.destroy();
-    }
-  }
+  const countdown = new Countdown(2, () => {
+    server.close();
+    client.close();
+  });
 
   client.on('remoteSettings', common.mustCall((settings) => {
     assert.strictEqual(settings.maxConcurrentStreams, 1);
   }));
 
   // This one should go through with no problems
-  const req1 = client.request({
-    [HTTP2_HEADER_PATH]: '/',
-    [HTTP2_HEADER_METHOD]: HTTP2_METHOD_POST
-  });
-  req1.on('aborted', common.mustNotCall());
-  req1.on('response', common.mustCall());
-  req1.resume();
-  req1.on('end', onEnd);
-  req1.end();
-
-  // This one should be aborted
-  const req2 = client.request({
-    [HTTP2_HEADER_PATH]: '/',
-    [HTTP2_HEADER_METHOD]: HTTP2_METHOD_POST
-  });
-  req2.on('aborted', common.mustCall());
-  req2.on('response', common.mustNotCall());
-  req2.resume();
-  req2.on('end', onEnd);
-  req2.on('error', common.mustCall(common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code 7'
-  })));
+  {
+    const req = client.request({ ':method': 'POST' });
+    req.on('aborted', common.mustNotCall());
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => countdown.dec()));
+    req.end();
+  }
 
+  {
+    // This one should be aborted
+    const req = client.request({ ':method': 'POST' });
+    req.on('aborted', common.mustCall());
+    req.on('response', common.mustNotCall());
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => countdown.dec()));
+    req.on('error', common.expectsError({
+      code: 'ERR_HTTP2_STREAM_ERROR',
+      type: Error,
+      message: 'Stream closed with error code 7'
+    }));
+  }
 }));
diff --git a/test/parallel/test-http2-methods.js b/test/parallel/test-http2-methods.js
index 36f64f13abcf86..a291bdf00800d5 100644
--- a/test/parallel/test-http2-methods.js
+++ b/test/parallel/test-http2-methods.js
@@ -41,7 +41,7 @@ server.on('listening', common.mustCall(() => {
     req.on('end', common.mustCall(() => {
       if (--expected === 0) {
         server.close();
-        client.destroy();
+        client.close();
       }
     }));
     req.end();
diff --git a/test/parallel/test-http2-misbehaving-flow-control-paused.js b/test/parallel/test-http2-misbehaving-flow-control-paused.js
index ee799b1d5a27d3..0b7299d5ac80a8 100644
--- a/test/parallel/test-http2-misbehaving-flow-control-paused.js
+++ b/test/parallel/test-http2-misbehaving-flow-control-paused.js
@@ -56,32 +56,24 @@ let client;
 
 const server = h2.createServer({ settings: { initialWindowSize: 36 } });
 server.on('stream', (stream) => {
-
-  // Not reading causes the flow control window to get backed up.
   stream.pause();
-
-  stream.on('error', common.mustCall((err) => {
-    common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code 3'
-    })(err);
+  stream.on('error', common.expectsError({
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code 3'
+  }));
+  stream.on('close', common.mustCall(() => {
     server.close();
     client.destroy();
   }));
-
   stream.on('end', common.mustNotCall());
-
   stream.respond();
   stream.end('ok');
 });
 
 server.listen(0, () => {
   client = net.connect(server.address().port, () => {
-    client.on('error', console.log);
-
     client.write(preamble);
-
     client.write(data);
     client.write(data);
     client.write(data);
diff --git a/test/parallel/test-http2-misbehaving-flow-control.js b/test/parallel/test-http2-misbehaving-flow-control.js
index 010e07741316b6..8a0b411b8de65c 100644
--- a/test/parallel/test-http2-misbehaving-flow-control.js
+++ b/test/parallel/test-http2-misbehaving-flow-control.js
@@ -29,6 +29,21 @@ const preamble = Buffer.from([
 ]);
 
 const data = Buffer.from([
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
+  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
+  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
+  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
+  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
+  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
   0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
   0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
   0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a
@@ -51,30 +66,23 @@ const data = Buffer.from([
 let client;
 const server = h2.createServer({ settings: { initialWindowSize: 18 } });
 server.on('stream', (stream) => {
-
-  stream.resume();
-
-  stream.on('error', common.mustCall((err) => {
-    common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code 3'
-    })(err);
+  stream.on('error', common.expectsError({
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code 3'
+  }));
+  stream.on('close', common.mustCall(() => {
     server.close();
     client.destroy();
   }));
-
+  stream.resume();
   stream.respond();
   stream.end('ok');
 });
 
 server.listen(0, () => {
   client = net.connect(server.address().port, () => {
-    client.on('error', console.log);
-
     client.write(preamble);
-
-    client.write(data);
     client.write(data);
     client.write(data);
   });
diff --git a/test/parallel/test-http2-misused-pseudoheaders.js b/test/parallel/test-http2-misused-pseudoheaders.js
index 1f501598c1c421..b47462b14fd0e1 100644
--- a/test/parallel/test-http2-misused-pseudoheaders.js
+++ b/test/parallel/test-http2-misused-pseudoheaders.js
@@ -7,11 +7,7 @@ const h2 = require('http2');
 
 const server = h2.createServer();
 
-// we use the lower-level API here
-server.on('stream', common.mustCall(onStream));
-
-function onStream(stream, headers, flags) {
-
+server.on('stream', common.mustCall((stream) => {
   [
     ':path',
     ':authority',
@@ -24,10 +20,7 @@ function onStream(stream, headers, flags) {
                         });
   });
 
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  }, {
+  stream.respond({}, {
     getTrailers: common.mustCall((trailers) => {
       trailers[':status'] = 'bar';
     })
@@ -38,22 +31,24 @@ function onStream(stream, headers, flags) {
   }));
 
   stream.end('hello world');
-}
-
-server.listen(0);
+}));
 
-server.on('listening', common.mustCall(() => {
 
+server.listen(0, common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
 
-  const req = client.request({ ':path': '/' });
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code 2'
+  }));
 
   req.on('response', common.mustCall());
   req.resume();
-  req.on('end', common.mustCall(() => {
+  req.on('end', common.mustCall());
+  req.on('close', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
-  req.end();
-
 }));
diff --git a/test/parallel/test-http2-multi-content-length.js b/test/parallel/test-http2-multi-content-length.js
index d0f0094d2408aa..4d18356f127da0 100644
--- a/test/parallel/test-http2-multi-content-length.js
+++ b/test/parallel/test-http2-multi-content-length.js
@@ -4,6 +4,7 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 const http2 = require('http2');
+const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
 
@@ -15,29 +16,25 @@ server.on('stream', common.mustCall((stream) => {
 server.listen(0, common.mustCall(() => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  let remaining = 3;
-  function maybeClose() {
-    if (--remaining === 0) {
-      server.close();
-      client.destroy();
-    }
-  }
+  const countdown = new Countdown(2, () => {
+    server.close();
+    client.close();
+  });
 
-  {
-    // Request 1 will fail because there are two content-length header values
-    const req = client.request({
-      ':method': 'POST',
-      'content-length': 1,
-      'Content-Length': 2
-    });
-    req.on('error', common.expectsError({
+  // Request 1 will fail because there are two content-length header values
+  common.expectsError(
+    () => {
+      client.request({
+        ':method': 'POST',
+        'content-length': 1,
+        'Content-Length': 2
+      });
+    }, {
       code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
       type: Error,
       message: 'Header field "content-length" must have only a single value'
-    }));
-    req.on('error', common.mustCall(maybeClose));
-    req.end('a');
-  }
+    }
+  );
 
   {
     // Request 2 will succeed
@@ -46,7 +43,8 @@ server.listen(0, common.mustCall(() => {
       'content-length': 1
     });
     req.resume();
-    req.on('end', common.mustCall(maybeClose));
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => countdown.dec()));
     req.end('a');
   }
 
@@ -55,7 +53,8 @@ server.listen(0, common.mustCall(() => {
     // header to be set for non-payload bearing requests...
     const req = client.request({ 'content-length': 1 });
     req.resume();
-    req.on('end', common.mustCall(maybeClose));
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => countdown.dec()));
     req.on('error', common.expectsError({
       code: 'ERR_HTTP2_STREAM_ERROR',
       type: Error,
diff --git a/test/parallel/test-http2-multiheaders-raw.js b/test/parallel/test-http2-multiheaders-raw.js
index c06bf23bff3071..50486450d5aeb7 100644
--- a/test/parallel/test-http2-multiheaders-raw.js
+++ b/test/parallel/test-http2-multiheaders-raw.js
@@ -44,6 +44,6 @@ server.listen(0, common.mustCall(() => {
   const req = client.request(src);
   req.on('close', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
 }));
diff --git a/test/parallel/test-http2-multiheaders.js b/test/parallel/test-http2-multiheaders.js
index 5e477104091cb1..9bf8f76d22e60e 100644
--- a/test/parallel/test-http2-multiheaders.js
+++ b/test/parallel/test-http2-multiheaders.js
@@ -56,6 +56,6 @@ server.listen(0, common.mustCall(() => {
   req.on('response', common.mustCall(checkHeaders));
   req.on('close', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
 }));
diff --git a/test/parallel/test-http2-multiplex.js b/test/parallel/test-http2-multiplex.js
index c818a28572eca7..1778bced5f92f4 100644
--- a/test/parallel/test-http2-multiplex.js
+++ b/test/parallel/test-http2-multiplex.js
@@ -8,6 +8,7 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
+const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
 
@@ -20,15 +21,12 @@ server.on('stream', common.mustCall((stream) => {
 
 server.listen(0, common.mustCall(() => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
+  client.setMaxListeners(100);
 
-  let remaining = count;
-
-  function maybeClose() {
-    if (--remaining === 0) {
-      server.close();
-      client.destroy();
-    }
-  }
+  const countdown = new Countdown(count, () => {
+    server.close();
+    client.close();
+  });
 
   function doRequest() {
     const req = client.request({ ':method': 'POST ' });
@@ -38,8 +36,8 @@ server.listen(0, common.mustCall(() => {
     req.on('data', (chunk) => data += chunk);
     req.on('end', common.mustCall(() => {
       assert.strictEqual(data, 'abcdefghij');
-      maybeClose();
     }));
+    req.on('close', common.mustCall(() => countdown.dec()));
 
     let n = 0;
     function writeChunk() {
diff --git a/test/parallel/test-http2-no-more-streams.js b/test/parallel/test-http2-no-more-streams.js
index 6f4169756c0b4a..dd06a709f23023 100644
--- a/test/parallel/test-http2-no-more-streams.js
+++ b/test/parallel/test-http2-no-more-streams.js
@@ -25,7 +25,7 @@ server.listen(0, common.mustCall(() => {
 
     const countdown = new Countdown(2, common.mustCall(() => {
       server.close();
-      client.destroy();
+      client.close();
     }));
 
     {
diff --git a/test/parallel/test-http2-options-max-headers-block-length.js b/test/parallel/test-http2-options-max-headers-block-length.js
index 402803dd33a73a..a728c28c6576d4 100644
--- a/test/parallel/test-http2-options-max-headers-block-length.js
+++ b/test/parallel/test-http2-options-max-headers-block-length.js
@@ -10,9 +10,7 @@ const server = h2.createServer();
 
 // we use the lower-level API here
 server.on('stream', common.mustNotCall());
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
+server.listen(0, common.mustCall(() => {
 
   // Setting the maxSendHeaderBlockLength, then attempting to send a
   // headers block that is too big should cause a 'frameError' to
@@ -24,13 +22,13 @@ server.on('listening', common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`,
                             options);
 
-  const req = client.request({ ':path': '/' });
-
+  const req = client.request();
   req.on('response', common.mustNotCall());
 
   req.resume();
-  req.on('end', common.mustCall(() => {
-    client.destroy();
+  req.on('close', common.mustCall(() => {
+    client.close();
+    server.close();
   }));
 
   req.on('frameError', common.mustCall((type, code) => {
@@ -42,33 +40,4 @@ server.on('listening', common.mustCall(() => {
     type: Error,
     message: 'Stream closed with error code 7'
   }));
-
-  req.end();
-
-  // if no frameError listener, should emit 'error' with
-  // code ERR_HTTP2_FRAME_ERROR
-  const req2 = client.request({ ':path': '/' });
-
-  req2.on('response', common.mustNotCall());
-
-  req2.resume();
-  req2.on('end', common.mustCall(() => {
-    server.close();
-    client.destroy();
-  }));
-
-  req2.once('error', common.mustCall((err) => {
-    common.expectsError({
-      code: 'ERR_HTTP2_FRAME_ERROR',
-      type: Error
-    })(err);
-    req2.on('error', common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code 7'
-    }));
-  }));
-
-  req2.end();
-
 }));
diff --git a/test/parallel/test-http2-options-max-reserved-streams.js b/test/parallel/test-http2-options-max-reserved-streams.js
index d54ca6a7886b3c..994a8817451686 100644
--- a/test/parallel/test-http2-options-max-reserved-streams.js
+++ b/test/parallel/test-http2-options-max-reserved-streams.js
@@ -5,20 +5,24 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
+const Countdown = require('../common/countdown');
 
 const server = h2.createServer();
+let client;
+
+const countdown = new Countdown(3, () => {
+  server.close();
+  client.close();
+});
 
 // we use the lower-level API here
 server.on('stream', common.mustCall((stream) => {
-  stream.respond({ ':status': 200 });
-
   // The first pushStream will complete as normal
   stream.pushStream({
-    ':scheme': 'http',
     ':path': '/foobar',
-    ':authority': `localhost:${server.address().port}`,
-  }, common.mustCall((pushedStream) => {
-    pushedStream.respond({ ':status': 200 });
+  }, common.mustCall((err, pushedStream) => {
+    assert.ifError(err);
+    pushedStream.respond();
     pushedStream.end();
     pushedStream.on('aborted', common.mustNotCall());
   }));
@@ -27,52 +31,41 @@ server.on('stream', common.mustCall((stream) => {
   // will reject it due to the maxReservedRemoteStreams option
   // being set to only 1
   stream.pushStream({
-    ':scheme': 'http',
     ':path': '/foobar',
-    ':authority': `localhost:${server.address().port}`,
-  }, common.mustCall((pushedStream) => {
-    pushedStream.respond({ ':status': 200 });
+  }, common.mustCall((err, pushedStream) => {
+    assert.ifError(err);
+    pushedStream.respond();
     pushedStream.on('aborted', common.mustCall());
     pushedStream.on('error', common.mustNotCall());
-    pushedStream.on('close',
-                    common.mustCall((code) => assert.strictEqual(code, 8)));
+    pushedStream.on('close', common.mustCall((code) => {
+      assert.strictEqual(code, 8);
+      countdown.dec();
+    }));
   }));
 
+  stream.respond();
   stream.end('hello world');
 }));
 server.listen(0);
 
 server.on('listening', common.mustCall(() => {
+  client = h2.connect(`http://localhost:${server.address().port}`,
+                      { maxReservedRemoteStreams: 1 });
 
-  const options = {
-    maxReservedRemoteStreams: 1
-  };
-
-  const client = h2.connect(`http://localhost:${server.address().port}`,
-                            options);
-
-  let remaining = 2;
-  function maybeClose() {
-    if (--remaining === 0) {
-      server.close();
-      client.destroy();
-    }
-  }
-
-  const req = client.request({ ':path': '/' });
+  const req = client.request();
 
   // Because maxReservedRemoteStream is 1, the stream event
   // must only be emitted once, even tho the server sends
   // two push streams.
   client.on('stream', common.mustCall((stream) => {
     stream.resume();
+    stream.on('push', common.mustCall());
     stream.on('end', common.mustCall());
-    stream.on('close', common.mustCall(maybeClose));
+    stream.on('close', common.mustCall(() => countdown.dec()));
   }));
 
   req.on('response', common.mustCall());
-
   req.resume();
   req.on('end', common.mustCall());
-  req.on('close', common.mustCall(maybeClose));
+  req.on('close', common.mustCall(() => countdown.dec()));
 }));
diff --git a/test/parallel/test-http2-padding-callback.js b/test/parallel/test-http2-padding-callback.js
index af547ad498da1b..6d6a6b27221b07 100644
--- a/test/parallel/test-http2-padding-callback.js
+++ b/test/parallel/test-http2-padding-callback.js
@@ -45,7 +45,7 @@ server.on('listening', common.mustCall(() => {
   req.resume();
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end();
 }));
diff --git a/test/parallel/test-http2-ping.js b/test/parallel/test-http2-ping.js
index 4892d67b4d738d..32fb8926e4716c 100644
--- a/test/parallel/test-http2-ping.js
+++ b/test/parallel/test-http2-ping.js
@@ -80,7 +80,7 @@ server.listen(0, common.mustCall(() => {
     const req = client.request();
     req.resume();
     req.on('end', common.mustCall(() => {
-      client.destroy();
+      client.close();
       server.close();
     }));
   }));
diff --git a/test/parallel/test-http2-pipe.js b/test/parallel/test-http2-pipe.js
index 8b446f4f88118b..891fc6e292b909 100644
--- a/test/parallel/test-http2-pipe.js
+++ b/test/parallel/test-http2-pipe.js
@@ -8,7 +8,6 @@ const assert = require('assert');
 const http2 = require('http2');
 const fs = require('fs');
 const path = require('path');
-const Countdown = require('../common/countdown');
 
 // piping should work as expected with createWriteStream
 
@@ -20,28 +19,28 @@ const server = http2.createServer();
 
 server.on('stream', common.mustCall((stream) => {
   const dest = stream.pipe(fs.createWriteStream(fn));
-  dest.on('finish', common.mustCall(() => {
-    assert.strictEqual(fs.readFileSync(loc).length, fs.readFileSync(fn).length);
-    fs.unlinkSync(fn);
-    stream.respond();
-    stream.end();
-  }));
+
+  dest.on('finish', () => {
+    assert.strictEqual(fs.readFileSync(loc).length,
+                       fs.readFileSync(fn).length);
+  });
+  stream.respond();
+  stream.end();
 }));
 
 server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
-
-  const countdown = new Countdown(2, common.mustCall(() => {
-    server.close();
-    client.destroy();
-  }));
+  const client = http2.connect(`http://localhost:${server.address().port}`);
 
   const req = client.request({ ':method': 'POST' });
   req.on('response', common.mustCall());
   req.resume();
-  req.on('end', common.mustCall(() => countdown.dec()));
+
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+
   const str = fs.createReadStream(loc);
-  str.on('end', common.mustCall(() => countdown.dec()));
+  str.on('end', common.mustCall());
   str.pipe(req);
 }));
diff --git a/test/parallel/test-http2-priority-event.js b/test/parallel/test-http2-priority-event.js
index b0704902d31101..fe04ffb342d70d 100644
--- a/test/parallel/test-http2-priority-event.js
+++ b/test/parallel/test-http2-priority-event.js
@@ -54,7 +54,7 @@ server.on('listening', common.mustCall(() => {
   req.resume();
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end();
 
diff --git a/test/parallel/test-http2-respond-errors.js b/test/parallel/test-http2-respond-errors.js
index dcc05357faedad..2a48456c9394a4 100644
--- a/test/parallel/test-http2-respond-errors.js
+++ b/test/parallel/test-http2-respond-errors.js
@@ -74,13 +74,18 @@ function runTest(test) {
 
   const client = http2.connect(url);
   const req = client.request(headers);
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code 2'
+  }));
 
   currentError = test;
   req.resume();
   req.end();
 
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
 
     if (!tests.length) {
       server.close();
diff --git a/test/parallel/test-http2-respond-file-204.js b/test/parallel/test-http2-respond-file-204.js
index 4be2d42c779a5e..b0ba634e67df69 100644
--- a/test/parallel/test-http2-respond-file-204.js
+++ b/test/parallel/test-http2-respond-file-204.js
@@ -34,7 +34,7 @@ server.listen(0, () => {
   req.on('response', common.mustCall());
   req.on('data', common.mustNotCall());
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-304.js b/test/parallel/test-http2-respond-file-304.js
index e6e0842c7f9448..536c48c624e73c 100644
--- a/test/parallel/test-http2-respond-file-304.js
+++ b/test/parallel/test-http2-respond-file-304.js
@@ -38,7 +38,7 @@ server.listen(0, () => {
 
   req.on('data', common.mustNotCall());
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-404.js b/test/parallel/test-http2-respond-file-404.js
index ba62f384485bc0..60bc21f185dd5c 100644
--- a/test/parallel/test-http2-respond-file-404.js
+++ b/test/parallel/test-http2-respond-file-404.js
@@ -40,7 +40,7 @@ server.listen(0, () => {
   }));
   req.on('data', common.mustNotCall());
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-compat.js b/test/parallel/test-http2-respond-file-compat.js
index 0f6e3199d68ab2..0205f2d0d85aaf 100644
--- a/test/parallel/test-http2-respond-file-compat.js
+++ b/test/parallel/test-http2-respond-file-compat.js
@@ -16,7 +16,7 @@ server.listen(0, () => {
   const req = client.request();
   req.on('response', common.mustCall());
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-error-dir.js b/test/parallel/test-http2-respond-file-error-dir.js
index 18a9540451f865..6818616227df89 100644
--- a/test/parallel/test-http2-respond-file-error-dir.js
+++ b/test/parallel/test-http2-respond-file-error-dir.js
@@ -6,14 +6,10 @@ if (!common.hasCrypto)
 const http2 = require('http2');
 const assert = require('assert');
 
-const {
-  HTTP2_HEADER_CONTENT_TYPE
-} = http2.constants;
-
 const server = http2.createServer();
 server.on('stream', (stream) => {
   stream.respondWithFile(process.cwd(), {
-    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+    'content-type': 'text/plain'
   }, {
     onError(err) {
       common.expectsError({
@@ -38,7 +34,7 @@ server.listen(0, () => {
   }));
   req.on('data', common.mustNotCall());
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-errors.js b/test/parallel/test-http2-respond-file-errors.js
index c2c749873c82ac..83d3900bc5c288 100644
--- a/test/parallel/test-http2-respond-file-errors.js
+++ b/test/parallel/test-http2-respond-file-errors.js
@@ -6,11 +6,6 @@ if (!common.hasCrypto)
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 
-const {
-  HTTP2_HEADER_CONTENT_TYPE,
-  HTTP2_HEADER_METHOD
-} = http2.constants;
-
 const optionsWithTypeError = {
   offset: 'number',
   length: 'number',
@@ -33,6 +28,7 @@ const fname = fixtures.path('elipses.txt');
 const server = http2.createServer();
 
 server.on('stream', common.mustCall((stream) => {
+
   // Check for all possible TypeError triggers on options
   Object.keys(optionsWithTypeError).forEach((option) => {
     Object.keys(types).forEach((type) => {
@@ -42,7 +38,7 @@ server.on('stream', common.mustCall((stream) => {
 
       common.expectsError(
         () => stream.respondWithFile(fname, {
-          [http2.constants.HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+          'content-type': 'text/plain'
         }, {
           [option]: types[type]
         }),
@@ -59,7 +55,7 @@ server.on('stream', common.mustCall((stream) => {
   // Should throw if :status 204, 205 or 304
   [204, 205, 304].forEach((status) => common.expectsError(
     () => stream.respondWithFile(fname, {
-      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain',
+      'content-type': 'text/plain',
       ':status': status,
     }),
     {
@@ -68,31 +64,11 @@ server.on('stream', common.mustCall((stream) => {
     }
   ));
 
-  // should emit an error on the stream if headers aren't valid
-  stream.respondWithFile(fname, {
-    [HTTP2_HEADER_METHOD]: 'POST'
-  }, {
-    statCheck: common.mustCall(() => {
-      // give time to the current test case to finish
-      process.nextTick(continueTest, stream);
-      return true;
-    })
-  });
-  stream.once('error', common.expectsError({
-    code: 'ERR_HTTP2_INVALID_PSEUDOHEADER',
-    type: Error,
-    message: '":method" is an invalid pseudoheader or is used incorrectly'
-  }));
-}));
-
-function continueTest(stream) {
   // Should throw if headers already sent
-  stream.respond({
-    ':status': 200,
-  });
+  stream.respond({ ':status': 200 });
   common.expectsError(
     () => stream.respondWithFile(fname, {
-      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+      'content-type': 'text/plain'
     }),
     {
       code: 'ERR_HTTP2_HEADERS_SENT',
@@ -104,21 +80,21 @@ function continueTest(stream) {
   stream.destroy();
   common.expectsError(
     () => stream.respondWithFile(fname, {
-      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+      'content-type': 'text/plain'
     }),
     {
       code: 'ERR_HTTP2_INVALID_STREAM',
       message: 'The stream has been destroyed'
     }
   );
-}
+}));
 
 server.listen(0, common.mustCall(() => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
   req.on('close', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-fd-errors.js b/test/parallel/test-http2-respond-file-fd-errors.js
index 9458b2f49af087..44876b60e1c4cb 100644
--- a/test/parallel/test-http2-respond-file-fd-errors.js
+++ b/test/parallel/test-http2-respond-file-fd-errors.js
@@ -7,11 +7,6 @@ const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 const fs = require('fs');
 
-const {
-  HTTP2_HEADER_CONTENT_TYPE,
-  HTTP2_HEADER_METHOD
-} = http2.constants;
-
 const optionsWithTypeError = {
   offset: 'number',
   length: 'number',
@@ -43,7 +38,7 @@ server.on('stream', common.mustCall((stream) => {
 
     common.expectsError(
       () => stream.respondWithFD(types[type], {
-        [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+        'content-type': 'text/plain'
       }),
       {
         type: TypeError,
@@ -62,7 +57,7 @@ server.on('stream', common.mustCall((stream) => {
 
       common.expectsError(
         () => stream.respondWithFD(fd, {
-          [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+          'content-type': 'text/plain'
         }, {
           [option]: types[type]
         }),
@@ -79,7 +74,7 @@ server.on('stream', common.mustCall((stream) => {
   // Should throw if :status 204, 205 or 304
   [204, 205, 304].forEach((status) => common.expectsError(
     () => stream.respondWithFD(fd, {
-      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain',
+      'content-type': 'text/plain',
       ':status': status,
     }),
     {
@@ -89,35 +84,11 @@ server.on('stream', common.mustCall((stream) => {
     }
   ));
 
-  // should emit an error on the stream if headers aren't valid
-  stream.respondWithFD(fd, {
-    [HTTP2_HEADER_METHOD]: 'POST'
-  }, {
-    statCheck() {
-      return true;
-    }
-  });
-  stream.once('error', common.expectsError({
-    code: 'ERR_HTTP2_INVALID_PSEUDOHEADER',
-    type: Error,
-    message: '":method" is an invalid pseudoheader or is used incorrectly'
-  }));
-  stream.respondWithFD(fd, {
-    [HTTP2_HEADER_METHOD]: 'POST'
-  });
-  stream.once('error', common.expectsError({
-    code: 'ERR_HTTP2_INVALID_PSEUDOHEADER',
-    type: Error,
-    message: '":method" is an invalid pseudoheader or is used incorrectly'
-  }));
-
   // Should throw if headers already sent
-  stream.respond({
-    ':status': 200,
-  });
+  stream.respond();
   common.expectsError(
     () => stream.respondWithFD(fd, {
-      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+      'content-type': 'text/plain'
     }),
     {
       code: 'ERR_HTTP2_HEADERS_SENT',
@@ -130,7 +101,7 @@ server.on('stream', common.mustCall((stream) => {
   stream.destroy();
   common.expectsError(
     () => stream.respondWithFD(fd, {
-      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+      'content-type': 'text/plain'
     }),
     {
       code: 'ERR_HTTP2_INVALID_STREAM',
@@ -145,7 +116,7 @@ server.listen(0, common.mustCall(() => {
   const req = client.request();
 
   req.on('close', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-fd-invalid.js b/test/parallel/test-http2-respond-file-fd-invalid.js
index f3bcab8904bee4..77a4d3df00d0d6 100644
--- a/test/parallel/test-http2-respond-file-fd-invalid.js
+++ b/test/parallel/test-http2-respond-file-fd-invalid.js
@@ -31,7 +31,7 @@ server.listen(0, () => {
   req.on('data', common.mustNotCall());
   req.on('end', common.mustCall(() => {
     assert.strictEqual(req.rstCode, NGHTTP2_INTERNAL_ERROR);
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-fd-range.js b/test/parallel/test-http2-respond-file-fd-range.js
index 8479dca518558e..2dd73e0001544c 100644
--- a/test/parallel/test-http2-respond-file-fd-range.js
+++ b/test/parallel/test-http2-respond-file-fd-range.js
@@ -9,6 +9,7 @@ const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 const assert = require('assert');
 const fs = require('fs');
+const Countdown = require('../common/countdown');
 
 const {
   HTTP2_HEADER_CONTENT_TYPE,
@@ -39,7 +40,7 @@ server.on('stream', (stream, headers) => {
     statCheck: common.mustCall((stat, headers, options) => {
       assert.strictEqual(options.length, length);
       assert.strictEqual(options.offset, offset);
-      headers[HTTP2_HEADER_CONTENT_LENGTH] =
+      headers['content-length'] =
         Math.min(options.length, stat.size - offset);
     }),
     offset: offset,
@@ -47,23 +48,21 @@ server.on('stream', (stream, headers) => {
   });
 });
 server.on('close', common.mustCall(() => fs.closeSync(fd)));
+
 server.listen(0, () => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  let remaining = 2;
-  function maybeClose() {
-    if (--remaining === 0) {
-      client.destroy();
-      server.close();
-    }
-  }
+  const countdown = new Countdown(2, () => {
+    client.close();
+    server.close();
+  });
 
   {
     const req = client.request({ range: 'bytes=8-11' });
 
     req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
-      assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], 3);
+      assert.strictEqual(headers['content-type'], 'text/plain');
+      assert.strictEqual(+headers['content-length'], 3);
     }));
     req.setEncoding('utf8');
     let check = '';
@@ -71,7 +70,7 @@ server.listen(0, () => {
     req.on('end', common.mustCall(() => {
       assert.strictEqual(check, data.toString('utf8', 8, 11));
     }));
-    req.on('close', common.mustCall(maybeClose));
+    req.on('close', common.mustCall(() => countdown.dec()));
     req.end();
   }
 
@@ -88,7 +87,7 @@ server.listen(0, () => {
     req.on('end', common.mustCall(() => {
       assert.strictEqual(check, data.toString('utf8', 8, 28));
     }));
-    req.on('close', common.mustCall(maybeClose));
+    req.on('close', common.mustCall(() => countdown.dec()));
     req.end();
   }
 
diff --git a/test/parallel/test-http2-respond-file-fd.js b/test/parallel/test-http2-respond-file-fd.js
index 303d25be3f2b66..7d4395bbc360aa 100644
--- a/test/parallel/test-http2-respond-file-fd.js
+++ b/test/parallel/test-http2-respond-file-fd.js
@@ -40,7 +40,7 @@ server.listen(0, () => {
   req.on('data', (chunk) => check += chunk);
   req.on('end', common.mustCall(() => {
     assert.strictEqual(check, data.toString('utf8'));
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file-push.js b/test/parallel/test-http2-respond-file-push.js
index 4f7b179faf81a8..a5229beb07d1a7 100644
--- a/test/parallel/test-http2-respond-file-push.js
+++ b/test/parallel/test-http2-respond-file-push.js
@@ -29,7 +29,8 @@ server.on('stream', (stream) => {
   stream.pushStream({
     ':path': '/file.txt',
     ':method': 'GET'
-  }, (stream) => {
+  }, (err, stream) => {
+    assert.ifError(err);
     stream.respondWithFD(fd, {
       [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain',
       [HTTP2_HEADER_CONTENT_LENGTH]: stat.size,
@@ -50,7 +51,7 @@ server.listen(0, () => {
   function maybeClose() {
     if (--expected === 0) {
       server.close();
-      client.destroy();
+      client.close();
     }
   }
 
diff --git a/test/parallel/test-http2-respond-file-range.js b/test/parallel/test-http2-respond-file-range.js
index a5995cbba77c1c..4e6a6074514f14 100644
--- a/test/parallel/test-http2-respond-file-range.js
+++ b/test/parallel/test-http2-respond-file-range.js
@@ -46,7 +46,7 @@ server.listen(0, () => {
   req.on('data', (chunk) => check += chunk);
   req.on('end', common.mustCall(() => {
     assert.strictEqual(check, data.toString('utf8', 8, 11));
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-file.js b/test/parallel/test-http2-respond-file.js
index c2f513b7cae2b7..9ad8e7a69648dc 100644
--- a/test/parallel/test-http2-respond-file.js
+++ b/test/parallel/test-http2-respond-file.js
@@ -45,7 +45,7 @@ server.listen(0, () => {
   req.on('data', (chunk) => check += chunk);
   req.on('end', common.mustCall(() => {
     assert.strictEqual(check, data.toString('utf8'));
-    client.destroy();
+    client.close();
     server.close();
   }));
   req.end();
diff --git a/test/parallel/test-http2-respond-no-data.js b/test/parallel/test-http2-respond-no-data.js
index d891fe4e8ddd2b..9572bdffe54927 100644
--- a/test/parallel/test-http2-respond-no-data.js
+++ b/test/parallel/test-http2-respond-no-data.js
@@ -27,7 +27,7 @@ function makeRequest() {
   req.resume();
 
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
 
     if (!status.length) {
       server.close();
diff --git a/test/parallel/test-http2-respond-with-fd-errors.js b/test/parallel/test-http2-respond-with-fd-errors.js
index c8ecfcf5f3490e..0b215134663bda 100644
--- a/test/parallel/test-http2-respond-with-fd-errors.js
+++ b/test/parallel/test-http2-respond-with-fd-errors.js
@@ -82,12 +82,18 @@ function runTest(test) {
   const client = http2.connect(url);
   const req = client.request(headers);
 
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code 2'
+  }));
+
   currentError = test;
   req.resume();
   req.end();
 
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
 
     if (!tests.length) {
       server.close();
diff --git a/test/parallel/test-http2-response-splitting.js b/test/parallel/test-http2-response-splitting.js
index 1d9b616105f450..9613eca9636ae4 100644
--- a/test/parallel/test-http2-response-splitting.js
+++ b/test/parallel/test-http2-response-splitting.js
@@ -55,7 +55,7 @@ server.listen(0, common.mustCall(() => {
   function maybeClose() {
     if (remaining === 0) {
       server.close();
-      client.destroy();
+      client.close();
     }
   }
 
diff --git a/test/parallel/test-http2-rststream-errors.js b/test/parallel/test-http2-rststream-errors.js
deleted file mode 100644
index f53956ce998e93..00000000000000
--- a/test/parallel/test-http2-rststream-errors.js
+++ /dev/null
@@ -1,94 +0,0 @@
-'use strict';
-
-const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
-const http2 = require('http2');
-const {
-  constants,
-  Http2Stream,
-  nghttp2ErrorString
-} = process.binding('http2');
-
-// tests error handling within rstStream
-// - every other NGHTTP2 error from binding (should emit stream error)
-
-const specificTestKeys = [];
-const specificTests = [];
-
-const genericTests = Object.getOwnPropertyNames(constants)
-  .filter((key) => (
-    key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
-  ))
-  .map((key) => ({
-    ngError: constants[key],
-    error: {
-      code: 'ERR_HTTP2_ERROR',
-      type: Error,
-      message: nghttp2ErrorString(constants[key])
-    },
-    type: 'stream'
-  }));
-
-
-const tests = specificTests.concat(genericTests);
-
-let currentError;
-
-// mock submitRstStream because we only care about testing error handling
-Http2Stream.prototype.rstStream = () => currentError.ngError;
-
-const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const errorMustCall = common.expectsError(currentError.error);
-  const errorMustNotCall = common.mustNotCall(
-    `${currentError.error.code} should emit on ${currentError.type}`
-  );
-
-  if (currentError.type === 'stream') {
-    stream.session.on('error', errorMustNotCall);
-    stream.on('error', errorMustCall);
-    stream.on('error', common.mustCall(() => {
-      stream.session.destroy();
-    }));
-  } else {
-    stream.session.once('error', errorMustCall);
-    stream.on('error', errorMustNotCall);
-  }
-
-  stream.rstStream();
-}, tests.length));
-
-server.listen(0, common.mustCall(() => runTest(tests.shift())));
-
-function runTest(test) {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const headers = {
-    ':path': '/',
-    ':method': 'POST',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  };
-
-  const client = http2.connect(url);
-  const req = client.request(headers);
-
-  currentError = test;
-  req.resume();
-  req.end();
-
-  if (currentError.type === 'stream') {
-    req.on('error', common.mustCall());
-  }
-
-  req.on('end', common.mustCall(() => {
-    client.destroy();
-
-    if (!tests.length) {
-      server.close();
-    } else {
-      runTest(tests.shift());
-    }
-  }));
-}
diff --git a/test/parallel/test-http2-serve-file.js b/test/parallel/test-http2-serve-file.js
index af82360e464b31..7b73fe639e0cc5 100644
--- a/test/parallel/test-http2-serve-file.js
+++ b/test/parallel/test-http2-serve-file.js
@@ -48,7 +48,7 @@ server.listen(0, () => {
   let remaining = 2;
   function maybeClose() {
     if (--remaining === 0) {
-      client.destroy();
+      client.close();
       server.close();
     }
   }
diff --git a/test/parallel/test-http2-server-errors.js b/test/parallel/test-http2-server-errors.js
index 7d7db6a24538fd..a3586bd64d46e7 100644
--- a/test/parallel/test-http2-server-errors.js
+++ b/test/parallel/test-http2-server-errors.js
@@ -6,7 +6,6 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
-const { Http2Stream } = require('internal/http2/core');
 
 // Errors should not be reported both in Http2ServerRequest
 // and Http2ServerResponse
@@ -29,11 +28,6 @@ const { Http2Stream } = require('internal/http2/core');
     server.close();
   }));
 
-  server.on('streamError', common.mustCall(function(err, stream) {
-    assert.strictEqual(err, expected);
-    assert.strictEqual(stream instanceof Http2Stream, true);
-  }));
-
   server.listen(0, common.mustCall(function() {
     const port = server.address().port;
 
@@ -70,11 +64,6 @@ const { Http2Stream } = require('internal/http2/core');
     server.close();
   }));
 
-  server.on('streamError', common.mustCall(function(err, stream) {
-    assert.strictEqual(err, expected);
-    assert.strictEqual(stream instanceof Http2Stream, true);
-  }));
-
   server.listen(0, common.mustCall(function() {
     const port = server.address().port;
 
diff --git a/test/parallel/test-http2-server-http1-client.js b/test/parallel/test-http2-server-http1-client.js
index ef3a79c0fd143a..34a8f48b5e130d 100644
--- a/test/parallel/test-http2-server-http1-client.js
+++ b/test/parallel/test-http2-server-http1-client.js
@@ -12,11 +12,14 @@ const server = http2.createServer();
 server.on('stream', common.mustNotCall());
 server.on('session', common.mustCall((session) => {
   session.on('close', common.mustCall());
+  session.on('error', common.expectsError({
+    code: 'ERR_HTTP2_ERROR',
+    type: Error,
+    message: 'Received bad client magic byte string'
+  }));
 }));
 
 server.listen(0, common.mustCall(() => {
   const req = http.get(`http://localhost:${server.address().port}`);
-  req.on('error', (error) => {
-    server.close();
-  });
+  req.on('error', (error) => server.close());
 }));
diff --git a/test/parallel/test-http2-server-push-disabled.js b/test/parallel/test-http2-server-push-disabled.js
index 33390f2ecae886..9a0b748d354276 100644
--- a/test/parallel/test-http2-server-push-disabled.js
+++ b/test/parallel/test-http2-server-push-disabled.js
@@ -48,7 +48,7 @@ server.listen(0, common.mustCall(() => {
   req.resume();
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end();
 }));
diff --git a/test/parallel/test-http2-server-push-stream-errors-args.js b/test/parallel/test-http2-server-push-stream-errors-args.js
index 73fa064b439199..f752f44310c0df 100644
--- a/test/parallel/test-http2-server-push-stream-errors-args.js
+++ b/test/parallel/test-http2-server-push-stream-errors-args.js
@@ -50,7 +50,7 @@ server.listen(0, common.mustCall(() => {
   req.on('end', common.mustCall(() => {
     assert.strictEqual(data, 'test');
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end();
 }));
diff --git a/test/parallel/test-http2-server-push-stream-errors.js b/test/parallel/test-http2-server-push-stream-errors.js
index 56e329dcff1cd2..7eaf4dc94d15e2 100644
--- a/test/parallel/test-http2-server-push-stream-errors.js
+++ b/test/parallel/test-http2-server-push-stream-errors.js
@@ -34,9 +34,8 @@ const specificTests = [
   {
     ngError: constants.NGHTTP2_ERR_STREAM_CLOSED,
     error: {
-      code: 'ERR_HTTP2_STREAM_CLOSED',
-      type: Error,
-      message: 'The stream is already closed'
+      code: 'ERR_HTTP2_INVALID_STREAM',
+      type: Error
     },
     type: 'stream'
   },
@@ -66,47 +65,25 @@ Http2Stream.prototype.pushPromise = () => currentError.ngError;
 
 const server = http2.createServer();
 server.on('stream', common.mustCall((stream, headers) => {
-  const errorMustCall = common.expectsError(currentError.error);
-  const errorMustNotCall = common.mustNotCall(
-    `${currentError.error.code} should emit on ${currentError.type}`
-  );
-
-  if (currentError.type === 'stream') {
-    stream.session.on('error', errorMustNotCall);
-    stream.on('error', errorMustCall);
-    stream.on('error', common.mustCall(() => {
-      stream.respond();
-      stream.end();
-    }));
-  } else {
-    stream.session.once('error', errorMustCall);
-    stream.on('error', errorMustNotCall);
-  }
-
-  stream.pushStream({}, () => {});
+  stream.pushStream({}, common.expectsError(currentError.error));
+  stream.respond();
+  stream.end();
 }, tests.length));
 
 server.listen(0, common.mustCall(() => runTest(tests.shift())));
 
 function runTest(test) {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const headers = {
-    ':path': '/',
-    ':method': 'POST',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  };
+  const url = `http://localhost:${server.address().port}`;
 
   const client = http2.connect(url);
-  const req = client.request(headers);
+  const req = client.request();
 
   currentError = test;
   req.resume();
   req.end();
 
-  req.on('end', common.mustCall(() => {
-    client.destroy();
+  req.on('close', common.mustCall(() => {
+    client.close();
 
     if (!tests.length) {
       server.close();
diff --git a/test/parallel/test-http2-server-push-stream-head.js b/test/parallel/test-http2-server-push-stream-head.js
index c2fc8db4a92eba..cd2276746f4bdd 100644
--- a/test/parallel/test-http2-server-push-stream-head.js
+++ b/test/parallel/test-http2-server-push-stream-head.js
@@ -5,6 +5,7 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
+const Countdown = require('../common/countdown');
 
 // Check that pushStream handles method HEAD correctly
 // - stream should end immediately (no body)
@@ -17,8 +18,10 @@ server.on('stream', common.mustCall((stream, headers) => {
       ':scheme': 'http',
       ':method': 'HEAD',
       ':authority': `localhost:${port}`,
-    }, common.mustCall((push, headers) => {
+    }, common.mustCall((err, push, headers) => {
       assert.strictEqual(push._writableState.ended, true);
+      push.respond();
+      assert(!push.write('test'));
       stream.end('test');
     }));
   }
@@ -30,15 +33,26 @@ server.on('stream', common.mustCall((stream, headers) => {
 
 server.listen(0, common.mustCall(() => {
   const port = server.address().port;
-  const headers = { ':path': '/' };
   const client = http2.connect(`http://localhost:${port}`);
-  const req = client.request(headers);
+
+  const countdown = new Countdown(2, () => {
+    server.close();
+    client.close();
+  });
+
+  const req = client.request();
   req.setEncoding('utf8');
 
   client.on('stream', common.mustCall((stream, headers) => {
+    assert.strictEqual(headers[':method'], 'HEAD');
     assert.strictEqual(headers[':scheme'], 'http');
     assert.strictEqual(headers[':path'], '/');
     assert.strictEqual(headers[':authority'], `localhost:${port}`);
+    stream.on('push', common.mustCall(() => {
+      stream.on('data', common.mustNotCall());
+      stream.on('end', common.mustCall());
+    }));
+    stream.on('close', common.mustCall(() => countdown.dec()));
   }));
 
   let data = '';
@@ -46,8 +60,7 @@ server.listen(0, common.mustCall(() => {
   req.on('data', common.mustCall((d) => data += d));
   req.on('end', common.mustCall(() => {
     assert.strictEqual(data, 'test');
-    server.close();
-    client.destroy();
   }));
+  req.on('close', common.mustCall(() => countdown.dec()));
   req.end();
 }));
diff --git a/test/parallel/test-http2-server-push-stream.js b/test/parallel/test-http2-server-push-stream.js
index 395743869198ca..6ac10cae77f951 100644
--- a/test/parallel/test-http2-server-push-stream.js
+++ b/test/parallel/test-http2-server-push-stream.js
@@ -14,7 +14,8 @@ server.on('stream', common.mustCall((stream, headers) => {
       ':scheme': 'http',
       ':path': '/foobar',
       ':authority': `localhost:${port}`,
-    }, common.mustCall((push, headers) => {
+    }, common.mustCall((err, push, headers) => {
+      assert.ifError(err);
       push.respond({
         'content-type': 'text/html',
         ':status': 200,
@@ -53,7 +54,7 @@ server.listen(0, common.mustCall(() => {
   req.on('end', common.mustCall(() => {
     assert.strictEqual(data, 'test');
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end();
 }));
diff --git a/test/parallel/test-http2-server-rst-before-respond.js b/test/parallel/test-http2-server-rst-before-respond.js
index 950beea4eb39ab..74181f4ffa0bbe 100644
--- a/test/parallel/test-http2-server-rst-before-respond.js
+++ b/test/parallel/test-http2-server-rst-before-respond.js
@@ -12,35 +12,26 @@ const server = h2.createServer();
 server.on('stream', common.mustCall(onStream));
 
 function onStream(stream, headers, flags) {
-  stream.rstStream();
+  stream.close();
 
   common.expectsError(() => {
     stream.additionalHeaders({
       ':status': 123,
       abc: 123
     });
-  }, {
-    code: 'ERR_HTTP2_INVALID_STREAM',
-    message: /^The stream has been destroyed$/
-  });
+  }, { code: 'ERR_HTTP2_INVALID_STREAM' });
 }
 
 server.listen(0);
 
 server.on('listening', common.mustCall(() => {
-
   const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const req = client.request({ ':path': '/' });
-
+  const req = client.request();
   req.on('headers', common.mustNotCall());
-
   req.on('close', common.mustCall((code) => {
     assert.strictEqual(h2.constants.NGHTTP2_NO_ERROR, code);
     server.close();
-    client.destroy();
+    client.close();
   }));
-
   req.on('response', common.mustNotCall());
-
 }));
diff --git a/test/parallel/test-http2-server-rst-stream.js b/test/parallel/test-http2-server-rst-stream.js
index 4b04f29c8ec7c0..c2d938c22f4483 100644
--- a/test/parallel/test-http2-server-rst-stream.js
+++ b/test/parallel/test-http2-server-rst-stream.js
@@ -16,39 +16,38 @@ const {
 } = http2.constants;
 
 const tests = [
-  ['rstStream', NGHTTP2_NO_ERROR, false],
-  ['rstWithNoError', NGHTTP2_NO_ERROR, false],
-  ['rstWithProtocolError', NGHTTP2_PROTOCOL_ERROR, true],
-  ['rstWithCancel', NGHTTP2_CANCEL, false],
-  ['rstWithRefuse', NGHTTP2_REFUSED_STREAM, true],
-  ['rstWithInternalError', NGHTTP2_INTERNAL_ERROR, true]
+  [NGHTTP2_NO_ERROR, false],
+  [NGHTTP2_NO_ERROR, false],
+  [NGHTTP2_PROTOCOL_ERROR, true],
+  [NGHTTP2_CANCEL, false],
+  [NGHTTP2_REFUSED_STREAM, true],
+  [NGHTTP2_INTERNAL_ERROR, true]
 ];
 
 const server = http2.createServer();
 server.on('stream', (stream, headers) => {
-  const method = headers['rstmethod'];
-  stream[method]();
+  stream.close(headers['rstcode'] | 0);
 });
 
 server.listen(0, common.mustCall(() => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
 
   const countdown = new Countdown(tests.length, common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
 
   tests.forEach((test) => {
     const req = client.request({
       ':method': 'POST',
-      rstmethod: test[0]
+      rstcode: test[0]
     });
     req.on('close', common.mustCall((code) => {
-      assert.strictEqual(code, test[1]);
+      assert.strictEqual(code, test[0]);
       countdown.dec();
     }));
     req.on('aborted', common.mustCall());
-    if (test[2])
+    if (test[1])
       req.on('error', common.mustCall());
     else
       req.on('error', common.mustNotCall());
diff --git a/test/parallel/test-http2-server-sessionerror.js b/test/parallel/test-http2-server-sessionerror.js
new file mode 100644
index 00000000000000..525eb2e6efd11a
--- /dev/null
+++ b/test/parallel/test-http2-server-sessionerror.js
@@ -0,0 +1,48 @@
+// Flags: --expose-internals
+
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+const { kSocket } = require('internal/http2/util');
+
+const server = http2.createServer();
+server.on('stream', common.mustNotCall());
+
+let test = 0;
+
+server.on('session', common.mustCall((session) => {
+  switch (++test) {
+    case 1:
+      server.on('error', common.mustNotCall());
+      session.on('error', common.expectsError({
+        type: Error,
+        message: 'test'
+      }));
+      session[kSocket].emit('error', new Error('test'));
+      break;
+    case 2:
+      // If the server does not have a socketError listener,
+      // error will be silent on the server but will close
+      // the session
+      session[kSocket].emit('error', new Error('test'));
+      break;
+  }
+}, 2));
+
+server.listen(0, common.mustCall(() => {
+  const url = `http://localhost:${server.address().port}`;
+  http2.connect(url)
+    // An ECONNRESET error may occur depending on the platform (due largely
+    // to differences in the timing of socket closing). Do not wrap this in
+    // a common must call.
+    .on('error', () => {})
+    .on('close', () => {
+      server.removeAllListeners('error');
+      http2.connect(url)
+        .on('error', () => {})
+        .on('close', () => server.close());
+    });
+}));
diff --git a/test/parallel/test-http2-server-set-header.js b/test/parallel/test-http2-server-set-header.js
index ed27638f6849f4..4b6228053f8ece 100644
--- a/test/parallel/test-http2-server-set-header.js
+++ b/test/parallel/test-http2-server-set-header.js
@@ -29,7 +29,7 @@ server.listen(0, common.mustCall(() => {
   req.on('end', () => {
     assert.strictEqual(body, data);
     server.close();
-    client.destroy();
+    client.close();
   });
   req.end();
 }));
diff --git a/test/parallel/test-http2-server-shutdown-before-respond.js b/test/parallel/test-http2-server-shutdown-before-respond.js
index c3ad9714b5f39b..33f224fc69a9d5 100644
--- a/test/parallel/test-http2-server-shutdown-before-respond.js
+++ b/test/parallel/test-http2-server-shutdown-before-respond.js
@@ -11,24 +11,26 @@ const server = h2.createServer();
 server.on('stream', common.mustCall(onStream));
 
 function onStream(stream, headers, flags) {
-  const session = stream.session;
-  stream.session.shutdown({ graceful: true }, common.mustCall(() => {
-    session.destroy();
-  }));
-  stream.respond({});
+  stream.session.goaway(1);
+  stream.respond();
   stream.end('data');
 }
 
 server.listen(0);
 
 server.on('listening', common.mustCall(() => {
-
   const client = h2.connect(`http://localhost:${server.address().port}`);
 
   client.on('goaway', common.mustCall());
+  client.on('error', common.expectsError({
+    code: 'ERR_HTTP2_SESSION_ERROR'
+  }));
 
   const req = client.request();
-
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_SESSION_ERROR'
+  }));
   req.resume();
+  req.on('data', common.mustNotCall());
   req.on('end', common.mustCall(() => server.close()));
 }));
diff --git a/test/parallel/test-http2-server-shutdown-options-errors.js b/test/parallel/test-http2-server-shutdown-options-errors.js
index 2bf2b47dd73dec..6cee8f25729535 100644
--- a/test/parallel/test-http2-server-shutdown-options-errors.js
+++ b/test/parallel/test-http2-server-shutdown-options-errors.js
@@ -7,55 +7,63 @@ const http2 = require('http2');
 
 const server = http2.createServer();
 
-const optionsToTest = {
-  opaqueData: 'Uint8Array',
-  graceful: 'boolean',
-  errorCode: 'number',
-  lastStreamID: 'number'
-};
+const types = [
+  true,
+  {},
+  [],
+  null,
+  new Date()
+];
 
-const types = {
-  boolean: true,
-  number: 1,
-  object: {},
-  array: [],
-  null: null,
-  Uint8Array: Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])
-};
+server.on('stream', common.mustCall((stream) => {
+  const session = stream.session;
 
-server.on(
-  'stream',
-  common.mustCall((stream) => {
-    Object.keys(optionsToTest).forEach((option) => {
-      Object.keys(types).forEach((type) => {
-        if (type === optionsToTest[option]) {
-          return;
-        }
-        common.expectsError(
-          () =>
-            stream.session.shutdown(
-              { [option]: types[type] },
-              common.mustNotCall()
-            ),
-          {
-            type: TypeError,
-            code: 'ERR_INVALID_OPT_VALUE',
-            message: `The value "${String(types[type])}" is invalid ` +
-            `for option "${option}"`
-          }
-        );
-      });
-    });
-    stream.session.destroy();
-  })
-);
+  types.forEach((i) => {
+    common.expectsError(
+      () => session.goaway(i),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message: 'The "code" argument must be of type number'
+      }
+    );
+    common.expectsError(
+      () => session.goaway(0, i),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message: 'The "lastStreamID" argument must be of type number'
+      }
+    );
+    common.expectsError(
+      () => session.goaway(0, 0, i),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message: 'The "opaqueData" argument must be one of type Buffer, ' +
+                 'TypedArray, or DataView'
+      }
+    );
+  });
+
+  stream.session.destroy();
+}));
 
 server.listen(
   0,
   common.mustCall(() => {
     const client = http2.connect(`http://localhost:${server.address().port}`);
+    // On certain operating systems, an ECONNRESET may occur. We do not need
+    // to test for it here. Do not make this a mustCall
+    client.on('error', () => {});
     const req = client.request();
+    // On certain operating systems, an ECONNRESET may occur. We do not need
+    // to test for it here. Do not make this a mustCall
+    req.on('error', () => {});
     req.resume();
-    req.on('end', common.mustCall(() => server.close()));
+    req.on('close', common.mustCall(() => {
+      client.close();
+      server.close();
+    }));
   })
 );
diff --git a/test/parallel/test-http2-server-shutdown-redundant.js b/test/parallel/test-http2-server-shutdown-redundant.js
index 708be0868c2f9e..f47a0d2c951c86 100644
--- a/test/parallel/test-http2-server-shutdown-redundant.js
+++ b/test/parallel/test-http2-server-shutdown-redundant.js
@@ -3,27 +3,38 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
-const assert = require('assert');
 const http2 = require('http2');
 
 const server = http2.createServer();
 
-// Test blank return when a stream.session.shutdown is called twice
-// Also tests stream.session.shutdown with just a callback function (no options)
 server.on('stream', common.mustCall((stream) => {
-  stream.session.shutdown(common.mustCall(() => {
-    assert.strictEqual(
-      stream.session.shutdown(common.mustNotCall()),
-      undefined
+  const session = stream.session;
+  session.goaway(1);
+  session.goaway(2);
+  stream.session.on('close', common.mustCall(() => {
+    common.expectsError(
+      () => session.goaway(3),
+      {
+        code: 'ERR_HTTP2_INVALID_SESSION',
+        type: Error
+      }
     );
   }));
-  stream.session.shutdown(common.mustNotCall());
 }));
 
 server.listen(0, common.mustCall(() => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
+  client.on('error', common.expectsError({
+    code: 'ERR_HTTP2_SESSION_ERROR'
+  }));
 
   const req = client.request();
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_SESSION_ERROR'
+  }));
   req.resume();
-  req.on('end', common.mustCall(() => server.close()));
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
 }));
diff --git a/test/parallel/test-http2-server-socket-destroy.js b/test/parallel/test-http2-server-socket-destroy.js
index 8291c415284571..03afc1957b8af4 100644
--- a/test/parallel/test-http2-server-socket-destroy.js
+++ b/test/parallel/test-http2-server-socket-destroy.js
@@ -9,22 +9,13 @@ const assert = require('assert');
 const h2 = require('http2');
 const { kSocket } = require('internal/http2/util');
 
-const {
-  HTTP2_HEADER_METHOD,
-  HTTP2_HEADER_PATH,
-  HTTP2_METHOD_POST
-} = h2.constants;
-
 const server = h2.createServer();
 
 // we use the lower-level API here
 server.on('stream', common.mustCall(onStream));
 
 function onStream(stream) {
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
+  stream.respond();
   stream.write('test');
 
   const socket = stream.session[kSocket];
@@ -32,6 +23,7 @@ function onStream(stream) {
   // When the socket is destroyed, the close events must be triggered
   // on the socket, server and session.
   socket.on('close', common.mustCall());
+  stream.on('close', common.mustCall());
   server.on('close', common.mustCall());
   stream.session.on('close', common.mustCall(() => server.close()));
 
@@ -40,23 +32,25 @@ function onStream(stream) {
 
   assert.notStrictEqual(stream.session, undefined);
   socket.destroy();
-  stream.on('destroy', common.mustCall(() => {
-    assert.strictEqual(stream.session, undefined);
-  }));
 }
 
 server.listen(0);
 
 server.on('listening', common.mustCall(() => {
   const client = h2.connect(`http://localhost:${server.address().port}`);
+  // The client may have an ECONNRESET error here depending on the operating
+  // system, due mainly to differences in the timing of socket closing. Do
+  // not wrap this in a common mustCall.
+  client.on('error', () => {});
+  client.on('close', common.mustCall());
 
-  const req = client.request({
-    [HTTP2_HEADER_PATH]: '/',
-    [HTTP2_HEADER_METHOD]: HTTP2_METHOD_POST });
+  const req = client.request({ ':method': 'POST' });
+  // The client may have an ECONNRESET error here depending on the operating
+  // system, due mainly to differences in the timing of socket closing. Do
+  // not wrap this in a common mustCall.
+  req.on('error', () => {});
 
   req.on('aborted', common.mustCall());
   req.resume();
   req.on('end', common.mustCall());
-
-  client.on('close', common.mustCall());
 }));
diff --git a/test/parallel/test-http2-server-socketerror.js b/test/parallel/test-http2-server-socketerror.js
deleted file mode 100644
index 9f52b9280d2779..00000000000000
--- a/test/parallel/test-http2-server-socketerror.js
+++ /dev/null
@@ -1,56 +0,0 @@
-// Flags: --expose-internals
-
-'use strict';
-
-const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
-const assert = require('assert');
-const http2 = require('http2');
-const { kSocket } = require('internal/http2/util');
-
-const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.end('ok');
-}));
-server.on('session', common.mustCall((session) => {
-  // First, test that the socketError event is forwarded to the session object
-  // and not the server object.
-  const handler = common.mustCall((error, socket) => {
-    common.expectsError({
-      type: Error,
-      message: 'test'
-    })(error);
-    assert.strictEqual(socket, session[kSocket]);
-  });
-  const isNotCalled = common.mustNotCall();
-  session.on('socketError', handler);
-  server.on('socketError', isNotCalled);
-  session[kSocket].emit('error', new Error('test'));
-  session.removeListener('socketError', handler);
-  server.removeListener('socketError', isNotCalled);
-
-  // Second, test that the socketError is forwarded to the server object when
-  // no socketError listener is registered for the session
-  server.on('socketError', common.mustCall((error, socket, session) => {
-    common.expectsError({
-      type: Error,
-      message: 'test'
-    })(error);
-    assert.strictEqual(socket, session[kSocket]);
-    assert.strictEqual(session, session);
-  }));
-  session[kSocket].emit('error', new Error('test'));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  req.resume();
-  req.on('end', common.mustCall());
-  req.on('close', common.mustCall(() => {
-    client.destroy();
-    server.close();
-  }));
-}));
diff --git a/test/parallel/test-http2-server-stream-session-destroy.js b/test/parallel/test-http2-server-stream-session-destroy.js
index 24d064a448f87d..5eb04a8d376635 100644
--- a/test/parallel/test-http2-server-stream-session-destroy.js
+++ b/test/parallel/test-http2-server-stream-session-destroy.js
@@ -8,56 +8,41 @@ const h2 = require('http2');
 
 const server = h2.createServer();
 
-server.on(
-  'stream',
-  common.mustCall((stream) => {
-    stream.session.destroy();
-
-    // Test that stream.state getter returns an empty object
-    // when the stream session has been destroyed
-    assert.deepStrictEqual({}, stream.state);
-
-    // Test that ERR_HTTP2_INVALID_STREAM is thrown while calling
-    // stream operations after the stream session has been destroyed
-    const invalidStreamError = {
-      type: Error,
-      code: 'ERR_HTTP2_INVALID_STREAM',
-      message: 'The stream has been destroyed'
-    };
-    common.expectsError(() => stream.additionalHeaders(), invalidStreamError);
-    common.expectsError(() => stream.priority(), invalidStreamError);
-    common.expectsError(
-      () => stream.pushStream({}, common.mustNotCall()),
-      invalidStreamError
-    );
-    common.expectsError(() => stream.respond(), invalidStreamError);
-    common.expectsError(() => stream.write('data'), invalidStreamError);
-
-    // Test that ERR_HTTP2_INVALID_SESSION is thrown while calling
-    // session operations after the stream session has been destroyed
-    const invalidSessionError = {
-      type: Error,
-      code: 'ERR_HTTP2_INVALID_SESSION',
-      message: 'The session has been destroyed'
-    };
-    common.expectsError(() => stream.session.settings(), invalidSessionError);
-    common.expectsError(() => stream.session.shutdown(), invalidSessionError);
-
-    // Wait for setImmediate call from destroy() to complete
-    // so that state.destroyed is set to true
-    setImmediate((session) => {
-      common.expectsError(() => session.settings(), invalidSessionError);
-      common.expectsError(() => session.shutdown(), invalidSessionError);
-    }, stream.session);
-  })
-);
-
-server.listen(
-  0,
-  common.mustCall(() => {
-    const client = h2.connect(`http://localhost:${server.address().port}`);
-    const req = client.request();
-    req.resume();
-    req.on('end', common.mustCall(() => server.close()));
-  })
-);
+server.on('stream', common.mustCall((stream) => {
+  assert(stream.session);
+  stream.session.destroy();
+  assert.strictEqual(stream.session, undefined);
+
+  // Test that stream.state getter returns an empty object
+  // when the stream session has been destroyed
+  assert.deepStrictEqual({}, stream.state);
+
+  // Test that ERR_HTTP2_INVALID_STREAM is thrown while calling
+  // stream operations after the stream session has been destroyed
+  const invalidStreamError = {
+    type: Error,
+    code: 'ERR_HTTP2_INVALID_STREAM',
+    message: 'The stream has been destroyed'
+  };
+  common.expectsError(() => stream.additionalHeaders(), invalidStreamError);
+  common.expectsError(() => stream.priority(), invalidStreamError);
+  common.expectsError(() => stream.respond(), invalidStreamError);
+  common.expectsError(
+    () => stream.pushStream({}, common.mustNotCall()),
+    {
+      code: 'ERR_HTTP2_PUSH_DISABLED',
+      type: Error
+    }
+  );
+  assert.strictEqual(stream.write('data'), false);
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+  client.on('error', () => {});
+  const req = client.request();
+  req.resume();
+  req.on('end', common.mustCall());
+  req.on('close', common.mustCall(() => server.close()));
+  req.on('error', () => {});
+}));
diff --git a/test/parallel/test-http2-server-timeout.js b/test/parallel/test-http2-server-timeout.js
index 28ab6efb87f6c1..581a409ce9171d 100755
--- a/test/parallel/test-http2-server-timeout.js
+++ b/test/parallel/test-http2-server-timeout.js
@@ -9,7 +9,7 @@ const server = http2.createServer();
 server.setTimeout(common.platformTimeout(1));
 
 const onServerTimeout = common.mustCall((session) => {
-  session.destroy();
+  session.close(() => session.destroy());
 });
 
 server.on('stream', common.mustNotCall());
@@ -18,10 +18,14 @@ server.once('timeout', onServerTimeout);
 server.listen(0, common.mustCall(() => {
   const url = `http://localhost:${server.address().port}`;
   const client = http2.connect(url);
+  // Because of the timeout, an ECONRESET error may or may not happen here.
+  // Keep this as a non-op and do not use common.mustCall()
+  client.on('error', () => {});
   client.on('close', common.mustCall(() => {
-
     const client2 = http2.connect(url);
+    // Because of the timeout, an ECONRESET error may or may not happen here.
+    // Keep this as a non-op and do not use common.mustCall()
+    client2.on('error', () => {});
     client2.on('close', common.mustCall(() => server.close()));
-
   }));
 }));
diff --git a/test/parallel/test-http2-session-settings.js b/test/parallel/test-http2-session-settings.js
index 53ff44dd9ec2fe..239e2fa76c9c02 100644
--- a/test/parallel/test-http2-session-settings.js
+++ b/test/parallel/test-http2-session-settings.js
@@ -68,71 +68,62 @@ server.listen(
 
     const req = client.request(headers);
 
-    req.on(
-      'connect',
-      common.mustCall(() => {
-        // pendingSettingsAck will be true if a SETTINGS frame
-        // has been sent but we are still waiting for an acknowledgement
-        assert(client.pendingSettingsAck);
-      })
-    );
+    req.on('ready', common.mustCall(() => {
+      // pendingSettingsAck will be true if a SETTINGS frame
+      // has been sent but we are still waiting for an acknowledgement
+      assert(client.pendingSettingsAck);
+    }));
 
     // State will only be valid after connect event is emitted
-    req.on(
-      'ready',
-      common.mustCall(() => {
-        assert.doesNotThrow(() => {
-          client.settings({
-            maxHeaderListSize: 1
-          });
+    req.on('ready', common.mustCall(() => {
+      assert.doesNotThrow(() => {
+        client.settings({
+          maxHeaderListSize: 1
         });
+      });
 
-        // Verify valid error ranges
-        [
-          ['headerTableSize', -1],
-          ['headerTableSize', 2 ** 32],
-          ['initialWindowSize', -1],
-          ['initialWindowSize', 2 ** 32],
-          ['maxFrameSize', 16383],
-          ['maxFrameSize', 2 ** 24],
-          ['maxHeaderListSize', -1],
-          ['maxHeaderListSize', 2 ** 32]
-        ].forEach((i) => {
-          const settings = {};
-          settings[i[0]] = i[1];
-          common.expectsError(
-            () => client.settings(settings),
-            {
-              type: RangeError,
-              code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-              message: `Invalid value for setting "${i[0]}": ${i[1]}`
-            }
-          );
-        });
+      // Verify valid error ranges
+      [
+        ['headerTableSize', -1],
+        ['headerTableSize', 2 ** 32],
+        ['initialWindowSize', -1],
+        ['initialWindowSize', 2 ** 32],
+        ['maxFrameSize', 16383],
+        ['maxFrameSize', 2 ** 24],
+        ['maxHeaderListSize', -1],
+        ['maxHeaderListSize', 2 ** 32]
+      ].forEach((i) => {
+        const settings = {};
+        settings[i[0]] = i[1];
+        common.expectsError(
+          () => client.settings(settings),
+          {
+            type: RangeError,
+            code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+            message: `Invalid value for setting "${i[0]}": ${i[1]}`
+          }
+        );
+      });
 
-        // error checks for enablePush
-        [1, {}, 'test', [], null, Infinity, NaN].forEach((i) => {
-          common.expectsError(
-            () => client.settings({ enablePush: i }),
-            {
-              type: TypeError,
-              code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-              message: `Invalid value for setting "enablePush": ${i}`
-            }
-          );
-        });
-      })
-    );
+      // error checks for enablePush
+      [1, {}, 'test', [], null, Infinity, NaN].forEach((i) => {
+        common.expectsError(
+          () => client.settings({ enablePush: i }),
+          {
+            type: TypeError,
+            code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+            message: `Invalid value for setting "enablePush": ${i}`
+          }
+        );
+      });
+    }));
 
     req.on('response', common.mustCall());
     req.resume();
-    req.on(
-      'end',
-      common.mustCall(() => {
-        server.close();
-        client.destroy();
-      })
-    );
+    req.on('end', common.mustCall(() => {
+      server.close();
+      client.close();
+    }));
     req.end();
   })
 );
diff --git a/test/parallel/test-http2-session-stream-state.js b/test/parallel/test-http2-session-stream-state.js
index 9bbac3f482cbcf..612feb8cf1e2ca 100644
--- a/test/parallel/test-http2-session-stream-state.js
+++ b/test/parallel/test-http2-session-stream-state.js
@@ -57,7 +57,7 @@ server.on('listening', common.mustCall(() => {
   const req = client.request(headers);
 
   // State will only be valid after connect event is emitted
-  req.on('connect', common.mustCall(() => {
+  req.on('ready', common.mustCall(() => {
 
     // Test Stream State.
     {
@@ -91,7 +91,7 @@ server.on('listening', common.mustCall(() => {
   req.resume();
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end();
 
diff --git a/test/parallel/test-http2-shutdown-errors.js b/test/parallel/test-http2-shutdown-errors.js
deleted file mode 100644
index 30bdb7a986d898..00000000000000
--- a/test/parallel/test-http2-shutdown-errors.js
+++ /dev/null
@@ -1,75 +0,0 @@
-'use strict';
-
-const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
-const http2 = require('http2');
-const {
-  constants,
-  Http2Session,
-  nghttp2ErrorString
-} = process.binding('http2');
-
-// tests error handling within shutdown
-// - should emit ERR_HTTP2_ERROR on session for all errors
-
-const tests = Object.getOwnPropertyNames(constants)
-  .filter((key) => (
-    key.indexOf('NGHTTP2_ERR') === 0
-  ))
-  .map((key) => ({
-    ngError: constants[key],
-    error: {
-      code: 'ERR_HTTP2_ERROR',
-      type: Error,
-      message: nghttp2ErrorString(constants[key])
-    }
-  }));
-
-let currentError;
-
-// mock submitGoaway because we only care about testing error handling
-Http2Session.prototype.goaway = () => currentError.ngError;
-
-const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const errorMustCall = common.expectsError(currentError.error);
-  const errorMustNotCall = common.mustNotCall(
-    `${currentError.error.code} should emit on session`
-  );
-
-  stream.session.once('error', errorMustCall);
-  stream.on('error', errorMustNotCall);
-
-  stream.session.shutdown();
-}, tests.length));
-
-server.listen(0, common.mustCall(() => runTest(tests.shift())));
-
-function runTest(test) {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const headers = {
-    ':path': '/',
-    ':method': 'POST',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  };
-
-  const client = http2.connect(url);
-  const req = client.request(headers);
-
-  currentError = test;
-  req.resume();
-  req.end();
-
-  req.on('end', common.mustCall(() => {
-    client.destroy();
-
-    if (!tests.length) {
-      server.close();
-    } else {
-      runTest(tests.shift());
-    }
-  }));
-}
diff --git a/test/parallel/test-http2-single-headers.js b/test/parallel/test-http2-single-headers.js
index bb2f57cba1a939..c545b065015050 100644
--- a/test/parallel/test-http2-single-headers.js
+++ b/test/parallel/test-http2-single-headers.js
@@ -26,35 +26,26 @@ server.on('stream', common.mustNotCall());
 server.listen(0, common.mustCall(() => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  let remaining = singles.length * 2;
-  function maybeClose() {
-    if (--remaining === 0) {
-      server.close();
-      client.destroy();
-    }
-  }
-
   singles.forEach((i) => {
-    const req = client.request({
-      [i]: 'abc',
-      [i.toUpperCase()]: 'xyz'
-    });
-    req.on('error', common.expectsError({
-      code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
-      type: Error,
-      message: `Header field "${i}" must have only a single value`
-    }));
-    req.on('error', common.mustCall(maybeClose));
-
-    const req2 = client.request({
-      [i]: ['abc', 'xyz']
-    });
-    req2.on('error', common.expectsError({
-      code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
-      type: Error,
-      message: `Header field "${i}" must have only a single value`
-    }));
-    req2.on('error', common.mustCall(maybeClose));
+    common.expectsError(
+      () => client.request({ [i]: 'abc', [i.toUpperCase()]: 'xyz' }),
+      {
+        code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
+        type: Error,
+        message: `Header field "${i}" must have only a single value`
+      }
+    );
+
+    common.expectsError(
+      () => client.request({ [i]: ['abc', 'xyz'] }),
+      {
+        code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
+        type: Error,
+        message: `Header field "${i}" must have only a single value`
+      }
+    );
   });
 
+  server.close();
+  client.close();
 }));
diff --git a/test/parallel/test-http2-socket-proxy.js b/test/parallel/test-http2-socket-proxy.js
index 3b15c18628d218..2d90ef7e952a55 100644
--- a/test/parallel/test-http2-socket-proxy.js
+++ b/test/parallel/test-http2-socket-proxy.js
@@ -57,7 +57,7 @@ server.on('stream', common.mustCall(function(stream, headers) {
   assert.strictEqual(socket.writable, 0);
   assert.strictEqual(socket.readable, 0);
 
-  stream.session.destroy();
+  stream.end();
 
   socket.setTimeout = undefined;
   assert.strictEqual(session.setTimeout, undefined);
@@ -71,18 +71,11 @@ server.listen(0, common.mustCall(function() {
   const port = server.address().port;
   const url = `http://localhost:${port}`;
   const client = h2.connect(url, common.mustCall(() => {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
+    const request = client.request();
     request.on('end', common.mustCall(() => {
-      client.destroy();
+      client.close();
       server.close();
     }));
-    request.end();
     request.resume();
   }));
 }));
diff --git a/test/parallel/test-http2-status-code-invalid.js b/test/parallel/test-http2-status-code-invalid.js
index 3a0d882dea19da..3337aad32d7f70 100644
--- a/test/parallel/test-http2-status-code-invalid.js
+++ b/test/parallel/test-http2-status-code-invalid.js
@@ -36,6 +36,6 @@ server.listen(0, common.mustCall(() => {
   req.resume();
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
 }));
diff --git a/test/parallel/test-http2-status-code.js b/test/parallel/test-http2-status-code.js
index e8f64da368a5f5..d3642b4ff0217f 100644
--- a/test/parallel/test-http2-status-code.js
+++ b/test/parallel/test-http2-status-code.js
@@ -22,7 +22,7 @@ server.listen(0, common.mustCall(() => {
   let remaining = codes.length;
   function maybeClose() {
     if (--remaining === 0) {
-      client.destroy();
+      client.close();
       server.close();
     }
   }
diff --git a/test/parallel/test-http2-stream-client.js b/test/parallel/test-http2-stream-client.js
index aa722c5ff2b6d9..3e6c6b2a8a1b5e 100644
--- a/test/parallel/test-http2-stream-client.js
+++ b/test/parallel/test-http2-stream-client.js
@@ -22,7 +22,7 @@ server.listen(0, common.mustCall(() => {
   const req = client.request();
   req.resume();
   req.on('close', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
 }));
diff --git a/test/parallel/test-http2-stream-destroy-event-order.js b/test/parallel/test-http2-stream-destroy-event-order.js
index c375bd80b38e22..e2732830efbd8a 100644
--- a/test/parallel/test-http2-stream-destroy-event-order.js
+++ b/test/parallel/test-http2-stream-destroy-event-order.js
@@ -3,26 +3,27 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
-const assert = require('assert');
 const http2 = require('http2');
 
 let client;
 let req;
 const server = http2.createServer();
 server.on('stream', common.mustCall((stream) => {
-  stream.on('error', common.mustCall(() => {
-    stream.on('close', common.mustCall((code) => {
-      assert.strictEqual(code, 2);
-      client.destroy();
+  stream.on('close', common.mustCall(() => {
+    stream.on('error', common.mustCall(() => {
       server.close();
     }));
   }));
 
-  req.rstStream(2);
+  req.close(2);
 }));
 server.listen(0, common.mustCall(() => {
   client = http2.connect(`http://localhost:${server.address().port}`);
   req = client.request();
   req.resume();
-  req.on('error', common.mustCall());
+  req.on('close', common.mustCall(() => {
+    req.on('error', common.mustCall(() => {
+      client.close();
+    }));
+  }));
 }));
diff --git a/test/parallel/test-http2-timeouts.js b/test/parallel/test-http2-timeouts.js
index e3163a3dc8d927..083dcaf40c10ad 100644
--- a/test/parallel/test-http2-timeouts.js
+++ b/test/parallel/test-http2-timeouts.js
@@ -51,7 +51,7 @@ server.on('listening', common.mustCall(() => {
       req.resume();
       req.on('end', common.mustCall(() => {
         server.close();
-        client.destroy();
+        client.close();
       }));
       req.end();
     }));
diff --git a/test/parallel/test-http2-too-large-headers.js b/test/parallel/test-http2-too-large-headers.js
index f7ac25170b846f..7a7082736160f8 100644
--- a/test/parallel/test-http2-too-large-headers.js
+++ b/test/parallel/test-http2-too-large-headers.js
@@ -25,7 +25,7 @@ server.listen(0, common.mustCall(() => {
     req.on('close', common.mustCall((code) => {
       assert.strictEqual(code, NGHTTP2_ENHANCE_YOUR_CALM);
       server.close();
-      client.destroy();
+      client.close();
     }));
   });
 
diff --git a/test/parallel/test-http2-too-many-headers.js b/test/parallel/test-http2-too-many-headers.js
index eff0fa9c351c32..f05511cff657e0 100644
--- a/test/parallel/test-http2-too-many-headers.js
+++ b/test/parallel/test-http2-too-many-headers.js
@@ -28,7 +28,7 @@ server.listen(0, common.mustCall(() => {
   req.on('close', common.mustCall((code) => {
     assert.strictEqual(code, NGHTTP2_ENHANCE_YOUR_CALM);
     server.close();
-    client.destroy();
+    client.close();
   }));
 
 }));
diff --git a/test/parallel/test-http2-too-many-settings.js b/test/parallel/test-http2-too-many-settings.js
index 9b685fa8ceb16f..9ba8605be8b55b 100644
--- a/test/parallel/test-http2-too-many-settings.js
+++ b/test/parallel/test-http2-too-many-settings.js
@@ -43,7 +43,7 @@ server.on('listening', common.mustCall(() => {
   client.on('close', closeServer);
   client.on('localSettings', common.mustCall(() => {
     if (--remaining <= 0) {
-      client.destroy();
+      client.close();
     }
   }, maxPendingAck + 1));
   client.on('connect', common.mustCall(() => doTest(client)));
@@ -56,6 +56,6 @@ server.on('listening', common.mustCall(() => {
 
   client.on('close', closeServer);
   client.on('localSettings', common.mustCall(() => {
-    client.destroy();
+    client.close();
   }));
 }));
diff --git a/test/parallel/test-http2-trailers.js b/test/parallel/test-http2-trailers.js
index 5e0db6a30c3db0..1ca5bdf70d05b0 100644
--- a/test/parallel/test-http2-trailers.js
+++ b/test/parallel/test-http2-trailers.js
@@ -45,7 +45,7 @@ server.on('listening', common.mustCall(function() {
   }));
   req.on('end', common.mustCall(() => {
     server.close();
-    client.destroy();
+    client.close();
   }));
   req.end('data');
 
diff --git a/test/parallel/test-http2-window-size.js b/test/parallel/test-http2-window-size.js
index 381416c0d23cc6..3d1c14de847e48 100644
--- a/test/parallel/test-http2-window-size.js
+++ b/test/parallel/test-http2-window-size.js
@@ -67,7 +67,7 @@ function run(buffers, initialWindowSize) {
             const actualBuffer = Buffer.concat(responses);
             assert.strictEqual(Buffer.compare(actualBuffer, expectedBuffer), 0);
             // shut down
-            client.destroy();
+            client.close();
             server.close(() => {
               resolve();
             });
diff --git a/test/parallel/test-http2-write-callbacks.js b/test/parallel/test-http2-write-callbacks.js
index 44e33573a680b6..eca7f00ea7e292 100644
--- a/test/parallel/test-http2-write-callbacks.js
+++ b/test/parallel/test-http2-write-callbacks.js
@@ -31,7 +31,7 @@ server.listen(0, common.mustCall(() => {
   req.on('data', (chunk) => actual += chunk);
   req.on('end', common.mustCall(() => assert.strictEqual(actual, 'abcxyz')));
   req.on('close', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
 }));
diff --git a/test/parallel/test-http2-write-empty-string.js b/test/parallel/test-http2-write-empty-string.js
index fea261917187da..6e6ce5254ddcfc 100644
--- a/test/parallel/test-http2-write-empty-string.js
+++ b/test/parallel/test-http2-write-empty-string.js
@@ -34,7 +34,7 @@ server.listen(0, common.mustCall(function() {
 
   req.on('end', common.mustCall(function() {
     assert.strictEqual('1\n2\n3\n', res);
-    client.destroy();
+    client.close();
   }));
 
   req.end();
diff --git a/test/parallel/test-http2-zero-length-write.js b/test/parallel/test-http2-zero-length-write.js
index 899c28bace6f53..0b50715330a1c4 100644
--- a/test/parallel/test-http2-zero-length-write.js
+++ b/test/parallel/test-http2-zero-length-write.js
@@ -41,11 +41,12 @@ server.listen(0, common.mustCall(() => {
   let actual = '';
   const req = client.request({ ':method': 'POST' });
   req.on('response', common.mustCall());
+  req.setEncoding('utf8');
   req.on('data', (chunk) => actual += chunk);
   req.on('end', common.mustCall(() => {
     assert.strictEqual(actual, expect);
     server.close();
-    client.destroy();
+    client.close();
   }));
   getSrc().pipe(req);
 }));
diff --git a/test/sequential/test-http2-session-timeout.js b/test/sequential/test-http2-session-timeout.js
index 7a401e90ea4bbc..fce4570563c584 100644
--- a/test/sequential/test-http2-session-timeout.js
+++ b/test/sequential/test-http2-session-timeout.js
@@ -38,7 +38,7 @@ server.listen(0, common.mustCall(() => {
         setTimeout(() => makeReq(attempts - 1), callTimeout);
       } else {
         server.removeListener('timeout', mustNotCall);
-        client.destroy();
+        client.close();
         server.close();
       }
     });
diff --git a/test/sequential/test-http2-timeout-large-write-file.js b/test/sequential/test-http2-timeout-large-write-file.js
index 922e5f99668da2..e32f6037eef9e3 100644
--- a/test/sequential/test-http2-timeout-large-write-file.js
+++ b/test/sequential/test-http2-timeout-large-write-file.js
@@ -79,7 +79,7 @@ server.listen(0, common.mustCall(() => {
     }
   }, 1));
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
 }));
diff --git a/test/sequential/test-http2-timeout-large-write.js b/test/sequential/test-http2-timeout-large-write.js
index f0a11b2e44469e..a15fb46af6d28a 100644
--- a/test/sequential/test-http2-timeout-large-write.js
+++ b/test/sequential/test-http2-timeout-large-write.js
@@ -78,7 +78,7 @@ server.listen(0, common.mustCall(() => {
     }
   }, 1));
   req.on('end', common.mustCall(() => {
-    client.destroy();
+    client.close();
     server.close();
   }));
 }));