Revert "http2: avoid per-write closures in kWriteGeneric"

This reverts commit a44fca5.

PR-URL: #64663
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Tim Perry <pimterry@gmail.com>
Reviewed-By: Ethan Arrowood <ethan@arrowood.dev>

Author: aduh95

lib/internal/http2/core.js

@@ -1991,47 +1991,6 @@ function shutdownWritable(callback) {
     return afterShutdown.call(req, 0);
 }
 
-// Completes one of the two halves of a dispatched write (the write callback
-// itself and the end-of-stream check); the stream machinery callback runs
-// once both have finished. The state lives on stream[kState] because only a
-// single write may be in flight at any given time.
-function finishWrite(stream) {
-  const state = stream[kState];
-  if (--state.writePending !== 0)
-    return;
-  const cb = state.writeCb;
-  state.writeCb = null;
-  const err = aggregateTwoErrors(state.endErr, state.writeErr);
-  state.writeErr = null;
-  state.endErr = null;
-  // writeGeneric does not destroy on error and
-  // we cannot enable autoDestroy,
-  // so make sure to destroy on error.
-  if (err) {
-    stream.destroy(err);
-  }
-  cb(err);
-}
-
-// Runs on the tick after a write was dispatched: if the write turned out to
-// be the last chunk of an ending writable, shut the writable side down right
-// away so the final DATA frame can include the END_STREAM flag.
-function endCheckNT(stream) {
-  const state = stream[kState];
-  if (state.writeErr ||
-      !stream._writableState.ending ||
-      stream._writableState.buffered.length ||
-      (state.flags & STREAM_FLAGS_HAS_TRAILERS)) {
-    finishWrite(stream);
-    return;
-  }
-  debugStreamObj(stream, 'shutting down writable on last write');
-  shutdownWritable.call(stream, (err) => {
-    state.endErr = err;
-    finishWrite(stream);
-  });
-}
-
 function finishSendTrailers(stream, headersList) {
   // The stream might be destroyed and in that case
   // there is nothing to do.
@@ -2139,12 +2098,6 @@ class Http2Stream extends Duplex {
       writeQueueSize: 0,
       trailersReady: false,
       endAfterHeaders: false,
-      writeCb: null,
-      writeErr: null,
-      endErr: null,
-      writePending: 0,
-      shutdownWritableCalled: false,
-      fd: -1,
     };
 
     // Fields used by the compat API to avoid megamorphisms.
@@ -2332,34 +2285,45 @@ class Http2Stream extends Duplex {
     if (!this.headersSent)
       this[kProceed]();
 
-    // The stream machinery dispatches at most one _write()/_writev() at a
-    // time, so the coordination state between the write callback and the
-    // end-of-stream check below can live on the stream state instead of
-    // being captured by per-write closures.
-    const state = this[kState];
-    state.writeCb = cb;
-    state.writeErr = null;
-    state.endErr = null;
-
-    if (state.flags & STREAM_FLAGS_HAS_TRAILERS) {
-      // Trailers are pending, so the writable side cannot be shut down
-      // early anyway; there is no point in scheduling the end check.
-      state.writePending = 1;
-    } else {
-      state.writePending = 2;
-      // Shutdown write stream right after last chunk is sent
-      // so final DATA frame can include END_STREAM flag
-      process.nextTick(endCheckNT, this);
-    }
+    let req;
 
-    // This is invoked both as a method on the write req and as a plain
-    // call, so the stream has to be captured here.
+    let waitingForWriteCallback = true;
+    let waitingForEndCheck = true;
+    let writeCallbackErr;
+    let endCheckCallbackErr;
+    const done = () => {
+      if (waitingForEndCheck || waitingForWriteCallback) return;
+      const err = aggregateTwoErrors(endCheckCallbackErr, writeCallbackErr);
+      // writeGeneric does not destroy on error and
+      // we cannot enable autoDestroy,
+      // so make sure to destroy on error.
+      if (err) {
+        this.destroy(err);
+      }
+      cb(err);
+    };
     const writeCallback = (err) => {
-      state.writeErr = err;
-      finishWrite(this);
+      waitingForWriteCallback = false;
+      writeCallbackErr = err;
+      done();
+    };
+    const endCheckCallback = (err) => {
+      waitingForEndCheck = false;
+      endCheckCallbackErr = err;
+      done();
     };
+    // Shutdown write stream right after last chunk is sent
+    // so final DATA frame can include END_STREAM flag
+    process.nextTick(() => {
+      if (writeCallbackErr ||
+        !this._writableState.ending ||
+        this._writableState.buffered.length ||
+        (this[kState].flags & STREAM_FLAGS_HAS_TRAILERS))
+        return endCheckCallback();
+      debugStreamObj(this, 'shutting down writable on last write');
+      shutdownWritable.call(this, endCheckCallback);
+    });
 
-    let req;
     if (writev)
       req = writevGeneric(this, data, writeCallback);
     else