url: adding WHATWG URL support

Implements WHATWG URL support. Example:
```
var u = new url.URL('http://example.org');
```
Many, many other commits improving the implementation have been squashed
into this backport PR. They are not listed separately here for brevity.
Backport-PR-URL: #17365
PR-URL: #7448
Reviewed-By: Ilkka Myller <ilkka.myller@nodefield.com>

Author: jasnell

benchmark/url/legacy-vs-whatwg-url-get-prop.js

@@ -0,0 +1,97 @@
+'use strict';
+constcommon=require('../common.js');
+consturl=require('url');
+constURL=url.URL;
+constassert=require('assert');
+constinputs=require('../fixtures/url-inputs.js').urls;
+
+constbench=common.createBenchmark(main,{
+type: Object.keys(inputs),
+method: ['legacy','whatwg'],
+n: [1e5]
+});
+
+// At the time of writing, when using a passed property name to index
+// the object, Crankshaft would generate a LoadKeyedGeneric even when it
+// remains a constant in the function, so here we must use the literal
+// instead to get a LoadNamedField.
+functionuseLegacy(n,input){
+constobj=url.parse(input);
+constnoDead={
+protocol: obj.protocol,
+auth: obj.auth,
+host: obj.host,
+hostname: obj.hostname,
+port: obj.port,
+pathname: obj.pathname,
+search: obj.search,
+hash: obj.hash
+};
+// It's necessary to assign the values to an object
+// to avoid loop invariant code motion.
+bench.start();
+for(vari=0;i<n;i+=1){
+noDead.protocol=obj.protocol;
+noDead.auth=obj.auth;
+noDead.host=obj.host;
+noDead.hostname=obj.hostname;
+noDead.port=obj.port;
+noDead.pathname=obj.pathname;
+noDead.search=obj.search;
+noDead.hash=obj.hash;
+}
+bench.end(n);
+returnnoDead;
+}
+
+functionuseWHATWG(n,input){
+constobj=newURL(input);
+constnoDead={
+protocol: obj.protocol,
+auth: `${obj.username}:${obj.password}`,
+host: obj.host,
+hostname: obj.hostname,
+port: obj.port,
+pathname: obj.pathname,
+search: obj.search,
+hash: obj.hash
+};
+bench.start();
+for(vari=0;i<n;i+=1){
+noDead.protocol=obj.protocol;
+noDead.auth=`${obj.username}:${obj.password}`;
+noDead.host=obj.host;
+noDead.hostname=obj.hostname;
+noDead.port=obj.port;
+noDead.pathname=obj.pathname;
+noDead.search=obj.search;
+noDead.hash=obj.hash;
+}
+bench.end(n);
+returnnoDead;
+}
+
+functionmain(conf){
+consttype=conf.type;
+constn=conf.n|0;
+constmethod=conf.method;
+
+constinput=inputs[type];
+if(!input){
+thrownewError('Unknown input type');
+}
+
+varnoDead;// Avoid dead code elimination.
+switch(method){
+case'legacy':
+noDead=useLegacy(n,input);
+break;
+case'whatwg':
+noDead=useWHATWG(n,input);
+break;
+default:
+thrownewError('Unknown method');
+}
+
+assert.ok(noDead);
+}

benchmark/url/legacy-vs-whatwg-url-parse.js

@@ -0,0 +1,57 @@
+'use strict';
+constcommon=require('../common.js');
+consturl=require('url');
+constURL=url.URL;
+constassert=require('assert');
+constinputs=require('../fixtures/url-inputs.js').urls;
+
+constbench=common.createBenchmark(main,{
+type: Object.keys(inputs),
+method: ['legacy','whatwg'],
+n: [1e5]
+});
+
+functionuseLegacy(n,input){
+varnoDead=url.parse(input);
+bench.start();
+for(vari=0;i<n;i+=1){
+noDead=url.parse(input);
+}
+bench.end(n);
+returnnoDead;
+}
+
+functionuseWHATWG(n,input){
+varnoDead=newURL(input);
+bench.start();
+for(vari=0;i<n;i+=1){
+noDead=newURL(input);
+}
+bench.end(n);
+returnnoDead;
+}
+
+functionmain(conf){
+consttype=conf.type;
+constn=conf.n|0;
+constmethod=conf.method;
+
+constinput=inputs[type];
+if(!input){
+thrownewError('Unknown input type');
+}
+
+varnoDead;// Avoid dead code elimination.
+switch(method){
+case'legacy':
+noDead=useLegacy(n,input);
+break;
+case'whatwg':
+noDead=useWHATWG(n,input);
+break;
+default:
+thrownewError('Unknown method');
+}
+
+assert.ok(noDead);
+}

benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js

