@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/aliased_buffer.h

@@ -0,0 +1,206 @@
+#ifndef SRC_ALIASED_BUFFER_H_
+#define SRC_ALIASED_BUFFER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "memory_tracker.h"
+#include "v8.h"
+
+namespace node {
+
+typedef size_t AliasedBufferIndex;
+
+/**
+ * Do not use this class directly when creating instances of it - use the
+ * Aliased*Array defined at the end of this file instead.
+ *
+ * This class encapsulates the technique of having a native buffer mapped to
+ * a JS object. Writes to the native buffer can happen efficiently without
+ * going through JS, and the data is then available to user's via the exposed
+ * JS object.
+ *
+ * While this technique is computationally efficient, it is effectively a
+ * write to JS program state w/out going through the standard
+ * (monitored) API. Thus, any VM capabilities to detect the modification are
+ * circumvented.
+ *
+ * The encapsulation herein provides a placeholder where such writes can be
+ * observed. Any notification APIs will be left as a future exercise.
+ */
+template <class NativeT, class V8T>
+class AliasedBufferBase final : public MemoryRetainer {
+ public:
+  static_assert(std::is_scalar_v<NativeT>);
+
+  AliasedBufferBase(v8::Isolate* isolate,
+                    size_t count,
+                    const AliasedBufferIndex* index = nullptr);
+
+  /**
+   * Create an AliasedBufferBase over a sub-region of another aliased buffer.
+   * The two will share a v8::ArrayBuffer instance &
+   * a native buffer, but will each read/write to different sections of the
+   * native buffer.
+   *
+   *  Note that byte_offset must be aligned by sizeof(NativeT).
+   */
+  // TODO(refack): refactor into a non-owning `AliasedBufferBaseView`
+  AliasedBufferBase(
+      v8::Isolate* isolate,
+      size_t byte_offset,
+      size_t count,
+      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer,
+      const AliasedBufferIndex* index = nullptr);
+
+  AliasedBufferBase(const AliasedBufferBase& that);
+
+  AliasedBufferIndex Serialize(v8::Local<v8::Context> context,
+                               v8::SnapshotCreator* creator);
+
+  void Deserialize(v8::Local<v8::Context> context);
+
+  AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept;
+
+  /**
+   * Helper class that is returned from operator[] to support assignment into
+   * a specified location.
+   */
+  class Reference {
+   public:
+    Reference(AliasedBufferBase* aliased_buffer, const size_t index)
+        : aliased_buffer_(aliased_buffer), index_(index) {}
+
+    Reference(const Reference& that)
+        : aliased_buffer_(that.aliased_buffer_),
+          index_(that.index_) {
+    }
+
+    Reference& operator=(const NativeT& val) {
+      aliased_buffer_->SetValue(index_, val);
+      return *this;
+    }
+
+    Reference& operator=(const Reference& val) {
+      return *this = static_cast<NativeT>(val);
+    }
+
+    operator NativeT() const {
+      return aliased_buffer_->GetValue(index_);
+    }
+
+    Reference& operator+=(const NativeT& val) {
+      const NativeT current = aliased_buffer_->GetValue(index_);
+      aliased_buffer_->SetValue(index_, current + val);
+      return *this;
+    }
+
+    Reference& operator+=(const Reference& val) {
+      return this->operator+=(static_cast<NativeT>(val));
+    }
+
+    Reference& operator-=(const NativeT& val) {
+      const NativeT current = aliased_buffer_->GetValue(index_);
+      aliased_buffer_->SetValue(index_, current - val);
+      return *this;
+    }
+
+   private:
+    AliasedBufferBase* aliased_buffer_;
+    size_t index_;
+  };
+
+  /**
+   *  Get the underlying v8 TypedArray overlaid on top of the native buffer
+   */
+  v8::Local<V8T> GetJSArray() const;
+
+  void Release();
+
+  /**
+   * Make the global reference to the typed array weak. The caller must make
+   * sure that no operation can be done on the AliasedBuffer when the typed
+   * array becomes unreachable. Usually this means the caller must maintain
+   * a JS reference to the typed array from JS object.
+   */
+  void MakeWeak();
+
+  /**
+  *  Get the underlying v8::ArrayBuffer underlying the TypedArray and
+  *  overlaying the native buffer
+  */
+  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const;
+
+  /**
+   *  Get the underlying native buffer. Note that all reads/writes should occur
+   *  through the GetValue/SetValue/operator[] methods
+   */
+  const NativeT* GetNativeBuffer() const;
+
+  /**
+   *  Synonym for GetBuffer()
+   */
+  const NativeT* operator*() const;
+
+  /**
+   *  Set position index to given value.
+   */
+  void SetValue(size_t index, NativeT value);
+
+  /**
+   *  Get value at position index
+   */
+  const NativeT GetValue(size_t index) const;
+
+  /**
+   *  Effectively, a synonym for GetValue/SetValue
+   */
+  Reference operator[](size_t index);
+
+  NativeT operator[](size_t index) const;
+
+  size_t Length() const;
+
+  // Should only be used to extend the array.
+  // Should only be used on an owning array, not one created as a sub array of
+  // an owning `AliasedBufferBase`.
+  void reserve(size_t new_capacity);
+
+  size_t SelfSize() const override;
+
+  const char* MemoryInfoName() const override;
+  void MemoryInfo(MemoryTracker* tracker) const override;
+
+ private:
+  bool is_valid() const;
+  v8::Isolate* isolate_ = nullptr;
+  size_t count_ = 0;
+  size_t byte_offset_ = 0;
+  NativeT* buffer_ = nullptr;
+  v8::Global<V8T> js_array_;
+
+  // Deserialize data
+  const AliasedBufferIndex* index_ = nullptr;
+};
+
+#define ALIASED_BUFFER_LIST(V)                                                 \
+  V(int8_t, Int8Array)                                                         \
+  V(uint8_t, Uint8Array)                                                       \
+  V(int16_t, Int16Array)                                                       \
+  V(uint16_t, Uint16Array)                                                     \
+  V(int32_t, Int32Array)                                                       \
+  V(uint32_t, Uint32Array)                                                     \
+  V(float, Float32Array)                                                       \
+  V(double, Float64Array)                                                      \
+  V(int64_t, BigInt64Array)
+
+#define V(NativeT, V8T)                                                        \
+  typedef AliasedBufferBase<NativeT, v8::V8T> Aliased##V8T;
+ALIASED_BUFFER_LIST(V)
+#undef V
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ALIASED_BUFFER_H_

package/src/headers/24/amaro_version.h

@@ -0,0 +1,6 @@
+// This is an auto generated file, please do not edit.
+// Refer to tools/dep_updaters/update-amaro.sh
+#ifndef SRC_AMARO_VERSION_H_
+#define SRC_AMARO_VERSION_H_
+#define AMARO_VERSION "1.1.1"
+#endif  // SRC_AMARO_VERSION_H_

package/src/headers/24/application.h

@@ -0,0 +1,165 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include "base_object.h"
+#include "bindingdata.h"
+#include "defs.h"
+#include "session.h"
+#include "sessionticket.h"
+#include "streams.h"
+
+namespace node::quic {
+
+// An Application implements the ALPN-protocol specific semantics on behalf
+// of a QUIC Session.
+class Session::Application : public MemoryRetainer {
+ public:
+  using Options = Session::Application_Options;
+
+  Application(Session* session, const Options& options);
+  DISALLOW_COPY_AND_MOVE(Application)
+
+  virtual bool Start();
+
+  // Session will forward all received stream data immediately on to the
+  // Application. The only additional processing the Session does is to
+  // automatically adjust the session-level flow control window. It is up to
+  // the Application to do the same for the Stream-level flow control.
+  virtual bool ReceiveStreamData(int64_t stream_id,
+                                 const uint8_t* data,
+                                 size_t datalen,
+                                 const Stream::ReceiveDataFlags& flags,
+                                 void* stream_user_data) = 0;
+
+  // Session will forward all data acknowledgements for a stream to the
+  // Application.
+  virtual bool AcknowledgeStreamData(int64_t stream_id, size_t datalen);
+
+  // Called to determine if a Header can be added to this application.
+  // Applications that do not support headers will always return false.
+  virtual bool CanAddHeader(size_t current_count,
+                            size_t current_headers_length,
+                            size_t this_header_length);
+
+  // Called to mark the identified stream as being blocked. Not all
+  // Application types will support blocked streams, and those that do will do
+  // so differently.
+  virtual void BlockStream(int64_t id);
+
+  // Called when the session determines that there is outbound data available
+  // to send for the given stream.
+  virtual void ResumeStream(int64_t id);
+
+  // Called when the Session determines that the maximum number of
+  // remotely-initiated unidirectional streams has been extended. Not all
+  // Application types will require this notification so the default is to do
+  // nothing.
+  virtual void ExtendMaxStreams(EndpointLabel label,
+                                Direction direction,
+                                uint64_t max_streams);
+
+  // Called when the Session determines that the flow control window for the
+  // given stream has been expanded. Not all Application types will require
+  // this notification so the default is to do nothing.
+  virtual void ExtendMaxStreamData(Stream* stream, uint64_t max_data);
+
+  // Different Applications may wish to set some application data in the
+  // session ticket (e.g. http/3 would set server settings in the application
+  // data). By default, there's nothing to set.
+  virtual void CollectSessionTicketAppData(
+      SessionTicket::AppData* app_data) const;
+
+  // Different Applications may set some application data in the session
+  // ticket (e.g. http/3 would set server settings in the application data).
+  // By default, there's nothing to get.
+  virtual SessionTicket::AppData::Status ExtractSessionTicketAppData(
+      const SessionTicket::AppData& app_data,
+      SessionTicket::AppData::Source::Flag flag);
+
+  // Notifies the Application that the identified stream has been closed.
+  virtual void StreamClose(Stream* stream, QuicError&& error = QuicError());
+
+  // Notifies the Application that the identified stream has been reset.
+  virtual void StreamReset(Stream* stream,
+                           uint64_t final_size,
+                           QuicError&& error = QuicError());
+
+  // Notifies the Application that the identified stream should stop sending.
+  virtual void StreamStopSending(Stream* stream,
+                                 QuicError&& error = QuicError());
+
+  // Submits an outbound block of headers for the given stream. Not all
+  // Application types will support headers, in which case this function
+  // should return false.
+  virtual bool SendHeaders(const Stream& stream,
+                           HeadersKind kind,
+                           const v8::Local<v8::Array>& headers,
+                           HeadersFlags flags = HeadersFlags::NONE);
+
+  // Signals to the Application that it should serialize and transmit any
+  // pending session and stream packets it has accumulated.
+  void SendPendingData();
+
+  // Set the priority level of the stream if supported by the application. Not
+  // all applications support priorities, in which case this function is a
+  // non-op.
+  virtual void SetStreamPriority(
+      const Stream& stream,
+      StreamPriority priority = StreamPriority::DEFAULT,
+      StreamPriorityFlags flags = StreamPriorityFlags::NONE);
+
+  // Get the priority level of the stream if supported by the application. Not
+  // all applications support priorities, in which case this function returns
+  // the default stream priority.
+  virtual StreamPriority GetStreamPriority(const Stream& stream);
+
+  struct StreamData;
+
+  virtual int GetStreamData(StreamData* data) = 0;
+  virtual bool StreamCommit(StreamData* data, size_t datalen) = 0;
+  virtual bool ShouldSetFin(const StreamData& data) = 0;
+
+  inline Environment* env() const { return session_->env(); }
+  inline Session& session() { return *session_; }
+  inline const Session& session() const { return *session_; }
+
+ private:
+  BaseObjectPtr<Packet> CreateStreamDataPacket();
+
+  // Write the given stream_data into the buffer.
+  ssize_t WriteVStream(PathStorage* path,
+                       uint8_t* buf,
+                       ssize_t* ndatalen,
+                       size_t max_packet_size,
+                       const StreamData& stream_data);
+
+  Session* session_;
+};
+
+struct Session::Application::StreamData final {
+  // The actual number of vectors in the struct, up to kMaxVectorCount.
+  size_t count = 0;
+  size_t remaining = 0;
+  // The stream identifier. If this is a negative value then no stream is
+  // identified.
+  int64_t id = -1;
+  int fin = 0;
+  ngtcp2_vec data[kMaxVectorCount]{};
+  BaseObjectPtr<Stream> stream;
+
+  inline operator nghttp3_vec*() {
+    return reinterpret_cast<nghttp3_vec*>(data);
+  }
+
+  inline operator const ngtcp2_vec*() const { return data; }
+  inline operator ngtcp2_vec*() { return data; }
+
+  std::string ToString() const;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/async_context_frame.h

@@ -0,0 +1,33 @@
+#ifndef SRC_ASYNC_CONTEXT_FRAME_H_
+#define SRC_ASYNC_CONTEXT_FRAME_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "v8.h"
+
+#include <cstdint>
+
+namespace node {
+namespace async_context_frame {
+
+class Scope {
+ public:
+  explicit Scope(v8::Isolate* isolate, v8::Local<v8::Value> object);
+  ~Scope();
+
+ private:
+  v8::Isolate* isolate_;
+  v8::Global<v8::Value> prior_;
+};
+
+v8::Local<v8::Value> current(v8::Isolate* isolate);
+void set(v8::Isolate* isolate, v8::Local<v8::Value> value);
+v8::Local<v8::Value> exchange(v8::Isolate* isolate, v8::Local<v8::Value> value);
+
+}  // namespace async_context_frame
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ASYNC_CONTEXT_FRAME_H_

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

@@ -49,6 +49,9 @@ inline double AsyncWrap::get_trigger_async_id() const {
   return trigger_async_id_;
 }
 
+inline v8::Local<v8::Value> AsyncWrap::context_frame() const {
+  return context_frame_.Get(env()->isolate());
+}
 
 inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
     const v8::Local<v8::String> symbol,
@@ -80,12 +83,11 @@ inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
   return MakeCallback(cb_v.As<v8::Function>(), argc, argv);
 }
 
-
-// Defined here to avoid a circular dependency with env-inl.h.
-inline AsyncHooks::DefaultTriggerAsyncIdScope ::DefaultTriggerAsyncIdScope(
-    AsyncWrap* async_wrap)
-    : DefaultTriggerAsyncIdScope(async_wrap->env(),
-                                 async_wrap->get_async_id()) {}
+// static
+inline v8::Local<v8::FunctionTemplate> AsyncWrap::GetConstructorTemplate(
+    Environment* env) {
+  return GetConstructorTemplate(env->isolate_data());
+}
 
 }  // namespace node
 

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

@@ -31,82 +31,84 @@
 
 namespace node {
 
-#define NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                               \
-  V(NONE)                                                                     \
-  V(DIRHANDLE)                                                                \
-  V(DNSCHANNEL)                                                               \
-  V(ELDHISTOGRAM)                                                             \
-  V(FILEHANDLE)                                                               \
-  V(FILEHANDLECLOSEREQ)                                                       \
-  V(FIXEDSIZEBLOBCOPY)                                                        \
-  V(FSEVENTWRAP)                                                              \
-  V(FSREQCALLBACK)                                                            \
-  V(FSREQPROMISE)                                                             \
-  V(GETADDRINFOREQWRAP)                                                       \
-  V(GETNAMEINFOREQWRAP)                                                       \
-  V(HEAPSNAPSHOT)                                                             \
-  V(HTTP2SESSION)                                                             \
-  V(HTTP2STREAM)                                                              \
-  V(HTTP2PING)                                                                \
-  V(HTTP2SETTINGS)                                                            \
-  V(HTTPINCOMINGMESSAGE)                                                      \
-  V(HTTPCLIENTREQUEST)                                                        \
-  V(JSSTREAM)                                                                 \
-  V(JSUDPWRAP)                                                                \
-  V(MESSAGEPORT)                                                              \
-  V(PIPECONNECTWRAP)                                                          \
-  V(PIPESERVERWRAP)                                                           \
-  V(PIPEWRAP)                                                                 \
-  V(PROCESSWRAP)                                                              \
-  V(PROMISE)                                                                  \
-  V(QUERYWRAP)                                                                \
-  V(SHUTDOWNWRAP)                                                             \
-  V(SIGNALWRAP)                                                               \
-  V(STATWATCHER)                                                              \
-  V(STREAMPIPE)                                                               \
-  V(TCPCONNECTWRAP)                                                           \
-  V(TCPSERVERWRAP)                                                            \
-  V(TCPWRAP)                                                                  \
-  V(TTYWRAP)                                                                  \
-  V(UDPSENDWRAP)                                                              \
-  V(UDPWRAP)                                                                  \
-  V(SIGINTWATCHDOG)                                                           \
-  V(WORKER)                                                                   \
-  V(WORKERHEAPSNAPSHOT)                                                       \
-  V(WRITEWRAP)                                                                \
+#define NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                                \
+  V(NONE)                                                                      \
+  V(DIRHANDLE)                                                                 \
+  V(DNSCHANNEL)                                                                \
+  V(ELDHISTOGRAM)                                                              \
+  V(FILEHANDLE)                                                                \
+  V(FILEHANDLECLOSEREQ)                                                        \
+  V(BLOBREADER)                                                                \
+  V(FSEVENTWRAP)                                                               \
+  V(FSREQCALLBACK)                                                             \
+  V(FSREQPROMISE)                                                              \
+  V(GETADDRINFOREQWRAP)                                                        \
+  V(GETNAMEINFOREQWRAP)                                                        \
+  V(HEAPSNAPSHOT)                                                              \
+  V(HTTP2SESSION)                                                              \
+  V(HTTP2STREAM)                                                               \
+  V(HTTP2PING)                                                                 \
+  V(HTTP2SETTINGS)                                                             \
+  V(HTTPINCOMINGMESSAGE)                                                       \
+  V(HTTPCLIENTREQUEST)                                                         \
+  V(LOCKS)                                                                     \
+  V(JSSTREAM)                                                                  \
+  V(JSUDPWRAP)                                                                 \
+  V(MESSAGEPORT)                                                               \
+  V(PIPECONNECTWRAP)                                                           \
+  V(PIPESERVERWRAP)                                                            \
+  V(PIPEWRAP)                                                                  \
+  V(PROCESSWRAP)                                                               \
+  V(PROMISE)                                                                   \
+  V(QUERYWRAP)                                                                 \
+  V(QUIC_ENDPOINT)                                                             \
+  V(QUIC_LOGSTREAM)                                                            \
+  V(QUIC_PACKET)                                                               \
+  V(QUIC_SESSION)                                                              \
+  V(QUIC_STREAM)                                                               \
+  V(QUIC_UDP)                                                                  \
+  V(SHUTDOWNWRAP)                                                              \
+  V(SIGNALWRAP)                                                                \
+  V(STATWATCHER)                                                               \
+  V(STREAMPIPE)                                                                \
+  V(TCPCONNECTWRAP)                                                            \
+  V(TCPSERVERWRAP)                                                             \
+  V(TCPWRAP)                                                                   \
+  V(TTYWRAP)                                                                   \
+  V(UDPSENDWRAP)                                                               \
+  V(UDPWRAP)                                                                   \
+  V(SIGINTWATCHDOG)                                                            \
+  V(WORKER)                                                                    \
+  V(WORKERCPUUSAGE)                                                            \
+  V(WORKERHEAPSNAPSHOT)                                                        \
+  V(WORKERHEAPSTATISTICS)                                                      \
+  V(WRITEWRAP)                                                                 \
   V(ZLIB)
 
 #if HAVE_OPENSSL
-#define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)                                   \
-  V(CHECKPRIMEREQUEST)                                                        \
-  V(PBKDF2REQUEST)                                                            \
-  V(KEYPAIRGENREQUEST)                                                        \
-  V(KEYGENREQUEST)                                                            \
-  V(KEYEXPORTREQUEST)                                                         \
-  V(CIPHERREQUEST)                                                            \
-  V(DERIVEBITSREQUEST)                                                        \
-  V(HASHREQUEST)                                                              \
-  V(RANDOMBYTESREQUEST)                                                       \
-  V(RANDOMPRIMEREQUEST)                                                       \
-  V(SCRYPTREQUEST)                                                            \
-  V(SIGNREQUEST)                                                              \
-  V(TLSWRAP)                                                                  \
+#define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)                                    \
+  V(CHECKPRIMEREQUEST)                                                         \
+  V(PBKDF2REQUEST)                                                             \
+  V(KEYPAIRGENREQUEST)                                                         \
+  V(KEYGENREQUEST)                                                             \
+  V(KEYEXPORTREQUEST)                                                          \
+  V(ARGON2REQUEST)                                                             \
+  V(CIPHERREQUEST)                                                             \
+  V(DERIVEBITSREQUEST)                                                         \
+  V(HASHREQUEST)                                                               \
+  V(RANDOMBYTESREQUEST)                                                        \
+  V(RANDOMPRIMEREQUEST)                                                        \
+  V(SCRYPTREQUEST)                                                             \
+  V(SIGNREQUEST)                                                               \
+  V(TLSWRAP)                                                                   \
   V(VERIFYREQUEST)
 #else
 #define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)
 #endif  // HAVE_OPENSSL
 
-#if HAVE_INSPECTOR
-#define NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)                                \
-  V(INSPECTORJSBINDING)
-#else
-#define NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)
-#endif  // HAVE_INSPECTOR
-
-#define NODE_ASYNC_PROVIDER_TYPES(V)                                          \
-  NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                                     \
-  NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)                                         \
-  NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)
+#define NODE_ASYNC_PROVIDER_TYPES(V)                                           \
+  NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                                      \
+  NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)
 
 class Environment;
 class DestroyParam;
