http: add sendFile to OutgoingMessage

One of the most common usages of http servers are to response with files.
This provides a faster alternative to:

stream.pipeline(fs.createReadStream(path, { start, end }), res, callback)

PR-URL: #50576

Author: ronag

lib/_http_outgoing.js

@@ -1005,6 +1005,75 @@ function connectionCorkNT(conn) {
   conn.uncork();
 }
 
+OutgoingMessage.prototype.sendFile = function sendFild (path, optsOrCallback, callback) {
+  let start = 0;
+  let end = null;
+
+  if (typeof optsOrCallback === 'function') {
+    callback = optsOrCallback;
+    opts = null;
+  } else if (opts != null) {
+    start = opts.start ?? 0;
+    end = opts.end;
+  }
+
+  fs.open(path, (err, fd) => {
+    if (err) {
+      callback(err);
+    } else {
+      let pos = start;
+      let drain = null;
+
+      const next = (err, bytesRead, buf) => {
+        pos += bytesRead;
+
+        if (err != null && err.code === 'EAGAIN') {
+          setImmediate(() => read(buf));
+          return;
+        } else if (err) {
+          // Fallthrough
+        } else if (bytesRead === 0) {
+          // Fallthrough
+        } else if (dst.write(bytesRead < buf.byteLength ? buf.subarray(0, bytesRead) : buf)) {
+          // TODO (perf): Use FastBuffer instead of subarray.
+          // TODO (perf): Is there a way we can re-use the buffer once we
+          //              know for sure it's been flushed through the socket?
+          // TODO (perf): Avoid creating subarray and use offset parameter in fs.read
+          //              instead.
+          read(bytesRead < buf.byteLength < buf.subarray(bytesRead), null);
+          return;
+        } else if (dst.destroyed) {
+          // Fallthrough
+        } else if (drain == null) {
+          drain = read;
+          dst.on('drain', drain);
+          return;
+        }
+
+        if (drain) {
+          dst.off('drain', drain);
+        }
+
+        fs.close(fd, nop);
+
+        callback(err, pos);
+      };
+
+      // TODO (perf): Avoid closure...
+      const read = (buf) => {
+        const n = end ? Math.min(end - pos, Buffer.poolSize) : Buffer.poolSize;
+        if (n <= 0) {
+          next(null, 0, null)
+        } else {
+          fs.read(fd, buf ?? Buffer.allocUnsafe(n), 0, n, pos, next);
+        }
+      };
+
+      read();
+    }
+  })
+}
+
 OutgoingMessage.prototype.addTrailers = function addTrailers(headers) {
   this._trailer = '';
   const keys = ObjectKeys(headers);