@@ -0,0 +1,51 @@
+'use strict';
+constcommon=require('../common.js');
+const{ URLSearchParams }=require('url');
+constquerystring=require('querystring');
+constinputs=require('../fixtures/url-inputs.js').searchParams;
+
+constbench=common.createBenchmark(main,{
+type: Object.keys(inputs),
+method: ['legacy','whatwg'],
+n: [1e6]
+});
+
+functionuseLegacy(n,input){
+querystring.parse(input);
+bench.start();
+for(vari=0;i<n;i+=1){
+querystring.parse(input);
+}
+bench.end(n);
+}
+
+functionuseWHATWG(n,input){
+newURLSearchParams(input);
+bench.start();
+for(vari=0;i<n;i+=1){
+newURLSearchParams(input);
+}
+bench.end(n);
+}
+
+functionmain(conf){
+consttype=conf.type;
+constn=conf.n|0;
+constmethod=conf.method;
+
+constinput=inputs[type];
+if(!input){
+thrownewError('Unknown input type');
+}
+
+switch(method){
+case'legacy':
+useLegacy(n,input);
+break;
+case'whatwg':
+useWHATWG(n,input);
+break;
+default:
+thrownewError('Unknown method');
+}
+}

benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js

@@ -0,0 +1,53 @@
+'use strict';
+constcommon=require('../common.js');
+const{ URLSearchParams }=require('url');
+constquerystring=require('querystring');
+constinputs=require('../fixtures/url-inputs.js').searchParams;
+
+constbench=common.createBenchmark(main,{
+type: Object.keys(inputs),
+method: ['legacy','whatwg'],
+n: [1e6]
+});
+
+functionuseLegacy(n,input,prop){
+constobj=querystring.parse(input);
+querystring.stringify(obj);
+bench.start();
+for(vari=0;i<n;i+=1){
+querystring.stringify(obj);
+}
+bench.end(n);
+}
+
+functionuseWHATWG(n,input,prop){
+constobj=newURLSearchParams(input);
+obj.toString();
+bench.start();
+for(vari=0;i<n;i+=1){
+obj.toString();
+}
+bench.end(n);
+}
+
+functionmain(conf){
+consttype=conf.type;
+constn=conf.n|0;
+constmethod=conf.method;
+
+constinput=inputs[type];
+if(!input){
+thrownewError('Unknown input type');
+}
+
+switch(method){
+case'legacy':
+useLegacy(n,input);
+break;
+case'whatwg':
+useWHATWG(n,input);
+break;
+default:
+thrownewError('Unknown method');
+}
+}

benchmark/url/legacy-vs-whatwg-url-serialize.js

@@ -0,0 +1,59 @@
+'use strict';
+constcommon=require('../common.js');
+consturl=require('url');
+constURL=url.URL;
+constassert=require('assert');
+constinputs=require('../fixtures/url-inputs.js').urls;
+
+constbench=common.createBenchmark(main,{
+type: Object.keys(inputs),
+method: ['legacy','whatwg'],
+n: [1e5]
+});
+
+functionuseLegacy(n,input,prop){
+constobj=url.parse(input);
+varnoDead=url.format(obj);
+bench.start();
+for(vari=0;i<n;i+=1){
+noDead=url.format(obj);
+}
+bench.end(n);
+returnnoDead;
+}
+
+functionuseWHATWG(n,input,prop){
+constobj=newURL(input);
+varnoDead=obj.toString();
+bench.start();
+for(vari=0;i<n;i+=1){
+noDead=obj.toString();
+}
+bench.end(n);
+returnnoDead;
+}
+
+functionmain(conf){
+consttype=conf.type;
+constn=conf.n|0;
+constmethod=conf.method;
+
+constinput=inputs[type];
+if(!input){
+thrownewError('Unknown input type');
+}
+
+varnoDead;// Avoid dead code elimination.
+switch(method){
+case'legacy':
+noDead=useLegacy(n,input);
+break;
+case'whatwg':
+noDead=useWHATWG(n,input);
+break;
+default:
+thrownewError('Unknown method');
+}
+
+assert.ok(noDead);
+}

benchmark/url/url-searchparams-iteration.js

@@ -0,0 +1,61 @@
+'use strict';
+constcommon=require('../common.js');
+constassert=require('assert');
+const{ URLSearchParams }=require('url');
+
+constbench=common.createBenchmark(main,{
+method: ['forEach','iterator'],
+n: [1e6]
+});
+
+conststr='one=single&two=first&three=first&two=2nd&three=2nd&three=3rd';
+
+functionforEach(n){
+constparams=newURLSearchParams(str);
+constnoDead=[];
+constcb=(val,key)=>{
+noDead[0]=key;
+noDead[1]=val;
+};
+
+bench.start();
+for(vari=0;i<n;i+=1)
+params.forEach(cb);
+bench.end(n);
+
+assert.strictEqual(noDead[0],'three');
+assert.strictEqual(noDead[1],'3rd');
+}
+
+functioniterator(n){
+constparams=newURLSearchParams(str);
+constnoDead=[];
+
+bench.start();
+for(vari=0;i<n;i+=1){
+for(constpairofparams){
+noDead[0]=pair[0];
+noDead[1]=pair[1];
+}
+}
+bench.end(n);
+
+assert.strictEqual(noDead[0],'three');
+assert.strictEqual(noDead[1],'3rd');
+}
+
+functionmain(conf){
+constmethod=conf.method;
+constn=conf.n|0;
+
+switch(method){
+case'forEach':
+forEach(n);
+break;
+case'iterator':
+iterator(n);
+break;
+default:
+thrownewError('Unknown method');
+}
+}