Merge nodejs/master to xplat

Merge '6f216710eb' as of 2017-05-19 into xplat

doc/api/buffer.md

@@ -1340,6 +1340,10 @@ console.log(b.indexOf('b', null));
 console.log(b.indexOf('b', []));
 ```
 
+If `value` is an empty string or empty `Buffer` and `byteOffset` is less
+than `buf.length`, `byteOffset` will be returned. If `value` is empty and
+`byteOffset` is at least `buf.length`, `buf.length` will be returned.
+
 ### buf.keys()
 <!-- YAML
 added: v1.1.0
@@ -1450,6 +1454,8 @@ console.log(b.lastIndexOf('b', null));
 console.log(b.lastIndexOf('b', []));
 ```
 
+If `value` is an empty string or empty `Buffer`, `byteOffset` will be returned.
+
 ### buf.length
 <!-- YAML
 added: v0.1.90

doc/api/crypto.md

@@ -1637,7 +1637,7 @@ treated as the key with no passphrase and will use `RSA_PKCS1_PADDING`.
 <!-- YAML
 added: v1.1.0
 -->
-- `private_key` {Object | string}
+- `public_key` {Object | string}
   - `key` {string} A PEM encoded private key.
   - `passphrase` {string} An optional passphrase for the private key.
   - `padding` {crypto.constants} An optional padding value defined in
@@ -1657,15 +1657,16 @@ be passed instead of a public key.
 <!-- YAML
 added: v0.11.14
 -->
-- `private_key` {Object | string}
+- `public_key` {Object | string}
   - `key` {string} A PEM encoded private key.
   - `passphrase` {string} An optional passphrase for the private key.
   - `padding` {crypto.constants} An optional padding value defined in
     `crypto.constants`, which may be: `crypto.constants.RSA_NO_PADDING`,
     `RSA_PKCS1_PADDING`, or `crypto.constants.RSA_PKCS1_OAEP_PADDING`.
 - `buffer` {Buffer | TypedArray | DataView}
 
-Encrypts `buffer` with `public_key`.
+Encrypts the content of `buffer` with `public_key` and returns a new
+[`Buffer`][] with encrypted content.
 
 `public_key` can be an object or a string. If `public_key` is a string, it is
 treated as the key with no passphrase and will use `RSA_PKCS1_OAEP_PADDING`.

doc/api/stream.md

@@ -920,24 +920,21 @@ added: v0.9.4
 * `encoding` {string} The encoding to use.
 * Returns: `this`
 
-The `readable.setEncoding()` method sets the default character encoding for
+The `readable.setEncoding()` method sets the character encoding for
 data read from the Readable stream.
 
-Setting an encoding causes the stream data
-to be returned as string of the specified encoding rather than as `Buffer`
+By default, no encoding is assigned and stream data will be returned as
+`Buffer` objects. Setting an encoding causes the stream data
+to be returned as strings of the specified encoding rather than as `Buffer`
 objects. For instance, calling `readable.setEncoding('utf8')` will cause the
-output data will be interpreted as UTF-8 data, and passed as strings. Calling
+output data to be interpreted as UTF-8 data, and passed as strings. Calling
 `readable.setEncoding('hex')` will cause the data to be encoded in hexadecimal
 string format.
 
 The Readable stream will properly handle multi-byte characters delivered through
 the stream that would otherwise become improperly decoded if simply pulled from
 the stream as `Buffer` objects.
 
