@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/streams.h

@@ -0,0 +1,370 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <aliased_struct.h>
+#include <async_wrap.h>
+#include <base_object.h>
+#include <dataqueue/queue.h>
+#include <env.h>
+#include <memory_tracker.h>
+#include <node_blob.h>
+#include <node_bob.h>
+#include <node_http_common.h>
+#include <util.h>
+#include "bindingdata.h"
+#include "data.h"
+
+namespace node::quic {
+
+class Session;
+class Stream;
+
+using Ngtcp2Source = bob::SourceImpl<ngtcp2_vec>;
+
+// When a request to open a stream is made before a Session is able to actually
+// open a stream (either because the handshake is not yet sufficiently complete
+// or concurrency limits are temporarily reached) then the request to open the
+// stream is represented as a queued PendingStream.
+//
+// The PendingStream instance itself is held by the stream but sits in a linked
+// list in the session.
+//
+// The PendingStream request can be canceled by dropping the PendingStream
+// instance before it can be fulfilled, at which point it is removed from the
+// pending stream queue.
+//
+// Note that only locally initiated streams can be created in a pending state.
+class PendingStream final {
+ public:
+  PendingStream(Direction direction,
+                Stream* stream,
+                BaseObjectWeakPtr<Session> session);
+  DISALLOW_COPY_AND_MOVE(PendingStream)
+  ~PendingStream();
+
+  // Called when the stream has been opened. Transitions the stream from a
+  // pending state to an opened state.
+  void fulfill(int64_t id);
+
+  // Called when opening the stream fails or is canceled. Transitions the
+  // stream into a closed/destroyed state.
+  void reject(QuicError error = QuicError());
+
+  inline Direction direction() const { return direction_; }
+
+ private:
+  Direction direction_;
+  Stream* stream_;
+  BaseObjectWeakPtr<Session> session_;
+  bool waiting_ = true;
+
+  ListNode<PendingStream> pending_stream_queue_;
+
+ public:
+  using PendingStreamQueue =
+      ListHead<PendingStream, &PendingStream::pending_stream_queue_>;
+};
+
+// QUIC Stream's are simple data flows that may be:
+//
+// * Bidirectional (both sides can send) or Unidirectional (one side can send)
+// * Server or Client Initiated
+//
+// The flow direction and origin of the stream are important in determining the
+// write and read state (Open or Closed). Specifically:
+//
+// Bidirectional Stream States:
+// +--------+--------------+----------+----------+
+// |   ON   | Initiated By | Readable | Writable |
+// +--------+--------------+----------+----------+
+// | Server |   Server     |    Y     |    Y     |
+// +--------+--------------+----------+----------+
+// | Server |   Client     |    Y     |    Y     |
+// +--------+--------------+----------+----------+
+// | Client |   Server     |    Y     |    Y     |
+// +--------+--------------+----------+----------+
+// | Client |   Client     |    Y     |    Y     |
+// +--------+--------------+----------+----------+
+//
+// Unidirectional Stream States
+// +--------+--------------+----------+----------+
+// |   ON   | Initiated By | Readable | Writable |
+// +--------+--------------+----------+----------+
+// | Server |   Server     |    N     |    Y     |
+// +--------+--------------+----------+----------+
+// | Server |   Client     |    Y     |    N     |
+// +--------+--------------+----------+----------+
+// | Client |   Server     |    Y     |    N     |
+// +--------+--------------+----------+----------+
+// | Client |   Client     |    N     |    Y     |
+// +--------+--------------+----------+----------+
+//
+// All data sent via the Stream is buffered internally until either receipt is
+// acknowledged from the peer or attempts to send are abandoned. The fact that
+// data is buffered in memory makes it essential that the flow control for the
+// session and the stream are properly handled. For now, we are largely relying
+// on ngtcp2's default flow control mechanisms which generally should be doing
+// the right thing.
+//
+// A Stream may be in a fully closed state (No longer readable nor writable)
+// state but still have unacknowledged data in both the inbound and outbound
+// queues.
+//
+// A Stream is gracefully closed when (a) both read and write states are closed,
+// (b) all queued data has been acknowledged.
+//
+// The Stream may be forcefully closed immediately using destroy(err). This
+// causes all queued outbound data and pending JavaScript writes are abandoned,
+// and causes the Stream to be immediately closed at the ngtcp2 level without
+// waiting for any outstanding acknowledgements. Keep in mind, however, that the
+// peer is not notified that the stream is destroyed and may attempt to continue
+// sending data and acknowledgements.
+//
+// QUIC streams in general do not have headers. Some QUIC applications, however,
+// may associate headers with the stream (HTTP/3 for instance).
+//
+// Streams may be created in a pending state. This means that while the Stream
+// object is created, it has not yet been opened in ngtcp2 and therefore has
+// no official status yet. Certain operations can still be performed on the
+// stream object such as providing data and headers, and destroying the stream.
+//
+// When a stream is created the data source for the stream must be given.
+// If no data source is given, then the stream is assumed to not have any
+// outbound data. The data source can be fixed length or may support
+// streaming. What this means practically is, when a stream is opened,
+// you must already have a sense of whether that will provide data or
+// not. When in doubt, specify a streaming data source, which can produce
+// zero-length output.
+class Stream final : public AsyncWrap,
+                     public Ngtcp2Source,
+                     public DataQueue::BackpressureListener {
+ public:
+  using Header = NgHeaderBase<BindingData>;
+
+  static v8::Maybe<std::shared_ptr<DataQueue>> GetDataQueueFromSource(
+      Environment* env, v8::Local<v8::Value> value);
+
+  static Stream* From(void* stream_user_data);
+
+  static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void InitPerIsolate(IsolateData* data,
+                             v8::Local<v8::ObjectTemplate> target);
+  static void InitPerContext(Realm* realm, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  // Creates a new non-pending stream.
+  static BaseObjectPtr<Stream> Create(
+      Session* session,
+      int64_t id,
+      std::shared_ptr<DataQueue> source = nullptr);
+
+  // Creates a new pending stream.
+  static BaseObjectPtr<Stream> Create(
+      Session* session,
+      Direction direction,
+      std::shared_ptr<DataQueue> source = nullptr);
+
+  // The constructor is only public to be visible by MakeDetachedBaseObject.
+  // Call Create to create new instances of Stream.
+  Stream(BaseObjectWeakPtr<Session> session,
+         v8::Local<v8::Object> obj,
+         int64_t id,
+         std::shared_ptr<DataQueue> source);
+
+  // Creates the stream in a pending state. The constructor is only public
+  // to be visible to MakeDetachedBaseObject. Call Create to create new
+  // instances of Stream.
+  Stream(BaseObjectWeakPtr<Session> session,
+         v8::Local<v8::Object> obj,
+         Direction direction,
+         std::shared_ptr<DataQueue> source);
+  DISALLOW_COPY_AND_MOVE(Stream)
+  ~Stream() override;
+
+  // While the stream is still pending, the id will be -1.
+  int64_t id() const;
+
+  // While the stream is still pending, the origin will be invalid.
+  Side origin() const;
+
+  Direction direction() const;
+
+  Session& session() const;
+
+  // True if this stream was created in a pending state and is still waiting
+  // to be created.
+  bool is_pending() const;
+
+  // True if we've completely sent all outbound data for this stream.
+  // Importantly, this does not necessarily mean that we are completely
+  // done with the outbound data. We may still be waiting on outbound
+  // data to be acknowledged by the remote peer.
+  bool is_eos() const;
+
+  // True if this stream is still in a readable state.
+  bool is_readable() const;
+
+  // True if this stream is still in a writable state.
+  bool is_writable() const;
+
+  // Called by the session/application to indicate that the specified number
+  // of bytes have been acknowledged by the peer.
+  void Acknowledge(size_t datalen);
+  void Commit(size_t datalen);
+
+  void EndWritable();
+  void EndReadable(std::optional<uint64_t> maybe_final_size = std::nullopt);
+  void EntryRead(size_t amount) override;
+
+  // Pulls data from the internal outbound DataQueue configured for this stream.
+  int DoPull(bob::Next<ngtcp2_vec> next,
+             int options,
+             ngtcp2_vec* data,
+             size_t count,
+             size_t max_count_hint) override;
+
+  // Forcefully close the stream immediately. Data already queued in the
+  // inbound is preserved but new data will not be accepted. All pending
+  // writes are abandoned, and the stream is immediately closed at the ngtcp2
+  // level without waiting for any outstanding acknowledgements.
+  void Destroy(QuicError error = QuicError());
+
+  struct ReceiveDataFlags final {
+    // Identifies the final chunk of data that the peer will send for the
+    // stream.
+    bool fin = false;
+    // Indicates that this chunk of data was received in a 0RTT packet before
+    // the TLS handshake completed, suggesting that is is not as secure and
+    // could be replayed by an attacker.
+    bool early = false;
+  };
+
+  void ReceiveData(const uint8_t* data, size_t len, ReceiveDataFlags flags);
+  void ReceiveStopSending(QuicError error);
+  void ReceiveStreamReset(uint64_t final_size, QuicError error);
+
+  // Currently, only HTTP/3 streams support headers. These methods are here
+  // to support that. They are not used when using any other QUIC application.
+
+  void BeginHeaders(HeadersKind kind);
+  void set_headers_kind(HeadersKind kind);
+  // Returns false if the header cannot be added. This will typically happen
+  // if the application does not support headers, a maximum number of headers
+  // have already been added, or the maximum total header length is reached.
+  bool AddHeader(const Header& header);
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(Stream)
+  SET_SELF_SIZE(Stream)
+
+  struct State;
+  struct Stats;
+
+ private:
+  struct Impl;
+  struct PendingHeaders;
+
+  class Outbound;
+
+  // Gets a reader for the data received for this stream from the peer,
+  BaseObjectPtr<Blob::Reader> get_reader();
+
+  void set_final_size(uint64_t amount);
+  void set_outbound(std::shared_ptr<DataQueue> source);
+
+  bool is_local_unidirectional() const;
+  bool is_remote_unidirectional() const;
+
+  // JavaScript callouts
+
+  // Notifies the JavaScript side that the stream has been destroyed.
+  void EmitClose(const QuicError& error);
+
+  // Notifies the JavaScript side that the stream has been reset.
+  void EmitReset(const QuicError& error);
+
+  // Notifies the JavaScript side that the application is ready to receive
+  // trailing headers.
+  void EmitWantTrailers();
+
+  // Notifies the JavaScript side that sending data on the stream has been
+  // blocked because of flow control restriction.
+  void EmitBlocked();
+
+  // Delivers the set of inbound headers that have been collected.
+  void EmitHeaders();
+
+  void NotifyReadableEnded(uint64_t code);
+  void NotifyWritableEnded(uint64_t code);
+
+  // When a pending stream is finally opened, the NotifyStreamOpened method
+  // will be called and the id will be assigned.
+  void NotifyStreamOpened(int64_t id);
+  void EnqueuePendingHeaders(HeadersKind kind,
+                             v8::Local<v8::Array> headers,
+                             HeadersFlags flags);
+
+  AliasedStruct<Stats> stats_;
+  AliasedStruct<State> state_;
+  BaseObjectWeakPtr<Session> session_;
+  std::unique_ptr<Outbound> outbound_;
+  std::shared_ptr<DataQueue> inbound_;
+
+  // If the stream cannot be opened yet, it will be created in a pending state.
+  // Once the owning session is able to, it will complete opening of the stream
+  // and the stream id will be assigned.
+  std::optional<std::unique_ptr<PendingStream>> maybe_pending_stream_ =
+      std::nullopt;
+  std::vector<std::unique_ptr<PendingHeaders>> pending_headers_queue_;
+  uint64_t pending_close_read_code_ = NGTCP2_APP_NOERROR;
+  uint64_t pending_close_write_code_ = NGTCP2_APP_NOERROR;
+
+  struct PendingPriority {
+    StreamPriority priority;
+    StreamPriorityFlags flags;
+  };
+  std::optional<PendingPriority> pending_priority_ = std::nullopt;
+
+  // The headers_ field holds a block of headers that have been received and
+  // are being buffered for delivery to the JavaScript side.
+  // TODO(@jasnell): Use v8::Global instead of v8::Local here.
+  v8::LocalVector<v8::Value> headers_;
+
+  // The headers_kind_ field indicates the kind of headers that are being
+  // buffered.
+  HeadersKind headers_kind_ = HeadersKind::INITIAL;
+
+  // The headers_length_ field holds the total length of the headers that have
+  // been buffered.
+  size_t headers_length_ = 0;
+
+  friend struct Impl;
+  friend class PendingStream;
+  friend class Http3ApplicationImpl;
+  friend class DefaultApplication;
+
+ public:
+  // The Queue/Schedule/Unschedule here are part of the mechanism used to
+  // determine which streams have data to send on the session. When a stream
+  // potentially has data available, it will be scheduled in the Queue. Then,
+  // when the Session::Application starts sending pending data, it will check
+  // the queue to see if there are streams waiting. If there are, it will grab
+  // one and check to see if there is data to send. When a stream does not have
+  // data to send (such as when it is initially created or is using an async
+  // source that is still waiting for data to be pushed) it will not appear in
+  // the queue.
+  ListNode<Stream> stream_queue_;
+  using Queue = ListHead<Stream, &Stream::stream_queue_>;
+
+  void Schedule(Queue* queue);
+  void Unschedule();
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/{16 → 24}/string_bytes.h

@@ -37,19 +37,19 @@ class StringBytes {
  public:
   class InlineDecoder : public MaybeStackBuffer<char> {
    public:
-    inline v8::Maybe<bool> Decode(Environment* env,
+    inline v8::Maybe<void> Decode(Environment* env,
                                   v8::Local<v8::String> string,
                                   enum encoding enc) {
       size_t storage;
       if (!StringBytes::StorageSize(env->isolate(), string, enc).To(&storage))
-        return v8::Nothing<bool>();
+        return v8::Nothing<void>();
       AllocateSufficientStorage(storage);
       const size_t length =
           StringBytes::Write(env->isolate(), out(), storage, string, enc);
 
       // No zero terminator is included when using this method.
       SetLength(length);
-      return v8::Just(true);
+      return v8::JustVoid();
     }
 
     inline size_t size() const { return length(); }
@@ -75,15 +75,13 @@ class StringBytes {
                       char* buf,
                       size_t buflen,
                       v8::Local<v8::Value> val,
-                      enum encoding enc,
-                      int* chars_written = nullptr);
+                      enum encoding enc);
 
   // Take the bytes in the src, and turn it into a Buffer or String.
   static v8::MaybeLocal<v8::Value> Encode(v8::Isolate* isolate,
                                           const char* buf,
                                           size_t buflen,
-                                          enum encoding encoding,
-                                          v8::Local<v8::Value>* error);
+                                          enum encoding encoding);
 
   // Warning: This reverses endianness on BE platforms, even though the
   // signature using uint16_t implies that it should not.
@@ -91,28 +89,17 @@ class StringBytes {
   // be changed easily.
   static v8::MaybeLocal<v8::Value> Encode(v8::Isolate* isolate,
                                           const uint16_t* buf,
-                                          size_t buflen,
-                                          v8::Local<v8::Value>* error);
+                                          size_t buflen);
 
   static v8::MaybeLocal<v8::Value> Encode(v8::Isolate* isolate,
                                           const char* buf,
-                                          enum encoding encoding,
-                                          v8::Local<v8::Value>* error);
-
-  static size_t hex_encode(const char* src,
-                           size_t slen,
-                           char* dst,
-                           size_t dlen);
-
-  static std::string hex_encode(const char* src, size_t slen);
+                                          enum encoding encoding);
 
  private:
   static size_t WriteUCS2(v8::Isolate* isolate,
                           char* buf,
                           size_t buflen,
-                          v8::Local<v8::String> str,
-                          int flags,
-                          size_t* chars_written);
+                          v8::Local<v8::String> str);
 };
 
 }  // namespace node

