deps: update V8 to 9.3.345.16

PR-URL: https://github.com/nodejs/node/pull/39469
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

1 files changed, 57 insertions, 8 deletions

diff --git a/deps/v8/src/heap/parked-scope.h b/deps/v8/src/heap/parked-scope.h
index 1a35fbc400..41dc6bfc1f 100644
--- a/deps/v8/src/heap/parked-scope.h
+++ b/deps/v8/src/heap/parked-scope.h
@@ -45,18 +45,67 @@ class V8_NODISCARD UnparkedScope {
 };
 
 class V8_NODISCARD ParkedMutexGuard {
-  base::Mutex* guard_;
+ public:
+  explicit ParkedMutexGuard(LocalIsolate* local_isolate, base::Mutex* mutex)
+      : ParkedMutexGuard(local_isolate->heap(), mutex) {}
+  explicit ParkedMutexGuard(LocalHeap* local_heap, base::Mutex* mutex)
+      : mutex_(mutex) {
+    if (!mutex_->TryLock()) {
+      ParkedScope scope(local_heap);
+      mutex_->Lock();
+    }
+  }
+
+  ParkedMutexGuard(const ParkedMutexGuard&) = delete;
+  ParkedMutexGuard& operator=(const ParkedMutexGuard&) = delete;
+
+  ~ParkedMutexGuard() { mutex_->Unlock(); }
+
+ private:
+  base::Mutex* mutex_;
+};
 
+template <base::MutexSharedType kIsShared,
+          base::NullBehavior Behavior = base::NullBehavior::kRequireNotNull>
+class V8_NODISCARD ParkedSharedMutexGuardIf final {
  public:
-  explicit ParkedMutexGuard(LocalIsolate* local_isolate, base::Mutex* guard)
-      : ParkedMutexGuard(local_isolate->heap(), guard) {}
-  explicit ParkedMutexGuard(LocalHeap* local_heap, base::Mutex* guard)
-      : guard_(guard) {
-    ParkedScope scope(local_heap);
-    guard_->Lock();
+  ParkedSharedMutexGuardIf(LocalIsolate* local_isolate,
+                           base::SharedMutex* mutex, bool enable_mutex)
+      : ParkedSharedMutexGuardIf(local_isolate->heap(), mutex, enable_mutex) {}
+  ParkedSharedMutexGuardIf(LocalHeap* local_heap, base::SharedMutex* mutex,
+                           bool enable_mutex) {
+    DCHECK_IMPLIES(Behavior == base::NullBehavior::kRequireNotNull,
+                   mutex != nullptr);
+    if (!enable_mutex) return;
+    mutex_ = mutex;
+
+    if (kIsShared) {
+      if (!mutex_->TryLockShared()) {
+        ParkedScope scope(local_heap);
+        mutex_->LockShared();
+      }
+    } else {
+      if (!mutex_->TryLockExclusive()) {
+        ParkedScope scope(local_heap);
+        mutex_->LockExclusive();
+      }
+    }
+  }
+  ParkedSharedMutexGuardIf(const ParkedSharedMutexGuardIf&) = delete;
+  ParkedSharedMutexGuardIf& operator=(const ParkedSharedMutexGuardIf&) = delete;
+
+  ~ParkedSharedMutexGuardIf() {
+    if (!mutex_) return;
+
+    if (kIsShared) {
+      mutex_->UnlockShared();
+    } else {
+      mutex_->UnlockExclusive();
+    }
   }
 
-  ~ParkedMutexGuard() { guard_->Unlock(); }
+ private:
+  base::SharedMutex* mutex_ = nullptr;
 };
 
 }  // namespace internal