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: nodejs#50576

Author: ronag

lib/_http_outgoing.js

@@ -1005,6 +1005,90 @@ function connectionCorkNT(conn) {
   conn.uncork();
 }
 
+OutgoingMessage.prototype.sendFile = function sendFile (path, optsOrCallback, callback) {
+  let start = 0;
+  let end = null;
+  let fd = null;
+
+  if (typeof optsOrCallback === 'function') {
+    callback = optsOrCallback;
+    opts = null;
+  } else if (opts != null) {
+    start = opts.start ?? 0;
+    end = opts.end;
+    fd = opts.fd;
+  }
+
+  // TODO (fix): Validate path, fd, start, end
+
+  if (fd) {
+    _sendFile(fd, dst, start, end, callback);
+  } else {
+    fs.open(path, (err, fd) => {
+      if (err) {
+        callback(err);
+      } else {
+        _sendFile(fd, dst, start, end, callback);
+      }
+    });
+  }
+}
+
+function _sendFile(fd, dst, start, end, callback) {
+  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, er => {
+      if (err && er) {
+        err = new AggregateError([err, er]);
+      }
+      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(null);
+}
+
 OutgoingMessage.prototype.addTrailers = function addTrailers(headers) {
   this._trailer = '';
   const keys = ObjectKeys(headers);