lib: revert primordials in a hot path

Evidence has shown that use of primordials have sometimes an impact of
performance. This commit reverts the changes who are most likely to be
responsible for performance regression in the HTTP response path.

Author: aduh95

lib/_http_common.js

@@ -22,11 +22,9 @@
 'use strict';
 
 const {
-  ArrayPrototypePushApply,
   MathMin,
   Symbol,
   RegExpPrototypeTest,
-  TypedArrayPrototypeSlice,
 } = primordials;
 const { setImmediate } = require('timers');
 
@@ -66,7 +64,7 @@ function parserOnHeaders(headers, url) {
   // Once we exceeded headers limit - stop collecting them
   if (this.maxHeaderPairs <= 0 ||
       this._headers.length < this.maxHeaderPairs) {
-    ArrayPrototypePushApply(this._headers, headers);
+    this._headers.push(...headers);
   }
   this._url += url;
 }
@@ -138,7 +136,7 @@ function parserOnBody(b, start, len) {
 
   // Pretend this was the result of a stream._read call.
   if (len > 0 && !stream._dumped) {
-    const slice = TypedArrayPrototypeSlice(b, start, start + len);
+    const slice = b.slice(start, start + len);
     const ret = stream.push(slice);
     if (!ret)
       readStop(this.socket);

lib/_http_incoming.js

@@ -22,8 +22,6 @@
 'use strict';
 
 const {
-  ArrayPrototypePush,
-  FunctionPrototypeCall,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
   StringPrototypeCharCodeAt,
@@ -59,7 +57,7 @@ function IncomingMessage(socket) {
     };
   }
 
-  FunctionPrototypeCall(Readable, this, streamOptions);
+  Readable.call(this, streamOptions);
 
   this._readableState.readingMore = true;
 
@@ -350,7 +348,7 @@ function _addHeaderLine(field, value, dest) {
   } else if (flag === 1) {
     // Array header -- only Set-Cookie at the moment
     if (dest['set-cookie'] !== undefined) {
-      ArrayPrototypePush(dest['set-cookie'], value);
+      dest['set-cookie'].push(value);
     } else {
       dest['set-cookie'] = [value];
     }

lib/_http_outgoing.js

@@ -24,13 +24,7 @@
 const {
   Array,
   ArrayIsArray,
-  ArrayPrototypeForEach,
   ArrayPrototypeJoin,
-  ArrayPrototypePush,
-  ArrayPrototypeUnshift,
-  FunctionPrototype,
-  FunctionPrototypeBind,
-  FunctionPrototypeCall,
   MathFloor,
   NumberPrototypeToString,
   ObjectCreate,
@@ -88,7 +82,7 @@ const { CRLF } = common;
 
 const kCorked = Symbol('corked');
 
-const nop = FunctionPrototype;
+const nop = () => {};
 
 const RE_CONN_CLOSE = /(?:^|\W)close(?:$|\W)/i;
 const RE_TE_CHUNKED = common.chunkExpression;
@@ -101,7 +95,7 @@ function isCookieField(s) {
 }
 
 function OutgoingMessage() {
-  FunctionPrototypeCall(Stream, this);
+  Stream.call(this);
 
   // Queue that holds all currently pending data, until the response will be
   // assigned to the socket (until it will its turn in the HTTP pipeline).
@@ -331,7 +325,7 @@ OutgoingMessage.prototype._send = function _send(data, encoding, callback) {
       data = this._header + data;
     } else {
       const header = this._header;
-      ArrayPrototypeUnshift(this.outputData, {
+      this.outputData.unshift({
         data: header,
         encoding: 'latin1',
         callback: null
@@ -368,7 +362,7 @@ function _writeRaw(data, encoding, callback) {
     return conn.write(data, encoding, callback);
   }
   // Buffer, as long as we're not destroyed.
-  ArrayPrototypePush(this.outputData, { data, encoding, callback });
+  this.outputData.push({ data, encoding, callback });
   this.outputSize += data.length;
   this._onPendingData(data.length);
   return this.outputSize < HIGH_WATER_MARK;
@@ -397,9 +391,10 @@ function _storeHeader(firstLine, headers) {
       }
     } else if (ArrayIsArray(headers)) {
       if (headers.length && ArrayIsArray(headers[0])) {
-        ArrayPrototypeForEach(headers, (entry) =>
-          processHeader(this, state, entry[0], entry[1], true)
-        );
+        for (let i = 0; i < headers.length; i++) {
+          const entry = headers[i];
+          processHeader(this, state, entry[0], entry[1], true);
+        }
       } else {
         if (headers.length % 2 !== 0) {
           throw new ERR_INVALID_ARG_VALUE('headers', headers);
@@ -877,7 +872,7 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
   if (typeof callback === 'function')
     this.once('finish', callback);
 
-  const finish = FunctionPrototypeBind(onFinish, undefined, this);
+  const finish = onFinish.bind(undefined, this);
 
   if (this._hasBody && this.chunkedEncoding) {
     this._send('0\r\n' + this._trailer + '\r\n', 'latin1', finish);

lib/_http_server.js

@@ -23,20 +23,12 @@
 
 const {
   ArrayIsArray,
-  ArrayPrototypeForEach,
-  ArrayPrototypePush,
-  ArrayPrototypeShift,
   Error,
-  FunctionPrototype,
-  FunctionPrototypeBind,
-  FunctionPrototypeCall,
   ObjectKeys,
   ObjectSetPrototypeOf,
-  ReflectApply,
   RegExpPrototypeTest,
   Symbol,
   SymbolFor,
-  TypedArrayPrototypeSlice,
 } = primordials;
 
 const net = require('net');
@@ -185,7 +177,7 @@ class HTTPServerAsyncResource {
 }
 
 function ServerResponse(req) {
-  FunctionPrototypeCall(OutgoingMessage, this);
+  OutgoingMessage.call(this);
 
   if (req.method === 'HEAD') this._hasBody = false;
 
@@ -212,7 +204,7 @@ ObjectSetPrototypeOf(ServerResponse, OutgoingMessage);
 ServerResponse.prototype._finish = function _finish() {
   DTRACE_HTTP_SERVER_RESPONSE(this.socket);
   emitStatistics(this[kServerResponseStatistics]);
-  FunctionPrototypeCall(OutgoingMessage.prototype._finish, this);
+  OutgoingMessage.prototype._finish.call(this);
 };
 
 
@@ -386,7 +378,7 @@ function Server(options, requestListener) {
     validateBoolean(insecureHTTPParser, 'options.insecureHTTPParser');
   this.insecureHTTPParser = insecureHTTPParser;
 
-  FunctionPrototypeCall(net.Server, this, { allowHalfOpen: true });
+  net.Server.call(this, { allowHalfOpen: true });
 
   if (requestListener) {
     this.on('request', requestListener);
@@ -422,17 +414,19 @@ Server.prototype[EE.captureRejectionSymbol] = function(err, event, ...args) {
       const { 1: res } = args;
       if (!res.headersSent && !res.writableEnded) {
         // Don't leak headers.
-        ArrayPrototypeForEach(res.getHeaderNames(),
-                              (name) => res.removeHeader(name));
+        const names = res.getHeaderNames();
+        for (let i = 0; i < names.length; i++) {
+          res.removeHeader(names[i]);
+        }
         res.statusCode = 500;
         res.end(STATUS_CODES[500]);
       } else {
         res.destroy();
       }
       break;
     default:
-      ReflectApply(net.Server.prototype[SymbolFor('nodejs.rejection')],
-                   this, arguments);
+      net.Server.prototype[SymbolFor('nodejs.rejection')]
+        .apply(this, arguments);
   }
 };
 
@@ -493,20 +487,20 @@ function connectionListenerInternal(server, socket) {
     outgoingData: 0,
     keepAliveTimeoutSet: false
   };
-  state.onData = FunctionPrototypeBind(socketOnData, undefined,
-                                       server, socket, parser, state);
-  state.onEnd = FunctionPrototypeBind(socketOnEnd, undefined,
-                                      server, socket, parser, state);
-  state.onClose = FunctionPrototypeBind(socketOnClose, undefined,
-                                        socket, state);
-  state.onDrain = FunctionPrototypeBind(socketOnDrain, undefined,
-                                        socket, state);
+  state.onData = socketOnData.bind(undefined,
+                                   server, socket, parser, state);
+  state.onEnd = socketOnEnd.bind(undefined,
+                                 server, socket, parser, state);
+  state.onClose = socketOnClose.bind(undefined,
+                                     socket, state);
+  state.onDrain = socketOnDrain.bind(undefined,
+                                     socket, state);
   socket.on('data', state.onData);
   socket.on('error', socketOnError);
   socket.on('end', state.onEnd);
   socket.on('close', state.onClose);
   socket.on('drain', state.onDrain);
-  parser.onIncoming = FunctionPrototypeBind(parserOnIncoming, undefined,
+  parser.onIncoming = parserOnIncoming.bind(undefined,
                                             server, socket, state);
 
   // We are consuming socket, so it won't get any actual data
@@ -527,18 +521,18 @@ function connectionListenerInternal(server, socket) {
     parser.consume(socket._handle);
   }
   parser[kOnExecute] =
-    FunctionPrototypeBind(onParserExecute, undefined,
-                          server, socket, parser, state);
+    onParserExecute.bind(undefined,
+                         server, socket, parser, state);
 
   parser[kOnTimeout] =
-    FunctionPrototypeBind(onParserTimeout, undefined,
-                          server, socket);
+    onParserTimeout.bind(undefined,
+                         server, socket);
 
   // When receiving new requests on the same socket (pipelining or keep alive)
   // make sure the requestTimeout is active.
   parser[kOnMessageBegin] =
-    FunctionPrototypeBind(setRequestTimeout, undefined,
-                          server, socket);
+    setRequestTimeout.bind(undefined,
+                           server, socket);
 
   // This protects from DOS attack where an attacker establish the connection
   // without sending any data on applications where server.timeout is left to
@@ -594,7 +588,7 @@ function socketOnClose(socket, state) {
 
 function abortIncoming(incoming) {
   while (incoming.length) {
-    const req = ArrayPrototypeShift(incoming);
+    const req = incoming.shift();
     req.destroy(connResetException('aborted'));
   }
   // Abort socket._httpMessage ?
@@ -606,7 +600,7 @@ function socketOnEnd(server, socket, parser, state) {
   if (ret instanceof Error) {
     debug('parse error');
     // socketOnError has additional logic and will call socket.destroy(err).
-    FunctionPrototypeCall(socketOnError, socket, ret);
+    socketOnError.call(socket, ret);
   } else if (!server.httpAllowHalfOpen) {
     socket.end();
   } else if (state.outgoing.length) {
@@ -629,7 +623,7 @@ function socketOnData(server, socket, parser, state, d) {
 function onRequestTimeout(socket) {
   socket[kRequestTimeout] = undefined;
   // socketOnError has additional logic and will call socket.destroy(err).
-  ReflectApply(socketOnError, socket, [new ERR_HTTP_REQUEST_TIMEOUT()]);
+  socketOnError.call(socket, new ERR_HTTP_REQUEST_TIMEOUT());
 }
 
 function onParserExecute(server, socket, parser, state, ret) {
@@ -649,7 +643,7 @@ function onParserTimeout(server, socket) {
     socket.destroy();
 }
 
-const noop = FunctionPrototype;
+const noop = () => {};
 const badRequestResponse = Buffer.from(
   `HTTP/1.1 400 ${STATUS_CODES[400]}${CRLF}` +
   `Connection: close${CRLF}${CRLF}`, 'ascii'
@@ -696,7 +690,7 @@ function onParserExecuteCommon(server, socket, parser, state, ret, d) {
     prepareError(ret, parser, d);
     ret.rawPacket = d || parser.getCurrentBuffer();
     debug('parse error', ret);
-    FunctionPrototypeCall(socketOnError, socket, ret);
+    socketOnError.call(socket, ret);
   } else if (parser.incoming && parser.incoming.upgrade) {
     // Upgrade or CONNECT
     const req = parser.incoming;
@@ -719,7 +713,7 @@ function onParserExecuteCommon(server, socket, parser, state, ret, d) {
     const eventName = req.method === 'CONNECT' ? 'connect' : 'upgrade';
     if (eventName === 'upgrade' || server.listenerCount(eventName) > 0) {
       debug('SERVER have listener for %s', eventName);
-      const bodyHead = TypedArrayPrototypeSlice(d, ret, d.length);
+      const bodyHead = d.slice(ret, d.length);
 
       socket.readableFlowing = null;
 
@@ -738,7 +732,7 @@ function onParserExecuteCommon(server, socket, parser, state, ret, d) {
     // When receiving new requests on the same socket (pipelining or keep alive)
     // make sure the requestTimeout is active.
     parser[kOnMessageBegin] =
-      FunctionPrototypeBind(setRequestTimeout, undefined, server, socket);
+      setRequestTimeout.bind(undefined, server, socket);
   }
 
   if (socket._paused && socket.parser) {
@@ -802,7 +796,7 @@ function resOnFinish(req, res, socket, state, server) {
   // array will be empty.
   assert(state.incoming.length === 0 || state.incoming[0] === req);
 
-  ArrayPrototypeShift(state.incoming);
+  state.incoming.shift();
 
   // If the user never called req.read(), and didn't pipe() or
   // .resume() or .on('data'), then we call req._dump() so that the
@@ -835,7 +829,7 @@ function resOnFinish(req, res, socket, state, server) {
     }
   } else {
     // Start sending the next message
-    const m = ArrayPrototypeShift(state.outgoing);
+    const m = state.outgoing.shift();
     if (m) {
       m.assignSocket(socket);
     }
@@ -861,7 +855,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
       return 2;
   }
 
-  ArrayPrototypePush(state.incoming, req);
+  state.incoming.push(req);
 
   // If the writable end isn't consuming, then stop reading
   // so that we don't become overwhelmed by a flood of
@@ -879,8 +873,8 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
 
   const res = new server[kServerResponse](req);
   res._keepAliveTimeout = server.keepAliveTimeout;
-  res._onPendingData = FunctionPrototypeBind(updateOutgoingData, undefined,
-                                             socket, state);
+  res._onPendingData = updateOutgoingData.bind(undefined,
+                                               socket, state);
 
   res.shouldKeepAlive = keepAlive;
   DTRACE_HTTP_SERVER_REQUEST(req, socket);
@@ -896,16 +890,16 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
 
   if (socket._httpMessage) {
     // There are already pending outgoing res, append.
-    ArrayPrototypePush(state.outgoing, res);
+    state.outgoing.push(res);
   } else {
     res.assignSocket(socket);
   }
 
   // When we're finished writing the response, check if this is the last
   // response, if so destroy the socket.
   res.on('finish',
-         FunctionPrototypeBind(resOnFinish, undefined,
-                               req, res, socket, state, server));
+         resOnFinish.bind(undefined,
+                          req, res, socket, state, server));
 
   if (req.headers.expect !== undefined &&
       (req.httpVersionMajor === 1 && req.httpVersionMinor === 1)) {
@@ -977,8 +971,8 @@ function unconsume(parser, socket) {
 
 function generateSocketListenerWrapper(originalFnName) {
   return function socketListenerWrap(ev, fn) {
-    const res = ReflectApply(net.Socket.prototype[originalFnName], this,
-                             [ev, fn]);
+    const res = net.Socket.prototype[originalFnName].call(this,
+                                                          ev, fn);
     if (!this.parser) {
       this.on = net.Socket.prototype.on;
       this.addListener = net.Socket.prototype.addListener;