- 7.6.0 7.7.0 7.6.0 7.5.0 7.4.0 7.3.0
+
+
+ Directory
+ Purpose
+
+
+
+
+ arrays
+
+ Benchmarks for various operations on array-like objects,
+ including Array, Buffer, and typed arrays.
+
+
+
+ assert
+
+ Benchmarks for the assert subsystem.
+
+
+
+ buffers
+
+ Benchmarks for the buffer subsystem.
+
+
+
+ child_process
+
+ Benchmarks for the child_process subsystem.
+
+
+
+ crypto
+
+ Benchmarks for the crypto subsystem.
+
+
+
+ dgram
+
+ Benchmarks for the dgram subsystem.
+
+
+
+ domain
+
+ Benchmarks for the domain subsystem.
+
+
+
+ es
+
+ Benchmarks for various new ECMAScript features and their
+ pre-ES2015 counterparts.
+
+
+
+ events
+
+ Benchmarks for the events subsystem.
+
+
+
+ fixtures
+
+ Benchmarks fixtures used in various benchmarks throughout
+ the benchmark suite.
+
+
+
+ fs
+
+ Benchmarks for the fs subsystem.
+
+
+
+ http
+
+ Benchmarks for the http subsystem.
+
+
+
+ misc
+
+ Miscellaneous benchmarks and benchmarks for shared
+ internal modules.
+
+
+
+ module
+
+ Benchmarks for the module subsystem.
+
+
+
+ net
+
+ Benchmarks for the net subsystem.
+
+
+
+ path
+
+ Benchmarks for the path subsystem.
+
+
+
+ process
+
+ Benchmarks for the process subsystem.
+
+
+
+ querystring
+
+ Benchmarks for the querystring subsystem.
+
+
+
+ streams
+
+ Benchmarks for the streams subsystem.
+
+
+
+ string_decoder
+
+ Benchmarks for the string_decoder subsystem.
+
+
+
+ timers
+
+ Benchmarks for the timers subsystem, including
+ setTimeout, setInterval, .etc.
+
+
+
+ tls
+
+ Benchmarks for the tls subsystem.
+
+
+
+ url
+
+ Benchmarks for the url subsystem, including the legacy
+ url implementation and the WHATWG URL implementation.
+
+
+
+ util
+
+ Benchmarks for the util subsystem.
+
+
+
+ vm
+
+ Benchmarks for the vm subsystem.
+
+
+
+
+
+### Other Top-level files
+
+The top-level files include common dependencies of the benchmarks
+and the tools for launching benchmarks and visualizing their output.
+The actual benchmark scripts should be placed in their corresponding
+directories.
+
+* `_benchmark_progress.js`: implements the progress bar displayed
+ when running `compare.js`
+* `_cli.js`: parses the command line arguments passed to `compare.js`,
+ `run.js` and `scatter.js`
+* `_cli.R`: parses the command line arguments passed to `compare.R`
+* `_http-benchmarkers.js`: selects and runs external tools for benchmarking
+ the `http` subsystem.
+* `common.js`: see [Common API](#common-api).
+* `compare.js`: command line tool for comparing performance between different
+ Node.js binaries.
+* `compare.R`: R script for statistically analyzing the output of
+ `compare.js`
+* `run.js`: command line tool for running individual benchmark suite(s).
+* `scatter.js`: command line tool for comparing the performance
+ between different parameters in benchmark configurations,
+ for example to analyze the time complexity.
+* `scatter.R`: R script for visualizing the output of `scatter.js` with
+ scatter plots.
+
+## Common API
+
+The common.js module is used by benchmarks for consistency across repeated
+tasks. It has a number of helpful functions and properties to help with
+writing benchmarks.
+
+### createBenchmark(fn, configs[, options])
+
+See [the guide on writing benchmarks](../doc/guides/writing-and-running-benchmarks.md#basics-of-a-benchmark).
+
+### default\_http\_benchmarker
+
+The default benchmarker used to run HTTP benchmarks.
+See [the guide on writing HTTP benchmarks](../doc/guides/writing-and-running-benchmarks.md#creating-an-http-benchmark).
+
+
+### PORT
+
+The default port used to run HTTP benchmarks.
+See [the guide on writing HTTP benchmarks](../doc/guides/writing-and-running-benchmarks.md#creating-an-http-benchmark).
+
+### sendResult(data)
+
+Used in special benchmarks that can't use `createBenchmark` and the object
+it returns to accomplish what they need. This function reports timing
+data to the parent process (usually created by running `compare.js`, `run.js` or
+`scatter.js`).
+
+### v8ForceOptimization(method[, ...args])
+
+Force V8 to mark the `method` for optimization with the native function
+`%OptimizeFunctionOnNextCall()` and return the optimization status
+after that.
+
+It can be used to prevent the benchmark from getting disrupted by the optimizer
+kicking in halfway through. However, this could result in a less effective
+optimization. In general, only use it if you know what it actually does.
diff --git a/benchmark/_benchmark_progress.js b/benchmark/_benchmark_progress.js
index 2a2a458c5c4e4b..4b42248f246858 100644
--- a/benchmark/_benchmark_progress.js
+++ b/benchmark/_benchmark_progress.js
@@ -15,9 +15,9 @@ function fraction(numerator, denominator) {
function getTime(diff) {
const time = Math.ceil(diff[0] + diff[1] / 1e9);
- const seconds = pad(time % 60, 2, '0');
- const minutes = pad(Math.floor(time / 60) % (60 * 60), 2, '0');
- const hours = pad(Math.floor(time / (60 * 60)), 2, '0');
+ const hours = pad(Math.floor(time / 3600), 2, '0');
+ const minutes = pad(Math.floor((time % 3600) / 60), 2, '0');
+ const seconds = pad((time % 3600) % 60, 2, '0');
return `${hours}:${minutes}:${seconds}`;
}
diff --git a/benchmark/dgram/bind-params.js b/benchmark/dgram/bind-params.js
new file mode 100644
index 00000000000000..92e9b7f85b1e12
--- /dev/null
+++ b/benchmark/dgram/bind-params.js
@@ -0,0 +1,38 @@
+'use strict';
+
+const common = require('../common.js');
+const dgram = require('dgram');
+
+const configs = {
+ n: [1e4],
+ port: ['true', 'false'],
+ address: ['true', 'false'],
+};
+
+const bench = common.createBenchmark(main, configs);
+
+function main(conf) {
+ const n = +conf.n;
+ const port = conf.port === 'true' ? 0 : undefined;
+ const address = conf.address === 'true' ? '0.0.0.0' : undefined;
+
+ if (port !== undefined && address !== undefined) {
+ bench.start();
+ for (let i = 0; i < n; i++) {
+ dgram.createSocket('udp4').bind(port, address).unref();
+ }
+ bench.end(n);
+ } else if (port !== undefined) {
+ bench.start();
+ for (let i = 0; i < n; i++) {
+ dgram.createSocket('udp4').bind(port).unref();
+ }
+ bench.end(n);
+ } else if (port === undefined && address === undefined) {
+ bench.start();
+ for (let i = 0; i < n; i++) {
+ dgram.createSocket('udp4').bind().unref();
+ }
+ bench.end(n);
+ }
+}
diff --git a/benchmark/domain/domain-fn-args.js b/benchmark/domain/domain-fn-args.js
index e9b24811c81689..20f452d67a6f9a 100644
--- a/benchmark/domain/domain-fn-args.js
+++ b/benchmark/domain/domain-fn-args.js
@@ -12,14 +12,14 @@ var gargs = [1, 2, 3];
function main(conf) {
- var args, n = +conf.n;
+ var n = +conf.n;
var myArguments = gargs.slice(0, conf.arguments);
bench.start();
bdomain.enter();
for (var i = 0; i < n; i++) {
if (myArguments.length >= 2) {
- args = Array.prototype.slice.call(myArguments, 1);
+ const args = Array.prototype.slice.call(myArguments, 1);
fn.apply(this, args);
} else {
fn.call(this);
diff --git a/benchmark/es/destructuring-bench.js b/benchmark/es/destructuring-bench.js
index 0e9b5e93f3b318..3288e009a08515 100644
--- a/benchmark/es/destructuring-bench.js
+++ b/benchmark/es/destructuring-bench.js
@@ -9,9 +9,9 @@ const bench = common.createBenchmark(main, {
});
function runSwapManual(n) {
- var i = 0, x, y, r;
+ var x, y, r;
bench.start();
- for (; i < n; i++) {
+ for (var i = 0; i < n; i++) {
x = 1, y = 2;
r = x;
x = y;
@@ -23,9 +23,9 @@ function runSwapManual(n) {
}
function runSwapDestructured(n) {
- var i = 0, x, y;
+ var x, y;
bench.start();
- for (; i < n; i++) {
+ for (var i = 0; i < n; i++) {
x = 1, y = 2;
[x, y] = [y, x];
assert.strictEqual(x, 2);
diff --git a/benchmark/fixtures/url-inputs.js b/benchmark/fixtures/url-inputs.js
new file mode 100644
index 00000000000000..7b1983f6faa590
--- /dev/null
+++ b/benchmark/fixtures/url-inputs.js
@@ -0,0 +1,30 @@
+'use strict';
+
+exports.urls = {
+ long: 'http://nodejs.org:89/docs/latest/api/foo/bar/qua/13949281/0f28b/' +
+ '/5d49/b3020/url.html#test?payload1=true&payload2=false&test=1' +
+ '&benchmark=3&foo=38.38.011.293&bar=1234834910480&test=19299&3992&' +
+ 'key=f5c65e1e98fe07e648249ad41e1cfdb0',
+ short: 'https://nodejs.org/en/blog/',
+ idn: 'http://你好你好.在线',
+ auth: 'https://user:pass@example.com/path?search=1',
+ file: 'file:///foo/bar/test/node.js',
+ ws: 'ws://localhost:9229/f46db715-70df-43ad-a359-7f9949f39868',
+ javascript: 'javascript:alert("node is awesome");',
+ percent: 'https://%E4%BD%A0/foo',
+ dot: 'https://example.org/./a/../b/./c'
+};
+
+exports.searchParams = {
+ noencode: 'foo=bar&baz=quux&xyzzy=thud',
+ multicharsep: 'foo=bar&&&&&&&&&&baz=quux&&&&&&&&&&xyzzy=thud',
+ encodefake: 'foo=%©ar&baz=%A©uux&xyzzy=%©ud',
+ encodemany: '%66%6F%6F=bar&%62%61%7A=quux&xyzzy=%74h%75d',
+ encodelast: 'foo=bar&baz=quux&xyzzy=thu%64',
+ multivalue: 'foo=bar&foo=baz&foo=quux&quuy=quuz',
+ multivaluemany: 'foo=bar&foo=baz&foo=quux&quuy=quuz&foo=abc&foo=def&' +
+ 'foo=ghi&foo=jkl&foo=mno&foo=pqr&foo=stu&foo=vwxyz',
+ manypairs: 'a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z',
+ manyblankpairs: '&&&&&&&&&&&&&&&&&&&&&&&&',
+ altspaces: 'foo+bar=baz+quux&xyzzy+thud=quuy+quuz&abc=def+ghi'
+};
diff --git a/benchmark/fs/bench-statSync.js b/benchmark/fs/bench-statSync.js
index ba1e8168b4aaf5..4bc2ecd65a3624 100644
--- a/benchmark/fs/bench-statSync.js
+++ b/benchmark/fs/bench-statSync.js
@@ -5,17 +5,35 @@ const fs = require('fs');
const bench = common.createBenchmark(main, {
n: [1e4],
- kind: ['lstatSync', 'statSync']
+ kind: ['fstatSync', 'lstatSync', 'statSync']
});
function main(conf) {
const n = conf.n >>> 0;
- const fn = fs[conf.kind];
-
- bench.start();
- for (var i = 0; i < n; i++) {
- fn(__filename);
+ var fn;
+ var i;
+ switch (conf.kind) {
+ case 'statSync':
+ case 'lstatSync':
+ fn = fs[conf.kind];
+ bench.start();
+ for (i = 0; i < n; i++) {
+ fn(__filename);
+ }
+ bench.end(n);
+ break;
+ case 'fstatSync':
+ fn = fs.fstatSync;
+ const fd = fs.openSync(__filename, 'r');
+ bench.start();
+ for (i = 0; i < n; i++) {
+ fn(fd);
+ }
+ bench.end(n);
+ fs.closeSync(fd);
+ break;
+ default:
+ throw new Error('Invalid kind argument');
}
- bench.end(n);
}
diff --git a/benchmark/os/loadavg.js b/benchmark/os/loadavg.js
new file mode 100644
index 00000000000000..6e3c57ed44b777
--- /dev/null
+++ b/benchmark/os/loadavg.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common.js');
+const loadavg = require('os').loadavg;
+
+const bench = common.createBenchmark(main, {
+ n: [5e6]
+});
+
+function main(conf) {
+ const n = +conf.n;
+
+ bench.start();
+ for (var i = 0; i < n; ++i)
+ loadavg();
+ bench.end(n);
+}
diff --git a/benchmark/process/memoryUsage.js b/benchmark/process/memoryUsage.js
new file mode 100644
index 00000000000000..d68ef339b4d10b
--- /dev/null
+++ b/benchmark/process/memoryUsage.js
@@ -0,0 +1,16 @@
+'use strict';
+
+var common = require('../common.js');
+var bench = common.createBenchmark(main, {
+ n: [1e5]
+});
+
+function main(conf) {
+ var n = +conf.n;
+
+ bench.start();
+ for (var i = 0; i < n; i++) {
+ process.memoryUsage();
+ }
+ bench.end(n);
+}
diff --git a/benchmark/querystring/querystring-parse.js b/benchmark/querystring/querystring-parse.js
index fe14d95a53f0a0..2e2ec1417bcd35 100644
--- a/benchmark/querystring/querystring-parse.js
+++ b/benchmark/querystring/querystring-parse.js
@@ -3,17 +3,7 @@ var common = require('../common.js');
var querystring = require('querystring');
var v8 = require('v8');
-var inputs = {
- noencode: 'foo=bar&baz=quux&xyzzy=thud',
- multicharsep: 'foo=bar&&&&&&&&&&baz=quux&&&&&&&&&&xyzzy=thud',
- encodefake: 'foo=%©ar&baz=%A©uux&xyzzy=%©ud',
- encodemany: '%66%6F%6F=bar&%62%61%7A=quux&xyzzy=%74h%75d',
- encodelast: 'foo=bar&baz=quux&xyzzy=thu%64',
- multivalue: 'foo=bar&foo=baz&foo=quux&quuy=quuz',
- multivaluemany: 'foo=bar&foo=baz&foo=quux&quuy=quuz&foo=abc&foo=def&' +
- 'foo=ghi&foo=jkl&foo=mno&foo=pqr&foo=stu&foo=vwxyz',
- manypairs: 'a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z'
-};
+var inputs = require('../fixtures/url-inputs.js').searchParams;
var bench = common.createBenchmark(main, {
type: Object.keys(inputs),
diff --git a/benchmark/url/legacy-vs-whatwg-url-get-prop.js b/benchmark/url/legacy-vs-whatwg-url-get-prop.js
index f703b75b16f6f7..ffc8b4995df3de 100644
--- a/benchmark/url/legacy-vs-whatwg-url-get-prop.js
+++ b/benchmark/url/legacy-vs-whatwg-url-get-prop.js
@@ -3,19 +3,7 @@ const common = require('../common.js');
const url = require('url');
const URL = url.URL;
const assert = require('assert');
-
-const inputs = {
- long: 'http://nodejs.org:89/docs/latest/api/url.html#test?' +
- 'payload1=true&payload2=false&test=1&benchmark=3&' +
- 'foo=38.38.011.293&bar=1234834910480&test=19299&3992&' +
- 'key=f5c65e1e98fe07e648249ad41e1cfdb0',
- short: 'https://nodejs.org/en/blog/',
- idn: 'http://你好你好',
- auth: 'https://user:pass@example.com/path?search=1',
- special: 'file:///foo/bar/test/node.js',
- percent: 'https://%E4%BD%A0/foo',
- dot: 'https://example.org/./a/../b/./c'
-};
+const inputs = require('../fixtures/url-inputs.js').urls;
const bench = common.createBenchmark(main, {
type: Object.keys(inputs),
diff --git a/benchmark/url/legacy-vs-whatwg-url-parse.js b/benchmark/url/legacy-vs-whatwg-url-parse.js
index 64533e67e4a46a..ec386b7b85597d 100644
--- a/benchmark/url/legacy-vs-whatwg-url-parse.js
+++ b/benchmark/url/legacy-vs-whatwg-url-parse.js
@@ -3,19 +3,7 @@ const common = require('../common.js');
const url = require('url');
const URL = url.URL;
const assert = require('assert');
-
-const inputs = {
- long: 'http://nodejs.org:89/docs/latest/api/url.html#test?' +
- 'payload1=true&payload2=false&test=1&benchmark=3&' +
- 'foo=38.38.011.293&bar=1234834910480&test=19299&3992&' +
- 'key=f5c65e1e98fe07e648249ad41e1cfdb0',
- short: 'https://nodejs.org/en/blog/',
- idn: 'http://你好你好',
- auth: 'https://user:pass@example.com/path?search=1',
- special: 'file:///foo/bar/test/node.js',
- percent: 'https://%E4%BD%A0/foo',
- dot: 'https://example.org/./a/../b/./c'
-};
+const inputs = require('../fixtures/url-inputs.js').urls;
const bench = common.createBenchmark(main, {
type: Object.keys(inputs),
diff --git a/benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js b/benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js
index e76f2dd837bb97..86714df6c196a7 100644
--- a/benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js
+++ b/benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js
@@ -2,18 +2,7 @@
const common = require('../common.js');
const { URLSearchParams } = require('url');
const querystring = require('querystring');
-
-const inputs = {
- noencode: 'foo=bar&baz=quux&xyzzy=thud',
- encodemany: '%66%6F%6F=bar&%62%61%7A=quux&xyzzy=%74h%75d',
- encodefake: 'foo=%©ar&baz=%A©uux&xyzzy=%©ud',
- encodelast: 'foo=bar&baz=quux&xyzzy=thu%64',
- multicharsep: 'foo=bar&&&&&&&&&&baz=quux&&&&&&&&&&xyzzy=thud',
- multivalue: 'foo=bar&foo=baz&foo=quux&quuy=quuz',
- multivaluemany: 'foo=bar&foo=baz&foo=quux&quuy=quuz&foo=abc&foo=def&' +
- 'foo=ghi&foo=jkl&foo=mno&foo=pqr&foo=stu&foo=vwxyz',
- manypairs: 'a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z'
-};
+const inputs = require('../fixtures/url-inputs.js').searchParams;
const bench = common.createBenchmark(main, {
type: Object.keys(inputs),
diff --git a/benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js b/benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js
index ef3160eccd49e6..7e56b5fba6e4f8 100644
--- a/benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js
+++ b/benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js
@@ -2,18 +2,7 @@
const common = require('../common.js');
const { URLSearchParams } = require('url');
const querystring = require('querystring');
-
-const inputs = {
- noencode: 'foo=bar&baz=quux&xyzzy=thud',
- encodemany: '%66%6F%6F=bar&%62%61%7A=quux&xyzzy=%74h%75d',
- encodefake: 'foo=%©ar&baz=%A©uux&xyzzy=%©ud',
- encodelast: 'foo=bar&baz=quux&xyzzy=thu%64',
- multicharsep: 'foo=bar&&&&&&&&&&baz=quux&&&&&&&&&&xyzzy=thud',
- multivalue: 'foo=bar&foo=baz&foo=quux&quuy=quuz',
- multivaluemany: 'foo=bar&foo=baz&foo=quux&quuy=quuz&foo=abc&foo=def&' +
- 'foo=ghi&foo=jkl&foo=mno&foo=pqr&foo=stu&foo=vwxyz',
- manypairs: 'a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z'
-};
+const inputs = require('../fixtures/url-inputs.js').searchParams;
const bench = common.createBenchmark(main, {
type: Object.keys(inputs),
diff --git a/benchmark/url/legacy-vs-whatwg-url-serialize.js b/benchmark/url/legacy-vs-whatwg-url-serialize.js
index c0b7f5a6ce1565..911e79794b84fb 100644
--- a/benchmark/url/legacy-vs-whatwg-url-serialize.js
+++ b/benchmark/url/legacy-vs-whatwg-url-serialize.js
@@ -3,19 +3,7 @@ const common = require('../common.js');
const url = require('url');
const URL = url.URL;
const assert = require('assert');
-
-const inputs = {
- long: 'http://nodejs.org:89/docs/latest/api/url.html#test?' +
- 'payload1=true&payload2=false&test=1&benchmark=3&' +
- 'foo=38.38.011.293&bar=1234834910480&test=19299&3992&' +
- 'key=f5c65e1e98fe07e648249ad41e1cfdb0',
- short: 'https://nodejs.org/en/blog/',
- idn: 'http://你好你好',
- auth: 'https://user:pass@example.com/path?search=1',
- special: 'file:///foo/bar/test/node.js',
- percent: 'https://%E4%BD%A0/foo',
- dot: 'https://example.org/./a/../b/./c'
-};
+const inputs = require('../fixtures/url-inputs.js').urls;
const bench = common.createBenchmark(main, {
type: Object.keys(inputs),
diff --git a/benchmark/url/url-format.js b/benchmark/url/url-format.js
index 3f7df8a0bc4536..886958406b91c5 100644
--- a/benchmark/url/url-format.js
+++ b/benchmark/url/url-format.js
@@ -3,8 +3,13 @@ const common = require('../common.js');
const url = require('url');
const v8 = require('v8');
+const inputs = {
+ slashes: {slashes: true, host: 'localhost'},
+ file: {protocol: 'file:', pathname: '/foo'},
+};
+
const bench = common.createBenchmark(main, {
- type: 'one two'.split(' '),
+ type: Object.keys(inputs),
n: [25e6]
});
@@ -12,10 +17,6 @@ function main(conf) {
const type = conf.type;
const n = conf.n | 0;
- const inputs = {
- one: {slashes: true, host: 'localhost'},
- two: {protocol: 'file:', pathname: '/foo'},
- };
const input = inputs[type] || '';
// Force-optimize url.format() so that the benchmark doesn't get
diff --git a/benchmark/url/url-parse.js b/benchmark/url/url-parse.js
deleted file mode 100644
index 89679548b8f193..00000000000000
--- a/benchmark/url/url-parse.js
+++ /dev/null
@@ -1,37 +0,0 @@
-'use strict';
-var common = require('../common.js');
-var url = require('url');
-var v8 = require('v8');
-
-var bench = common.createBenchmark(main, {
- type: 'one two three four five six'.split(' '),
- n: [25e4]
-});
-
-function main(conf) {
- var type = conf.type;
- var n = conf.n | 0;
-
- var inputs = {
- one: 'http://nodejs.org/docs/latest/api/url.html#url_url_format_urlobj',
- two: 'http://blog.nodejs.org/',
- three: 'https://encrypted.google.com/search?q=url&q=site:npmjs.org&hl=en',
- four: 'javascript:alert("node is awesome");',
- five: 'some.ran/dom/url.thing?oh=yes#whoo',
- six: 'https://user:pass@example.com/',
- };
- var input = inputs[type] || '';
-
- // Force-optimize url.parse() so that the benchmark doesn't get
- // disrupted by the optimizer kicking in halfway through.
- for (var name in inputs)
- url.parse(inputs[name]);
-
- v8.setFlagsFromString('--allow_natives_syntax');
- eval('%OptimizeFunctionOnNextCall(url.parse)');
-
- bench.start();
- for (var i = 0; i < n; i += 1)
- url.parse(input);
- bench.end(n);
-}
diff --git a/benchmark/url/url-resolve.js b/benchmark/url/url-resolve.js
index 8372132e4d269e..4335511ca6d2df 100644
--- a/benchmark/url/url-resolve.js
+++ b/benchmark/url/url-resolve.js
@@ -1,36 +1,28 @@
'use strict';
-var common = require('../common.js');
-var url = require('url');
-var v8 = require('v8');
+const common = require('../common.js');
+const url = require('url');
+const v8 = require('v8');
+const hrefs = require('../fixtures/url-inputs.js').urls;
+hrefs.noscheme = 'some.ran/dom/url.thing?oh=yes#whoo';
-var hrefs = [
- 'http://example.com/',
- 'http://nodejs.org/docs/latest/api/url.html#url_url_format_urlobj',
- 'http://blog.nodejs.org/',
- 'https://encrypted.google.com/search?q=url&q=site:npmjs.org&hl=en',
- 'javascript:alert("node is awesome");',
- 'some.ran/dom/url.thing?oh=yes#whoo'
-];
+const paths = {
+ 'up': '../../../../../etc/passwd',
+ 'sibling': '../foo/bar?baz=boom',
+ 'foo/bar': 'foo/bar',
+ 'withscheme': 'http://nodejs.org',
+ 'down': './foo/bar?baz'
+};
-
-var paths = [
- '../../../../../etc/passwd',
- '../foo/bar?baz=boom',
- 'foo/bar',
- 'http://nodejs.org',
- './foo/bar?baz'
-];
-
-var bench = common.createBenchmark(main, {
+const bench = common.createBenchmark(main, {
href: Object.keys(hrefs),
path: Object.keys(paths),
n: [1e5]
});
function main(conf) {
- var n = conf.n | 0;
- var href = hrefs[conf.href];
- var path = paths[conf.path];
+ const n = conf.n | 0;
+ const href = hrefs[conf.href];
+ const path = paths[conf.path];
// Force-optimize url.resolve() so that the benchmark doesn't get
// disrupted by the optimizer kicking in halfway through.
diff --git a/benchmark/url/url-searchparams-sort.js b/benchmark/url/url-searchparams-sort.js
new file mode 100644
index 00000000000000..677ce511cf3ea2
--- /dev/null
+++ b/benchmark/url/url-searchparams-sort.js
@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common.js');
+const URLSearchParams = require('url').URLSearchParams;
+
+const inputs = {
+ empty: '',
+ sorted: 'a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z',
+ almostsorted: 'a&b&c&d&e&f&g&i&h&j&k&l&m&n&o&p&q&r&s&t&u&w&v&x&y&z',
+ reversed: 'z&y&x&w&v&u&t&s&r&q&p&o&n&m&l&k&j&i&h&g&f&e&d&c&b&a',
+ random: 'm&t&d&c&z&v&a&n&p&y&u&o&h&l&f&j&e&q&b&i&s&x&k&w&r&g',
+ // 8 parameters
+ short: 'm&t&d&c&z&v&a&n',
+ // 88 parameters
+ long: 'g&r&t&h&s&r&d&w&b&n&h&k&x&m&k&h&o&e&x&c&c&g&e&b&p&p&s&n&j&b&y&z&' +
+ 'u&l&o&r&w&a&u&l&m&f&j&q&p&f&e&y&e&n&e&l&m&w&u&w&t&n&t&q&v&y&c&o&' +
+ 'k&f&j&i&l&m&g&j&d&i&z&q&p&x&q&q&d&n&y&w&g&i&v&r'
+};
+
+function getParams(str) {
+ const out = [];
+ for (const key of str.split('&')) {
+ out.push(key, '');
+ }
+ return out;
+}
+
+const bench = common.createBenchmark(main, {
+ type: Object.keys(inputs),
+ n: [1e6]
+}, {
+ flags: ['--expose-internals']
+});
+
+function main(conf) {
+ const searchParams = require('internal/url').searchParamsSymbol;
+ const input = inputs[conf.type];
+ const n = conf.n | 0;
+ const params = new URLSearchParams();
+ const array = getParams(input);
+
+ var i;
+ bench.start();
+ for (i = 0; i < n; i++) {
+ params[searchParams] = array.slice();
+ params.sort();
+ }
+ bench.end(n);
+}
diff --git a/benchmark/url/whatwg-url-idna.js b/benchmark/url/whatwg-url-idna.js
new file mode 100644
index 00000000000000..41b4c639de97b6
--- /dev/null
+++ b/benchmark/url/whatwg-url-idna.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common.js');
+const { domainToASCII, domainToUnicode } = require('url');
+
+const inputs = {
+ empty: {
+ ascii: '',
+ unicode: ''
+ },
+ none: {
+ ascii: 'passports',
+ unicode: 'passports'
+ },
+ some: {
+ ascii: 'Paßstraße',
+ unicode: 'xn--Pastrae-1vae'
+ },
+ all: {
+ ascii: '他们不说中文',
+ unicode: 'xn--ihqwczyycu19kkg2c'
+ },
+ nonstring: {
+ ascii: { toString() { return ''; } },
+ unicode: { toString() { return ''; } }
+ }
+};
+
+const bench = common.createBenchmark(main, {
+ input: Object.keys(inputs),
+ to: ['ascii', 'unicode'],
+ n: [5e6]
+});
+
+function main(conf) {
+ const n = conf.n | 0;
+ const to = conf.to;
+ const input = inputs[conf.input][to];
+ const method = to === 'ascii' ? domainToASCII : domainToUnicode;
+
+ common.v8ForceOptimization(method, input);
+
+ bench.start();
+ for (var i = 0; i < n; i++) {
+ method(input);
+ }
+ bench.end(n);
+}
diff --git a/benchmark/url/whatwg-url-properties.js b/benchmark/url/whatwg-url-properties.js
index 375939c601d363..9bdc9778a8c922 100644
--- a/benchmark/url/whatwg-url-properties.js
+++ b/benchmark/url/whatwg-url-properties.js
@@ -1,16 +1,11 @@
'use strict';
+const common = require('../common.js');
+const URL = require('url').URL;
+const inputs = require('../fixtures/url-inputs.js').urls;
-var common = require('../common.js');
-var URL = require('url').URL;
-
-var bench = common.createBenchmark(main, {
- url: [
- 'http://example.com/',
- 'https://encrypted.google.com/search?q=url&q=site:npmjs.org&hl=en',
- 'javascript:alert("node is awesome");',
- 'http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test'
- ],
- prop: ['toString', 'href', 'origin', 'protocol',
+const bench = common.createBenchmark(main, {
+ input: Object.keys(inputs),
+ prop: ['href', 'origin', 'protocol',
'username', 'password', 'host', 'hostname', 'port',
'pathname', 'search', 'searchParams', 'hash'],
n: [1e4]
@@ -34,14 +29,6 @@ function get(n, url, prop) {
bench.end(n);
}
-function stringify(n, url, prop) {
- bench.start();
- for (var i = 0; i < n; i += 1) {
- url.toString();
- }
- bench.end(n);
-}
-
const alternatives = {
href: 'http://user:pass@foo.bar.com:21/aaa/zzz?l=25#test',
protocol: 'https:',
@@ -61,7 +48,8 @@ function getAlternative(prop) {
function main(conf) {
const n = conf.n | 0;
- const url = new URL(conf.url);
+ const input = inputs[conf.input];
+ const url = new URL(input);
const prop = conf.prop;
switch (prop) {
@@ -74,17 +62,13 @@ function main(conf) {
case 'pathname':
case 'search':
case 'hash':
+ case 'href':
setAndGet(n, url, prop, getAlternative(prop));
break;
- // TODO: move href to the first group when the setter lands.
- case 'href':
case 'origin':
case 'searchParams':
get(n, url, prop);
break;
- case 'toString':
- stringify(n, url);
- break;
default:
throw new Error('Unknown prop');
}
diff --git a/common.gypi b/common.gypi
index 0fa36197be97a9..a52915d59a7ac4 100644
--- a/common.gypi
+++ b/common.gypi
@@ -42,12 +42,19 @@
'os_posix': 1,
'v8_postmortem_support%': 'true',
}],
- ['GENERATOR == "ninja" or OS== "mac"', {
+ ['OS== "mac"', {
'OBJ_DIR': '<(PRODUCT_DIR)/obj',
'V8_BASE': '<(PRODUCT_DIR)/libv8_base.a',
}, {
- 'OBJ_DIR': '<(PRODUCT_DIR)/obj.target',
- 'V8_BASE': '<(PRODUCT_DIR)/obj.target/deps/v8/src/libv8_base.a',
+ 'conditions': [
+ ['GENERATOR=="ninja"', {
+ 'OBJ_DIR': '<(PRODUCT_DIR)/obj',
+ 'V8_BASE': '<(PRODUCT_DIR)/obj/deps/v8/src/libv8_base.a',
+ }, {
+ 'OBJ_DIR': '<(PRODUCT_DIR)/obj.target',
+ 'V8_BASE': '<(PRODUCT_DIR)/obj.target/deps/v8/src/libv8_base.a',
+ }],
+ ],
}],
['openssl_fips != ""', {
'OPENSSL_PRODUCT': 'libcrypto.a',
diff --git a/configure b/configure
index d0b50f80f9f07d..50078df43a9ed5 100755
--- a/configure
+++ b/configure
@@ -2,7 +2,16 @@
import sys
if sys.version_info[0] != 2 or sys.version_info[1] not in (6, 7):
- sys.stdout.write("Please use either Python 2.6 or 2.7\n")
+ sys.stderr.write('Please use either Python 2.6 or 2.7')
+
+ from distutils.spawn import find_executable as which
+ python2 = which('python2') or which('python2.6') or which('python2.7')
+
+ if python2:
+ sys.stderr.write(':\n\n')
+ sys.stderr.write(' ' + python2 + ' ' + ' '.join(sys.argv))
+
+ sys.stderr.write('\n')
sys.exit(1)
import errno
diff --git a/deps/v8/include/v8-version.h b/deps/v8/include/v8-version.h
index b216cf04c30a00..f2c738770a43b4 100644
--- a/deps/v8/include/v8-version.h
+++ b/deps/v8/include/v8-version.h
@@ -11,7 +11,7 @@
#define V8_MAJOR_VERSION 5
#define V8_MINOR_VERSION 5
#define V8_BUILD_NUMBER 372
-#define V8_PATCH_LEVEL 40
+#define V8_PATCH_LEVEL 41
// Use 1 for candidates and 0 otherwise.
// (Boolean macro values are not supported by all preprocessors.)
diff --git a/deps/v8/src/compiler/ppc/instruction-selector-ppc.cc b/deps/v8/src/compiler/ppc/instruction-selector-ppc.cc
index a2eb7b8f22c9b8..1a3523745b9fae 100644
--- a/deps/v8/src/compiler/ppc/instruction-selector-ppc.cc
+++ b/deps/v8/src/compiler/ppc/instruction-selector-ppc.cc
@@ -245,7 +245,7 @@ void InstructionSelector::VisitStore(Node* node) {
MachineRepresentation rep = store_rep.representation();
if (write_barrier_kind != kNoWriteBarrier) {
- DCHECK_EQ(MachineRepresentation::kTagged, rep);
+ DCHECK(CanBeTaggedPointer(rep));
AddressingMode addressing_mode;
InstructionOperand inputs[3];
size_t input_count = 0;
diff --git a/deps/v8/src/compiler/s390/instruction-selector-s390.cc b/deps/v8/src/compiler/s390/instruction-selector-s390.cc
index f1aa332a493ce4..c4cd3c92993ac4 100644
--- a/deps/v8/src/compiler/s390/instruction-selector-s390.cc
+++ b/deps/v8/src/compiler/s390/instruction-selector-s390.cc
@@ -343,7 +343,7 @@ void InstructionSelector::VisitStore(Node* node) {
MachineRepresentation rep = store_rep.representation();
if (write_barrier_kind != kNoWriteBarrier) {
- DCHECK_EQ(MachineRepresentation::kTagged, rep);
+ DCHECK(CanBeTaggedPointer(rep));
AddressingMode addressing_mode;
InstructionOperand inputs[3];
size_t input_count = 0;
diff --git a/doc/STYLE_GUIDE.md b/doc/STYLE_GUIDE.md
new file mode 100644
index 00000000000000..10f26421a4ceb5
--- /dev/null
+++ b/doc/STYLE_GUIDE.md
@@ -0,0 +1,63 @@
+# Style Guide
+
+* Documents are written in markdown files.
+* Those files should be written in **`lowercase-with-dashes.md`.**
+ * Underscores in filenames are allowed only when they are present in the
+ topic the document will describe (e.g., `child_process`.)
+ * Filenames should be **lowercase**.
+ * Some files, such as top-level markdown files, are exceptions.
+ * Older files may use the `.markdown` extension. These may be ported to `.md`
+ at will. **Prefer `.md` for all new documents.**
+* Documents should be word-wrapped at 80 characters.
+* The formatting described in `.editorconfig` is preferred.
+ * A [plugin][] is available for some editors to automatically apply these rules.
+* Mechanical issues, like spelling and grammar, should be identified by tools,
+ insofar as is possible. If not caught by a tool, they should be pointed out by
+ human reviewers.
+* American English spelling is preferred. "Capitalize" vs. "Capitalise",
+ "color" vs. "colour", etc.
+* Though controversial, the [Oxford comma][] is preferred for clarity's sake.
+* Generally avoid personal pronouns in reference documentation ("I", "you",
+ "we".)
+ * Pronouns are acceptable in more colloquial documentation, like guides.
+ * Use **gender-neutral pronouns** and **mass nouns**. Non-comprehensive
+ examples:
+ * **OK**: "they", "their", "them", "folks", "people", "developers", "cats"
+ * **NOT OK**: "his", "hers", "him", "her", "guys", "dudes".
+* When combining wrapping elements (parentheses and quotes), terminal
+ punctuation should be placed:
+ * Inside the wrapping element if the wrapping element contains a complete
+ clause — a subject, verb, and an object.
+ * Outside of the wrapping element if the wrapping element contains only a
+ fragment of a clause.
+* Place end-of-sentence punctuation inside wrapping elements — periods go
+ inside parentheses and quotes, not after.
+* Documents must start with a level-one heading. An example document will be
+ linked here eventually.
+* Prefer affixing links to inlining links — prefer `[a link][]` to
+ `[a link](http://example.com)`.
+* When documenting APIs, note the version the API was introduced in at
+ the end of the section. If an API has been deprecated, also note the first
+ version that the API appeared deprecated in.
+* When using dashes, use emdashes ("—", Ctrl+Alt+"-" on OSX) surrounded by
+ spaces, per the New York Times usage.
+* Including assets:
+ * If you wish to add an illustration or full program, add it to the
+ appropriate sub-directory in the `assets/` dir.
+ * Link to it like so: `[Asset](/assets/{subdir}/{filename})` for file-based
+ assets, and `` for image-based assets.
+ * For illustrations, prefer SVG to other assets. When SVG is not feasible,
+ please keep a close eye on the filesize of the asset you're introducing.
+* For code blocks:
+ * Use language aware fences. ("```js")
+ * Code need not be complete — treat code blocks as an illustration or aid to
+ your point, not as complete running programs. If a complete running program
+ is necessary, include it as an asset in `assets/code-examples` and link to
+ it.
+* When using underscores, asterisks and backticks please use proper escaping (**\\\_**, **\\\*** and **\\\`** instead of **\_**, **\*** and **\`**)
+* References to constructor functions should use PascalCase
+* References to constructor instances should be camelCased
+* References to methods should be used with parenthesis: `socket.end()` instead of `socket.end`
+
+[plugin]: http://editorconfig.org/#download
+[Oxford comma]: https://en.wikipedia.org/wiki/Serial_comma
diff --git a/doc/api/_toc.md b/doc/api/_toc.md
index 2527ad84e2e360..345e8e393145fd 100644
--- a/doc/api/_toc.md
+++ b/doc/api/_toc.md
@@ -35,6 +35,7 @@
* [String Decoder](string_decoder.html)
* [Timers](timers.html)
* [TLS/SSL](tls.html)
+* [Tracing](tracing.html)
* [TTY](tty.html)
* [UDP/Datagram](dgram.html)
* [URL](url.html)
diff --git a/doc/api/all.md b/doc/api/all.md
index 93c7a300a162e9..f65b24587511a1 100644
--- a/doc/api/all.md
+++ b/doc/api/all.md
@@ -1,15 +1,15 @@
@include documentation
@include synopsis
-@include addons
@include assert
@include buffer
+@include addons
@include child_process
@include cluster
@include cli
@include console
@include crypto
@include debugger
-@include dgram
+@include deprecations
@include dns
@include domain
@include errors
@@ -31,7 +31,9 @@
@include string_decoder
@include timers
@include tls
+@include tracing
@include tty
+@include dgram
@include url
@include util
@include v8
diff --git a/doc/api/assert.md b/doc/api/assert.md
index 8c4279f5d03d22..8478c235e783b6 100644
--- a/doc/api/assert.md
+++ b/doc/api/assert.md
@@ -1,6 +1,6 @@
# Assert
-> Stability: 3 - Locked
+> Stability: 2 - Stable
The `assert` module provides a simple set of assertion tests that can be used to
test invariants.
@@ -9,6 +9,8 @@ test invariants.
+* `value` {any}
+* `message` {any}
An alias of [`assert.ok()`][] .
@@ -30,7 +32,20 @@ assert(false, 'it\'s false');
## assert.deepEqual(actual, expected[, message])
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
Tests for deep equality between the `actual` and `expected` parameters.
Primitive values are compared with the equal comparison operator ( `==` ).
@@ -91,7 +106,20 @@ parameter is undefined, a default error message is assigned.
## assert.deepStrictEqual(actual, expected[, message])
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
Generally identical to `assert.deepEqual()` with two exceptions. First,
primitive values are compared using the strict equality operator ( `===` ).
@@ -115,7 +143,17 @@ parameter is undefined, a default error message is assigned.
## assert.doesNotThrow(block[, error][, message])
+* `block` {Function}
+* `error` {RegExp|Function}
+* `message` {any}
Asserts that the function `block` does not throw an error. See
[`assert.throws()`][] for more details.
@@ -171,6 +209,9 @@ assert.doesNotThrow(
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
Tests shallow, coercive equality between the `actual` and `expected` parameters
using the equal comparison operator ( `==` ).
@@ -197,6 +238,10 @@ parameter is undefined, a default error message is assigned.
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
+* `operator` {String}
Throws an `AssertionError`. If `message` is falsy, the error message is set as
the values of `actual` and `expected` separated by the provided `operator`.
@@ -216,6 +261,7 @@ assert.fail(1, 2, 'whoops', '>');
+* `value` {any}
Throws `value` if `value` is truthy. This is useful when testing the `error`
argument in callbacks.
@@ -237,6 +283,9 @@ assert.ifError(new Error());
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
Tests for any deep inequality. Opposite of [`assert.deepEqual()`][].
@@ -281,6 +330,9 @@ parameter is undefined, a default error message is assigned.
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
Tests for deep strict inequality. Opposite of [`assert.deepStrictEqual()`][].
@@ -302,6 +354,9 @@ the `message` parameter is undefined, a default error message is assigned.
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
Tests shallow, coercive inequality with the not equal comparison operator
( `!=` ).
@@ -327,6 +382,9 @@ parameter is undefined, a default error message is assigned.
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
Tests strict inequality as determined by the strict not equal operator
( `!==` ).
@@ -352,6 +410,8 @@ If the values are strictly equal, an `AssertionError` is thrown with a
+* `value` {any}
+* `message` {any}
Tests if `value` is truthy. It is equivalent to
`assert.equal(!!value, true, message)`.
@@ -379,6 +439,9 @@ assert.ok(false, 'it\'s false');
+* `actual` {any}
+* `expected` {any}
+* `message` {any}
Tests strict equality as determined by the strict equality operator ( `===` ).
@@ -402,7 +465,14 @@ If the values are not strictly equal, an `AssertionError` is thrown with a
## assert.throws(block[, error][, message])
+* `block` {Function}
+* `error` {RegExp|Function}
+* `message` {any}
Expects the function `block` to throw an error.
diff --git a/doc/api/buffer.md b/doc/api/buffer.md
index 14212d3ed60d03..9aa7d0d9cbbbda 100644
--- a/doc/api/buffer.md
+++ b/doc/api/buffer.md
@@ -138,6 +138,15 @@ extra care *must* be taken in order to avoid introducing security
vulnerabilities into an application.
## Buffers and Character Encodings
+
`Buffer` instances are commonly used to represent sequences of encoded characters
such as UTF-8, UCS2, Base64 or even Hex-encoded data. It is possible to
@@ -188,6 +197,12 @@ that the server actually returned win-1252-encoded data, and using `'latin1'`
encoding may incorrectly decode the characters.
## Buffers and TypedArray
+
`Buffer` instances are also [`Uint8Array`] instances. However, there are subtle
incompatibilities with the TypedArray specification in ECMAScript 2015.
@@ -298,6 +313,13 @@ It can be constructed in a variety of ways.
### new Buffer(array)
> Stability: 0 - Deprecated: Use [`Buffer.from(array)`] instead.
@@ -313,35 +335,20 @@ Example:
const buf = new Buffer([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
```
-### new Buffer(buffer)
-
-
-> Stability: 0 - Deprecated: Use [`Buffer.from(buffer)`] instead.
-
-* `buffer` {Buffer} An existing `Buffer` to copy data from
-
-Copies the passed `buffer` data onto a new `Buffer` instance.
-
-Example:
-
-```js
-const buf1 = new Buffer('buffer');
-const buf2 = new Buffer(buf1);
-
-buf1[0] = 0x61;
-
-// Prints: auffer
-console.log(buf1.toString());
-
-// Prints: buffer
-console.log(buf2.toString());
-```
-
### new Buffer(arrayBuffer[, byteOffset [, length]])
> Stability: 0 - Deprecated: Use
@@ -383,9 +390,49 @@ arr[1] = 6000;
console.log(buf);
```
+### new Buffer(buffer)
+
+
+> Stability: 0 - Deprecated: Use [`Buffer.from(buffer)`] instead.
+
+* `buffer` {Buffer} An existing `Buffer` to copy data from
+
+Copies the passed `buffer` data onto a new `Buffer` instance.
+
+Example:
+
+```js
+const buf1 = new Buffer('buffer');
+const buf2 = new Buffer(buf1);
+
+buf1[0] = 0x61;
+
+// Prints: auffer
+console.log(buf1.toString());
+
+// Prints: buffer
+console.log(buf2.toString());
+```
+
### new Buffer(size)
> Stability: 0 - Deprecated: Use [`Buffer.alloc()`] instead (also see
@@ -419,6 +466,13 @@ console.log(buf);
### new Buffer(string[, encoding])
> Stability: 0 - Deprecated:
@@ -508,6 +562,10 @@ A `TypeError` will be thrown if `size` is not a number.
### Class Method: Buffer.allocUnsafe(size)
* `size` {Integer} The desired length of the new `Buffer`
@@ -606,6 +664,14 @@ A `TypeError` will be thrown if `size` is not a number.
### Class Method: Buffer.byteLength(string[, encoding])
* `string` {String | Buffer | TypedArray | DataView | ArrayBuffer} A value to
@@ -886,6 +952,10 @@ console.log(buf.toString('ascii'));
### buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])
* `target` {Buffer} A `Buffer` to compare to
@@ -964,7 +1034,7 @@ A `RangeError` will be thrown if: `targetStart < 0`, `sourceStart < 0`,
added: v0.1.90
-->
-* `target` {Buffer} A `Buffer` to copy into.
+* `target` {Buffer|Uint8Array} A `Buffer` or [`Uint8Array`] to copy into.
* `targetStart` {Integer} The offset within `target` at which to begin
copying to. **Default:** `0`
* `sourceStart` {Integer} The offset within `buf` at which to begin copying from.
@@ -1066,6 +1136,10 @@ console.log(buf1.equals(buf3));
### buf.fill(value[, offset[, end]][, encoding])
* `value` {String | Buffer | Integer} The value to fill `buf` with
@@ -1100,9 +1174,55 @@ Example: Fill a `Buffer` with a two-byte character
console.log(Buffer.allocUnsafe(3).fill('\u0222'));
```
+### buf.includes(value[, byteOffset][, encoding])
+
+
+* `value` {String | Buffer | Integer} What to search for
+* `byteOffset` {Integer} Where to begin searching in `buf`. **Default:** `0`
+* `encoding` {String} If `value` is a string, this is its encoding.
+ **Default:** `'utf8'`
+* Returns: {Boolean} `true` if `value` was found in `buf`, `false` otherwise
+
+Equivalent to [`buf.indexOf() !== -1`][`buf.indexOf()`].
+
+Examples:
+
+```js
+const buf = Buffer.from('this is a buffer');
+
+// Prints: true
+console.log(buf.includes('this'));
+
+// Prints: true
+console.log(buf.includes('is'));
+
+// Prints: true
+console.log(buf.includes(Buffer.from('a buffer')));
+
+// Prints: true
+// (97 is the decimal ASCII value for 'a')
+console.log(buf.includes(97));
+
+// Prints: false
+console.log(buf.includes(Buffer.from('a buffer example')));
+
+// Prints: true
+console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
+
+// Prints: false
+console.log(buf.includes('this', 4));
+```
+
### buf.indexOf(value[, byteOffset][, encoding])
* `value` {String | Buffer | Integer} What to search for
@@ -1179,47 +1299,6 @@ console.log(b.indexOf('b', null));
console.log(b.indexOf('b', []));
```
-### buf.includes(value[, byteOffset][, encoding])
-
-
-* `value` {String | Buffer | Integer} What to search for
-* `byteOffset` {Integer} Where to begin searching in `buf`. **Default:** `0`
-* `encoding` {String} If `value` is a string, this is its encoding.
- **Default:** `'utf8'`
-* Returns: {Boolean} `true` if `value` was found in `buf`, `false` otherwise
-
-Equivalent to [`buf.indexOf() !== -1`][`buf.indexOf()`].
-
-Examples:
-
-```js
-const buf = Buffer.from('this is a buffer');
-
-// Prints: true
-console.log(buf.includes('this'));
-
-// Prints: true
-console.log(buf.includes('is'));
-
-// Prints: true
-console.log(buf.includes(Buffer.from('a buffer')));
-
-// Prints: true
-// (97 is the decimal ASCII value for 'a')
-console.log(buf.includes(97));
-
-// Prints: false
-console.log(buf.includes(Buffer.from('a buffer example')));
-
-// Prints: true
-console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
-
-// Prints: false
-console.log(buf.includes('this', 4));
-```
-
### buf.keys()
* `start` {Integer} Where the new `Buffer` will start. **Default:** `0`
@@ -1859,6 +1947,35 @@ buf2.swap64();
Note that JavaScript cannot encode 64-bit integers. This method is intended
for working with 64-bit floats.
+### buf.toJSON()
+
+
+* Returns: {Object}
+
+Returns a JSON representation of `buf`. [`JSON.stringify()`] implicitly calls
+this function when stringifying a `Buffer` instance.
+
+Example:
+
+```js
+const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
+const json = JSON.stringify(buf);
+
+// Prints: {"type":"Buffer","data":[1,2,3,4,5]}
+console.log(json);
+
+const copy = JSON.parse(json, (key, value) => {
+ return value && value.type === 'Buffer'
+ ? Buffer.from(value.data)
+ : value;
+});
+
+// Prints:
+console.log(copy);
+```
+
### buf.toString([encoding[, start[, end]]])
-
-* Returns: {Object}
-
-Returns a JSON representation of `buf`. [`JSON.stringify()`] implicitly calls
-this function when stringifying a `Buffer` instance.
-
-Example:
-
-```js
-const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
-const json = JSON.stringify(buf);
-
-// Prints: {"type":"Buffer","data":[1,2,3,4,5]}
-console.log(json);
-
-const copy = JSON.parse(json, (key, value) => {
- return value && value.type === 'Buffer'
- ? Buffer.from(value.data)
- : value;
-});
-
-// Prints:
-console.log(copy);
-```
-
### buf.values()
* `modulePath` {String} The module to run in the child
@@ -302,6 +306,13 @@ not clone the current process.*
### child_process.spawn(command[, args][, options])
* `command` {String} The command to run
@@ -485,6 +496,10 @@ child.unref();
#### options.stdio
The `options.stdio` option is used to configure the pipes that are established
@@ -554,9 +569,9 @@ spawn('prg', [], { stdio: ['pipe', null, null, null, 'pipe'] });
*It is worth noting that when an IPC channel is established between the
parent and child processes, and the child is a Node.js process, the child
is launched with the IPC channel unreferenced (using `unref()`) until the
-child registers an event handler for the [`process.on('disconnect')`][] event.
-This allows the child to exit normally without the process being held open
-by the open IPC channel.*
+child registers an event handler for the [`process.on('disconnect')`][] event
+or the [`process.on('message')`][] event.This allows the child to exit normally
+without the process being held open by the open IPC channel.*
See also: [`child_process.exec()`][] and [`child_process.fork()`][]
@@ -574,6 +589,10 @@ configuration at startup.
### child_process.execFileSync(file[, args][, options])
* `file` {String} The name or path of the executable file to run
@@ -660,6 +679,13 @@ execution.**
### child_process.spawnSync(command[, args][, options])
* `command` {String} The command to run
@@ -911,6 +937,17 @@ grep.stdin.end();
### child.send(message[, sendHandle[, options]][, callback])
* `message` {Object}
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 809bd326a6273c..538b1e06afdb12 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -43,6 +43,10 @@ The output of this option is less detailed than this document.
### `-e`, `--eval "script"`
Evaluate the following argument as JavaScript. The modules which are
@@ -52,6 +56,10 @@ predefined in the REPL can also be used in `script`.
### `-p`, `--print "script"`
Identical to `-e` but prints the result.
@@ -59,7 +67,9 @@ Identical to `-e` but prints the result.
### `-c`, `--check`
Syntax check the script without executing.
@@ -129,6 +139,20 @@ added: v2.1.0
Prints a stack trace whenever synchronous I/O is detected after the first turn
of the event loop.
+### `--trace-events-enabled`
+
+
+Enables the collection of trace event tracing information.
+
+### `--trace-event-categories`
+
+
+A comma separated list of categories that should be traced when trace event
+tracing is enabled using `--trace-events-enabled`.
### `--zero-fill-buffers`
+
+Load an OpenSSL configuration file on startup. Among other uses, this can be
+used to enable FIPS-compliant crypto if Node.js is built with `./configure
+\-\-openssl\-fips`.
+
+If the [`--openssl-config`][] command line option is used, the environment
+variable is ignored.
+
### `SSL_CERT_DIR=dir`
+
If `--use-openssl-ca` is enabled, this overrides and sets OpenSSL's directory
containing trusted certificates.
@@ -373,6 +412,9 @@ evironment variable will be inherited by any child processes, and if they use
OpenSSL, it may cause them to trust the same CAs as node.
### `SSL_CERT_FILE=file`
+
If `--use-openssl-ca` is enabled, this overrides and sets OpenSSL's file
containing trusted certificates.
@@ -386,3 +428,4 @@ OpenSSL, it may cause them to trust the same CAs as node.
[debugger]: debugger.html
[REPL]: repl.html
[SlowBuffer]: buffer.html#buffer_class_slowbuffer
+[`--openssl-config`]: #cli_openssl_config_file
diff --git a/doc/api/cluster.md b/doc/api/cluster.md
index 01a2aaf6a8cc86..d0ec3f4ed5d277 100644
--- a/doc/api/cluster.md
+++ b/doc/api/cluster.md
@@ -260,6 +260,10 @@ It is not emitted in the worker.
### worker.disconnect()
* Returns: {Worker} A reference to `worker`.
@@ -416,6 +420,10 @@ accidental disconnection.
### worker.send(message[, sendHandle][, callback])
* `message` {Object}
@@ -449,6 +457,10 @@ if (cluster.isMaster) {
> Stability: 0 - Deprecated: Use [`worker.exitedAfterDisconnect`][] instead.
@@ -579,6 +591,13 @@ The `addressType` is one of:
* `"udp4"` or `"udp6"` (UDP v4 or v6)
## Event: 'message'
+
* `worker` {cluster.Worker}
* `message` {Object}
@@ -708,6 +727,10 @@ values are `"rr"` and `"none"`.
## cluster.settings
* {Object}
@@ -732,6 +755,10 @@ This object is not supposed to be changed or set manually, by you.
## cluster.setupMaster([settings])
* `settings` {Object}
diff --git a/doc/api/console.md b/doc/api/console.md
index 7315ca5192be64..45566a9cdf586d 100644
--- a/doc/api/console.md
+++ b/doc/api/console.md
@@ -9,10 +9,15 @@ The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and
`console.warn()` that can be used to write to any Node.js stream.
-* A global `console` instance configured to write to `stdout` and `stderr`.
- Because this object is global, it can be used without calling
+* A global `console` instance configured to write to [`process.stdout`][] and
+ [`process.stderr`][]. The global `console` can be used without calling
`require('console')`.
+***Warning***: The global console object's methods are neither consistently
+synchronous like the browser APIs they resemble, nor are they consistently
+asynchronous like all other Node.js streams. See the [note on process I/O][] for
+more information.
+
Example using the global `console`:
```js
@@ -47,21 +52,6 @@ myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
-While the API for the `Console` class is designed fundamentally around the
-browser `console` object, the `Console` in Node.js is *not* intended to
-duplicate the browser's functionality exactly.
-
-## Asynchronous vs Synchronous Consoles
-
-The console functions are usually asynchronous unless the destination is a file.
-Disks are fast and operating systems normally employ write-back caching;
-it should be a very rare occurrence indeed that a write blocks, but it
-is possible.
-
-Additionally, console functions are blocking when outputting to TTYs
-(terminals) on OS X as a workaround for the OS's very small, 1kb buffer size.
-This is to prevent interleaving between `stdout` and `stderr`.
-
## Class: Console
@@ -246,6 +236,11 @@ milliseconds to `stdout`. Timer durations are accurate to the sub-millisecond.
### console.timeEnd(label)
Stops a timer that was previously started by calling [`console.time()`][] and
@@ -305,4 +300,5 @@ The `console.warn()` function is an alias for [`console.error()`][].
[`util.format()`]: util.html#util_util_format_format_args
[`util.inspect()`]: util.html#util_util_inspect_object_options
[customizing `util.inspect()` colors]: util.html#util_customizing_util_inspect_colors
+[note on process I/O]: process.html#process_a_note_on_process_i_o
[web-api-assert]: https://developer.mozilla.org/en-US/docs/Web/API/console/assert
diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index 9102f2e89c03c4..d14c787a2b3c60 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -229,6 +229,10 @@ Returns `this` for method chaining.
### cipher.update(data[, input_encoding][, output_encoding])
Updates the cipher with `data`. If the `input_encoding` argument is given,
@@ -327,6 +331,10 @@ than once will result in an error being thrown.
### decipher.setAAD(buffer)
When using an authenticated encryption mode (only `GCM` is currently
@@ -338,6 +346,10 @@ Returns `this` for method chaining.
### decipher.setAuthTag(buffer)
When using an authenticated encryption mode (only `GCM` is currently
@@ -368,6 +380,10 @@ Returns `this` for method chaining.
### decipher.update(data[, input_encoding][, output_encoding])
Updates the decipher with `data`. If the `input_encoding` argument is given,
@@ -548,6 +564,10 @@ assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
### ecdh.computeSecret(other_public_key[, input_encoding][, output_encoding])
Computes the shared secret using `other_public_key` as the other
@@ -731,6 +751,10 @@ called. Multiple calls will cause an error to be thrown.
### hash.update(data[, input_encoding])
Updates the hash content with the given `data`, the encoding of which
@@ -813,6 +837,10 @@ called. Multiple calls to `hmac.digest()` will result in an error being thrown.
### hmac.update(data[, input_encoding])
Updates the `Hmac` content with the given `data`, the encoding of which
@@ -914,6 +942,10 @@ called. Multiple calls to `sign.sign()` will result in an error being thrown.
### sign.update(data[, input_encoding])
Updates the `Sign` content with the given `data`, the encoding of which
@@ -972,6 +1004,10 @@ console.log(verify.verify(publicKey, signature));
### verifier.update(data[, input_encoding])
Updates the `Verify` content with the given `data`, the encoding of which
@@ -1133,6 +1169,11 @@ The `key` is the raw key used by the `algorithm` and `iv` is an
### crypto.createDiffieHellman(prime[, prime_encoding][, generator][, generator_encoding])
Creates a `DiffieHellman` key exchange object using the supplied `prime` and an
@@ -1334,6 +1375,15 @@ console.log(hashes); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
### crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)
Provides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2)
@@ -1369,6 +1419,15 @@ An array of supported digest functions can be retrieved using
### crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)
Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)
@@ -1419,22 +1478,6 @@ keys:
All paddings are defined in `crypto.constants`.
-### crypto.timingSafeEqual(a, b)
-
-
-Returns true if `a` is equal to `b`, without leaking timing information that
-would allow an attacker to guess one of the values. This is suitable for
-comparing HMAC digests or secret values like authentication cookies or
-[capability urls](https://www.w3.org/TR/capability-urls/).
-
-`a` and `b` must both be `Buffer`s, and they must have the same length.
-
-**Note**: Use of `crypto.timingSafeEqual` does not guarantee that the
-*surrounding* code is timing-safe. Care should be taken to ensure that the
-surrounding code does not introduce timing vulnerabilities.
-
### crypto.privateEncrypt(private_key, buffer)
+
+Returns true if `a` is equal to `b`, without leaking timing information that
+would allow an attacker to guess one of the values. This is suitable for
+comparing HMAC digests or secret values like authentication cookies or
+[capability urls](https://www.w3.org/TR/capability-urls/).
+
+`a` and `b` must both be `Buffer`s, and they must have the same length.
+
+**Note**: Use of `crypto.timingSafeEqual` does not guarantee that the
+*surrounding* code is timing-safe. Care should be taken to ensure that the
+surrounding code does not introduce timing vulnerabilities.
+
## Notes
### Legacy Streams API (pre Node.js v0.10)
diff --git a/doc/api/debugger.md b/doc/api/debugger.md
index 7112b403fe35f3..b9503ca8d7b72a 100644
--- a/doc/api/debugger.md
+++ b/doc/api/debugger.md
@@ -190,8 +190,8 @@ V8 Inspector can be enabled by passing the `--inspect` flag when starting a
Node.js application. It is also possible to supply a custom port with that flag,
e.g. `--inspect=9222` will accept DevTools connections on port 9222.
-To break on the first line of the application code, provide the `--debug-brk`
-flag in addition to `--inspect`.
+To break on the first line of the application code, pass the `--inspect-brk`
+flag instead of `--inspect`.
```txt
$ node --inspect index.js
@@ -201,4 +201,4 @@ To start debugging, open the following URL in Chrome:
chrome-devtools://devtools/remote/serve_file/@60cd6e859b9f557d2312f5bf532f6aec5f284980/inspector.html?experiments=true&v8only=true&ws=localhost:9229/node
```
-[TCP-based protocol]: https://github.com/v8/v8/wiki/Debugging-Protocol
+[TCP-based protocol]: https://github.com/v8/v8/wiki/Debugging-Protocol
\ No newline at end of file
diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
new file mode 100644
index 00000000000000..e8a71996c78c0a
--- /dev/null
+++ b/doc/api/deprecations.md
@@ -0,0 +1,40 @@
+# Deprecated APIs
+
+Node.js may deprecate APIs when either: (a) use of the API is considered to be
+unsafe, (b) an improved alternative API has been made available, or (c)
+breaking changes to the API are expected in a future major release.
+
+Node.js utilizes three kinds of Deprecations:
+
+* Documentation-only
+* Runtime
+* End-of-Life
+
+A Documentation-only deprecation is one that is expressed only within the
+Node.js API docs. These generate no side-effects while running Node.js.
+
+A Runtime deprecation will, by default, generate a process warning that will
+be printed to `stderr` the first time the deprecated API is used. When the
+`--throw-deprecation` command-line flag is used, a Runtime deprecation will
+cause an error to be thrown.
+
+An End-of-Life deprecation is used to identify code that either has been
+removed or will soon be removed from Node.js.
+
+## Un-deprecation
+
+From time-to-time the deprecation of an API may be reversed. Such action may
+happen in either a semver-minor or semver-major release. In such situations,
+this document will be updated with information relevant to the decision.
+*However, the deprecation identifier will not be modified*.
+
+## List of Deprecated APIs
+
+-Z` (i.e. `SIGTSTP`) is then brought back to the
-foreground using fg(1).
+foreground using fg(1p).
If the `input` stream was paused *before* the `SIGTSTP` request, this event will
not be emitted.
@@ -174,7 +174,7 @@ input, typically known as `SIGTSTP`. If there are no `SIGTSTP` event listeners
registered when the `input` stream receives a `SIGTSTP`, the Node.js process
will be sent to the background.
-When the program is resumed using fg(1), the `'pause'` and `SIGCONT` events
+When the program is resumed using fg(1p), the `'pause'` and `SIGCONT` events
will be emitted. These can be used to resume the `input` stream.
The `'pause'` and `'SIGCONT'` events will not be emitted if the `input` was
@@ -344,6 +344,13 @@ the current position of the cursor down.
## readline.createInterface(options)
* `options` {Object}
@@ -518,8 +525,8 @@ rl.on('line', (line) => {
[`process.stdin`]: process.html#process_process_stdin
[`process.stdout`]: process.html#process_process_stdout
-[Writable]: stream.html
-[Readable]: stream.html
+[Writable]: stream.html#stream_writable_streams
+[Readable]: stream.html#stream_readable_streams
[TTY]: tty.html
[`SIGTSTP`]: readline.html#readline_event_sigtstp
[`SIGCONT`]: readline.html#readline_event_sigcont
diff --git a/doc/api/repl.md b/doc/api/repl.md
index 1b03ba47a25d99..f4d85e11c96b3b 100644
--- a/doc/api/repl.md
+++ b/doc/api/repl.md
@@ -373,6 +373,10 @@ within the action function for commands registered using the
## repl.start([options])
* `options` {Object | String}
diff --git a/doc/api/stream.md b/doc/api/stream.md
index ba1c56398d544c..0e12e76c810c17 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -380,6 +380,10 @@ file.end('world!');
##### writable.setDefaultEncoding(encoding)
* `encoding` {String} The new default encoding
@@ -429,6 +433,11 @@ See also: [`writable.cork()`][].
##### writable.write(chunk[, encoding][, callback])
* `chunk` {String|Buffer} The data to write
@@ -1069,6 +1078,11 @@ myReader.on('readable', () => {
#### Class: stream.Duplex
@@ -1190,6 +1204,9 @@ the [API for Stream Consumers][] section). Doing so may lead to adverse
side effects in application code consuming the stream.
### Simplified Construction
+
For many simple cases, it is possible to construct a stream without relying on
inheritance. This can be accomplished by directly creating instances of the
diff --git a/doc/api/tls.md b/doc/api/tls.md
index f83ed1df3e449f..94281dd3f00c28 100644
--- a/doc/api/tls.md
+++ b/doc/api/tls.md
@@ -214,19 +214,6 @@ added: v0.3.2
The `tls.Server` class is a subclass of `net.Server` that accepts encrypted
connections using TLS or SSL.
-### Event: 'tlsClientError'
-
-
-The `'tlsClientError'` event is emitted when an error occurs before a secure
-connection is established. The listener callback is passed two arguments when
-called:
-
-* `exception` {Error} The `Error` object describing the error
-* `tlsSocket` {tls.TLSSocket} The `tls.TLSSocket` instance from which the
- error originated.
-
### Event: 'newSession'
+
+The `'tlsClientError'` event is emitted when an error occurs before a secure
+connection is established. The listener callback is passed two arguments when
+called:
+
+* `exception` {Error} The `Error` object describing the error
+* `tlsSocket` {tls.TLSSocket} The `tls.TLSSocket` instance from which the
+ error originated.
+
### server.addContext(hostname, context)
* `socket` {net.Socket} An instance of [`net.Socket`][]
@@ -483,7 +487,12 @@ added: v0.11.4
will be emitted on the socket before establishing a secure communication
* `secureContext`: Optional TLS context object created with
[`tls.createSecureContext()`][]. If a `secureContext` is _not_ provided, one
- will be created by calling [`tls.createSecureContext()`][] with no options.
+ will be created by passing the entire `options` object to
+ `tls.createSecureContext()`. *Note*: In effect, all
+ [`tls.createSecureContext()`][] options can be provided, but they will be
+ _completely ignored_ unless the `secureContext` option is missing.
+ * ...: Optional [`tls.createSecureContext()`][] options can be provided, see
+ the `secureContext` option for more information.
Construct a new `tls.TLSSocket` object from an existing TCP socket.
@@ -526,21 +535,21 @@ underlying socket as reported by the operating system. Returns an
object with three properties, e.g.,
`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`
-### tlsSocket.authorized
+### tlsSocket.authorizationError
-Returns `true` if the peer certificate was signed by one of the CAs specified
-when creating the `tls.TLSSocket` instance, otherwise `false`.
+Returns the reason why the peer's certificate was not been verified. This
+property is set only when `tlsSocket.authorized === false`.
-### tlsSocket.authorizationError
+### tlsSocket.authorized
-Returns the reason why the peer's certificate was not been verified. This
-property is set only when `tlsSocket.authorized === false`.
+Returns `true` if the peer certificate was signed by one of the CAs specified
+when creating the `tls.TLSSocket` instance, otherwise `false`.
### tlsSocket.encrypted
-
-* `port` {number} Default value for `options.port`.
-* `host` {string} Optional default value for `options.host`.
-* `options` {Object} See [`tls.connect()`][].
-* `callback` {Function} See [`tls.connect()`][].
-
-Same as [`tls.connect()`][] except that `port` and `host` can be provided
-as arguments instead of options.
-
-*Note*: A port or host option, if specified, will take precedence over any port
-or host argument.
-
-## tls.connect(path[, options][, callback])
-
-
-* `path` {string} Default value for `options.path`.
-* `options` {Object} See [`tls.connect()`][].
-* `callback` {Function} See [`tls.connect()`][].
-
-Same as [`tls.connect()`][] except that `path` can be provided
-as an argument instead of an option.
-
-*Note*: A path option, if specified, will take precedence over the path
-argument.
-
## tls.connect(options[, callback])
* `options` {Object}
@@ -879,10 +864,51 @@ socket.on('end', () => {
});
```
+## tls.connect(path[, options][, callback])
+
+
+* `path` {string} Default value for `options.path`.
+* `options` {Object} See [`tls.connect()`][].
+* `callback` {Function} See [`tls.connect()`][].
+
+Same as [`tls.connect()`][] except that `path` can be provided
+as an argument instead of an option.
+
+*Note*: A path option, if specified, will take precedence over the path
+argument.
+
+## tls.connect(port[, host][, options][, callback])
+
+
+* `port` {number} Default value for `options.port`.
+* `host` {string} Optional default value for `options.host`.
+* `options` {Object} See [`tls.connect()`][].
+* `callback` {Function} See [`tls.connect()`][].
+
+Same as [`tls.connect()`][] except that `port` and `host` can be provided
+as arguments instead of options.
+
+*Note*: A port or host option, if specified, will take precedence over any port
+or host argument.
+
## tls.createSecureContext(options)
* `options` {Object}
@@ -972,6 +998,10 @@ publicly trusted list of CAs as given in
## tls.createServer([options][, secureConnectionListener])
* `options` {Object}
@@ -1146,6 +1176,10 @@ certificate used is properly authorized.
> Stability: 0 - Deprecated: Use [`tls.TLSSocket`][] instead.
diff --git a/doc/api/tracing.md b/doc/api/tracing.md
new file mode 100644
index 00000000000000..28e488201ec2d8
--- /dev/null
+++ b/doc/api/tracing.md
@@ -0,0 +1,19 @@
+# Tracing
+
+Trace Event provides a mechanism to centralize tracing information generated by
+V8, Node core, and userspace code.
+
+Tracing can be enabled by passing the `--trace-events-enabled` flag when starting a
+Node.js application.
+
+The set of categories for which traces are recorded can be specified using the
+`--trace-event-categories` flag followed by a list of comma separated category names.
+By default the `node` and `v8` categories are enabled.
+
+```txt
+node --trace-events-enabled --trace-event-categories v8,node server.js
+```
+
+Running Node.js with tracing enabled will produce log files that can be opened
+in the [`chrome://tracing`](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool)
+tab of Chrome.
diff --git a/doc/api/url.md b/doc/api/url.md
old mode 100755
new mode 100644
index 50e7433e6110e5..c7bc6d5dbbe2f1
--- a/doc/api/url.md
+++ b/doc/api/url.md
@@ -34,24 +34,22 @@ illustrate each.
(all spaces in the "" line should be ignored -- they are purely for formatting)
```
-### urlObject.href
-
-The `href` property is the full URL string that was parsed with both the
-`protocol` and `host` components converted to lower-case.
-
-For example: `'http://user:pass@host.com:8080/p/a/t/h?query=string#hash'`
+### urlObject.auth
-### urlObject.protocol
+The `auth` property is the username and password portion of the URL, also
+referred to as "userinfo". This string subset follows the `protocol` and
+double slashes (if present) and precedes the `host` component, delimited by an
+ASCII "at sign" (`@`). The format of the string is `{username}[:{password}]`,
+with the `[:{password}]` portion being optional.
-The `protocol` property identifies the URL's lower-cased protocol scheme.
+For example: `'user:pass'`
-For example: `'http:'`
+### urlObject.hash
-### urlObject.slashes
+The `hash` property consists of the "fragment" portion of the URL including
+the leading ASCII hash (`#`) character.
-The `slashes` property is a `boolean` with a value of `true` if two ASCII
-forward-slash characters (`/`) are required following the colon in the
-`protocol`.
+For example: `'#hash'`
### urlObject.host
@@ -60,16 +58,6 @@ the `port` if specified.
For example: `'host.com:8080'`
-### urlObject.auth
-
-The `auth` property is the username and password portion of the URL, also
-referred to as "userinfo". This string subset follows the `protocol` and
-double slashes (if present) and precedes the `host` component, delimited by an
-ASCII "at sign" (`@`). The format of the string is `{username}[:{password}]`,
-with the `[:{password}]` portion being optional.
-
-For example: `'user:pass'`
-
### urlObject.hostname
The `hostname` property is the lower-cased host name portion of the `host`
@@ -77,11 +65,21 @@ component *without* the `port` included.
For example: `'host.com'`
-### urlObject.port
+### urlObject.href
-The `port` property is the numeric port portion of the `host` component.
+The `href` property is the full URL string that was parsed with both the
+`protocol` and `host` components converted to lower-case.
-For example: `'8080'`
+For example: `'http://user:pass@host.com:8080/p/a/t/h?query=string#hash'`
+
+### urlObject.path
+
+The `path` property is a concatenation of the `pathname` and `search`
+components.
+
+For example: `'/p/a/t/h?query=string'`
+
+No decoding of the `path` is performed.
### urlObject.pathname
@@ -94,23 +92,17 @@ For example `'/p/a/t/h'`
No decoding of the path string is performed.
-### urlObject.search
-
-The `search` property consists of the entire "query string" portion of the
-URL, including the leading ASCII question mark (`?`) character.
-
-For example: `'?query=string'`
+### urlObject.port
-No decoding of the query string is performed.
+The `port` property is the numeric port portion of the `host` component.
-### urlObject.path
+For example: `'8080'`
-The `path` property is a concatenation of the `pathname` and `search`
-components.
+### urlObject.protocol
-For example: `'/p/a/t/h?query=string'`
+The `protocol` property identifies the URL's lower-cased protocol scheme.
-No decoding of the `path` is performed.
+For example: `'http:'`
### urlObject.query
@@ -124,12 +116,20 @@ For example: `'query=string'` or `{'query': 'string'}`
If returned as a string, no decoding of the query string is performed. If
returned as an object, both keys and values are decoded.
-### urlObject.hash
+### urlObject.search
-The `hash` property consists of the "fragment" portion of the URL including
-the leading ASCII hash (`#`) character.
+The `search` property consists of the entire "query string" portion of the
+URL, including the leading ASCII question mark (`?`) character.
-For example: `'#hash'`
+For example: `'?query=string'`
+
+No decoding of the query string is performed.
+
+### urlObject.slashes
+
+The `slashes` property is a `boolean` with a value of `true` if two ASCII
+forward-slash characters (`/`) are required following the colon in the
+`protocol`.
## url.format(urlObject)
* `from` {String} The Base URL being resolved against.
@@ -270,6 +323,35 @@ console.log(myURL.pathname); // /foo
*Note*: Using the `delete` keyword (e.g. `delete myURL.protocol`,
`delete myURL.pathname`, etc) has no effect but will still return `true`.
+A comparison between this API and `url.parse()` is given below. Above the URL
+`'http://user:pass@host.com:8080/p/a/t/h?query=string#hash'`, properties of an
+object returned by `url.parse()` are shown. Below it are properties of a WHATWG
+`URL` object.
+
+*Note*: WHATWG URL's `origin` property includes `protocol` and `host`, but not
+`username` or `password`.
+
+```txt
+┌─────────────────────────────────────────────────────────────────────────────────────────┐
+│ href │
+├──────────┬──┬─────────────────────┬─────────────────┬───────────────────────────┬───────┤
+│ protocol │ │ auth │ host │ path │ hash │
+│ │ │ ├──────────┬──────┼──────────┬────────────────┤ │
+│ │ │ │ hostname │ port │ pathname │ search │ │
+│ │ │ │ │ │ ├─┬──────────────┤ │
+│ │ │ │ │ │ │ │ query │ │
+" http: // user : pass @ host.com : 8080 /p/a/t/h ? query=string #hash "
+│ │ │ │ │ hostname │ port │ │ │ │
+│ │ │ │ ├──────────┴──────┤ │ │ │
+│ protocol │ │ username │ password │ host │ │ │ │
+├──────────┴──┼──────────┴──────────┼─────────────────┤ │ │ │
+│ origin │ │ origin │ pathname │ search │ hash │
+├─────────────┴─────────────────────┴─────────────────┴──────────┴────────────────┴───────┤
+│ href │
+└─────────────────────────────────────────────────────────────────────────────────────────┘
+(all spaces in the "" line should be ignored -- they are purely for formatting)
+```
+
### Class: URL
#### Constructor: new URL(input[, base])
@@ -299,13 +381,15 @@ automatically converted to ASCII using the [Punycode][] algorithm.
```js
const myURL = new URL('https://你好你好');
- // https://xn--6qqa088eba
+ // https://xn--6qqa088eba/
```
Additional [examples of parsed URLs][] may be found in the WHATWG URL Standard.
#### url.hash
+* {String}
+
Gets and sets the fragment portion of the URL.
```js
@@ -319,12 +403,14 @@ console.log(myURL.href);
```
Invalid URL characters included in the value assigned to the `hash` property
-are [percent-encoded](#whatwg-percent-encoding). Note that the selection of
-which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+are [percent-encoded][]. Note that the selection of which characters to
+percent-encode may vary somewhat from what the [`url.parse()`][] and
+[`url.format()`][] methods would produce.
#### url.host
+* {String}
+
Gets and sets the host portion of the URL.
```js
@@ -341,6 +427,8 @@ Invalid host values assigned to the `host` property are ignored.
#### url.hostname
+* {String}
+
Gets and sets the hostname portion of the URL. The key difference between
`url.host` and `url.hostname` is that `url.hostname` does *not* include the
port.
@@ -359,6 +447,8 @@ Invalid hostname values assigned to the `hostname` property are ignored.
#### url.href
+* {String}
+
Gets and sets the serialized URL.
```js
@@ -370,15 +460,20 @@ myURL.href = 'https://example.com/bar'
// Prints https://example.com/bar
```
-Setting the value of the `href` property to a new value is equivalent to
-creating a new `URL` object using `new URL(value)`. Each of the `URL` object's
-properties will be modified.
+Getting the value of the `href` property is equivalent to calling
+[`url.toString()`][].
+
+Setting the value of this property to a new value is equivalent to creating a
+new `URL` object using [`new URL(value)`][`new URL()`]. Each of the `URL`
+object's properties will be modified.
If the value assigned to the `href` property is not a valid URL, a `TypeError`
will be thrown.
#### url.origin
+* {String}
+
Gets the read-only serialization of the URL's origin. Unicode characters that
may be contained within the hostname will be encoded as-is without [Punycode][]
encoding.
@@ -400,6 +495,8 @@ console.log(idnURL.hostname);
#### url.password
+* {String}
+
Gets and sets the password portion of the URL.
```js
@@ -413,12 +510,14 @@ console.log(myURL.href);
```
Invalid URL characters included in the value assigned to the `password` property
-are [percent-encoded](#whatwg-percent-encoding). Note that the selection of
-which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+are [percent-encoded][]. Note that the selection of which characters to
+percent-encode may vary somewhat from what the [`url.parse()`][] and
+[`url.format()`][] methods would produce.
#### url.pathname
+* {String}
+
Gets and sets the path portion of the URL.
```js
@@ -432,23 +531,54 @@ console.log(myURL.href);
```
Invalid URL characters included in the value assigned to the `pathname`
-property are [percent-encoded](#whatwg-percent-encoding). Note that the
-selection of which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+property are [percent-encoded][]. Note that the selection of which characters
+to percent-encode may vary somewhat from what the [`url.parse()`][] and
+[`url.format()`][] methods would produce.
#### url.port
-Gets and sets the port portion of the URL. When getting the port, the value
-is returned as a String.
+* {String}
+
+Gets and sets the port portion of the URL.
```js
const myURL = new URL('https://example.org:8888');
console.log(myURL.port);
// Prints 8888
+// Default ports are automatically transformed to the empty string
+// (HTTPS protocol's default port is 443)
+myURL.port = '443';
+console.log(myURL.port);
+ // Prints the empty string
+console.log(myURL.href);
+ // Prints https://example.org/
+
myURL.port = 1234;
+console.log(myURL.port);
+ // Prints 1234
console.log(myURL.href);
- // Prints https://example.org:1234
+ // Prints https://example.org:1234/
+
+// Completely invalid port strings are ignored
+myURL.port = 'abcd';
+console.log(myURL.port);
+ // Prints 1234
+
+// Leading numbers are treated as a port number
+myURL.port = '5678abcd';
+console.log(myURL.port);
+ // Prints 5678
+
+// Non-integers are truncated
+myURL.port = 1234.5678;
+console.log(myURL.port);
+ // Prints 1234
+
+// Out-of-range numbers are ignored
+myURL.port = 1e10;
+console.log(myURL.port);
+ // Prints 1234
```
The port value may be set as either a number or as a String containing a number
@@ -456,10 +586,14 @@ in the range `0` to `65535` (inclusive). Setting the value to the default port
of the `URL` objects given `protocol` will result in the `port` value becoming
the empty string (`''`).
-Invalid URL port values assigned to the `port` property are ignored.
+If an invalid string is assigned to the `port` property, but it begins with a
+number, the leading number is assigned to `port`. Otherwise, or if the number
+lies outside the range denoted above, it is ignored.
#### url.protocol
+* {String}
+
Gets and sets the protocol portion of the URL.
```js
@@ -476,6 +610,8 @@ Invalid URL protocol values assigned to the `protocol` property are ignored.
#### url.search
+* {String}
+
Gets and sets the serialized query portion of the URL.
```js
@@ -489,17 +625,23 @@ console.log(myURL.href);
```
Any invalid URL characters appearing in the value assigned the `search`
-property will be [percent-encoded](#whatwg-percent-encoding). Note that the
-selection of which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+property will be [percent-encoded][]. Note that the selection of which
+characters to percent-encode may vary somewhat from what the [`url.parse()`][]
+and [`url.format()`][] methods would produce.
#### url.searchParams
-Gets a [`URLSearchParams`](#url_class_urlsearchparams) object representing the
-query parameters of the URL.
+* {URLSearchParams}
+
+Gets the [`URLSearchParams`][] object representing the query parameters of the
+URL. This property is read-only; to replace the entirety of query parameters of
+the URL, use the [`url.search`][] setter. See [`URLSearchParams`][]
+documentation for details.
#### url.username
+* {String}
+
Gets and sets the username portion of the URL.
```js
@@ -513,20 +655,51 @@ console.log(myURL.href);
```
Any invalid URL characters appearing in the value assigned the `username`
-property will be [percent-encoded](#whatwg-percent-encoding). Note that the
-selection of which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+property will be [percent-encoded][]. Note that the selection of which
+characters to percent-encode may vary somewhat from what the [`url.parse()`][]
+and [`url.format()`][] methods would produce.
#### url.toString()
+* Returns: {String}
+
The `toString()` method on the `URL` object returns the serialized URL. The
-value returned is equivalent to that of `url.href`.
+value returned is equivalent to that of [`url.href`][] and [`url.toJSON()`][].
+
+Because of the need for standard compliance, this method does not allow users
+to customize the serialization process of the URL. For more flexibility,
+[`require('url').format()`][] method might be of interest.
+
+#### url.toJSON()
+
+* Returns: {String}
+
+The `toJSON()` method on the `URL` object returns the serialized URL. The
+value returned is equivalent to that of [`url.href`][] and
+[`url.toString()`][].
+
+This method is automatically called when an `URL` object is serialized
+with [`JSON.stringify()`][].
+
+```js
+const myURLs = [
+ new URL('https://www.example.com'),
+ new URL('https://test.example.org')
+];
+console.log(JSON.stringify(myURLs));
+ // Prints ["https://www.example.com/","https://test.example.org/"]
+```
### Class: URLSearchParams
-The `URLSearchParams` object provides read and write access to the query of a
+The `URLSearchParams` API provides read and write access to the query of a
`URL`.
+The WHATWG `URLSearchParams` interface and the [`querystring`][] module have
+similar purpose, but the purpose of the [`querystring`][] module is more
+general, as it allows the customization of delimiter characters (`&` and `=`).
+On the other hand, this API is designed purely for URL query strings.
+
```js
const URL = require('url').URL;
const myURL = new URL('https://example.org/?abc=123');
@@ -568,36 +741,41 @@ Returns an ES6 Iterator over each of the name-value pairs in the query.
Each item of the iterator is a JavaScript Array. The first item of the Array
is the `name`, the second item of the Array is the `value`.
-Alias for `urlSearchParams\[\@\@iterator\]()`.
+Alias for [`urlSearchParams[@@iterator]()`][`urlSearchParams@@iterator()`].
-#### urlSearchParams.forEach(fn)
+#### urlSearchParams.forEach(fn[, thisArg])
* `fn` {Function} Function invoked for each name-value pair in the query.
+* `thisArg` {Object} Object to be used as `this` value for when `fn` is called
Iterates over each name-value pair in the query and invokes the given function.
```js
const URL = require('url').URL;
const myURL = new URL('https://example.org/?a=b&c=d');
-myURL.searchParams.forEach((value, name) => {
- console.log(name, value);
+myURL.searchParams.forEach((value, name, searchParams) => {
+ console.log(name, value, myURL.searchParams === searchParams);
});
+ // Prints:
+ // a b true
+ // c d true
```
#### urlSearchParams.get(name)
* `name` {String}
-* Returns: {String} or `null` if there is no name-value pair with the given
- `name`.
+* Returns: {String | Null}
-Returns the value of the first name-value pair whose name is `name`.
+Returns the value of the first name-value pair whose name is `name`. If there
+are no such pairs, `null` is returned.
#### urlSearchParams.getAll(name)
* `name` {String}
* Returns: {Array}
-Returns the values of all name-value pairs whose name is `name`.
+Returns the values of all name-value pairs whose name is `name`. If there are
+no such pairs, an empty array is returned.
#### urlSearchParams.has(name)
@@ -612,19 +790,64 @@ Returns `true` if there is at least one name-value pair whose name is `name`.
Returns an ES6 Iterator over the names of each name-value pair.
+```js
+const { URLSearchParams } = require('url');
+const params = new URLSearchParams('foo=bar&foo=baz');
+for (const name of params.keys()) {
+ console.log(name);
+}
+ // Prints:
+ // foo
+ // foo
+```
+
#### urlSearchParams.set(name, value)
* `name` {String}
* `value` {String}
-Remove any existing name-value pairs whose name is `name` and append a new
-name-value pair.
+Sets the value in the `URLSearchParams` object associated with `name` to
+`value`. If there are any pre-existing name-value pairs whose names are `name`,
+set the first such pair's value to `value` and remove all others. If not,
+append the name-value pair to the query string.
+
+```js
+const { URLSearchParams } = require('url');
+
+const params = new URLSearchParams();
+params.append('foo', 'bar');
+params.append('foo', 'baz');
+params.append('abc', 'def');
+console.log(params.toString());
+ // Prints foo=bar&foo=baz&abc=def
+
+params.set('foo', 'def');
+params.set('xyz', 'opq');
+console.log(params.toString());
+ // Prints foo=def&abc=def&xyz=opq
+```
+
+#### urlSearchParams.sort()
+
+Sort all existing name-value pairs in-place by their names. Sorting is done
+with a [stable sorting algorithm][], so relative order between name-value pairs
+with the same name is preserved.
+
+This method can be used, in particular, to increase cache hits.
+
+```js
+const params = new URLSearchParams('query[]=abc&type=search&query[]=123');
+params.sort();
+console.log(params.toString());
+ // Prints query%5B%5D=abc&query%5B%5D=123&type=search
+```
#### urlSearchParams.toString()
* Returns: {String}
-Returns the search parameters serialized as a URL-encoded string.
+Returns the search parameters serialized as a string, with characters
+percent-encoded where necessary.
#### urlSearchParams.values()
@@ -632,7 +855,7 @@ Returns the search parameters serialized as a URL-encoded string.
Returns an ES6 Iterator over the values of each name-value pair.
-#### urlSearchParams\[\@\@iterator\]()
+#### urlSearchParams\[@@iterator\]()
* Returns: {Iterator}
@@ -640,7 +863,18 @@ Returns an ES6 Iterator over each of the name-value pairs in the query string.
Each item of the iterator is a JavaScript Array. The first item of the Array
is the `name`, the second item of the Array is the `value`.
-Alias for `urlSearchParams.entries()`.
+Alias for [`urlSearchParams.entries()`][].
+
+```js
+const { URLSearchParams } = require('url');
+const params = new URLSearchParams('foo=bar&xyz=baz');
+for (const [name, value] of params) {
+ console.log(name, value);
+}
+ // Prints:
+ // foo bar
+ // xyz baz
+```
### require('url').domainToAscii(domain)
@@ -711,4 +945,17 @@ console.log(myURL.origin);
[examples of parsed URLs]: https://url.spec.whatwg.org/#example-url-parsing
[`url.parse()`]: #url_url_parse_urlstring_parsequerystring_slashesdenotehost
[`url.format()`]: #url_url_format_urlobject
+[`require('url').format()`]: #url_url_format_url_options
+[`url.toString()`]: #url_url_tostring
[Punycode]: https://tools.ietf.org/html/rfc5891#section-4.4
+[WHATWG URL]: #url_the_whatwg_url_api
+[`new URL()`]: #url_constructor_new_url_input_base
+[`url.href`]: #url_url_href
+[`url.search`]: #url_url_search
+[percent-encoded]: #whatwg-percent-encoding
+[`URLSearchParams`]: #url_class_urlsearchparams
+[`urlSearchParams.entries()`]: #url_urlsearchparams_entries
+[`urlSearchParams@@iterator()`]: #url_urlsearchparams_iterator
+[stable sorting algorithm]: https://en.wikipedia.org/wiki/Sorting_algorithm#Stability
+[`JSON.stringify()`]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
+[`url.toJSON()`]: #url_url_tojson
diff --git a/doc/api/util.md b/doc/api/util.md
index 3843f80ce75366..726691b8d6dabd 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -136,6 +136,10 @@ util.format(1, 2, 3); // '1 2 3'
## util.inherits(constructor, superConstructor)
_Note: usage of `util.inherits()` is discouraged. Please use the ES6 `class` and
@@ -203,6 +207,20 @@ stream.write('With ES6');
## util.inspect(object[, options])
* `object` {any} Any JavaScript primitive or Object.
@@ -343,6 +361,14 @@ util.inspect(obj);
// Returns: "{ bar: 'baz' }"
```
+### util.inspect.custom
+
+
+A Symbol that can be used to declare custom inspect functions, see
+[Custom inspection functions on Objects][].
+
### util.inspect.defaultOptions
-A Symbol that can be used to declare custom inspect functions, see
-[Custom inspection functions on Objects][].
+> Stability: 0 - Deprecated: Use [`Object.assign()`] instead.
-## Deprecated APIs
+The `util._extend()` method was never intended to be used outside of internal
+Node.js modules. The community found and used it anyway.
-The following APIs have been deprecated and should no longer be used. Existing
-applications and modules should be updated to find alternative approaches.
+It is deprecated and should not be used in new code. JavaScript comes with very
+similar built-in functionality through [`Object.assign()`].
### util.debug(string)
-
-> Stability: 0 - Deprecated: Use [`Object.assign()`] instead.
-
-The `util._extend()` method was never intended to be used outside of internal
-Node.js modules. The community found and used it anyway.
-
-It is deprecated and should not be used in new code. JavaScript comes with very
-similar built-in functionality through [`Object.assign()`].
-
[`Array.isArray`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
[constructor]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/constructor
[semantically incompatible]: https://github.com/nodejs/node/issues/4179
diff --git a/doc/api/v8.md b/doc/api/v8.md
index 8cec6bdfdf8007..be222bbabf63ed 100644
--- a/doc/api/v8.md
+++ b/doc/api/v8.md
@@ -9,48 +9,13 @@ const v8 = require('v8');
*Note*: The APIs and implementation are subject to change at any time.
-## v8.getHeapStatistics()
-
-
-Returns an object with the following properties:
-
-* `total_heap_size` {number}
-* `total_heap_size_executable` {number}
-* `total_physical_size` {number}
-* `total_available_size` {number}
-* `used_heap_size` {number}
-* `heap_size_limit` {number}
-* `malloced_memory` {number}
-* `peak_malloced_memory` {number}
-* `does_zap_garbage` {number}
-
-`does_zap_garbage` is a 0/1 boolean, which signifies whether the `--zap_code_space`
-option is enabled or not. This makes V8 overwrite heap garbage with a bit
-pattern. The RSS footprint (resident memory set) gets bigger because it
-continuously touches all heap pages and that makes them less likely to get
-swapped out by the operating system.
-
-For example:
-
-```js
-{
- total_heap_size: 7326976,
- total_heap_size_executable: 4194304,
- total_physical_size: 7326976,
- total_available_size: 1152656,
- used_heap_size: 3476208,
- heap_size_limit: 1535115264,
- malloced_memory: 16384,
- peak_malloced_memory: 1127496,
- does_zap_garbage: 0
-}
-```
-
## v8.getHeapSpaceStatistics()
Returns statistics about the V8 heap spaces, i.e. the segments which make up
@@ -108,6 +73,53 @@ For example:
]
```
+## v8.getHeapStatistics()
+
+
+Returns an object with the following properties:
+
+* `total_heap_size` {number}
+* `total_heap_size_executable` {number}
+* `total_physical_size` {number}
+* `total_available_size` {number}
+* `used_heap_size` {number}
+* `heap_size_limit` {number}
+* `malloced_memory` {number}
+* `peak_malloced_memory` {number}
+* `does_zap_garbage` {number}
+
+`does_zap_garbage` is a 0/1 boolean, which signifies whether the `--zap_code_space`
+option is enabled or not. This makes V8 overwrite heap garbage with a bit
+pattern. The RSS footprint (resident memory set) gets bigger because it
+continuously touches all heap pages and that makes them less likely to get
+swapped out by the operating system.
+
+For example:
+
+```js
+{
+ total_heap_size: 7326976,
+ total_heap_size_executable: 4194304,
+ total_physical_size: 7326976,
+ total_available_size: 1152656,
+ used_heap_size: 3476208,
+ heap_size_limit: 1535115264,
+ malloced_memory: 16384,
+ peak_malloced_memory: 1127496,
+ does_zap_garbage: 0
+}
+```
+
## v8.setFlagsFromString(string)
* `code` {string} The JavaScript code to compile.
@@ -60,6 +65,10 @@ each run, just for that run.
### script.runInContext(contextifiedSandbox[, options])
* `contextifiedSandbox` {Object} A [contextified][] object as returned by the
diff --git a/doc/api/zlib.md b/doc/api/zlib.md
index 0d79c084acd565..5b02a8ed37d278 100644
--- a/doc/api/zlib.md
+++ b/doc/api/zlib.md
@@ -277,6 +277,10 @@ Compression strategy.
## Class Options
@@ -315,6 +319,17 @@ Compress data using deflate, and do not append a `zlib` header.
## Class: zlib.Gunzip
Decompress a gzip stream.
@@ -329,6 +344,10 @@ Compress data using gzip.
## Class: zlib.Inflate
Decompress a deflate stream.
@@ -336,6 +355,13 @@ Decompress a deflate stream.
## Class: zlib.InflateRaw
Decompress a raw deflate stream.
diff --git a/doc/api_assets/style.css b/doc/api_assets/style.css
index f45c4672af88f8..7889389f59b251 100644
--- a/doc/api_assets/style.css
+++ b/doc/api_assets/style.css
@@ -470,6 +470,12 @@ th > *:last-child, td > *:last-child {
margin-bottom: 0;
}
+.changelog > summary {
+ margin: .5rem 0;
+ padding: .5rem 0;
+ cursor: pointer;
+}
+
/* simpler clearfix */
.clearfix:after {
content: ".";
diff --git a/doc/changelogs/CHANGELOG_V7.md b/doc/changelogs/CHANGELOG_V7.md
index 3355de15e35795..b1d3310a0668e9 100644
--- a/doc/changelogs/CHANGELOG_V7.md
+++ b/doc/changelogs/CHANGELOG_V7.md
@@ -6,6 +6,7 @@
+7.7.0 7.6.0 7.5.0 7.4.0 UVException(Isolate* isolate,
// Look up environment variable unless running as setuid root.
-inline const char* secure_getenv(const char* key) {
+bool SafeGetenv(const char* key, std::string* text) {
#ifndef _WIN32
- if (getuid() != geteuid() || getgid() != getegid())
- return nullptr;
+ // TODO(bnoordhuis) Should perhaps also check whether getauxval(AT_SECURE)
+ // is non-zero on Linux.
+ if (getuid() != geteuid() || getgid() != getegid()) {
+ text->clear();
+ return false;
+ }
#endif
- return getenv(key);
+ if (const char* value = getenv(key)) {
+ *text = value;
+ return true;
+ }
+ text->clear();
+ return false;
}
@@ -2238,25 +2252,22 @@ void MemoryUsage(const FunctionCallbackInfo& args) {
return env->ThrowUVException(err, "uv_resident_set_memory");
}
+ Isolate* isolate = env->isolate();
// V8 memory usage
HeapStatistics v8_heap_stats;
- env->isolate()->GetHeapStatistics(&v8_heap_stats);
-
- Local heap_total =
- Number::New(env->isolate(), v8_heap_stats.total_heap_size());
- Local heap_used =
- Number::New(env->isolate(), v8_heap_stats.used_heap_size());
- Local external_mem =
- Number::New(env->isolate(),
- env->isolate()->AdjustAmountOfExternalAllocatedMemory(0));
+ isolate->GetHeapStatistics(&v8_heap_stats);
- Local info = Object::New(env->isolate());
- info->Set(env->rss_string(), Number::New(env->isolate(), rss));
- info->Set(env->heap_total_string(), heap_total);
- info->Set(env->heap_used_string(), heap_used);
- info->Set(env->external_string(), external_mem);
+ // Get the double array pointer from the Float64Array argument.
+ CHECK(args[0]->IsFloat64Array());
+ Local array = args[0].As();
+ CHECK_EQ(array->Length(), 4);
+ Local ab = array->Buffer();
+ double* fields = static_cast(ab->GetContents().Data());
- args.GetReturnValue().Set(info);
+ fields[0] = rss;
+ fields[1] = v8_heap_stats.total_heap_size();
+ fields[2] = v8_heap_stats.used_heap_size();
+ fields[3] = isolate->AdjustAmountOfExternalAllocatedMemory(0);
}
@@ -2368,8 +2379,6 @@ struct node_module* get_linked_module(const char* name) {
return mp;
}
-typedef void (UV_DYNAMIC* extInit)(Local exports);
-
// DLOpen is process.dlopen(module, filename).
// Used to load 'module.node' dynamically shared objects.
//
@@ -3060,17 +3069,6 @@ void SetupProcessObject(Environment* env,
"ares",
FIXED_ONE_BYTE_STRING(env->isolate(), ARES_VERSION_STR));
-#if defined(NODE_HAVE_I18N_SUPPORT) && defined(U_ICU_VERSION)
- // ICU-related versions are now handled on the js side, see bootstrap_node.js
-
- if (icu_data_dir != nullptr) {
- // Did the user attempt (via env var or parameter) to set an ICU path?
- READONLY_PROPERTY(process,
- "icu_data_dir",
- OneByteString(env->isolate(), icu_data_dir));
- }
-#endif
-
const char node_modules_version[] = NODE_STRINGIFY(NODE_MODULE_VERSION);
READONLY_PROPERTY(
versions,
@@ -3376,6 +3374,9 @@ void SetupProcessObject(Environment* env,
void SignalExit(int signo) {
uv_tty_reset_mode();
+ if (trace_enabled) {
+ tracing_agent->Stop();
+ }
#ifdef __FreeBSD__
// FreeBSD has a nasty bug, see RegisterSignalHandler for details
struct sigaction sa;
@@ -3521,8 +3522,9 @@ static void PrintHelp() {
" --enable-fips enable FIPS crypto at startup\n"
" --force-fips force FIPS crypto (cannot be disabled)\n"
#endif /* NODE_FIPS_MODE */
- " --openssl-config=path load OpenSSL configuration file from\n"
- " the specified path\n"
+ " --openssl-config=file load OpenSSL configuration from the\n"
+ " specified file (overrides\n"
+ " OPENSSL_CONF)\n"
#endif /* HAVE_OPENSSL */
#if defined(NODE_HAVE_I18N_SUPPORT)
" --icu-data-dir=dir set ICU data load path to dir\n"
@@ -3555,6 +3557,8 @@ static void PrintHelp() {
" prefixed to the module search path\n"
"NODE_REPL_HISTORY path to the persistent REPL history\n"
" file\n"
+ "OPENSSL_CONF load OpenSSL configuration from file\n"
+ "\n"
"Documentation can be found at https://nodejs.org/\n");
}
@@ -3659,6 +3663,16 @@ static void ParseArgs(int* argc,
trace_deprecation = true;
} else if (strcmp(arg, "--trace-sync-io") == 0) {
trace_sync_io = true;
+ } else if (strcmp(arg, "--trace-events-enabled") == 0) {
+ trace_enabled = true;
+ } else if (strcmp(arg, "--trace-event-categories") == 0) {
+ const char* categories = argv[index + 1];
+ if (categories == nullptr) {
+ fprintf(stderr, "%s: %s requires an argument\n", argv[0], arg);
+ exit(9);
+ }
+ args_consumed += 1;
+ trace_enabled_categories = categories;
} else if (strcmp(arg, "--track-heap-objects") == 0) {
track_heap_objects = true;
} else if (strcmp(arg, "--throw-deprecation") == 0) {
@@ -3692,11 +3706,11 @@ static void ParseArgs(int* argc,
force_fips_crypto = true;
#endif /* NODE_FIPS_MODE */
} else if (strncmp(arg, "--openssl-config=", 17) == 0) {
- openssl_config = arg + 17;
+ openssl_config.assign(arg + 17);
#endif /* HAVE_OPENSSL */
#if defined(NODE_HAVE_I18N_SUPPORT)
} else if (strncmp(arg, "--icu-data-dir=", 15) == 0) {
- icu_data_dir = arg + 15;
+ icu_data_dir.assign(arg + 15);
#endif
} else if (strcmp(arg, "--expose-internals") == 0 ||
strcmp(arg, "--expose_internals") == 0) {
@@ -4183,10 +4197,15 @@ void Init(int* argc,
#endif
// Allow for environment set preserving symlinks.
- if (auto preserve_symlinks = secure_getenv("NODE_PRESERVE_SYMLINKS")) {
- config_preserve_symlinks = (*preserve_symlinks == '1');
+ {
+ std::string text;
+ config_preserve_symlinks =
+ SafeGetenv("NODE_PRESERVE_SYMLINKS", &text) && text[0] == '1';
}
+ if (openssl_config.empty())
+ SafeGetenv("OPENSSL_CONF", &openssl_config);
+
// Parse a few arguments which are specific to Node.
int v8_argc;
const char** v8_argv;
@@ -4213,12 +4232,11 @@ void Init(int* argc,
#endif
#if defined(NODE_HAVE_I18N_SUPPORT)
- if (icu_data_dir == nullptr) {
- // if the parameter isn't given, use the env variable.
- icu_data_dir = secure_getenv("NODE_ICU_DATA");
- }
+ // If the parameter isn't given, use the env variable.
+ if (icu_data_dir.empty())
+ SafeGetenv("NODE_ICU_DATA", &icu_data_dir);
// Initialize ICU.
- // If icu_data_dir is nullptr here, it will load the 'minimal' data.
+ // If icu_data_dir is empty here, it will load the 'minimal' data.
if (!i18n::InitializeICUDirectory(icu_data_dir)) {
FatalError(nullptr, "Could not initialize ICU "
"(check NODE_ICU_DATA or --icu-data-dir parameters)");
@@ -4483,8 +4501,11 @@ int Start(int argc, char** argv) {
Init(&argc, const_cast(argv), &exec_argc, &exec_argv);
#if HAVE_OPENSSL
- if (const char* extra = secure_getenv("NODE_EXTRA_CA_CERTS"))
- crypto::UseExtraCaCerts(extra);
+ {
+ std::string extra_ca_certs;
+ if (SafeGetenv("NODE_EXTRA_CA_CERTS", &extra_ca_certs))
+ crypto::UseExtraCaCerts(extra_ca_certs);
+ }
#ifdef NODE_FIPS_MODE
// In the case of FIPS builds we should make sure
// the random source is properly initialized first.
@@ -4493,13 +4514,23 @@ int Start(int argc, char** argv) {
// V8 on Windows doesn't have a good source of entropy. Seed it from
// OpenSSL's pool.
V8::SetEntropySource(crypto::EntropySource);
-#endif
+#endif // HAVE_OPENSSL
v8_platform.Initialize(v8_thread_pool_size);
+ // Enable tracing when argv has --trace-events-enabled.
+ if (trace_enabled) {
+ fprintf(stderr, "Warning: Trace event is an experimental feature "
+ "and could change at any time.\n");
+ tracing_agent = new tracing::Agent();
+ tracing_agent->Start(v8_platform.platform_, trace_enabled_categories);
+ }
V8::Initialize();
v8_initialized = true;
const int exit_code =
Start(uv_default_loop(), argc, argv, exec_argc, exec_argv);
+ if (trace_enabled) {
+ tracing_agent->Stop();
+ }
v8_initialized = false;
V8::Dispose();
diff --git a/src/node.h b/src/node.h
index 1255a4af7f11ce..24ebce87c8fdfc 100644
--- a/src/node.h
+++ b/src/node.h
@@ -41,6 +41,7 @@
#include "v8.h" // NOLINT(build/include_order)
#include "node_version.h" // NODE_MODULE_VERSION
+#include "tracing/trace_event.h"
#define NODE_MAKE_VERSION(major, minor, patch) \
((major) * 0x1000 + (minor) * 0x100 + (patch))
diff --git a/src/node_config.cc b/src/node_config.cc
index 401345f6a608be..98b219c3e81d1b 100644
--- a/src/node_config.cc
+++ b/src/node_config.cc
@@ -38,8 +38,11 @@ void InitConfig(Local target,
READONLY_BOOLEAN_PROPERTY("hasSmallICU");
#endif // NODE_HAVE_SMALL_ICU
- if (flag_icu_data_dir)
- READONLY_BOOLEAN_PROPERTY("usingICUDataDir");
+ target->DefineOwnProperty(env->context(),
+ OneByteString(env->isolate(), "icuDataDir"),
+ OneByteString(env->isolate(), icu_data_dir.data()))
+ .FromJust();
+
#endif // NODE_HAVE_I18N_SUPPORT
if (config_preserve_symlinks)
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index ff66ffdaaa0467..9b0ab4ea262d41 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -261,7 +261,8 @@ class ContextifyContext {
Environment* env = Environment::GetCurrent(args);
if (debug_context.IsEmpty()) {
// Force-load the debug context.
- Debug::GetMirror(args.GetIsolate()->GetCurrentContext(), args[0]);
+ auto dummy_event_listener = [] (const Debug::EventDetails&) {};
+ Debug::SetDebugEventListener(args.GetIsolate(), dummy_event_listener);
debug_context = Debug::GetDebugContext(args.GetIsolate());
CHECK(!debug_context.IsEmpty());
// Ensure that the debug context has an Environment assigned in case
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 072a48f40c58dc..d9f056682013b5 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -1813,7 +1813,6 @@ template
void SSLWrap& args) {
Base* w;
ASSIGN_OR_RETURN_UNWRAP(&w, args.Holder());
- Environment* env = w->ssl_env();
if (args.Length() >= 1 && Buffer::HasInstance(args[0])) {
ssize_t slen = Buffer::Length(args[0]);
@@ -5881,14 +5880,14 @@ void InitCryptoOnce() {
OPENSSL_no_config();
// --openssl-config=...
- if (openssl_config != nullptr) {
+ if (!openssl_config.empty()) {
OPENSSL_load_builtin_modules();
#ifndef OPENSSL_NO_ENGINE
ENGINE_load_builtin_engines();
#endif
ERR_clear_error();
CONF_modules_load_file(
- openssl_config,
+ openssl_config.c_str(),
nullptr,
CONF_MFLAGS_DEFAULT_SECTION);
int err = ERR_get_error();
diff --git a/src/node_file.cc b/src/node_file.cc
index 0abb88088786ae..99048b223478df 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -27,8 +27,10 @@
namespace node {
using v8::Array;
+using v8::ArrayBuffer;
using v8::Context;
using v8::EscapableHandleScope;
+using v8::Float64Array;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
@@ -528,6 +530,37 @@ Local BuildStatsObject(Environment* env, const uv_stat_t* s) {
return handle_scope.Escape(stats);
}
+void FillStatsArray(double* fields, const uv_stat_t* s) {
+ fields[0] = s->st_dev;
+ fields[1] = s->st_mode;
+ fields[2] = s->st_nlink;
+ fields[3] = s->st_uid;
+ fields[4] = s->st_gid;
+ fields[5] = s->st_rdev;
+#if defined(__POSIX__)
+ fields[6] = s->st_blksize;
+#else
+ fields[6] = -1;
+#endif
+ fields[7] = s->st_ino;
+ fields[8] = s->st_size;
+#if defined(__POSIX__)
+ fields[9] = s->st_blocks;
+#else
+ fields[9] = -1;
+#endif
+ // Dates.
+#define X(idx, name) \
+ fields[idx] = (static_cast(s->st_##name.tv_sec) * 1000) + \
+ (static_cast(s->st_##name.tv_nsec / 1000000)); \
+
+ X(10, atim)
+ X(11, mtim)
+ X(12, ctim)
+ X(13, birthtim)
+#undef X
+}
+
// Used to speed up module loading. Returns the contents of the file as
// a string or undefined when the file cannot be opened. The speedup
// comes from not creating Error objects on failure.
@@ -612,12 +645,15 @@ static void Stat(const FunctionCallbackInfo& args) {
BufferValue path(env->isolate(), args[0]);
ASSERT_PATH(path)
- if (args[1]->IsObject()) {
- ASYNC_CALL(stat, args[1], UTF8, *path)
- } else {
+ if (args[1]->IsFloat64Array()) {
+ Local array = args[1].As();
+ CHECK_EQ(array->Length(), 14);
+ Local ab = array->Buffer();
+ double* fields = static_cast(ab->GetContents().Data());
SYNC_CALL(stat, *path, *path)
- args.GetReturnValue().Set(
- BuildStatsObject(env, static_cast(SYNC_REQ.ptr)));
+ FillStatsArray(fields, static_cast(SYNC_REQ.ptr));
+ } else if (args[1]->IsObject()) {
+ ASYNC_CALL(stat, args[1], UTF8, *path)
}
}
@@ -630,12 +666,15 @@ static void LStat(const FunctionCallbackInfo& args) {
BufferValue path(env->isolate(), args[0]);
ASSERT_PATH(path)
- if (args[1]->IsObject()) {
- ASYNC_CALL(lstat, args[1], UTF8, *path)
- } else {
+ if (args[1]->IsFloat64Array()) {
+ Local array = args[1].As();
+ CHECK_EQ(array->Length(), 14);
+ Local ab = array->Buffer();
+ double* fields = static_cast(ab->GetContents().Data());
SYNC_CALL(lstat, *path, *path)
- args.GetReturnValue().Set(
- BuildStatsObject(env, static_cast(SYNC_REQ.ptr)));
+ FillStatsArray(fields, static_cast(SYNC_REQ.ptr));
+ } else if (args[1]->IsObject()) {
+ ASYNC_CALL(lstat, args[1], UTF8, *path)
}
}
@@ -649,12 +688,15 @@ static void FStat(const FunctionCallbackInfo& args) {
int fd = args[0]->Int32Value();
- if (args[1]->IsObject()) {
- ASYNC_CALL(fstat, args[1], UTF8, fd)
- } else {
+ if (args[1]->IsFloat64Array()) {
+ Local array = args[1].As();
+ CHECK_EQ(array->Length(), 14);
+ Local ab = array->Buffer();
+ double* fields = static_cast(ab->GetContents().Data());
SYNC_CALL(fstat, 0, fd)
- args.GetReturnValue().Set(
- BuildStatsObject(env, static_cast(SYNC_REQ.ptr)));
+ FillStatsArray(fields, static_cast(SYNC_REQ.ptr));
+ } else if (args[1]->IsObject()) {
+ ASYNC_CALL(fstat, args[1], UTF8, fd)
}
}
diff --git a/src/node_http_parser.cc b/src/node_http_parser.cc
index f757cd6797058d..bc9b5d953e8ebf 100644
--- a/src/node_http_parser.cc
+++ b/src/node_http_parser.cc
@@ -15,7 +15,7 @@
#include // free()
#include // strdup()
-// This is a binding to http_parser (https://github.com/joyent/http-parser)
+// This is a binding to http_parser (https://github.com/nodejs/http-parser)
// The goal is to decouple sockets from parsing for more javascript-level
// agility. A Buffer is read from a socket and passed to parser.execute().
// The parser then issues callbacks with slices of the data
diff --git a/src/node_i18n.cc b/src/node_i18n.cc
index a98fdca4d1bffd..ae14aed7c6b4c2 100644
--- a/src/node_i18n.cc
+++ b/src/node_i18n.cc
@@ -70,41 +70,21 @@ using v8::Object;
using v8::String;
using v8::Value;
-bool flag_icu_data_dir = false;
-
namespace i18n {
-const size_t kStorageSize = 1024;
-
-// TODO(jasnell): This could potentially become a member of MaybeStackBuffer
-// at some point in the future. Care would need to be taken with the
-// MaybeStackBuffer variant below.
-MaybeLocal AsBuffer(Isolate* isolate,
- MaybeStackBuffer* buf,
- size_t len) {
- if (buf->IsAllocated()) {
- MaybeLocal ret = Buffer::New(isolate, buf->out(), len);
- if (!ret.IsEmpty()) buf->Release();
+template
+MaybeLocal ToBufferEndian(Environment* env, MaybeStackBuffer* buf) {
+ MaybeLocal ret = Buffer::New(env, buf);
+ if (ret.IsEmpty())
return ret;
- }
- return Buffer::Copy(isolate, buf->out(), len);
-}
-MaybeLocal AsBuffer(Isolate* isolate,
- MaybeStackBuffer* buf,
- size_t len) {
- char* dst = reinterpret_cast(**buf);
- MaybeLocal ret;
- if (buf->IsAllocated()) {
- ret = Buffer::New(isolate, dst, len);
- if (!ret.IsEmpty()) buf->Release();
- } else {
- ret = Buffer::Copy(isolate, dst, len);
- }
- if (!ret.IsEmpty() && IsBigEndian()) {
- SPREAD_BUFFER_ARG(ret.ToLocalChecked(), buf);
- SwapBytes16(buf_data, buf_length);
+ static_assert(sizeof(T) == 1 || sizeof(T) == 2,
+ "Currently only one- or two-byte buffers are supported");
+ if (sizeof(T) > 1 && IsBigEndian()) {
+ SPREAD_BUFFER_ARG(ret.ToLocalChecked(), retbuf);
+ SwapBytes16(retbuf_data, retbuf_length);
}
+
return ret;
}
@@ -140,14 +120,14 @@ void CopySourceBuffer(MaybeStackBuffer* dest,
}
}
-typedef MaybeLocal (*TranscodeFunc)(Isolate* isolate,
+typedef MaybeLocal (*TranscodeFunc)(Environment* env,
const char* fromEncoding,
const char* toEncoding,
const char* source,
const size_t source_length,
UErrorCode* status);
-MaybeLocal Transcode(Isolate* isolate,
+MaybeLocal Transcode(Environment* env,
const char* fromEncoding,
const char* toEncoding,
const char* source,
@@ -164,12 +144,14 @@ MaybeLocal Transcode(Isolate* isolate,
ucnv_convertEx(to.conv, from.conv, &target, target + limit,
&source, source + source_length, nullptr, nullptr,
nullptr, nullptr, true, true, status);
- if (U_SUCCESS(*status))
- ret = AsBuffer(isolate, &result, target - &result[0]);
+ if (U_SUCCESS(*status)) {
+ result.SetLength(target - &result[0]);
+ ret = ToBufferEndian(env, &result);
+ }
return ret;
}
-MaybeLocal TranscodeToUcs2(Isolate* isolate,
+MaybeLocal TranscodeToUcs2(Environment* env,
const char* fromEncoding,
const char* toEncoding,
const char* source,
@@ -183,11 +165,11 @@ MaybeLocal TranscodeToUcs2(Isolate* isolate,
ucnv_toUChars(from.conv, *destbuf, length_in_chars,
source, source_length, status);
if (U_SUCCESS(*status))
- ret = AsBuffer(isolate, &destbuf, length_in_chars);
+ ret = ToBufferEndian(env, &destbuf);
return ret;
}
-MaybeLocal TranscodeFromUcs2(Isolate* isolate,
+MaybeLocal TranscodeFromUcs2(Environment* env,
const char* fromEncoding,
const char* toEncoding,
const char* source,
@@ -202,37 +184,42 @@ MaybeLocal TranscodeFromUcs2(Isolate* isolate,
MaybeStackBuffer destbuf(length_in_chars);
const uint32_t len = ucnv_fromUChars(to.conv, *destbuf, length_in_chars,
*sourcebuf, length_in_chars, status);
- if (U_SUCCESS(*status))
- ret = AsBuffer(isolate, &destbuf, len);
+ if (U_SUCCESS(*status)) {
+ destbuf.SetLength(len);
+ ret = ToBufferEndian(env, &destbuf);
+ }
return ret;
}
-MaybeLocal TranscodeUcs2FromUtf8(Isolate* isolate,
+MaybeLocal TranscodeUcs2FromUtf8(Environment* env,
const char* fromEncoding,
const char* toEncoding,
const char* source,
const size_t source_length,
UErrorCode* status) {
*status = U_ZERO_ERROR;
- MaybeStackBuffer destbuf;
+ MaybeStackBuffer destbuf;
int32_t result_length;
- u_strFromUTF8(*destbuf, kStorageSize, &result_length,
+ u_strFromUTF8(*destbuf, destbuf.capacity(), &result_length,
source, source_length, status);
MaybeLocal ret;
if (U_SUCCESS(*status)) {
- ret = AsBuffer(isolate, &destbuf, result_length * sizeof(**destbuf));
+ destbuf.SetLength(result_length);
+ ret = ToBufferEndian(env, &destbuf);
} else if (*status == U_BUFFER_OVERFLOW_ERROR) {
*status = U_ZERO_ERROR;
destbuf.AllocateSufficientStorage(result_length);
u_strFromUTF8(*destbuf, result_length, &result_length,
source, source_length, status);
- if (U_SUCCESS(*status))
- ret = AsBuffer(isolate, &destbuf, result_length * sizeof(**destbuf));
+ if (U_SUCCESS(*status)) {
+ destbuf.SetLength(result_length);
+ ret = ToBufferEndian(env, &destbuf);
+ }
}
return ret;
}
-MaybeLocal TranscodeUtf8FromUcs2(Isolate* isolate,
+MaybeLocal TranscodeUtf8FromUcs2(Environment* env,
const char* fromEncoding,
const char* toEncoding,
const char* source,
@@ -243,20 +230,21 @@ MaybeLocal TranscodeUtf8FromUcs2(Isolate* isolate,
const size_t length_in_chars = source_length / sizeof(UChar);
int32_t result_length;
MaybeStackBuffer sourcebuf;
- MaybeStackBuffer destbuf;
+ MaybeStackBuffer destbuf;
CopySourceBuffer(&sourcebuf, source, source_length, length_in_chars);
- u_strToUTF8(*destbuf, kStorageSize, &result_length,
+ u_strToUTF8(*destbuf, destbuf.capacity(), &result_length,
*sourcebuf, length_in_chars, status);
if (U_SUCCESS(*status)) {
- ret = AsBuffer(isolate, &destbuf, result_length);
+ destbuf.SetLength(result_length);
+ ret = ToBufferEndian(env, &destbuf);
} else if (*status == U_BUFFER_OVERFLOW_ERROR) {
*status = U_ZERO_ERROR;
destbuf.AllocateSufficientStorage(result_length);
u_strToUTF8(*destbuf, result_length, &result_length, *sourcebuf,
length_in_chars, status);
if (U_SUCCESS(*status)) {
- ret = Buffer::New(isolate, *destbuf, result_length);
- destbuf.Release();
+ destbuf.SetLength(result_length);
+ ret = ToBufferEndian(env, &destbuf);
}
}
return ret;
@@ -322,7 +310,7 @@ void Transcode(const FunctionCallbackInfo&args) {
ABORT();
}
- result = tfn(isolate, EncodingName(fromEncoding), EncodingName(toEncoding),
+ result = tfn(env, EncodingName(fromEncoding), EncodingName(toEncoding),
ts_obj_data, ts_obj_length, &status);
} else {
status = U_ILLEGAL_ARGUMENT_ERROR;
@@ -404,12 +392,8 @@ static void GetVersion(const FunctionCallbackInfo& args) {
}
}
-bool InitializeICUDirectory(const char* icu_data_path) {
- if (icu_data_path != nullptr) {
- flag_icu_data_dir = true;
- u_setDataDirectory(icu_data_path);
- return true; // no error
- } else {
+bool InitializeICUDirectory(const std::string& path) {
+ if (path.empty()) {
UErrorCode status = U_ZERO_ERROR;
#ifdef NODE_HAVE_SMALL_ICU
// install the 'small' data.
@@ -418,6 +402,9 @@ bool InitializeICUDirectory(const char* icu_data_path) {
// no small data, so nothing to do.
#endif // !NODE_HAVE_SMALL_ICU
return (status == U_ZERO_ERROR);
+ } else {
+ u_setDataDirectory(path.c_str());
+ return true; // No error.
}
}
@@ -434,7 +421,7 @@ int32_t ToUnicode(MaybeStackBuffer* buf,
int32_t len = uidna_nameToUnicodeUTF8(uidna,
input, length,
- **buf, buf->length(),
+ **buf, buf->capacity(),
&info,
&status);
@@ -443,13 +430,17 @@ int32_t ToUnicode(MaybeStackBuffer* buf,
buf->AllocateSufficientStorage(len);
len = uidna_nameToUnicodeUTF8(uidna,
input, length,
- **buf, buf->length(),
+ **buf, buf->capacity(),
&info,
&status);
}
- if (U_FAILURE(status))
+ if (U_FAILURE(status)) {
len = -1;
+ buf->SetLength(0);
+ } else {
+ buf->SetLength(len);
+ }
uidna_close(uidna);
return len;
@@ -468,7 +459,7 @@ int32_t ToASCII(MaybeStackBuffer* buf,
int32_t len = uidna_nameToASCII_UTF8(uidna,
input, length,
- **buf, buf->length(),
+ **buf, buf->capacity(),
&info,
&status);
@@ -477,13 +468,17 @@ int32_t ToASCII(MaybeStackBuffer* buf,
buf->AllocateSufficientStorage(len);
len = uidna_nameToASCII_UTF8(uidna,
input, length,
- **buf, buf->length(),
+ **buf, buf->capacity(),
&info,
&status);
}
- if (U_FAILURE(status))
+ if (U_FAILURE(status)) {
len = -1;
+ buf->SetLength(0);
+ } else {
+ buf->SetLength(len);
+ }
uidna_close(uidna);
return len;
diff --git a/src/node_i18n.h b/src/node_i18n.h
index 21a579526ddc1a..21567eeb3ec38f 100644
--- a/src/node_i18n.h
+++ b/src/node_i18n.h
@@ -4,16 +4,17 @@
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#include "node.h"
+#include
#if defined(NODE_HAVE_I18N_SUPPORT)
namespace node {
-extern bool flag_icu_data_dir;
+extern std::string icu_data_dir; // NOLINT(runtime/string)
namespace i18n {
-bool InitializeICUDirectory(const char* icu_data_path);
+bool InitializeICUDirectory(const std::string& path);
int32_t ToASCII(MaybeStackBuffer* buf,
const char* input,
diff --git a/src/node_internals.h b/src/node_internals.h
index 0a65be7642ff2a..b68594162b8ab8 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -12,6 +12,8 @@
#include
#include
+#include
+
struct sockaddr;
// Variation on NODE_DEFINE_CONSTANT that sets a String value.
@@ -34,7 +36,7 @@ namespace node {
// Set in node.cc by ParseArgs with the value of --openssl-config.
// Used in node_crypto.cc when initializing OpenSSL.
-extern const char* openssl_config;
+extern std::string openssl_config;
// Set in node.cc by ParseArgs when --preserve-symlinks is used.
// Used in node_config.cc to set a constant on process.binding('config')
@@ -106,6 +108,8 @@ void RegisterSignalHandler(int signal,
bool reset_handler = false);
#endif
+bool SafeGetenv(const char* key, std::string* text);
+
template
constexpr size_t arraysize(const T(&)[N]) { return N; }
@@ -194,6 +198,35 @@ v8::MaybeLocal New(Environment* env,
// because ArrayBufferAllocator::Free() deallocates it again with free().
// Mixing operator new and free() is undefined behavior so don't do that.
v8::MaybeLocal New(Environment* env, char* data, size_t length);
+
+// Construct a Buffer from a MaybeStackBuffer (and also its subclasses like
+// Utf8Value and TwoByteValue).
+// If |buf| is invalidated, an empty MaybeLocal is returned, and nothing is
+// changed.
+// If |buf| contains actual data, this method takes ownership of |buf|'s
+// underlying buffer. However, |buf| itself can be reused even after this call,
+// but its capacity, if increased through AllocateSufficientStorage, is not
+// guaranteed to stay the same.
+template
+static v8::MaybeLocal New(Environment* env,
+ MaybeStackBuffer* buf) {
+ v8::MaybeLocal ret;
+ char* src = reinterpret_cast(buf->out());
+ const size_t len_in_bytes = buf->length() * sizeof(buf->out()[0]);
+
+ if (buf->IsAllocated())
+ ret = New(env, src, len_in_bytes);
+ else if (!buf->IsInvalidated())
+ ret = Copy(env, src, len_in_bytes);
+
+ if (ret.IsEmpty())
+ return ret;
+
+ if (buf->IsAllocated())
+ buf->Release();
+
+ return ret;
+}
} // namespace Buffer
} // namespace node
diff --git a/src/node_os.cc b/src/node_os.cc
index 97b1a1d08da6ed..211ac3d01dd8b2 100644
--- a/src/node_os.cc
+++ b/src/node_os.cc
@@ -28,8 +28,10 @@ namespace node {
namespace os {
using v8::Array;
+using v8::ArrayBuffer;
using v8::Boolean;
using v8::Context;
+using v8::Float64Array;
using v8::FunctionCallbackInfo;
using v8::Integer;
using v8::Local;
@@ -182,14 +184,12 @@ static void GetUptime(const FunctionCallbackInfo& args) {
static void GetLoadAvg(const FunctionCallbackInfo& args) {
- Environment* env = Environment::GetCurrent(args);
- double loadavg[3];
+ CHECK(args[0]->IsFloat64Array());
+ Local array = args[0].As();
+ CHECK_EQ(array->Length(), 3);
+ Local ab = array->Buffer();
+ double* loadavg = static_cast(ab->GetContents().Data());
uv_loadavg(loadavg);
- Local loads = Array::New(env->isolate(), 3);
- loads->Set(0, Number::New(env->isolate(), loadavg[0]));
- loads->Set(1, Number::New(env->isolate(), loadavg[1]));
- loads->Set(2, Number::New(env->isolate(), loadavg[2]));
- args.GetReturnValue().Set(loads);
}
diff --git a/src/node_url.cc b/src/node_url.cc
index 0d5e695a3c13a5..5027399e89dd71 100644
--- a/src/node_url.cc
+++ b/src/node_url.cc
@@ -1074,8 +1074,10 @@ namespace url {
SET_HAVE_QUERY()
url.query = base.query;
}
+ break;
}
- break;
+ state = kPath;
+ continue;
case '\\':
case '/':
state = kFileSlash;
@@ -1092,8 +1094,8 @@ namespace url {
}
SET_HAVE_QUERY()
state = kQuery;
+ break;
}
- break;
case '#':
if (base_is_file) {
if (DOES_HAVE_HOST(base)) {
@@ -1109,8 +1111,8 @@ namespace url {
url.query = base.query;
}
state = kFragment;
+ break;
}
- break;
default:
if (base_is_file &&
(!WINDOWS_DRIVE_LETTER(ch, p[1]) ||
diff --git a/src/node_version.h b/src/node_version.h
index 7175e5824dd26d..48c5a3b2b807bf 100644
--- a/src/node_version.h
+++ b/src/node_version.h
@@ -2,10 +2,10 @@
#define SRC_NODE_VERSION_H_
#define NODE_MAJOR_VERSION 7
-#define NODE_MINOR_VERSION 6
-#define NODE_PATCH_VERSION 1
+#define NODE_MINOR_VERSION 7
+#define NODE_PATCH_VERSION 0
-#define NODE_VERSION_IS_RELEASE 0
+#define NODE_VERSION_IS_RELEASE 1
#ifndef NODE_STRINGIFY
#define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)
diff --git a/src/spawn_sync.cc b/src/spawn_sync.cc
index 79f10a0ea2594d..3fcd61f22a4614 100644
--- a/src/spawn_sync.cc
+++ b/src/spawn_sync.cc
@@ -645,12 +645,17 @@ Local SyncProcessRunner::BuildResultObject() {
Integer::New(env()->isolate(), GetError()));
}
- if (exit_status_ >= 0)
- js_result->Set(env()->status_string(),
- Number::New(env()->isolate(), static_cast(exit_status_)));
- else
+ if (exit_status_ >= 0) {
+ if (term_signal_ > 0) {
+ js_result->Set(env()->status_string(), Null(env()->isolate()));
+ } else {
+ js_result->Set(env()->status_string(),
+ Number::New(env()->isolate(), static_cast(exit_status_)));
+ }
+ } else {
// If exit_status_ < 0 the process was never started because of some error.
js_result->Set(env()->status_string(), Null(env()->isolate()));
+ }
if (term_signal_ > 0)
js_result->Set(env()->signal_string(),
diff --git a/src/tracing/agent.cc b/src/tracing/agent.cc
new file mode 100644
index 00000000000000..97a3e11a2c458c
--- /dev/null
+++ b/src/tracing/agent.cc
@@ -0,0 +1,72 @@
+#include "tracing/agent.h"
+
+#include
+#include
+
+#include "env-inl.h"
+#include "libplatform/libplatform.h"
+
+namespace node {
+namespace tracing {
+
+using v8::platform::tracing::TraceConfig;
+
+Agent::Agent() {}
+
+void Agent::Start(v8::Platform* platform, const char* enabled_categories) {
+ platform_ = platform;
+
+ int err = uv_loop_init(&tracing_loop_);
+ CHECK_EQ(err, 0);
+
+ NodeTraceWriter* trace_writer = new NodeTraceWriter(&tracing_loop_);
+ TraceBuffer* trace_buffer = new NodeTraceBuffer(
+ NodeTraceBuffer::kBufferChunks, trace_writer, &tracing_loop_);
+
+ tracing_controller_ = new TracingController();
+
+ TraceConfig* trace_config = new TraceConfig();
+ if (enabled_categories) {
+ std::stringstream category_list(enabled_categories);
+ while (category_list.good()) {
+ std::string category;
+ getline(category_list, category, ',');
+ trace_config->AddIncludedCategory(category.c_str());
+ }
+ } else {
+ trace_config->AddIncludedCategory("v8");
+ trace_config->AddIncludedCategory("node");
+ }
+
+ // This thread should be created *after* async handles are created
+ // (within NodeTraceWriter and NodeTraceBuffer constructors).
+ // Otherwise the thread could shut down prematurely.
+ err = uv_thread_create(&thread_, ThreadCb, this);
+ CHECK_EQ(err, 0);
+
+ tracing_controller_->Initialize(trace_buffer);
+ tracing_controller_->StartTracing(trace_config);
+ v8::platform::SetTracingController(platform, tracing_controller_);
+}
+
+void Agent::Stop() {
+ if (!IsStarted()) {
+ return;
+ }
+ // Perform final Flush on TraceBuffer. We don't want the tracing controller
+ // to flush the buffer again on destruction of the V8::Platform.
+ tracing_controller_->StopTracing();
+ delete tracing_controller_;
+ // Thread should finish when the tracing loop is stopped.
+ uv_thread_join(&thread_);
+ v8::platform::SetTracingController(platform_, nullptr);
+}
+
+// static
+void Agent::ThreadCb(void* arg) {
+ Agent* agent = static_cast(arg);
+ uv_run(&agent->tracing_loop_, UV_RUN_DEFAULT);
+}
+
+} // namespace tracing
+} // namespace node
diff --git a/src/tracing/agent.h b/src/tracing/agent.h
new file mode 100644
index 00000000000000..098f955192e0cf
--- /dev/null
+++ b/src/tracing/agent.h
@@ -0,0 +1,31 @@
+#ifndef SRC_TRACING_AGENT_H_
+#define SRC_TRACING_AGENT_H_
+
+#include "tracing/node_trace_buffer.h"
+#include "tracing/node_trace_writer.h"
+#include "uv.h"
+#include "v8.h"
+
+namespace node {
+namespace tracing {
+
+class Agent {
+ public:
+ explicit Agent();
+ void Start(v8::Platform* platform, const char* enabled_categories);
+ void Stop();
+
+ private:
+ bool IsStarted() { return platform_ != nullptr; }
+ static void ThreadCb(void* arg);
+
+ uv_thread_t thread_;
+ uv_loop_t tracing_loop_;
+ v8::Platform* platform_ = nullptr;
+ TracingController* tracing_controller_;
+};
+
+} // namespace tracing
+} // namespace node
+
+#endif // SRC_TRACING_AGENT_H_
diff --git a/src/tracing/node_trace_buffer.cc b/src/tracing/node_trace_buffer.cc
new file mode 100644
index 00000000000000..4773e08325a3ef
--- /dev/null
+++ b/src/tracing/node_trace_buffer.cc
@@ -0,0 +1,177 @@
+#include "tracing/node_trace_buffer.h"
+
+namespace node {
+namespace tracing {
+
+InternalTraceBuffer::InternalTraceBuffer(size_t max_chunks, uint32_t id,
+ NodeTraceWriter* trace_writer, NodeTraceBuffer* external_buffer)
+ : id_(id), flushing_(false), max_chunks_(max_chunks),
+ trace_writer_(trace_writer), external_buffer_(external_buffer) {
+ chunks_.resize(max_chunks);
+}
+
+TraceObject* InternalTraceBuffer::AddTraceEvent(uint64_t* handle) {
+ Mutex::ScopedLock scoped_lock(mutex_);
+ // Create new chunk if last chunk is full or there is no chunk.
+ if (total_chunks_ == 0 || chunks_[total_chunks_ - 1]->IsFull()) {
+ auto& chunk = chunks_[total_chunks_++];
+ if (chunk) {
+ chunk->Reset(current_chunk_seq_++);
+ } else {
+ chunk.reset(new TraceBufferChunk(current_chunk_seq_++));
+ }
+ }
+ auto& chunk = chunks_[total_chunks_ - 1];
+ size_t event_index;
+ TraceObject* trace_object = chunk->AddTraceEvent(&event_index);
+ *handle = MakeHandle(total_chunks_ - 1, chunk->seq(), event_index);
+ return trace_object;
+}
+
+TraceObject* InternalTraceBuffer::GetEventByHandle(uint64_t handle) {
+ Mutex::ScopedLock scoped_lock(mutex_);
+ if (handle == 0) {
+ // A handle value of zero never has a trace event associated with it.
+ return NULL;
+ }
+ size_t chunk_index, event_index;
+ uint32_t buffer_id, chunk_seq;
+ ExtractHandle(handle, &buffer_id, &chunk_index, &chunk_seq, &event_index);
+ if (buffer_id != id_ || chunk_index >= total_chunks_) {
+ // Either the chunk belongs to the other buffer, or is outside the current
+ // range of chunks loaded in memory (the latter being true suggests that
+ // the chunk has already been flushed and is no longer in memory.)
+ return NULL;
+ }
+ auto& chunk = chunks_[chunk_index];
+ if (chunk->seq() != chunk_seq) {
+ // Chunk is no longer in memory.
+ return NULL;
+ }
+ return chunk->GetEventAt(event_index);
+}
+
+void InternalTraceBuffer::Flush(bool blocking) {
+ {
+ Mutex::ScopedLock scoped_lock(mutex_);
+ if (total_chunks_ > 0) {
+ flushing_ = true;
+ for (size_t i = 0; i < total_chunks_; ++i) {
+ auto& chunk = chunks_[i];
+ for (size_t j = 0; j < chunk->size(); ++j) {
+ trace_writer_->AppendTraceEvent(chunk->GetEventAt(j));
+ }
+ }
+ total_chunks_ = 0;
+ flushing_ = false;
+ }
+ }
+ trace_writer_->Flush(blocking);
+}
+
+uint64_t InternalTraceBuffer::MakeHandle(
+ size_t chunk_index, uint32_t chunk_seq, size_t event_index) const {
+ return ((static_cast(chunk_seq) * Capacity() +
+ chunk_index * TraceBufferChunk::kChunkSize + event_index) << 1) + id_;
+}
+
+void InternalTraceBuffer::ExtractHandle(
+ uint64_t handle, uint32_t* buffer_id, size_t* chunk_index,
+ uint32_t* chunk_seq, size_t* event_index) const {
+ *buffer_id = static_cast(handle & 0x1);
+ handle >>= 1;
+ *chunk_seq = static_cast(handle / Capacity());
+ size_t indices = handle % Capacity();
+ *chunk_index = indices / TraceBufferChunk::kChunkSize;
+ *event_index = indices % TraceBufferChunk::kChunkSize;
+}
+
+NodeTraceBuffer::NodeTraceBuffer(size_t max_chunks,
+ NodeTraceWriter* trace_writer, uv_loop_t* tracing_loop)
+ : tracing_loop_(tracing_loop), trace_writer_(trace_writer),
+ buffer1_(max_chunks, 0, trace_writer, this),
+ buffer2_(max_chunks, 1, trace_writer, this) {
+ current_buf_.store(&buffer1_);
+
+ flush_signal_.data = this;
+ int err = uv_async_init(tracing_loop_, &flush_signal_, NonBlockingFlushSignalCb);
+ CHECK_EQ(err, 0);
+
+ exit_signal_.data = this;
+ err = uv_async_init(tracing_loop_, &exit_signal_, ExitSignalCb);
+ CHECK_EQ(err, 0);
+}
+
+NodeTraceBuffer::~NodeTraceBuffer() {
+ uv_async_send(&exit_signal_);
+ Mutex::ScopedLock scoped_lock(exit_mutex_);
+ while(!exited_) {
+ exit_cond_.Wait(scoped_lock);
+ }
+}
+
+TraceObject* NodeTraceBuffer::AddTraceEvent(uint64_t* handle) {
+ // If the buffer is full, attempt to perform a flush.
+ if (!TryLoadAvailableBuffer()) {
+ // Assign a value of zero as the trace event handle.
+ // This is equivalent to calling InternalTraceBuffer::MakeHandle(0, 0, 0),
+ // and will cause GetEventByHandle to return NULL if passed as an argument.
+ *handle = 0;
+ return nullptr;
+ }
+ return current_buf_.load()->AddTraceEvent(handle);
+}
+
+TraceObject* NodeTraceBuffer::GetEventByHandle(uint64_t handle) {
+ return current_buf_.load()->GetEventByHandle(handle);
+}
+
+bool NodeTraceBuffer::Flush() {
+ buffer1_.Flush(true);
+ buffer2_.Flush(true);
+ return true;
+}
+
+// Attempts to set current_buf_ such that it references a buffer that can
+// can write at least one trace event. If both buffers are unavailable this
+// method returns false; otherwise it returns true.
+bool NodeTraceBuffer::TryLoadAvailableBuffer() {
+ InternalTraceBuffer* prev_buf = current_buf_.load();
+ if (prev_buf->IsFull()) {
+ uv_async_send(&flush_signal_); // trigger flush on a separate thread
+ InternalTraceBuffer* other_buf = prev_buf == &buffer1_ ?
+ &buffer2_ : &buffer1_;
+ if (!other_buf->IsFull()) {
+ current_buf_.store(other_buf);
+ } else {
+ return false;
+ }
+ }
+ return true;
+}
+
+// static
+void NodeTraceBuffer::NonBlockingFlushSignalCb(uv_async_t* signal) {
+ NodeTraceBuffer* buffer = reinterpret_cast(signal->data);
+ if (buffer->buffer1_.IsFull() && !buffer->buffer1_.IsFlushing()) {
+ buffer->buffer1_.Flush(false);
+ }
+ if (buffer->buffer2_.IsFull() && !buffer->buffer2_.IsFlushing()) {
+ buffer->buffer2_.Flush(false);
+ }
+}
+
+// static
+void NodeTraceBuffer::ExitSignalCb(uv_async_t* signal) {
+ NodeTraceBuffer* buffer = reinterpret_cast(signal->data);
+ uv_close(reinterpret_cast(&buffer->flush_signal_), nullptr);
+ uv_close(reinterpret_cast(&buffer->exit_signal_), [](uv_handle_t* signal) {
+ NodeTraceBuffer* buffer = reinterpret_cast(signal->data);
+ Mutex::ScopedLock scoped_lock(buffer->exit_mutex_);
+ buffer->exited_ = true;
+ buffer->exit_cond_.Signal(scoped_lock);
+ });
+}
+
+} // namespace tracing
+} // namespace node
diff --git a/src/tracing/node_trace_buffer.h b/src/tracing/node_trace_buffer.h
new file mode 100644
index 00000000000000..619799fdb21978
--- /dev/null
+++ b/src/tracing/node_trace_buffer.h
@@ -0,0 +1,89 @@
+#ifndef SRC_NODE_TRACE_BUFFER_H_
+#define SRC_NODE_TRACE_BUFFER_H_
+
+#include "node_mutex.h"
+#include "tracing/node_trace_writer.h"
+#include "libplatform/v8-tracing.h"
+
+#include
+
+namespace node {
+namespace tracing {
+
+using v8::platform::tracing::TraceBuffer;
+using v8::platform::tracing::TraceBufferChunk;
+using v8::platform::tracing::TraceObject;
+
+// forward declaration
+class NodeTraceBuffer;
+
+class InternalTraceBuffer {
+ public:
+ InternalTraceBuffer(size_t max_chunks, uint32_t id,
+ NodeTraceWriter* trace_writer,
+ NodeTraceBuffer* external_buffer);
+
+ TraceObject* AddTraceEvent(uint64_t* handle);
+ TraceObject* GetEventByHandle(uint64_t handle);
+ void Flush(bool blocking);
+ bool IsFull() const {
+ return total_chunks_ == max_chunks_ && chunks_[total_chunks_ - 1]->IsFull();
+ }
+ bool IsFlushing() const {
+ return flushing_;
+ }
+
+ private:
+ uint64_t MakeHandle(size_t chunk_index, uint32_t chunk_seq,
+ size_t event_index) const;
+ void ExtractHandle(uint64_t handle, uint32_t* buffer_id, size_t* chunk_index,
+ uint32_t* chunk_seq, size_t* event_index) const;
+ size_t Capacity() const { return max_chunks_ * TraceBufferChunk::kChunkSize; }
+
+ Mutex mutex_;
+ bool flushing_;
+ size_t max_chunks_;
+ NodeTraceWriter* trace_writer_;
+ NodeTraceBuffer* external_buffer_;
+ std::vector> chunks_;
+ size_t total_chunks_ = 0;
+ uint32_t current_chunk_seq_ = 1;
+ uint32_t id_;
+};
+
+class NodeTraceBuffer : public TraceBuffer {
+ public:
+ NodeTraceBuffer(size_t max_chunks, NodeTraceWriter* trace_writer,
+ uv_loop_t* tracing_loop);
+ ~NodeTraceBuffer();
+
+ TraceObject* AddTraceEvent(uint64_t* handle) override;
+ TraceObject* GetEventByHandle(uint64_t handle) override;
+ bool Flush() override;
+
+ static const size_t kBufferChunks = 1024;
+
+ private:
+ bool TryLoadAvailableBuffer();
+ static void NonBlockingFlushSignalCb(uv_async_t* signal);
+ static void ExitSignalCb(uv_async_t* signal);
+
+ uv_loop_t* tracing_loop_;
+ uv_async_t flush_signal_;
+ uv_async_t exit_signal_;
+ bool exited_ = false;
+ // Used exclusively for exit logic.
+ Mutex exit_mutex_;
+ // Used to wait until async handles have been closed.
+ ConditionVariable exit_cond_;
+ std::unique_ptr trace_writer_;
+ // TODO: Change std::atomic to something less contentious.
+ std::atomic current_buf_;
+ InternalTraceBuffer buffer1_;
+ InternalTraceBuffer buffer2_;
+};
+
+} // namespace tracing
+} // namespace node
+
+#endif // SRC_NODE_TRACING_CONTROLLER_H_
diff --git a/src/tracing/node_trace_writer.cc b/src/tracing/node_trace_writer.cc
new file mode 100644
index 00000000000000..41753c5e65e557
--- /dev/null
+++ b/src/tracing/node_trace_writer.cc
@@ -0,0 +1,185 @@
+#include "tracing/node_trace_writer.h"
+
+#include
+#include
+
+#include "util.h"
+
+namespace node {
+namespace tracing {
+
+NodeTraceWriter::NodeTraceWriter(uv_loop_t* tracing_loop)
+ : tracing_loop_(tracing_loop) {
+ flush_signal_.data = this;
+ int err = uv_async_init(tracing_loop_, &flush_signal_, FlushSignalCb);
+ CHECK_EQ(err, 0);
+
+ exit_signal_.data = this;
+ err = uv_async_init(tracing_loop_, &exit_signal_, ExitSignalCb);
+ CHECK_EQ(err, 0);
+}
+
+void NodeTraceWriter::WriteSuffix() {
+ // If our final log file has traces, then end the file appropriately.
+ // This means that if no trace events are recorded, then no trace file is
+ // produced.
+ bool should_flush = false;
+ {
+ Mutex::ScopedLock scoped_lock(stream_mutex_);
+ if (total_traces_ > 0) {
+ total_traces_ = 0; // so we don't write it again in FlushPrivate
+ // Appends "]}" to stream_.
+ delete json_trace_writer_;
+ should_flush = true;
+ }
+ }
+ if (should_flush) {
+ Flush(true);
+ }
+}
+
+NodeTraceWriter::~NodeTraceWriter() {
+ WriteSuffix();
+ uv_fs_t req;
+ int err;
+ if (fd_ != -1) {
+ err = uv_fs_close(tracing_loop_, &req, fd_, nullptr);
+ CHECK_EQ(err, 0);
+ uv_fs_req_cleanup(&req);
+ }
+ uv_async_send(&exit_signal_);
+ Mutex::ScopedLock scoped_lock(request_mutex_);
+ while(!exited_) {
+ exit_cond_.Wait(scoped_lock);
+ }
+}
+
+void NodeTraceWriter::OpenNewFileForStreaming() {
+ ++file_num_;
+ uv_fs_t req;
+ std::ostringstream log_file;
+ log_file << "node_trace." << file_num_ << ".log";
+ fd_ = uv_fs_open(tracing_loop_, &req, log_file.str().c_str(),
+ O_CREAT | O_WRONLY | O_TRUNC, 0644, NULL);
+ CHECK_NE(fd_, -1);
+ uv_fs_req_cleanup(&req);
+}
+
+void NodeTraceWriter::AppendTraceEvent(TraceObject* trace_event) {
+ Mutex::ScopedLock scoped_lock(stream_mutex_);
+ // If this is the first trace event, open a new file for streaming.
+ if (total_traces_ == 0) {
+ OpenNewFileForStreaming();
+ // Constructing a new JSONTraceWriter object appends "{\"traceEvents\":["
+ // to stream_.
+ // In other words, the constructor initializes the serialization stream
+ // to a state where we can start writing trace events to it.
+ // Repeatedly constructing and destroying json_trace_writer_ allows
+ // us to use V8's JSON writer instead of implementing our own.
+ json_trace_writer_ = TraceWriter::CreateJSONTraceWriter(stream_);
+ }
+ ++total_traces_;
+ json_trace_writer_->AppendTraceEvent(trace_event);
+}
+
+void NodeTraceWriter::FlushPrivate() {
+ std::string str;
+ int highest_request_id;
+ {
+ Mutex::ScopedLock stream_scoped_lock(stream_mutex_);
+ if (total_traces_ >= kTracesPerFile) {
+ total_traces_ = 0;
+ // Destroying the member JSONTraceWriter object appends "]}" to
+ // stream_ - in other words, ending a JSON file.
+ delete json_trace_writer_;
+ }
+ // str() makes a copy of the contents of the stream.
+ str = stream_.str();
+ stream_.str("");
+ stream_.clear();
+ }
+ {
+ Mutex::ScopedLock request_scoped_lock(request_mutex_);
+ highest_request_id = num_write_requests_;
+ }
+ WriteToFile(std::move(str), highest_request_id);
+}
+
+void NodeTraceWriter::FlushSignalCb(uv_async_t* signal) {
+ NodeTraceWriter* trace_writer = static_cast(signal->data);
+ trace_writer->FlushPrivate();
+}
+
+// TODO: Remove (is it necessary to change the API? Since because of WriteSuffix
+// it no longer matters whether it's true or false)
+void NodeTraceWriter::Flush() {
+ Flush(true);
+}
+
+void NodeTraceWriter::Flush(bool blocking) {
+ Mutex::ScopedLock scoped_lock(request_mutex_);
+ if (!json_trace_writer_) {
+ return;
+ }
+ int request_id = ++num_write_requests_;
+ int err = uv_async_send(&flush_signal_);
+ CHECK_EQ(err, 0);
+ if (blocking) {
+ // Wait until data associated with this request id has been written to disk.
+ // This guarantees that data from all earlier requests have also been
+ // written.
+ while (request_id > highest_request_id_completed_) {
+ request_cond_.Wait(scoped_lock);
+ }
+ }
+}
+
+void NodeTraceWriter::WriteToFile(std::string&& str, int highest_request_id) {
+ WriteRequest* write_req = new WriteRequest();
+ write_req->str = std::move(str);
+ write_req->writer = this;
+ write_req->highest_request_id = highest_request_id;
+ uv_buf_t uv_buf = uv_buf_init(const_cast(write_req->str.c_str()),
+ write_req->str.length());
+ request_mutex_.Lock();
+ // Manage a queue of WriteRequest objects because the behavior of uv_write is
+ // is undefined if the same WriteRequest object is used more than once
+ // between WriteCb calls. In addition, this allows us to keep track of the id
+ // of the latest write request that actually been completed.
+ write_req_queue_.push(write_req);
+ request_mutex_.Unlock();
+ int err = uv_fs_write(tracing_loop_, reinterpret_cast(write_req),
+ fd_, &uv_buf, 1, -1, WriteCb);
+ CHECK_EQ(err, 0);
+}
+
+void NodeTraceWriter::WriteCb(uv_fs_t* req) {
+ WriteRequest* write_req = reinterpret_cast(req);
+ CHECK_GE(write_req->req.result, 0);
+
+ NodeTraceWriter* writer = write_req->writer;
+ int highest_request_id = write_req->highest_request_id;
+ {
+ Mutex::ScopedLock scoped_lock(writer->request_mutex_);
+ CHECK_EQ(write_req, writer->write_req_queue_.front());
+ writer->write_req_queue_.pop();
+ writer->highest_request_id_completed_ = highest_request_id;
+ writer->request_cond_.Broadcast(scoped_lock);
+ }
+ delete write_req;
+}
+
+// static
+void NodeTraceWriter::ExitSignalCb(uv_async_t* signal) {
+ NodeTraceWriter* trace_writer = static_cast(signal->data);
+ uv_close(reinterpret_cast(&trace_writer->flush_signal_), nullptr);
+ uv_close(reinterpret_cast(&trace_writer->exit_signal_), [](uv_handle_t* signal) {
+ NodeTraceWriter* trace_writer = static_cast(signal->data);
+ Mutex::ScopedLock scoped_lock(trace_writer->request_mutex_);
+ trace_writer->exited_ = true;
+ trace_writer->exit_cond_.Signal(scoped_lock);
+ });
+}
+
+} // namespace tracing
+} // namespace node
diff --git a/src/tracing/node_trace_writer.h b/src/tracing/node_trace_writer.h
new file mode 100644
index 00000000000000..5813db0ab1fd33
--- /dev/null
+++ b/src/tracing/node_trace_writer.h
@@ -0,0 +1,74 @@
+#ifndef SRC_NODE_TRACE_WRITER_H_
+#define SRC_NODE_TRACE_WRITER_H_
+
+#include
+#include
+
+#include "node_mutex.h"
+#include "libplatform/v8-tracing.h"
+#include "uv.h"
+
+namespace node {
+namespace tracing {
+
+using v8::platform::tracing::TraceObject;
+using v8::platform::tracing::TraceWriter;
+using v8::platform::tracing::TracingController;
+
+class NodeTraceWriter : public TraceWriter {
+ public:
+ NodeTraceWriter(uv_loop_t* tracing_loop);
+ ~NodeTraceWriter();
+
+ void AppendTraceEvent(TraceObject* trace_event) override;
+ void Flush() override;
+ void Flush(bool blocking);
+
+ static const int kTracesPerFile = 1 << 19;
+
+ private:
+ struct WriteRequest {
+ uv_fs_t req;
+ NodeTraceWriter* writer;
+ std::string str;
+ int highest_request_id;
+ };
+
+ static void WriteCb(uv_fs_t* req);
+ void OpenNewFileForStreaming();
+ void WriteToFile(std::string&& str, int highest_request_id);
+ void WriteSuffix();
+ static void FlushSignalCb(uv_async_t* signal);
+ void FlushPrivate();
+ static void ExitSignalCb(uv_async_t* signal);
+
+ uv_loop_t* tracing_loop_;
+ // Triggers callback to initiate writing the contents of stream_ to disk.
+ uv_async_t flush_signal_;
+ // Triggers callback to close async objects, ending the tracing thread.
+ uv_async_t exit_signal_;
+ // Prevents concurrent R/W on state related to serialized trace data
+ // before it's written to disk, namely stream_ and total_traces_.
+ Mutex stream_mutex_;
+ // Prevents concurrent R/W on state related to write requests.
+ Mutex request_mutex_;
+ // Allows blocking calls to Flush() to wait on a condition for
+ // trace events to be written to disk.
+ ConditionVariable request_cond_;
+ // Used to wait until async handles have been closed.
+ ConditionVariable exit_cond_;
+ int fd_ = -1;
+ std::queue write_req_queue_;
+ int num_write_requests_ = 0;
+ int highest_request_id_completed_ = 0;
+ int total_traces_ = 0;
+ int file_num_ = 0;
+ std::ostringstream stream_;
+ TraceWriter* json_trace_writer_ = nullptr;
+ bool exited_ = false;
+};
+
+} // namespace tracing
+} // namespace node
+
+#endif // SRC_NODE_TRACE_WRITER_H_
diff --git a/src/tracing/trace_event.cc b/src/tracing/trace_event.cc
new file mode 100644
index 00000000000000..b83cae6e05c10c
--- /dev/null
+++ b/src/tracing/trace_event.cc
@@ -0,0 +1,17 @@
+#include "tracing/trace_event.h"
+
+namespace node {
+namespace tracing {
+
+v8::Platform* platform_ = nullptr;
+
+void TraceEventHelper::SetCurrentPlatform(v8::Platform* platform) {
+ platform_ = platform;
+}
+
+v8::Platform* TraceEventHelper::GetCurrentPlatform() {
+ return platform_;
+}
+
+} // namespace tracing
+} // namespace node
diff --git a/src/tracing/trace_event.h b/src/tracing/trace_event.h
new file mode 100644
index 00000000000000..a035fd51500bb9
--- /dev/null
+++ b/src/tracing/trace_event.h
@@ -0,0 +1,1710 @@
+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_TRACING_TRACE_EVENT_H_
+#define SRC_TRACING_TRACE_EVENT_H_
+
+#include
+
+#include "v8-platform.h"
+
+// This header file defines implementation details of how the trace macros in
+// trace_event_common.h collect and store trace events. Anything not
+// implementation-specific should go in trace_macros_common.h instead of here.
+
+// From v8/base/trace_event/common/trace_event_common.h
+
+// This header file defines the set of trace_event macros without specifying
+// how the events actually get collected and stored. If you need to expose trace
+// events to some other universe, you can copy-and-paste this file as well as
+// trace_event.h, modifying the macros contained there as necessary for the
+// target platform. The end result is that multiple libraries can funnel events
+// through to a shared trace event collector.
+
+// IMPORTANT: To avoid conflicts, if you need to modify this file for a library,
+// land your change in base/ first, and then copy-and-paste it.
+
+// Trace events are for tracking application performance and resource usage.
+// Macros are provided to track:
+// Begin and end of function calls
+// Counters
+//
+// Events are issued against categories. Whereas LOG's
+// categories are statically defined, TRACE categories are created
+// implicitly with a string. For example:
+// TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent",
+// TRACE_EVENT_SCOPE_THREAD)
+//
+// It is often the case that one trace may belong in multiple categories at the
+// same time. The first argument to the trace can be a comma-separated list of
+// categories, forming a category group, like:
+//
+// TRACE_EVENT_INSTANT0("input,views", "OnMouseOver", TRACE_EVENT_SCOPE_THREAD)
+//
+// We can enable/disable tracing of OnMouseOver by enabling/disabling either
+// category.
+//
+// Events can be INSTANT, or can be pairs of BEGIN and END in the same scope:
+// TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly")
+// doSomethingCostly()
+// TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly")
+// Note: our tools can't always determine the correct BEGIN/END pairs unless
+// these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you
+// need them to be in separate scopes.
+//
+// A common use case is to trace entire function scopes. This
+// issues a trace BEGIN and END automatically:
+// void doSomethingCostly() {
+// TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
+// ...
+// }
+//
+// Additional parameters can be associated with an event:
+// void doSomethingCostly2(int howMuch) {
+// TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly",
+// "howMuch", howMuch);
+// ...
+// }
+//
+// The trace system will automatically add to this information the
+// current process id, thread id, and a timestamp in microseconds.
+//
+// To trace an asynchronous procedure such as an IPC send/receive, use
+// ASYNC_BEGIN and ASYNC_END:
+// [single threaded sender code]
+// static int send_count = 0;
+// ++send_count;
+// TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count);
+// Send(new MyMessage(send_count));
+// [receive code]
+// void OnMyMessage(send_count) {
+// TRACE_EVENT_ASYNC_END0("ipc", "message", send_count);
+// }
+// The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs.
+// ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process.
+// Pointers can be used for the ID parameter, and they will be mangled
+// internally so that the same pointer on two different processes will not
+// match. For example:
+// class MyTracedClass {
+// public:
+// MyTracedClass() {
+// TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this);
+// }
+// ~MyTracedClass() {
+// TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this);
+// }
+// }
+//
+// Trace event also supports counters, which is a way to track a quantity
+// as it varies over time. Counters are created with the following macro:
+// TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
+//
+// Counters are process-specific. The macro itself can be issued from any
+// thread, however.
+//
+// Sometimes, you want to track two counters at once. You can do this with two
+// counter macros:
+// TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
+// TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
+// Or you can do it with a combined macro:
+// TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
+// "bytesPinned", g_myCounterValue[0],
+// "bytesAllocated", g_myCounterValue[1]);
+// This indicates to the tracing UI that these counters should be displayed
+// in a single graph, as a summed area chart.
+//
+// Since counters are in a global namespace, you may want to disambiguate with a
+// unique ID, by using the TRACE_COUNTER_ID* variations.
+//
+// By default, trace collection is compiled in, but turned off at runtime.
+// Collecting trace data is the responsibility of the embedding
+// application. In Chrome's case, navigating to about:tracing will turn on
+// tracing and display data collected across all active processes.
+//
+//
+// Memory scoping note:
+// Tracing copies the pointers, not the string content, of the strings passed
+// in for category_group, name, and arg_names. Thus, the following code will
+// cause problems:
+// char* str = strdup("importantName");
+// TRACE_EVENT_INSTANT0("SUBSYSTEM", str); // BAD!
+// free(str); // Trace system now has dangling pointer
+//
+// To avoid this issue with the |name| and |arg_name| parameters, use the
+// TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime overhead.
+// Notes: The category must always be in a long-lived char* (i.e. static const).
+// The |arg_values|, when used, are always deep copied with the _COPY
+// macros.
+//
+// When are string argument values copied:
+// const char* arg_values are only referenced by default:
+// TRACE_EVENT1("category", "name",
+// "arg1", "literal string is only referenced");
+// Use TRACE_STR_COPY to force copying of a const char*:
+// TRACE_EVENT1("category", "name",
+// "arg1", TRACE_STR_COPY("string will be copied"));
+// std::string arg_values are always copied:
+// TRACE_EVENT1("category", "name",
+// "arg1", std::string("string will be copied"));
+//
+//
+// Convertable notes:
+// Converting a large data type to a string can be costly. To help with this,
+// the trace framework provides an interface ConvertableToTraceFormat. If you
+// inherit from it and implement the AppendAsTraceFormat method the trace
+// framework will call back to your object to convert a trace output time. This
+// means, if the category for the event is disabled, the conversion will not
+// happen.
+//
+// class MyData : public base::trace_event::ConvertableToTraceFormat {
+// public:
+// MyData() {}
+// void AppendAsTraceFormat(std::string* out) const override {
+// out->append("{\"foo\":1}");
+// }
+// private:
+// ~MyData() override {}
+// DISALLOW_COPY_AND_ASSIGN(MyData);
+// };
+//
+// TRACE_EVENT1("foo", "bar", "data",
+// std::unique_ptr(new MyData()));
+//
+// The trace framework will take ownership if the passed pointer and it will
+// be free'd when the trace buffer is flushed.
+//
+// Note, we only do the conversion when the buffer is flushed, so the provided
+// data object should not be modified after it's passed to the trace framework.
+//
+//
+// Thread Safety:
+// A thread safe singleton and mutex are used for thread safety. Category
+// enabled flags are used to limit the performance impact when the system
+// is not enabled.
+//
+// TRACE_EVENT macros first cache a pointer to a category. The categories are
+// statically allocated and safe at all times, even after exit. Fetching a
+// category is protected by the TraceLog::lock_. Multiple threads initializing
+// the static variable is safe, as they will be serialized by the lock and
+// multiple calls will return the same pointer to the category.
+//
+// Then the category_group_enabled flag is checked. This is a unsigned char, and
+// not intended to be multithread safe. It optimizes access to AddTraceEvent
+// which is threadsafe internally via TraceLog::lock_. The enabled flag may
+// cause some threads to incorrectly call or skip calling AddTraceEvent near
+// the time of the system being enabled or disabled. This is acceptable as
+// we tolerate some data loss while the system is being enabled/disabled and
+// because AddTraceEvent is threadsafe internally and checks the enabled state
+// again under lock.
+//
+// Without the use of these static category pointers and enabled flags all
+// trace points would carry a significant performance cost of acquiring a lock
+// and resolving the category.
+
+#if defined(TRACE_EVENT0)
+#error "Another copy of this file has already been included."
+#endif
+
+// This will mark the trace event as disabled by default. The user will need
+// to explicitly enable the event.
+#define TRACE_DISABLED_BY_DEFAULT(name) "disabled-by-default-" name
+
+// Records a pair of begin and end events called "name" for the current
+// scope, with 0, 1 or 2 associated arguments. If the category is not
+// enabled, then this does nothing.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+#define TRACE_EVENT0(category_group, name) \
+ INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name)
+#define TRACE_EVENT_WITH_FLOW0(category_group, name, bind_id, flow_flags) \
+ INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
+ flow_flags)
+#define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val)
+#define TRACE_EVENT_WITH_FLOW1(category_group, name, bind_id, flow_flags, \
+ arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
+ flow_flags, arg1_name, arg1_val)
+#define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, \
+ arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+#define TRACE_EVENT_WITH_FLOW2(category_group, name, bind_id, flow_flags, \
+ arg1_name, arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
+ flow_flags, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+
+// UNSHIPPED_TRACE_EVENT* are like TRACE_EVENT* except that they are not
+// included in official builds.
+
+#if OFFICIAL_BUILD
+#undef TRACING_IS_OFFICIAL_BUILD
+#define TRACING_IS_OFFICIAL_BUILD 1
+#elif !defined(TRACING_IS_OFFICIAL_BUILD)
+#define TRACING_IS_OFFICIAL_BUILD 0
+#endif
+
+#if TRACING_IS_OFFICIAL_BUILD
+#define UNSHIPPED_TRACE_EVENT0(category_group, name) (void)0
+#define UNSHIPPED_TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
+ (void)0
+#define UNSHIPPED_TRACE_EVENT2(category_group, name, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ (void)0
+#define UNSHIPPED_TRACE_EVENT_INSTANT0(category_group, name, scope) (void)0
+#define UNSHIPPED_TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, \
+ arg1_val) \
+ (void)0
+#define UNSHIPPED_TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ (void)0
+#else
+#define UNSHIPPED_TRACE_EVENT0(category_group, name) \
+ TRACE_EVENT0(category_group, name)
+#define UNSHIPPED_TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
+ TRACE_EVENT1(category_group, name, arg1_name, arg1_val)
+#define UNSHIPPED_TRACE_EVENT2(category_group, name, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val)
+#define UNSHIPPED_TRACE_EVENT_INSTANT0(category_group, name, scope) \
+ TRACE_EVENT_INSTANT0(category_group, name, scope)
+#define UNSHIPPED_TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, \
+ arg1_val) \
+ TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val)
+#define UNSHIPPED_TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+#endif
+
+// Records a single event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+#define TRACE_EVENT_INSTANT0(category_group, name, scope) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
+ TRACE_EVENT_FLAG_NONE | scope)
+#define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
+ TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val)
+#define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
+ TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_INSTANT0(category_group, name, scope) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
+ TRACE_EVENT_FLAG_COPY | scope)
+#define TRACE_EVENT_COPY_INSTANT1(category_group, name, scope, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
+ TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_INSTANT2(category_group, name, scope, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
+ TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+
+#define TRACE_EVENT_INSTANT_WITH_TIMESTAMP0(category_group, name, scope, \
+ timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_INSTANT, category_group, name, 0, 0, timestamp, \
+ TRACE_EVENT_FLAG_NONE | scope)
+
+// Syntactic sugars for the sampling tracing in the main thread.
+#define TRACE_EVENT_SCOPED_SAMPLING_STATE(category, name) \
+ TRACE_EVENT_SCOPED_SAMPLING_STATE_FOR_BUCKET(0, category, name)
+#define TRACE_EVENT_GET_SAMPLING_STATE() \
+ TRACE_EVENT_GET_SAMPLING_STATE_FOR_BUCKET(0)
+#define TRACE_EVENT_SET_SAMPLING_STATE(category, name) \
+ TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(0, category, name)
+#define TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(categoryAndName) \
+ TRACE_EVENT_SET_NONCONST_SAMPLING_STATE_FOR_BUCKET(0, categoryAndName)
+
+// Records a single BEGIN event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+#define TRACE_EVENT_BEGIN0(category_group, name) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
+ TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_BEGIN1(category_group, name, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_BEGIN2(category_group, name, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_BEGIN0(category_group, name) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
+ TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_BEGIN1(category_group, name, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_BEGIN2(category_group, name, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+
+// Similar to TRACE_EVENT_BEGINx but with a custom |at| timestamp provided.
+// - |id| is used to match the _BEGIN event with the _END event.
+// Events are considered to match if their category_group, name and id values
+// all match. |id| must either be a pointer or an integer value up to 64 bits.
+// If it's a pointer, the bits will be xored with a hash of the process ID so
+// that the same pointer on two different processes will not collide.
+#define TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
+ thread_id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
+ timestamp, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0( \
+ category_group, name, id, thread_id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
+ timestamp, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP1( \
+ category_group, name, id, thread_id, timestamp, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
+ timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP2( \
+ category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
+ timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, \
+ arg2_val)
+
+// Records a single END event for "name" immediately. If the category
+// is not enabled, then this does nothing.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+#define TRACE_EVENT_END0(category_group, name) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
+ TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_END1(category_group, name, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_END2(category_group, name, arg1_name, arg1_val, arg2_name, \
+ arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_END0(category_group, name) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
+ TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_END1(category_group, name, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_END2(category_group, name, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+
+#define TRACE_EVENT_MARK_WITH_TIMESTAMP1(category_group, name, timestamp, \
+ arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_MARK, category_group, name, 0, 0, timestamp, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+
+#define TRACE_EVENT_COPY_MARK(category_group, name) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_MARK, category_group, name, \
+ TRACE_EVENT_FLAG_COPY)
+
+#define TRACE_EVENT_COPY_MARK_WITH_TIMESTAMP(category_group, name, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_MARK, category_group, name, 0, 0, timestamp, \
+ TRACE_EVENT_FLAG_COPY)
+
+// Similar to TRACE_EVENT_ENDx but with a custom |at| timestamp provided.
+// - |id| is used to match the _BEGIN event with the _END event.
+// Events are considered to match if their category_group, name and id values
+// all match. |id| must either be a pointer or an integer value up to 64 bits.
+// If it's a pointer, the bits will be xored with a hash of the process ID so
+// that the same pointer on two different processes will not collide.
+#define TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
+ thread_id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
+ timestamp, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0( \
+ category_group, name, id, thread_id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
+ timestamp, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP1( \
+ category_group, name, id, thread_id, timestamp, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
+ timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP2( \
+ category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
+ timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, \
+ arg2_val)
+
+// Records the value of a counter called "name" immediately. Value
+// must be representable as a 32 bit integer.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+#define TRACE_COUNTER1(category_group, name, value) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
+ TRACE_EVENT_FLAG_NONE, "value", \
+ static_cast(value))
+#define TRACE_COPY_COUNTER1(category_group, name, value) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
+ TRACE_EVENT_FLAG_COPY, "value", \
+ static_cast(value))
+
+// Records the values of a multi-parted counter called "name" immediately.
+// The UI will treat value1 and value2 as parts of a whole, displaying their
+// values as a stacked-bar chart.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+#define TRACE_COUNTER2(category_group, name, value1_name, value1_val, \
+ value2_name, value2_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
+ TRACE_EVENT_FLAG_NONE, value1_name, \
+ static_cast(value1_val), value2_name, \
+ static_cast(value2_val))
+#define TRACE_COPY_COUNTER2(category_group, name, value1_name, value1_val, \
+ value2_name, value2_val) \
+ INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
+ TRACE_EVENT_FLAG_COPY, value1_name, \
+ static_cast(value1_val), value2_name, \
+ static_cast(value2_val))
+
+// Similar to TRACE_COUNTERx, but with a custom |timestamp| provided.
+#define TRACE_COUNTER_WITH_TIMESTAMP1(category_group, name, timestamp, value) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
+ TRACE_EVENT_PHASE_COUNTER, category_group, name, timestamp, \
+ TRACE_EVENT_FLAG_NONE, "value", static_cast(value))
+
+#define TRACE_COUNTER_WITH_TIMESTAMP2(category_group, name, timestamp, \
+ value1_name, value1_val, value2_name, \
+ value2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
+ TRACE_EVENT_PHASE_COUNTER, category_group, name, timestamp, \
+ TRACE_EVENT_FLAG_NONE, value1_name, static_cast(value1_val), \
+ value2_name, static_cast(value2_val))
+
+// Records the value of a counter called "name" immediately. Value
+// must be representable as a 32 bit integer.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+// - |id| is used to disambiguate counters with the same name. It must either
+// be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
+// will be xored with a hash of the process ID so that the same pointer on
+// two different processes will not collide.
+#define TRACE_COUNTER_ID1(category_group, name, id, value) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
+ name, id, TRACE_EVENT_FLAG_NONE, "value", \
+ static_cast(value))
+#define TRACE_COPY_COUNTER_ID1(category_group, name, id, value) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
+ name, id, TRACE_EVENT_FLAG_COPY, "value", \
+ static_cast(value))
+
+// Records the values of a multi-parted counter called "name" immediately.
+// The UI will treat value1 and value2 as parts of a whole, displaying their
+// values as a stacked-bar chart.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+// - |id| is used to disambiguate counters with the same name. It must either
+// be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
+// will be xored with a hash of the process ID so that the same pointer on
+// two different processes will not collide.
+#define TRACE_COUNTER_ID2(category_group, name, id, value1_name, value1_val, \
+ value2_name, value2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
+ name, id, TRACE_EVENT_FLAG_NONE, \
+ value1_name, static_cast(value1_val), \
+ value2_name, static_cast(value2_val))
+#define TRACE_COPY_COUNTER_ID2(category_group, name, id, value1_name, \
+ value1_val, value2_name, value2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
+ name, id, TRACE_EVENT_FLAG_COPY, \
+ value1_name, static_cast(value1_val), \
+ value2_name, static_cast(value2_val))
+
+// TRACE_EVENT_SAMPLE_* events are injected by the sampling profiler.
+#define TRACE_EVENT_SAMPLE_WITH_TID_AND_TIMESTAMP0(category_group, name, \
+ thread_id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_SAMPLE, category_group, name, 0, thread_id, timestamp, \
+ TRACE_EVENT_FLAG_NONE)
+
+#define TRACE_EVENT_SAMPLE_WITH_TID_AND_TIMESTAMP1( \
+ category_group, name, thread_id, timestamp, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_SAMPLE, category_group, name, 0, thread_id, timestamp, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+
+#define TRACE_EVENT_SAMPLE_WITH_TID_AND_TIMESTAMP2(category_group, name, \
+ thread_id, timestamp, \
+ arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_SAMPLE, category_group, name, 0, thread_id, timestamp, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+
+// ASYNC_STEP_* APIs should be only used by legacy code. New code should
+// consider using NESTABLE_ASYNC_* APIs to describe substeps within an async
+// event.
+// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+// - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event. ASYNC
+// events are considered to match if their category_group, name and id values
+// all match. |id| must either be a pointer or an integer value up to 64 bits.
+// If it's a pointer, the bits will be xored with a hash of the process ID so
+// that the same pointer on two different processes will not collide.
+//
+// An asynchronous operation can consist of multiple phases. The first phase is
+// defined by the ASYNC_BEGIN calls. Additional phases can be defined using the
+// ASYNC_STEP_INTO or ASYNC_STEP_PAST macros. The ASYNC_STEP_INTO macro will
+// annotate the block following the call. The ASYNC_STEP_PAST macro will
+// annotate the block prior to the call. Note that any particular event must use
+// only STEP_INTO or STEP_PAST macros; they can not mix and match. When the
+// operation completes, call ASYNC_END.
+//
+// An ASYNC trace typically occurs on a single thread (if not, they will only be
+// drawn on the thread defined in the ASYNC_BEGIN event), but all events in that
+// operation must use the same |name| and |id|. Each step can have its own
+// args.
+#define TRACE_EVENT_ASYNC_BEGIN0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
+
+// Similar to TRACE_EVENT_ASYNC_BEGINx but with a custom |at| timestamp
+// provided.
+#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
+ timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP1( \
+ category_group, name, id, timestamp, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
+ arg1_name, arg1_val)
+#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP2(category_group, name, id, \
+ timestamp, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
+ arg1_name, arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
+ timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
+
+// Records a single ASYNC_STEP_INTO event for |step| immediately. If the
+// category is not enabled, then this does nothing. The |name| and |id| must
+// match the ASYNC_BEGIN event above. The |step| param identifies this step
+// within the async event. This should be called at the beginning of the next
+// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
+// ASYNC_STEP_PAST events.
+#define TRACE_EVENT_ASYNC_STEP_INTO0(category_group, name, id, step) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_INTO, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, "step", step)
+#define TRACE_EVENT_ASYNC_STEP_INTO1(category_group, name, id, step, \
+ arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
+
+// Similar to TRACE_EVENT_ASYNC_STEP_INTOx but with a custom |at| timestamp
+// provided.
+#define TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(category_group, name, id, \
+ step, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
+ "step", step)
+
+// Records a single ASYNC_STEP_PAST event for |step| immediately. If the
+// category is not enabled, then this does nothing. The |name| and |id| must
+// match the ASYNC_BEGIN event above. The |step| param identifies this step
+// within the async event. This should be called at the beginning of the next
+// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
+// ASYNC_STEP_INTO events.
+#define TRACE_EVENT_ASYNC_STEP_PAST0(category_group, name, id, step) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_PAST, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, "step", step)
+#define TRACE_EVENT_ASYNC_STEP_PAST1(category_group, name, id, step, \
+ arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_ASYNC_STEP_PAST, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
+
+// Records a single ASYNC_END event for "name" immediately. If the category
+// is not enabled, then this does nothing.
+#define TRACE_EVENT_ASYNC_END0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_ASYNC_END1(category_group, name, id, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_ASYNC_END2(category_group, name, id, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_ASYNC_END0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_ASYNC_END1(category_group, name, id, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_ASYNC_END2(category_group, name, id, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
+
+// Similar to TRACE_EVENT_ASYNC_ENDx but with a custom |at| timestamp provided.
+#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP0(category_group, name, id, \
+ timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP1(category_group, name, id, \
+ timestamp, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
+ arg1_name, arg1_val)
+#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP2(category_group, name, id, \
+ timestamp, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
+ arg1_name, arg1_val, arg2_name, arg2_val)
+
+// NESTABLE_ASYNC_* APIs are used to describe an async operation, which can
+// be nested within a NESTABLE_ASYNC event and/or have inner NESTABLE_ASYNC
+// events.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+// - A pair of NESTABLE_ASYNC_BEGIN event and NESTABLE_ASYNC_END event is
+// considered as a match if their category_group, name and id all match.
+// - |id| must either be a pointer or an integer value up to 64 bits.
+// If it's a pointer, the bits will be xored with a hash of the process ID so
+// that the same pointer on two different processes will not collide.
+// - |id| is used to match a child NESTABLE_ASYNC event with its parent
+// NESTABLE_ASYNC event. Therefore, events in the same nested event tree must
+// be logged using the same id and category_group.
+//
+// Unmatched NESTABLE_ASYNC_END event will be parsed as an event that starts
+// at the first NESTABLE_ASYNC event of that id, and unmatched
+// NESTABLE_ASYNC_BEGIN event will be parsed as an event that ends at the last
+// NESTABLE_ASYNC event of that id. Corresponding warning messages for
+// unmatched events will be shown in the analysis view.
+
+// Records a single NESTABLE_ASYNC_BEGIN event called "name" immediately, with
+// 0, 1 or 2 associated arguments. If the category is not enabled, then this
+// does nothing.
+#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+// Records a single NESTABLE_ASYNC_END event called "name" immediately, with 0
+// or 2 associated arguments. If the category is not enabled, then this does
+// nothing.
+#define TRACE_EVENT_NESTABLE_ASYNC_END0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE)
+// Records a single NESTABLE_ASYNC_END event called "name" immediately, with 1
+// associated argument. If the category is not enabled, then this does nothing.
+#define TRACE_EVENT_NESTABLE_ASYNC_END1(category_group, name, id, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_NESTABLE_ASYNC_END2(category_group, name, id, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+
+// Records a single NESTABLE_ASYNC_INSTANT event called "name" immediately,
+// with one associated argument. If the category is not enabled, then this
+// does nothing.
+#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT1(category_group, name, id, \
+ arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+// Records a single NESTABLE_ASYNC_INSTANT event called "name" immediately,
+// with 2 associated arguments. If the category is not enabled, then this
+// does nothing.
+#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT2( \
+ category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+
+#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TTS2( \
+ category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_FLAG_ASYNC_TTS | TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TTS2( \
+ category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_FLAG_ASYNC_TTS | TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
+ arg2_name, arg2_val)
+
+// Similar to TRACE_EVENT_NESTABLE_ASYNC_{BEGIN,END}x but with a custom
+// |timestamp| provided.
+#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, \
+ id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
+
+#define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0(category_group, name, \
+ id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
+
+#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( \
+ category_group, name, id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( \
+ category_group, name, id, timestamp) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
+ TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
+
+// Records a single NESTABLE_ASYNC_INSTANT event called "name" immediately,
+// with 2 associated arguments. If the category is not enabled, then this
+// does nothing.
+#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT2( \
+ category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+
+// Records a single FLOW_BEGIN event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+// literals). They may not include " chars.
+// - |id| is used to match the FLOW_BEGIN event with the FLOW_END event. FLOW
+// events are considered to match if their category_group, name and id values
+// all match. |id| must either be a pointer or an integer value up to 64 bits.
+// If it's a pointer, the bits will be xored with a hash of the process ID so
+// that the same pointer on two different processes will not collide.
+// FLOW events are different from ASYNC events in how they are drawn by the
+// tracing UI. A FLOW defines asynchronous data flow, such as posting a task
+// (FLOW_BEGIN) and later executing that task (FLOW_END). Expect FLOWs to be
+// drawn as lines or arrows from FLOW_BEGIN scopes to FLOW_END scopes. Similar
+// to ASYNC, a FLOW can consist of multiple phases. The first phase is defined
+// by the FLOW_BEGIN calls. Additional phases can be defined using the FLOW_STEP
+// macros. When the operation completes, call FLOW_END. An async operation can
+// span threads and processes, but all events in that operation must use the
+// same |name| and |id|. Each event can have its own args.
+#define TRACE_EVENT_FLOW_BEGIN0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_FLOW_BEGIN1(category_group, name, id, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_FLOW_BEGIN2(category_group, name, id, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_FLOW_BEGIN, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_FLOW_BEGIN0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_FLOW_BEGIN1(category_group, name, id, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_FLOW_BEGIN2(category_group, name, id, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_FLOW_BEGIN, category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
+
+// Records a single FLOW_STEP event for |step| immediately. If the category
+// is not enabled, then this does nothing. The |name| and |id| must match the
+// FLOW_BEGIN event above. The |step| param identifies this step within the
+// async event. This should be called at the beginning of the next phase of an
+// asynchronous operation.
+#define TRACE_EVENT_FLOW_STEP0(category_group, name, id, step) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, "step", step)
+#define TRACE_EVENT_FLOW_STEP1(category_group, name, id, step, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_FLOW_STEP, category_group, name, id, \
+ TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_FLOW_STEP0(category_group, name, id, step) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, \
+ category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY, "step", step)
+#define TRACE_EVENT_COPY_FLOW_STEP1(category_group, name, id, step, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_FLOW_STEP, category_group, name, id, \
+ TRACE_EVENT_FLAG_COPY, "step", step, arg1_name, arg1_val)
+
+// Records a single FLOW_END event for "name" immediately. If the category
+// is not enabled, then this does nothing.
+#define TRACE_EVENT_FLOW_END0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
+ name, id, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_FLOW_END_BIND_TO_ENCLOSING0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
+ name, id, \
+ TRACE_EVENT_FLAG_BIND_TO_ENCLOSING)
+#define TRACE_EVENT_FLOW_END1(category_group, name, id, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
+ name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
+ arg1_val)
+#define TRACE_EVENT_FLOW_END2(category_group, name, id, arg1_name, arg1_val, \
+ arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
+ name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
+ arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_FLOW_END0(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
+ name, id, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_FLOW_END1(category_group, name, id, arg1_name, \
+ arg1_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
+ name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
+ arg1_val)
+#define TRACE_EVENT_COPY_FLOW_END2(category_group, name, id, arg1_name, \
+ arg1_val, arg2_name, arg2_val) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category_group, \
+ name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
+ arg1_val, arg2_name, arg2_val)
+
+// Special trace event macro to trace task execution with the location where it
+// was posted from.
+#define TRACE_TASK_EXECUTION(run_function, task) \
+ INTERNAL_TRACE_TASK_EXECUTION(run_function, task)
+
+// TRACE_EVENT_METADATA* events are information related to other
+// injected events, not events in their own right.
+#define TRACE_EVENT_METADATA1(category_group, name, arg1_name, arg1_val) \
+ INTERNAL_TRACE_EVENT_METADATA_ADD(category_group, name, arg1_name, arg1_val)
+
+// Records a clock sync event.
+#define TRACE_EVENT_CLOCK_SYNC_RECEIVER(sync_id) \
+ INTERNAL_TRACE_EVENT_ADD( \
+ TRACE_EVENT_PHASE_CLOCK_SYNC, "__metadata", "clock_sync", \
+ TRACE_EVENT_FLAG_NONE, "sync_id", sync_id)
+#define TRACE_EVENT_CLOCK_SYNC_ISSUER(sync_id, issue_ts, issue_end_ts) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
+ TRACE_EVENT_PHASE_CLOCK_SYNC, "__metadata", "clock_sync", \
+ issue_end_ts.ToInternalValue(), TRACE_EVENT_FLAG_NONE, \
+ "sync_id", sync_id, "issue_ts", issue_ts.ToInternalValue())
+
+// Macros to track the life time and value of arbitrary client objects.
+// See also TraceTrackableObject.
+#define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_CREATE_OBJECT, category_group, name, \
+ TRACE_ID_DONT_MANGLE(id), TRACE_EVENT_FLAG_NONE)
+
+#define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, \
+ snapshot) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, \
+ TRACE_ID_DONT_MANGLE(id), TRACE_EVENT_FLAG_NONE, "snapshot", snapshot)
+
+#define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID_AND_TIMESTAMP( \
+ category_group, name, id, timestamp, snapshot) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, \
+ TRACE_ID_DONT_MANGLE(id), TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, \
+ TRACE_EVENT_FLAG_NONE, "snapshot", snapshot)
+
+#define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_DELETE_OBJECT, category_group, name, \
+ TRACE_ID_DONT_MANGLE(id), TRACE_EVENT_FLAG_NONE)
+
+// Records entering and leaving trace event contexts. |category_group| and
+// |name| specify the context category and type. |context| is a
+// snapshotted context object id.
+#define TRACE_EVENT_ENTER_CONTEXT(category_group, name, context) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_ENTER_CONTEXT, category_group, name, \
+ TRACE_ID_DONT_MANGLE(context), TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_LEAVE_CONTEXT(category_group, name, context) \
+ INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
+ TRACE_EVENT_PHASE_LEAVE_CONTEXT, category_group, name, \
+ TRACE_ID_DONT_MANGLE(context), TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_SCOPED_CONTEXT(category_group, name, context) \
+ INTERNAL_TRACE_EVENT_SCOPED_CONTEXT(category_group, name, \
+ TRACE_ID_DONT_MANGLE(context))
+
+// Macro to specify that two trace IDs are identical. For example,
+// TRACE_BIND_IDS(
+// "category", "name",
+// TRACE_ID_WITH_SCOPE("net::URLRequest", 0x1000),
+// TRACE_ID_WITH_SCOPE("blink::ResourceFetcher::FetchRequest", 0x2000))
+// tells the trace consumer that events with ID ("net::URLRequest", 0x1000) from
+// the current process have the same ID as events with ID
+// ("blink::ResourceFetcher::FetchRequest", 0x2000).
+#define TRACE_BIND_IDS(category_group, name, id, bind_id) \
+ INTERNAL_TRACE_EVENT_ADD_BIND_IDS(category_group, name, id, bind_id);
+
+// Macro to efficiently determine if a given category group is enabled.
+#define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \
+ do { \
+ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
+ if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+ *ret = true; \
+ } else { \
+ *ret = false; \
+ } \
+ } while (0)
+
+// Macro to explicitly warm up a given category group. This could be useful in
+// cases where we want to initialize a category group before any trace events
+// for that category group is reported. For example, to have a category group
+// always show up in the "record categories" list for manually selecting
+// settings in about://tracing.
+#define TRACE_EVENT_WARMUP_CATEGORY(category_group) \
+ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group)
+
+// Macro to efficiently determine, through polling, if a new trace has begun.
+#define TRACE_EVENT_IS_NEW_TRACE(ret) \
+ do { \
+ static int INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = 0; \
+ int num_traces_recorded = TRACE_EVENT_API_GET_NUM_TRACES_RECORDED(); \
+ if (num_traces_recorded != -1 && \
+ num_traces_recorded != \
+ INTERNAL_TRACE_EVENT_UID(lastRecordingNumber)) { \
+ INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = num_traces_recorded; \
+ *ret = true; \
+ } else { \
+ *ret = false; \
+ } \
+ } while (0)
+
+// Notes regarding the following definitions:
+// New values can be added and propagated to third party libraries, but existing
+// definitions must never be changed, because third party libraries may use old
+// definitions.
+
+// Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
+#define TRACE_EVENT_PHASE_BEGIN ('B')
+#define TRACE_EVENT_PHASE_END ('E')
+#define TRACE_EVENT_PHASE_COMPLETE ('X')
+#define TRACE_EVENT_PHASE_INSTANT ('I')
+#define TRACE_EVENT_PHASE_ASYNC_BEGIN ('S')
+#define TRACE_EVENT_PHASE_ASYNC_STEP_INTO ('T')
+#define TRACE_EVENT_PHASE_ASYNC_STEP_PAST ('p')
+#define TRACE_EVENT_PHASE_ASYNC_END ('F')
+#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN ('b')
+#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_END ('e')
+#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT ('n')
+#define TRACE_EVENT_PHASE_FLOW_BEGIN ('s')
+#define TRACE_EVENT_PHASE_FLOW_STEP ('t')
+#define TRACE_EVENT_PHASE_FLOW_END ('f')
+#define TRACE_EVENT_PHASE_METADATA ('M')
+#define TRACE_EVENT_PHASE_COUNTER ('C')
+#define TRACE_EVENT_PHASE_SAMPLE ('P')
+#define TRACE_EVENT_PHASE_CREATE_OBJECT ('N')
+#define TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ('O')
+#define TRACE_EVENT_PHASE_DELETE_OBJECT ('D')
+#define TRACE_EVENT_PHASE_MEMORY_DUMP ('v')
+#define TRACE_EVENT_PHASE_MARK ('R')
+#define TRACE_EVENT_PHASE_CLOCK_SYNC ('c')
+#define TRACE_EVENT_PHASE_ENTER_CONTEXT ('(')
+#define TRACE_EVENT_PHASE_LEAVE_CONTEXT (')')
+#define TRACE_EVENT_PHASE_BIND_IDS ('=')
+
+// Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
+#define TRACE_EVENT_FLAG_NONE (static_cast(0))
+#define TRACE_EVENT_FLAG_COPY (static_cast(1 << 0))
+#define TRACE_EVENT_FLAG_HAS_ID (static_cast(1 << 1))
+#define TRACE_EVENT_FLAG_MANGLE_ID (static_cast(1 << 2))
+#define TRACE_EVENT_FLAG_SCOPE_OFFSET (static_cast(1 << 3))
+#define TRACE_EVENT_FLAG_SCOPE_EXTRA (static_cast(1 << 4))
+#define TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP (static_cast(1 << 5))
+#define TRACE_EVENT_FLAG_ASYNC_TTS (static_cast(1 << 6))
+#define TRACE_EVENT_FLAG_BIND_TO_ENCLOSING (static_cast(1 << 7))
+#define TRACE_EVENT_FLAG_FLOW_IN (static_cast(1 << 8))
+#define TRACE_EVENT_FLAG_FLOW_OUT (static_cast(1 << 9))
+#define TRACE_EVENT_FLAG_HAS_CONTEXT_ID (static_cast(1 << 10))
+#define TRACE_EVENT_FLAG_HAS_PROCESS_ID (static_cast(1 << 11))
+
+#define TRACE_EVENT_FLAG_SCOPE_MASK \
+ (static_cast(TRACE_EVENT_FLAG_SCOPE_OFFSET | \
+ TRACE_EVENT_FLAG_SCOPE_EXTRA))
+
+// Type values for identifying types in the TraceValue union.
+#define TRACE_VALUE_TYPE_BOOL (static_cast(1))
+#define TRACE_VALUE_TYPE_UINT (static_cast(2))
+#define TRACE_VALUE_TYPE_INT (static_cast(3))
+#define TRACE_VALUE_TYPE_DOUBLE (static_cast(4))
+#define TRACE_VALUE_TYPE_POINTER (static_cast(5))
+#define TRACE_VALUE_TYPE_STRING (static_cast(6))
+#define TRACE_VALUE_TYPE_COPY_STRING (static_cast(7))
+#define TRACE_VALUE_TYPE_CONVERTABLE (static_cast(8))
+
+// Enum reflecting the scope of an INSTANT event. Must fit within
+// TRACE_EVENT_FLAG_SCOPE_MASK.
+#define TRACE_EVENT_SCOPE_GLOBAL (static_cast(0 << 3))
+#define TRACE_EVENT_SCOPE_PROCESS (static_cast(1 << 3))
+#define TRACE_EVENT_SCOPE_THREAD (static_cast(2 << 3))
+
+#define TRACE_EVENT_SCOPE_NAME_GLOBAL ('g')
+#define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
+#define TRACE_EVENT_SCOPE_NAME_THREAD ('t')
+
+
+// The pointer returned from GetCategoryGroupEnabled() points to a
+// value with zero or more of the following bits. Used in this class only.
+// The TRACE_EVENT macros should only use the value as a bool.
+// These values must be in sync with macro values in trace_log.h in
+// chromium.
+enum CategoryGroupEnabledFlags {
+ // Category group enabled for the recording mode.
+ kEnabledForRecording_CategoryGroupEnabledFlags = 1 << 0,
+ // Category group enabled by SetEventCallbackEnabled().
+ kEnabledForEventCallback_CategoryGroupEnabledFlags = 1 << 2,
+ // Category group enabled to export events to ETW.
+ kEnabledForETWExport_CategoryGroupEnabledFlags = 1 << 3,
+};
+
+// By default, const char* asrgument values are assumed to have long-lived scope
+// and will not be copied. Use this macro to force a const char* to be copied.
+#define TRACE_STR_COPY(str) node::tracing::TraceStringWithCopy(str)
+
+// By default, uint64 ID argument values are not mangled with the Process ID in
+// TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
+#define TRACE_ID_MANGLE(id) node::tracing::TraceID::ForceMangle(id)
+
+// By default, pointers are mangled with the Process ID in TRACE_EVENT_ASYNC
+// macros. Use this macro to prevent Process ID mangling.
+#define TRACE_ID_DONT_MANGLE(id) node::tracing::TraceID::DontMangle(id)
+
+// By default, trace IDs are eventually converted to a single 64-bit number. Use
+// this macro to add a scope string.
+#define TRACE_ID_WITH_SCOPE(scope, id) \
+ node::tracing::TraceID::WithScope(scope, id)
+
+// Sets the current sample state to the given category and name (both must be
+// constant strings). These states are intended for a sampling profiler.
+// Implementation note: we store category and name together because we don't
+// want the inconsistency/expense of storing two pointers.
+// |thread_bucket| is [0..2] and is used to statically isolate samples in one
+// thread from others.
+#define TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(bucket_number, category, \
+ name) \
+ node::tracing::TraceEventSamplingStateScope::Set( \
+ category "\0" name)
+
+// Returns a current sampling state of the given bucket.
+#define TRACE_EVENT_GET_SAMPLING_STATE_FOR_BUCKET(bucket_number) \
+ node::tracing::TraceEventSamplingStateScope::Current()
+
+// Creates a scope of a sampling state of the given bucket.
+//
+// { // The sampling state is set within this scope.
+// TRACE_EVENT_SAMPLING_STATE_SCOPE_FOR_BUCKET(0, "category", "name");
+// ...;
+// }
+#define TRACE_EVENT_SCOPED_SAMPLING_STATE_FOR_BUCKET(bucket_number, category, \
+ name) \
+ node::tracing::TraceEventSamplingStateScope \
+ traceEventSamplingScope(category "\0" name);
+
+
+#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
+ *INTERNAL_TRACE_EVENT_UID(category_group_enabled) & \
+ (kEnabledForRecording_CategoryGroupEnabledFlags | \
+ kEnabledForEventCallback_CategoryGroupEnabledFlags)
+
+// The following macro has no implementation, but it needs to exist since
+// it gets called from scoped trace events. It cannot call UNIMPLEMENTED()
+// since an empty implementation is a valid one.
+#define INTERNAL_TRACE_MEMORY(category, name)
+
+////////////////////////////////////////////////////////////////////////////////
+// Implementation specific tracing API definitions.
+
+// Get a pointer to the enabled state of the given trace category. Only
+// long-lived literal strings should be given as the category group. The
+// returned pointer can be held permanently in a local static for example. If
+// the unsigned char is non-zero, tracing is enabled. If tracing is enabled,
+// TRACE_EVENT_API_ADD_TRACE_EVENT can be called. It's OK if tracing is disabled
+// between the load of the tracing state and the call to
+// TRACE_EVENT_API_ADD_TRACE_EVENT, because this flag only provides an early out
+// for best performance when tracing is disabled.
+// const uint8_t*
+// TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(const char* category_group)
+#define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED \
+ node::tracing::TraceEventHelper::GetCurrentPlatform() \
+ ->GetCategoryGroupEnabled
+
+// Get the number of times traces have been recorded. This is used to implement
+// the TRACE_EVENT_IS_NEW_TRACE facility.
+// unsigned int TRACE_EVENT_API_GET_NUM_TRACES_RECORDED()
+#define TRACE_EVENT_API_GET_NUM_TRACES_RECORDED UNIMPLEMENTED()
+
+// Add a trace event to the platform tracing system.
+// uint64_t TRACE_EVENT_API_ADD_TRACE_EVENT(
+// char phase,
+// const uint8_t* category_group_enabled,
+// const char* name,
+// const char* scope,
+// uint64_t id,
+// uint64_t bind_id,
+// int num_args,
+// const char** arg_names,
+// const uint8_t* arg_types,
+// const uint64_t* arg_values,
+// unsigned int flags)
+#define TRACE_EVENT_API_ADD_TRACE_EVENT \
+ node::tracing::TraceEventHelper::GetCurrentPlatform()->AddTraceEvent
+
+// Set the duration field of a COMPLETE trace event.
+// void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
+// const uint8_t* category_group_enabled,
+// const char* name,
+// uint64_t id)
+#define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION \
+ node::tracing::TraceEventHelper::GetCurrentPlatform() \
+ ->UpdateTraceEventDuration
+
+// Defines atomic operations used internally by the tracing system.
+#define TRACE_EVENT_API_ATOMIC_WORD intptr_t
+#define TRACE_EVENT_API_ATOMIC_LOAD(var) (var)
+#define TRACE_EVENT_API_ATOMIC_STORE(var, value) (var) = (value)
+
+// The thread buckets for the sampling profiler.
+extern TRACE_EVENT_API_ATOMIC_WORD g_trace_state[3];
+
+#define TRACE_EVENT_API_THREAD_BUCKET(thread_bucket) \
+ g_trace_state[thread_bucket]
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Implementation detail: trace event macros create temporary variables
+// to keep instrumentation overhead low. These macros give each temporary
+// variable a unique name based on the line number to prevent name collisions.
+#define INTERNAL_TRACE_EVENT_UID3(a, b) trace_event_unique_##a##b
+#define INTERNAL_TRACE_EVENT_UID2(a, b) INTERNAL_TRACE_EVENT_UID3(a, b)
+#define INTERNAL_TRACE_EVENT_UID(name_prefix) \
+ INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
+
+// Implementation detail: internal macro to create static category.
+// No barriers are needed, because this code is designed to operate safely
+// even when the unsigned char* points to garbage data (which may be the case
+// on processors without cache coherency).
+// TODO(fmeawad): This implementation contradicts that we can have a different
+// configuration for each isolate,
+// https://code.google.com/p/v8/issues/detail?id=4563
+#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES( \
+ category_group, atomic, category_group_enabled) \
+ category_group_enabled = \
+ reinterpret_cast(TRACE_EVENT_API_ATOMIC_LOAD(atomic)); \
+ if (!category_group_enabled) { \
+ category_group_enabled = \
+ TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_group); \
+ TRACE_EVENT_API_ATOMIC_STORE( \
+ atomic, reinterpret_cast( \
+ category_group_enabled)); \
+ }
+
+#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group) \
+ static TRACE_EVENT_API_ATOMIC_WORD INTERNAL_TRACE_EVENT_UID(atomic) = 0; \
+ const uint8_t* INTERNAL_TRACE_EVENT_UID(category_group_enabled); \
+ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES( \
+ category_group, INTERNAL_TRACE_EVENT_UID(atomic), \
+ INTERNAL_TRACE_EVENT_UID(category_group_enabled));
+
+// Implementation detail: internal macro to create static category and add
+// event if the category is enabled.
+#define INTERNAL_TRACE_EVENT_ADD(phase, category_group, name, flags, ...) \
+ do { \
+ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
+ if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+ node::tracing::AddTraceEvent( \
+ phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+ node::tracing::kGlobalScope, node::tracing::kNoId, \
+ node::tracing::kNoId, flags, ##__VA_ARGS__); \
+ } \
+ } while (0)
+
+// Implementation detail: internal macro to create static category and add begin
+// event if the category is enabled. Also adds the end event when the scope
+// ends.
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, ...) \
+ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
+ node::tracing::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer); \
+ if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+ uint64_t h = node::tracing::AddTraceEvent( \
+ TRACE_EVENT_PHASE_COMPLETE, \
+ INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+ node::tracing::kGlobalScope, node::tracing::kNoId, \
+ node::tracing::kNoId, TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__); \
+ INTERNAL_TRACE_EVENT_UID(tracer) \
+ .Initialize(INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+ h); \
+ }
+
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, \
+ bind_id, flow_flags, ...) \
+ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
+ node::tracing::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer); \
+ if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+ unsigned int trace_event_flags = flow_flags; \
+ node::tracing::TraceID trace_event_bind_id(bind_id, \
+ &trace_event_flags); \
+ uint64_t h = node::tracing::AddTraceEvent( \
+ TRACE_EVENT_PHASE_COMPLETE, \
+ INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+ node::tracing::kGlobalScope, node::tracing::kNoId, \
+ trace_event_bind_id.raw_id(), trace_event_flags, ##__VA_ARGS__); \
+ INTERNAL_TRACE_EVENT_UID(tracer) \
+ .Initialize(INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+ h); \
+ }
+
+// Implementation detail: internal macro to create static category and add
+// event if the category is enabled.
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category_group, name, id, \
+ flags, ...) \
+ do { \
+ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
+ if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+ unsigned int trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
+ node::tracing::TraceID trace_event_trace_id(id, \
+ &trace_event_flags); \
+ node::tracing::AddTraceEvent( \
+ phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+ trace_event_trace_id.scope(), trace_event_trace_id.raw_id(), \
+ node::tracing::kNoId, trace_event_flags, ##__VA_ARGS__); \
+ } \
+ } while (0)
+
+// Adds a trace event with a given timestamp. Not Implemented.
+#define INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(phase, category_group, name, \
+ timestamp, flags, ...) \
+ UNIMPLEMENTED()
+
+// Adds a trace event with a given id and timestamp. Not Implemented.
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_AND_TIMESTAMP( \
+ phase, category_group, name, id, timestamp, flags, ...) \
+ UNIMPLEMENTED()
+
+// Adds a trace event with a given id, thread_id, and timestamp. Not
+// Implemented.
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+ phase, category_group, name, id, thread_id, timestamp, flags, ...) \
+ UNIMPLEMENTED()
+
+// Enter and leave a context based on the current scope.
+#define INTERNAL_TRACE_EVENT_SCOPED_CONTEXT(category_group, name, context) \
+ struct INTERNAL_TRACE_EVENT_UID(ScopedContext) { \
+ public: \
+ INTERNAL_TRACE_EVENT_UID(ScopedContext)(uint64_t cid) : cid_(cid) { \
+ TRACE_EVENT_ENTER_CONTEXT(category_group, name, cid_); \
+ } \
+ ~INTERNAL_TRACE_EVENT_UID(ScopedContext)() { \
+ TRACE_EVENT_LEAVE_CONTEXT(category_group, name, cid_); \
+ } \
+ \
+ private: \
+ /* Local class friendly DISALLOW_COPY_AND_ASSIGN */ \
+ INTERNAL_TRACE_EVENT_UID(ScopedContext) \
+ (const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {} \
+ void operator=(const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {} \
+ uint64_t cid_; \
+ }; \
+ INTERNAL_TRACE_EVENT_UID(ScopedContext) \
+ INTERNAL_TRACE_EVENT_UID(scoped_context)(context.raw_id());
+
+namespace node {
+namespace tracing {
+
+// Specify these values when the corresponding argument of AddTraceEvent is not
+// used.
+const int kZeroNumArgs = 0;
+const decltype(nullptr) kGlobalScope = nullptr;
+const uint64_t kNoId = 0;
+
+class TraceEventHelper {
+ public:
+ static void SetCurrentPlatform(v8::Platform* platform);
+ static v8::Platform* GetCurrentPlatform();
+};
+
+// TraceID encapsulates an ID that can either be an integer or pointer. Pointers
+// are by default mangled with the Process ID so that they are unlikely to
+// collide when the same pointer is used on different processes.
+class TraceID {
+ public:
+ class WithScope {
+ public:
+ WithScope(const char* scope, uint64_t raw_id)
+ : scope_(scope), raw_id_(raw_id) {}
+ uint64_t raw_id() const { return raw_id_; }
+ const char* scope() const { return scope_; }
+
+ private:
+ const char* scope_ = nullptr;
+ uint64_t raw_id_;
+ };
+
+ class DontMangle {
+ public:
+ explicit DontMangle(const void* raw_id)
+ : raw_id_(static_cast(reinterpret_cast(raw_id))) {}
+ explicit DontMangle(uint64_t raw_id) : raw_id_(raw_id) {}
+ explicit DontMangle(unsigned int raw_id) : raw_id_(raw_id) {}
+ explicit DontMangle(uint16_t raw_id) : raw_id_(raw_id) {}
+ explicit DontMangle(unsigned char raw_id) : raw_id_(raw_id) {}
+ explicit DontMangle(int64_t raw_id)
+ : raw_id_(static_cast(raw_id)) {}
+ explicit DontMangle(int raw_id) : raw_id_(static_cast(raw_id)) {}
+ explicit DontMangle(int16_t raw_id)
+ : raw_id_(static_cast(raw_id)) {}
+ explicit DontMangle(signed char raw_id)
+ : raw_id_(static_cast(raw_id)) {}
+ explicit DontMangle(WithScope scoped_id)
+ : scope_(scoped_id.scope()), raw_id_(scoped_id.raw_id()) {}
+ const char* scope() const { return scope_; }
+ uint64_t raw_id() const { return raw_id_; }
+
+ private:
+ const char* scope_ = nullptr;
+ uint64_t raw_id_;
+ };
+
+ class ForceMangle {
+ public:
+ explicit ForceMangle(uint64_t raw_id) : raw_id_(raw_id) {}
+ explicit ForceMangle(unsigned int raw_id) : raw_id_(raw_id) {}
+ explicit ForceMangle(uint16_t raw_id) : raw_id_(raw_id) {}
+ explicit ForceMangle(unsigned char raw_id) : raw_id_(raw_id) {}
+ explicit ForceMangle(int64_t raw_id)
+ : raw_id_(static_cast(raw_id)) {}
+ explicit ForceMangle(int raw_id) : raw_id_(static_cast(raw_id)) {}
+ explicit ForceMangle(int16_t raw_id)
+ : raw_id_(static_cast(raw_id)) {}
+ explicit ForceMangle(signed char raw_id)
+ : raw_id_(static_cast(raw_id)) {}
+ uint64_t raw_id() const { return raw_id_; }
+
+ private:
+ uint64_t raw_id_;
+ };
+
+ TraceID(const void* raw_id, unsigned int* flags)
+ : raw_id_(static_cast(reinterpret_cast(raw_id))) {
+ *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
+ }
+ TraceID(ForceMangle raw_id, unsigned int* flags) : raw_id_(raw_id.raw_id()) {
+ *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
+ }
+ TraceID(DontMangle maybe_scoped_id, unsigned int* flags)
+ : scope_(maybe_scoped_id.scope()), raw_id_(maybe_scoped_id.raw_id()) {}
+ TraceID(uint64_t raw_id, unsigned int* flags) : raw_id_(raw_id) {
+ (void)flags;
+ }
+ TraceID(unsigned int raw_id, unsigned int* flags) : raw_id_(raw_id) {
+ (void)flags;
+ }
+ TraceID(uint16_t raw_id, unsigned int* flags) : raw_id_(raw_id) {
+ (void)flags;
+ }
+ TraceID(unsigned char raw_id, unsigned int* flags) : raw_id_(raw_id) {
+ (void)flags;
+ }
+ TraceID(int64_t raw_id, unsigned int* flags)
+ : raw_id_(static_cast(raw_id)) {
+ (void)flags;
+ }
+ TraceID(int raw_id, unsigned int* flags)
+ : raw_id_(static_cast(raw_id)) {
+ (void)flags;
+ }
+ TraceID(int16_t raw_id, unsigned int* flags)
+ : raw_id_(static_cast(raw_id)) {
+ (void)flags;
+ }
+ TraceID(signed char raw_id, unsigned int* flags)
+ : raw_id_(static_cast(raw_id)) {
+ (void)flags;
+ }
+ TraceID(WithScope scoped_id, unsigned int* flags)
+ : scope_(scoped_id.scope()), raw_id_(scoped_id.raw_id()) {}
+
+ uint64_t raw_id() const { return raw_id_; }
+ const char* scope() const { return scope_; }
+
+ private:
+ const char* scope_ = nullptr;
+ uint64_t raw_id_;
+};
+
+// Simple union to store various types as uint64_t.
+union TraceValueUnion {
+ bool as_bool;
+ uint64_t as_uint;
+ int64_t as_int;
+ double as_double;
+ const void* as_pointer;
+ const char* as_string;
+};
+
+// Simple container for const char* that should be copied instead of retained.
+class TraceStringWithCopy {
+ public:
+ explicit TraceStringWithCopy(const char* str) : str_(str) {}
+ operator const char*() const { return str_; }
+
+ private:
+ const char* str_;
+};
+
+// Define SetTraceValue for each allowed type. It stores the type and
+// value in the return arguments. This allows this API to avoid declaring any
+// structures so that it is portable to third_party libraries.
+#define INTERNAL_DECLARE_SET_TRACE_VALUE(actual_type, union_member, \
+ value_type_id) \
+ static inline void SetTraceValue(actual_type arg, unsigned char* type, \
+ uint64_t* value) { \
+ TraceValueUnion type_value; \
+ type_value.union_member = arg; \
+ *type = value_type_id; \
+ *value = type_value.as_uint; \
+ }
+// Simpler form for int types that can be safely casted.
+#define INTERNAL_DECLARE_SET_TRACE_VALUE_INT(actual_type, value_type_id) \
+ static inline void SetTraceValue(actual_type arg, unsigned char* type, \
+ uint64_t* value) { \
+ *type = value_type_id; \
+ *value = static_cast(arg); \
+ }
+
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(uint64_t, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned int, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(uint16_t, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned char, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int64_t, TRACE_VALUE_TYPE_INT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int, TRACE_VALUE_TYPE_INT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int16_t, TRACE_VALUE_TYPE_INT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(signed char, TRACE_VALUE_TYPE_INT)
+INTERNAL_DECLARE_SET_TRACE_VALUE(bool, as_bool, TRACE_VALUE_TYPE_BOOL)
+INTERNAL_DECLARE_SET_TRACE_VALUE(double, as_double, TRACE_VALUE_TYPE_DOUBLE)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, as_pointer,
+ TRACE_VALUE_TYPE_POINTER)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, as_string,
+ TRACE_VALUE_TYPE_STRING)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, as_string,
+ TRACE_VALUE_TYPE_COPY_STRING)
+
+#undef INTERNAL_DECLARE_SET_TRACE_VALUE
+#undef INTERNAL_DECLARE_SET_TRACE_VALUE_INT
+
+// These AddTraceEvent template
+// function is defined here instead of in the macro, because the arg_values
+// could be temporary objects, such as std::string. In order to store
+// pointers to the internal c_str and pass through to the tracing API,
+// the arg_values must live throughout these procedures.
+
+static inline uint64_t AddTraceEvent(char phase,
+ const uint8_t* category_group_enabled,
+ const char* name, const char* scope,
+ uint64_t id, uint64_t bind_id,
+ unsigned int flags) {
+ return TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_group_enabled, name,
+ scope, id, bind_id, kZeroNumArgs, NULL,
+ NULL, NULL, flags);
+}
+
+template
+static inline uint64_t AddTraceEvent(
+ char phase, const uint8_t* category_group_enabled, const char* name,
+ const char* scope, uint64_t id, uint64_t bind_id, unsigned int flags,
+ const char* arg1_name, const ARG1_TYPE& arg1_val) {
+ const int num_args = 1;
+ uint8_t arg_types[1];
+ uint64_t arg_values[1];
+ SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
+ return TRACE_EVENT_API_ADD_TRACE_EVENT(
+ phase, category_group_enabled, name, scope, id, bind_id, num_args,
+ &arg1_name, arg_types, arg_values, flags);
+}
+
+template
+static inline uint64_t AddTraceEvent(
+ char phase, const uint8_t* category_group_enabled, const char* name,
+ const char* scope, uint64_t id, uint64_t bind_id, unsigned int flags,
+ const char* arg1_name, const ARG1_TYPE& arg1_val, const char* arg2_name,
+ const ARG2_TYPE& arg2_val) {
+ const int num_args = 2;
+ const char* arg_names[2] = {arg1_name, arg2_name};
+ unsigned char arg_types[2];
+ uint64_t arg_values[2];
+ SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
+ SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
+ return TRACE_EVENT_API_ADD_TRACE_EVENT(
+ phase, category_group_enabled, name, scope, id, bind_id, num_args,
+ arg_names, arg_types, arg_values, flags);
+}
+
+// Used by TRACE_EVENTx macros. Do not use directly.
+class ScopedTracer {
+ public:
+ // Note: members of data_ intentionally left uninitialized. See Initialize.
+ ScopedTracer() : p_data_(NULL) {}
+
+ ~ScopedTracer() {
+ if (p_data_ && *data_.category_group_enabled)
+ TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
+ data_.category_group_enabled, data_.name, data_.event_handle);
+ }
+
+ void Initialize(const uint8_t* category_group_enabled, const char* name,
+ uint64_t event_handle) {
+ data_.category_group_enabled = category_group_enabled;
+ data_.name = name;
+ data_.event_handle = event_handle;
+ p_data_ = &data_;
+ }
+
+ private:
+ // This Data struct workaround is to avoid initializing all the members
+ // in Data during construction of this object, since this object is always
+ // constructed, even when tracing is disabled. If the members of Data were
+ // members of this class instead, compiler warnings occur about potential
+ // uninitialized accesses.
+ struct Data {
+ const uint8_t* category_group_enabled;
+ const char* name;
+ uint64_t event_handle;
+ };
+ Data* p_data_;
+ Data data_;
+};
+
+// Used by TRACE_EVENT_BINARY_EFFICIENTx macro. Do not use directly.
+class ScopedTraceBinaryEfficient {
+ public:
+ ScopedTraceBinaryEfficient(const char* category_group, const char* name);
+ ~ScopedTraceBinaryEfficient();
+
+ private:
+ const uint8_t* category_group_enabled_;
+ const char* name_;
+ uint64_t event_handle_;
+};
+
+// TraceEventSamplingStateScope records the current sampling state
+// and sets a new sampling state. When the scope exists, it restores
+// the sampling state having recorded.
+template
+class TraceEventSamplingStateScope {
+ public:
+ explicit TraceEventSamplingStateScope(const char* category_and_name) {
+ previous_state_ = TraceEventSamplingStateScope::Current();
+ TraceEventSamplingStateScope::Set(category_and_name);
+ }
+
+ ~TraceEventSamplingStateScope() {
+ TraceEventSamplingStateScope::Set(previous_state_);
+ }
+
+ static inline const char* Current() {
+ return reinterpret_cast(
+ TRACE_EVENT_API_ATOMIC_LOAD(g_trace_state[BucketNumber]));
+ }
+
+ static inline void Set(const char* category_and_name) {
+ TRACE_EVENT_API_ATOMIC_STORE(g_trace_state[BucketNumber],
+ reinterpret_cast(
+ const_cast(category_and_name)));
+ }
+
+ private:
+ const char* previous_state_;
+};
+
+} // namespace tracing
+} // namespace node
+
+#endif // SRC_TRACING_TRACE_EVENT_H_
diff --git a/src/util.h b/src/util.h
index b32f2b8a71ca0f..cf530a4da9146c 100644
--- a/src/util.h
+++ b/src/util.h
@@ -10,6 +10,7 @@
#include
#include
#include
+#include
#include // std::remove_reference
@@ -304,29 +305,40 @@ class MaybeStackBuffer {
return length_;
}
- // Call to make sure enough space for `storage` entries is available.
- // There can only be 1 call to AllocateSufficientStorage or Invalidate
- // per instance.
+ // Current maximum capacity of the buffer with which SetLength() can be used
+ // without first calling AllocateSufficientStorage().
+ size_t capacity() const {
+ return IsAllocated() ? capacity_ :
+ IsInvalidated() ? 0 : kStackStorageSize;
+ }
+
+ // Make sure enough space for `storage` entries is available.
+ // This method can be called multiple times throughout the lifetime of the
+ // buffer, but once this has been called Invalidate() cannot be used.
+ // Content of the buffer in the range [0, length()) is preserved.
void AllocateSufficientStorage(size_t storage) {
- if (storage <= kStackStorageSize) {
- buf_ = buf_st_;
- } else {
- buf_ = Malloc(storage);
+ CHECK(!IsInvalidated());
+ if (storage > capacity()) {
+ bool was_allocated = IsAllocated();
+ T* allocated_ptr = was_allocated ? buf_ : nullptr;
+ buf_ = Realloc(allocated_ptr, storage);
+ capacity_ = storage;
+ if (!was_allocated && length_ > 0)
+ memcpy(buf_, buf_st_, length_ * sizeof(buf_[0]));
}
- // Remember how much was allocated to check against that in SetLength().
length_ = storage;
}
void SetLength(size_t length) {
- // length_ stores how much memory was allocated.
- CHECK_LE(length, length_);
+ // capacity() returns how much memory is actually available.
+ CHECK_LE(length, capacity());
length_ = length;
}
void SetLengthAndZeroTerminate(size_t length) {
- // length_ stores how much memory was allocated.
- CHECK_LE(length + 1, length_);
+ // capacity() returns how much memory is actually available.
+ CHECK_LE(length + 1, capacity());
SetLength(length);
// T() is 0 for integer types, nullptr for pointers, etc.
@@ -334,24 +346,35 @@ class MaybeStackBuffer {
}
// Make derefencing this object return nullptr.
- // Calling this is mutually exclusive with calling
- // AllocateSufficientStorage.
+ // This method can be called multiple times throughout the lifetime of the
+ // buffer, but once this has been called AllocateSufficientStorage() cannot
+ // be used.
void Invalidate() {
- CHECK_EQ(buf_, buf_st_);
+ CHECK(!IsAllocated());
length_ = 0;
buf_ = nullptr;
}
- bool IsAllocated() {
- return buf_ != buf_st_;
+ // If the buffer is stored in the heap rather than on the stack.
+ bool IsAllocated() const {
+ return !IsInvalidated() && buf_ != buf_st_;
+ }
+
+ // If Invalidate() has been called.
+ bool IsInvalidated() const {
+ return buf_ == nullptr;
}
+ // Release ownership of the malloc'd buffer.
+ // Note: This does not free the buffer.
void Release() {
+ CHECK(IsAllocated());
buf_ = buf_st_;
length_ = 0;
+ capacity_ = 0;
}
- MaybeStackBuffer() : length_(0), buf_(buf_st_) {
+ MaybeStackBuffer() : length_(0), capacity_(0), buf_(buf_st_) {
// Default to a zero-length, null-terminated buffer.
buf_[0] = T();
}
@@ -361,12 +384,14 @@ class MaybeStackBuffer {
}
~MaybeStackBuffer() {
- if (buf_ != buf_st_)
+ if (IsAllocated())
free(buf_);
}
private:
size_t length_;
+ // capacity of the malloc'ed buf_
+ size_t capacity_;
T* buf_;
T buf_st_[kStackStorageSize];
};
@@ -394,7 +419,7 @@ class BufferValue : public MaybeStackBuffer {
#define SPREAD_BUFFER_ARG(val, name) \
CHECK((val)->IsUint8Array()); \
- Local name = (val).As(); \
+ v8::Local name = (val).As(); \
v8::ArrayBuffer::Contents name##_c = name->Buffer()->GetContents(); \
const size_t name##_offset = name->ByteOffset(); \
const size_t name##_length = name->ByteLength(); \
diff --git a/test/README.md b/test/README.md
index 5ed028a19631d6..949a275792abb0 100644
--- a/test/README.md
+++ b/test/README.md
@@ -1,147 +1,154 @@
-# Table of Contents
-* [Test directories](#test-directories)
-* [Common module API](#common-module-api)
-
-## Test Directories
-
-### abort
-
-Tests for when the `--abort-on-uncaught-exception` flag is used.
-
-| Runs on CI |
-|:----------:|
-| No |
-
-### addons
-
-Tests for [addon](https://nodejs.org/api/addons.html) functionality along with
-some tests that require an addon to function properly.
-
-
-| Runs on CI |
-|:----------:|
-| Yes |
-
-### cctest
-
-C++ test that is run as part of the build process.
-
-| Runs on CI |
-|:----------:|
-| Yes |
-
-### debugger
-
-Tests for [debugger](https://nodejs.org/api/debugger.html) functionality.
-
-| Runs on CI |
-|:----------:|
-| No |
-
-### disabled
-
-Tests that have been disabled from running for various reasons.
-
-| Runs on CI |
-|:----------:|
-| No |
-
-### fixtures
-
-Test fixtures used in various tests throughout the test suite.
-
-### gc
-
-Tests for garbage collection related functionality.
-
-| Runs on CI |
-|:----------:|
-| No |
-
-
-### inspector
+# Node.js Core Tests
-Tests for the V8 inspector integration.
+This folder contains code and data used to test the Node.js implementation.
-| Runs on CI |
-|:----------:|
-| Yes |
+For a detailed guide on how to write tests in this
+directory, see [the guide on writing tests](../doc/guides/writing-tests.md).
-### internet
+On how to run tests in this direcotry, see
+[the contributing guide](../CONTRIBUTING.md#step-5-test).
-Tests that make real outbound connections (mainly networking related modules).
-Tests for networking related modules may also be present in other directories,
-but those tests do not make outbound connections.
+## Table of Contents
-| Runs on CI |
-|:----------:|
-| No |
-
-### known_issues
-
-Tests reproducing known issues within the system.
-
-| Runs on CI |
-|:----------:|
-| No |
-
-### message
-
-Tests for messages that are output for various conditions (`console.log`,
-error messages etc.)
-
-| Runs on CI |
-|:----------:|
-| Yes |
-
-### parallel
-
-Various tests that are able to be run in parallel.
-
-| Runs on CI |
-|:----------:|
-| Yes |
-
-### pummel
-
-Various tests for various modules / system functionality operating under load.
-
-| Runs on CI |
-|:----------:|
-| No |
-
-### sequential
-
-Various tests that are run sequentially.
-
-| Runs on CI |
-|:----------:|
-| Yes |
-
-### testpy
-
-Test configuration utility used by various test suites.
-
-### tick-processor
-
-Tests for the V8 tick processor integration. The tests are for the logic in
-`lib/internal/v8_prof_processor.js` and `lib/internal/v8_prof_polyfill.js`. The
-tests confirm that the profile processor packages the correct set of scripts
-from V8 and introduces the correct platform specific logic.
-
-| Runs on CI |
-|:----------:|
-| No |
-
-### timers
-
-Tests for [timing utilities](https://nodejs.org/api/timers.html) (`setTimeout`
-and `setInterval`).
+* [Test directories](#test-directories)
+* [Common module API](#common-module-api)
-| Runs on CI |
-|:----------:|
-| No |
+## Test Directories
+
+
+
+ Directory
+ Runs on CI
+ Purpose
+
+
+
+
+ abort
+ No
+
+ Tests for when the --abort-on-uncaught-exception
+ flag is used.
+
+
+
+ addons
+ Yes
+
+ Tests for addon
+ functionality along with some tests that require an addon to function
+ properly.
+
+
+
+ cctest
+ Yes
+
+ C++ test that is run as part of the build process.
+
+
+
+ debugger
+ No
+
+ Tests for debugger
+ functionality along with some tests that require an addon to function
+ properly.
+
+
+
+ disabled
+ No
+
+ Tests that have been disabled from running for various reasons.
+
+
+
+ fixtures
+ Test fixtures used in various tests throughout the test suite.
+
+
+ gc
+ No
+ Tests for garbage collection related functionality.
+
+
+ inspector
+ Yes
+ Tests for the V8 inspector integration.
+
+
+ internet
+ No
+
+ Tests that make real outbound connections (mainly networking related
+ modules). Tests for networking related modules may also be present in
+ other directories, but those tests do not make outbound connections.
+
+
+
+ known_issues
+ No
+ Tests reproducing known issues within the system.
+
+
+ message
+ Yes
+
+ Tests for messages that are output for various conditions
+ (console.log, error messages etc.)
+
+
+ parallel
+ Yes
+ Various tests that are able to be run in parallel.
+
+
+ pummel
+ No
+
+ Various tests for various modules / system functionality operating
+ under load.
+
+
+
+ sequential
+ Yes
+
+ Various tests that are run sequentially.
+
+
+
+ testpy
+
+ Test configuration utility used by various test suites.
+
+
+
+ tick-processor
+ No
+
+ Tests for the V8 tick processor integration. The tests are for the
+ logic in lib/internal/v8_prof_processor.js and
+ lib/internal/v8_prof_polyfill.js. The tests confirm that
+ the profile processor packages the correct set of scripts from V8 and
+ introduces the correct platform specific logic.
+
+
+
+ timers
+ No
+
+ Tests for
+ timing utilities
+ (setTimeout and setInterval).
+
+
+
+
## Common module API
@@ -180,6 +187,24 @@ Platform normalizes the `dd` command
Check if there is more than 1gb of total memory.
+### expectsError(settings)
+* `settings` [<Object>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
+ with the following optional properties:
+ * `code` [<String>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type)
+ expected error must have this value for its `code` property
+ * `type` [<Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
+ expected error must be an instance of `type`
+ * `message` [<String>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type)
+ or [<RegExp>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp)
+ if a string is provided for `message`, expected error must have it for its
+ `message` property; if a regular expression is provided for `message`, the
+ regular expression must match the `message` property of the expected error
+
+* return function suitable for use as a validation function passed as the second
+ argument to `assert.throws()`
+
+The expected error should be [subclassed by the `internal/errors` module](https://github.com/nodejs/node/blob/master/doc/guides/using-internal-errors.md#api).
+
### expectWarning(name, expected)
* `name` [<String>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type)
* `expected` [<String>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) | [<Array>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
diff --git a/test/cctest/util.cc b/test/cctest/util.cc
index f99a46cdf5353b..a6ece3c6f4d377 100644
--- a/test/cctest/util.cc
+++ b/test/cctest/util.cc
@@ -132,3 +132,127 @@ TEST(UtilTest, UncheckedCalloc) {
TEST_AND_FREE(UncheckedCalloc(0));
TEST_AND_FREE(UncheckedCalloc(1));
}
+
+template
+static void MaybeStackBufferBasic() {
+ using node::MaybeStackBuffer;
+
+ MaybeStackBuffer buf;
+ size_t old_length;
+ size_t old_capacity;
+
+ /* Default constructor */
+ EXPECT_EQ(0U, buf.length());
+ EXPECT_FALSE(buf.IsAllocated());
+ EXPECT_GT(buf.capacity(), buf.length());
+
+ /* SetLength() expansion */
+ buf.SetLength(buf.capacity());
+ EXPECT_EQ(buf.capacity(), buf.length());
+ EXPECT_FALSE(buf.IsAllocated());
+
+ /* Means of accessing raw buffer */
+ EXPECT_EQ(buf.out(), *buf);
+ EXPECT_EQ(&buf[0], *buf);
+
+ /* Basic I/O */
+ for (size_t i = 0; i < buf.length(); i++)
+ buf[i] = static_cast(i);
+ for (size_t i = 0; i < buf.length(); i++)
+ EXPECT_EQ(static_cast(i), buf[i]);
+
+ /* SetLengthAndZeroTerminate() */
+ buf.SetLengthAndZeroTerminate(buf.capacity() - 1);
+ EXPECT_EQ(buf.capacity() - 1, buf.length());
+ for (size_t i = 0; i < buf.length(); i++)
+ EXPECT_EQ(static_cast(i), buf[i]);
+ buf.SetLength(buf.capacity());
+ EXPECT_EQ(0, buf[buf.length() - 1]);
+
+ /* Initial Realloc */
+ old_length = buf.length() - 1;
+ old_capacity = buf.capacity();
+ buf.AllocateSufficientStorage(buf.capacity() * 2);
+ EXPECT_EQ(buf.capacity(), buf.length());
+ EXPECT_TRUE(buf.IsAllocated());
+ for (size_t i = 0; i < old_length; i++)
+ EXPECT_EQ(static_cast(i), buf[i]);
+ EXPECT_EQ(0, buf[old_length]);
+
+ /* SetLength() reduction and expansion */
+ for (size_t i = 0; i < buf.length(); i++)
+ buf[i] = static_cast(i);
+ buf.SetLength(10);
+ for (size_t i = 0; i < buf.length(); i++)
+ EXPECT_EQ(static_cast(i), buf[i]);
+ buf.SetLength(buf.capacity());
+ for (size_t i = 0; i < buf.length(); i++)
+ EXPECT_EQ(static_cast(i), buf[i]);
+
+ /* Subsequent Realloc */
+ old_length = buf.length();
+ old_capacity = buf.capacity();
+ buf.AllocateSufficientStorage(old_capacity * 1.5);
+ EXPECT_EQ(buf.capacity(), buf.length());
+ EXPECT_EQ(static_cast(old_capacity * 1.5), buf.length());
+ EXPECT_TRUE(buf.IsAllocated());
+ for (size_t i = 0; i < old_length; i++)
+ EXPECT_EQ(static_cast(i), buf[i]);
+
+ /* Basic I/O on Realloc'd buffer */
+ for (size_t i = 0; i < buf.length(); i++)
+ buf[i] = static_cast(i);
+ for (size_t i = 0; i < buf.length(); i++)
+ EXPECT_EQ(static_cast(i), buf[i]);
+
+ /* Release() */
+ T* rawbuf = buf.out();
+ buf.Release();
+ EXPECT_EQ(0U, buf.length());
+ EXPECT_FALSE(buf.IsAllocated());
+ EXPECT_GT(buf.capacity(), buf.length());
+ free(rawbuf);
+}
+
+TEST(UtilTest, MaybeStackBuffer) {
+ using node::MaybeStackBuffer;
+
+ MaybeStackBufferBasic();
+ MaybeStackBufferBasic();
+
+ // Constructor with size parameter
+ {
+ MaybeStackBuffer buf(100);
+ EXPECT_EQ(100U, buf.length());
+ EXPECT_FALSE(buf.IsAllocated());
+ EXPECT_GT(buf.capacity(), buf.length());
+ buf.SetLength(buf.capacity());
+ EXPECT_EQ(buf.capacity(), buf.length());
+ EXPECT_FALSE(buf.IsAllocated());
+ for (size_t i = 0; i < buf.length(); i++)
+ buf[i] = static_cast(i);
+ for (size_t i = 0; i < buf.length(); i++)
+ EXPECT_EQ(static_cast(i), buf[i]);
+
+ MaybeStackBuffer bigbuf(10000);
+ EXPECT_EQ(10000U, bigbuf.length());
+ EXPECT_TRUE(bigbuf.IsAllocated());
+ EXPECT_EQ(bigbuf.length(), bigbuf.capacity());
+ for (size_t i = 0; i < bigbuf.length(); i++)
+ bigbuf[i] = static_cast(i);
+ for (size_t i = 0; i < bigbuf.length(); i++)
+ EXPECT_EQ(static_cast(i), bigbuf[i]);
+ }
+
+ // Invalidated buffer
+ {
+ MaybeStackBuffer buf;
+ buf.Invalidate();
+ EXPECT_TRUE(buf.IsInvalidated());
+ EXPECT_FALSE(buf.IsAllocated());
+ EXPECT_EQ(0U, buf.length());
+ EXPECT_EQ(0U, buf.capacity());
+ buf.Invalidate();
+ EXPECT_TRUE(buf.IsInvalidated());
+ }
+}
diff --git a/test/common.js b/test/common.js
index 830206ea0f93ef..99ea679114c038 100644
--- a/test/common.js
+++ b/test/common.js
@@ -284,6 +284,9 @@ exports.platformTimeout = function(ms) {
if (process.config.target_defaults.default_configuration === 'Debug')
ms = 2 * ms;
+ if (global.__coverage__)
+ ms = 4 * ms;
+
if (exports.isAix)
return 2 * ms; // default localhost speed is slower on AIX
@@ -381,7 +384,11 @@ function leakedGlobals() {
if (!knownGlobals.includes(global[val]))
leaked.push(val);
- return leaked;
+ if (global.__coverage__) {
+ return leaked.filter((varname) => !/^(cov_|__cov)/.test(varname));
+ } else {
+ return leaked;
+ }
}
exports.leakedGlobals = leakedGlobals;
@@ -392,8 +399,7 @@ process.on('exit', function() {
if (!exports.globalCheck) return;
const leaked = leakedGlobals();
if (leaked.length > 0) {
- console.error('Unknown globals: %s', leaked);
- fail('Unknown global found');
+ fail(`Unexpected global(s) found: ${leaked.join(', ')}`);
}
});
@@ -588,3 +594,45 @@ Object.defineProperty(exports, 'hasIntl', {
return process.binding('config').hasIntl;
}
});
+
+// https://github.com/w3c/testharness.js/blob/master/testharness.js
+exports.WPT = {
+ test: (fn, desc) => {
+ try {
+ fn();
+ } catch (err) {
+ if (err instanceof Error)
+ err.message = `In ${desc}:\n ${err.message}`;
+ throw err;
+ }
+ },
+ assert_equals: assert.strictEqual,
+ assert_true: (value, message) => assert.strictEqual(value, true, message),
+ assert_false: (value, message) => assert.strictEqual(value, false, message),
+ assert_throws: (code, func, desc) => {
+ assert.throws(func, (err) => {
+ return typeof err === 'object' && 'name' in err && err.name === code.name;
+ }, desc);
+ },
+ assert_array_equals: assert.deepStrictEqual,
+ assert_unreached(desc) {
+ assert.fail(undefined, undefined, `Reached unreachable code: ${desc}`);
+ }
+};
+
+// Useful for testing expected internal/error objects
+exports.expectsError = function expectsError({code, type, message}) {
+ return function(error) {
+ assert.strictEqual(error.code, code);
+ if (type !== undefined)
+ assert(error instanceof type,
+ `${error} is not the expected type ${type}`);
+ if (message instanceof RegExp) {
+ assert(message.test(error.message),
+ `${error.message} does not match ${message}`);
+ } else if (typeof message === 'string') {
+ assert.strictEqual(error.message, message);
+ }
+ return true;
+ };
+};
diff --git a/test/doctool/test-doctool-html.js b/test/doctool/test-doctool-html.js
index 442381b54d7b72..e119ee86172c25 100644
--- a/test/doctool/test-doctool-html.js
+++ b/test/doctool/test-doctool-html.js
@@ -47,14 +47,25 @@ const testData = [
'Describe Foobar in more detail here.
' +
'Foobar II# ' +
- 'Added in: v5.3.0, v4.2.0
' +
- 'Describe Foobar II in more detail here.
' +
+ ' ' +
+ 'Describe Foobar II in more detail here.' +
+ 'fg(1)
' +
'Deprecated thingy# ' +
' ' +
'Added in: v1.0.0 ' +
'Deprecated since: v2.0.0
Describe ' +
- 'Deprecated thingy in more detail here.
' +
+ 'Deprecated thingy in more detail here.' +
+ 'fg(1p) ' +
+ '' +
'Something# ' +
' ' +
diff --git a/test/doctool/test-doctool-json.js b/test/doctool/test-doctool-json.js
index ae7b2007b7d2ef..346a7f331e9d7f 100644
--- a/test/doctool/test-doctool-json.js
+++ b/test/doctool/test-doctool-json.js
@@ -89,7 +89,8 @@ const testData = [
textRaw: 'Foobar',
name: 'foobar',
meta: {
- added: ['v1.0.0']
+ added: ['v1.0.0'],
+ changes: []
},
desc: 'Describe Foobar in more detail ' +
'here.
\n',
@@ -100,10 +101,17 @@ const testData = [
textRaw: 'Foobar II',
name: 'foobar_ii',
meta: {
- added: ['v5.3.0', 'v4.2.0']
+ added: ['v5.3.0', 'v4.2.0'],
+ changes: [
+ { version: 'v4.2.0',
+ 'pr-url': 'https://github.com/nodejs/node/pull/3276',
+ description: 'The `error` parameter can now be ' +
+ 'an arrow function.'
+ }
+ ]
},
desc: 'Describe Foobar II in more detail ' +
- 'here.
\n',
+ 'here. fg(1)\n',
type: 'module',
displayName: 'Foobar II'
},
@@ -112,10 +120,11 @@ const testData = [
name: 'deprecated_thingy',
meta: {
added: ['v1.0.0'],
- deprecated: ['v2.0.0']
+ deprecated: ['v2.0.0'],
+ changes: []
},
desc: 'Describe Deprecated thingy in more ' +
- 'detail here.
\n',
+ 'detail here. fg(1p)\n',
type: 'module',
displayName: 'Deprecated thingy'
},
diff --git a/test/fixtures/doc_with_yaml.md b/test/fixtures/doc_with_yaml.md
index 493c2e7e4268b2..89cf28104e5533 100644
--- a/test/fixtures/doc_with_yaml.md
+++ b/test/fixtures/doc_with_yaml.md
@@ -12,9 +12,13 @@ Describe `Foobar` in more detail here.
added:
- v5.3.0
- v4.2.0
+changes:
+ - version: v4.2.0
+ pr-url: https://github.com/nodejs/node/pull/3276
+ description: The `error` parameter can now be an arrow function.
-->
-Describe `Foobar II` in more detail here.
+Describe `Foobar II` in more detail here. fg(1)
## Deprecated thingy
-Describe `Deprecated thingy` in more detail here.
+Describe `Deprecated thingy` in more detail here. fg(1p)
## Something
diff --git a/test/fixtures/url-setter-tests.json b/test/fixtures/url-setter-tests.json
index 56a1c00a86fd45..4876b9940c1d98 100644
--- a/test/fixtures/url-setter-tests.json
+++ b/test/fixtures/url-setter-tests.json
@@ -1,5 +1,6 @@
{
"comment": [
+ "License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html",
"## Tests for setters of https://url.spec.whatwg.org/#urlutils-members",
"",
"This file contains a JSON object.",
@@ -19,8 +20,7 @@
" get the attribute `key` (invoke its getter).",
" The returned string must be equal to `value`.",
"",
- "Note: the 'href' setter is already covered by urltestdata.json.",
- "Source: https://github.com/w3c/web-platform-tests/tree/master/url"
+ "Note: the 'href' setter is already covered by urltestdata.json."
],
"protocol": [
{
@@ -103,7 +103,7 @@
}
},
{
- "comment": "Can’t switch from special scheme to non-special. Note: this may change, see https://github.com/whatwg/url/issues/104",
+ "comment": "Can’t switch from special scheme to non-special",
"href": "http://example.net",
"new_value": "b",
"expected": {
@@ -111,6 +111,22 @@
"protocol": "http:"
}
},
+ {
+ "href": "https://example.net",
+ "new_value": "s",
+ "expected": {
+ "href": "https://example.net/",
+ "protocol": "https:"
+ }
+ },
+ {
+ "href": "ftp://example.net",
+ "new_value": "test",
+ "expected": {
+ "href": "ftp://example.net/",
+ "protocol": "ftp:"
+ }
+ },
{
"comment": "Cannot-be-a-base URL doesn’t have a host, but URL in a special scheme must.",
"href": "mailto:me@example.net",
@@ -121,7 +137,7 @@
}
},
{
- "comment": "Can’t switch from non-special scheme to special. Note: this may change, see https://github.com/whatwg/url/issues/104",
+ "comment": "Can’t switch from non-special scheme to special",
"href": "ssh://me@example.net",
"new_value": "http",
"expected": {
@@ -129,6 +145,30 @@
"protocol": "ssh:"
}
},
+ {
+ "href": "ssh://me@example.net",
+ "new_value": "gopher",
+ "expected": {
+ "href": "ssh://me@example.net/",
+ "protocol": "ssh:"
+ }
+ },
+ {
+ "href": "ssh://me@example.net",
+ "new_value": "file",
+ "expected": {
+ "href": "ssh://me@example.net/",
+ "protocol": "ssh:"
+ }
+ },
+ {
+ "href": "nonsense:///test",
+ "new_value": "https",
+ "expected": {
+ "href": "nonsense:///test",
+ "protocol": "nonsense:"
+ }
+ },
{
"comment": "Stuff after the first ':' is ignored",
"href": "http://example.net",
diff --git a/test/fixtures/url-tests-additional.js b/test/fixtures/url-tests-additional.js
new file mode 100644
index 00000000000000..ffe47fb639dcba
--- /dev/null
+++ b/test/fixtures/url-tests-additional.js
@@ -0,0 +1,6 @@
+'use strict';
+
+// This file contains test cases not part of the WPT
+
+module.exports = [
+];
diff --git a/test/fixtures/url-tests.json b/test/fixtures/url-tests.js
similarity index 82%
rename from test/fixtures/url-tests.json
rename to test/fixtures/url-tests.js
index 634a8e3f663985..3b162391cd2ef5 100644
--- a/test/fixtures/url-tests.json
+++ b/test/fixtures/url-tests.js
@@ -1,7 +1,12 @@
+'use strict';
+
+/* WPT Refs:
+ https://github.com/w3c/web-platform-tests/blob/b207902/url/urltestdata.json
+ License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+module.exports =
[
"# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/segments.js",
- "License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html",
- "Source: https://github.com/w3c/web-platform-tests/tree/master/url",
{
"input": "http://example\t.\norg",
"base": "http://example.org/foo/bar",
@@ -167,6 +172,20 @@
"search": "?%20d%20",
"hash": "# e"
},
+ {
+ "input": "lolscheme:x x#x x",
+ "base": "about:blank",
+ "href": "lolscheme:x x#x x",
+ "protocol": "lolscheme:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "x x",
+ "search": "",
+ "hash": "#x x"
+ },
{
"input": "http://f:/c",
"base": "http://example.org/foo/bar",
@@ -552,21 +571,21 @@
"search": "",
"hash": ""
},
- {
- "input": "foo://",
- "base": "http://example.org/foo/bar",
- "href": "foo:///",
- "origin": "null",
- "protocol": "foo:",
- "username": "",
- "password": "",
- "host": "",
- "hostname": "",
- "port": "",
- "pathname": "/",
- "search": "",
- "hash": ""
- },
+ // {
+ // "input": "foo://",
+ // "base": "http://example.org/foo/bar",
+ // "href": "foo://",
+ // "origin": "null",
+ // "protocol": "foo:",
+ // "username": "",
+ // "password": "",
+ // "host": "",
+ // "hostname": "",
+ // "port": "",
+ // "pathname": "",
+ // "search": "",
+ // "hash": ""
+ // },
{
"input": "http://a:b@c:29/d",
"base": "http://example.org/foo/bar",
@@ -1021,6 +1040,26 @@
"search": "",
"hash": ""
},
+ // {
+ // "input": "file://example:1/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ // {
+ // "input": "file://example:test/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ {
+ "input": "file://example%/",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "file://[example]/",
+ "base": "about:blank",
+ "failure": true
+ },
{
"input": "ftps:/example.com/",
"base": "http://example.org/foo/bar",
@@ -2250,11 +2289,6 @@
"search": "",
"hash": "# %C2%BB"
},
- {
- "input": "http://[www.google.com]/",
- "base": "about:blank",
- "failure": true
- },
{
"input": "http://www.google.com",
"base": "about:blank",
@@ -3555,6 +3589,32 @@
"base": "http://other.com/",
"failure": true
},
+ // "U+FFFD",
+ // {
+ // "input": "https://\ufffd",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ // {
+ // "input": "https://%EF%BF%BD",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ {
+ "input": "https://x/\ufffd?\ufffd#\ufffd",
+ "base": "about:blank",
+ "href": "https://x/%EF%BF%BD?%EF%BF%BD#%EF%BF%BD",
+ "origin": "https://x",
+ "protocol": "https:",
+ "username": "",
+ "password": "",
+ "host": "x",
+ "hostname": "x",
+ "port": "",
+ "pathname": "/%EF%BF%BD",
+ "search": "?%EF%BF%BD",
+ "hash": "#%EF%BF%BD"
+ },
"Test name prepping, fullwidth input should be converted to ASCII and NOT IDN-ized. This is 'Go' in fullwidth UTF-8/UTF-16.",
{
"input": "http://Ｇｏ.com",
@@ -3662,18 +3722,23 @@
"base": "http://other.com/",
"failure": true
},
- "Invalid escaping should trigger the regular host error handling",
+ "Invalid escaping in hosts causes failure",
{
"input": "http://%3g%78%63%30%2e%30%32%35%30%2E.01",
"base": "http://other.com/",
"failure": true
},
- "Something that isn't exactly an IP should get treated as a host and spaces escaped",
+ "A space in a host causes failure",
{
"input": "http://192.168.0.1 hello",
"base": "http://other.com/",
"failure": true
},
+ {
+ "input": "https://x x:12",
+ "base": "about:blank",
+ "failure": true
+ },
"Fullwidth and escaped UTF-8 fullwidth should still be treated as IP",
{
"input": "http://０Ｘｃ０．０２５０．０１",
@@ -3691,11 +3756,36 @@
"hash": ""
},
"Broken IPv6",
+ {
+ "input": "http://[www.google.com]/",
+ "base": "about:blank",
+ "failure": true
+ },
{
"input": "http://[google.com]",
"base": "http://other.com/",
"failure": true
},
+ // {
+ // "input": "http://[::1.2.3.4x]",
+ // "base": "http://other.com/",
+ // "failure": true
+ // },
+ // {
+ // "input": "http://[::1.2.3.]",
+ // "base": "http://other.com/",
+ // "failure": true
+ // },
+ // {
+ // "input": "http://[::1.2.]",
+ // "base": "http://other.com/",
+ // "failure": true
+ // },
+ // {
+ // "input": "http://[::1.]",
+ // "base": "http://other.com/",
+ // "failure": true
+ // },
"Misc Unicode",
{
"input": "http://foo:💩@example.com/bar",
@@ -4238,22 +4328,111 @@
"search": "",
"hash": ""
},
- "# unknown schemes and non-ASCII domains",
+ // "# unknown schemes and their hosts",
+ // {
+ // "input": "sc://ñ.test/",
+ // "base": "about:blank",
+ // "href": "sc://%C3%B1.test/",
+ // "origin": "null",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%C3%B1.test",
+ // "hostname": "%C3%B1.test",
+ // "port": "",
+ // "pathname": "/",
+ // "search": "",
+ // "hash": ""
+ // },
+ // {
+ // "input": "sc://\u001F!\"$&'()*+,-.;<=>^_`{|}~/",
+ // "base": "about:blank",
+ // "href": "sc://%1F!\"$&'()*+,-.;<=>^_`{|}~/",
+ // "origin": "null",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%1F!\"$&'()*+,-.;<=>^_`{|}~",
+ // "hostname": "%1F!\"$&'()*+,-.;<=>^_`{|}~",
+ // "port": "",
+ // "pathname": "/",
+ // "search": "",
+ // "hash": ""
+ // },
+ {
+ "input": "sc://\u0000/",
+ "base": "about:blank",
+ "failure": true
+ },
{
- "input": "sc://ñ.test/",
+ "input": "sc:// /",
"base": "about:blank",
- "href": "sc://xn--ida.test/",
- "origin": "null",
- "protocol": "sc:",
- "username": "",
- "password": "",
- "host": "xn--ida.test",
- "hostname": "xn--ida.test",
- "port": "",
- "pathname": "/",
- "search": "",
- "hash": ""
+ "failure": true
},
+ // {
+ // "input": "sc://%/",
+ // "base": "about:blank",
+ // "href": "sc://%/",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%",
+ // "hostname": "%",
+ // "port": "",
+ // "pathname": "/",
+ // "search": "",
+ // "hash": ""
+ // },
+ // {
+ // "input": "sc://@/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ // {
+ // "input": "sc://te@s:t@/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ // {
+ // "input": "sc://:/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ // {
+ // "input": "sc://:12/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ {
+ "input": "sc://[/",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "sc://\\/",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "sc://]/",
+ "base": "about:blank",
+ "failure": true
+ },
+ // {
+ // "input": "x",
+ // "base": "sc://ñ",
+ // "href": "sc://%C3%B1/x",
+ // "origin": "null",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%C3%B1",
+ // "hostname": "%C3%B1",
+ // "port": "",
+ // "pathname": "/x",
+ // "search": "",
+ // "hash": ""
+ // },
"# unknown schemes and backslashes",
{
"input": "sc:\\../",
@@ -4286,6 +4465,88 @@
"search": "",
"hash": ""
},
+ "# unknown scheme with bogus percent-encoding",
+ {
+ "input": "wow:%NBD",
+ "base": "about:blank",
+ "href": "wow:%NBD",
+ "origin": "null",
+ "protocol": "wow:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "%NBD",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "wow:%1G",
+ "base": "about:blank",
+ "href": "wow:%1G",
+ "origin": "null",
+ "protocol": "wow:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "%1G",
+ "search": "",
+ "hash": ""
+ },
+ "# Hosts and percent-encoding",
+ // {
+ // "input": "ftp://example.com%80/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ // {
+ // "input": "ftp://example.com%A0/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ // {
+ // "input": "https://example.com%80/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ // {
+ // "input": "https://example.com%A0/",
+ // "base": "about:blank",
+ // "failure": true
+ // },
+ {
+ "input": "ftp://%e2%98%83",
+ "base": "about:blank",
+ "href": "ftp://xn--n3h/",
+ "origin": "ftp://☃",
+ "protocol": "ftp:",
+ "username": "",
+ "password": "",
+ "host": "xn--n3h",
+ "hostname": "xn--n3h",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "https://%e2%98%83",
+ "base": "about:blank",
+ "href": "https://xn--n3h/",
+ "origin": "https://☃",
+ "protocol": "https:",
+ "username": "",
+ "password": "",
+ "host": "xn--n3h",
+ "hostname": "xn--n3h",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
"# tests from jsdom/whatwg-url designed for code coverage",
{
"input": "http://127.0.0.1:10100/relative_import.html",
@@ -4378,7 +4639,7 @@
"port": "",
"pathname": "/foo/bar",
"search": "??a=b&c=d",
- "searchParams": "%3Fa=b&c=d",
+ // "searchParams": "%3Fa=b&c=d",
"hash": ""
},
"# Scheme only",
@@ -4433,7 +4694,7 @@
"port": "",
"pathname": "/baz",
"search": "?qux",
- "searchParams": "",
+ "searchParams": "qux=",
"hash": "#foo%08bar"
},
"# IPv4 parsing (via https://github.com/nodejs/node/pull/10317)",
@@ -4607,6 +4868,50 @@
"search": "",
"hash": ""
},
+ {
+ "input": "https://0x.0x.0",
+ "base": "about:blank",
+ "href": "https://0.0.0.0/",
+ "origin": "https://0.0.0.0",
+ "protocol": "https:",
+ "username": "",
+ "password": "",
+ "host": "0.0.0.0",
+ "hostname": "0.0.0.0",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ "# file URLs containing percent-encoded Windows drive letters (shouldn't work)",
+ {
+ "input": "file:///C%3A/",
+ "base": "about:blank",
+ "href": "file:///C%3A/",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/C%3A/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "file:///C%7C/",
+ "base": "about:blank",
+ "href": "file:///C%7C/",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/C%7C/",
+ "search": "",
+ "hash": ""
+ },
"# file URLs relative to other file URLs (via https://github.com/jsdom/whatwg-url/pull/60)",
{
"input": "pix/submit.gif",
@@ -4649,5 +4954,673 @@
"pathname": "/",
"search": "",
"hash": ""
+ },
+ "# More file URL tests by zcorpan and annevk",
+ {
+ "input": "/",
+ "base": "file:///C:/a/b",
+ "href": "file:///C:/",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/C:/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "//d:",
+ "base": "file:///C:/a/b",
+ "href": "file:///d:",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/d:",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "//d:/..",
+ "base": "file:///C:/a/b",
+ "href": "file:///d:/",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/d:/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "..",
+ "base": "file:///ab:/",
+ "href": "file:///",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "..",
+ "base": "file:///1:/",
+ "href": "file:///",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "",
+ "base": "file:///test?test#test",
+ "href": "file:///test?test",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/test",
+ "search": "?test",
+ "hash": ""
+ },
+ {
+ "input": "file:",
+ "base": "file:///test?test#test",
+ "href": "file:///test?test",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/test",
+ "search": "?test",
+ "hash": ""
+ },
+ {
+ "input": "?x",
+ "base": "file:///test?test#test",
+ "href": "file:///test?x",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/test",
+ "search": "?x",
+ "hash": ""
+ },
+ {
+ "input": "file:?x",
+ "base": "file:///test?test#test",
+ "href": "file:///test?x",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/test",
+ "search": "?x",
+ "hash": ""
+ },
+ {
+ "input": "#x",
+ "base": "file:///test?test#test",
+ "href": "file:///test?test#x",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/test",
+ "search": "?test",
+ "hash": "#x"
+ },
+ {
+ "input": "file:#x",
+ "base": "file:///test?test#test",
+ "href": "file:///test?test#x",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/test",
+ "search": "?test",
+ "hash": "#x"
+ },
+ "# file URLs without base URL by Rimas Misevičius",
+ {
+ "input": "file:",
+ "base": "about:blank",
+ "href": "file:///",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "file:?q=v",
+ "base": "about:blank",
+ "href": "file:///?q=v",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/",
+ "search": "?q=v",
+ "hash": ""
+ },
+ {
+ "input": "file:#frag",
+ "base": "about:blank",
+ "href": "file:///#frag",
+ "protocol": "file:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": "#frag"
+ },
+ "# IPv6 tests",
+ {
+ "input": "http://[1:0::]",
+ "base": "http://example.net/",
+ "href": "http://[1::]/",
+ "origin": "http://[1::]",
+ "protocol": "http:",
+ "username": "",
+ "password": "",
+ "host": "[1::]",
+ "hostname": "[1::]",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "http://[0:1:2:3:4:5:6:7:8]",
+ "base": "http://example.net/",
+ "failure": true
+ },
+ {
+ "input": "https://[0::0::0]",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "https://[0:.0]",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "https://[0:0:]",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "https://[0:1:2:3:4:5:6:7.0.0.0.1]",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "https://[0:1.00.0.0.0]",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "https://[0:1.290.0.0.0]",
+ "base": "about:blank",
+ "failure": true
+ },
+ {
+ "input": "https://[0:1.23.23]",
+ "base": "about:blank",
+ "failure": true
+ },
+ "# Empty host",
+ {
+ "input": "http://?",
+ "base": "about:blank",
+ "failure": "true"
+ },
+ {
+ "input": "http://#",
+ "base": "about:blank",
+ "failure": "true"
+ },
+ "# Non-special-URL path tests",
+ // {
+ // "input": "sc://ñ",
+ // "base": "about:blank",
+ // "href": "sc://%C3%B1",
+ // "origin": "null",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%C3%B1",
+ // "hostname": "%C3%B1",
+ // "port": "",
+ // "pathname": "",
+ // "search": "",
+ // "hash": ""
+ // },
+ // {
+ // "input": "sc://ñ?x",
+ // "base": "about:blank",
+ // "href": "sc://%C3%B1?x",
+ // "origin": "null",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%C3%B1",
+ // "hostname": "%C3%B1",
+ // "port": "",
+ // "pathname": "",
+ // "search": "?x",
+ // "hash": ""
+ // },
+ // {
+ // "input": "sc://ñ#x",
+ // "base": "about:blank",
+ // "href": "sc://%C3%B1#x",
+ // "origin": "null",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%C3%B1",
+ // "hostname": "%C3%B1",
+ // "port": "",
+ // "pathname": "",
+ // "search": "",
+ // "hash": "#x"
+ // },
+ // {
+ // "input": "#x",
+ // "base": "sc://ñ",
+ // "href": "sc://%C3%B1#x",
+ // "origin": "null",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%C3%B1",
+ // "hostname": "%C3%B1",
+ // "port": "",
+ // "pathname": "",
+ // "search": "",
+ // "hash": "#x"
+ // },
+ // {
+ // "input": "?x",
+ // "base": "sc://ñ",
+ // "href": "sc://%C3%B1?x",
+ // "origin": "null",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "%C3%B1",
+ // "hostname": "%C3%B1",
+ // "port": "",
+ // "pathname": "",
+ // "search": "?x",
+ // "hash": ""
+ // },
+ // {
+ // "input": "sc://?",
+ // "base": "about:blank",
+ // "href": "sc://?",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "",
+ // "hostname": "",
+ // "port": "",
+ // "pathname": "",
+ // "search": "",
+ // "hash": ""
+ // },
+ // {
+ // "input": "sc://#",
+ // "base": "about:blank",
+ // "href": "sc://#",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "",
+ // "hostname": "",
+ // "port": "",
+ // "pathname": "",
+ // "search": "",
+ // "hash": ""
+ // },
+ {
+ "input": "///",
+ "base": "sc://x/",
+ "href": "sc:///",
+ "protocol": "sc:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ // {
+ // "input": "////",
+ // "base": "sc://x/",
+ // "href": "sc:////",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "",
+ // "hostname": "",
+ // "port": "",
+ // "pathname": "//",
+ // "search": "",
+ // "hash": ""
+ // },
+ // {
+ // "input": "////x/",
+ // "base": "sc://x/",
+ // "href": "sc:////x/",
+ // "protocol": "sc:",
+ // "username": "",
+ // "password": "",
+ // "host": "",
+ // "hostname": "",
+ // "port": "",
+ // "pathname": "//x/",
+ // "search": "",
+ // "hash": ""
+ // },
+ {
+ "input": "tftp://foobar.com/someconfig;mode=netascii",
+ "base": "about:blank",
+ "href": "tftp://foobar.com/someconfig;mode=netascii",
+ "origin": "null",
+ "protocol": "tftp:",
+ "username": "",
+ "password": "",
+ "host": "foobar.com",
+ "hostname": "foobar.com",
+ "port": "",
+ "pathname": "/someconfig;mode=netascii",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "telnet://user:pass@foobar.com:23/",
+ "base": "about:blank",
+ "href": "telnet://user:pass@foobar.com:23/",
+ "origin": "null",
+ "protocol": "telnet:",
+ "username": "user",
+ "password": "pass",
+ "host": "foobar.com:23",
+ "hostname": "foobar.com",
+ "port": "23",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "ut2004://10.10.10.10:7777/Index.ut2",
+ "base": "about:blank",
+ "href": "ut2004://10.10.10.10:7777/Index.ut2",
+ "origin": "null",
+ "protocol": "ut2004:",
+ "username": "",
+ "password": "",
+ "host": "10.10.10.10:7777",
+ "hostname": "10.10.10.10",
+ "port": "7777",
+ "pathname": "/Index.ut2",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "redis://foo:bar@somehost:6379/0?baz=bam&qux=baz",
+ "base": "about:blank",
+ "href": "redis://foo:bar@somehost:6379/0?baz=bam&qux=baz",
+ "origin": "null",
+ "protocol": "redis:",
+ "username": "foo",
+ "password": "bar",
+ "host": "somehost:6379",
+ "hostname": "somehost",
+ "port": "6379",
+ "pathname": "/0",
+ "search": "?baz=bam&qux=baz",
+ "hash": ""
+ },
+ {
+ "input": "rsync://foo@host:911/sup",
+ "base": "about:blank",
+ "href": "rsync://foo@host:911/sup",
+ "origin": "null",
+ "protocol": "rsync:",
+ "username": "foo",
+ "password": "",
+ "host": "host:911",
+ "hostname": "host",
+ "port": "911",
+ "pathname": "/sup",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "git://github.com/foo/bar.git",
+ "base": "about:blank",
+ "href": "git://github.com/foo/bar.git",
+ "origin": "null",
+ "protocol": "git:",
+ "username": "",
+ "password": "",
+ "host": "github.com",
+ "hostname": "github.com",
+ "port": "",
+ "pathname": "/foo/bar.git",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "irc://myserver.com:6999/channel?passwd",
+ "base": "about:blank",
+ "href": "irc://myserver.com:6999/channel?passwd",
+ "origin": "null",
+ "protocol": "irc:",
+ "username": "",
+ "password": "",
+ "host": "myserver.com:6999",
+ "hostname": "myserver.com",
+ "port": "6999",
+ "pathname": "/channel",
+ "search": "?passwd",
+ "hash": ""
+ },
+ {
+ "input": "dns://fw.example.org:9999/foo.bar.org?type=TXT",
+ "base": "about:blank",
+ "href": "dns://fw.example.org:9999/foo.bar.org?type=TXT",
+ "origin": "null",
+ "protocol": "dns:",
+ "username": "",
+ "password": "",
+ "host": "fw.example.org:9999",
+ "hostname": "fw.example.org",
+ "port": "9999",
+ "pathname": "/foo.bar.org",
+ "search": "?type=TXT",
+ "hash": ""
+ },
+ {
+ "input": "ldap://localhost:389/ou=People,o=JNDITutorial",
+ "base": "about:blank",
+ "href": "ldap://localhost:389/ou=People,o=JNDITutorial",
+ "origin": "null",
+ "protocol": "ldap:",
+ "username": "",
+ "password": "",
+ "host": "localhost:389",
+ "hostname": "localhost",
+ "port": "389",
+ "pathname": "/ou=People,o=JNDITutorial",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "git+https://github.com/foo/bar",
+ "base": "about:blank",
+ "href": "git+https://github.com/foo/bar",
+ "origin": "null",
+ "protocol": "git+https:",
+ "username": "",
+ "password": "",
+ "host": "github.com",
+ "hostname": "github.com",
+ "port": "",
+ "pathname": "/foo/bar",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "urn:ietf:rfc:2648",
+ "base": "about:blank",
+ "href": "urn:ietf:rfc:2648",
+ "origin": "null",
+ "protocol": "urn:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "ietf:rfc:2648",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "tag:joe@example.org,2001:foo/bar",
+ "base": "about:blank",
+ "href": "tag:joe@example.org,2001:foo/bar",
+ "origin": "null",
+ "protocol": "tag:",
+ "username": "",
+ "password": "",
+ "host": "",
+ "hostname": "",
+ "port": "",
+ "pathname": "joe@example.org,2001:foo/bar",
+ "search": "",
+ "hash": ""
+ },
+ "# percent encoded hosts in non-special-URLs",
+ // {
+ // "input": "non-special://%E2%80%A0/",
+ // "base": "about:blank",
+ // "href": "non-special://%E2%80%A0/",
+ // "protocol": "non-special:",
+ // "username": "",
+ // "password": "",
+ // "host": "%E2%80%A0",
+ // "hostname": "%E2%80%A0",
+ // "port": "",
+ // "pathname": "/",
+ // "search": "",
+ // "hash": ""
+ // },
+ // {
+ // "input": "non-special://H%4fSt/path",
+ // "base": "about:blank",
+ // "href": "non-special://H%4fSt/path",
+ // "protocol": "non-special:",
+ // "username": "",
+ // "password": "",
+ // "host": "H%4fSt",
+ // "hostname": "H%4fSt",
+ // "port": "",
+ // "pathname": "/path",
+ // "search": "",
+ // "hash": ""
+ // },
+ "# IPv6 in non-special-URLs",
+ {
+ "input": "non-special://[1:2:0:0:5:0:0:0]/",
+ "base": "about:blank",
+ "href": "non-special://[1:2:0:0:5::]/",
+ "protocol": "non-special:",
+ "username": "",
+ "password": "",
+ "host": "[1:2:0:0:5::]",
+ "hostname": "[1:2:0:0:5::]",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "non-special://[1:2:0:0:0:0:0:3]/",
+ "base": "about:blank",
+ "href": "non-special://[1:2::3]/",
+ "protocol": "non-special:",
+ "username": "",
+ "password": "",
+ "host": "[1:2::3]",
+ "hostname": "[1:2::3]",
+ "port": "",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "non-special://[1:2::3]:80/",
+ "base": "about:blank",
+ "href": "non-special://[1:2::3]:80/",
+ "protocol": "non-special:",
+ "username": "",
+ "password": "",
+ "host": "[1:2::3]:80",
+ "hostname": "[1:2::3]",
+ "port": "80",
+ "pathname": "/",
+ "search": "",
+ "hash": ""
+ },
+ {
+ "input": "non-special://[:80/",
+ "base": "about:blank",
+ "failure": true
}
]
diff --git a/test/internet/test-dgram-multicast-multi-process.js b/test/internet/test-dgram-multicast-multi-process.js
index 46f47a5982977e..793d22bd4c137e 100644
--- a/test/internet/test-dgram-multicast-multi-process.js
+++ b/test/internet/test-dgram-multicast-multi-process.js
@@ -22,14 +22,14 @@ if (common.inFreeBSDJail) {
return;
}
-function launchChildProcess(index) {
+function launchChildProcess() {
const worker = fork(__filename, ['child']);
workers[worker.pid] = worker;
worker.messagesReceived = [];
// Handle the death of workers.
- worker.on('exit', function(code, signal) {
+ worker.on('exit', function(code) {
// Don't consider this the true death if the worker has finished
// successfully or if the exit code is 0.
if (worker.isDone || code === 0) {
@@ -189,7 +189,7 @@ if (process.argv[2] === 'child') {
process.send({ message: buf.toString() });
- if (receivedMessages.length == messages.length) {
+ if (receivedMessages.length === messages.length) {
// .dropMembership() not strictly needed but here as a sanity check.
listenSocket.dropMembership(LOCAL_BROADCAST_HOST);
process.nextTick(function() {
diff --git a/test/known_issues/test-url-parse-conformance.js b/test/known_issues/test-url-parse-conformance.js
index f7fcec821c8e50..62c36da87e6678 100644
--- a/test/known_issues/test-url-parse-conformance.js
+++ b/test/known_issues/test-url-parse-conformance.js
@@ -7,7 +7,7 @@ const url = require('url');
const assert = require('assert');
const path = require('path');
-const tests = require(path.join(common.fixturesDir, 'url-tests.json'));
+const tests = require(path.join(common.fixturesDir, 'url-tests'));
let failed = 0;
let attempted = 0;
diff --git a/test/message/eval_messages.out b/test/message/eval_messages.out
index 44965be374bac5..ba0c35431c6907 100644
--- a/test/message/eval_messages.out
+++ b/test/message/eval_messages.out
@@ -3,7 +3,8 @@
with(this){__filename}
^^^^
SyntaxError: Strict mode code may not include a with statement
- at Object.exports.runInThisContext (vm.js:*)
+ at createScript (vm.js:*)
+ at Object.runInThisContext (vm.js:*)
at Object. ([eval]-wrapper:*:*)
at Module._compile (module.js:*:*)
at Immediate. (bootstrap_node.js:*:*)
@@ -15,10 +16,11 @@ SyntaxError: Strict mode code may not include a with statement
[eval]:1
throw new Error("hello")
^
+
Error: hello
at [eval]:1:7
at ContextifyScript.Script.runInThisContext (vm.js:*)
- at Object.exports.runInThisContext (vm.js:*)
+ at Object.runInThisContext (vm.js:*)
at Object. ([eval]-wrapper:*:*)
at Module._compile (module.js:*:*)
at Immediate. (bootstrap_node.js:*:*)
@@ -28,10 +30,11 @@ Error: hello
[eval]:1
throw new Error("hello")
^
+
Error: hello
at [eval]:1:7
at ContextifyScript.Script.runInThisContext (vm.js:*)
- at Object.exports.runInThisContext (vm.js:*)
+ at Object.runInThisContext (vm.js:*)
at Object. ([eval]-wrapper:*:*)
at Module._compile (module.js:*:*)
at Immediate. (bootstrap_node.js:*:*)
@@ -42,20 +45,23 @@ Error: hello
[eval]:1
var x = 100; y = x;
^
+
ReferenceError: y is not defined
at [eval]:1:16
at ContextifyScript.Script.runInThisContext (vm.js:*)
- at Object.exports.runInThisContext (vm.js:*)
+ at Object.runInThisContext (vm.js:*)
at Object. ([eval]-wrapper:*:*)
at Module._compile (module.js:*:*)
at Immediate. (bootstrap_node.js:*:*)
at runCallback (timers.js:*:*)
at tryOnImmediate (timers.js:*:*)
at processImmediate [as _immediateCallback] (timers.js:*:*)
+
[eval]:1
var ______________________________________________; throw 10
^
10
+
[eval]:1
var ______________________________________________; throw 10
^
diff --git a/test/message/stdin_messages.out b/test/message/stdin_messages.out
index 828bee92cb6f7f..b4c51d7ad567f0 100644
--- a/test/message/stdin_messages.out
+++ b/test/message/stdin_messages.out
@@ -1,10 +1,10 @@
[stdin]
-
[stdin]:1
with(this){__filename}
^^^^
SyntaxError: Strict mode code may not include a with statement
- at Object.exports.runInThisContext (vm.js:*)
+ at createScript (vm.js:*)
+ at Object.runInThisContext (vm.js:*)
at Object. ([stdin]-wrapper:*:*)
at Module._compile (module.js:*:*)
at Immediate. (bootstrap_node.js:*:*)
@@ -13,28 +13,28 @@ SyntaxError: Strict mode code may not include a with statement
at processImmediate [as _immediateCallback] (timers.js:*:*)
42
42
-
[stdin]:1
throw new Error("hello")
^
+
Error: hello
- at [stdin]:1:*
+ at [stdin]:1:7
at ContextifyScript.Script.runInThisContext (vm.js:*)
- at Object.exports.runInThisContext (vm.js:*)
+ at Object.runInThisContext (vm.js:*)
at Object. ([stdin]-wrapper:*:*)
at Module._compile (module.js:*:*)
at Immediate.