src: use consistent names for JSStream

Its confusing to call a js class with a handle a "Wrap", usually it's
the C++ handle that is called a Wrap (tcp_wrap, tls_wrap, ...). Its
derived from Socket, and makes a JS stream look like a Socket, so call
it that. Also, remove use of lib/_stream_wrap.js so it can be deprecated
some time.
PR-URL: #25153
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>

Author: sam-github

lib/_stream_wrap.js

@@ -1,3 +1,3 @@
 'use strict';
 
-module.exports=require('internal/wrap_js_stream');
+module.exports=require('internal/js_stream_socket');

lib/_tls_wrap.js

@@ -29,7 +29,7 @@ const net = require('net');
 consttls=require('tls');
 constutil=require('util');
 constcommon=require('_tls_common');
-const{ StreamWrap }=require('_stream_wrap');
+constJSStreamSocket=require('internal/js_stream_socket');
 const{ Buffer }=require('buffer');
 constdebug=util.debuglog('tls');
 const{TCP,constants: TCPConstants}=internalBinding('tcp_wrap');
@@ -308,12 +308,14 @@ function TLSSocket(socket, opts) {
 this.authorizationError=null;
 this[kRes]=null;
 
-// Wrap plain JS Stream into StreamWrap
 varwrap;
 if((socketinstanceofnet.Socket&&socket._handle)||!socket){
 wrap=socket;
 }else{
-wrap=newStreamWrap(socket);
+// TLS expects to interact from C++ with a net.Socket that has a C++ stream
+// handle, but a JS stream doesn't have one. Wrap it up to make it look like
+// a socket.
+wrap=newJSStreamSocket(socket);
 wrap.once('close',()=>this.destroy());
 }
 

lib/internal/http2/core.js

@@ -22,7 +22,7 @@ const util = require('util');
 
 const{ kIncomingMessage }=require('_http_common');
 const{ kServerResponse }=require('_http_server');
-const{ StreamWrap }=require('_stream_wrap');
+constJSStreamSocket=require('internal/js_stream_socket');
 
 const{
  defaultTriggerAsyncIdScope,
@@ -935,7 +935,7 @@ class Http2Session extends EventEmitter {
 super();
 
 if(!socket._handle||!socket._handle._externalStream){
-socket=newStreamWrap(socket);
+socket=newJSStreamSocket(socket);
 }
 
 // No validation is performed on the input parameters because this

lib/internal/wrap_js_stream.js lib/internal/js_stream_socket.jslib/internal/wrap_js_stream.js renamed to lib/internal/js_stream_socket.js

@@ -5,7 +5,7 @@ const util = require('util');
 const{ Socket }=require('net');
 const{ JSStream }=internalBinding('js_stream');
 constuv=internalBinding('uv');
-constdebug=util.debuglog('stream_wrap');
+constdebug=util.debuglog('stream_socket');
 const{ owner_symbol }=require('internal/async_hooks').symbols;
 const{ERR_STREAM_WRAP}=require('internal/errors').codes;
 
@@ -29,17 +29,17 @@ function onwrite(req, bufs) { return this[owner_symbol].doWrite(req, bufs); }
  * can skip going through the JS layer and let TLS access the raw C++ handle
  * of a net.Socket. The flipside of this is that, to maintain composability,
  * we need a way to create "fake" net.Socket instances that call back into a
- * "real" JavaScript stream. JSStreamWrap is exactly this.
+ * "real" JavaScript stream. JSStreamSocket is exactly this.
  */
-classJSStreamWrapextendsSocket{
+classJSStreamSocketextendsSocket{
 constructor(stream){
 consthandle=newJSStream();
 handle.close=(cb)=>{
 debug('close');
 this.doClose(cb);
 };
 // Inside of the following functions, `this` refers to the handle
-// and `this[owner_symbol]` refers to this JSStreamWrap instance.
+// and `this[owner_symbol]` refers to this JSStreamSocket instance.
 handle.isClosing=isClosing;
 handle.onreadstart=onreadstart;
 handle.onreadstop=onreadstop;
@@ -88,9 +88,10 @@ class JSStreamWrap extends Socket {
 this.read(0);
 }
 
-// Legacy
+// Allow legacy requires in the test suite to keep working:
+// const { StreamWrap } = require('internal/js_stream_socket')
 staticgetStreamWrap(){
-returnJSStreamWrap;
+returnJSStreamSocket;
 }
 
 isClosing(){
@@ -223,4 +224,4 @@ class JSStreamWrap extends Socket {
 }
 }
 
-module.exports=JSStreamWrap;
+module.exports=JSStreamSocket;

node.gyp

@@ -124,6 +124,7 @@
 'lib/internal/fs/watchers.js',
 'lib/internal/http.js',
 'lib/internal/inspector_async_hook.js',
+'lib/internal/js_stream_socket.js',
 'lib/internal/linkedlist.js',
 'lib/internal/modules/cjs/helpers.js',
 'lib/internal/modules/cjs/loader.js',
@@ -186,7 +187,6 @@
 'lib/internal/streams/state.js',
 'lib/internal/streams/pipeline.js',
 'lib/internal/streams/end-of-stream.js',
-'lib/internal/wrap_js_stream.js',
 'deps/v8/tools/splaytree.js',
 'deps/v8/tools/codemap.js',
 'deps/v8/tools/consarray.js',

test/parallel/test-stream-wrap-drain.js

@@ -2,12 +2,12 @@
 'use strict';
 constcommon=require('../common');
 constassert=require('assert');
-const{ StreamWrap }=require('_stream_wrap');
+const{ StreamWrap }=require('internal/js_stream_socket');
 const{ Duplex }=require('stream');
 const{ internalBinding }=require('internal/test/binding');
 const{ ShutdownWrap }=internalBinding('stream_wrap');
 
-// This test makes sure that when an instance of JSStreamWrap is waiting for
+// This test makes sure that when a wrapped stream is waiting for
 // a "drain" event to `doShutdown`, the instance will work correctly when a
 // "drain" event emitted.
 {

test/parallel/test-stream-wrap-encoding.js

@@ -1,7 +1,8 @@
+// Flags: --expose-internals
 'use strict';
 constcommon=require('../common');
 
-constStreamWrap=require('_stream_wrap');
+constStreamWrap=require('internal/js_stream_socket');
 constDuplex=require('stream').Duplex;
 
 {

test/parallel/test-stream-wrap.js

@@ -4,7 +4,7 @@ const common = require('../common');
 constassert=require('assert');
 
 const{ internalBinding }=require('internal/test/binding');
-constStreamWrap=require('_stream_wrap');
+constStreamWrap=require('internal/js_stream_socket');
 const{ Duplex }=require('stream');
 const{ ShutdownWrap }=internalBinding('stream_wrap');
 

test/parallel/test-wrap-js-stream-destroy.js

@@ -1,7 +1,8 @@
+// Flags: --expose-internals
 'use strict';
 
 constcommon=require('../common');
-constStreamWrap=require('_stream_wrap');
+constStreamWrap=require('internal/js_stream_socket');
 constnet=require('net');
 
 // This test ensures that when we directly call `socket.destroy()` without

test/parallel/test-wrap-js-stream-duplex.js

@@ -1,7 +1,8 @@
+// Flags: --expose-internals
 'use strict';
 constcommon=require('../common');
 constassert=require('assert');
-constStreamWrap=require('_stream_wrap');
+constStreamWrap=require('internal/js_stream_socket');
 const{ PassThrough }=require('stream');
 const{ Socket }=require('net');