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) {
 returnafterShutdown.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.
-functionfinishWrite(stream){
-conststate=stream[kState];
-if(--state.writePending!==0)
-return;
-constcb=state.writeCb;
-state.writeCb=null;
-consterr=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.
-functionendCheckNT(stream){
-conststate=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);
-});
-}
-
 functionfinishSendTrailers(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.
-conststate=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);
-}
+letreq;
 
-// This is invoked both as a method on the write req and as a plain
-// call, so the stream has to be captured here.
+letwaitingForWriteCallback=true;
+letwaitingForEndCheck=true;
+letwriteCallbackErr;
+letendCheckCallbackErr;
+constdone=()=>{
+if(waitingForEndCheck||waitingForWriteCallback)return;
+consterr=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);
+};
 constwriteCallback=(err)=>{
-state.writeErr=err;
-finishWrite(this);
+waitingForWriteCallback=false;
+writeCallbackErr=err;
+done();
+};
+constendCheckCallback=(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))
+returnendCheckCallback();
+debugStreamObj(this,'shutting down writable on last write');
+shutdownWritable.call(this,endCheckCallback);
+});
 
-letreq;
 if(writev)
 req=writevGeneric(this,data,writeCallback);
 else