package/src/headers/{18 → 24}/string_decoder-inl.h

@@ -7,12 +7,6 @@
 
 namespace node {
 
-void StringDecoder::SetEncoding(enum encoding encoding) {
-  state_[kBufferedBytes] = 0;
-  state_[kMissingBytes] = 0;
-  state_[kEncodingField] = encoding;
-}
-
 enum encoding StringDecoder::Encoding() const {
   return static_cast<enum encoding>(state_[kEncodingField]);
 }

package/src/headers/{18 → 24}/string_decoder.h

@@ -10,7 +10,6 @@ namespace node {
 class StringDecoder {
  public:
   StringDecoder() { state_[kEncodingField] = BUFFER; }
-  inline void SetEncoding(enum encoding encoding);
   inline enum encoding Encoding() const;
 
   inline char* IncompleteCharacterBuffer();

package/src/headers/24/target_agent.h

@@ -0,0 +1,75 @@
+#ifndef SRC_INSPECTOR_TARGET_AGENT_H_
+#define SRC_INSPECTOR_TARGET_AGENT_H_
+
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+#include "inspector/worker_inspector.h"
+#include "node/inspector/protocol/Target.h"
+
+namespace node {
+
+namespace inspector {
+class TargetInspector;
+
+namespace protocol {
+
+struct TargetInfo {
+  std::string target_id;
+  std::string type;
+  std::string title;
+  std::string url;
+  std::shared_ptr<MainThreadHandle> worker;
+  bool attached;
+};
+
+class TargetAgent : public Target::Backend,
+                    public std::enable_shared_from_this<TargetAgent> {
+ public:
+  void Wire(UberDispatcher* dispatcher);
+
+  void createAndAttachIfNecessary(std::shared_ptr<MainThreadHandle> worker,
+                                  const std::string& title,
+                                  const std::string& url);
+
+  DispatchResponse setAutoAttach(bool auto_attach,
+                                 bool wait_for_debugger_on_start) override;
+
+  void listenWorker(std::weak_ptr<WorkerManager> worker_manager);
+  void reset();
+  static std::unordered_map<int, std::shared_ptr<MainThreadHandle>>
+      target_session_id_worker_map_;
+
+  bool isThisThread(MainThreadHandle* worker) { return worker == main_thread_; }
+
+ private:
+  int getNextTargetId();
+  int getNextSessionId();
+  void targetCreated(const std::string_view target_id,
+                     const std::string_view type,
+                     const std::string_view title,
+                     const std::string_view url);
+  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
+                        const std::string& target_id,
+                        const std::string& type,
+                        const std::string& title,
+                        const std::string& url);
+
+  std::shared_ptr<Target::Frontend> frontend_;
+  std::weak_ptr<WorkerManager> worker_manager_;
+  static int next_session_id_;
+  int next_target_id_ = 1;
+  std::unique_ptr<WorkerManagerEventHandle> worker_event_handle_ = nullptr;
+  bool auto_attach_ = false;
+  // TODO(islandryu): If false, implement it so that each thread does not wait
+  // for the worker to execute.
+  bool wait_for_debugger_on_start_ = true;
+  std::vector<TargetInfo> targets_;
+  MainThreadHandle* main_thread_;
+};
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_TARGET_AGENT_H_

package/src/headers/{16 → 24}/tcp_wrap.h

@@ -50,7 +50,7 @@ class TCPWrap : public ConnectionWrap<TCPWrap, uv_tcp_t> {
 
   SET_NO_MEMORY_INFO()
   SET_SELF_SIZE(TCPWrap)
-  std::string MemoryInfoName() const override {
+  const char* MemoryInfoName() const override {
     switch (provider_type()) {
       case ProviderType::PROVIDER_TCPWRAP:
         return "TCPSocketWrap";
@@ -88,6 +88,8 @@ class TCPWrap : public ConnectionWrap<TCPWrap, uv_tcp_t> {
       const v8::FunctionCallbackInfo<v8::Value>& args,
       int family,
       std::function<int(const char* ip_address, int port, T* addr)> uv_ip_addr);
+  static void Reset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  int Reset(v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
 
 #ifdef _WIN32
   static void SetSimultaneousAccepts(

package/src/headers/{14 → 24}/threadpoolwork-inl.h

@@ -24,23 +24,36 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "util-inl.h"
 #include "node_internals.h"
+#include "tracing/trace_event.h"
+#include "util-inl.h"
 
 namespace node {
 
 void ThreadPoolWork::ScheduleWork() {
   env_->IncreaseWaitingRequestCounter();
+  TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(
+      TRACING_CATEGORY_NODE2(threadpoolwork, async), type_, this);
   int status = uv_queue_work(
       env_->event_loop(),
       &work_req_,
       [](uv_work_t* req) {
         ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
+        TRACE_EVENT_BEGIN0(TRACING_CATEGORY_NODE2(threadpoolwork, sync),
+                           self->type_);
         self->DoThreadPoolWork();
+        TRACE_EVENT_END0(TRACING_CATEGORY_NODE2(threadpoolwork, sync),
+                         self->type_);
       },
       [](uv_work_t* req, int status) {
         ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
         self->env_->DecreaseWaitingRequestCounter();
+        TRACE_EVENT_NESTABLE_ASYNC_END1(
+            TRACING_CATEGORY_NODE2(threadpoolwork, async),
+            self->type_,
+            self,
+            "result",
+            status);
         self->AfterThreadPoolWork(status);
       });
   CHECK_EQ(status, 0);

package/src/headers/24/timer_wrap-inl.h

@@ -0,0 +1,32 @@
+#ifndef SRC_TIMER_WRAP_INL_H_
+#define SRC_TIMER_WRAP_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "timer_wrap.h"
+
+#include <utility>
+
+#include "env.h"
+#include "uv.h"
+
+namespace node {
+
+template <typename... Args>
+inline TimerWrap::TimerWrap(Environment* env, Args&&... args)
+    : env_(env), fn_(std::forward<Args>(args)...) {
+  uv_timer_init(env->event_loop(), &timer_);
+  timer_.data = this;
+}
+
+template <typename... Args>
+inline TimerWrapHandle::TimerWrapHandle(Environment* env, Args&&... args) {
+  timer_ = new TimerWrap(env, std::forward<Args>(args)...);
+  env->AddCleanupHook(CleanupHook, this);
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMER_WRAP_INL_H_

package/src/headers/{16 → 24}/timer_wrap.h

@@ -16,7 +16,9 @@ class TimerWrap final : public MemoryRetainer {
  public:
   using TimerCb = std::function<void()>;
 
-  TimerWrap(Environment* env, const TimerCb& fn);
+  template <typename... Args>
+  explicit inline TimerWrap(Environment* env, Args&&... args);
+
   TimerWrap(const TimerWrap&) = delete;
 
   inline Environment* env() const { return env_; }
@@ -50,9 +52,8 @@ class TimerWrap final : public MemoryRetainer {
 
 class TimerWrapHandle : public MemoryRetainer  {
  public:
-  TimerWrapHandle(
-      Environment* env,
-      const TimerWrap::TimerCb& fn);
+  template <typename... Args>
+  explicit inline TimerWrapHandle(Environment* env, Args&&... args);
 
   TimerWrapHandle(const TimerWrapHandle&) = delete;
 
@@ -60,6 +61,8 @@ class TimerWrapHandle : public MemoryRetainer  {
 
   void Update(uint64_t interval, uint64_t repeat = 0);
 
+  inline operator bool() const { return timer_ != nullptr; }
+
   void Ref();
   void Unref();