@@ -138,13 +140,17 @@ class AsyncWrap : public BaseObject {
   static constexpr double kInvalidAsyncId = -1;
 
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      IsolateData* isolate_data);
+  inline static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
 
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context,
-                         void* priv);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
 
   static void GetAsyncId(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void PushAsyncContext(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -173,6 +179,7 @@ class AsyncWrap : public BaseObject {
 
   void EmitDestroy(bool from_gc = false);
 
+  void EmitTraceAsyncStart() const;
   void EmitTraceEventBefore();
   static void EmitTraceEventAfter(ProviderType type, double async_id);
   void EmitTraceEventDestroy();
@@ -185,9 +192,10 @@ class AsyncWrap : public BaseObject {
   inline double get_async_id() const;
   inline double get_trigger_async_id() const;
 
+  inline v8::Local<v8::Value> context_frame() const;
+
   void AsyncReset(v8::Local<v8::Object> resource,
-                  double execution_async_id = kInvalidAsyncId,
-                  bool silent = false);
+                  double execution_async_id = kInvalidAsyncId);
 
   // Only call these within a valid HandleScope.
   v8::MaybeLocal<v8::Value> MakeCallback(const v8::Local<v8::Function> cb,
@@ -207,7 +215,7 @@ class AsyncWrap : public BaseObject {
       v8::Local<v8::Value>* argv);
 
   virtual std::string diagnostic_name() const;
-  std::string MemoryInfoName() const override;
+  const char* MemoryInfoName() const override;
 
   static void WeakCallback(const v8::WeakCallbackInfo<DestroyParam> &info);
 
@@ -220,23 +228,13 @@ class AsyncWrap : public BaseObject {
   bool IsDoneInitializing() const override;
 
  private:
-  friend class PromiseWrap;
-
-  AsyncWrap(Environment* env,
-            v8::Local<v8::Object> promise,
-            ProviderType provider,
-            double execution_async_id,
-            bool silent);
-  AsyncWrap(Environment* env,
-            v8::Local<v8::Object> promise,
-            ProviderType provider,
-            double execution_async_id,
-            double trigger_async_id);
   ProviderType provider_type_ = PROVIDER_NONE;
   bool init_hook_ran_ = false;
   // Because the values may be Reset(), cannot be made const.
   double async_id_ = kInvalidAsyncId;
-  double trigger_async_id_;
+  double trigger_async_id_ = kInvalidAsyncId;
+
+  v8::Global<v8::Value> context_frame_;
 };
 
 }  // namespace node