libv8-node 20.2.0.0-x86_64-linux → 21.7.2.0-x86_64-linux

data/vendor/v8/include/v8-persistent-handle.h

@@ -26,7 +26,7 @@ class PersistentValueMap;
 class Value;
 
 namespace api_internal {
-V8_EXPORT Value* Eternalize(v8::Isolate* isolate, Value* handle);
+V8_EXPORT internal::Address* Eternalize(v8::Isolate* isolate, Value* handle);
 V8_EXPORT internal::Address* CopyGlobalReference(internal::Address* from);
 V8_EXPORT void DisposeGlobal(internal::Address* global_handle);
 V8_EXPORT void MakeWeak(internal::Address** location_addr);
@@ -34,7 +34,7 @@ V8_EXPORT void* ClearWeak(internal::Address* location);
 V8_EXPORT void AnnotateStrongRetainer(internal::Address* location,
                                       const char* label);
 V8_EXPORT internal::Address* GlobalizeReference(internal::Isolate* isolate,
-                                                internal::Address* handle);
+                                                internal::Address value);
 V8_EXPORT void MoveGlobalReference(internal::Address** from,
                                    internal::Address** to);
 }  // namespace api_internal
@@ -44,35 +44,28 @@ V8_EXPORT void MoveGlobalReference(internal::Address** from,
  * isolate.
  */
 template <class T>
-class Eternal {
+class Eternal : public IndirectHandleBase {
  public:
-  V8_INLINE Eternal() : val_(nullptr) {}
+  V8_INLINE Eternal() = default;
+
   template <class S>
-  V8_INLINE Eternal(Isolate* isolate, Local<S> handle) : val_(nullptr) {
+  V8_INLINE Eternal(Isolate* isolate, Local<S> handle) {
     Set(isolate, handle);
   }
+
   // Can only be safely called if already set.
   V8_INLINE Local<T> Get(Isolate* isolate) const {
     // The eternal handle will never go away, so as with the roots, we don't
     // even need to open a handle.
-    return Local<T>(internal::ValueHelper::SlotAsValue<T>(val_));
+    return Local<T>::FromSlot(slot());
   }
 
-  V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
-
   template <class S>
   void Set(Isolate* isolate, Local<S> handle) {
     static_assert(std::is_base_of<T, S>::value, "type check");
-    val_ = reinterpret_cast<T*>(
-        api_internal::Eternalize(isolate, reinterpret_cast<Value*>(*handle)));
-  }
-
- private:
-  V8_INLINE internal::Address address() const {
-    return *reinterpret_cast<internal::Address*>(val_);
+    slot() =
+        api_internal::Eternalize(isolate, *handle.template UnsafeAs<Value>());
   }
-
-  T* val_;
 };
 
 namespace api_internal {
@@ -95,7 +88,7 @@ V8_EXPORT void MakeWeak(internal::Address* location, void* data,
  *
  */
 template <class T>
-class PersistentBase {
+class PersistentBase : public IndirectHandleBase {
  public:
   /**
    * If non-empty, destroy the underlying storage cell
@@ -117,9 +110,6 @@ class PersistentBase {
   template <class S>
   V8_INLINE void Reset(Isolate* isolate, const PersistentBase<S>& other);
 
-  V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
-  V8_INLINE void Empty() { val_ = 0; }
-
   V8_INLINE Local<T> Get(Isolate* isolate) const {
     return Local<T>::New(isolate, *this);
   }
@@ -217,18 +207,14 @@ class PersistentBase {
   template <class F1, class F2>
   friend class PersistentValueVector;
   friend class Object;
-  friend class internal::HandleHelper;
+  friend class internal::ValueHelper;
 
-  explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
-  V8_INLINE T* operator*() const { return this->val_; }
-  V8_INLINE internal::Address address() const {
-    return *reinterpret_cast<internal::Address*>(val_);
-  }
+  V8_INLINE PersistentBase() = default;
 
-  V8_INLINE static T* New(Isolate* isolate, Local<T> that);
-  V8_INLINE static T* New(Isolate* isolate, T* that);
+  V8_INLINE explicit PersistentBase(internal::Address* location)
+      : IndirectHandleBase(location) {}
 
-  T* val_;
+  V8_INLINE static internal::Address* New(Isolate* isolate, T* that);
 };
 
 /**
@@ -279,16 +265,17 @@ class Persistent : public PersistentBase<T> {
   /**
    * A Persistent with no storage cell.
    */
-  V8_INLINE Persistent() : PersistentBase<T>(nullptr) {}
+  V8_INLINE Persistent() = default;
+
   /**
    * Construct a Persistent from a Local.
    * When the Local is non-empty, a new storage cell is created
    * pointing to the same object, and no flags are set.
    */
-
   template <class S>
   V8_INLINE Persistent(Isolate* isolate, Local<S> that)
-      : PersistentBase<T>(PersistentBase<T>::New(isolate, that)) {
+      : PersistentBase<T>(
+            PersistentBase<T>::New(isolate, that.template value<S>())) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -299,20 +286,22 @@ class Persistent : public PersistentBase<T> {
    */
   template <class S, class M2>
   V8_INLINE Persistent(Isolate* isolate, const Persistent<S, M2>& that)
-      : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
+      : PersistentBase<T>(
+            PersistentBase<T>::New(isolate, that.template value<S>())) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
+
   /**
    * The copy constructors and assignment operator create a Persistent
    * exactly as the Persistent constructor, but the Copy function from the
    * traits class is called, allowing the setting of flags based on the
    * copied Persistent.
    */
-  V8_INLINE Persistent(const Persistent& that) : PersistentBase<T>(nullptr) {
+  V8_INLINE Persistent(const Persistent& that) : PersistentBase<T>() {
     Copy(that);
   }
   template <class S, class M2>
-  V8_INLINE Persistent(const Persistent<S, M2>& that) : PersistentBase<T>(0) {
+  V8_INLINE Persistent(const Persistent<S, M2>& that) : PersistentBase<T>() {
     Copy(that);
   }
   V8_INLINE Persistent& operator=(const Persistent& that) {
@@ -324,6 +313,7 @@ class Persistent : public PersistentBase<T> {
     Copy(that);
     return *this;
   }
+
   /**
    * The destructor will dispose the Persistent based on the
    * kResetInDestructor flags in the traits class.  Since not calling dispose
@@ -334,20 +324,21 @@ class Persistent : public PersistentBase<T> {
   }
 
   // TODO(dcarney): this is pretty useless, fix or remove
-  template <class S>
-  V8_INLINE static Persistent<T>& Cast(const Persistent<S>& that) {
+  template <class S, class M2>
+  V8_INLINE static Persistent<T, M>& Cast(const Persistent<S, M2>& that) {
 #ifdef V8_ENABLE_CHECKS
     // If we're going to perform the type check then we have to check
     // that the handle isn't empty before doing the checked cast.
-    if (!that.IsEmpty()) T::Cast(*that);
+    if (!that.IsEmpty()) T::Cast(that.template value<S>());
 #endif
-    return reinterpret_cast<Persistent<T>&>(const_cast<Persistent<S>&>(that));
+    return reinterpret_cast<Persistent<T, M>&>(
+        const_cast<Persistent<S, M2>&>(that));
   }
 
   // TODO(dcarney): this is pretty useless, fix or remove
-  template <class S>
-  V8_INLINE Persistent<S>& As() const {
-    return Persistent<S>::Cast(*this);
+  template <class S, class M2>
+  V8_INLINE Persistent<S, M2>& As() const {
+    return Persistent<S, M2>::Cast(*this);
   }
 
  private:
@@ -360,7 +351,6 @@ class Persistent : public PersistentBase<T> {
   template <class F>
   friend class ReturnValue;
 
-  explicit V8_INLINE Persistent(T* that) : PersistentBase<T>(that) {}
   template <class S, class M2>
   V8_INLINE void Copy(const Persistent<S, M2>& that);
 };
@@ -376,7 +366,7 @@ class Global : public PersistentBase<T> {
   /**
    * A Global with no storage cell.
    */
-  V8_INLINE Global() : PersistentBase<T>(nullptr) {}
+  V8_INLINE Global() = default;
 
   /**
    * Construct a Global from a Local.
@@ -385,7 +375,8 @@ class Global : public PersistentBase<T> {
    */
   template <class S>
   V8_INLINE Global(Isolate* isolate, Local<S> that)
-      : PersistentBase<T>(PersistentBase<T>::New(isolate, that)) {
+      : PersistentBase<T>(
+            PersistentBase<T>::New(isolate, that.template value<S>())) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -396,7 +387,8 @@ class Global : public PersistentBase<T> {
    */
   template <class S>
   V8_INLINE Global(Isolate* isolate, const PersistentBase<S>& that)
-      : PersistentBase<T>(PersistentBase<T>::New(isolate, that.val_)) {
+      : PersistentBase<T>(
+            PersistentBase<T>::New(isolate, that.template value<S>())) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -446,17 +438,11 @@ class V8_EXPORT PersistentHandleVisitor {
 };
 
 template <class T>
-T* PersistentBase<T>::New(Isolate* isolate, Local<T> that) {
-  return PersistentBase<T>::New(isolate,
-                                internal::ValueHelper::ValueAsSlot(*that));
-}
-
-template <class T>
-T* PersistentBase<T>::New(Isolate* isolate, T* that) {
-  if (that == nullptr) return nullptr;
-  internal::Address* p = reinterpret_cast<internal::Address*>(that);
-  return reinterpret_cast<T*>(api_internal::GlobalizeReference(
-      reinterpret_cast<internal::Isolate*>(isolate), p));
+internal::Address* PersistentBase<T>::New(Isolate* isolate, T* that) {
+  if (internal::ValueHelper::IsEmpty(that)) return nullptr;
+  return api_internal::GlobalizeReference(
+      reinterpret_cast<internal::Isolate*>(isolate),
+      internal::ValueHelper::ValueAsAddress(that));
 }
 
 template <class T, class M>
@@ -465,8 +451,7 @@ void Persistent<T, M>::Copy(const Persistent<S, M2>& that) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   this->Reset();
   if (that.IsEmpty()) return;
-  internal::Address* p = reinterpret_cast<internal::Address*>(that.val_);
-  this->val_ = reinterpret_cast<T*>(api_internal::CopyGlobalReference(p));
+  this->slot() = api_internal::CopyGlobalReference(that.slot());
   M::Copy(that, this);
 }
 
@@ -474,15 +459,14 @@ template <class T>
 bool PersistentBase<T>::IsWeak() const {
   using I = internal::Internals;
   if (this->IsEmpty()) return false;
-  return I::GetNodeState(reinterpret_cast<internal::Address*>(this->val_)) ==
-         I::kNodeStateIsWeakValue;
+  return I::GetNodeState(this->slot()) == I::kNodeStateIsWeakValue;
 }
 
 template <class T>
 void PersistentBase<T>::Reset() {
   if (this->IsEmpty()) return;
-  api_internal::DisposeGlobal(reinterpret_cast<internal::Address*>(this->val_));
-  val_ = nullptr;
+  api_internal::DisposeGlobal(this->slot());
+  this->Clear();
 }
 
 /**
@@ -495,7 +479,7 @@ void PersistentBase<T>::Reset(Isolate* isolate, const Local<S>& other) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   Reset();
   if (other.IsEmpty()) return;
-  this->val_ = New(isolate, internal::ValueHelper::ValueAsSlot(*other));
+  this->slot() = New(isolate, *other);
 }
 
 /**
@@ -509,7 +493,7 @@ void PersistentBase<T>::Reset(Isolate* isolate,
   static_assert(std::is_base_of<T, S>::value, "type check");
   Reset();
   if (other.IsEmpty()) return;
-  this->val_ = New(isolate, other.val_);
+  this->slot() = New(isolate, other.template value<S>());
 }
 
 template <class T>
@@ -522,8 +506,8 @@ V8_INLINE void PersistentBase<T>::SetWeak(
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
 #endif
-  api_internal::MakeWeak(reinterpret_cast<internal::Address*>(this->val_),
-                         parameter, reinterpret_cast<Callback>(callback), type);
+  api_internal::MakeWeak(this->slot(), parameter,
+                         reinterpret_cast<Callback>(callback), type);
 #if (__GNUC__ >= 8) && !defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
@@ -531,28 +515,25 @@ V8_INLINE void PersistentBase<T>::SetWeak(
 
 template <class T>
 void PersistentBase<T>::SetWeak() {
-  api_internal::MakeWeak(reinterpret_cast<internal::Address**>(&this->val_));
+  api_internal::MakeWeak(&this->slot());
 }
 
 template <class T>
 template <typename P>
 P* PersistentBase<T>::ClearWeak() {
-  return reinterpret_cast<P*>(api_internal::ClearWeak(
-      reinterpret_cast<internal::Address*>(this->val_)));
+  return reinterpret_cast<P*>(api_internal::ClearWeak(this->slot()));
 }
 
 template <class T>
 void PersistentBase<T>::AnnotateStrongRetainer(const char* label) {
-  api_internal::AnnotateStrongRetainer(
-      reinterpret_cast<internal::Address*>(this->val_), label);
+  api_internal::AnnotateStrongRetainer(this->slot(), label);
 }
 
 template <class T>
 void PersistentBase<T>::SetWrapperClassId(uint16_t class_id) {
   using I = internal::Internals;
   if (this->IsEmpty()) return;
-  internal::Address* obj = reinterpret_cast<internal::Address*>(this->val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
+  uint8_t* addr = reinterpret_cast<uint8_t*>(slot()) + I::kNodeClassIdOffset;
   *reinterpret_cast<uint16_t*>(addr) = class_id;
 }
 
@@ -560,18 +541,15 @@ template <class T>
 uint16_t PersistentBase<T>::WrapperClassId() const {
   using I = internal::Internals;
   if (this->IsEmpty()) return 0;
-  internal::Address* obj = reinterpret_cast<internal::Address*>(this->val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
+  uint8_t* addr = reinterpret_cast<uint8_t*>(slot()) + I::kNodeClassIdOffset;
   return *reinterpret_cast<uint16_t*>(addr);
 }
 
 template <class T>
-Global<T>::Global(Global&& other) : PersistentBase<T>(other.val_) {
-  if (other.val_ != nullptr) {
-    api_internal::MoveGlobalReference(
-        reinterpret_cast<internal::Address**>(&other.val_),
-        reinterpret_cast<internal::Address**>(&this->val_));
-    other.val_ = nullptr;
+Global<T>::Global(Global&& other) : PersistentBase<T>(other.slot()) {
+  if (!other.IsEmpty()) {
+    api_internal::MoveGlobalReference(&other.slot(), &this->slot());
+    other.Clear();
   }
 }
 
@@ -581,12 +559,10 @@ Global<T>& Global<T>::operator=(Global<S>&& rhs) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   if (this != &rhs) {
     this->Reset();
-    if (rhs.val_ != nullptr) {
-      this->val_ = rhs.val_;
-      api_internal::MoveGlobalReference(
-          reinterpret_cast<internal::Address**>(&rhs.val_),
-          reinterpret_cast<internal::Address**>(&this->val_));
-      rhs.val_ = nullptr;
+    if (!rhs.IsEmpty()) {
+      this->slot() = rhs.slot();
+      api_internal::MoveGlobalReference(&rhs.slot(), &this->slot());
+      rhs.Clear();
     }
   }
   return *this;

data/vendor/v8/include/v8-platform.h

@@ -13,6 +13,7 @@
 #include <memory>
 #include <string>
 
+#include "v8-source-location.h"  // NOLINT(build/include_directory)
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -39,6 +40,7 @@ enum class TaskPriority : uint8_t {
    * possible.
    */
   kUserBlocking,
+  kMaxPriority = kUserBlocking
 };
 
 /**
@@ -261,8 +263,12 @@ class JobTask {
    * Controls the maximum number of threads calling Run() concurrently, given
    * the number of threads currently assigned to this job and executing Run().
    * Run() is only invoked if the number of threads previously running Run() was
-   * less than the value returned. Since GetMaxConcurrency() is a leaf function,
-   * it must not call back any JobHandle methods.
+   * less than the value returned. In general, this should return the latest
+   * number of incomplete work items (smallest unit of work) left to process,
+   * including items that are currently in progress. |worker_count| is the
+   * number of threads currently assigned to this job which some callers may
+   * need to determine their return value. Since GetMaxConcurrency() is a leaf
+   * function, it must not call back any JobHandle methods.
    */
   virtual size_t GetMaxConcurrency(size_t worker_count) const = 0;
 };
@@ -566,6 +572,42 @@ class PageAllocator {
   virtual bool CanAllocateSharedPages() { return false; }
 };
 
+/**
+ * An allocator that uses per-thread permissions to protect the memory.
+ *
+ * The implementation is platform/hardware specific, e.g. using pkeys on x64.
+ *
+ * INTERNAL ONLY: This interface has not been stabilised and may change
+ * without notice from one release to another without being deprecated first.
+ */
+class ThreadIsolatedAllocator {
+ public:
+  virtual ~ThreadIsolatedAllocator() = default;
+
+  virtual void* Allocate(size_t size) = 0;
+
+  virtual void Free(void* object) = 0;
+
+  enum class Type {
+    kPkey,
+  };
+
+  virtual Type Type() const = 0;
+
+  /**
+   * Return the pkey used to implement the thread isolation if Type == kPkey.
+   */
+  virtual int Pkey() const { return -1; }
+
+  /**
+   * Per-thread permissions can be reset on signal handler entry. Even reading
+   * ThreadIsolated memory will segfault in that case.
+   * Call this function on signal handler entry to ensure that read permissions
+   * are restored.
+   */
+  static void SetDefaultPermissionsForSignalHandler();
+};
+
 // Opaque type representing a handle to a shared memory region.
 using PlatformSharedMemoryHandle = intptr_t;
 static constexpr PlatformSharedMemoryHandle kInvalidSharedMemoryHandle = -1;
@@ -969,6 +1011,16 @@ class Platform {
    */
   virtual PageAllocator* GetPageAllocator() = 0;
 
+  /**
+   * Allows the embedder to provide an allocator that uses per-thread memory
+   * permissions to protect allocations.
+   * Returning nullptr will cause V8 to disable protections that rely on this
+   * feature.
+   */
+  virtual ThreadIsolatedAllocator* GetThreadIsolatedAllocator() {
+    return nullptr;
+  }
+
   /**
    * Allows the embedder to specify a custom allocator used for zones.
    */
@@ -1000,40 +1052,80 @@ class Platform {
    * Returns a TaskRunner which can be used to post a task on the foreground.
    * The TaskRunner's NonNestableTasksEnabled() must be true. This function
    * should only be called from a foreground thread.
+   * TODO(chromium:1448758): Deprecate once |GetForegroundTaskRunner(Isolate*,
+   * TaskPriority)| is ready.
    */
   virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
-      Isolate* isolate) = 0;
+      Isolate* isolate) {
+    return GetForegroundTaskRunner(isolate, TaskPriority::kUserBlocking);
+  }
 
   /**
-   * Schedules a task to be invoked on a worker thread.
+   * Returns a TaskRunner with a specific |priority| which can be used to post a
+   * task on the foreground thread. The TaskRunner's NonNestableTasksEnabled()
+   * must be true. This function should only be called from a foreground thread.
+   * TODO(chromium:1448758): Make pure virtual once embedders implement it.
    */
-  virtual void CallOnWorkerThread(std::unique_ptr<Task> task) = 0;
+  virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
+      Isolate* isolate, TaskPriority priority) {
+    return nullptr;
+  }
+
+  /**
+   * Schedules a task to be invoked on a worker thread.
+   * Embedders should override PostTaskOnWorkerThreadImpl() instead of
+   * CallOnWorkerThread().
+   * TODO(chromium:1424158): Make non-virtual once embedders are migrated to
+   * PostTaskOnWorkerThreadImpl().
+   */
+  virtual void CallOnWorkerThread(std::unique_ptr<Task> task) {
+    PostTaskOnWorkerThreadImpl(TaskPriority::kUserVisible, std::move(task),
+                               SourceLocation::Current());
+  }
 
   /**
    * Schedules a task that blocks the main thread to be invoked with
    * high-priority on a worker thread.
+   * Embedders should override PostTaskOnWorkerThreadImpl() instead of
+   * CallBlockingTaskOnWorkerThread().
+   * TODO(chromium:1424158): Make non-virtual once embedders are migrated to
+   * PostTaskOnWorkerThreadImpl().
    */
   virtual void CallBlockingTaskOnWorkerThread(std::unique_ptr<Task> task) {
     // Embedders may optionally override this to process these tasks in a high
     // priority pool.
-    CallOnWorkerThread(std::move(task));
+    PostTaskOnWorkerThreadImpl(TaskPriority::kUserBlocking, std::move(task),
+                               SourceLocation::Current());
   }
 
   /**
    * Schedules a task to be invoked with low-priority on a worker thread.
+   * Embedders should override PostTaskOnWorkerThreadImpl() instead of
+   * CallLowPriorityTaskOnWorkerThread().
+   * TODO(chromium:1424158): Make non-virtual once embedders are migrated to
+   * PostTaskOnWorkerThreadImpl().
    */
   virtual void CallLowPriorityTaskOnWorkerThread(std::unique_ptr<Task> task) {
     // Embedders may optionally override this to process these tasks in a low
     // priority pool.
-    CallOnWorkerThread(std::move(task));
+    PostTaskOnWorkerThreadImpl(TaskPriority::kBestEffort, std::move(task),
+                               SourceLocation::Current());
   }
 
   /**
    * Schedules a task to be invoked on a worker thread after |delay_in_seconds|
    * expires.
+   * Embedders should override PostDelayedTaskOnWorkerThreadImpl() instead of
+   * CallDelayedOnWorkerThread().
+   * TODO(chromium:1424158): Make non-virtual once embedders are migrated to
+   * PostDelayedTaskOnWorkerThreadImpl().
    */
   virtual void CallDelayedOnWorkerThread(std::unique_ptr<Task> task,
-                                         double delay_in_seconds) = 0;
+                                         double delay_in_seconds) {
+    PostDelayedTaskOnWorkerThreadImpl(TaskPriority::kUserVisible,
+                                      std::move(task), delay_in_seconds,
+                                      SourceLocation::Current());
+  }
 
   /**
    * Returns true if idle tasks are enabled for the given |isolate|.
@@ -1083,6 +1175,9 @@ class Platform {
    * thread (A=>B/B=>A deadlock) and [2] JobTask::Run or
    * JobTask::GetMaxConcurrency may be invoked synchronously from JobHandle
    * (B=>JobHandle::foo=>B deadlock).
+   * Embedders should override CreateJobImpl() instead of PostJob().
+   * TODO(chromium:1424158): Make non-virtual once embedders are migrated to
+   * CreateJobImpl().
    */
   virtual std::unique_ptr<JobHandle> PostJob(
       TaskPriority priority, std::unique_ptr<JobTask> job_task) {
@@ -1103,9 +1198,16 @@ class Platform {
    *    return v8::platform::NewDefaultJobHandle(
    *        this, priority, std::move(job_task), NumberOfWorkerThreads());
    * }
+   *
+   * Embedders should override CreateJobImpl() instead of CreateJob().
+   * TODO(chromium:1424158): Make non-virtual once embedders are migrated to
+   * CreateJobImpl().
    */
   virtual std::unique_ptr<JobHandle> CreateJob(
-      TaskPriority priority, std::unique_ptr<JobTask> job_task) = 0;
+      TaskPriority priority, std::unique_ptr<JobTask> job_task) {
+    return CreateJobImpl(priority, std::move(job_task),
+                         SourceLocation::Current());
+  }
 
   /**
    * Instantiates a ScopedBlockingCall to annotate a scope that may/will block.
@@ -1183,6 +1285,35 @@ class Platform {
    * nothing special needed.
    */
   V8_EXPORT static double SystemClockTimeMillis();
+
+  /**
+   * Creates and returns a JobHandle associated with a Job.
+   * TODO(chromium:1424158): Make pure virtual once embedders implement it.
+   */
+  virtual std::unique_ptr<JobHandle> CreateJobImpl(
+      TaskPriority priority, std::unique_ptr<JobTask> job_task,
+      const SourceLocation& location) {
+    return nullptr;
+  }
+
+  /**
+   * Schedules a task with |priority| to be invoked on a worker thread.
+   * TODO(chromium:1424158): Make pure virtual once embedders implement it.
+   */
+  virtual void PostTaskOnWorkerThreadImpl(TaskPriority priority,
+                                          std::unique_ptr<Task> task,
+                                          const SourceLocation& location) {
+    CallOnWorkerThread(std::move(task));
+  }
+
+  /**
+   * Schedules a task with |priority| to be invoked on a worker thread after
+   * |delay_in_seconds| expires.
+   * TODO(chromium:1424158): Make pure virtual once embedders implement it.
+   */
+  virtual void PostDelayedTaskOnWorkerThreadImpl(
+      TaskPriority priority, std::unique_ptr<Task> task,
+      double delay_in_seconds, const SourceLocation& location) {}
 };
 
 }  // namespace v8

data/vendor/v8/include/v8-primitive.h

@@ -490,12 +490,6 @@ class V8_EXPORT String : public Name {
    */
   bool MakeExternal(ExternalOneByteStringResource* resource);
 
-  /**
-   * Returns true if this string can be made external.
-   */
-  V8_DEPRECATE_SOON("Use the version that takes an encoding as argument.")
-  bool CanMakeExternal() const;
-
   /**
    * Returns true if this string can be made external, given the encoding for
    * the external string resource.
@@ -644,10 +638,20 @@ class V8_EXPORT Symbol : public Name {
   static void CheckCast(Data* that);
 };
 
+/**
+ * A JavaScript numeric value (either Number or BigInt).
+ * https://tc39.es/ecma262/#sec-numeric-types
+ */
+class V8_EXPORT Numeric : public Primitive {
+ private:
+  Numeric();
+  static void CheckCast(v8::Data* that);
+};
+
 /**
  * A JavaScript number value (ECMA-262, 4.3.20)
  */
-class V8_EXPORT Number : public Primitive {
+class V8_EXPORT Number : public Numeric {
  public:
   double Value() const;
   static Local<Number> New(Isolate* isolate, double value);
@@ -722,7 +726,7 @@ class V8_EXPORT Uint32 : public Integer {
 /**
  * A JavaScript BigInt value (https://tc39.github.io/proposal-bigint)
  */
-class V8_EXPORT BigInt : public Primitive {
+class V8_EXPORT BigInt : public Numeric {
  public:
   static Local<BigInt> New(Isolate* isolate, int64_t value);
   static Local<BigInt> NewFromUnsigned(Isolate* isolate, uint64_t value);