http2: settle pending write callbacks on stream destroy

When an HTTP/2 stream is destroyed while a write is still in flight,
nghttp2 may have already handed the data off to the socket and never
report the write's completion once the stream or session tears down. In
that case the callback that resolves the Writable write is never invoked,
so the Writable stays stuck and the event loop never drains, causing
test-http2-close-while-writing to time out on macOS.

In Http2Stream._destroy, settle any write that is still in flight by
invoking its callback with the destroy error and resetting writePending.
A later native completion callback is then a no-op because writeCb is
null and writePending is 0, so the settle is idempotent. Passing the
error (rather than null) also drains any buffered writes.

Fixes: #58252

Signed-off-by: Matteo Collina <hello@matteocollina.com>
Assisted-by: pi-coding-agent

Author: mcollina

lib/internal/http2/core.js

@@ -2721,6 +2721,15 @@ class Http2Stream extends Duplex {
         });
       }
     }
+
+    // A write in flight may never get its native completion callback once the
+    // stream tears down; settle it so the Writable can clean up.
+    if (state.writeCb !== null) {
+      const writeCb = state.writeCb;
+      state.writeCb = null;
+      state.writePending = 0;
+      writeCb(err);
+    }
     callback(err);
   }
   // The Http2Stream can be destroyed if it has closed and if the readable

test/parallel/test-http2-close-while-writing.js

@@ -29,11 +29,21 @@ server.on('session', common.mustCall(function(session) {
     stream.on('error', common.mustCall((err) => {
       assert.strictEqual(err.code, 'ERR_HTTP2_STREAM_ABORTED');
     }));
-    stream.resume();
+
+    // Every write dispatched before close must have its callback invoked.
+    let writes = 0;
+    let writeCallbacks = 0;
     stream.on('data', function() {
-      this.write(Buffer.alloc(1));
+      writes++;
+      this.write(Buffer.alloc(1), () => {
+        writeCallbacks++;
+      });
       process.nextTick(() => client_stream.destroy());
     });
+    stream.on('close', common.mustCall(() => {
+      assert.strictEqual(writeCallbacks, writes);
+    }));
+    stream.resume();
   }));
 }));