dgram: hide underscored Socket properties

dgram sockets have a fair number of exposed private properties.
This commit hides them all behind a single symbol property.

PR-URL: #21923
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Wyatt Preul <wpreul@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

lib/internal/child_process.js

@@ -32,6 +32,7 @@ const { isUint8Array } = require('internal/util/types');
 const spawn_sync = process.binding('spawn_sync');
 const { HTTPParser } = process.binding('http_parser');
 const { freeParser } = require('_http_common');
+const { kStateSymbol } = require('internal/dgram');
 
 const {
   UV_EACCES,
@@ -181,7 +182,7 @@ const handleConversion = {
     send: function(message, socket, options) {
       message.dgramType = socket.type;
 
-      return socket._handle;
+      return socket[kStateSymbol].handle;
     },
 
     got: function(message, handle, emit) {

lib/internal/dgram.js

@@ -0,0 +1,4 @@
+'use strict';
+const kStateSymbol = Symbol('state symbol');
+
+module.exports = { kStateSymbol };

node.gyp

@@ -104,6 +104,7 @@
       'lib/internal/crypto/sig.js',
       'lib/internal/crypto/util.js',
       'lib/internal/constants.js',
+      'lib/internal/dgram.js',
       'lib/internal/dns/promises.js',
       'lib/internal/dns/utils.js',
       'lib/internal/domexception.js',

test/parallel/test-dgram-close-during-bind.js

@@ -1,13 +1,16 @@
+// Flags: --expose-internals
 'use strict';
 const common = require('../common');
 const dgram = require('dgram');
+const { kStateSymbol } = require('internal/dgram');
 const socket = dgram.createSocket('udp4');
-const lookup = socket._handle.lookup;
+const { handle } = socket[kStateSymbol];
+const lookup = handle.lookup;
 
 // Test the scenario where the socket is closed during a bind operation.
-socket._handle.bind = common.mustNotCall('bind() should not be called.');
+handle.bind = common.mustNotCall('bind() should not be called.');
 
-socket._handle.lookup = common.mustCall(function(address, callback) {
+handle.lookup = common.mustCall(function(address, callback) {
   socket.close(common.mustCall(() => {
     lookup.call(this, address, callback);
   }));

test/parallel/test-dgram-close.js

@@ -19,18 +19,20 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+// Flags: --expose-internals
 'use strict';
 // Ensure that if a dgram socket is closed before the DNS lookup completes, it
 // won't crash.
 
 const common = require('../common');
 const assert = require('assert');
 const dgram = require('dgram');
+const { kStateSymbol } = require('internal/dgram');
 
 const buf = Buffer.alloc(1024, 42);
 
 let socket = dgram.createSocket('udp4');
-const handle = socket._handle;
+const { handle } = socket[kStateSymbol];
 
 // get a random port for send
 const portGetter = dgram.createSocket('udp4')

test/parallel/test-dgram-recv-error.js

@@ -1,8 +1,11 @@
+// Flags: --expose-internals
 'use strict';
 const common = require('../common');
 const assert = require('assert');
 const dgram = require('dgram');
+const { kStateSymbol } = require('internal/dgram');
 const s = dgram.createSocket('udp4');
+const { handle } = s[kStateSymbol];
 
 s.on('error', common.mustCall((err) => {
   s.close();
@@ -13,4 +16,4 @@ s.on('error', common.mustCall((err) => {
 }));
 
 s.on('message', common.mustNotCall('no message should be received.'));
-s.bind(common.mustCall(() => s._handle.onmessage(-1, s._handle, null, null)));
+s.bind(common.mustCall(() => handle.onmessage(-1, handle, null, null)));

test/parallel/test-dgram-send-error.js

@@ -1,15 +1,17 @@
+// Flags: --expose-internals
 'use strict';
 const common = require('../common');
 const assert = require('assert');
 const dgram = require('dgram');
+const { kStateSymbol } = require('internal/dgram');
 const mockError = new Error('mock DNS error');
 
 function getSocket(callback) {
   const socket = dgram.createSocket('udp4');
 
   socket.on('message', common.mustNotCall('Should not receive any messages.'));
   socket.bind(common.mustCall(() => {
-    socket._handle.lookup = function(address, callback) {
+    socket[kStateSymbol].handle.lookup = function(address, callback) {
       process.nextTick(callback, mockError);
     };
 
@@ -57,7 +59,7 @@ getSocket((socket) => {
       );
     });
 
-    socket._handle.send = function() {
+    socket[kStateSymbol].handle.send = function() {
       return errCode;
     };
 

test/parallel/test-handle-wrap-isrefed.js

@@ -1,3 +1,4 @@
+// Flags: --expose-internals
 'use strict';
 
 const common = require('../common');
@@ -25,41 +26,46 @@ const strictEqual = require('assert').strictEqual;
 
 
 const dgram = require('dgram');
+const { kStateSymbol } = require('internal/dgram');
 
 // dgram ipv4
 {
   const sock4 = dgram.createSocket('udp4');
-  strictEqual(Object.getPrototypeOf(sock4._handle).hasOwnProperty('hasRef'),
+  const handle = sock4[kStateSymbol].handle;
+
+  strictEqual(Object.getPrototypeOf(handle).hasOwnProperty('hasRef'),
               true, 'udp_wrap: ipv4: hasRef() missing');
-  strictEqual(sock4._handle.hasRef(),
+  strictEqual(handle.hasRef(),
               true, 'udp_wrap: ipv4: not initially refed');
   sock4.unref();
-  strictEqual(sock4._handle.hasRef(),
+  strictEqual(handle.hasRef(),
               false, 'udp_wrap: ipv4: unref() ineffective');
   sock4.ref();
-  strictEqual(sock4._handle.hasRef(),
+  strictEqual(handle.hasRef(),
               true, 'udp_wrap: ipv4: ref() ineffective');
-  sock4._handle.close(common.mustCall(() =>
-    strictEqual(sock4._handle.hasRef(),
+  handle.close(common.mustCall(() =>
+    strictEqual(handle.hasRef(),
                 false, 'udp_wrap: ipv4: not unrefed on close')));
 }
 
 
 // dgram ipv6
 {
   const sock6 = dgram.createSocket('udp6');
-  strictEqual(Object.getPrototypeOf(sock6._handle).hasOwnProperty('hasRef'),
+  const handle = sock6[kStateSymbol].handle;
+
+  strictEqual(Object.getPrototypeOf(handle).hasOwnProperty('hasRef'),
               true, 'udp_wrap: ipv6: hasRef() missing');
-  strictEqual(sock6._handle.hasRef(),
+  strictEqual(handle.hasRef(),
               true, 'udp_wrap: ipv6: not initially refed');
   sock6.unref();
-  strictEqual(sock6._handle.hasRef(),
+  strictEqual(handle.hasRef(),
               false, 'udp_wrap: ipv6: unref() ineffective');
   sock6.ref();
-  strictEqual(sock6._handle.hasRef(),
+  strictEqual(handle.hasRef(),
               true, 'udp_wrap: ipv6: ref() ineffective');
-  sock6._handle.close(common.mustCall(() =>
-    strictEqual(sock6._handle.hasRef(),
+  handle.close(common.mustCall(() =>
+    strictEqual(handle.hasRef(),
                 false, 'udp_wrap: ipv6: not unrefed on close')));
 }
 

test/sequential/test-dgram-implicit-bind-failure.js

@@ -1,8 +1,10 @@
+// Flags: --expose-internals
 'use strict';
 const common = require('../common');
 const assert = require('assert');
 const dgram = require('dgram');
 const dns = require('dns');
+const { kStateSymbol } = require('internal/dgram');
 
 // Monkey patch dns.lookup() so that it always fails.
 dns.lookup = function(address, family, callback) {
@@ -25,8 +27,8 @@ socket.on('error', (err) => {
     // should also be two listeners - this function and the dgram internal one
     // time error handler.
     dnsFailures++;
-    assert(Array.isArray(socket._queue));
-    assert.strictEqual(socket._queue.length, 1);
+    assert(Array.isArray(socket[kStateSymbol].queue));
+    assert.strictEqual(socket[kStateSymbol].queue.length, 1);
     assert.strictEqual(socket.listenerCount('error'), 2);
     return;
   }
@@ -35,7 +37,7 @@ socket.on('error', (err) => {
     // On error, the queue should be destroyed and this function should be
     // the only listener.
     sendFailures++;
-    assert.strictEqual(socket._queue, undefined);
+    assert.strictEqual(socket[kStateSymbol].queue, undefined);
     assert.strictEqual(socket.listenerCount('error'), 1);
     return;
   }