diff --git a/deps/v8/include/v8-internal.h b/deps/v8/include/v8-internal.h
index f289149d8d06e2..5f0177182b598f 100644
--- a/deps/v8/include/v8-internal.h
+++ b/deps/v8/include/v8-internal.h
@@ -33,7 +33,6 @@ const int kApiSystemPointerSize = sizeof(void*);
 const int kApiDoubleSize = sizeof(double);
 const int kApiInt32Size = sizeof(int32_t);
 const int kApiInt64Size = sizeof(int64_t);
-const int kApiSizetSize = sizeof(size_t);
 
 // Tag information for HeapObject.
 const int kHeapObjectTag = 1;
@@ -230,12 +229,8 @@ class Internals {
       kIsolateFastCCallCallerFpOffset + kApiSystemPointerSize;
   static const int kIsolateFastApiCallTargetOffset =
       kIsolateFastCCallCallerPcOffset + kApiSystemPointerSize;
-  static const int kIsolateCageBaseOffset =
-      kIsolateFastApiCallTargetOffset + kApiSystemPointerSize;
-  static const int kIsolateLongTaskStatsCounterOffset =
-      kIsolateCageBaseOffset + kApiSystemPointerSize;
   static const int kIsolateStackGuardOffset =
-      kIsolateLongTaskStatsCounterOffset + kApiSizetSize;
+      kIsolateFastApiCallTargetOffset + kApiSystemPointerSize;
   static const int kIsolateRootsOffset =
       kIsolateStackGuardOffset + 7 * kApiSystemPointerSize;
 
@@ -368,12 +363,6 @@ class Internals {
     return *reinterpret_cast<void* const*>(addr);
   }
 
-  V8_INLINE static void IncrementLongTasksStatsCounter(v8::Isolate* isolate) {
-    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
-                             kIsolateLongTaskStatsCounterOffset;
-    ++(*reinterpret_cast<size_t*>(addr));
-  }
-
   V8_INLINE static internal::Address* GetRoot(v8::Isolate* isolate, int index) {
     internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
                              kIsolateRootsOffset +
diff --git a/deps/v8/include/v8-metrics.h b/deps/v8/include/v8-metrics.h
index 2404cc0a4c30d4..0217f40d63a629 100644
--- a/deps/v8/include/v8-metrics.h
+++ b/deps/v8/include/v8-metrics.h
@@ -5,8 +5,7 @@
 #ifndef V8_METRICS_H_
 #define V8_METRICS_H_
 
-#include "v8-internal.h"  // NOLINT(build/include_directory)
-#include "v8.h"           // NOLINT(build/include_directory)
+#include "v8.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
 namespace metrics {
@@ -184,32 +183,6 @@ class V8_EXPORT Recorder {
   static ContextId GetContextId(Local<Context> context);
 };
 
-/**
- * Experimental API intended for the LongTasks UKM (crbug.com/1173527).
- * The Reset() method should be called at the start of a potential
- * long task. The Get() method returns durations of V8 work that
- * happened during the task.
- *
- * This API is experimental and may be removed/changed in the future.
- */
-struct V8_EXPORT LongTaskStats {
-  /**
-   * Resets durations of V8 work for the new task.
-   */
-  V8_INLINE static void Reset(Isolate* isolate) {
-    v8::internal::Internals::IncrementLongTasksStatsCounter(isolate);
-  }
-
-  /**
-   * Returns durations of V8 work that happened since the last Reset().
-   */
-  static LongTaskStats Get(Isolate* isolate);
-
-  int64_t gc_full_atomic_wall_clock_duration_us = 0;
-  int64_t gc_full_incremental_wall_clock_duration_us = 0;
-  int64_t gc_young_wall_clock_duration_us = 0;
-};
-
 }  // namespace metrics
 }  // namespace v8
 
diff --git a/deps/v8/include/v8-platform.h b/deps/v8/include/v8-platform.h
index fc9a357feb66cb..4c94d7fd392c0c 100644
--- a/deps/v8/include/v8-platform.h
+++ b/deps/v8/include/v8-platform.h
@@ -181,8 +181,9 @@ class JobDelegate {
   /**
    * Returns true if the current task is called from the thread currently
    * running JobHandle::Join().
+   * TODO(etiennep): Make pure virtual once custom embedders implement it.
    */
-  virtual bool IsJoiningThread() const = 0;
+  virtual bool IsJoiningThread() const { return false; }
 };
 
 /**
@@ -219,14 +220,19 @@ class JobHandle {
    * Forces all existing workers to yield ASAP but doesn’t wait for them.
    * Warning, this is dangerous if the Job's callback is bound to or has access
    * to state which may be deleted after this call.
+   * TODO(etiennep): Cleanup once implemented by all embedders.
    */
-  virtual void CancelAndDetach() = 0;
+  virtual void CancelAndDetach() { Cancel(); }
 
   /**
    * Returns true if there's any work pending or any worker running.
    */
   virtual bool IsActive() = 0;
 
+  // TODO(etiennep): Clean up once all overrides are removed.
+  V8_DEPRECATED("Use !IsActive() instead.")
+  virtual bool IsCompleted() { return !IsActive(); }
+
   /**
    * Returns true if associated with a Job and other methods may be called.
    * Returns false after Join() or Cancel() was called. This may return true
@@ -234,6 +240,10 @@ class JobHandle {
    */
   virtual bool IsValid() = 0;
 
+  // TODO(etiennep): Clean up once all overrides are removed.
+  V8_DEPRECATED("Use IsValid() instead.")
+  virtual bool IsRunning() { return IsValid(); }
+
   /**
    * Returns true if job priority can be changed.
    */
@@ -262,6 +272,10 @@ class JobTask {
    * it must not call back any JobHandle methods.
    */
   virtual size_t GetMaxConcurrency(size_t worker_count) const = 0;
+
+  // TODO(1114823): Clean up once all overrides are removed.
+  V8_DEPRECATED("Use the version that takes |worker_count|.")
+  virtual size_t GetMaxConcurrency() const { return 0; }
 };
 
 /**
diff --git a/deps/v8/include/v8-profiler.h b/deps/v8/include/v8-profiler.h
index 9a40cfcf307e1d..49ada0a7bf68e5 100644
--- a/deps/v8/include/v8-profiler.h
+++ b/deps/v8/include/v8-profiler.h
@@ -289,8 +289,8 @@ class V8_EXPORT CpuProfilingOptions {
    *                             interval, set via SetSamplingInterval(). If
    *                             zero, the sampling interval will be equal to
    *                             the profiler's sampling interval.
-   * \param filter_context If specified, profiles will only contain frames
-   *                       using this context. Other frames will be elided.
+   * \param filter_context Deprecated option to filter by context, currently a
+   *                       no-op.
    */
   CpuProfilingOptions(
       CpuProfilingMode mode = kLeafNodeLineNumbers,
@@ -304,13 +304,9 @@ class V8_EXPORT CpuProfilingOptions {
  private:
   friend class internal::CpuProfile;
 
-  bool has_filter_context() const { return !filter_context_.IsEmpty(); }
-  void* raw_filter_context() const;
-
   CpuProfilingMode mode_;
   unsigned max_samples_;
   int sampling_interval_us_;
-  CopyablePersistentTraits<Context>::CopyablePersistent filter_context_;
 };
 
 /**
@@ -900,6 +896,14 @@ class V8_EXPORT HeapProfiler {
    * Takes a heap snapshot and returns it.
    */
   const HeapSnapshot* TakeHeapSnapshot(
+      ActivityControl* control = nullptr,
+      ObjectNameResolver* global_object_name_resolver = nullptr,
+      bool treat_global_objects_as_roots = true);
+
+  /**
+   * Takes a heap snapshot and returns it.
+   */
+  const HeapSnapshot* TakeHeapSnapshotV8_92(
       ActivityControl* control = nullptr,
       ObjectNameResolver* global_object_name_resolver = nullptr,
       bool treat_global_objects_as_roots = true,
diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h
index 464ced97679881..cbdca19367d766 100644
--- a/deps/v8/include/v8.h
+++ b/deps/v8/include/v8.h
@@ -1495,7 +1495,7 @@ class V8_EXPORT UnboundScript {
    */
   Local<Script> BindToCurrentContext();
 
-  int GetId() const;
+  int GetId();
   Local<Value> GetScriptName();
 
   /**
@@ -1707,7 +1707,7 @@ class V8_EXPORT Module : public Data {
    *
    * The module must be a SourceTextModule and must not have a kErrored status.
    */
-  int ScriptId() const;
+  int ScriptId();
 
   /**
    * Returns whether this module or any of its requested modules is async,
@@ -2432,7 +2432,7 @@ struct SampleInfo {
   StateTag vm_state;              // Current VM state.
   void* external_callback_entry;  // External callback address if VM is
                                   // executing an external callback.
-  void* context;                  // Incumbent native context address.
+  void* top_context;              // Incumbent native context address.
 };
 
 struct MemoryRange {
@@ -3549,12 +3549,12 @@ class V8_EXPORT String : public Name {
   /**
    * Returns true if this string can be made external.
    */
-  bool CanMakeExternal() const;
+  bool CanMakeExternal();
 
   /**
    * Returns true if the strings values are equal. Same as JS ==/===.
    */
-  bool StringEquals(Local<String> str) const;
+  bool StringEquals(Local<String> str);
 
   /**
    * Converts an object to a UTF-8-encoded character array.  Useful if
@@ -3634,10 +3634,12 @@ class V8_EXPORT Symbol : public Name {
   /**
    * Returns the description string of the symbol, or undefined if none.
    */
-  V8_DEPRECATE_SOON("Use Symbol::Description(isolate)")
   Local<Value> Description() const;
   Local<Value> Description(Isolate* isolate) const;
 
+  V8_DEPRECATED("Use Symbol::Description()")
+  Local<Value> Name() const { return Description(); }
+
   /**
    * Create a symbol. If description is not empty, it will be used as the
    * description.
@@ -4162,7 +4164,7 @@ class V8_EXPORT Object : public Value {
   Maybe<bool> SetIntegrityLevel(Local<Context> context, IntegrityLevel level);
 
   /** Gets the number of internal fields for this Object. */
-  int InternalFieldCount() const;
+  int InternalFieldCount();
 
   /** Same as above, but works for PersistentBase. */
   V8_INLINE static int InternalFieldCount(
@@ -4272,10 +4274,10 @@ class V8_EXPORT Object : public Value {
       Local<Context> context, Local<Name> key);
 
   /** Tests for a named lookup interceptor.*/
-  bool HasNamedLookupInterceptor() const;
+  bool HasNamedLookupInterceptor();
 
   /** Tests for an index lookup interceptor.*/
-  bool HasIndexedLookupInterceptor() const;
+  bool HasIndexedLookupInterceptor();
 
   /**
    * Returns the identity hash for this object. The current implementation
@@ -4315,12 +4317,12 @@ class V8_EXPORT Object : public Value {
    * ObjectTemplate::SetCallAsFunctionHandler method.
    * When an Object is callable this method returns true.
    */
-  bool IsCallable() const;
+  bool IsCallable();
 
   /**
    * True if this object is a constructor.
    */
-  bool IsConstructor() const;
+  bool IsConstructor();
 
   /**
    * True if this object can carry information relevant to the embedder in its
@@ -4329,14 +4331,14 @@ class V8_EXPORT Object : public Value {
    * V8 automatically adds internal fields at compile time, such as e.g.
    * v8::ArrayBuffer.
    */
-  bool IsApiWrapper() const;
+  bool IsApiWrapper();
 
   /**
    * True if this object was created from an object template which was marked
    * as undetectable. See v8::ObjectTemplate::MarkAsUndetectable for more
    * information.
    */
-  bool IsUndetectable() const;
+  bool IsUndetectable();
 
   /**
    * Call an Object as a function if a callback is set by the
@@ -4395,7 +4397,7 @@ class V8_EXPORT Object : public Value {
    *
    * See also: v8::ObjectTemplate::SetCodeLike
    */
-  bool IsCodeLike(Isolate* isolate) const;
+  bool IsCodeLike(Isolate* isolate);
 
  private:
   Object();
@@ -4776,6 +4778,17 @@ class V8_EXPORT Function : public Object {
    */
   Local<Value> GetDebugName() const;
 
+  /**
+   * User-defined name assigned to the "displayName" property of this function.
+   * Used to facilitate debugging and profiling of JavaScript code.
+   */
+  V8_DEPRECATED(
+      "Use v8::Object::Get() instead to look up \"displayName\". "
+      "V8 and DevTools no longer use \"displayName\" in stack "
+      "traces, but the standard \"name\" property. "
+      "See http://crbug.com/1177685.")
+  Local<Value> GetDisplayName() const;
+
   /**
    * Returns zero based line number of function body and
    * kLineOffsetNotFound if no information available.
@@ -4882,7 +4895,7 @@ class V8_EXPORT Promise : public Object {
    * Returns true if the promise has at least one derived promise, and
    * therefore resolve/reject handlers (including default handler).
    */
-  bool HasHandler() const;
+  bool HasHandler();
 
   /**
    * Returns the content of the [[PromiseResult]] field. The Promise must not
@@ -4990,7 +5003,7 @@ class V8_EXPORT Proxy : public Object {
  public:
   Local<Value> GetTarget();
   Local<Value> GetHandler();
-  bool IsRevoked() const;
+  bool IsRevoked();
   void Revoke();
 
   /**
@@ -5405,6 +5418,57 @@ class V8_EXPORT ArrayBuffer : public Object {
     static Allocator* NewDefaultAllocator();
   };
 
+  /**
+   * The contents of an |ArrayBuffer|. Externalization of |ArrayBuffer|
+   * returns an instance of this class, populated, with a pointer to data
+   * and byte length.
+   *
+   * The Data pointer of ArrayBuffer::Contents must be freed using the provided
+   * deleter, which will call ArrayBuffer::Allocator::Free if the buffer
+   * was allocated with ArraryBuffer::Allocator::Allocate.
+   */
+  class V8_EXPORT Contents { // NOLINT
+   public:
+    using DeleterCallback = void (*)(void* buffer, size_t length, void* info);
+
+    Contents()
+        : data_(nullptr),
+          byte_length_(0),
+          allocation_base_(nullptr),
+          allocation_length_(0),
+          allocation_mode_(Allocator::AllocationMode::kNormal),
+          deleter_(nullptr),
+          deleter_data_(nullptr) {}
+
+    void* AllocationBase() const { return allocation_base_; }
+    size_t AllocationLength() const { return allocation_length_; }
+    Allocator::AllocationMode AllocationMode() const {
+      return allocation_mode_;
+    }
+
+    void* Data() const { return data_; }
+    size_t ByteLength() const { return byte_length_; }
+    DeleterCallback Deleter() const { return deleter_; }
+    void* DeleterData() const { return deleter_data_; }
+
+   private:
+    Contents(void* data, size_t byte_length, void* allocation_base,
+             size_t allocation_length,
+             Allocator::AllocationMode allocation_mode, DeleterCallback deleter,
+             void* deleter_data);
+
+    void* data_;
+    size_t byte_length_;
+    void* allocation_base_;
+    size_t allocation_length_;
+    Allocator::AllocationMode allocation_mode_;
+    DeleterCallback deleter_;
+    void* deleter_data_;
+
+    friend class ArrayBuffer;
+  };
+
+
   /**
    * Data length in bytes.
    */
@@ -5418,6 +5482,22 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   static Local<ArrayBuffer> New(Isolate* isolate, size_t byte_length);
 
+  /**
+   * Create a new ArrayBuffer over an existing memory block.
+   * The created array buffer is by default immediately in externalized state.
+   * In externalized state, the memory block will not be reclaimed when a
+   * created ArrayBuffer is garbage-collected.
+   * In internalized state, the memory block will be released using
+   * |Allocator::Free| once all ArrayBuffers referencing it are collected by
+   * the garbage collector.
+   */
+  V8_DEPRECATED(
+      "Use the version that takes a BackingStore. "
+      "See http://crbug.com/v8/9908.")
+  static Local<ArrayBuffer> New(
+      Isolate* isolate, void* data, size_t byte_length,
+      ArrayBufferCreationMode mode = ArrayBufferCreationMode::kExternalized);
+
   /**
    * Create a new ArrayBuffer with an existing backing store.
    * The created array keeps a reference to the backing store until the array
@@ -5456,6 +5536,15 @@ class V8_EXPORT ArrayBuffer : public Object {
       void* data, size_t byte_length, v8::BackingStore::DeleterCallback deleter,
       void* deleter_data);
 
+  /**
+   * Returns true if ArrayBuffer is externalized, that is, does not
+   * own its memory block.
+   */
+  V8_DEPRECATED(
+      "With v8::BackingStore externalized ArrayBuffers are "
+      "the same as ordinary ArrayBuffers. See http://crbug.com/v8/9908.")
+  bool IsExternal() const;
+
   /**
    * Returns true if this ArrayBuffer may be detached.
    */
@@ -5469,11 +5558,47 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   void Detach();
 
+  /**
+   * Make this ArrayBuffer external. The pointer to underlying memory block
+   * and byte length are returned as |Contents| structure. After ArrayBuffer
+   * had been externalized, it does no longer own the memory block. The caller
+   * should take steps to free memory when it is no longer needed.
+   *
+   * The Data pointer of ArrayBuffer::Contents must be freed using the provided
+   * deleter, which will call ArrayBuffer::Allocator::Free if the buffer
+   * was allocated with ArrayBuffer::Allocator::Allocate.
+   */
+  V8_DEPRECATED("Use GetBackingStore or Detach. See http://crbug.com/v8/9908.")
+  Contents Externalize();
+
+  /**
+   * Marks this ArrayBuffer external given a witness that the embedder
+   * has fetched the backing store using the new GetBackingStore() function.
+   *
+   * With the new lifetime management of backing stores there is no need for
+   * externalizing, so this function exists only to make the transition easier.
+   */
+  V8_DEPRECATED("This will be removed together with IsExternal.")
+  void Externalize(const std::shared_ptr<BackingStore>& backing_store);
+
+  /**
+   * Get a pointer to the ArrayBuffer's underlying memory block without
+   * externalizing it. If the ArrayBuffer is not externalized, this pointer
+   * will become invalid as soon as the ArrayBuffer gets garbage collected.
+   *
+   * The embedder should make sure to hold a strong reference to the
+   * ArrayBuffer while accessing this pointer.
+   */
+  V8_DEPRECATED("Use GetBackingStore. See http://crbug.com/v8/9908.")
+  Contents GetContents();
+
   /**
    * Get a shared pointer to the backing store of this array buffer. This
    * pointer coordinates the lifetime management of the internal storage
    * with any live ArrayBuffers on the heap, even across isolates. The embedder
    * should not attempt to manage lifetime of the storage through other means.
+   *
+   * This function replaces both Externalize() and GetContents().
    */
   std::shared_ptr<BackingStore> GetBackingStore();
 
@@ -5485,6 +5610,7 @@ class V8_EXPORT ArrayBuffer : public Object {
  private:
   ArrayBuffer();
   static void CheckCast(Value* obj);
+  Contents GetContents(bool externalize);
 };
 
 
@@ -5777,6 +5903,57 @@ class V8_EXPORT DataView : public ArrayBufferView {
  */
 class V8_EXPORT SharedArrayBuffer : public Object {
  public:
+  /**
+   * The contents of an |SharedArrayBuffer|. Externalization of
+   * |SharedArrayBuffer| returns an instance of this class, populated, with a
+   * pointer to data and byte length.
+   *
+   * The Data pointer of ArrayBuffer::Contents must be freed using the provided
+   * deleter, which will call ArrayBuffer::Allocator::Free if the buffer
+   * was allocated with ArraryBuffer::Allocator::Allocate.
+   */
+  class V8_EXPORT Contents {  // NOLINT
+   public:
+    using Allocator = v8::ArrayBuffer::Allocator;
+    using DeleterCallback = void (*)(void* buffer, size_t length, void* info);
+
+    Contents()
+        : data_(nullptr),
+          byte_length_(0),
+          allocation_base_(nullptr),
+          allocation_length_(0),
+          allocation_mode_(Allocator::AllocationMode::kNormal),
+          deleter_(nullptr),
+          deleter_data_(nullptr) {}
+
+    void* AllocationBase() const { return allocation_base_; }
+    size_t AllocationLength() const { return allocation_length_; }
+    Allocator::AllocationMode AllocationMode() const {
+      return allocation_mode_;
+    }
+
+    void* Data() const { return data_; }
+    size_t ByteLength() const { return byte_length_; }
+    DeleterCallback Deleter() const { return deleter_; }
+    void* DeleterData() const { return deleter_data_; }
+
+   private:
+    Contents(void* data, size_t byte_length, void* allocation_base,
+             size_t allocation_length,
+             Allocator::AllocationMode allocation_mode, DeleterCallback deleter,
+             void* deleter_data);
+
+    void* data_;
+    size_t byte_length_;
+    void* allocation_base_;
+    size_t allocation_length_;
+    Allocator::AllocationMode allocation_mode_;
+    DeleterCallback deleter_;
+    void* deleter_data_;
+
+    friend class SharedArrayBuffer;
+  };
+
   /**
    * Data length in bytes.
    */
@@ -5790,6 +5967,19 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    */
   static Local<SharedArrayBuffer> New(Isolate* isolate, size_t byte_length);
 
+  /**
+   * Create a new SharedArrayBuffer over an existing memory block.  The created
+   * array buffer is immediately in externalized state unless otherwise
+   * specified. The memory block will not be reclaimed when a created
+   * SharedArrayBuffer is garbage-collected.
+   */
+  V8_DEPRECATED(
+      "Use the version that takes a BackingStore. "
+      "See http://crbug.com/v8/9908.")
+  static Local<SharedArrayBuffer> New(
+      Isolate* isolate, void* data, size_t byte_length,
+      ArrayBufferCreationMode mode = ArrayBufferCreationMode::kExternalized);
+
   /**
    * Create a new SharedArrayBuffer with an existing backing store.
    * The created array keeps a reference to the backing store until the array
@@ -5828,11 +6018,73 @@ class V8_EXPORT SharedArrayBuffer : public Object {
       void* data, size_t byte_length, v8::BackingStore::DeleterCallback deleter,
       void* deleter_data);
 
+  /**
+   * Create a new SharedArrayBuffer over an existing memory block. Propagate
+   * flags to indicate whether the underlying buffer can be grown.
+   */
+  V8_DEPRECATED(
+      "Use the version that takes a BackingStore. "
+      "See http://crbug.com/v8/9908.")
+  static Local<SharedArrayBuffer> New(
+      Isolate* isolate, const SharedArrayBuffer::Contents&,
+      ArrayBufferCreationMode mode = ArrayBufferCreationMode::kExternalized);
+
+  /**
+   * Returns true if SharedArrayBuffer is externalized, that is, does not
+   * own its memory block.
+   */
+  V8_DEPRECATED(
+      "With v8::BackingStore externalized SharedArrayBuffers are the same "
+      "as ordinary SharedArrayBuffers. See http://crbug.com/v8/9908.")
+  bool IsExternal() const;
+
+  /**
+   * Make this SharedArrayBuffer external. The pointer to underlying memory
+   * block and byte length are returned as |Contents| structure. After
+   * SharedArrayBuffer had been externalized, it does no longer own the memory
+   * block. The caller should take steps to free memory when it is no longer
+   * needed.
+   *
+   * The memory block is guaranteed to be allocated with |Allocator::Allocate|
+   * by the allocator specified in
+   * v8::Isolate::CreateParams::array_buffer_allocator.
+   *
+   */
+  V8_DEPRECATED("Use GetBackingStore or Detach. See http://crbug.com/v8/9908.")
+  Contents Externalize();
+
+  /**
+   * Marks this SharedArrayBuffer external given a witness that the embedder
+   * has fetched the backing store using the new GetBackingStore() function.
+   *
+   * With the new lifetime management of backing stores there is no need for
+   * externalizing, so this function exists only to make the transition easier.
+   */
+  V8_DEPRECATED("This will be removed together with IsExternal.")
+  void Externalize(const std::shared_ptr<BackingStore>& backing_store);
+
+  /**
+   * Get a pointer to the ArrayBuffer's underlying memory block without
+   * externalizing it. If the ArrayBuffer is not externalized, this pointer
+   * will become invalid as soon as the ArrayBuffer became garbage collected.
+   *
+   * The embedder should make sure to hold a strong reference to the
+   * ArrayBuffer while accessing this pointer.
+   *
+   * The memory block is guaranteed to be allocated with |Allocator::Allocate|
+   * by the allocator specified in
+   * v8::Isolate::CreateParams::array_buffer_allocator.
+   */
+  V8_DEPRECATED("Use GetBackingStore. See http://crbug.com/v8/9908.")
+  Contents GetContents();
+
   /**
    * Get a shared pointer to the backing store of this array buffer. This
    * pointer coordinates the lifetime management of the internal storage
    * with any live ArrayBuffers on the heap, even across isolates. The embedder
    * should not attempt to manage lifetime of the storage through other means.
+   *
+   * This function replaces both Externalize() and GetContents().
    */
   std::shared_ptr<BackingStore> GetBackingStore();
 
@@ -5843,6 +6095,7 @@ class V8_EXPORT SharedArrayBuffer : public Object {
  private:
   SharedArrayBuffer();
   static void CheckCast(Value* obj);
+  Contents GetContents(bool externalize);
 };
 
 
@@ -6960,7 +7213,7 @@ class V8_EXPORT ObjectTemplate : public Template {
    * Gets the number of internal fields for objects generated from
    * this template.
    */
-  int InternalFieldCount() const;
+  int InternalFieldCount();
 
   /**
    * Sets the number of internal fields for objects generated from
@@ -6971,7 +7224,7 @@ class V8_EXPORT ObjectTemplate : public Template {
   /**
    * Returns true if the object will be an immutable prototype exotic object.
    */
-  bool IsImmutableProto() const;
+  bool IsImmutableProto();
 
   /**
    * Makes the ObjectTemplate for an immutable prototype exotic object, with an
@@ -6989,7 +7242,7 @@ class V8_EXPORT ObjectTemplate : public Template {
    * Reference: https://github.com/tc39/proposal-dynamic-code-brand-checks
    */
   void SetCodeLike();
-  bool IsCodeLike() const;
+  bool IsCodeLike();
 
   V8_INLINE static ObjectTemplate* Cast(Data* data);
 
@@ -10614,7 +10867,7 @@ class V8_EXPORT Context : public Data {
    * Returns true if code generation from strings is allowed for the context.
    * For more details see AllowCodeGenerationFromStrings(bool) documentation.
    */
-  bool IsCodeGenerationFromStringsAllowed() const;
+  bool IsCodeGenerationFromStringsAllowed();
 
   /**
    * Sets the error description for the exception that is thrown when
diff --git a/deps/v8/src/api/api.cc b/deps/v8/src/api/api.cc
index 9d1e53d3bb69c6..2c1223afedc5c0 100644
--- a/deps/v8/src/api/api.cc
+++ b/deps/v8/src/api/api.cc
@@ -937,9 +937,11 @@ bool Data::IsModule() const { return Utils::OpenHandle(this)->IsModule(); }
 
 bool Data::IsValue() const {
   i::DisallowGarbageCollection no_gc;
-  i::Object self = *Utils::OpenHandle(this);
-  if (self.IsSmi()) return true;
-  i::HeapObject heap_object = i::HeapObject::cast(self);
+  i::Handle<i::Object> self = Utils::OpenHandle(this);
+  if (self->IsSmi()) {
+    return true;
+  }
+  i::HeapObject heap_object = i::HeapObject::cast(*self);
   DCHECK(!heap_object.IsTheHole());
   if (heap_object.IsSymbol()) {
     return !i::Symbol::cast(heap_object).is_private();
@@ -1788,7 +1790,7 @@ void ObjectTemplate::SetCallAsFunctionHandler(FunctionCallback callback,
   i::FunctionTemplateInfo::SetInstanceCallHandler(isolate, cons, obj);
 }
 
-int ObjectTemplate::InternalFieldCount() const {
+int ObjectTemplate::InternalFieldCount() {
   return Utils::OpenHandle(this)->embedder_field_count();
 }
 
@@ -1809,7 +1811,7 @@ void ObjectTemplate::SetInternalFieldCount(int value) {
   Utils::OpenHandle(this)->set_embedder_field_count(value);
 }
 
-bool ObjectTemplate::IsImmutableProto() const {
+bool ObjectTemplate::IsImmutableProto() {
   return Utils::OpenHandle(this)->immutable_proto();
 }
 
@@ -1820,7 +1822,7 @@ void ObjectTemplate::SetImmutableProto() {
   self->set_immutable_proto(true);
 }
 
-bool ObjectTemplate::IsCodeLike() const {
+bool ObjectTemplate::IsCodeLike() {
   return Utils::OpenHandle(this)->code_like();
 }
 
@@ -1875,11 +1877,15 @@ Local<Script> UnboundScript::BindToCurrentContext() {
   return ToApiHandle<Script>(function);
 }
 
-int UnboundScript::GetId() const {
-  auto function_info = i::SharedFunctionInfo::cast(*Utils::OpenHandle(this));
-  i::Isolate* isolate = function_info.GetIsolate();
+int UnboundScript::GetId() {
+  auto function_info =
+      i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
+  i::Isolate* isolate = function_info->GetIsolate();
   LOG_API(isolate, UnboundScript, GetId);
-  return i::Script::cast(function_info.script()).id();
+  i::HandleScope scope(isolate);
+  i::Handle<i::Script> script(i::Script::cast(function_info->script()),
+                              isolate);
+  return script->id();
 }
 
 int UnboundScript::GetLineNumber(int code_pos) {
@@ -2108,10 +2114,13 @@ Local<Value> Module::GetException() const {
 }
 
 int Module::GetModuleRequestsLength() const {
-  i::Module self = *Utils::OpenHandle(this);
-  if (self.IsSyntheticModule()) return 0;
-  ASSERT_NO_SCRIPT_NO_EXCEPTION(self.GetIsolate());
-  return i::SourceTextModule::cast(self).info().module_requests().length();
+  i::Handle<i::Module> self = Utils::OpenHandle(this);
+  if (self->IsSyntheticModule()) return 0;
+  ASSERT_NO_SCRIPT_NO_EXCEPTION(self->GetIsolate());
+  return i::Handle<i::SourceTextModule>::cast(self)
+      ->info()
+      .module_requests()
+      .length();
 }
 
 Local<String> Module::GetModuleRequest(int i) const {
@@ -2212,22 +2221,22 @@ Local<UnboundModuleScript> Module::GetUnboundModuleScript() {
       isolate));
 }
 
-int Module::ScriptId() const {
-  i::Module self = *Utils::OpenHandle(this);
-  Utils::ApiCheck(self.IsSourceTextModule(), "v8::Module::ScriptId",
+int Module::ScriptId() {
+  i::Handle<i::Module> self = Utils::OpenHandle(this);
+  Utils::ApiCheck(self->IsSourceTextModule(), "v8::Module::ScriptId",
                   "v8::Module::ScriptId must be used on an SourceTextModule");
-  ASSERT_NO_SCRIPT_NO_EXCEPTION(self.GetIsolate());
-  return i::SourceTextModule::cast(self).GetScript().id();
+  ASSERT_NO_SCRIPT_NO_EXCEPTION(self->GetIsolate());
+  return i::Handle<i::SourceTextModule>::cast(self)->GetScript().id();
 }
 
 bool Module::IsGraphAsync() const {
   Utils::ApiCheck(
       GetStatus() >= kInstantiated, "v8::Module::IsGraphAsync",
       "v8::Module::IsGraphAsync must be used on an instantiated module");
-  i::Module self = *Utils::OpenHandle(this);
-  auto isolate = self.GetIsolate();
+  i::Handle<i::Module> self = Utils::OpenHandle(this);
+  auto isolate = self->GetIsolate();
   ASSERT_NO_SCRIPT_NO_EXCEPTION(isolate);
-  return self.IsGraphAsync(isolate);
+  return self->IsGraphAsync(isolate);
 }
 
 bool Module::IsSourceTextModule() const {
@@ -3365,15 +3374,15 @@ bool Value::FullIsNull() const {
 }
 
 bool Value::IsTrue() const {
-  i::Object object = *Utils::OpenHandle(this);
-  if (object.IsSmi()) return false;
-  return object.IsTrue();
+  i::Handle<i::Object> object = Utils::OpenHandle(this);
+  if (object->IsSmi()) return false;
+  return object->IsTrue();
 }
 
 bool Value::IsFalse() const {
-  i::Object object = *Utils::OpenHandle(this);
-  if (object.IsSmi()) return false;
-  return object.IsFalse();
+  i::Handle<i::Object> object = Utils::OpenHandle(this);
+  if (object->IsSmi()) return false;
+  return object->IsFalse();
 }
 
 bool Value::IsFunction() const { return Utils::OpenHandle(this)->IsCallable(); }
@@ -3393,9 +3402,8 @@ bool Value::IsSymbol() const {
 bool Value::IsArray() const { return Utils::OpenHandle(this)->IsJSArray(); }
 
 bool Value::IsArrayBuffer() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (!obj.IsJSArrayBuffer()) return false;
-  return !i::JSArrayBuffer::cast(obj).is_shared();
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  return obj->IsJSArrayBuffer() && !i::JSArrayBuffer::cast(*obj).is_shared();
 }
 
 bool Value::IsArrayBufferView() const {
@@ -3422,9 +3430,8 @@ bool Value::IsDataView() const {
 }
 
 bool Value::IsSharedArrayBuffer() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (!obj.IsJSArrayBuffer()) return false;
-  return i::JSArrayBuffer::cast(obj).is_shared();
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  return obj->IsJSArrayBuffer() && i::JSArrayBuffer::cast(*obj).is_shared();
 }
 
 bool Value::IsObject() const { return Utils::OpenHandle(this)->IsJSReceiver(); }
@@ -3465,23 +3472,23 @@ VALUE_IS_SPECIFIC_TYPE(WeakSet, JSWeakSet)
 bool Value::IsBoolean() const { return Utils::OpenHandle(this)->IsBoolean(); }
 
 bool Value::IsExternal() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (!obj.IsHeapObject()) return false;
-  i::HeapObject heap_obj = i::HeapObject::cast(obj);
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  if (!obj->IsHeapObject()) return false;
+  i::Handle<i::HeapObject> heap_obj = i::Handle<i::HeapObject>::cast(obj);
   // Check the instance type is JS_OBJECT (instance type of Externals) before
   // attempting to get the Isolate since that guarantees the object is writable
   // and GetIsolate will work.
-  if (heap_obj.map().instance_type() != i::JS_OBJECT_TYPE) return false;
-  i::Isolate* isolate = i::JSObject::cast(heap_obj).GetIsolate();
+  if (heap_obj->map().instance_type() != i::JS_OBJECT_TYPE) return false;
+  i::Isolate* isolate = i::JSObject::cast(*heap_obj).GetIsolate();
   ASSERT_NO_SCRIPT_NO_EXCEPTION(isolate);
-  return heap_obj.IsExternal(isolate);
+  return heap_obj->IsExternal(isolate);
 }
 
 bool Value::IsInt32() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (obj.IsSmi()) return true;
-  if (obj.IsNumber()) {
-    return i::IsInt32Double(obj.Number());
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  if (obj->IsSmi()) return true;
+  if (obj->IsNumber()) {
+    return i::IsInt32Double(obj->Number());
   }
   return false;
 }
@@ -3507,18 +3514,18 @@ bool Value::IsRegExp() const {
 }
 
 bool Value::IsAsyncFunction() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (!obj.IsJSFunction()) return false;
-  i::JSFunction func = i::JSFunction::cast(obj);
-  return i::IsAsyncFunction(func.shared().kind());
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  if (!obj->IsJSFunction()) return false;
+  i::Handle<i::JSFunction> func = i::Handle<i::JSFunction>::cast(obj);
+  return i::IsAsyncFunction(func->shared().kind());
 }
 
 bool Value::IsGeneratorFunction() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (!obj.IsJSFunction()) return false;
-  i::JSFunction func = i::JSFunction::cast(obj);
-  ASSERT_NO_SCRIPT_NO_EXCEPTION(func.GetIsolate());
-  return i::IsGeneratorFunction(func.shared().kind());
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  if (!obj->IsJSFunction()) return false;
+  i::Handle<i::JSFunction> func = i::Handle<i::JSFunction>::cast(obj);
+  ASSERT_NO_SCRIPT_NO_EXCEPTION(func->GetIsolate());
+  return i::IsGeneratorFunction(func->shared().kind());
 }
 
 bool Value::IsGeneratorObject() const {
@@ -3839,6 +3846,7 @@ std::shared_ptr<v8::BackingStore> v8::ArrayBuffer::GetBackingStore() {
     backing_store =
         i::BackingStore::EmptyBackingStore(i::SharedFlag::kNotShared);
   }
+  i::GlobalBackingStoreRegistry::Register(backing_store);
   std::shared_ptr<i::BackingStoreBase> bs_base = backing_store;
   return std::static_pointer_cast<v8::BackingStore>(bs_base);
 }
@@ -3849,6 +3857,7 @@ std::shared_ptr<v8::BackingStore> v8::SharedArrayBuffer::GetBackingStore() {
   if (!backing_store) {
     backing_store = i::BackingStore::EmptyBackingStore(i::SharedFlag::kShared);
   }
+  i::GlobalBackingStoreRegistry::Register(backing_store);
   std::shared_ptr<i::BackingStoreBase> bs_base = backing_store;
   return std::static_pointer_cast<v8::BackingStore>(bs_base);
 }
@@ -4752,16 +4761,16 @@ Maybe<bool> v8::Object::HasRealNamedCallbackProperty(Local<Context> context,
   return result;
 }
 
-bool v8::Object::HasNamedLookupInterceptor() const {
-  auto self = *Utils::OpenHandle(this);
-  if (self.IsJSObject()) return false;
-  return i::JSObject::cast(self).HasNamedInterceptor();
+bool v8::Object::HasNamedLookupInterceptor() {
+  auto self = Utils::OpenHandle(this);
+  return self->IsJSObject() &&
+         i::Handle<i::JSObject>::cast(self)->HasNamedInterceptor();
 }
 
-bool v8::Object::HasIndexedLookupInterceptor() const {
-  auto self = *Utils::OpenHandle(this);
-  if (self.IsJSObject()) return false;
-  return i::JSObject::cast(self).HasIndexedInterceptor();
+bool v8::Object::HasIndexedLookupInterceptor() {
+  auto self = Utils::OpenHandle(this);
+  return self->IsJSObject() &&
+         i::Handle<i::JSObject>::cast(self)->HasIndexedInterceptor();
 }
 
 MaybeLocal<Value> v8::Object::GetRealNamedPropertyInPrototypeChain(
@@ -4896,22 +4905,22 @@ int v8::Object::GetIdentityHash() {
   return self->GetOrCreateIdentityHash(isolate).value();
 }
 
-bool v8::Object::IsCallable() const {
+bool v8::Object::IsCallable() {
   auto self = Utils::OpenHandle(this);
   return self->IsCallable();
 }
 
-bool v8::Object::IsConstructor() const {
+bool v8::Object::IsConstructor() {
   auto self = Utils::OpenHandle(this);
   return self->IsConstructor();
 }
 
-bool v8::Object::IsApiWrapper() const {
+bool v8::Object::IsApiWrapper() {
   auto self = i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
   return self->IsApiWrapper();
 }
 
-bool v8::Object::IsUndetectable() const {
+bool v8::Object::IsUndetectable() {
   auto self = i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
   return self->IsUndetectable();
 }
@@ -5089,6 +5098,25 @@ Local<Value> Function::GetDebugName() const {
   return Utils::ToLocal(i::Handle<i::Object>(*name, self->GetIsolate()));
 }
 
+Local<Value> Function::GetDisplayName() const {
+  auto self = Utils::OpenHandle(this);
+  i::Isolate* isolate = self->GetIsolate();
+  ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
+  if (!self->IsJSFunction()) {
+    return ToApiHandle<Primitive>(isolate->factory()->undefined_value());
+  }
+  auto func = i::Handle<i::JSFunction>::cast(self);
+  i::Handle<i::String> property_name =
+      isolate->factory()->InternalizeString(i::StaticCharVector("displayName"));
+  i::Handle<i::Object> value =
+      i::JSReceiver::GetDataProperty(func, property_name);
+  if (value->IsString()) {
+    i::Handle<i::String> name = i::Handle<i::String>::cast(value);
+    if (name->length() > 0) return Utils::ToLocal(name);
+  }
+  return ToApiHandle<Primitive>(isolate->factory()->undefined_value());
+}
+
 ScriptOrigin Function::GetScriptOrigin() const {
   auto self = Utils::OpenHandle(this);
   auto isolate = reinterpret_cast<v8::Isolate*>(self->GetIsolate());
@@ -5133,11 +5161,17 @@ int Function::GetScriptColumnNumber() const {
 }
 
 int Function::ScriptId() const {
-  i::JSReceiver self = *Utils::OpenHandle(this);
-  if (!self.IsJSFunction()) return v8::UnboundScript::kNoScriptId;
-  auto func = i::JSFunction::cast(self);
-  if (!func.shared().script().IsScript()) return v8::UnboundScript::kNoScriptId;
-  return i::Script::cast(func.shared().script()).id();
+  auto self = Utils::OpenHandle(this);
+  if (!self->IsJSFunction()) {
+    return v8::UnboundScript::kNoScriptId;
+  }
+  auto func = i::Handle<i::JSFunction>::cast(self);
+  if (!func->shared().script().IsScript()) {
+    return v8::UnboundScript::kNoScriptId;
+  }
+  i::Handle<i::Script> script(i::Script::cast(func->shared().script()),
+                              func->GetIsolate());
+  return script->id();
 }
 
 Local<v8::Value> Function::GetBoundFunction() const {
@@ -5685,36 +5719,36 @@ bool Boolean::Value() const {
 }
 
 int64_t Integer::Value() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (obj.IsSmi()) {
-    return i::Smi::ToInt(obj);
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  if (obj->IsSmi()) {
+    return i::Smi::ToInt(*obj);
   } else {
-    return static_cast<int64_t>(obj.Number());
+    return static_cast<int64_t>(obj->Number());
   }
 }
 
 int32_t Int32::Value() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (obj.IsSmi()) {
-    return i::Smi::ToInt(obj);
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  if (obj->IsSmi()) {
+    return i::Smi::ToInt(*obj);
   } else {
-    return static_cast<int32_t>(obj.Number());
+    return static_cast<int32_t>(obj->Number());
   }
 }
 
 uint32_t Uint32::Value() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  if (obj.IsSmi()) {
-    return i::Smi::ToInt(obj);
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  if (obj->IsSmi()) {
+    return i::Smi::ToInt(*obj);
   } else {
-    return static_cast<uint32_t>(obj.Number());
+    return static_cast<uint32_t>(obj->Number());
   }
 }
 
-int v8::Object::InternalFieldCount() const {
-  i::JSReceiver self = *Utils::OpenHandle(this);
-  if (!self.IsJSObject()) return 0;
-  return i::JSObject::cast(self).GetEmbedderFieldCount();
+int v8::Object::InternalFieldCount() {
+  i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
+  if (!self->IsJSObject()) return 0;
+  return i::Handle<i::JSObject>::cast(self)->GetEmbedderFieldCount();
 }
 
 static bool InternalFieldOK(i::Handle<i::JSReceiver> obj, int index,
@@ -6242,9 +6276,9 @@ void Context::AllowCodeGenerationFromStrings(bool allow) {
             : i::ReadOnlyRoots(isolate).false_value());
 }
 
-bool Context::IsCodeGenerationFromStringsAllowed() const {
-  i::Context context = *Utils::OpenHandle(this);
-  return !context.allow_code_gen_from_strings().IsFalse(context.GetIsolate());
+bool Context::IsCodeGenerationFromStringsAllowed() {
+  i::Handle<i::Context> context = Utils::OpenHandle(this);
+  return !context->allow_code_gen_from_strings().IsFalse(context->GetIsolate());
 }
 
 void Context::SetErrorMessageForCodeGenerationFromStrings(Local<String> error) {
@@ -6337,11 +6371,6 @@ metrics::Recorder::ContextId metrics::Recorder::GetContextId(
       handle(i_context->native_context(), isolate));
 }
 
-metrics::LongTaskStats metrics::LongTaskStats::Get(v8::Isolate* isolate) {
-  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
-  return *i_isolate->GetCurrentLongTaskStats();
-}
-
 namespace {
 i::Address* GetSerializedDataFromFixedArray(i::Isolate* isolate,
                                             i::FixedArray list, size_t index) {
@@ -6703,7 +6732,8 @@ bool v8::String::MakeExternal(
   return result;
 }
 
-bool v8::String::CanMakeExternal() const {
+bool v8::String::CanMakeExternal() {
+  i::DisallowGarbageCollection no_gc;
   i::String obj = *Utils::OpenHandle(this);
 
   if (obj.IsThinString()) {
@@ -6718,7 +6748,7 @@ bool v8::String::CanMakeExternal() const {
   return !i::Heap::InYoungGeneration(obj);
 }
 
-bool v8::String::StringEquals(Local<String> that) const {
+bool v8::String::StringEquals(Local<String> that) {
   auto self = Utils::OpenHandle(this);
   auto other = Utils::OpenHandle(*that);
   return self->Equals(*other);
@@ -6889,11 +6919,12 @@ Local<v8::Value> v8::BooleanObject::New(Isolate* isolate, bool value) {
 }
 
 bool v8::BooleanObject::ValueOf() const {
-  i::Object obj = *Utils::OpenHandle(this);
-  i::JSPrimitiveWrapper js_primitive_wrapper = i::JSPrimitiveWrapper::cast(obj);
-  i::Isolate* isolate = js_primitive_wrapper.GetIsolate();
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  i::Handle<i::JSPrimitiveWrapper> js_primitive_wrapper =
+      i::Handle<i::JSPrimitiveWrapper>::cast(obj);
+  i::Isolate* isolate = js_primitive_wrapper->GetIsolate();
   LOG_API(isolate, BooleanObject, BooleanValue);
-  return js_primitive_wrapper.value().IsTrue(isolate);
+  return js_primitive_wrapper->value().IsTrue(isolate);
 }
 
 Local<v8::Value> v8::StringObject::New(Isolate* v8_isolate,
@@ -7420,13 +7451,16 @@ MaybeLocal<Promise> Promise::Then(Local<Context> context,
   RETURN_ESCAPED(Local<Promise>::Cast(Utils::ToLocal(result)));
 }
 
-bool Promise::HasHandler() const {
-  i::JSReceiver promise = *Utils::OpenHandle(this);
-  i::Isolate* isolate = promise.GetIsolate();
+bool Promise::HasHandler() {
+  i::Handle<i::JSReceiver> promise = Utils::OpenHandle(this);
+  i::Isolate* isolate = promise->GetIsolate();
   LOG_API(isolate, Promise, HasRejectHandler);
   ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
-  if (!promise.IsJSPromise()) return false;
-  return i::JSPromise::cast(promise).has_handler();
+  if (promise->IsJSPromise()) {
+    i::Handle<i::JSPromise> js_promise = i::Handle<i::JSPromise>::cast(promise);
+    return js_promise->has_handler();
+  }
+  return false;
 }
 
 Local<Value> Promise::Result() {
@@ -7465,7 +7499,7 @@ Local<Value> Proxy::GetHandler() {
   return Utils::ToLocal(handler);
 }
 
-bool Proxy::IsRevoked() const {
+bool Proxy::IsRevoked() {
   i::Handle<i::JSProxy> self = Utils::OpenHandle(this);
   return self->IsRevoked();
 }
@@ -7592,17 +7626,169 @@ v8::ArrayBuffer::Allocator* v8::ArrayBuffer::Allocator::NewDefaultAllocator() {
   return new ArrayBufferAllocator();
 }
 
+bool v8::ArrayBuffer::IsExternal() const {
+  return Utils::OpenHandle(this)->is_external();
+}
+
 bool v8::ArrayBuffer::IsDetachable() const {
   return Utils::OpenHandle(this)->is_detachable();
 }
 
 namespace {
+// The backing store deleter just deletes the indirection, which downrefs
+// the shared pointer. It will get collected normally.
+void BackingStoreDeleter(void* buffer, size_t length, void* info) {
+  std::shared_ptr<i::BackingStore>* bs_indirection =
+      reinterpret_cast<std::shared_ptr<i::BackingStore>*>(info);
+  if (bs_indirection) {
+    i::BackingStore* backing_store = bs_indirection->get();
+    TRACE_BS("API:delete bs=%p mem=%p (length=%zu)\n", backing_store,
+             backing_store->buffer_start(), backing_store->byte_length());
+    USE(backing_store);
+  }
+  delete bs_indirection;
+}
+
+void* MakeDeleterData(std::shared_ptr<i::BackingStore> backing_store) {
+  if (!backing_store) return nullptr;
+  TRACE_BS("API:extern bs=%p mem=%p (length=%zu)\n", backing_store.get(),
+           backing_store->buffer_start(), backing_store->byte_length());
+  return new std::shared_ptr<i::BackingStore>(backing_store);
+}
+
+std::shared_ptr<i::BackingStore> LookupOrCreateBackingStore(
+    i::Isolate* i_isolate, void* data, size_t byte_length, i::SharedFlag shared,
+    ArrayBufferCreationMode mode) {
+  // "internalized" means that the storage was allocated by the
+  // ArrayBufferAllocator and thus should be freed upon destruction.
+  bool free_on_destruct = mode == ArrayBufferCreationMode::kInternalized;
+
+  // Try to lookup a previously-registered backing store in the global
+  // registry. If found, use that instead of wrapping an embedder allocation.
+  std::shared_ptr<i::BackingStore> backing_store =
+      i::GlobalBackingStoreRegistry::Lookup(data, byte_length);
+
+  if (backing_store) {
+    // Check invariants for a previously-found backing store.
+
+    // 1. We cannot allow an embedder to first allocate a backing store that
+    // should not be freed upon destruct, and then allocate an alias that should
+    // destruct it. The other order is fine.
+    bool changing_destruct_mode =
+        free_on_destruct && !backing_store->free_on_destruct();
+    Utils::ApiCheck(
+        !changing_destruct_mode, "v8_[Shared]ArrayBuffer_New",
+        "previous backing store found that should not be freed on destruct");
+
+    // 2. We cannot allow embedders to use the same backing store for both
+    // SharedArrayBuffers and regular ArrayBuffers.
+    bool changing_shared_flag =
+        (shared == i::SharedFlag::kShared) != backing_store->is_shared();
+    Utils::ApiCheck(
+        !changing_shared_flag, "v8_[Shared]ArrayBuffer_New",
+        "previous backing store found that does not match shared flag");
+  } else {
+    // No previous backing store found.
+    backing_store = i::BackingStore::WrapAllocation(
+        i_isolate, data, byte_length, shared, free_on_destruct);
+
+    // The embedder already has a direct pointer to the buffer start, so
+    // globally register the backing store in case they come back with the
+    // same buffer start and the backing store is marked as free_on_destruct.
+    i::GlobalBackingStoreRegistry::Register(backing_store);
+  }
+  return backing_store;
+}
+
 std::shared_ptr<i::BackingStore> ToInternal(
     std::shared_ptr<i::BackingStoreBase> backing_store) {
   return std::static_pointer_cast<i::BackingStore>(backing_store);
 }
 }  // namespace
 
+v8::ArrayBuffer::Contents::Contents(void* data, size_t byte_length,
+                                    void* allocation_base,
+                                    size_t allocation_length,
+                                    Allocator::AllocationMode allocation_mode,
+                                    DeleterCallback deleter, void* deleter_data)
+    : data_(data),
+      byte_length_(byte_length),
+      allocation_base_(allocation_base),
+      allocation_length_(allocation_length),
+      allocation_mode_(allocation_mode),
+      deleter_(deleter),
+      deleter_data_(deleter_data) {
+  DCHECK_LE(allocation_base_, data_);
+  DCHECK_LE(byte_length_, allocation_length_);
+}
+
+v8::ArrayBuffer::Contents v8::ArrayBuffer::Externalize() {
+  return GetContents(true);
+}
+
+void v8::ArrayBuffer::Externalize(
+    const std::shared_ptr<BackingStore>& backing_store) {
+  i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
+  Utils::ApiCheck(!self->is_external(), "v8_ArrayBuffer_Externalize",
+                  "ArrayBuffer already externalized");
+  self->set_is_external(true);
+  DCHECK_EQ(self->backing_store(), backing_store->Data());
+}
+
+v8::ArrayBuffer::Contents v8::ArrayBuffer::GetContents() {
+  return GetContents(false);
+}
+
+v8::ArrayBuffer::Contents v8::ArrayBuffer::GetContents(bool externalize) {
+  // TODO(titzer): reduce duplication between shared/unshared GetContents()
+  using BufferType = v8::ArrayBuffer;
+
+  i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
+
+  std::shared_ptr<i::BackingStore> backing_store = self->GetBackingStore();
+
+  void* deleter_data = nullptr;
+  if (externalize) {
+    Utils::ApiCheck(!self->is_external(), "v8_ArrayBuffer_Externalize",
+                    "ArrayBuffer already externalized");
+    self->set_is_external(true);
+    // When externalizing, upref the shared pointer to the backing store
+    // and store that as the deleter data. When the embedder calls the deleter
+    // callback, we will delete the additional (on-heap) shared_ptr.
+    deleter_data = MakeDeleterData(backing_store);
+  }
+
+  if (!backing_store) {
+    // If the array buffer has zero length or was detached, return empty
+    // contents.
+    DCHECK_EQ(0, self->byte_length());
+    BufferType::Contents contents(
+        nullptr, 0, nullptr, 0,
+        v8::ArrayBuffer::Allocator::AllocationMode::kNormal,
+        BackingStoreDeleter, deleter_data);
+    return contents;
+  }
+
+  // Backing stores that given to the embedder might be passed back through
+  // the API using only the start of the buffer. We need to find such
+  // backing stores using global registration until the API is changed.
+  i::GlobalBackingStoreRegistry::Register(backing_store);
+
+  auto allocation_mode =
+      backing_store->is_wasm_memory()
+          ? v8::ArrayBuffer::Allocator::AllocationMode::kReservation
+          : v8::ArrayBuffer::Allocator::AllocationMode::kNormal;
+
+  BufferType::Contents contents(backing_store->buffer_start(),  // --
+                                backing_store->byte_length(),   // --
+                                backing_store->buffer_start(),  // --
+                                backing_store->byte_length(),   // --
+                                allocation_mode,                // --
+                                BackingStoreDeleter,            // --
+                                deleter_data);
+  return contents;
+}
+
 void v8::ArrayBuffer::Detach() {
   i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
   i::Isolate* isolate = obj->GetIsolate();
@@ -7636,6 +7822,27 @@ Local<ArrayBuffer> v8::ArrayBuffer::New(Isolate* isolate, size_t byte_length) {
   return Utils::ToLocal(array_buffer);
 }
 
+Local<ArrayBuffer> v8::ArrayBuffer::New(Isolate* isolate, void* data,
+                                        size_t byte_length,
+                                        ArrayBufferCreationMode mode) {
+  // Embedders must guarantee that the external backing store is valid.
+  CHECK_IMPLIES(byte_length != 0, data != nullptr);
+  CHECK_LE(byte_length, i::JSArrayBuffer::kMaxByteLength);
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  LOG_API(i_isolate, ArrayBuffer, New);
+  ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
+
+  std::shared_ptr<i::BackingStore> backing_store = LookupOrCreateBackingStore(
+      i_isolate, data, byte_length, i::SharedFlag::kNotShared, mode);
+
+  i::Handle<i::JSArrayBuffer> obj =
+      i_isolate->factory()->NewJSArrayBuffer(std::move(backing_store));
+  if (mode == ArrayBufferCreationMode::kExternalized) {
+    obj->set_is_external(true);
+  }
+  return Utils::ToLocal(obj);
+}
+
 Local<ArrayBuffer> v8::ArrayBuffer::New(
     Isolate* isolate, std::shared_ptr<BackingStore> backing_store) {
   CHECK_IMPLIES(backing_store->ByteLength() != 0,
@@ -7809,6 +8016,119 @@ Local<DataView> DataView::New(Local<SharedArrayBuffer> shared_array_buffer,
   return Utils::ToLocal(obj);
 }
 
+namespace {
+i::Handle<i::JSArrayBuffer> SetupSharedArrayBuffer(
+    Isolate* isolate, void* data, size_t byte_length,
+    ArrayBufferCreationMode mode) {
+  CHECK(i::FLAG_harmony_sharedarraybuffer);
+  // Embedders must guarantee that the external backing store is valid.
+  CHECK(byte_length == 0 || data != nullptr);
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  LOG_API(i_isolate, SharedArrayBuffer, New);
+  ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
+
+  std::shared_ptr<i::BackingStore> backing_store = LookupOrCreateBackingStore(
+      i_isolate, data, byte_length, i::SharedFlag::kShared, mode);
+
+  i::Handle<i::JSArrayBuffer> obj =
+      i_isolate->factory()->NewJSSharedArrayBuffer(std::move(backing_store));
+
+  if (mode == ArrayBufferCreationMode::kExternalized) {
+    obj->set_is_external(true);
+  }
+  return obj;
+}
+
+}  // namespace
+
+bool v8::SharedArrayBuffer::IsExternal() const {
+  return Utils::OpenHandle(this)->is_external();
+}
+
+v8::SharedArrayBuffer::Contents::Contents(
+    void* data, size_t byte_length, void* allocation_base,
+    size_t allocation_length, Allocator::AllocationMode allocation_mode,
+    DeleterCallback deleter, void* deleter_data)
+    : data_(data),
+      byte_length_(byte_length),
+      allocation_base_(allocation_base),
+      allocation_length_(allocation_length),
+      allocation_mode_(allocation_mode),
+      deleter_(deleter),
+      deleter_data_(deleter_data) {
+  DCHECK_LE(allocation_base_, data_);
+  DCHECK_LE(byte_length_, allocation_length_);
+}
+
+v8::SharedArrayBuffer::Contents v8::SharedArrayBuffer::Externalize() {
+  return GetContents(true);
+}
+
+void v8::SharedArrayBuffer::Externalize(
+    const std::shared_ptr<BackingStore>& backing_store) {
+  i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
+  Utils::ApiCheck(!self->is_external(), "v8_SharedArrayBuffer_Externalize",
+                  "SharedArrayBuffer already externalized");
+  self->set_is_external(true);
+
+  DCHECK_EQ(self->backing_store(), backing_store->Data());
+}
+
+v8::SharedArrayBuffer::Contents v8::SharedArrayBuffer::GetContents() {
+  return GetContents(false);
+}
+
+v8::SharedArrayBuffer::Contents v8::SharedArrayBuffer::GetContents(
+    bool externalize) {
+  // TODO(titzer): reduce duplication between shared/unshared GetContents()
+  using BufferType = v8::SharedArrayBuffer;
+
+  i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
+
+  std::shared_ptr<i::BackingStore> backing_store = self->GetBackingStore();
+
+  void* deleter_data = nullptr;
+  if (externalize) {
+    Utils::ApiCheck(!self->is_external(), "v8_SharedArrayBuffer_Externalize",
+                    "SharedArrayBuffer already externalized");
+    self->set_is_external(true);
+    // When externalizing, upref the shared pointer to the backing store
+    // and store that as the deleter data. When the embedder calls the deleter
+    // callback, we will delete the additional (on-heap) shared_ptr.
+    deleter_data = MakeDeleterData(backing_store);
+  }
+
+  if (!backing_store) {
+    // If the array buffer has zero length or was detached, return empty
+    // contents.
+    DCHECK_EQ(0, self->byte_length());
+    BufferType::Contents contents(
+        nullptr, 0, nullptr, 0,
+        v8::ArrayBuffer::Allocator::AllocationMode::kNormal,
+        BackingStoreDeleter, deleter_data);
+    return contents;
+  }
+
+  // Backing stores that given to the embedder might be passed back through
+  // the API using only the start of the buffer. We need to find such
+  // backing stores using global registration until the API is changed.
+  i::GlobalBackingStoreRegistry::Register(backing_store);
+
+  auto allocation_mode =
+      backing_store->is_wasm_memory()
+          ? v8::ArrayBuffer::Allocator::AllocationMode::kReservation
+          : v8::ArrayBuffer::Allocator::AllocationMode::kNormal;
+
+  BufferType::Contents contents(backing_store->buffer_start(),  // --
+                                backing_store->byte_length(),   // --
+                                backing_store->buffer_start(),  // --
+                                backing_store->byte_length(),   // --
+                                allocation_mode,                // --
+                                BackingStoreDeleter,            // --
+                                deleter_data);
+  return contents;
+}
+
 size_t v8::SharedArrayBuffer::ByteLength() const {
   i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
   return obj->byte_length();
@@ -7836,6 +8156,14 @@ Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(Isolate* isolate,
   return Utils::ToLocalShared(obj);
 }
 
+Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(
+    Isolate* isolate, void* data, size_t byte_length,
+    ArrayBufferCreationMode mode) {
+  i::Handle<i::JSArrayBuffer> buffer =
+      SetupSharedArrayBuffer(isolate, data, byte_length, mode);
+  return Utils::ToLocalShared(buffer);
+}
+
 Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(
     Isolate* isolate, std::shared_ptr<BackingStore> backing_store) {
   CHECK(i::FLAG_harmony_sharedarraybuffer);
@@ -7853,6 +8181,14 @@ Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(
   return Utils::ToLocalShared(obj);
 }
 
+Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(
+    Isolate* isolate, const SharedArrayBuffer::Contents& contents,
+    ArrayBufferCreationMode mode) {
+  i::Handle<i::JSArrayBuffer> buffer = SetupSharedArrayBuffer(
+      isolate, contents.Data(), contents.ByteLength(), mode);
+  return Utils::ToLocalShared(buffer);
+}
+
 std::unique_ptr<v8::BackingStore> v8::SharedArrayBuffer::NewBackingStore(
     Isolate* isolate, size_t byte_length) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
@@ -9165,7 +9501,7 @@ void v8::Isolate::LocaleConfigurationChangeNotification() {
 #endif  // V8_INTL_SUPPORT
 }
 
-bool v8::Object::IsCodeLike(v8::Isolate* isolate) const {
+bool v8::Object::IsCodeLike(v8::Isolate* isolate) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   LOG_API(i_isolate, Object, IsCodeLike);
   ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
@@ -9216,21 +9552,18 @@ MicrotasksScope::~MicrotasksScope() {
 #endif
 }
 
-// static
 void MicrotasksScope::PerformCheckpoint(Isolate* v8_isolate) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   auto* microtask_queue = isolate->default_microtask_queue();
   microtask_queue->PerformCheckpoint(v8_isolate);
 }
 
-// static
 int MicrotasksScope::GetCurrentDepth(Isolate* v8_isolate) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   auto* microtask_queue = isolate->default_microtask_queue();
   return microtask_queue->GetMicrotasksScopeDepth();
 }
 
-// static
 bool MicrotasksScope::IsRunningMicrotasks(Isolate* v8_isolate) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   auto* microtask_queue = isolate->default_microtask_queue();
@@ -9513,21 +9846,7 @@ CpuProfilingOptions::CpuProfilingOptions(CpuProfilingMode mode,
                                          MaybeLocal<Context> filter_context)
     : mode_(mode),
       max_samples_(max_samples),
-      sampling_interval_us_(sampling_interval_us) {
-  if (!filter_context.IsEmpty()) {
-    Local<Context> local_filter_context = filter_context.ToLocalChecked();
-    filter_context_.Reset(local_filter_context->GetIsolate(),
-                          local_filter_context);
-    filter_context_.SetWeak();
-  }
-}
-
-void* CpuProfilingOptions::raw_filter_context() const {
-  return reinterpret_cast<void*>(
-      i::Context::cast(*Utils::OpenPersistent(filter_context_))
-          .native_context()
-          .address());
-}
+      sampling_interval_us_(sampling_interval_us) {}
 
 void CpuProfiler::Dispose() { delete reinterpret_cast<i::CpuProfiler*>(this); }
 
@@ -9807,6 +10126,14 @@ void HeapProfiler::ClearObjectIds() {
 }
 
 const HeapSnapshot* HeapProfiler::TakeHeapSnapshot(
+    ActivityControl* control, ObjectNameResolver* resolver,
+    bool treat_global_objects_as_roots) {
+  return reinterpret_cast<const HeapSnapshot*>(
+      reinterpret_cast<i::HeapProfiler*>(this)->TakeSnapshot(
+          control, resolver, treat_global_objects_as_roots, false));
+}
+
+const HeapSnapshot* HeapProfiler::TakeHeapSnapshotV8_92(
     ActivityControl* control, ObjectNameResolver* resolver,
     bool treat_global_objects_as_roots, bool capture_numeric_value) {
   return reinterpret_cast<const HeapSnapshot*>(
diff --git a/deps/v8/src/execution/isolate-data.h b/deps/v8/src/execution/isolate-data.h
index bc3e2b8d1a6b40..0232d70d2b8d53 100644
--- a/deps/v8/src/execution/isolate-data.h
+++ b/deps/v8/src/execution/isolate-data.h
@@ -30,7 +30,7 @@ class Isolate;
 class IsolateData final {
  public:
   IsolateData(Isolate* isolate, Address cage_base)
-      : cage_base_(cage_base), stack_guard_(isolate) {}
+      : stack_guard_(isolate), cage_base_(cage_base) {}
 
   IsolateData(const IsolateData&) = delete;
   IsolateData& operator=(const IsolateData&) = delete;
@@ -159,10 +159,9 @@ class IsolateData final {
   V(kFastCCallCallerFPOffset, kSystemPointerSize)                             \
   V(kFastCCallCallerPCOffset, kSystemPointerSize)                             \
   V(kFastApiCallTargetOffset, kSystemPointerSize)                             \
-  V(kCageBaseOffset, kSystemPointerSize)                                      \
-  V(kLongTaskStatsCounterOffset, kSizetSize)                                  \
   V(kStackGuardOffset, StackGuard::kSizeInBytes)                              \
   V(kRootsTableOffset, RootsTable::kEntriesCount* kSystemPointerSize)         \
+  V(kCageBaseOffset, kSystemPointerSize)                                      \
   V(kExternalReferenceTableOffset, ExternalReferenceTable::kSizeInBytes)      \
   V(kThreadLocalTopOffset, ThreadLocalTop::kSizeInBytes)                      \
   V(kBuiltinEntryTableOffset, Builtins::builtin_count* kSystemPointerSize)    \
@@ -199,18 +198,14 @@ class IsolateData final {
   Address fast_c_call_caller_pc_ = kNullAddress;
   Address fast_api_call_target_ = kNullAddress;
 
-  Address cage_base_ = kNullAddress;
-
-  // Used for implementation of LongTaskStats. Counts the number of potential
-  // long tasks.
-  size_t long_task_stats_counter_ = 0;
-
   // Fields related to the system and JS stack. In particular, this contains
   // the stack limit used by stack checks in generated code.
   StackGuard stack_guard_;
 
   RootsTable roots_;
 
+  Address cage_base_ = kNullAddress;
+
   ExternalReferenceTable external_reference_table_;
 
   ThreadLocalTop thread_local_top_;
@@ -271,8 +266,6 @@ void IsolateData::AssertPredictableLayout() {
   STATIC_ASSERT(offsetof(IsolateData, fast_api_call_target_) ==
                 kFastApiCallTargetOffset);
   STATIC_ASSERT(offsetof(IsolateData, cage_base_) == kCageBaseOffset);
-  STATIC_ASSERT(offsetof(IsolateData, long_task_stats_counter_) ==
-                kLongTaskStatsCounterOffset);
   STATIC_ASSERT(offsetof(IsolateData, stack_guard_) == kStackGuardOffset);
 #ifdef V8_HEAP_SANDBOX
   STATIC_ASSERT(offsetof(IsolateData, external_pointer_table_) ==
diff --git a/deps/v8/src/execution/isolate.cc b/deps/v8/src/execution/isolate.cc
index b4070372eeee34..90063fddd014b7 100644
--- a/deps/v8/src/execution/isolate.cc
+++ b/deps/v8/src/execution/isolate.cc
@@ -3055,11 +3055,6 @@ void Isolate::CheckIsolateLayout() {
   CHECK_EQ(static_cast<int>(
                OFFSET_OF(Isolate, isolate_data_.fast_c_call_caller_pc_)),
            Internals::kIsolateFastCCallCallerPcOffset);
-  CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, isolate_data_.cage_base_)),
-           Internals::kIsolateCageBaseOffset);
-  CHECK_EQ(static_cast<int>(
-               OFFSET_OF(Isolate, isolate_data_.long_task_stats_counter_)),
-           Internals::kIsolateLongTaskStatsCounterOffset);
   CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, isolate_data_.stack_guard_)),
            Internals::kIsolateStackGuardOffset);
   CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, isolate_data_.roots_)),
@@ -5012,18 +5007,6 @@ MaybeLocal<v8::Context> Isolate::GetContextFromRecorderContextId(
   return result->second.Get(reinterpret_cast<v8::Isolate*>(this));
 }
 
-void Isolate::UpdateLongTaskStats() {
-  if (last_long_task_stats_counter_ != isolate_data_.long_task_stats_counter_) {
-    last_long_task_stats_counter_ = isolate_data_.long_task_stats_counter_;
-    long_task_stats_ = v8::metrics::LongTaskStats{};
-  }
-}
-
-v8::metrics::LongTaskStats* Isolate::GetCurrentLongTaskStats() {
-  UpdateLongTaskStats();
-  return &long_task_stats_;
-}
-
 void Isolate::RemoveContextIdCallback(const v8::WeakCallbackInfo<void>& data) {
   Isolate* isolate = reinterpret_cast<Isolate*>(data.GetIsolate());
   uintptr_t context_id = reinterpret_cast<uintptr_t>(data.GetParameter());
diff --git a/deps/v8/src/execution/isolate.h b/deps/v8/src/execution/isolate.h
index f55af20acdf4a8..56b6daac554966 100644
--- a/deps/v8/src/execution/isolate.h
+++ b/deps/v8/src/execution/isolate.h
@@ -1740,9 +1740,6 @@ class V8_EXPORT_PRIVATE Isolate final : private HiddenFactory {
   MaybeLocal<v8::Context> GetContextFromRecorderContextId(
       v8::metrics::Recorder::ContextId id);
 
-  void UpdateLongTaskStats();
-  v8::metrics::LongTaskStats* GetCurrentLongTaskStats();
-
   LocalIsolate* main_thread_local_isolate() {
     return main_thread_local_isolate_.get();
   }
@@ -2107,9 +2104,6 @@ class V8_EXPORT_PRIVATE Isolate final : private HiddenFactory {
       Persistent<v8::Context, v8::CopyablePersistentTraits<v8::Context>>>
       recorder_context_id_map_;
 
-  size_t last_long_task_stats_counter_ = 0;
-  v8::metrics::LongTaskStats long_task_stats_;
-
   std::vector<Object> startup_object_cache_;
 
   // Used during builtins compilation to build the builtins constants table,
diff --git a/deps/v8/src/heap/gc-tracer.cc b/deps/v8/src/heap/gc-tracer.cc
index 70f8c276270b8a..d2b05971df276a 100644
--- a/deps/v8/src/heap/gc-tracer.cc
+++ b/deps/v8/src/heap/gc-tracer.cc
@@ -87,15 +87,6 @@ GCTracer::Scope::~Scope() {
   if (thread_kind_ == ThreadKind::kMain) {
     DCHECK_EQ(tracer_->heap_->isolate()->thread_id(), ThreadId::Current());
     tracer_->AddScopeSample(scope_, duration_ms);
-    if (scope_ == ScopeId::MC_INCREMENTAL ||
-        scope_ == ScopeId::MC_INCREMENTAL_START ||
-        scope_ == MC_INCREMENTAL_FINALIZE) {
-      auto* long_task_stats =
-          tracer_->heap_->isolate()->GetCurrentLongTaskStats();
-      long_task_stats->gc_full_incremental_wall_clock_duration_us +=
-          static_cast<int64_t>(duration_ms *
-                               base::Time::kMicrosecondsPerMillisecond);
-    }
   } else {
     tracer_->AddScopeSampleBackground(scope_, duration_ms);
   }
@@ -353,9 +344,6 @@ void GCTracer::Stop(GarbageCollector collector) {
   AddAllocation(current_.end_time);
 
   double duration = current_.end_time - current_.start_time;
-  int64_t duration_us =
-      static_cast<int64_t>(duration * base::Time::kMicrosecondsPerMillisecond);
-  auto* long_task_stats = heap_->isolate()->GetCurrentLongTaskStats();
 
   switch (current_.type) {
     case Event::SCAVENGER:
@@ -365,7 +353,6 @@ void GCTracer::Stop(GarbageCollector collector) {
       recorded_minor_gcs_survived_.Push(
           MakeBytesAndDuration(current_.survived_young_object_size, duration));
       FetchBackgroundMinorGCCounters();
-      long_task_stats->gc_young_wall_clock_duration_us += duration_us;
       break;
     case Event::INCREMENTAL_MARK_COMPACTOR:
       current_.incremental_marking_bytes = incremental_marking_bytes_;
@@ -385,7 +372,6 @@ void GCTracer::Stop(GarbageCollector collector) {
       ResetIncrementalMarkingCounters();
       combined_mark_compact_speed_cache_ = 0.0;
       FetchBackgroundMarkCompactCounters();
-      long_task_stats->gc_full_atomic_wall_clock_duration_us += duration_us;
       break;
     case Event::MARK_COMPACTOR:
       DCHECK_EQ(0u, current_.incremental_marking_bytes);
@@ -398,7 +384,6 @@ void GCTracer::Stop(GarbageCollector collector) {
       ResetIncrementalMarkingCounters();
       combined_mark_compact_speed_cache_ = 0.0;
       FetchBackgroundMarkCompactCounters();
-      long_task_stats->gc_full_atomic_wall_clock_duration_us += duration_us;
       break;
     case Event::START:
       UNREACHABLE();
diff --git a/deps/v8/src/heap/heap.cc b/deps/v8/src/heap/heap.cc
index 9da67b75344ccc..d302a2e665e855 100644
--- a/deps/v8/src/heap/heap.cc
+++ b/deps/v8/src/heap/heap.cc
@@ -3252,9 +3252,6 @@ void Heap::OnMoveEvent(HeapObject target, HeapObject source,
   if (target.IsSharedFunctionInfo()) {
     LOG_CODE_EVENT(isolate_, SharedFunctionInfoMoveEvent(source.address(),
                                                          target.address()));
-  } else if (target.IsNativeContext()) {
-    PROFILE(isolate_,
-            NativeContextMoveEvent(source.address(), target.address()));
   }
 
   if (FLAG_verify_predictable) {
diff --git a/deps/v8/src/inspector/v8-heap-profiler-agent-impl.cc b/deps/v8/src/inspector/v8-heap-profiler-agent-impl.cc
index b441be565c9b9c..9f82f0d50d7205 100644
--- a/deps/v8/src/inspector/v8-heap-profiler-agent-impl.cc
+++ b/deps/v8/src/inspector/v8-heap-profiler-agent-impl.cc
@@ -269,7 +269,7 @@ Response V8HeapProfilerAgentImpl::takeHeapSnapshot(
     progress.reset(new HeapSnapshotProgress(&m_frontend));
 
   GlobalObjectNameResolver resolver(m_session);
-  const v8::HeapSnapshot* snapshot = profiler->TakeHeapSnapshot(
+  const v8::HeapSnapshot* snapshot = profiler->TakeHeapSnapshotV8_92(
       progress.get(), &resolver, treatGlobalObjectsAsRoots.fromMaybe(true),
       captureNumericValue.fromMaybe(false));
   if (!snapshot) return Response::ServerError("Failed to take heap snapshot");
diff --git a/deps/v8/src/logging/code-events.h b/deps/v8/src/logging/code-events.h
index cda7c39fc7c976..c009ba0b15dd52 100644
--- a/deps/v8/src/logging/code-events.h
+++ b/deps/v8/src/logging/code-events.h
@@ -98,7 +98,6 @@ class CodeEventListener {
   // Not handlified as this happens during GC. No allocation allowed.
   virtual void CodeMoveEvent(AbstractCode from, AbstractCode to) = 0;
   virtual void SharedFunctionInfoMoveEvent(Address from, Address to) = 0;
-  virtual void NativeContextMoveEvent(Address from, Address to) = 0;
   virtual void CodeMovingGCEvent() = 0;
   virtual void CodeDisableOptEvent(Handle<AbstractCode> code,
                                    Handle<SharedFunctionInfo> shared) = 0;
@@ -218,11 +217,6 @@ class CodeEventDispatcher : public CodeEventListener {
       listener->SharedFunctionInfoMoveEvent(from, to);
     });
   }
-  void NativeContextMoveEvent(Address from, Address to) override {
-    DispatchEventToListeners([=](CodeEventListener* listener) {
-      listener->NativeContextMoveEvent(from, to);
-    });
-  }
   void CodeMovingGCEvent() override {
     DispatchEventToListeners(
         [](CodeEventListener* listener) { listener->CodeMovingGCEvent(); });
diff --git a/deps/v8/src/logging/log.h b/deps/v8/src/logging/log.h
index ec1903206018fe..e52f9f28338199 100644
--- a/deps/v8/src/logging/log.h
+++ b/deps/v8/src/logging/log.h
@@ -208,7 +208,6 @@ class Logger : public CodeEventListener {
                              Handle<String> source) override;
   void CodeMoveEvent(AbstractCode from, AbstractCode to) override;
   void SharedFunctionInfoMoveEvent(Address from, Address to) override;
-  void NativeContextMoveEvent(Address from, Address to) override {}
   void CodeMovingGCEvent() override;
   void CodeDisableOptEvent(Handle<AbstractCode> code,
                            Handle<SharedFunctionInfo> shared) override;
@@ -411,7 +410,6 @@ class V8_EXPORT_PRIVATE CodeEventLogger : public CodeEventListener {
   void GetterCallbackEvent(Handle<Name> name, Address entry_point) override {}
   void SetterCallbackEvent(Handle<Name> name, Address entry_point) override {}
   void SharedFunctionInfoMoveEvent(Address from, Address to) override {}
-  void NativeContextMoveEvent(Address from, Address to) override {}
   void CodeMovingGCEvent() override {}
   void CodeDeoptEvent(Handle<Code> code, DeoptimizeKind kind, Address pc,
                       int fp_to_sp_delta, bool reuse_code) override {}
@@ -477,7 +475,6 @@ class ExternalCodeEventListener : public CodeEventListener {
   void GetterCallbackEvent(Handle<Name> name, Address entry_point) override {}
   void SetterCallbackEvent(Handle<Name> name, Address entry_point) override {}
   void SharedFunctionInfoMoveEvent(Address from, Address to) override {}
-  void NativeContextMoveEvent(Address from, Address to) override {}
   void CodeMoveEvent(AbstractCode from, AbstractCode to) override;
   void CodeDisableOptEvent(Handle<AbstractCode> code,
                            Handle<SharedFunctionInfo> shared) override {}
diff --git a/deps/v8/src/objects/backing-store.cc b/deps/v8/src/objects/backing-store.cc
index 77eaf3a722cdbb..a3b6418037cb7e 100644
--- a/deps/v8/src/objects/backing-store.cc
+++ b/deps/v8/src/objects/backing-store.cc
@@ -811,8 +811,17 @@ inline GlobalBackingStoreRegistryImpl* impl() {
 void GlobalBackingStoreRegistry::Register(
     std::shared_ptr<BackingStore> backing_store) {
   if (!backing_store || !backing_store->buffer_start()) return;
-  // Only wasm memory backing stores need to be registered globally.
-  CHECK(backing_store->is_wasm_memory());
+
+  if (!backing_store->free_on_destruct()) {
+    // If the backing store buffer is managed by the embedder,
+    // then we don't have to guarantee that there is single unique
+    // BackingStore per buffer_start() because the destructor of
+    // of the BackingStore will be a no-op in that case.
+
+    // All Wasm memory has to be registered.
+    CHECK(!backing_store->is_wasm_memory());
+    return;
+  }
 
   base::MutexGuard scope_lock(&impl()->mutex_);
   if (backing_store->globally_registered_) return;
@@ -828,8 +837,6 @@ void GlobalBackingStoreRegistry::Register(
 void GlobalBackingStoreRegistry::Unregister(BackingStore* backing_store) {
   if (!backing_store->globally_registered_) return;
 
-  CHECK(backing_store->is_wasm_memory());
-
   DCHECK_NOT_NULL(backing_store->buffer_start());
 
   base::MutexGuard scope_lock(&impl()->mutex_);
@@ -841,6 +848,26 @@ void GlobalBackingStoreRegistry::Unregister(BackingStore* backing_store) {
   backing_store->globally_registered_ = false;
 }
 
+std::shared_ptr<BackingStore> GlobalBackingStoreRegistry::Lookup(
+    void* buffer_start, size_t length) {
+  base::MutexGuard scope_lock(&impl()->mutex_);
+  TRACE_BS("BS:lookup   mem=%p (%zu bytes)\n", buffer_start, length);
+  const auto& result = impl()->map_.find(buffer_start);
+  if (result == impl()->map_.end()) {
+    return std::shared_ptr<BackingStore>();
+  }
+  auto backing_store = result->second.lock();
+  CHECK_EQ(buffer_start, backing_store->buffer_start());
+  if (backing_store->is_wasm_memory()) {
+    // Grow calls to shared WebAssembly threads can be triggered from different
+    // workers, length equality cannot be guaranteed here.
+    CHECK_LE(length, backing_store->byte_length());
+  } else {
+    CHECK_EQ(length, backing_store->byte_length());
+  }
+  return backing_store;
+}
+
 void GlobalBackingStoreRegistry::Purge(Isolate* isolate) {
   // We need to keep a reference to all backing stores that are inspected
   // in the purging loop below. Otherwise, we might get a deadlock
@@ -854,7 +881,7 @@ void GlobalBackingStoreRegistry::Purge(Isolate* isolate) {
     auto backing_store = entry.second.lock();
     prevent_destruction_under_lock.emplace_back(backing_store);
     if (!backing_store) continue;  // skip entries where weak ptr is null
-    CHECK(backing_store->is_wasm_memory());
+    if (!backing_store->is_wasm_memory()) continue;  // skip non-wasm memory
     if (!backing_store->is_shared()) continue;       // skip non-shared memory
     SharedWasmMemoryData* shared_data =
         backing_store->get_shared_wasm_memory_data();
diff --git a/deps/v8/src/objects/backing-store.h b/deps/v8/src/objects/backing-store.h
index 5598388d3b9143..7258d11b1ea55b 100644
--- a/deps/v8/src/objects/backing-store.h
+++ b/deps/v8/src/objects/backing-store.h
@@ -246,16 +246,21 @@ class V8_EXPORT_PRIVATE BackingStore : public BackingStoreBase {
 #endif  // V8_ENABLE_WEBASSEMBLY
 };
 
-// A global, per-process mapping from buffer addresses to backing stores
-// of wasm memory objects.
+// A global, per-process mapping from buffer addresses to backing stores.
+// This is generally only used for dealing with an embedder that has not
+// migrated to the new API which should use proper pointers to manage
+// backing stores.
 class GlobalBackingStoreRegistry {
  public:
   // Register a backing store in the global registry. A mapping from the
   // {buffer_start} to the backing store object will be added. The backing
   // store will automatically unregister itself upon destruction.
-  // Only wasm memory backing stores are supported.
   static void Register(std::shared_ptr<BackingStore> backing_store);
 
+  // Look up a backing store based on the {buffer_start} pointer.
+  static std::shared_ptr<BackingStore> Lookup(void* buffer_start,
+                                              size_t length);
+
  private:
   friend class BackingStore;
   // Unregister a backing store in the global registry.
diff --git a/deps/v8/src/objects/string-inl.h b/deps/v8/src/objects/string-inl.h
index 8b71536d8f59f8..a886c3eb7997bb 100644
--- a/deps/v8/src/objects/string-inl.h
+++ b/deps/v8/src/objects/string-inl.h
@@ -134,51 +134,49 @@ StringShape::StringShape(InstanceType t) : type_(static_cast<uint32_t>(t)) {
   DCHECK_EQ(type_ & kIsNotStringMask, kStringTag);
 }
 
-bool StringShape::IsInternalized() const {
+bool StringShape::IsInternalized() {
   DCHECK(valid());
   STATIC_ASSERT(kNotInternalizedTag != 0);
   return (type_ & (kIsNotStringMask | kIsNotInternalizedMask)) ==
          (kStringTag | kInternalizedTag);
 }
 
-bool StringShape::IsCons() const {
+bool StringShape::IsCons() {
   return (type_ & kStringRepresentationMask) == kConsStringTag;
 }
 
-bool StringShape::IsThin() const {
+bool StringShape::IsThin() {
   return (type_ & kStringRepresentationMask) == kThinStringTag;
 }
 
-bool StringShape::IsSliced() const {
+bool StringShape::IsSliced() {
   return (type_ & kStringRepresentationMask) == kSlicedStringTag;
 }
 
-bool StringShape::IsIndirect() const {
+bool StringShape::IsIndirect() {
   return (type_ & kIsIndirectStringMask) == kIsIndirectStringTag;
 }
 
-bool StringShape::IsExternal() const {
+bool StringShape::IsExternal() {
   return (type_ & kStringRepresentationMask) == kExternalStringTag;
 }
 
-bool StringShape::IsSequential() const {
+bool StringShape::IsSequential() {
   return (type_ & kStringRepresentationMask) == kSeqStringTag;
 }
 
-bool StringShape::IsUncachedExternal() const {
+bool StringShape::IsUncachedExternal() {
   return (type_ & kUncachedExternalStringMask) == kUncachedExternalStringTag;
 }
 
-StringRepresentationTag StringShape::representation_tag() const {
+StringRepresentationTag StringShape::representation_tag() {
   uint32_t tag = (type_ & kStringRepresentationMask);
   return static_cast<StringRepresentationTag>(tag);
 }
 
-uint32_t StringShape::encoding_tag() const {
-  return type_ & kStringEncodingMask;
-}
+uint32_t StringShape::encoding_tag() { return type_ & kStringEncodingMask; }
 
-uint32_t StringShape::full_representation_tag() const {
+uint32_t StringShape::full_representation_tag() {
   return (type_ & (kStringRepresentationMask | kStringEncodingMask));
 }
 
@@ -188,15 +186,15 @@ STATIC_ASSERT((kStringRepresentationMask | kStringEncodingMask) ==
 STATIC_ASSERT(static_cast<uint32_t>(kStringEncodingMask) ==
               Internals::kStringEncodingMask);
 
-bool StringShape::IsSequentialOneByte() const {
+bool StringShape::IsSequentialOneByte() {
   return full_representation_tag() == (kSeqStringTag | kOneByteStringTag);
 }
 
-bool StringShape::IsSequentialTwoByte() const {
+bool StringShape::IsSequentialTwoByte() {
   return full_representation_tag() == (kSeqStringTag | kTwoByteStringTag);
 }
 
-bool StringShape::IsExternalOneByte() const {
+bool StringShape::IsExternalOneByte() {
   return full_representation_tag() == (kExternalStringTag | kOneByteStringTag);
 }
 
@@ -205,7 +203,7 @@ STATIC_ASSERT((kExternalStringTag | kOneByteStringTag) ==
 
 STATIC_ASSERT(v8::String::ONE_BYTE_ENCODING == kOneByteStringTag);
 
-bool StringShape::IsExternalTwoByte() const {
+bool StringShape::IsExternalTwoByte() {
   return full_representation_tag() == (kExternalStringTag | kTwoByteStringTag);
 }
 
@@ -301,7 +299,7 @@ bool String::IsOneByteRepresentationUnderneath(String string) {
   }
 }
 
-uc32 FlatStringReader::Get(int index) const {
+uc32 FlatStringReader::Get(int index) {
   if (is_one_byte_) {
     return Get<uint8_t>(index);
   } else {
@@ -310,7 +308,7 @@ uc32 FlatStringReader::Get(int index) const {
 }
 
 template <typename Char>
-Char FlatStringReader::Get(int index) const {
+Char FlatStringReader::Get(int index) {
   DCHECK_EQ(is_one_byte_, sizeof(Char) == 1);
   DCHECK(0 <= index && index < length_);
   if (sizeof(Char) == 1) {
@@ -436,7 +434,7 @@ class SeqSubStringKey final : public StringTableKey {
 using SeqOneByteSubStringKey = SeqSubStringKey<SeqOneByteString>;
 using SeqTwoByteSubStringKey = SeqSubStringKey<SeqTwoByteString>;
 
-bool String::Equals(String other) const {
+bool String::Equals(String other) {
   if (other == *this) return true;
   if (this->IsInternalizedString() && other.IsInternalizedString()) {
     return false;
@@ -444,7 +442,6 @@ bool String::Equals(String other) const {
   return SlowEquals(other);
 }
 
-// static
 bool String::Equals(Isolate* isolate, Handle<String> one, Handle<String> two) {
   if (one.is_identical_to(two)) return true;
   if (one->IsInternalizedString() && two->IsInternalizedString()) {
@@ -578,7 +575,7 @@ bool String::IsConsStringEqualToImpl(
 bool String::IsOneByteEqualTo(Vector<const char> str) { return IsEqualTo(str); }
 
 template <typename Char>
-const Char* String::GetChars(const DisallowGarbageCollection& no_gc) const {
+const Char* String::GetChars(const DisallowGarbageCollection& no_gc) {
   DCHECK(!SharedStringAccessGuardIfNeeded::IsNeeded(*this));
   return StringShape(*this).IsExternal()
              ? CharTraits<Char>::ExternalString::cast(*this).GetChars()
@@ -588,7 +585,7 @@ const Char* String::GetChars(const DisallowGarbageCollection& no_gc) const {
 template <typename Char>
 const Char* String::GetChars(
     const DisallowGarbageCollection& no_gc,
-    const SharedStringAccessGuardIfNeeded& access_guard) const {
+    const SharedStringAccessGuardIfNeeded& access_guard) {
   return StringShape(*this).IsExternal()
              ? CharTraits<Char>::ExternalString::cast(*this).GetChars()
              : CharTraits<Char>::String::cast(*this).GetChars(no_gc,
@@ -619,17 +616,17 @@ Handle<String> String::Flatten(LocalIsolate* isolate, Handle<String> string,
   return string;
 }
 
-uint16_t String::Get(int index, Isolate* isolate) const {
+uint16_t String::Get(int index, Isolate* isolate) {
   DCHECK(!SharedStringAccessGuardIfNeeded::IsNeeded(*this));
   return GetImpl(index);
 }
 
-uint16_t String::Get(int index, LocalIsolate* local_isolate) const {
+uint16_t String::Get(int index, LocalIsolate* local_isolate) {
   SharedStringAccessGuardIfNeeded scope(local_isolate);
   return GetImpl(index);
 }
 
-uint16_t String::GetImpl(int index) const {
+uint16_t String::GetImpl(int index) {
   DCHECK(index >= 0 && index < length());
 
   class StringGetDispatcher : public AllStatic {
@@ -658,12 +655,12 @@ void String::Set(int index, uint16_t value) {
              : SeqTwoByteString::cast(*this).SeqTwoByteStringSet(index, value);
 }
 
-bool String::IsFlat() const {
+bool String::IsFlat() {
   if (!StringShape(*this).IsCons()) return true;
   return ConsString::cast(*this).second().length() == 0;
 }
 
-String String::GetUnderlying() const {
+String String::GetUnderlying() {
   // Giving direct access to underlying string only makes sense if the
   // wrapping string is already flattened.
   DCHECK(this->IsFlat());
@@ -767,7 +764,7 @@ uint32_t String::ToValidIndex(Object number) {
   return index;
 }
 
-uint8_t SeqOneByteString::Get(int index) const {
+uint8_t SeqOneByteString::Get(int index) {
   DCHECK(index >= 0 && index < length());
   return ReadField<byte>(kHeaderSize + index * kCharSize);
 }
@@ -777,12 +774,11 @@ void SeqOneByteString::SeqOneByteStringSet(int index, uint16_t value) {
   WriteField<byte>(kHeaderSize + index * kCharSize, static_cast<byte>(value));
 }
 
-Address SeqOneByteString::GetCharsAddress() const {
+Address SeqOneByteString::GetCharsAddress() {
   return field_address(kHeaderSize);
 }
 
-uint8_t* SeqOneByteString::GetChars(
-    const DisallowGarbageCollection& no_gc) const {
+uint8_t* SeqOneByteString::GetChars(const DisallowGarbageCollection& no_gc) {
   USE(no_gc);
   DCHECK(!SharedStringAccessGuardIfNeeded::IsNeeded(*this));
   return reinterpret_cast<uint8_t*>(GetCharsAddress());
@@ -790,17 +786,17 @@ uint8_t* SeqOneByteString::GetChars(
 
 uint8_t* SeqOneByteString::GetChars(
     const DisallowGarbageCollection& no_gc,
-    const SharedStringAccessGuardIfNeeded& access_guard) const {
+    const SharedStringAccessGuardIfNeeded& access_guard) {
   USE(no_gc);
   USE(access_guard);
   return reinterpret_cast<uint8_t*>(GetCharsAddress());
 }
 
-Address SeqTwoByteString::GetCharsAddress() const {
+Address SeqTwoByteString::GetCharsAddress() {
   return field_address(kHeaderSize);
 }
 
-uc16* SeqTwoByteString::GetChars(const DisallowGarbageCollection& no_gc) const {
+uc16* SeqTwoByteString::GetChars(const DisallowGarbageCollection& no_gc) {
   USE(no_gc);
   DCHECK(!SharedStringAccessGuardIfNeeded::IsNeeded(*this));
   return reinterpret_cast<uc16*>(GetCharsAddress());
@@ -808,13 +804,13 @@ uc16* SeqTwoByteString::GetChars(const DisallowGarbageCollection& no_gc) const {
 
 uc16* SeqTwoByteString::GetChars(
     const DisallowGarbageCollection& no_gc,
-    const SharedStringAccessGuardIfNeeded& access_guard) const {
+    const SharedStringAccessGuardIfNeeded& access_guard) {
   USE(no_gc);
   USE(access_guard);
   return reinterpret_cast<uc16*>(GetCharsAddress());
 }
 
-uint16_t SeqTwoByteString::Get(int index) const {
+uint16_t SeqTwoByteString::Get(int index) {
   DCHECK(index >= 0 && index < length());
   return ReadField<uint16_t>(kHeaderSize + index * kShortSize);
 }
@@ -942,7 +938,7 @@ void ExternalOneByteString::set_resource(
   if (resource != nullptr) update_data_cache(isolate);
 }
 
-const uint8_t* ExternalOneByteString::GetChars() const {
+const uint8_t* ExternalOneByteString::GetChars() {
   DisallowGarbageCollection no_gc;
   if (is_uncached()) {
     if (resource()->IsCacheable()) {
@@ -964,7 +960,7 @@ const uint8_t* ExternalOneByteString::GetChars() const {
   return reinterpret_cast<const uint8_t*>(resource()->data());
 }
 
-uint8_t ExternalOneByteString::Get(int index) const {
+uint8_t ExternalOneByteString::Get(int index) {
   DCHECK(index >= 0 && index < length());
   return GetChars()[index];
 }
@@ -1007,7 +1003,7 @@ void ExternalTwoByteString::set_resource(
   if (resource != nullptr) update_data_cache(isolate);
 }
 
-const uint16_t* ExternalTwoByteString::GetChars() const {
+const uint16_t* ExternalTwoByteString::GetChars() {
   DisallowGarbageCollection no_gc;
   if (is_uncached()) {
     if (resource()->IsCacheable()) {
@@ -1029,7 +1025,7 @@ const uint16_t* ExternalTwoByteString::GetChars() const {
   return resource()->data();
 }
 
-uint16_t ExternalTwoByteString::Get(int index) const {
+uint16_t ExternalTwoByteString::Get(int index) {
   DCHECK(index >= 0 && index < length());
   return GetChars()[index];
 }
diff --git a/deps/v8/src/objects/string.cc b/deps/v8/src/objects/string.cc
index 52bb9679a54cb3..1fbab76697504c 100644
--- a/deps/v8/src/objects/string.cc
+++ b/deps/v8/src/objects/string.cc
@@ -774,7 +774,7 @@ template Handle<FixedArray> String::CalculateLineEnds(LocalIsolate* isolate,
                                                       Handle<String> src,
                                                       bool include_ending_line);
 
-bool String::SlowEquals(String other) const {
+bool String::SlowEquals(String other) {
   DisallowGarbageCollection no_gc;
   // Fast check: negative check with lengths.
   int len = length();
@@ -826,7 +826,6 @@ bool String::SlowEquals(String other) const {
   return comparator.Equals(*this, other);
 }
 
-// static
 bool String::SlowEquals(Isolate* isolate, Handle<String> one,
                         Handle<String> two) {
   // Fast check: negative check with lengths.
@@ -1442,7 +1441,7 @@ void SeqTwoByteString::clear_padding() {
          SizeFor(length()) - data_size);
 }
 
-uint16_t ConsString::Get(int index) const {
+uint16_t ConsString::Get(int index) {
   DCHECK(index >= 0 && index < this->length());
 
   // Check for a flattened cons string
@@ -1471,11 +1470,9 @@ uint16_t ConsString::Get(int index) const {
   UNREACHABLE();
 }
 
-uint16_t ThinString::Get(int index) const { return actual().Get(index); }
+uint16_t ThinString::Get(int index) { return actual().Get(index); }
 
-uint16_t SlicedString::Get(int index) const {
-  return parent().Get(offset() + index);
-}
+uint16_t SlicedString::Get(int index) { return parent().Get(offset() + index); }
 
 int ExternalString::ExternalPayloadSize() const {
   int length_multiplier = IsTwoByteRepresentation() ? i::kShortSize : kCharSize;
diff --git a/deps/v8/src/objects/string.h b/deps/v8/src/objects/string.h
index b873a069ada792..1384295c82956a 100644
--- a/deps/v8/src/objects/string.h
+++ b/deps/v8/src/objects/string.h
@@ -44,25 +44,25 @@ class StringShape {
   inline explicit StringShape(const String s);
   inline explicit StringShape(Map s);
   inline explicit StringShape(InstanceType t);
-  inline bool IsSequential() const;
-  inline bool IsExternal() const;
-  inline bool IsCons() const;
-  inline bool IsSliced() const;
-  inline bool IsThin() const;
-  inline bool IsIndirect() const;
-  inline bool IsUncachedExternal() const;
-  inline bool IsExternalOneByte() const;
-  inline bool IsExternalTwoByte() const;
-  inline bool IsSequentialOneByte() const;
-  inline bool IsSequentialTwoByte() const;
-  inline bool IsInternalized() const;
-  inline StringRepresentationTag representation_tag() const;
-  inline uint32_t encoding_tag() const;
-  inline uint32_t full_representation_tag() const;
+  inline bool IsSequential();
+  inline bool IsExternal();
+  inline bool IsCons();
+  inline bool IsSliced();
+  inline bool IsThin();
+  inline bool IsIndirect();
+  inline bool IsUncachedExternal();
+  inline bool IsExternalOneByte();
+  inline bool IsExternalTwoByte();
+  inline bool IsSequentialOneByte();
+  inline bool IsSequentialTwoByte();
+  inline bool IsInternalized();
+  inline StringRepresentationTag representation_tag();
+  inline uint32_t encoding_tag();
+  inline uint32_t full_representation_tag();
 #ifdef DEBUG
-  inline uint32_t type() const { return type_; }
+  inline uint32_t type() { return type_; }
   inline void invalidate() { valid_ = false; }
-  inline bool valid() const { return valid_; }
+  inline bool valid() { return valid_; }
 #else
   inline void invalidate() {}
 #endif
@@ -181,13 +181,13 @@ class String : public TorqueGeneratedString<String, Name> {
   // SharedStringAccessGuard is not needed (i.e. on the main thread or on
   // read-only strings).
   template <typename Char>
-  inline const Char* GetChars(const DisallowGarbageCollection& no_gc) const;
+  inline const Char* GetChars(const DisallowGarbageCollection& no_gc);
 
   // Get chars from sequential or external strings.
   template <typename Char>
   inline const Char* GetChars(
       const DisallowGarbageCollection& no_gc,
-      const SharedStringAccessGuardIfNeeded& access_guard) const;
+      const SharedStringAccessGuardIfNeeded& access_guard);
 
   // Returns the address of the character at an offset into this string.
   // Requires: this->IsFlat()
@@ -218,8 +218,8 @@ class String : public TorqueGeneratedString<String, Name> {
   // to this method are not efficient unless the string is flat.
   // If it is called from a background thread, the LocalIsolate version should
   // be used.
-  V8_INLINE uint16_t Get(int index, Isolate* isolate = nullptr) const;
-  V8_INLINE uint16_t Get(int index, LocalIsolate* local_isolate) const;
+  V8_INLINE uint16_t Get(int index, Isolate* isolate = nullptr);
+  V8_INLINE uint16_t Get(int index, LocalIsolate* local_isolate);
 
   // ES6 section 7.1.3.1 ToNumber Applied to the String Type
   static Handle<Object> ToNumber(Isolate* isolate, Handle<String> subject);
@@ -254,7 +254,7 @@ class String : public TorqueGeneratedString<String, Name> {
 
   // Returns the parent of a sliced string or first part of a flat cons string.
   // Requires: StringShape(this).IsIndirect() && this->IsFlat()
-  inline String GetUnderlying() const;
+  inline String GetUnderlying();
 
   // String relational comparison, implemented according to ES6 section 7.2.11
   // Abstract Relational Comparison (step 5): The comparison of Strings uses a
@@ -315,7 +315,7 @@ class String : public TorqueGeneratedString<String, Name> {
       int start_index = 0);
 
   // String equality operations.
-  inline bool Equals(String other) const;
+  inline bool Equals(String other);
   inline static bool Equals(Isolate* isolate, Handle<String> one,
                             Handle<String> two);
 
@@ -420,7 +420,7 @@ class String : public TorqueGeneratedString<String, Name> {
   DECL_PRINTER(String)
   DECL_VERIFIER(String)
 
-  inline bool IsFlat() const;
+  inline bool IsFlat();
 
   // Max char codes.
   static const int32_t kMaxOneByteCharCode = unibrow::Latin1::kMaxChar;
@@ -542,7 +542,7 @@ class String : public TorqueGeneratedString<String, Name> {
   friend class InternalizedStringKey;
 
   // Implementation of the Get() public methods. Do not use directly.
-  V8_INLINE uint16_t GetImpl(int index) const;
+  V8_INLINE uint16_t GetImpl(int index);
 
   // Implementation of the IsEqualTo() public methods. Do not use directly.
   template <EqualityType kEqType, typename Char>
@@ -562,7 +562,7 @@ class String : public TorqueGeneratedString<String, Name> {
 
   // Slow case of String::Equals.  This implementation works on any strings
   // but it is most efficient on strings that are almost flat.
-  V8_EXPORT_PRIVATE bool SlowEquals(String other) const;
+  V8_EXPORT_PRIVATE bool SlowEquals(String other);
 
   V8_EXPORT_PRIVATE static bool SlowEquals(Isolate* isolate, Handle<String> one,
                                            Handle<String> two);
@@ -634,21 +634,20 @@ class SeqOneByteString
   using Char = uint8_t;
 
   // Dispatched behavior.
-  inline uint8_t Get(int index) const;
+  inline uint8_t Get(int index);
   inline void SeqOneByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
-  inline Address GetCharsAddress() const;
+  inline Address GetCharsAddress();
 
   // Get a pointer to the characters of the string. May only be called when a
   // SharedStringAccessGuard is not needed (i.e. on the main thread or on
   // read-only strings).
-  inline uint8_t* GetChars(const DisallowGarbageCollection& no_gc) const;
+  inline uint8_t* GetChars(const DisallowGarbageCollection& no_gc);
 
   // Get a pointer to the characters of the string.
-  inline uint8_t* GetChars(
-      const DisallowGarbageCollection& no_gc,
-      const SharedStringAccessGuardIfNeeded& access_guard) const;
+  inline uint8_t* GetChars(const DisallowGarbageCollection& no_gc,
+                           const SharedStringAccessGuardIfNeeded& access_guard);
 
   // Clear uninitialized padding space. This ensures that the snapshot content
   // is deterministic.
@@ -680,21 +679,20 @@ class SeqTwoByteString
   using Char = uint16_t;
 
   // Dispatched behavior.
-  inline uint16_t Get(int index) const;
+  inline uint16_t Get(int index);
   inline void SeqTwoByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
-  inline Address GetCharsAddress() const;
+  inline Address GetCharsAddress();
 
   // Get a pointer to the characters of the string. May only be called when a
   // SharedStringAccessGuard is not needed (i.e. on the main thread or on
   // read-only strings).
-  inline uc16* GetChars(const DisallowGarbageCollection& no_gc) const;
+  inline uc16* GetChars(const DisallowGarbageCollection& no_gc);
 
   // Get a pointer to the characters of the string.
-  inline uc16* GetChars(
-      const DisallowGarbageCollection& no_gc,
-      const SharedStringAccessGuardIfNeeded& access_guard) const;
+  inline uc16* GetChars(const DisallowGarbageCollection& no_gc,
+                        const SharedStringAccessGuardIfNeeded& access_guard);
 
   // Clear uninitialized padding space. This ensures that the snapshot content
   // is deterministic.
@@ -737,7 +735,7 @@ class ConsString : public TorqueGeneratedConsString<ConsString, String> {
   inline Object unchecked_second();
 
   // Dispatched behavior.
-  V8_EXPORT_PRIVATE uint16_t Get(int index) const;
+  V8_EXPORT_PRIVATE uint16_t Get(int index);
 
   // Minimum length for a cons string.
   static const int kMinLength = 13;
@@ -760,7 +758,7 @@ class ThinString : public TorqueGeneratedThinString<ThinString, String> {
  public:
   DECL_GETTER(unchecked_actual, HeapObject)
 
-  V8_EXPORT_PRIVATE uint16_t Get(int index) const;
+  V8_EXPORT_PRIVATE uint16_t Get(int index);
 
   DECL_VERIFIER(ThinString)
 
@@ -786,7 +784,7 @@ class SlicedString : public TorqueGeneratedSlicedString<SlicedString, String> {
   inline void set_parent(String parent,
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
   // Dispatched behavior.
-  V8_EXPORT_PRIVATE uint16_t Get(int index) const;
+  V8_EXPORT_PRIVATE uint16_t Get(int index);
 
   // Minimum length for a sliced string.
   static const int kMinLength = 13;
@@ -865,10 +863,10 @@ class ExternalOneByteString : public ExternalString {
   // which the pointer cache has to be refreshed.
   inline void update_data_cache(Isolate* isolate);
 
-  inline const uint8_t* GetChars() const;
+  inline const uint8_t* GetChars();
 
   // Dispatched behavior.
-  inline uint8_t Get(int index) const;
+  inline uint8_t Get(int index);
 
   DECL_CAST(ExternalOneByteString)
 
@@ -911,10 +909,10 @@ class ExternalTwoByteString : public ExternalString {
   // which the pointer cache has to be refreshed.
   inline void update_data_cache(Isolate* isolate);
 
-  inline const uint16_t* GetChars() const;
+  inline const uint16_t* GetChars();
 
   // Dispatched behavior.
-  inline uint16_t Get(int index) const;
+  inline uint16_t Get(int index);
 
   // For regexp code.
   inline const uint16_t* ExternalTwoByteStringGetData(unsigned start);
@@ -944,9 +942,9 @@ class V8_EXPORT_PRIVATE FlatStringReader : public Relocatable {
  public:
   FlatStringReader(Isolate* isolate, Handle<String> str);
   void PostGarbageCollection() override;
-  inline uc32 Get(int index) const;
+  inline uc32 Get(int index);
   template <typename Char>
-  inline Char Get(int index) const;
+  inline Char Get(int index);
   int length() { return length_; }
 
  private:
diff --git a/deps/v8/src/profiler/cpu-profiler.cc b/deps/v8/src/profiler/cpu-profiler.cc
index ba9022be1b03d0..46a82a77193535 100644
--- a/deps/v8/src/profiler/cpu-profiler.cc
+++ b/deps/v8/src/profiler/cpu-profiler.cc
@@ -104,11 +104,10 @@ ProfilingScope::~ProfilingScope() {
 
 ProfilerEventsProcessor::ProfilerEventsProcessor(
     Isolate* isolate, Symbolizer* symbolizer,
-    ProfilerCodeObserver* code_observer, CpuProfilesCollection* profiles)
+    ProfilerCodeObserver* code_observer)
     : Thread(Thread::Options("v8:ProfEvntProc", kProfilerStackSize)),
       symbolizer_(symbolizer),
       code_observer_(code_observer),
-      profiles_(profiles),
       last_code_event_id_(0),
       last_processed_code_event_id_(0),
       isolate_(isolate) {
@@ -120,8 +119,9 @@ SamplingEventsProcessor::SamplingEventsProcessor(
     Isolate* isolate, Symbolizer* symbolizer,
     ProfilerCodeObserver* code_observer, CpuProfilesCollection* profiles,
     base::TimeDelta period, bool use_precise_sampling)
-    : ProfilerEventsProcessor(isolate, symbolizer, code_observer, profiles),
+    : ProfilerEventsProcessor(isolate, symbolizer, code_observer),
       sampler_(new CpuSampler(isolate, this)),
+      profiles_(profiles),
       period_(period),
       use_precise_sampling_(use_precise_sampling) {
   sampler_->Start();
@@ -188,14 +188,7 @@ void ProfilerEventsProcessor::StopSynchronously() {
 bool ProfilerEventsProcessor::ProcessCodeEvent() {
   CodeEventsContainer record;
   if (events_buffer_.Dequeue(&record)) {
-    if (record.generic.type == CodeEventRecord::NATIVE_CONTEXT_MOVE) {
-      NativeContextMoveEventRecord& nc_record =
-          record.NativeContextMoveEventRecord_;
-      profiles_->UpdateNativeContextAddressForCurrentProfiles(
-          nc_record.from_address, nc_record.to_address);
-    } else {
-      code_observer_->CodeEventHandlerInternal(record);
-    }
+    code_observer_->CodeEventHandlerInternal(record);
     last_processed_code_event_id_ = record.generic.order;
     return true;
   }
@@ -209,7 +202,6 @@ void ProfilerEventsProcessor::CodeEventHandler(
     case CodeEventRecord::CODE_MOVE:
     case CodeEventRecord::CODE_DISABLE_OPT:
     case CodeEventRecord::CODE_DELETE:
-    case CodeEventRecord::NATIVE_CONTEXT_MOVE:
       Enqueue(evt_rec);
       break;
     case CodeEventRecord::CODE_DEOPT: {
@@ -232,8 +224,7 @@ void SamplingEventsProcessor::SymbolizeAndAddToProfiles(
       symbolizer_->SymbolizeTickSample(record->sample);
   profiles_->AddPathToCurrentProfiles(
       record->sample.timestamp, symbolized.stack_trace, symbolized.src_line,
-      record->sample.update_stats, record->sample.sampling_interval,
-      reinterpret_cast<Address>(record->sample.context));
+      record->sample.update_stats, record->sample.sampling_interval);
 }
 
 ProfilerEventsProcessor::SampleProcessingResult
diff --git a/deps/v8/src/profiler/cpu-profiler.h b/deps/v8/src/profiler/cpu-profiler.h
index ced37e4ade59d1..d605a8c3d3d229 100644
--- a/deps/v8/src/profiler/cpu-profiler.h
+++ b/deps/v8/src/profiler/cpu-profiler.h
@@ -37,14 +37,10 @@ class Symbolizer;
   V(REPORT_BUILTIN, ReportBuiltinEventRecord)    \
   V(CODE_DELETE, CodeDeleteEventRecord)
 
-#define VM_EVENTS_TYPE_LIST(V) \
-  CODE_EVENTS_TYPE_LIST(V)     \
-  V(NATIVE_CONTEXT_MOVE, NativeContextMoveEventRecord)
-
 class CodeEventRecord {
  public:
 #define DECLARE_TYPE(type, ignore) type,
-  enum Type { NONE = 0, VM_EVENTS_TYPE_LIST(DECLARE_TYPE) };
+  enum Type { NONE = 0, CODE_EVENTS_TYPE_LIST(DECLARE_TYPE) };
 #undef DECLARE_TYPE
 
   Type type;
@@ -103,13 +99,6 @@ class ReportBuiltinEventRecord : public CodeEventRecord {
   V8_INLINE void UpdateCodeMap(CodeMap* code_map);
 };
 
-// Signals that a native context's address has changed.
-class NativeContextMoveEventRecord : public CodeEventRecord {
- public:
-  Address from_address;
-  Address to_address;
-};
-
 // A record type for sending samples from the main thread/signal handler to the
 // profiling thread.
 class TickSampleEventRecord {
@@ -141,7 +130,7 @@ class CodeEventsContainer {
   union  {
     CodeEventRecord generic;
 #define DECLARE_CLASS(ignore, type) type type##_;
-    VM_EVENTS_TYPE_LIST(DECLARE_CLASS)
+    CODE_EVENTS_TYPE_LIST(DECLARE_CLASS)
 #undef DECLARE_CLASS
   };
 };
@@ -185,8 +174,7 @@ class V8_EXPORT_PRIVATE ProfilerEventsProcessor : public base::Thread,
 
  protected:
   ProfilerEventsProcessor(Isolate* isolate, Symbolizer* symbolizer,
-                          ProfilerCodeObserver* code_observer,
-                          CpuProfilesCollection* profiles);
+                          ProfilerCodeObserver* code_observer);
 
   // Called from events processing thread (Run() method.)
   bool ProcessCodeEvent();
@@ -200,7 +188,6 @@ class V8_EXPORT_PRIVATE ProfilerEventsProcessor : public base::Thread,
 
   Symbolizer* symbolizer_;
   ProfilerCodeObserver* code_observer_;
-  CpuProfilesCollection* profiles_;
   std::atomic_bool running_{true};
   base::ConditionVariable running_cond_;
   base::Mutex running_mutex_;
@@ -251,6 +238,7 @@ class V8_EXPORT_PRIVATE SamplingEventsProcessor
   SamplingCircularQueue<TickSampleEventRecord,
                         kTickSampleQueueLength> ticks_buffer_;
   std::unique_ptr<sampler::Sampler> sampler_;
+  CpuProfilesCollection* profiles_;
   base::TimeDelta period_;           // Samples & code events processing period.
   const bool use_precise_sampling_;  // Whether or not busy-waiting is used for
                                      // low sampling intervals on Windows.
diff --git a/deps/v8/src/profiler/profile-generator.cc b/deps/v8/src/profiler/profile-generator.cc
index 93075d4f7c2a2f..375079de3e80f2 100644
--- a/deps/v8/src/profiler/profile-generator.cc
+++ b/deps/v8/src/profiler/profile-generator.cc
@@ -533,12 +533,6 @@ void ProfileTree::TraverseDepthFirst(Callback* callback) {
   }
 }
 
-void ContextFilter::OnMoveEvent(Address from_address, Address to_address) {
-  if (native_context_address() != from_address) return;
-
-  set_native_context_address(to_address);
-}
-
 using v8::tracing::TracedValue;
 
 std::atomic<uint32_t> CpuProfile::last_id_;
@@ -563,13 +557,6 @@ CpuProfile::CpuProfile(CpuProfiler* profiler, const char* title,
   value->SetDouble("startTime", start_time_.since_origin().InMicroseconds());
   TRACE_EVENT_SAMPLE_WITH_ID1(TRACE_DISABLED_BY_DEFAULT("v8.cpu_profiler"),
                               "Profile", id_, "data", std::move(value));
-
-  DisallowHeapAllocation no_gc;
-  if (options_.has_filter_context()) {
-    i::Address raw_filter_context =
-        reinterpret_cast<i::Address>(options_.raw_filter_context());
-    context_filter_.set_native_context_address(raw_filter_context);
-  }
 }
 
 bool CpuProfile::CheckSubsample(base::TimeDelta source_sampling_interval) {
@@ -719,8 +706,6 @@ void CpuProfile::StreamPendingTraceEvents() {
 
 void CpuProfile::FinishProfile() {
   end_time_ = base::TimeTicks::HighResolutionNow();
-  // Stop tracking context movements after profiling stops.
-  context_filter_.set_native_context_address(kNullAddress);
   StreamPendingTraceEvents();
   auto value = TracedValue::Create();
   // The endTime timestamp is not converted to Perfetto's clock domain and will
@@ -957,26 +942,14 @@ base::TimeDelta CpuProfilesCollection::GetCommonSamplingInterval() const {
 
 void CpuProfilesCollection::AddPathToCurrentProfiles(
     base::TimeTicks timestamp, const ProfileStackTrace& path, int src_line,
-    bool update_stats, base::TimeDelta sampling_interval,
-    Address native_context_address) {
+    bool update_stats, base::TimeDelta sampling_interval) {
   // As starting / stopping profiles is rare relatively to this
   // method, we don't bother minimizing the duration of lock holding,
   // e.g. copying contents of the list to a local vector.
   current_profiles_semaphore_.Wait();
   for (const std::unique_ptr<CpuProfile>& profile : current_profiles_) {
-    if (profile->context_filter().Accept(native_context_address)) {
-      profile->AddPath(timestamp, path, src_line, update_stats,
-                       sampling_interval);
-    }
-  }
-  current_profiles_semaphore_.Signal();
-}
-
-void CpuProfilesCollection::UpdateNativeContextAddressForCurrentProfiles(
-    Address from, Address to) {
-  current_profiles_semaphore_.Wait();
-  for (const std::unique_ptr<CpuProfile>& profile : current_profiles_) {
-    profile->context_filter().OnMoveEvent(from, to);
+    profile->AddPath(timestamp, path, src_line, update_stats,
+                     sampling_interval);
   }
   current_profiles_semaphore_.Signal();
 }
diff --git a/deps/v8/src/profiler/profile-generator.h b/deps/v8/src/profiler/profile-generator.h
index c4bffa945a0412..551dfdf59177c2 100644
--- a/deps/v8/src/profiler/profile-generator.h
+++ b/deps/v8/src/profiler/profile-generator.h
@@ -237,31 +237,6 @@ struct CodeEntryAndLineNumber {
 
 using ProfileStackTrace = std::vector<CodeEntryAndLineNumber>;
 
-// Filters stack frames from sources other than a target native context.
-class ContextFilter {
- public:
-  explicit ContextFilter(Address native_context_address = kNullAddress)
-      : native_context_address_(native_context_address) {}
-
-  // Invoked when a native context has changed address.
-  void OnMoveEvent(Address from_address, Address to_address);
-
-  bool Accept(Address native_context_address) const {
-    if (native_context_address_ == kNullAddress) return true;
-    return (native_context_address & ~kHeapObjectTag) ==
-           native_context_address_;
-  }
-
-  // Update the context's tracked address based on VM-thread events.
-  void set_native_context_address(Address address) {
-    native_context_address_ = address;
-  }
-  Address native_context_address() const { return native_context_address_; }
-
- private:
-  Address native_context_address_;
-};
-
 class ProfileTree;
 
 class V8_EXPORT_PRIVATE ProfileNode {
@@ -411,7 +386,6 @@ class CpuProfile {
   base::TimeTicks start_time() const { return start_time_; }
   base::TimeTicks end_time() const { return end_time_; }
   CpuProfiler* cpu_profiler() const { return profiler_; }
-  ContextFilter& context_filter() { return context_filter_; }
 
   void UpdateTicksScale();
 
@@ -423,7 +397,6 @@ class CpuProfile {
   const char* title_;
   const CpuProfilingOptions options_;
   std::unique_ptr<DiscardedSamplesDelegate> delegate_;
-  ContextFilter context_filter_;
   base::TimeTicks start_time_;
   base::TimeTicks end_time_;
   std::deque<SampleInfo> samples_;
@@ -513,11 +486,7 @@ class V8_EXPORT_PRIVATE CpuProfilesCollection {
   void AddPathToCurrentProfiles(base::TimeTicks timestamp,
                                 const ProfileStackTrace& path, int src_line,
                                 bool update_stats,
-                                base::TimeDelta sampling_interval,
-                                Address native_context_address = kNullAddress);
-
-  // Called from profile generator thread.
-  void UpdateNativeContextAddressForCurrentProfiles(Address from, Address to);
+                                base::TimeDelta sampling_interval);
 
   // Limits the number of profiles that can be simultaneously collected.
   static const int kMaxSimultaneousProfiles = 100;
diff --git a/deps/v8/src/profiler/profiler-listener.cc b/deps/v8/src/profiler/profiler-listener.cc
index a2cfb8b07b2de3..8b253fb4729237 100644
--- a/deps/v8/src/profiler/profiler-listener.cc
+++ b/deps/v8/src/profiler/profiler-listener.cc
@@ -302,13 +302,6 @@ void ProfilerListener::CodeMoveEvent(AbstractCode from, AbstractCode to) {
   DispatchCodeEvent(evt_rec);
 }
 
-void ProfilerListener::NativeContextMoveEvent(Address from, Address to) {
-  CodeEventsContainer evt_rec(CodeEventRecord::NATIVE_CONTEXT_MOVE);
-  evt_rec.NativeContextMoveEventRecord_.from_address = from;
-  evt_rec.NativeContextMoveEventRecord_.to_address = to;
-  DispatchCodeEvent(evt_rec);
-}
-
 void ProfilerListener::CodeDisableOptEvent(Handle<AbstractCode> code,
                                            Handle<SharedFunctionInfo> shared) {
   CodeEventsContainer evt_rec(CodeEventRecord::CODE_DISABLE_OPT);
diff --git a/deps/v8/src/profiler/profiler-listener.h b/deps/v8/src/profiler/profiler-listener.h
index 50a9b818936505..49e7db32baa4c1 100644
--- a/deps/v8/src/profiler/profiler-listener.h
+++ b/deps/v8/src/profiler/profiler-listener.h
@@ -59,7 +59,6 @@ class V8_EXPORT_PRIVATE ProfilerListener : public CodeEventListener,
                              Handle<String> source) override;
   void CodeMoveEvent(AbstractCode from, AbstractCode to) override;
   void SharedFunctionInfoMoveEvent(Address from, Address to) override {}
-  void NativeContextMoveEvent(Address from, Address to) override;
   void CodeMovingGCEvent() override {}
   void CodeDisableOptEvent(Handle<AbstractCode> code,
                            Handle<SharedFunctionInfo> shared) override;
diff --git a/deps/v8/src/profiler/tick-sample.cc b/deps/v8/src/profiler/tick-sample.cc
index 253b80d19e27d4..359e9dede971ef 100644
--- a/deps/v8/src/profiler/tick-sample.cc
+++ b/deps/v8/src/profiler/tick-sample.cc
@@ -177,7 +177,6 @@ DISABLE_ASAN void TickSample::Init(Isolate* v8_isolate,
   pc = regs.pc;
   frames_count = static_cast<unsigned>(info.frames_count);
   has_external_callback = info.external_callback_entry != nullptr;
-  context = info.context;
   if (has_external_callback) {
     external_callback_entry = info.external_callback_entry;
   } else if (frames_count) {
@@ -210,7 +209,6 @@ bool TickSample::GetStackSample(Isolate* v8_isolate, RegisterState* regs,
   sample_info->frames_count = 0;
   sample_info->vm_state = isolate->current_vm_state();
   sample_info->external_callback_entry = nullptr;
-  sample_info->context = nullptr;
   if (sample_info->vm_state == GC) return true;
 
   i::Address js_entry_sp = isolate->js_entry_sp();
@@ -280,13 +278,6 @@ bool TickSample::GetStackSample(Isolate* v8_isolate, RegisterState* regs,
                                reinterpret_cast<i::Address>(regs->lr),
                                js_entry_sp);
 
-  Context top_context = isolate->context();
-  if (top_context.ptr() != i::Context::kNoContext &&
-      top_context.ptr() != i::Context::kInvalidContext) {
-    NativeContext top_native_context = top_context.native_context();
-    sample_info->context = reinterpret_cast<void*>(top_native_context.ptr());
-  }
-
   if (it.done()) return true;
 
   size_t i = 0;
diff --git a/deps/v8/src/profiler/tick-sample.h b/deps/v8/src/profiler/tick-sample.h
index 1bfcb7d0971965..777c3d192dce05 100644
--- a/deps/v8/src/profiler/tick-sample.h
+++ b/deps/v8/src/profiler/tick-sample.h
@@ -90,7 +90,6 @@ struct V8_EXPORT TickSample {
   static const unsigned kMaxFramesCountLog2 = 8;
   static const unsigned kMaxFramesCount = (1 << kMaxFramesCountLog2) - 1;
   void* stack[kMaxFramesCount];     // Call stack.
-  void* context = nullptr;          // Address of the incumbent native context.
   unsigned frames_count : kMaxFramesCountLog2;  // Number of captured frames.
   bool has_external_callback : 1;
   bool update_stats : 1;  // Whether the sample should update aggregated stats.
diff --git a/deps/v8/src/runtime/runtime-test.cc b/deps/v8/src/runtime/runtime-test.cc
index 00a4124dcef58e..5e4092c1eaa387 100644
--- a/deps/v8/src/runtime/runtime-test.cc
+++ b/deps/v8/src/runtime/runtime-test.cc
@@ -1319,7 +1319,6 @@ RUNTIME_FUNCTION(Runtime_EnableCodeLoggingForTesting) {
                                Handle<String> source) final {}
     void CodeMoveEvent(AbstractCode from, AbstractCode to) final {}
     void SharedFunctionInfoMoveEvent(Address from, Address to) final {}
-    void NativeContextMoveEvent(Address from, Address to) final {}
     void CodeMovingGCEvent() final {}
     void CodeDisableOptEvent(Handle<AbstractCode> code,
                              Handle<SharedFunctionInfo> shared) final {}
diff --git a/deps/v8/src/wasm/module-compiler.cc b/deps/v8/src/wasm/module-compiler.cc
index 4742a85070c1d7..662fe7a54fe084 100644
--- a/deps/v8/src/wasm/module-compiler.cc
+++ b/deps/v8/src/wasm/module-compiler.cc
@@ -3370,8 +3370,6 @@ void CompilationStateImpl::WaitForCompilationEvent(
       return done_->load(std::memory_order_relaxed);
     }
 
-    bool IsJoiningThread() const override { return true; }
-
     void NotifyConcurrencyIncrease() override { UNIMPLEMENTED(); }
 
     uint8_t GetTaskId() override { return kMainTaskId; }
diff --git a/deps/v8/test/cctest/heap/test-heap.cc b/deps/v8/test/cctest/heap/test-heap.cc
index b9d6a24a46738e..c989cbb464616d 100644
--- a/deps/v8/test/cctest/heap/test-heap.cc
+++ b/deps/v8/test/cctest/heap/test-heap.cc
@@ -7383,18 +7383,6 @@ TEST(Regress10900) {
   CcTest::CollectAllAvailableGarbage();
 }
 
-namespace {
-void GenerateGarbage() {
-  const char* source =
-      "let roots = [];"
-      "for (let i = 0; i < 100; i++) roots.push(new Array(1000).fill(0));"
-      "roots.push(new Array(1000000).fill(0));"
-      "roots;";
-  CompileRun(source);
-}
-
-}  // anonymous namespace
-
 TEST(Regress11181) {
   FLAG_always_compact = true;
   CcTest::InitializeVM();
@@ -7402,71 +7390,16 @@ TEST(Regress11181) {
       v8::tracing::TracingCategoryObserver::ENABLED_BY_NATIVE,
       std::memory_order_relaxed);
   v8::HandleScope scope(CcTest::isolate());
-  GenerateGarbage();
+  const char* source =
+      "let roots = [];"
+      "for (let i = 0; i < 100; i++) roots.push(new Array(1000).fill(0));"
+      "roots.push(new Array(1000000).fill(0));"
+      "roots;";
+  CompileRun(source);
   CcTest::CollectAllAvailableGarbage();
   TracingFlags::runtime_stats.store(0, std::memory_order_relaxed);
 }
 
-TEST(LongTaskStatsFullAtomic) {
-  CcTest::InitializeVM();
-  v8::Isolate* isolate = CcTest::isolate();
-  v8::HandleScope scope(CcTest::isolate());
-  GenerateGarbage();
-  v8::metrics::LongTaskStats::Reset(isolate);
-  CHECK_EQ(0u, v8::metrics::LongTaskStats::Get(isolate)
-                   .gc_full_atomic_wall_clock_duration_us);
-  for (int i = 0; i < 10; ++i) {
-    CcTest::CollectAllAvailableGarbage();
-  }
-  CHECK_LT(0u, v8::metrics::LongTaskStats::Get(isolate)
-                   .gc_full_atomic_wall_clock_duration_us);
-  v8::metrics::LongTaskStats::Reset(isolate);
-  CHECK_EQ(0u, v8::metrics::LongTaskStats::Get(isolate)
-                   .gc_full_atomic_wall_clock_duration_us);
-}
-
-TEST(LongTaskStatsFullIncremental) {
-  if (!FLAG_incremental_marking) return;
-  CcTest::InitializeVM();
-  v8::Isolate* isolate = CcTest::isolate();
-  v8::HandleScope scope(CcTest::isolate());
-  GenerateGarbage();
-  v8::metrics::LongTaskStats::Reset(isolate);
-  CHECK_EQ(0u, v8::metrics::LongTaskStats::Get(isolate)
-                   .gc_full_incremental_wall_clock_duration_us);
-  for (int i = 0; i < 10; ++i) {
-    heap::SimulateIncrementalMarking(CcTest::heap());
-    CcTest::CollectAllAvailableGarbage();
-  }
-  CHECK_LT(0u, v8::metrics::LongTaskStats::Get(isolate)
-                   .gc_full_incremental_wall_clock_duration_us);
-  v8::metrics::LongTaskStats::Reset(isolate);
-  CHECK_EQ(0u, v8::metrics::LongTaskStats::Get(isolate)
-                   .gc_full_incremental_wall_clock_duration_us);
-}
-
-TEST(LongTaskStatsYoung) {
-  if (FLAG_single_generation) return;
-  CcTest::InitializeVM();
-  v8::Isolate* isolate = CcTest::isolate();
-  v8::HandleScope scope(CcTest::isolate());
-  GenerateGarbage();
-  v8::metrics::LongTaskStats::Reset(isolate);
-  CHECK_EQ(
-      0u,
-      v8::metrics::LongTaskStats::Get(isolate).gc_young_wall_clock_duration_us);
-  for (int i = 0; i < 10; ++i) {
-    CcTest::CollectGarbage(NEW_SPACE);
-  }
-  CHECK_LT(
-      0u,
-      v8::metrics::LongTaskStats::Get(isolate).gc_young_wall_clock_duration_us);
-  v8::metrics::LongTaskStats::Reset(isolate);
-  CHECK_EQ(
-      0u,
-      v8::metrics::LongTaskStats::Get(isolate).gc_young_wall_clock_duration_us);
-}
-
 }  // namespace heap
 }  // namespace internal
 }  // namespace v8
diff --git a/deps/v8/test/cctest/test-api-array-buffer.cc b/deps/v8/test/cctest/test-api-array-buffer.cc
index 9875098d1fb458..86044edcde414a 100644
--- a/deps/v8/test/cctest/test-api-array-buffer.cc
+++ b/deps/v8/test/cctest/test-api-array-buffer.cc
@@ -47,11 +47,31 @@ Local<TypedArray> CreateAndCheck(Local<v8::ArrayBuffer> ab, int byteOffset,
 
 std::shared_ptr<v8::BackingStore> Externalize(Local<v8::ArrayBuffer> ab) {
   std::shared_ptr<v8::BackingStore> backing_store = ab->GetBackingStore();
+  // Keep the tests until the deprecated functions are removed.
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+  ab->Externalize(backing_store);
+  CHECK(ab->IsExternal());
+#if __clang__
+#pragma clang diagnostic pop
+#endif
   return backing_store;
 }
 
 std::shared_ptr<v8::BackingStore> Externalize(Local<v8::SharedArrayBuffer> ab) {
   std::shared_ptr<v8::BackingStore> backing_store = ab->GetBackingStore();
+  // Keep the tests until the deprecated functions are removed.
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+  ab->Externalize(backing_store);
+  CHECK(ab->IsExternal());
+#if __clang__
+#pragma clang diagnostic pop
+#endif
   return backing_store;
 }
 
@@ -130,6 +150,46 @@ THREADED_TEST(ArrayBuffer_JSInternalToExternal) {
   CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
+THREADED_TEST(ArrayBuffer_External) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  i::ScopedVector<uint8_t> my_data(100);
+  memset(my_data.begin(), 0, 100);
+  // Keep the tests until the deprecated functions are removed.
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+  Local<v8::ArrayBuffer> ab3 =
+      v8::ArrayBuffer::New(isolate, my_data.begin(), 100);
+  CheckInternalFieldsAreZero(ab3);
+  CHECK_EQ(100, ab3->ByteLength());
+  CHECK(ab3->IsExternal());
+#if __clang__
+#pragma clang diagnostic pop
+#endif
+
+  CHECK(env->Global()->Set(env.local(), v8_str("ab3"), ab3).FromJust());
+
+  v8::Local<v8::Value> result = CompileRun("ab3.byteLength");
+  CHECK_EQ(100, result->Int32Value(env.local()).FromJust());
+
+  result = CompileRun(
+      "var u8_b = new Uint8Array(ab3);"
+      "u8_b[0] = 0xBB;"
+      "u8_b[1] = 0xCC;"
+      "u8_b.length");
+  CHECK_EQ(100, result->Int32Value(env.local()).FromJust());
+  CHECK_EQ(0xBB, my_data[0]);
+  CHECK_EQ(0xCC, my_data[1]);
+  my_data[0] = 0xCC;
+  my_data[1] = 0x11;
+  result = CompileRun("u8_b[0] + u8_b[1]");
+  CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
+}
+
 THREADED_TEST(ArrayBuffer_DisableDetach) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
@@ -233,6 +293,37 @@ THREADED_TEST(ArrayBuffer_DetachingScript) {
   CheckDataViewIsDetached(dv);
 }
 
+// TODO(v8:9380) the Contents data structure should be deprecated.
+THREADED_TEST(ArrayBuffer_AllocationInformation) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  const size_t ab_size = 1024;
+  Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, ab_size);
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+  v8::ArrayBuffer::Contents contents(ab->GetContents());
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+
+  // Array buffers should have normal allocation mode.
+  CHECK_EQ(contents.AllocationMode(),
+           v8::ArrayBuffer::Allocator::AllocationMode::kNormal);
+  // The allocation must contain the buffer (normally they will be equal, but
+  // this is not required by the contract).
+  CHECK_NOT_NULL(contents.AllocationBase());
+  const uintptr_t alloc =
+      reinterpret_cast<uintptr_t>(contents.AllocationBase());
+  const uintptr_t data = reinterpret_cast<uintptr_t>(contents.Data());
+  CHECK_LE(alloc, data);
+  CHECK_LE(data + contents.ByteLength(), alloc + contents.AllocationLength());
+}
+
 THREADED_TEST(ArrayBuffer_ExternalizeEmpty) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
@@ -251,6 +342,7 @@ THREADED_TEST(ArrayBuffer_ExternalizeEmpty) {
   // marked as is_external or not.
   USE(u8a->Buffer());
 
+  CHECK(ab->IsExternal());
   CHECK_EQ(2, backing_store->ByteLength());
 }
 
@@ -289,6 +381,35 @@ THREADED_TEST(SharedArrayBuffer_ApiInternalToExternal) {
   CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
+THREADED_TEST(ArrayBuffer_ExternalReused) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  i::ScopedVector<uint8_t> data(100);
+  Local<v8::ArrayBuffer> ab1 = v8::ArrayBuffer::New(isolate, data.begin(), 100);
+  std::shared_ptr<v8::BackingStore> bs1 = ab1->GetBackingStore();
+  ab1->Detach();
+  Local<v8::ArrayBuffer> ab2 = v8::ArrayBuffer::New(isolate, data.begin(), 100);
+  std::shared_ptr<v8::BackingStore> bs2 = ab2->GetBackingStore();
+  CHECK_EQ(bs1->Data(), bs2->Data());
+}
+
+THREADED_TEST(SharedArrayBuffer_ExternalReused) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  i::ScopedVector<uint8_t> data(100);
+  Local<v8::SharedArrayBuffer> ab1 =
+      v8::SharedArrayBuffer::New(isolate, data.begin(), 100);
+  std::shared_ptr<v8::BackingStore> bs1 = ab1->GetBackingStore();
+  Local<v8::SharedArrayBuffer> ab2 =
+      v8::SharedArrayBuffer::New(isolate, data.begin(), 100);
+  std::shared_ptr<v8::BackingStore> bs2 = ab2->GetBackingStore();
+  CHECK_EQ(bs1->Data(), bs2->Data());
+}
+
 THREADED_TEST(SharedArrayBuffer_JSInternalToExternal) {
   i::FLAG_harmony_sharedarraybuffer = true;
   LocalContext env;
@@ -330,6 +451,64 @@ THREADED_TEST(SharedArrayBuffer_JSInternalToExternal) {
   CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
+THREADED_TEST(SharedArrayBuffer_External) {
+  i::FLAG_harmony_sharedarraybuffer = true;
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  i::ScopedVector<uint8_t> my_data(100);
+  memset(my_data.begin(), 0, 100);
+  Local<v8::SharedArrayBuffer> ab3 =
+      v8::SharedArrayBuffer::New(isolate, my_data.begin(), 100);
+  CheckInternalFieldsAreZero(ab3);
+  CHECK_EQ(100, static_cast<int>(ab3->ByteLength()));
+  CHECK(ab3->IsExternal());
+
+  CHECK(env->Global()->Set(env.local(), v8_str("ab3"), ab3).FromJust());
+
+  v8::Local<v8::Value> result = CompileRun("ab3.byteLength");
+  CHECK_EQ(100, result->Int32Value(env.local()).FromJust());
+
+  result = CompileRun(
+      "var u8_b = new Uint8Array(ab3);"
+      "u8_b[0] = 0xBB;"
+      "u8_b[1] = 0xCC;"
+      "u8_b.length");
+  CHECK_EQ(100, result->Int32Value(env.local()).FromJust());
+  CHECK_EQ(0xBB, my_data[0]);
+  CHECK_EQ(0xCC, my_data[1]);
+  my_data[0] = 0xCC;
+  my_data[1] = 0x11;
+  result = CompileRun("u8_b[0] + u8_b[1]");
+  CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
+}
+
+// TODO(v8:9380) the Contents data structure should be deprecated.
+THREADED_TEST(SharedArrayBuffer_AllocationInformation) {
+  i::FLAG_harmony_sharedarraybuffer = true;
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  const size_t ab_size = 1024;
+  Local<v8::SharedArrayBuffer> ab =
+      v8::SharedArrayBuffer::New(isolate, ab_size);
+  v8::SharedArrayBuffer::Contents contents(ab->GetContents());
+
+  // Array buffers should have normal allocation mode.
+  CHECK_EQ(contents.AllocationMode(),
+           v8::ArrayBuffer::Allocator::AllocationMode::kNormal);
+  // The allocation must contain the buffer (normally they will be equal, but
+  // this is not required by the contract).
+  CHECK_NOT_NULL(contents.AllocationBase());
+  const uintptr_t alloc =
+      reinterpret_cast<uintptr_t>(contents.AllocationBase());
+  const uintptr_t data = reinterpret_cast<uintptr_t>(contents.Data());
+  CHECK_LE(alloc, data);
+  CHECK_LE(data + contents.ByteLength(), alloc + contents.AllocationLength());
+}
+
 THREADED_TEST(SkipArrayBufferBackingStoreDuringGC) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
@@ -337,12 +516,9 @@ THREADED_TEST(SkipArrayBufferBackingStoreDuringGC) {
 
   // Make sure the pointer looks like a heap object
   uint8_t* store_ptr = reinterpret_cast<uint8_t*>(i::kHeapObjectTag);
-  auto backing_store = v8::ArrayBuffer::NewBackingStore(
-      store_ptr, 8, [](void*, size_t, void*) {}, nullptr);
 
   // Create ArrayBuffer with pointer-that-cannot-be-visited in the backing store
-  Local<v8::ArrayBuffer> ab =
-      v8::ArrayBuffer::New(isolate, std::move(backing_store));
+  Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, store_ptr, 8);
 
   // Should not crash
   CcTest::CollectGarbage(i::NEW_SPACE);  // in survivor space now
@@ -363,15 +539,12 @@ THREADED_TEST(SkipArrayBufferDuringScavenge) {
   Local<v8::Object> tmp = v8::Object::New(isolate);
   uint8_t* store_ptr =
       reinterpret_cast<uint8_t*>(*reinterpret_cast<uintptr_t*>(*tmp));
-  auto backing_store = v8::ArrayBuffer::NewBackingStore(
-      store_ptr, 8, [](void*, size_t, void*) {}, nullptr);
 
   // Make `store_ptr` point to from space
   CcTest::CollectGarbage(i::NEW_SPACE);
 
   // Create ArrayBuffer with pointer-that-cannot-be-visited in the backing store
-  Local<v8::ArrayBuffer> ab =
-      v8::ArrayBuffer::New(isolate, std::move(backing_store));
+  Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, store_ptr, 8);
 
   // Should not crash,
   // i.e. backing store pointer should not be treated as a heap object pointer
diff --git a/deps/v8/test/cctest/test-cpu-profiler.cc b/deps/v8/test/cctest/test-cpu-profiler.cc
index 2373fd2f3a11bb..a131cfaf6ef48d 100644
--- a/deps/v8/test/cctest/test-cpu-profiler.cc
+++ b/deps/v8/test/cctest/test-cpu-profiler.cc
@@ -546,8 +546,7 @@ class ProfilerHelper {
       v8::Local<v8::Function> function, v8::Local<v8::Value> argv[], int argc,
       unsigned min_js_samples = 0, unsigned min_external_samples = 0,
       ProfilingMode mode = ProfilingMode::kLeafNodeLineNumbers,
-      unsigned max_samples = v8::CpuProfilingOptions::kNoSampleLimit,
-      v8::Local<v8::Context> context = v8::Local<v8::Context>());
+      unsigned max_samples = v8::CpuProfilingOptions::kNoSampleLimit);
 
   v8::CpuProfiler* profiler() { return profiler_; }
 
@@ -560,12 +559,11 @@ v8::CpuProfile* ProfilerHelper::Run(v8::Local<v8::Function> function,
                                     v8::Local<v8::Value> argv[], int argc,
                                     unsigned min_js_samples,
                                     unsigned min_external_samples,
-                                    ProfilingMode mode, unsigned max_samples,
-                                    v8::Local<v8::Context> context) {
+                                    ProfilingMode mode, unsigned max_samples) {
   v8::Local<v8::String> profile_name = v8_str("my_profile");
 
   profiler_->SetSamplingInterval(50);
-  profiler_->StartProfiling(profile_name, {mode, max_samples, 0, context});
+  profiler_->StartProfiling(profile_name, {mode, max_samples, 0});
 
   v8::internal::CpuProfiler* iprofiler =
       reinterpret_cast<v8::internal::CpuProfiler*>(profiler_);
@@ -3805,141 +3803,6 @@ TEST(Bug9151StaleCodeEntries) {
   CHECK(callback);
 }
 
-// Tests that functions from other contexts aren't recorded when filtering for
-// another context.
-TEST(ContextIsolation) {
-  i::FLAG_allow_natives_syntax = true;
-  LocalContext execution_env;
-  i::HandleScope scope(CcTest::i_isolate());
-
-  // Install CollectSample callback for more deterministic sampling.
-  v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
-      execution_env.local()->GetIsolate(), CallCollectSample);
-  v8::Local<v8::Function> func =
-      func_template->GetFunction(execution_env.local()).ToLocalChecked();
-  func->SetName(v8_str("CallCollectSample"));
-  execution_env->Global()
-      ->Set(execution_env.local(), v8_str("CallCollectSample"), func)
-      .FromJust();
-
-  ProfilerHelper helper(execution_env.local());
-  CompileRun(R"(
-    function optimized() {
-      CallCollectSample();
-    }
-
-    function unoptimized() {
-      CallCollectSample();
-    }
-
-    function start() {
-      // Test optimized functions
-      %PrepareFunctionForOptimization(optimized);
-      optimized();
-      optimized();
-      %OptimizeFunctionOnNextCall(optimized);
-      optimized();
-
-      // Test unoptimized functions
-      %NeverOptimizeFunction(unoptimized);
-      unoptimized();
-
-      // Test callback
-      CallCollectSample();
-    }
-  )");
-  v8::Local<v8::Function> function =
-      GetFunction(execution_env.local(), "start");
-
-  v8::CpuProfile* same_context_profile = helper.Run(
-      function, nullptr, 0, 0, 0, v8::CpuProfilingMode::kLeafNodeLineNumbers,
-      v8::CpuProfilingOptions::kNoSampleLimit, execution_env.local());
-  const v8::CpuProfileNode* root = same_context_profile->GetTopDownRoot();
-  const v8::CpuProfileNode* start_node = FindChild(root, "start");
-  CHECK(start_node);
-  const v8::CpuProfileNode* optimized_node = FindChild(start_node, "optimized");
-  CHECK(optimized_node);
-  const v8::CpuProfileNode* unoptimized_node =
-      FindChild(start_node, "unoptimized");
-  CHECK(unoptimized_node);
-  const v8::CpuProfileNode* callback_node =
-      FindChild(start_node, "CallCollectSample");
-  CHECK(callback_node);
-
-  {
-    LocalContext filter_env;
-    v8::CpuProfile* diff_context_profile = helper.Run(
-        function, nullptr, 0, 0, 0, v8::CpuProfilingMode::kLeafNodeLineNumbers,
-        v8::CpuProfilingOptions::kNoSampleLimit, filter_env.local());
-    const v8::CpuProfileNode* diff_root =
-        diff_context_profile->GetTopDownRoot();
-    // Ensure that no children were recorded (including callbacks, builtins).
-    CHECK(!FindChild(diff_root, "start"));
-  }
-}
-
-// Tests that when a native context that's being filtered is moved, we continue
-// to track its execution.
-TEST(ContextFilterMovedNativeContext) {
-  if (i::FLAG_enable_third_party_heap) return;
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_manual_evacuation_candidates_selection = true;
-  LocalContext env;
-  i::HandleScope scope(CcTest::i_isolate());
-
-  {
-    // Install CollectSample callback for more deterministic sampling.
-    v8::Local<v8::FunctionTemplate> sample_func_template =
-        v8::FunctionTemplate::New(env.local()->GetIsolate(), CallCollectSample);
-    v8::Local<v8::Function> sample_func =
-        sample_func_template->GetFunction(env.local()).ToLocalChecked();
-    sample_func->SetName(v8_str("CallCollectSample"));
-    env->Global()
-        ->Set(env.local(), v8_str("CallCollectSample"), sample_func)
-        .FromJust();
-
-    // Install a function that triggers the native context to be moved.
-    v8::Local<v8::FunctionTemplate> move_func_template =
-        v8::FunctionTemplate::New(
-            env.local()->GetIsolate(),
-            [](const v8::FunctionCallbackInfo<v8::Value>& info) {
-              i::Isolate* isolate =
-                  reinterpret_cast<i::Isolate*>(info.GetIsolate());
-              i::heap::ForceEvacuationCandidate(
-                  i::Page::FromHeapObject(isolate->raw_native_context()));
-              CcTest::CollectAllGarbage();
-            });
-    v8::Local<v8::Function> move_func =
-        move_func_template->GetFunction(env.local()).ToLocalChecked();
-    move_func->SetName(v8_str("ForceNativeContextMove"));
-    env->Global()
-        ->Set(env.local(), v8_str("ForceNativeContextMove"), move_func)
-        .FromJust();
-
-    ProfilerHelper helper(env.local());
-    CompileRun(R"(
-      function start() {
-        ForceNativeContextMove();
-        CallCollectSample();
-      }
-    )");
-    v8::Local<v8::Function> function = GetFunction(env.local(), "start");
-
-    v8::CpuProfile* profile = helper.Run(
-        function, nullptr, 0, 0, 0, v8::CpuProfilingMode::kLeafNodeLineNumbers,
-        v8::CpuProfilingOptions::kNoSampleLimit, env.local());
-    const v8::CpuProfileNode* root = profile->GetTopDownRoot();
-    const v8::CpuProfileNode* start_node = FindChild(root, "start");
-    CHECK(start_node);
-
-    // Verify that after moving the native context, CallCollectSample is still
-    // recorded.
-    const v8::CpuProfileNode* callback_node =
-        FindChild(start_node, "CallCollectSample");
-    CHECK(callback_node);
-  }
-}
-
 enum class EntryCountMode { kAll, kOnlyInlined };
 
 // Count the number of unique source positions.
diff --git a/deps/v8/test/cctest/test-heap-profiler.cc b/deps/v8/test/cctest/test-heap-profiler.cc
index 9f80891a581352..06c11602083bc9 100644
--- a/deps/v8/test/cctest/test-heap-profiler.cc
+++ b/deps/v8/test/cctest/test-heap-profiler.cc
@@ -516,7 +516,7 @@ TEST(HeapSnapshotHeapNumbersCaptureNumericValue) {
       "a = 1;    // a is Smi\n"
       "b = 2.5;  // b is HeapNumber");
   const v8::HeapSnapshot* snapshot =
-      heap_profiler->TakeHeapSnapshot(nullptr, nullptr, true, true);
+      heap_profiler->TakeHeapSnapshotV8_92(nullptr, nullptr, true, true);
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* a =
diff --git a/deps/v8/test/cctest/test-typedarrays.cc b/deps/v8/test/cctest/test-typedarrays.cc
index 0134befedd251a..867d0f90b9574c 100644
--- a/deps/v8/test/cctest/test-typedarrays.cc
+++ b/deps/v8/test/cctest/test-typedarrays.cc
@@ -71,6 +71,30 @@ TEST(CopyContentsView) {
   TestArrayBufferViewContents(&env, true);
 }
 
+
+TEST(AllocateNotExternal) {
+  LocalContext env;
+  v8::HandleScope scope(env->GetIsolate());
+  void* memory = reinterpret_cast<Isolate*>(env->GetIsolate())
+                     ->array_buffer_allocator()
+                     ->Allocate(1024);
+
+// Keep the test until the functions are removed.
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+  v8::Local<v8::ArrayBuffer> buffer =
+      v8::ArrayBuffer::New(env->GetIsolate(), memory, 1024,
+                           v8::ArrayBufferCreationMode::kInternalized);
+  CHECK(!buffer->IsExternal());
+#if __clang__
+#pragma clang diagnostic pop
+#endif
+
+  CHECK_EQ(memory, buffer->GetBackingStore()->Data());
+}
+
 void TestSpeciesProtector(char* code,
                           bool invalidates_species_protector = true) {
   v8::Isolate::CreateParams create_params;