Pass ref rather than move

Author: timfish

module.cc

@@ -121,20 +121,22 @@ JsStackFrames GetStackFrames(Isolate *isolate) {
 }
 
 // Function to fetch the thread state from the async context store
-std::string GetThreadState(Isolate *isolate,
-                           std::optional<AsyncLocalStorageLookup> store) {
-  if (!store.has_value()) {
+std::string
+GetThreadState(Isolate *isolate,
+               const std::optional<AsyncLocalStorageLookup> &maybe_store) {
+  if (!maybe_store.has_value()) {
     return "";
   }
 
+  auto store = &maybe_store.value();
+
 #if NODE_MAJOR_VERSION >= 22
   // Node.js stores the async local storage in the isolate's
   // "ContinuationPreservedEmbedderData" map, keyed by the
   // AsyncLocalStorage instance.
   // https://github.com/nodejs/node/blob/c6316f9db9869864cea84e5f07585fa08e3e06d2/src/async_context_frame.cc#L37
   auto data = isolate->GetContinuationPreservedEmbedderData();
-  auto async_local_storage_local =
-      store.value().async_local_storage.Get(isolate);
+  auto async_local_storage_local = store->async_local_storage.Get(isolate);
 
   if (data.IsEmpty() || async_local_storage_local.IsEmpty()) {
     return "";
@@ -150,8 +152,8 @@ std::string GetThreadState(Isolate *isolate,
 
   auto root_store = maybe_root_store.ToLocalChecked();
 
-  if (store.value().storage_key.has_value() && root_store->IsObject()) {
-    auto local_key = store.value().storage_key->Get(isolate);
+  if (store->storage_key.has_value() && root_store->IsObject()) {
+    auto local_key = store->storage_key->Get(isolate);
 
     if (local_key->IsString() || local_key->IsSymbol()) {
       auto root_obj = root_store.As<v8::Object>();
@@ -173,27 +175,25 @@ std::string GetThreadState(Isolate *isolate,
 
 struct InterruptArgs {
   std::promise<JsStackTrace> *promise;
-  std::optional<AsyncLocalStorageLookup> store;
+  const std::optional<AsyncLocalStorageLookup> *store;
 };
 
 // Function to be called when an isolate's execution is interrupted
 static void ExecutionInterrupted(Isolate *isolate, void *data) {
   auto args = static_cast<InterruptArgs *>(data);
 
-  v8::Locker locker(isolate);
-  v8::HandleScope scope(isolate);
-
   auto frames = GetStackFrames(isolate);
-  auto state = GetThreadState(isolate, std::move(*args->store));
+  auto state = GetThreadState(isolate, *args->store);
 
   args->promise->set_value({frames, state});
 
   delete args;
 }
 
 // Function to capture the stack trace of a single isolate
-JsStackTrace CaptureStackTrace(Isolate *isolate,
-                               std::optional<AsyncLocalStorageLookup> store) {
+JsStackTrace
+CaptureStackTrace(Isolate *isolate,
+                  const std::optional<AsyncLocalStorageLookup> &store) {
   if (isolate->IsExecutionTerminating()) {
     return JsStackTrace{{}, ""};
   }
@@ -203,7 +203,7 @@ JsStackTrace CaptureStackTrace(Isolate *isolate,
 
   // The v8 isolate must be interrupted to capture the stack trace
   isolate->RequestInterrupt(ExecutionInterrupted,
-                            new InterruptArgs{&promise, std::move(store)});
+                            new InterruptArgs{&promise, &store});
 
   return future.get();
 }
@@ -228,21 +228,17 @@ void CaptureStackTraces(const FunctionCallbackInfo<Value> &args) {
 
       futures.emplace_back(std::async(
           std::launch::async,
-          [thread_isolate, thread_name,
-           poll_state](std::optional<AsyncLocalStorageLookup> async_store)
+          [thread_isolate, thread_name, poll_state](
+              const std::optional<AsyncLocalStorageLookup> &async_store)
               -> ThreadResult {
-            return ThreadResult{
-                thread_name,
-                CaptureStackTrace(thread_isolate, std::move(async_store)),
-                poll_state};
+            return ThreadResult{thread_name,
+                                CaptureStackTrace(thread_isolate, async_store),
+                                poll_state};
           },
-          std::move(thread_info.async_store)));
+          std::cref(thread_info.async_store)));
     }
   }
 
-  v8::Locker locker(capture_from_isolate);
-  v8::HandleScope scope(capture_from_isolate);
-
   auto current_context = capture_from_isolate->GetCurrentContext();
 
   Local<Object> output = Object::New(capture_from_isolate);
@@ -499,9 +495,6 @@ void ThreadPoll(const FunctionCallbackInfo<Value> &args) {
 void GetThreadsLastSeen(const FunctionCallbackInfo<Value> &args) {
   Isolate *isolate = args.GetIsolate();
 
-  v8::Locker locker(isolate);
-  v8::HandleScope scope(isolate);
-
   Local<Object> result = Object::New(isolate);
   milliseconds now = duration_cast<milliseconds>(
       GetUnbiasedMonotonicTime().time_since_epoch());