http: refactor outgoing headers processing

Use a shared function, for..in instead of Object.keys, do less work in
`setHeader` and instead defer some of it until later, and other minor
changes to improve clarity, as well as a slight boost in performance.
PR-URL: #20250
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: apapirovski

benchmark/http/headers.js

@@ -0,0 +1,36 @@
+'use strict';
+
+constcommon=require('../common.js');
+consthttp=require('http');
+
+constbench=common.createBenchmark(main,{
+duplicates: [1,100],
+n: [10,1000],
+});
+
+functionmain({ duplicates, n }){
+constheaders={
+'Connection': 'keep-alive',
+'Transfer-Encoding': 'chunked',
+};
+
+for(vari=0;i<n/duplicates;i++){
+headers[`foo${i}`]=[];
+for(varj=0;j<duplicates;j++){
+headers[`foo${i}`].push(`some header value ${i}`);
+}
+}
+
+constserver=http.createServer(function(req,res){
+res.writeHead(200,headers);
+res.end();
+});
+server.listen(common.PORT,function(){
+bench.http({
+path: '/',
+connections: 10
+},function(){
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -52,6 +52,8 @@ const { utcDate } = internalHttp;
 
 constkIsCorked=Symbol('isCorked');
 
+consthasOwnProperty=Function.call.bind(Object.prototype.hasOwnProperty);
+
 varRE_CONN_CLOSE=/(?:^|\W)close(?:$|\W)/i;
 varRE_TE_CHUNKED=common.chunkExpression;
 
@@ -116,7 +118,7 @@ Object.defineProperty(OutgoingMessage.prototype, '_headers', {
 if(val==null){
 this[outHeadersKey]=null;
 }elseif(typeofval==='object'){
-constheaders=this[outHeadersKey]={};
+constheaders=this[outHeadersKey]=Object.create(null);
 constkeys=Object.keys(val);
 for(vari=0;i<keys.length;++i){
 constname=keys[i];
@@ -129,7 +131,7 @@ Object.defineProperty(OutgoingMessage.prototype, '_headers', {
 Object.defineProperty(OutgoingMessage.prototype,'_headerNames',{
 get: function(){
 constheaders=this[outHeadersKey];
-if(headers){
+if(headers!==null){
 constout=Object.create(null);
 constkeys=Object.keys(headers);
 for(vari=0;i<keys.length;++i){
@@ -138,9 +140,8 @@ Object.defineProperty(OutgoingMessage.prototype, '_headerNames', {
 out[key]=val;
 }
 returnout;
-}else{
-returnheaders;
 }
+returnnull;
 },
 set: function(val){
 if(typeofval==='object'&&val!==null){
@@ -164,14 +165,14 @@ OutgoingMessage.prototype._renderHeaders = function _renderHeaders() {
 }
 
 varheadersMap=this[outHeadersKey];
-if(!headersMap)return{};
-
-varheaders={};
-varkeys=Object.keys(headersMap);
+constheaders={};
 
-for(vari=0,l=keys.length;i<l;i++){
-varkey=keys[i];
-headers[headersMap[key][0]]=headersMap[key][1];
+if(headersMap!==null){
+constkeys=Object.keys(headersMap);
+for(vari=0,l=keys.length;i<l;i++){
+constkey=keys[i];
+headers[headersMap[key][0]]=headersMap[key][1];
+}
 }
 returnheaders;
 };
@@ -285,72 +286,40 @@ OutgoingMessage.prototype._storeHeader = _storeHeader;
 function_storeHeader(firstLine,headers){
 // firstLine in the case of request is: 'GET /index.html HTTP/1.1\r\n'
 // in the case of response it is: 'HTTP/1.1 200 OK\r\n'
-varstate={
+conststate={
 connection: false,
 contLen: false,
 te: false,
 date: false,
 expect: false,
 trailer: false,
-upgrade: false,
 header: firstLine
 };
 
-varfield;
 varkey;
-varvalue;
-vari;
-varj;
 if(headers===this[outHeadersKey]){
 for(keyinheaders){
-varentry=headers[key];
-field=entry[0];
-value=entry[1];
-
-if(valueinstanceofArray){
-if(value.length<2||!isCookieField(field)){
-for(j=0;j<value.length;j++)
-storeHeader(this,state,field,value[j],false);
-continue;
-}
-value=value.join('; ');
-}
-storeHeader(this,state,field,value,false);
+constentry=headers[key];
+processHeader(this,state,entry[0],entry[1],false);
 }
-}elseif(headersinstanceofArray){
-for(i=0;i<headers.length;i++){
-field=headers[i][0];
-value=headers[i][1];
-
-if(valueinstanceofArray){
-for(j=0;j<value.length;j++){
-storeHeader(this,state,field,value[j],true);
-}
-}else{
-storeHeader(this,state,field,value,true);
-}
+}elseif(Array.isArray(headers)){
+for(vari=0;i<headers.length;i++){
+constentry=headers[i];
+processHeader(this,state,entry[0],entry[1],true);
 }
 }elseif(headers){
-varkeys=Object.keys(headers);
-for(i=0;i<keys.length;i++){
-field=keys[i];
-value=headers[field];
-
-if(valueinstanceofArray){
-if(value.length<2||!isCookieField(field)){
-for(j=0;j<value.length;j++)
-storeHeader(this,state,field,value[j],true);
-continue;
-}
-value=value.join('; ');
+for(keyinheaders){
+if(hasOwnProperty(headers,key)){
+processHeader(this,state,key,headers[key],true);
 }
-storeHeader(this,state,field,value,true);
 }
 }
 
+let{ header }=state;
+
 // Date header
 if(this.sendDate&&!state.date){
-state.header+='Date: '+utcDate()+CRLF;
+header+='Date: '+utcDate()+CRLF;
 }
 
 // Force the connection to close when the response is a 204 No Content or
@@ -364,9 +333,9 @@ function _storeHeader(firstLine, headers) {
 // It was pointed out that this might confuse reverse proxies to the point
 // of creating security liabilities, so suppress the zero chunk and force
 // the connection to close.
-varstatusCode=this.statusCode;
-if((statusCode===204||statusCode===304)&&this.chunkedEncoding){
-debug(statusCode+' response should not use chunked encoding,'+
+if(this.chunkedEncoding&&(this.statusCode===204||
+this.statusCode===304)){
+debug(this.statusCode+' response should not use chunked encoding,'+
 ' closing connection.');
 this.chunkedEncoding=false;
 this.shouldKeepAlive=false;
@@ -377,13 +346,13 @@ function _storeHeader(firstLine, headers) {
 this._last=true;
 this.shouldKeepAlive=false;
 }elseif(!state.connection){
-varshouldSendKeepAlive=this.shouldKeepAlive&&
+constshouldSendKeepAlive=this.shouldKeepAlive&&
 (state.contLen||this.useChunkedEncodingByDefault||this.agent);
 if(shouldSendKeepAlive){
-state.header+='Connection: keep-alive\r\n';
+header+='Connection: keep-alive\r\n';
 }else{
 this._last=true;
-state.header+='Connection: close\r\n';
+header+='Connection: close\r\n';
 }
 }
 
@@ -396,9 +365,9 @@ function _storeHeader(firstLine, headers) {
 }elseif(!state.trailer&&
 !this._removedContLen&&
 typeofthis._contentLength==='number'){
-state.header+='Content-Length: '+this._contentLength+CRLF;
+header+='Content-Length: '+this._contentLength+CRLF;
 }elseif(!this._removedTE){
-state.header+='Transfer-Encoding: chunked\r\n';
+header+='Transfer-Encoding: chunked\r\n';
 this.chunkedEncoding=true;
 }else{
 // We should only be able to get here if both Content-Length and
@@ -416,18 +385,31 @@ function _storeHeader(firstLine, headers) {
 thrownewERR_HTTP_TRAILER_INVALID();
 }
 
-this._header=state.header+CRLF;
+this._header=header+CRLF;
 this._headerSent=false;
 
 // wait until the first body chunk, or close(), is sent to flush,
 // UNLESS we're sending Expect: 100-continue.
 if(state.expect)this._send('');
 }
 
-functionstoreHeader(self,state,key,value,validate){
-if(validate){
-validateHeader(key,value);
+functionprocessHeader(self,state,key,value,validate){
+if(validate)
+validateHeaderName(key);
+if(Array.isArray(value)){
+if(value.length<2||!isCookieField(key)){
+for(vari=0;i<value.length;i++)
+storeHeader(self,state,key,value[i],validate);
+return;
+}
+value=value.join('; ');
 }
+storeHeader(self,state,key,value,validate);
+}
+
+functionstoreHeader(self,state,key,value,validate){
+if(validate)
+validateHeaderValue(key,value);
 state.header+=key+': '+escapeHeaderValue(value)+CRLF;
 matchHeader(self,state,key,value);
 }
@@ -439,39 +421,47 @@ function matchHeader(self, state, field, value) {
 switch(field){
 case'connection':
 state.connection=true;
+self._removedConnection=false;
 if(RE_CONN_CLOSE.test(value))
 self._last=true;
 else
 self.shouldKeepAlive=true;
 break;
 case'transfer-encoding':
 state.te=true;
+self._removedTE=false;
 if(RE_TE_CHUNKED.test(value))self.chunkedEncoding=true;
 break;
 case'content-length':
 state.contLen=true;
+self._removedContLen=false;
 break;
 case'date':
 case'expect':
 case'trailer':
-case'upgrade':
 state[field]=true;
 break;
 }
 }
 
-functionvalidateHeader(name,value){
-leterr;
+functionvalidateHeaderName(name){
 if(typeofname!=='string'||!name||!checkIsHttpToken(name)){
-err=newERR_INVALID_HTTP_TOKEN('Header name',name);
-}elseif(value===undefined){
+consterr=newERR_INVALID_HTTP_TOKEN('Header name',name);
+Error.captureStackTrace(err,validateHeaderName);
+throwerr;
+}
+}
+
+functionvalidateHeaderValue(name,value){
+leterr;
+if(value===undefined){
 err=newERR_HTTP_INVALID_HEADER_VALUE(value,name);
 }elseif(checkInvalidHeaderChar(value)){
 debug('Header "%s" contains invalid characters',name);
 err=newERR_INVALID_CHAR('header content',name);
 }
 if(err!==undefined){
-Error.captureStackTrace(err,validateHeader);
+Error.captureStackTrace(err,validateHeaderValue);
 throwerr;
 }
 }
@@ -480,25 +470,14 @@ OutgoingMessage.prototype.setHeader = function setHeader(name, value) {
 if(this._header){
 thrownewERR_HTTP_HEADERS_SENT('set');
 }
-validateHeader(name,value);
+validateHeaderName(name);
+validateHeaderValue(name,value);
 
-if(!this[outHeadersKey])
-this[outHeadersKey]={};
+letheaders=this[outHeadersKey];
+if(headers===null)
+this[outHeadersKey]=headers=Object.create(null);
 
-constkey=name.toLowerCase();
-this[outHeadersKey][key]=[name,value];
-
-switch(key){
-case'connection':
-this._removedConnection=false;
-break;
-case'content-length':
-this._removedContLen=false;
-break;
-case'transfer-encoding':
-this._removedTE=false;
-break;
-}
+headers[name.toLowerCase()]=[name,value];
 };
 
 
@@ -507,18 +486,18 @@ OutgoingMessage.prototype.getHeader = function getHeader(name) {
 thrownewERR_INVALID_ARG_TYPE('name','string',name);
 }
 
-if(!this[outHeadersKey])return;
-
-varentry=this[outHeadersKey][name.toLowerCase()];
-if(!entry)
+constheaders=this[outHeadersKey];
+if(headers===null)
 return;
-returnentry[1];
+
+constentry=headers[name.toLowerCase()];
+returnentry&&entry[1];
 };
 
 
 // Returns an array of the names of the current outgoing headers.
 OutgoingMessage.prototype.getHeaderNames=functiongetHeaderNames(){
-return(this[outHeadersKey] ? Object.keys(this[outHeadersKey]) : []);
+returnthis[outHeadersKey]!==null? Object.keys(this[outHeadersKey]) : [];
 };
 
 
@@ -543,7 +522,8 @@ OutgoingMessage.prototype.hasHeader = function hasHeader(name) {
 thrownewERR_INVALID_ARG_TYPE('name','string',name);
 }
 
-return!!(this[outHeadersKey]&&this[outHeadersKey][name.toLowerCase()]);
+returnthis[outHeadersKey]!==null&&
+!!this[outHeadersKey][name.toLowerCase()];
 };
 
 
@@ -573,7 +553,7 @@ OutgoingMessage.prototype.removeHeader = function removeHeader(name) {
 break;
 }
 
-if(this[outHeadersKey]){
+if(this[outHeadersKey]!==null){
 deletethis[outHeadersKey][key];
 }
 };