src: introduce TimerWrap/TimerWrapHandle utility

node.gyp

@@ -638,6 +638,7 @@
         'src/string_decoder.cc',
         'src/tcp_wrap.cc',
         'src/timers.cc',
+        'src/timer_wrap.cc',
         'src/tracing/agent.cc',
         'src/tracing/node_trace_buffer.cc',
         'src/tracing/node_trace_writer.cc',
@@ -741,6 +742,7 @@
         'src/tracing/trace_event.h',
         'src/tracing/trace_event_common.h',
         'src/tracing/traced_value.h',
+        'src/timer_wrap.h',
         'src/tty_wrap.h',
         'src/udp_wrap.h',
         'src/util.h',

src/inspector_agent.cc

@@ -15,6 +15,7 @@
 #include "node_process.h"
 #include "node_url.h"
 #include "util-inl.h"
+#include "timer_wrap.h"
 #include "v8-inspector.h"
 #include "v8-platform.h"
 
@@ -326,86 +327,6 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   bool retaining_context_;
 };
 
-class InspectorTimer {
- public:
-  InspectorTimer(Environment* env,
-                 double interval_s,
-                 V8InspectorClient::TimerCallback callback,
-                 void* data) : env_(env),
-                               callback_(callback),
-                               data_(data) {
-    uv_timer_init(env->event_loop(), &timer_);
-    int64_t interval_ms = 1000 * interval_s;
-    uv_timer_start(&timer_, OnTimer, interval_ms, interval_ms);
-    timer_.data = this;
-  }
-
-  InspectorTimer(const InspectorTimer&) = delete;
-
-  void Stop() {
-    if (timer_.data == nullptr) return;
-
-    timer_.data = nullptr;
-    uv_timer_stop(&timer_);
-    env_->CloseHandle(reinterpret_cast<uv_handle_t*>(&timer_), TimerClosedCb);
-  }
-
-  inline Environment* env() const { return env_; }
-
- private:
-  static void OnTimer(uv_timer_t* uvtimer) {
-    InspectorTimer* timer = node::ContainerOf(&InspectorTimer::timer_, uvtimer);
-    timer->callback_(timer->data_);
-  }
-
-  static void TimerClosedCb(uv_handle_t* uvtimer) {
-    std::unique_ptr<InspectorTimer> timer(
-        node::ContainerOf(&InspectorTimer::timer_,
-                          reinterpret_cast<uv_timer_t*>(uvtimer)));
-    // Unique_ptr goes out of scope here and pointer is deleted.
-  }
-
-  ~InspectorTimer() = default;
-
-  Environment* env_;
-  uv_timer_t timer_;
-  V8InspectorClient::TimerCallback callback_;
-  void* data_;
-
-  friend std::unique_ptr<InspectorTimer>::deleter_type;
-};
-
-class InspectorTimerHandle {
- public:
-  InspectorTimerHandle(Environment* env, double interval_s,
-                       V8InspectorClient::TimerCallback callback, void* data) {
-    timer_ = new InspectorTimer(env, interval_s, callback, data);
-
-    env->AddCleanupHook(CleanupHook, this);
-  }
-
-  InspectorTimerHandle(const InspectorTimerHandle&) = delete;
-
-  ~InspectorTimerHandle() {
-    Stop();
-  }
-
- private:
-  void Stop() {
-    if (timer_ != nullptr) {
-      timer_->env()->RemoveCleanupHook(CleanupHook, this);
-      timer_->Stop();
-    }
-    timer_ = nullptr;
-  }
-
-  static void CleanupHook(void* data) {
-    static_cast<InspectorTimerHandle*>(data)->Stop();
-  }
-
-  InspectorTimer* timer_;
-};
-
 class SameThreadInspectorSession : public InspectorSession {
  public:
   SameThreadInspectorSession(
@@ -602,9 +523,12 @@ class NodeInspectorClient : public V8InspectorClient {
   void startRepeatingTimer(double interval_s,
                            TimerCallback callback,
                            void* data) override {
-    timers_.emplace(std::piecewise_construct, std::make_tuple(data),
-                    std::make_tuple(env_, interval_s, callback,
-                                    data));
+    auto result =
+        timers_.emplace(std::piecewise_construct, std::make_tuple(data),
+                        std::make_tuple(env_, callback, data));
+    CHECK(result.second);
+    uint64_t interval = 1000 * interval_s;
+    result.first->second.Update(interval, interval);
   }
 
   void cancelTimer(void* data) override {
@@ -724,7 +648,7 @@ class NodeInspectorClient : public V8InspectorClient {
   bool running_nested_loop_ = false;
   std::unique_ptr<V8Inspector> client_;
   // Note: ~ChannelImpl may access timers_ so timers_ has to come first.
-  std::unordered_map<void*, InspectorTimerHandle> timers_;
+  std::unordered_map<void*, TimerWrapHandle> timers_;
   std::unordered_map<int, std::unique_ptr<ChannelImpl>> channels_;
   int next_session_id_ = 1;
   bool waiting_for_resume_ = false;

src/quic/node_quic_session-inl.h

@@ -375,8 +375,7 @@ QuicCID QuicSession::dcid() const {
 // timer to actually monitor. Here we take the calculated timeout
 // and extend out the libuv timer.
 void QuicSession::UpdateRetransmitTimer(uint64_t timeout) {
-  DCHECK_NOT_NULL(retransmit_);
-  retransmit_->Update(timeout);
+  retransmit_.Update(timeout, timeout);
 }
 
 void QuicSession::CheckAllocatedSize(size_t previous_size) const {
@@ -512,13 +511,11 @@ void QuicSession::set_remote_transport_params() {
 }
 
 void QuicSession::StopIdleTimer() {
-  CHECK_NOT_NULL(idle_);
-  idle_->Stop();
+  idle_.Stop();
 }
 
 void QuicSession::StopRetransmitTimer() {
-  CHECK_NOT_NULL(retransmit_);
-  retransmit_->Stop();
+  retransmit_.Stop();
 }
 
 // Called by the OnVersionNegotiation callback when a version

src/quic/node_quic_session.cc

@@ -1431,8 +1431,8 @@ QuicSession::QuicSession(
     socket_(socket),
     alpn_(alpn),
     hostname_(hostname),
-    idle_(new Timer(socket->env(), [this]() { OnIdleTimeout(); })),
-    retransmit_(new Timer(socket->env(), [this]() { MaybeTimeout(); })),
+    idle_(socket->env(), [this](void* data) { OnIdleTimeout(); }),
+    retransmit_(socket->env(), [this](void* data) { MaybeTimeout(); }),
     dcid_(dcid),
     state_(env()->isolate()),
     quic_state_(socket->quic_state()) {
@@ -2461,14 +2461,13 @@ void QuicSession::UpdateConnectionID(
 // will be silently closed. It is important to update this as activity
 // occurs to keep the idle timer from firing.
 void QuicSession::UpdateIdleTimer() {
-  CHECK_NOT_NULL(idle_);
   uint64_t now = uv_hrtime();
   uint64_t expiry = ngtcp2_conn_get_idle_expiry(connection());
   // nano to millis
   uint64_t timeout = expiry > now ? (expiry - now) / 1000000ULL : 1;
   if (timeout == 0) timeout = 1;
   Debug(this, "Updating idle timeout to %" PRIu64, timeout);
-  idle_->Update(timeout);
+  idle_.Update(timeout, timeout);
 }
 
 

src/quic/node_quic_session.h

@@ -18,6 +18,7 @@
 #include "node_quic_util.h"
 #include "node_sockaddr.h"
 #include "stream_base.h"
+#include "timer_wrap.h"
 #include "v8.h"
 #include "uv.h"
 
@@ -1471,8 +1472,8 @@ class QuicSession : public AsyncWrap,
   QuicSessionListener* listener_ = nullptr;
   JSQuicSessionListener default_listener_;
 
-  TimerPointer idle_;
-  TimerPointer retransmit_;
+  TimerWrapHandle idle_;
+  TimerWrapHandle retransmit_;
 
   QuicCID scid_;
   QuicCID dcid_;

src/quic/node_quic_util-inl.h

@@ -73,49 +73,6 @@ size_t GetMaxPktLen(const SocketAddress& addr) {
       NGTCP2_MAX_PKTLEN_IPV4;
 }
 
-Timer::Timer(Environment* env, std::function<void()> fn)
-  : env_(env),
-    fn_(fn) {
-  uv_timer_init(env_->event_loop(), &timer_);
-  timer_.data = this;
-}
-
-void Timer::Stop() {
-  if (stopped_)
-    return;
-  stopped_ = true;
-
-  if (timer_.data == this) {
-    uv_timer_stop(&timer_);
-    timer_.data = nullptr;
-  }
-}
-
-// If the timer is not currently active, interval must be either 0 or greater.
-// If the timer is already active, interval is ignored.
-void Timer::Update(uint64_t interval) {
-  if (stopped_)
-    return;
-  uv_timer_start(&timer_, OnTimeout, interval, interval);
-  uv_unref(reinterpret_cast<uv_handle_t*>(&timer_));
-}
-
-void Timer::Free(Timer* timer) {
-  timer->env_->CloseHandle(
-      reinterpret_cast<uv_handle_t*>(&timer->timer_),
-      [&](uv_handle_t* timer) {
-        Timer* t = ContainerOf(
-            &Timer::timer_,
-            reinterpret_cast<uv_timer_t*>(timer));
-        delete t;
-      });
-}
-
-void Timer::OnTimeout(uv_timer_t* timer) {
-  Timer* t = ContainerOf(&Timer::timer_, timer);
-  t->fn_();
-}
-
 QuicError::QuicError(
     int32_t family_,
     uint64_t code_) :

src/quic/node_quic_util.h

@@ -338,38 +338,6 @@ class QuicCID : public MemoryRetainer {
   const ngtcp2_cid* ptr_;
 };
 
-// Simple timer wrapper that is used to implement the internals
-// for idle and retransmission timeouts. Call Update to start or
-// reset the timer; Stop to halt the timer.
-class Timer final : public MemoryRetainer {
- public:
-  inline explicit Timer(Environment* env, std::function<void()> fn);
-
-  // Stops the timer with the side effect of the timer no longer being usable.
-  // It will be cleaned up and the Timer object will be destroyed.
-  inline void Stop();
-
-  // If the timer is not currently active, interval must be either 0 or greater.
-  // If the timer is already active, interval is ignored.
-  inline void Update(uint64_t interval);
-
-  static inline void Free(Timer* timer);
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(Timer)
-  SET_SELF_SIZE(Timer)
-
- private:
-  static inline void OnTimeout(uv_timer_t* timer);
-
-  bool stopped_ = false;
-  Environment* env_;
-  std::function<void()> fn_;
-  uv_timer_t timer_;
-};
-
-using TimerPointer = DeleteFnPtr<Timer, Timer::Free>;
-
 // A Stateless Reset Token is a mechanism by which a QUIC
 // endpoint can discreetly signal to a peer that it has
 // lost all state associated with a connection. This

src/timer_wrap.cc

@@ -0,0 +1,94 @@
+#include "env-inl.h"
+#include "memory_tracker-inl.h"
+#include "timer_wrap.h"
+#include "uv.h"
+
+namespace node {
+
+TimerWrap::TimerWrap(Environment* env, TimerCb fn, void* user_data)
+    : env_(env),
+      fn_(fn),
+      user_data_(user_data) {
+  uv_timer_init(env->event_loop(), &timer_);
+  timer_.data = this;
+}
+
+void TimerWrap::Stop(bool close) {
+  if (timer_.data == nullptr) return;
+  uv_timer_stop(&timer_);
+  if (LIKELY(close)) {
+    timer_.data = nullptr;
+    env_->CloseHandle(reinterpret_cast<uv_handle_t*>(&timer_), TimerClosedCb);
+  }
+}
+
+void TimerWrap::TimerClosedCb(uv_handle_t* handle) {
+  std::unique_ptr<TimerWrap> ptr(
+      ContainerOf(&TimerWrap::timer_,
+                  reinterpret_cast<uv_timer_t*>(handle)));
+}
+
+void TimerWrap::Update(uint64_t interval, uint64_t repeat) {
+  if (timer_.data == nullptr) return;
+  uv_timer_start(&timer_, OnTimeout, interval, repeat);
+}
+
+void TimerWrap::Ref() {
+  if (timer_.data == nullptr) return;
+  uv_ref(reinterpret_cast<uv_handle_t*>(&timer_));
+}
+
+void TimerWrap::Unref() {
+  if (timer_.data == nullptr) return;
+  uv_unref(reinterpret_cast<uv_handle_t*>(&timer_));
+}
+
+void TimerWrap::OnTimeout(uv_timer_t* timer) {
+  TimerWrap* t = ContainerOf(&TimerWrap::timer_, timer);
+  t->fn_(t->user_data_);
+}
+
+TimerWrapHandle::TimerWrapHandle(
+    Environment* env,
+    TimerWrap::TimerCb fn,
+    void* user_data) {
+  timer_ = new TimerWrap(env, fn, user_data);
+  env->AddCleanupHook(CleanupHook, this);
+}
+
+void TimerWrapHandle::Stop(bool close) {
+  if (UNLIKELY(!close))
+    return timer_->Stop(close);
+
+  if (timer_ != nullptr) {
+    timer_->env()->RemoveCleanupHook(CleanupHook, this);
+    timer_->Stop();
+  }
+  timer_ = nullptr;
+}
+
+void TimerWrapHandle::Ref() {
+  if (timer_ != nullptr)
+    timer_->Ref();
+}
+
+void TimerWrapHandle::Unref() {
+  if (timer_ != nullptr)
+    timer_->Unref();
+}
+
+void TimerWrapHandle::Update(uint64_t interval, uint64_t repeat) {
+  if (timer_ != nullptr)
+    timer_->Update(interval, repeat);
+}
+
+void TimerWrapHandle::CleanupHook(void* data) {
+  static_cast<TimerWrapHandle*>(data)->Stop();
+}
+
+void TimerWrapHandle::MemoryInfo(node::MemoryTracker* tracker) const {
+  if (timer_ != nullptr)
+    tracker->TrackField("timer", *timer_);
+}
+
+}  // namespace node