-Encoding can be disabled by calling `readable.setEncoding(null)`. This approach
-is useful when working with binary data or with large multi-byte strings spread
-out over multiple chunks.
-
 ```js
 const readable = getReadableStreamSomehow();
 readable.setEncoding('utf8');

doc/guides/writing-and-running-benchmarks.md

@@ -27,24 +27,24 @@ either [`wrk`][wrk] or [`autocannon`][autocannon].
 
 `Autocannon` is a Node.js script that can be installed using
 `npm install -g autocannon`. It will use the Node.js executable that is in the
-path. Hence if you want to compare two HTTP benchmark runs, make sure that the
+path. In order to compare two HTTP benchmark runs, make sure that the
 Node.js version in the path is not altered.
 
-`wrk` may be available through your preferred package manager. If not, you can
-easily build it [from source][wrk] via `make`.
+`wrk` may be available through one of the available package managers. If not, it can
+be easily built [from source][wrk] via `make`.
 
 By default, `wrk` will be used as the benchmarker. If it is not available,
-`autocannon` will be used in its place. When creating an HTTP benchmark, you can
-specify which benchmarker should be used by providing it as an argument:
+`autocannon` will be used in its place. When creating an HTTP benchmark, the
+benchmarker to be used should be specified by providing it as an argument:
 
 `node benchmark/run.js --set benchmarker=autocannon http`
 
 `node benchmark/http/simple.js benchmarker=autocannon`
 
 ### Benchmark Analysis Requirements
 
-To analyze the results, `R` should be installed. Use your package manager or
-download it from https://www.r-project.org/.
+To analyze the results, `R` should be installed. Use one of the available
+package managers or download it from https://www.r-project.org/.
 
 The R packages `ggplot2` and `plyr` are also used and can be installed using
 the R REPL.
@@ -55,8 +55,8 @@ install.packages("ggplot2")
 install.packages("plyr")
 ```
 
-In the event you get a message that you need to select a CRAN mirror first, you
-can specify a mirror by adding in the repo parameter.
+In the event that a message is reported stating that a CRAN mirror must be
+selected first, specify a mirror by adding in the repo parameter.
 
 If we used the "http://cran.us.r-project.org" mirror, it could look something
 like this:
@@ -65,7 +65,7 @@ like this:
 install.packages("ggplot2", repo="http://cran.us.r-project.org")
 ```
 
-Of course, use the mirror that suits your location.
+Of course, use an appropriate mirror based on location.
 A list of mirrors is [located here](https://cran.r-project.org/mirrors.html).
 
 ## Running benchmarks
@@ -98,7 +98,7 @@ process. This ensures that benchmark results aren't affected by the execution
 order due to v8 optimizations. **The last number is the rate of operations
 measured in ops/sec (higher is better).**
 
-Furthermore you can specify a subset of the configurations, by setting them in
+Furthermore a subset of the configurations can be specified, by setting them in
 the process arguments:
 
 ```console
@@ -179,9 +179,9 @@ In the output, _improvement_ is the relative improvement of the new version,
 hopefully this is positive. _confidence_ tells if there is enough
 statistical evidence to validate the _improvement_. If there is enough evidence
 then there will be at least one star (`*`), more stars is just better. **However
-if there are no stars, then you shouldn't make any conclusions based on the
-_improvement_.** Sometimes this is fine, for example if you are expecting there
-to be no improvements, then there shouldn't be any stars.
+if there are no stars, then don't make any conclusions based on the
+_improvement_.** Sometimes this is fine, for example if no improvements are
+expected, then there shouldn't be any stars.
 
 **A word of caution:** Statistics is not a foolproof tool. If a benchmark shows
 a statistical significant difference, there is a 5% risk that this
@@ -198,9 +198,9 @@ same for both versions. The confidence field will show a star if the p-value
 is less than `0.05`._
 
 The `compare.R` tool can also produce a box plot by using the `--plot filename`
-option. In this case there are 48 different benchmark combinations, thus you
-may want to filter the csv file. This can be done while benchmarking using the
-`--set` parameter (e.g. `--set encoding=ascii`) or by filtering results
+option. In this case there are 48 different benchmark combinations, and there
+may be a need to filter the csv file. This can be done while benchmarking
+using the `--set` parameter (e.g. `--set encoding=ascii`) or by filtering results
 afterwards using tools such as `sed` or `grep`. In the `sed` case be sure to
 keep the first line since that contains the header information.
 
@@ -295,7 +295,7 @@ chunk     encoding       mean confidence.interval
 ### Basics of a benchmark
 
 All benchmarks use the `require('../common.js')` module. This contains the
-`createBenchmark(main, configs[, options])` method which will setup your
+`createBenchmark(main, configs[, options])` method which will setup the
 benchmark.
 
 The arguments of `createBenchmark` are:
