JSG Completion: update jsg/ser.{h,c++} to take jsg::Lock& instead of v8::Isolate

src/workerd/api/actor-state.c++

@@ -904,7 +904,7 @@ kj::Maybe<kj::Date> DurableObjectState::getWebSocketAutoResponseTimestamp(jsg::R
 }
 
 kj::Array<kj::byte> serializeV8Value(jsg::Lock& js, v8::Local<v8::Value> value) {
-  jsg::Serializer serializer(js.v8Isolate, jsg::Serializer::Options {
+  jsg::Serializer serializer(js, jsg::Serializer::Options {
     .version = 15,
     .omitHeader = false,
   });
@@ -960,7 +960,7 @@ v8::Local<v8::Value> deserializeV8Value(jsg::Lock& js,
     options.readHeader = false;
   }
 
-  jsg::Deserializer deserializer(js.v8Isolate, buf, nullptr, nullptr, options);
+  jsg::Deserializer deserializer(js, buf, nullptr, nullptr, options);
 
   v8::Local<v8::Value> value;
   try {

src/workerd/api/global-scope.c++

@@ -672,7 +672,7 @@ v8::Local<v8::Value> ServiceWorkerGlobalScope::structuredClone(
       return transfer.asPtr();
     });
   }
-  return jsg::structuredClone(value, js.v8Isolate, transfers);
+  return jsg::structuredClone(js, value, transfers);
 }
 
 TimeoutId::NumberType ServiceWorkerGlobalScope::setTimeoutInternal(

src/workerd/api/http.c++

@@ -2021,7 +2021,7 @@ jsg::Promise<Fetcher::QueueResult> Fetcher::queue(
 
   auto encodedMessages = kj::heapArrayBuilder<IncomingQueueMessage>(messages.size());
   for (auto& msg : messages) {
-    jsg::Serializer serializer(js.v8Isolate, jsg::Serializer::Options {
+    jsg::Serializer serializer(js, jsg::Serializer::Options {
         .version = 15,
         .omitHeader = false,
     });

src/workerd/api/node/diagnostics-channel.c++

@@ -24,7 +24,7 @@ void Channel::publish(jsg::Lock& js, jsg::Value message) {
 
   auto& context = IoContext::current();
   KJ_IF_MAYBE(tracer, context.getWorkerTracer()) {
-    jsg::Serializer ser(js.v8Isolate, jsg::Serializer::Options {
+    jsg::Serializer ser(js, jsg::Serializer::Options {
       .omitHeader = false,
     });
     ser.write(message.getHandle(js));

src/workerd/api/queue.c++

@@ -40,7 +40,7 @@ struct Serialized {
 Serialized serializeV8(jsg::Lock& js, v8::Local<v8::Value> body) {
   // Use a specific serialization version to avoid sending messages using a new version before all
   // runtimes at the edge know how to read it.
-  jsg::Serializer serializer(js.v8Isolate, jsg::Serializer::Options {
+  jsg::Serializer serializer(js, jsg::Serializer::Options {
     .version = 15,
     .omitHeader = false,
   });
@@ -277,7 +277,7 @@ jsg::Value deserialize(jsg::Lock& js, kj::Array<kj::byte> body, kj::Maybe<kj::St
   } else if (type == IncomingQueueMessage::ContentType::JSON) {
     return js.parseJson(jsg::v8Str(js.v8Isolate, body.asChars()));
   } else if (type == IncomingQueueMessage::ContentType::V8) {
-    return jsg::Value(js.v8Isolate, jsg::Deserializer(js.v8Isolate, body.asPtr()).readValue());
+    return jsg::Value(js.v8Isolate, jsg::Deserializer(js, body.asPtr()).readValue());
   } else {
     JSG_FAIL_REQUIRE(TypeError, kj::str("Unsupported queue message content type: ", type));
   }
@@ -298,7 +298,7 @@ jsg::Value deserialize(jsg::Lock& js, rpc::QueueMessage::Reader message) {
   } else if (type == IncomingQueueMessage::ContentType::JSON) {
     return js.parseJson(jsg::v8Str(js.v8Isolate, message.getData().asChars()));
   } else if (type == IncomingQueueMessage::ContentType::V8) {
-    return jsg::Value(js.v8Isolate, jsg::Deserializer(js.v8Isolate, message.getData()).readValue());
+    return jsg::Value(js.v8Isolate, jsg::Deserializer(js, message.getData()).readValue());
   } else {
     JSG_FAIL_REQUIRE(TypeError, kj::str("Unsupported queue message content type: ", type));
   }

src/workerd/api/trace.c++

@@ -378,7 +378,7 @@ kj::StringPtr TraceDiagnosticChannelEvent::getChannel() {
 v8::Local<v8::Value> TraceDiagnosticChannelEvent::getMessage(jsg::Lock& js) {
   // This is a lazy property that is evaluated at most once, so it is ok to move the message here.
   if (message.size() == 0) return js.v8Undefined();
-  jsg::Deserializer des(js.v8Isolate, kj::mv(message));
+  jsg::Deserializer des(js, kj::mv(message));
   return des.readValue();
 }
 

src/workerd/api/web-socket.c++

@@ -634,7 +634,7 @@ kj::Maybe<kj::StringPtr> WebSocket::getExtensions() {
 
 kj::Maybe<v8::Local<v8::Value>> WebSocket::deserializeAttachment(jsg::Lock& js) {
   return serializedAttachment.map([&](kj::ArrayPtr<byte> attachment) {
-    jsg::Deserializer deserializer(js.v8Isolate, attachment, nullptr, nullptr,
+    jsg::Deserializer deserializer(js, attachment, nullptr, nullptr,
         jsg::Deserializer::Options {
       .version = 15,
       .readHeader = true,
@@ -645,7 +645,7 @@ kj::Maybe<v8::Local<v8::Value>> WebSocket::deserializeAttachment(jsg::Lock& js)
 }
 
 void WebSocket::serializeAttachment(jsg::Lock& js, v8::Local<v8::Value> attachment) {
-  jsg::Serializer serializer(js.v8Isolate, jsg::Serializer::Options {
+  jsg::Serializer serializer(js, jsg::Serializer::Options {
     .version = 15,
     .omitHeader = false,
   });

src/workerd/jsg/ser.c++

@@ -6,8 +6,8 @@
 
 namespace workerd::jsg {
 
-Serializer::Serializer(v8::Isolate* isolate, kj::Maybe<Options> maybeOptions)
-    : isolate(isolate),
+Serializer::Serializer(Lock& js, kj::Maybe<Options> maybeOptions)
+    : isolate(js.v8Isolate),
       ser(isolate, this) {
   auto options = maybeOptions.orDefault({});
   KJ_IF_MAYBE(version, options.version) {
@@ -116,20 +116,20 @@ void SerializedBufferDisposer::disposeImpl(
 }
 
 v8::Local<v8::Value> structuredClone(
+    Lock& js,
     v8::Local<v8::Value> value,
-    v8::Isolate* isolate,
     kj::Maybe<kj::ArrayPtr<jsg::Value>> maybeTransfer) {
-  Serializer ser(isolate, nullptr);
+  Serializer ser(js, nullptr);
   KJ_IF_MAYBE(transfers, maybeTransfer) {
     for (auto& item : *transfers) {
-      auto val = item.getHandle(isolate);
+      auto val = item.getHandle(js);
       JSG_REQUIRE(val->IsArrayBuffer(), TypeError, "Object is not transferable");
       ser.transfer(val.As<v8::ArrayBuffer>());
     }
   }
   ser.write(value);
   auto released = ser.release();
-  Deserializer des(isolate, released, nullptr);
+  Deserializer des(js, released, nullptr);
   return des.readValue();
 }
 

src/workerd/jsg/ser.h

@@ -25,7 +25,7 @@ class Serializer final: v8::ValueSerializer::Delegate {
     kj::Array<std::shared_ptr<v8::BackingStore>> transferedArrayBuffers;
   };
 
-  explicit Serializer(v8::Isolate* isolate, kj::Maybe<Options> maybeOptions = nullptr);
+  explicit Serializer(Lock& js, kj::Maybe<Options> maybeOptions = nullptr);
 
   inline ~Serializer() noexcept(true) {}  // noexcept(true) because Delegate's is noexcept
 
@@ -65,23 +65,23 @@ class Deserializer final: v8::ValueDeserializer::Delegate {
   };
 
   inline explicit Deserializer(
-      v8::Isolate* isolate,
+      Lock& js,
       auto data,
       kj::Maybe<kj::ArrayPtr<std::shared_ptr<v8::BackingStore>>> transferedArrayBuffers = nullptr,
       kj::Maybe<kj::ArrayPtr<std::shared_ptr<v8::BackingStore>>> sharedArrayBuffers = nullptr,
       kj::Maybe<Options> maybeOptions = nullptr)
-      : isolate(isolate),
+      : isolate(js.v8Isolate),
         deser(isolate, data.begin(), data.size(), this),
         sharedBackingStores(kj::mv(sharedArrayBuffers)) {
     init(kj::mv(transferedArrayBuffers), kj::mv(maybeOptions));
   }
 
   inline explicit Deserializer(
-      v8::Isolate* isolate,
+      Lock& js,
       Serializer::Released& released,
       kj::Maybe<Options> maybeOptions = nullptr)
       : Deserializer(
-          isolate,
+          js,
           released.data.asPtr(),
           released.transferedArrayBuffers.asPtr(),
           released.sharedArrayBuffers.asPtr(),
@@ -116,8 +116,8 @@ class SerializedBufferDisposer: public kj::ArrayDisposer {
 constexpr SerializedBufferDisposer SERIALIZED_BUFFER_DISPOSER;
 
 v8::Local<v8::Value> structuredClone(
+    Lock& js,
     v8::Local<v8::Value> value,
-    v8::Isolate* isolate,
     kj::Maybe<kj::ArrayPtr<jsg::Value>> maybeTransfer = nullptr);
 
 }  // namespace workerd::jsg