libv8-node 18.13.0.0-x86_64-linux-musl → 19.9.0.0-x86_64-linux-musl

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

@@ -194,6 +194,11 @@ enum RAILMode : unsigned {
  */
 enum class MemoryPressureLevel { kNone, kModerate, kCritical };
 
+/**
+ * Indicator for the stack state.
+ */
+using StackState = cppgc::EmbedderStackState;
+
 /**
  * Isolate represents an isolated instance of the V8 engine.  V8 isolates have
  * completely separate states.  Objects from one isolate must not be used in
@@ -211,6 +216,8 @@ class V8_EXPORT Isolate {
     CreateParams();
     ~CreateParams();
 
+    ALLOW_COPY_AND_MOVE_WITH_DEPRECATED_FIELDS(CreateParams)
+
     /**
      * Allows the host application to provide the address of a function that is
      * notified each time code is added, moved or removed.
@@ -287,12 +294,6 @@ class V8_EXPORT Isolate {
      */
     FatalErrorCallback fatal_error_callback = nullptr;
     OOMErrorCallback oom_error_callback = nullptr;
-
-    /**
-     * The following parameter is experimental and may change significantly.
-     * This is currently for internal testing.
-     */
-    Isolate* experimental_attach_to_shared_isolate = nullptr;
   };
 
   /**
@@ -301,16 +302,18 @@ class V8_EXPORT Isolate {
    */
   class V8_EXPORT V8_NODISCARD Scope {
    public:
-    explicit Scope(Isolate* isolate) : isolate_(isolate) { isolate->Enter(); }
+    explicit Scope(Isolate* isolate) : v8_isolate_(isolate) {
+      v8_isolate_->Enter();
+    }
 
-    ~Scope() { isolate_->Exit(); }
+    ~Scope() { v8_isolate_->Exit(); }
 
     // Prevent copying of Scope objects.
     Scope(const Scope&) = delete;
     Scope& operator=(const Scope&) = delete;
 
    private:
-    Isolate* const isolate_;
+    Isolate* const v8_isolate_;
   };
 
   /**
@@ -331,7 +334,7 @@ class V8_EXPORT Isolate {
 
    private:
     OnFailure on_failure_;
-    Isolate* isolate_;
+    v8::Isolate* v8_isolate_;
 
     bool was_execution_allowed_assert_;
     bool was_execution_allowed_throws_;
@@ -353,7 +356,7 @@ class V8_EXPORT Isolate {
         const AllowJavascriptExecutionScope&) = delete;
 
    private:
-    Isolate* isolate_;
+    Isolate* v8_isolate_;
     bool was_execution_allowed_assert_;
     bool was_execution_allowed_throws_;
     bool was_execution_allowed_dump_;
@@ -376,7 +379,7 @@ class V8_EXPORT Isolate {
         const SuppressMicrotaskExecutionScope&) = delete;
 
    private:
-    internal::Isolate* const isolate_;
+    internal::Isolate* const i_isolate_;
     internal::MicrotaskQueue* const microtask_queue_;
     internal::Address previous_stack_height_;
 
@@ -389,7 +392,7 @@ class V8_EXPORT Isolate {
    */
   class V8_EXPORT V8_NODISCARD SafeForTerminationScope {
    public:
-    explicit SafeForTerminationScope(v8::Isolate* isolate);
+    explicit SafeForTerminationScope(v8::Isolate* v8_isolate);
     ~SafeForTerminationScope();
 
     // Prevent copying of Scope objects.
@@ -397,7 +400,7 @@ class V8_EXPORT Isolate {
     SafeForTerminationScope& operator=(const SafeForTerminationScope&) = delete;
 
    private:
-    internal::Isolate* isolate_;
+    internal::Isolate* i_isolate_;
     bool prev_value_;
   };
 
@@ -531,6 +534,9 @@ class V8_EXPORT Isolate {
     kInvalidatedMegaDOMProtector = 112,
     kFunctionPrototypeArguments = 113,
     kFunctionPrototypeCaller = 114,
+    kTurboFanOsrCompileStarted = 115,
+    kAsyncStackTaggingCreateTaskCall = 116,
+    kDurationFormat = 117,
 
     // If you add new values here, you'll also need to update Chromium's:
     // web_feature.mojom, use_counter_callback.cc, and enums.xml. V8 changes to
@@ -636,9 +642,6 @@ class V8_EXPORT Isolate {
    * This specifies the callback called by the upcoming dynamic
    * import() language feature to load modules.
    */
-  V8_DEPRECATED("Use HostImportModuleDynamicallyCallback")
-  void SetHostImportModuleDynamicallyCallback(
-      HostImportModuleDynamicallyWithImportAssertionsCallback callback);
   void SetHostImportModuleDynamicallyCallback(
       HostImportModuleDynamicallyCallback callback);
 
@@ -839,12 +842,6 @@ class V8_EXPORT Isolate {
    */
   int64_t AdjustAmountOfExternalAllocatedMemory(int64_t change_in_bytes);
 
-  /**
-   * Returns the number of phantom handles without callbacks that were reset
-   * by the garbage collector since the last call to this function.
-   */
-  size_t NumberOfPhantomHandleResetsSinceLastCall();
-
   /**
    * Returns heap profiler for this isolate. Will return NULL until the isolate
    * is initialized.
@@ -927,6 +924,7 @@ class V8_EXPORT Isolate {
   void RemoveGCPrologueCallback(GCCallbackWithData, void* data = nullptr);
   void RemoveGCPrologueCallback(GCCallback callback);
 
+  START_ALLOW_USE_DEPRECATED()
   /**
    * Sets the embedder heap tracer for the isolate.
    * SetEmbedderHeapTracer cannot be used simultaneously with AttachCppHeap.
@@ -938,6 +936,7 @@ class V8_EXPORT Isolate {
    * SetEmbedderHeapTracer.
    */
   EmbedderHeapTracer* GetEmbedderHeapTracer();
+  END_ALLOW_USE_DEPRECATED()
 
   /**
    * Sets an embedder roots handle that V8 should consider when performing
@@ -1163,9 +1162,8 @@ class V8_EXPORT Isolate {
    * LowMemoryNotification() instead to influence the garbage collection
    * schedule.
    */
-  void RequestGarbageCollectionForTesting(
-      GarbageCollectionType type,
-      EmbedderHeapTracer::EmbedderStackState stack_state);
+  void RequestGarbageCollectionForTesting(GarbageCollectionType type,
+                                          StackState stack_state);
 
   /**
    * Set the callback to invoke for logging event.
@@ -1523,15 +1521,15 @@ class V8_EXPORT Isolate {
 
   void SetWasmStreamingCallback(WasmStreamingCallback callback);
 
+  void SetWasmAsyncResolvePromiseCallback(
+      WasmAsyncResolvePromiseCallback callback);
+
   void SetWasmLoadSourceMapCallback(WasmLoadSourceMapCallback callback);
 
   void SetWasmSimdEnabledCallback(WasmSimdEnabledCallback callback);
 
   void SetWasmExceptionsEnabledCallback(WasmExceptionsEnabledCallback callback);
 
-  void SetWasmDynamicTieringEnabledCallback(
-      WasmDynamicTieringEnabledCallback callback);
-
   void SetSharedArrayBufferConstructorEnabledCallback(
       SharedArrayBufferConstructorEnabledCallback callback);
 
@@ -1598,19 +1596,6 @@ class V8_EXPORT Isolate {
    */
   void VisitExternalResources(ExternalResourceVisitor* visitor);
 
-  /**
-   * Iterates through all the persistent handles in the current isolate's heap
-   * that have class_ids.
-   */
-  void VisitHandlesWithClassIds(PersistentHandleVisitor* visitor);
-
-  /**
-   * Iterates through all the persistent handles in the current isolate's heap
-   * that have class_ids and are weak to be marked as inactive if there is no
-   * pending activity for the handle.
-   */
-  void VisitWeakHandles(PersistentHandleVisitor* visitor);
-
   /**
    * Check if this isolate is in use.
    * True if at least one thread Enter'ed this isolate.

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

@@ -86,7 +86,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   static int NumberOfHandles(Isolate* isolate);
 
   V8_INLINE Isolate* GetIsolate() const {
-    return reinterpret_cast<Isolate*>(isolate_);
+    return reinterpret_cast<Isolate*>(i_isolate_);
   }
 
   HandleScope(const HandleScope&) = delete;
@@ -97,7 +97,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
 
   void Initialize(Isolate* isolate);
 
-  static internal::Address* CreateHandle(internal::Isolate* isolate,
+  static internal::Address* CreateHandle(internal::Isolate* i_isolate,
                                          internal::Address value);
 
  private:
@@ -108,7 +108,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   void operator delete(void*, size_t);
   void operator delete[](void*, size_t);
 
-  internal::Isolate* isolate_;
+  internal::Isolate* i_isolate_;
   internal::Address* prev_next_;
   internal::Address* prev_limit_;
 
@@ -354,7 +354,7 @@ class MaybeLocal {
 
   /**
    * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty,
-   * |false| is returned and |out| is left untouched.
+   * |false| is returned and |out| is assigned with nullptr.
    */
   template <class S>
   V8_WARN_UNUSED_RESULT V8_INLINE bool ToLocal(Local<S>* out) const {
@@ -445,7 +445,7 @@ class V8_EXPORT V8_NODISCARD SealHandleScope {
   void operator delete(void*, size_t);
   void operator delete[](void*, size_t);
 
-  internal::Isolate* const isolate_;
+  internal::Isolate* const i_isolate_;
   internal::Address* prev_limit_;
   int prev_sealed_level_;
 };

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

@@ -121,17 +121,6 @@ class V8_EXPORT Locker {
    */
   static bool IsLocked(Isolate* isolate);
 
-  /**
-   * Returns whether any v8::Locker has ever been used in this process.
-   * TODO(cbruni, chromium:1240851): Fix locking checks on a per-thread basis.
-   * The current implementation is quite confusing and leads to unexpected
-   * results if anybody uses v8::Locker in the current process.
-   */
-  V8_DEPRECATE_SOON("This method will be removed.")
-  static bool WasEverUsed();
-  V8_DEPRECATED("Use WasEverUsed instead")
-  static bool IsActive();
-
   // Disallow copying and assigning.
   Locker(const Locker&) = delete;
   void operator=(const Locker&) = delete;

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

@@ -5,6 +5,9 @@
 #ifndef INCLUDE_V8_MAYBE_H_
 #define INCLUDE_V8_MAYBE_H_
 
+#include <type_traits>
+#include <utility>
+
 #include "v8-internal.h"  // NOLINT(build/include_directory)
 #include "v8config.h"     // NOLINT(build/include_directory)
 
@@ -57,11 +60,20 @@ class Maybe {
    * Converts this Maybe<> to a value of type T. If this Maybe<> is
    * nothing (empty), V8 will crash the process.
    */
-  V8_INLINE T FromJust() const {
+  V8_INLINE T FromJust() const& {
     if (V8_UNLIKELY(!IsJust())) api_internal::FromJustIsNothing();
     return value_;
   }
 
+  /**
+   * Converts this Maybe<> to a value of type T. If this Maybe<> is
+   * nothing (empty), V8 will crash the process.
+   */
+  V8_INLINE T FromJust() && {
+    if (V8_UNLIKELY(!IsJust())) api_internal::FromJustIsNothing();
+    return std::move(value_);
+  }
+
   /**
    * Converts this Maybe<> to a value of type T, using a default value if this
    * Maybe<> is nothing (empty).
@@ -82,6 +94,7 @@ class Maybe {
  private:
   Maybe() : has_value_(false) {}
   explicit Maybe(const T& t) : has_value_(true), value_(t) {}
+  explicit Maybe(T&& t) : has_value_(true), value_(std::move(t)) {}
 
   bool has_value_;
   T value_;
@@ -90,6 +103,8 @@ class Maybe {
   friend Maybe<U> Nothing();
   template <class U>
   friend Maybe<U> Just(const U& u);
+  template <class U, std::enable_if_t<!std::is_lvalue_reference_v<U>>*>
+  friend Maybe<U> Just(U&& u);
 };
 
 template <class T>
@@ -102,6 +117,14 @@ inline Maybe<T> Just(const T& t) {
   return Maybe<T>(t);
 }
 
+// Don't use forwarding references here but instead use two overloads.
+// Forwarding references only work when type deduction takes place, which is not
+// the case for callsites such as Just<Type>(t).
+template <class T, std::enable_if_t<!std::is_lvalue_reference_v<T>>* = nullptr>
+inline Maybe<T> Just(T&& t) {
+  return Maybe<T>(std::move(t));
+}
+
 // A template specialization of Maybe<T> for the case of T = void.
 template <>
 class Maybe<void> {

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

@@ -70,7 +70,7 @@ class V8_EXPORT ScriptOrigin {
                          bool resource_is_opaque = false, bool is_wasm = false,
                          bool is_module = false,
                          Local<Data> host_defined_options = Local<Data>())
-      : isolate_(isolate),
+      : v8_isolate_(isolate),
         resource_name_(resource_name),
         resource_line_offset_(resource_line_offset),
         resource_column_offset_(resource_column_offset),
@@ -87,14 +87,12 @@ class V8_EXPORT ScriptOrigin {
   V8_INLINE int ColumnOffset() const;
   V8_INLINE int ScriptId() const;
   V8_INLINE Local<Value> SourceMapUrl() const;
-  V8_DEPRECATE_SOON("Use GetHostDefinedOptions")
-  Local<PrimitiveArray> HostDefinedOptions() const;
   V8_INLINE Local<Data> GetHostDefinedOptions() const;
   V8_INLINE ScriptOriginOptions Options() const { return options_; }
 
  private:
   void VerifyHostDefinedOptions() const;
-  Isolate* isolate_;
+  Isolate* v8_isolate_;
   Local<Value> resource_name_;
   int resource_line_offset_;
   int resource_column_offset_;

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

@@ -125,31 +125,10 @@ struct WasmModuleInstantiated {
   int64_t wall_clock_duration_in_us = -1;
 };
 
-struct WasmModuleTieredUp {
-  bool lazy = false;
-  size_t code_size_in_bytes = 0;
-  int64_t wall_clock_duration_in_us = -1;
-  int64_t cpu_duration_in_us = -1;
-};
-
 struct WasmModulesPerIsolate {
   size_t count = 0;
 };
 
-#define V8_MAIN_THREAD_METRICS_EVENTS(V)                    \
-  V(GarbageCollectionFullCycle)                             \
-  V(GarbageCollectionFullMainThreadIncrementalMark)         \
-  V(GarbageCollectionFullMainThreadBatchedIncrementalMark)  \
-  V(GarbageCollectionFullMainThreadIncrementalSweep)        \
-  V(GarbageCollectionFullMainThreadBatchedIncrementalSweep) \
-  V(GarbageCollectionYoungCycle)                            \
-  V(WasmModuleDecoded)                                      \
-  V(WasmModuleCompiled)                                     \
-  V(WasmModuleInstantiated)                                 \
-  V(WasmModuleTieredUp)
-
-#define V8_THREAD_SAFE_METRICS_EVENTS(V) V(WasmModulesPerIsolate)
-
 /**
  * This class serves as a base class for recording event-based metrics in V8.
  * There a two kinds of metrics, those which are expected to be thread-safe and
@@ -159,19 +138,6 @@ struct WasmModulesPerIsolate {
  * background thread, it will be delayed and executed by the foreground task
  * runner.
  *
- * The thread-safe events are listed in the V8_THREAD_SAFE_METRICS_EVENTS
- * macro above while the main thread event are listed in
- * V8_MAIN_THREAD_METRICS_EVENTS above. For the former, a virtual method
- * AddMainThreadEvent(const E& event, v8::Context::Token token) will be
- * generated and for the latter AddThreadSafeEvent(const E& event).
- *
- * Thread-safe events are not allowed to access the context and therefore do
- * not carry a context ID with them. These IDs can be generated using
- * Recorder::GetContextId() and the ID will be valid throughout the lifetime
- * of the isolate. It is not guaranteed that the ID will still resolve to
- * a valid context using Recorder::GetContext() at the time the metric is
- * recorded. In this case, an empty handle will be returned.
- *
  * The embedder is expected to call v8::Isolate::SetMetricsRecorder()
  * providing its implementation and have the virtual methods overwritten
  * for the events it cares about.
@@ -202,14 +168,30 @@ class V8_EXPORT Recorder {
 
   virtual ~Recorder() = default;
 
+  // Main thread events. Those are only triggered on the main thread, and hence
+  // can access the context.
 #define ADD_MAIN_THREAD_EVENT(E) \
-  virtual void AddMainThreadEvent(const E& event, ContextId context_id) {}
-  V8_MAIN_THREAD_METRICS_EVENTS(ADD_MAIN_THREAD_EVENT)
+  virtual void AddMainThreadEvent(const E&, ContextId) {}
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullCycle)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadIncrementalMark)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadBatchedIncrementalMark)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadIncrementalSweep)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadBatchedIncrementalSweep)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionYoungCycle)
+  ADD_MAIN_THREAD_EVENT(WasmModuleDecoded)
+  ADD_MAIN_THREAD_EVENT(WasmModuleCompiled)
+  ADD_MAIN_THREAD_EVENT(WasmModuleInstantiated)
 #undef ADD_MAIN_THREAD_EVENT
 
+  // Thread-safe events are not allowed to access the context and therefore do
+  // not carry a context ID with them. These IDs can be generated using
+  // Recorder::GetContextId() and the ID will be valid throughout the lifetime
+  // of the isolate. It is not guaranteed that the ID will still resolve to
+  // a valid context using Recorder::GetContext() at the time the metric is
+  // recorded. In this case, an empty handle will be returned.
 #define ADD_THREAD_SAFE_EVENT(E) \
-  virtual void AddThreadSafeEvent(const E& event) {}
-  V8_THREAD_SAFE_METRICS_EVENTS(ADD_THREAD_SAFE_EVENT)
+  virtual void AddThreadSafeEvent(const E&) {}
+  ADD_THREAD_SAFE_EVENT(WasmModulesPerIsolate)
 #undef ADD_THREAD_SAFE_EVENT
 
   virtual void NotifyIsolateDisposal() {}

data/vendor/v8/include/v8-microtask-queue.h

@@ -142,7 +142,7 @@ class V8_EXPORT V8_NODISCARD MicrotasksScope {
   MicrotasksScope& operator=(const MicrotasksScope&) = delete;
 
  private:
-  internal::Isolate* const isolate_;
+  internal::Isolate* const i_isolate_;
   internal::MicrotaskQueue* const microtask_queue_;
   bool run_;
 };

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

@@ -594,8 +594,6 @@ class V8_EXPORT Object : public Value {
   /**
    * Returns the context in which the object was created.
    */
-  V8_DEPRECATED("Use MaybeLocal<Context> GetCreationContext()")
-  Local<Context> CreationContext();
   MaybeLocal<Context> GetCreationContext();
 
   /**
@@ -604,10 +602,6 @@ class V8_EXPORT Object : public Value {
   Local<Context> GetCreationContextChecked();
 
   /** Same as above, but works for Persistents */
-  V8_DEPRECATED(
-      "Use MaybeLocal<Context> GetCreationContext(const "
-      "PersistentBase<Object>& object)")
-  static Local<Context> CreationContext(const PersistentBase<Object>& object);
   V8_INLINE static MaybeLocal<Context> GetCreationContext(
       const PersistentBase<Object>& object) {
     return object.val_->GetCreationContext();
@@ -717,7 +711,7 @@ Local<Value> Object::GetInternalField(int index) {
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   int instance_type = I::GetInstanceType(obj);
-  if (v8::internal::CanHaveInternalField(instance_type)) {
+  if (I::CanHaveInternalField(instance_type)) {
     int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index);
     A value = I::ReadRawField<A>(obj, offset);
 #ifdef V8_COMPRESS_POINTERS
@@ -742,14 +736,13 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   auto instance_type = I::GetInstanceType(obj);
-  if (v8::internal::CanHaveInternalField(instance_type)) {
-    int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index);
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-    offset += I::kEmbedderDataSlotRawPayloadOffset;
-#endif
-    internal::Isolate* isolate = I::GetIsolateForSandbox(obj);
-    A value = I::ReadExternalPointerField(
-        isolate, obj, offset, internal::kEmbedderDataSlotPayloadTag);
+  if (I::CanHaveInternalField(instance_type)) {
+    int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) +
+                 I::kEmbedderDataSlotExternalPointerOffset;
+    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    A value =
+        I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+            isolate, obj, offset);
     return reinterpret_cast<void*>(value);
   }
 #endif

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

@@ -169,8 +169,6 @@ class PersistentBase {
    * Turns this handle into a weak phantom handle without finalization callback.
    * The handle will be reset automatically when the garbage collector detects
    * that the object is no longer reachable.
-   * A related function Isolate::NumberOfPhantomHandleResetsSinceLastCall
-   * returns how many phantom handles were reset by the garbage collector.
    */
   V8_INLINE void SetWeak();
 

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

@@ -158,9 +158,10 @@ class TaskRunner {
 class JobDelegate {
  public:
   /**
-   * Returns true if this thread should return from the worker task on the
+   * Returns true if this thread *must* return from the worker task on the
    * current thread ASAP. Workers should periodically invoke ShouldYield (or
    * YieldIfNeeded()) as often as is reasonable.
+   * After this method returned true, ShouldYield must not be called again.
    */
   virtual bool ShouldYield() = 0;
 
@@ -429,6 +430,17 @@ class PageAllocator {
   virtual bool SetPermissions(void* address, size_t length,
                               Permission permissions) = 0;
 
+  /**
+   * Recommits discarded pages in the given range with given permissions.
+   * Discarded pages must be recommitted with their original permissions
+   * before they are used again.
+   */
+  virtual bool RecommitPages(void* address, size_t length,
+                             Permission permissions) {
+    // TODO(v8:12797): make it pure once it's implemented on Chromium side.
+    return false;
+  }
+
   /**
    * Frees memory in the given [address, address + size) range. address and size
    * should be operating system page-aligned. The next write to this
@@ -698,6 +710,10 @@ class VirtualAddressSpace {
   /**
    * Sets permissions of all allocated pages in the given range.
    *
+   * This operation can fail due to OOM, in which case false is returned. If
+   * the operation fails for a reason other than OOM, this function will
+   * terminate the process as this implies a bug in the client.
+   *
    * \param address The start address of the range. Must be aligned to
    * page_size().
    *
@@ -706,7 +722,7 @@ class VirtualAddressSpace {
    *
    * \param permissions The new permissions for the range.
    *
-   * \returns true on success, false otherwise.
+   * \returns true on success, false on OOM.
    */
   virtual V8_WARN_UNUSED_RESULT bool SetPagePermissions(
       Address address, size_t size, PagePermissions permissions) = 0;
@@ -820,6 +836,24 @@ class VirtualAddressSpace {
   // takes a command enum as parameter.
   //
 
+  /**
+   * Recommits discarded pages in the given range with given permissions.
+   * Discarded pages must be recommitted with their original permissions
+   * before they are used again.
+   *
+   * \param address The start address of the range. Must be aligned to
+   * page_size().
+   *
+   * \param size The size in bytes of the range. Must be a multiple
+   * of page_size().
+   *
+   * \param permissions The permissions for the range that the pages must have.
+   *
+   * \returns true on success, false otherwise.
+   */
+  virtual V8_WARN_UNUSED_RESULT bool RecommitPages(
+      Address address, size_t size, PagePermissions permissions) = 0;
+
   /**
    * Frees memory in the given [address, address + size) range. address and
    * size should be aligned to the page_size(). The next write to this memory
@@ -890,10 +924,7 @@ class Platform {
   /**
    * Allows the embedder to manage memory page allocations.
    */
-  virtual PageAllocator* GetPageAllocator() {
-    // TODO(bbudge) Make this abstract after all embedders implement this.
-    return nullptr;
-  }
+  virtual PageAllocator* GetPageAllocator() = 0;
 
   /**
    * Allows the embedder to specify a custom allocator used for zones.
@@ -910,21 +941,7 @@ class Platform {
    * error.
    * Embedder overrides of this function must NOT call back into V8.
    */
-  virtual void OnCriticalMemoryPressure() {
-    // TODO(bbudge) Remove this when embedders override the following method.
-    // See crbug.com/634547.
-  }
-
-  /**
-   * Enables the embedder to respond in cases where V8 can't allocate large
-   * memory regions. The |length| parameter is the amount of memory needed.
-   * Returns true if memory is now available. Returns false if no memory could
-   * be made available. V8 will retry allocations until this method returns
-   * false.
-   *
-   * Embedder overrides of this function must NOT call back into V8.
-   */
-  virtual bool OnCriticalMemoryPressure(size_t length) { return false; }
+  virtual void OnCriticalMemoryPressure() {}
 
   /**
    * Gets the number of worker threads used by
@@ -1022,16 +1039,28 @@ 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).
+   */
+  virtual std::unique_ptr<JobHandle> PostJob(
+      TaskPriority priority, std::unique_ptr<JobTask> job_task) {
+    auto handle = CreateJob(priority, std::move(job_task));
+    handle->NotifyConcurrencyIncrease();
+    return handle;
+  }
+
+  /**
+   * Creates and returns a JobHandle associated with a Job. Unlike PostJob(),
+   * this doesn't immediately schedules |worker_task| to run; the Job is then
+   * scheduled by calling either NotifyConcurrencyIncrease() or Join().
    *
-   * A sufficient PostJob() implementation that uses the default Job provided in
-   * libplatform looks like:
-   *  std::unique_ptr<JobHandle> PostJob(
+   * A sufficient CreateJob() implementation that uses the default Job provided
+   * in libplatform looks like:
+   *  std::unique_ptr<JobHandle> CreateJob(
    *      TaskPriority priority, std::unique_ptr<JobTask> job_task) override {
    *    return v8::platform::NewDefaultJobHandle(
    *        this, priority, std::move(job_task), NumberOfWorkerThreads());
    * }
    */
-  virtual std::unique_ptr<JobHandle> PostJob(
+  virtual std::unique_ptr<JobHandle> CreateJob(
       TaskPriority priority, std::unique_ptr<JobTask> job_task) = 0;
 
   /**