From 48a2568f411cf09999b7e82992d15142ce9a45b0 Mon Sep 17 00:00:00 2001
From: Anatoli Papirovski <apapirovski@mac.com>
Date: Wed, 23 May 2018 02:01:53 +0400
Subject: [PATCH] timers: add hasRef method to Timeout & Immediate

Provide a way to check whether the current timer or immediate is refed.

PR-URL: https://github.com/nodejs/node/pull/20898
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
---
 doc/api/timers.md                            | 18 ++++++++++++++++++
 lib/timers.js                                | 12 ++++++++++--
 test/parallel/test-timers-immediate-unref.js |  8 ++++++++
 test/parallel/test-timers-unref.js           |  8 +++++++-
 4 files changed, 43 insertions(+), 3 deletions(-)

diff --git a/doc/api/timers.md b/doc/api/timers.md
index 1eb511c3b92b48..b86a49a932ec1c 100644
--- a/doc/api/timers.md
+++ b/doc/api/timers.md
@@ -23,6 +23,15 @@ running as long as the immediate is active. The `Immediate` object returned by
 [`setImmediate()`][] exports both `immediate.ref()` and `immediate.unref()`
 functions that can be used to control this default behavior.
 
+### immediate.hasRef()
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {boolean}
+
+If true, the `Immediate` object will keep the Node.js event loop active.
+
 ### immediate.ref()
 <!-- YAML
 added: v9.7.0
@@ -61,6 +70,15 @@ timer is active. Each of the `Timeout` objects returned by these functions
 export both `timeout.ref()` and `timeout.unref()` functions that can be used to
 control this default behavior.
 
+### timeout.hasRef()
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {boolean}
+
+If true, the `Timeout` object will keep the Node.js event loop active.
+
 ### timeout.ref()
 <!-- YAML
 added: v0.9.1
diff --git a/lib/timers.js b/lib/timers.js
index 3d200344a4589a..5ae0e6a5ad4fd4 100644
--- a/lib/timers.js
+++ b/lib/timers.js
@@ -547,6 +547,10 @@ Timeout.prototype.ref = function() {
   return this;
 };
 
+Timeout.prototype.hasRef = function() {
+  return !!this[kRefed];
+};
+
 Timeout.prototype.close = function() {
   clearTimeout(this);
   return this;
@@ -622,7 +626,7 @@ function processImmediate() {
     count++;
     if (immediate[kRefed])
       refCount++;
-    immediate[kRefed] = undefined;
+    immediate[kRefed] = null;
 
     tryOnImmediate(immediate, tail, count, refCount);
 
@@ -713,6 +717,10 @@ const Immediate = class Immediate {
     }
     return this;
   }
+
+  hasRef() {
+    return !!this[kRefed];
+  }
 };
 
 function setImmediate(callback, arg1, arg2, arg3) {
@@ -761,7 +769,7 @@ exports.clearImmediate = function clearImmediate(immediate) {
 
   if (immediate[kRefed] && --immediateInfo[kRefCount] === 0)
     toggleImmediateRef(false);
-  immediate[kRefed] = undefined;
+  immediate[kRefed] = null;
 
   if (destroyHooksExist()) {
     emitDestroy(immediate[async_id_symbol]);
diff --git a/test/parallel/test-timers-immediate-unref.js b/test/parallel/test-timers-immediate-unref.js
index 5b56eb7e1d8e5b..ecb26682c1e1bb 100644
--- a/test/parallel/test-timers-immediate-unref.js
+++ b/test/parallel/test-timers-immediate-unref.js
@@ -3,6 +3,14 @@
 const common = require('../common');
 const Countdown = require('../common/countdown');
 
+const assert = require('assert');
+
+const immediate = setImmediate(() => {});
+assert.strictEqual(immediate.hasRef(), true);
+immediate.unref();
+assert.strictEqual(immediate.hasRef(), false);
+clearImmediate(immediate);
+
 // This immediate should execute as it was unrefed and refed again.
 // It also confirms that unref/ref are chainable.
 setImmediate(common.mustCall(firstStep)).ref().unref().unref().ref();
diff --git a/test/parallel/test-timers-unref.js b/test/parallel/test-timers-unref.js
index 8c4891f1ed6459..35615d111ada54 100644
--- a/test/parallel/test-timers-unref.js
+++ b/test/parallel/test-timers-unref.js
@@ -23,6 +23,8 @@
 
 const common = require('../common');
 
+const assert = require('assert');
+
 let unref_interval = false;
 let unref_timer = false;
 let checks = 0;
@@ -30,8 +32,12 @@ let checks = 0;
 const LONG_TIME = 10 * 1000;
 const SHORT_TIME = 100;
 
+const timer = setTimeout(() => {}, 10);
+assert.strictEqual(timer.hasRef(), true);
 // Should not throw.
-setTimeout(() => {}, 10).unref().ref().unref();
+timer.unref().ref().unref();
+assert.strictEqual(timer.hasRef(), false);
+
 setInterval(() => {}, 10).unref().ref().unref();
 
 setInterval(common.mustNotCall('Interval should not fire'), LONG_TIME).unref();