@@ -312,20 +312,20 @@ The arguments of `createBenchmark` are:
 `createBenchmark` returns a `bench` object, which is used for timing
 the runtime of the benchmark. Run `bench.start()` after the initialization
 and `bench.end(n)` when the benchmark is done. `n` is the number of operations
-you performed in the benchmark.
+performed in the benchmark.
 
 The benchmark script will be run twice:
 
 The first pass will configure the benchmark with the combination of
 parameters specified in `configs`, and WILL NOT run the `main` function.
 In this pass, no flags except the ones directly passed via commands
-that you run the benchmarks with will be used.
+when running the benchmarks will be used.
 
 In the second pass, the `main` function will be run, and the process
 will be launched with:
 
-* The flags you've passed into `createBenchmark` (the third argument)
-* The flags in the command that you run this benchmark with
+* The flags passed into `createBenchmark` (the third argument)
+* The flags in the command passed when the benchmark was run
 
 Beware that any code outside the `main` function will be run twice
 in different processes. This could be troublesome if the code
@@ -346,7 +346,7 @@ const configs = {
 };
 
 const options = {
-  // Add --expose-internals if you want to require internal modules in main
+  // Add --expose-internals in order to require internal modules in main
   flags: ['--zero-fill-buffers']
 };
 
@@ -357,9 +357,9 @@ const bench = common.createBenchmark(main, configs, options);
 // in different processes, with different command line arguments.
 
 function main(conf) {
-  // You will only get the flags that you have passed to createBenchmark
-  // earlier when main is run. If you want to benchmark the internal modules,
-  // require them here. For example:
+  // Only flags that have been passed to createBenchmark
+  // earlier when main is run will be in effect.
+  // In order to benchmark the internal modules, require them here. For example:
   // const URL = require('internal/url').URL
 
   // Start the timer

lib/buffer.js

@@ -698,7 +698,7 @@ function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
   // If the offset is undefined, "foo", {}, coerces to NaN, search whole buffer.
   // `x !== x`-style conditionals are a faster form of `isNaN(x)`
   if (byteOffset !== byteOffset) {
-    byteOffset = dir ? 0 : (buffer.length - 1);
+    byteOffset = dir ? 0 : buffer.length;
   }
   dir = !!dir;  // Cast to bool.
 

lib/internal/net.js

@@ -10,5 +10,6 @@ function isLegalPort(port) {
 }
 
 module.exports = {
-  isLegalPort
+  isLegalPort,
+  normalizedArgsSymbol: Symbol('normalizedArgs')
 };

lib/net.js

@@ -49,6 +49,7 @@ var dns;
 const errnoException = util._errnoException;
 const exceptionWithHostPort = util._exceptionWithHostPort;
 const isLegalPort = internalNet.isLegalPort;
+const normalizedArgsSymbol = internalNet.normalizedArgsSymbol;
 
 function noop() {}
 
@@ -118,8 +119,12 @@ function connect() {
 // For Server.prototype.listen(), the [...] part is [, backlog]
 // but will not be handled here (handled in listen())
 function normalizeArgs(args) {
+  var arr;
+
   if (args.length === 0) {
-    return [{}, null];
+    arr = [{}, null];
+    arr[normalizedArgsSymbol] = true;
+    return arr;
   }
 
   const arg0 = args[0];
@@ -140,9 +145,12 @@ function normalizeArgs(args) {
 
   var cb = args[args.length - 1];
   if (typeof cb !== 'function')
-    return [options, null];
+    arr = [options, null];
   else
-    return [options, cb];
+    arr = [options, cb];
+
+  arr[normalizedArgsSymbol] = true;
+  return arr;
 }
 
 
@@ -947,7 +955,7 @@ Socket.prototype.connect = function() {
   // already been normalized (so we don't normalize more than once). This has
   // been solved before in https://github.com/nodejs/node/pull/12342, but was
   // reverted as it had unintended side effects.
-  if (arguments.length === 1 && Array.isArray(arguments[0])) {
+  if (Array.isArray(arguments[0]) && arguments[0][normalizedArgsSymbol]) {
     normalized = arguments[0];
   } else {
     var args = new Array(arguments.length);