LibWeb/Streams: Fix inconsistent uses of realm() and vm()

This is not documented yet, but the preferred style is getting both
upfront instead of inlining various kinds of calls in places that use
the realm and vm.

Userland/Libraries/LibWeb/Streams/AbstractOperations.cpp

@@ -302,14 +302,16 @@ WebIDL::ExceptionOr<void> readable_stream_reader_generic_release(ReadableStreamG
     // 3. Assert: stream.[[reader]] is reader.
     VERIFY(stream->reader().ptr() == &reader);
 
+    auto& realm = stream->realm();
+
     // 4. If stream.[[state]] is "readable", reject reader.[[closedPromise]] with a TypeError exception.
-    auto exception = TRY(JS::TypeError::create(stream->realm(), "Released readable stream"sv));
+    auto exception = TRY(JS::TypeError::create(realm, "Released readable stream"sv));
     if (stream->is_readable()) {
-        WebIDL::reject_promise(stream->realm(), *reader.closed_promise_capability(), exception);
+        WebIDL::reject_promise(realm, *reader.closed_promise_capability(), exception);
     }
     // 5. Otherwise, set reader.[[closedPromise]] to a promise rejected with a TypeError exception.
     else {
-        reader.set_closed_promise_capability(WebIDL::create_rejected_promise(stream->realm(), exception));
+        reader.set_closed_promise_capability(WebIDL::create_rejected_promise(realm, exception));
     }
 
     // 6. Set reader.[[closedPromise]].[[PromiseIsHandled]] to true.
@@ -374,11 +376,13 @@ void readable_stream_default_reader_read(ReadableStreamDefaultReader& reader, Re
 // https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaultreaderrelease
 WebIDL::ExceptionOr<void> readable_stream_default_reader_release(ReadableStreamDefaultReader& reader)
 {
+    auto& realm = reader.realm();
+
     // 1. Perform ! ReadableStreamReaderGenericRelease(reader).
     TRY(readable_stream_reader_generic_release(reader));
 
     // 2. Let e be a new TypeError exception.
-    auto e = TRY(JS::TypeError::create(reader.realm(), "Reader has been released"sv));
+    auto e = TRY(JS::TypeError::create(realm, "Reader has been released"sv));
 
     // 3. Perform ! ReadableStreamDefaultReaderErrorReadRequests(reader, e).
     readable_stream_default_reader_error_read_requests(reader, e);
@@ -1437,6 +1441,8 @@ Optional<double> writable_stream_default_writer_get_desired_size(WritableStreamD
 // https://streams.spec.whatwg.org/#writable-stream-default-writer-release
 WebIDL::ExceptionOr<void> writable_stream_default_writer_release(WritableStreamDefaultWriter& writer)
 {
+    auto& realm = writer.realm();
+
     // 1. Let stream be writer.[[stream]].
     auto stream = writer.stream();
 
@@ -1447,7 +1453,7 @@ WebIDL::ExceptionOr<void> writable_stream_default_writer_release(WritableStreamD
     VERIFY(stream->writer().ptr() == &writer);
 
     // 4. Let releasedError be a new TypeError.
-    auto released_error = MUST_OR_THROW_OOM(JS::TypeError::create(writer.realm(), "Writer's stream lock has been released"sv));
+    auto released_error = MUST_OR_THROW_OOM(JS::TypeError::create(realm, "Writer's stream lock has been released"sv));
 
     // 5. Perform ! WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError).
     writable_stream_default_writer_ensure_ready_promise_rejected(writer, released_error);

Userland/Libraries/LibWeb/Streams/ReadableStream.cpp

@@ -18,13 +18,15 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#rs-constructor
 WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> ReadableStream::construct_impl(JS::Realm& realm, Optional<JS::Handle<JS::Object>> const& underlying_source_object)
 {
+    auto& vm = realm.vm();
+
     auto readable_stream = MUST_OR_THROW_OOM(realm.heap().allocate<ReadableStream>(realm, realm));
 
     // 1. If underlyingSource is missing, set it to null.
     auto underlying_source = underlying_source_object.has_value() ? JS::Value(underlying_source_object.value().ptr()) : JS::js_null();
 
     // 2. Let underlyingSourceDict be underlyingSource, converted to an IDL value of type UnderlyingSource.
-    auto underlying_source_dict = TRY(UnderlyingSource::from_value(realm.vm(), underlying_source));
+    auto underlying_source_dict = TRY(UnderlyingSource::from_value(vm, underlying_source));
 
     // 3. Perform ! InitializeReadableStream(this).
 
@@ -71,10 +73,12 @@ bool ReadableStream::locked()
 // https://streams.spec.whatwg.org/#rs-cancel
 WebIDL::ExceptionOr<JS::GCPtr<JS::Object>> ReadableStream::cancel(JS::Value reason)
 {
+    auto& realm = this->realm();
+
     // 1. If ! IsReadableStreamLocked(this) is true, return a promise rejected with a TypeError exception.
     if (is_readable_stream_locked(*this)) {
-        auto exception = MUST_OR_THROW_OOM(JS::TypeError::create(realm(), "Cannot cancel a locked stream"sv));
+        auto exception = MUST_OR_THROW_OOM(JS::TypeError::create(realm, "Cannot cancel a locked stream"sv));
-        return WebIDL::create_rejected_promise(realm(), JS::Value { exception })->promise();
+        return WebIDL::create_rejected_promise(realm, JS::Value { exception })->promise();
     }
 
     // 2. Return ! ReadableStreamCancel(this, reason).

Userland/Libraries/LibWeb/Streams/UnderlyingSource.cpp

@@ -27,7 +27,7 @@ JS::ThrowCompletionOr<UnderlyingSource> UnderlyingSource::from_value(JS::VM& vm,
     };
 
     if (TRY(object.has_property("type"))) {
-        auto type_value = TRY(TRY(object.get("type")).to_string(object.vm()));
+        auto type_value = TRY(TRY(object.get("type")).to_string(vm));
         if (type_value == "bytes"sv) {
             underlying_source.type = ReadableStreamType::Bytes;
         } else {
@@ -36,7 +36,7 @@ JS::ThrowCompletionOr<UnderlyingSource> UnderlyingSource::from_value(JS::VM& vm,
     }
 
     if (TRY(object.has_property("autoAllocateChunkSize")))
-        underlying_source.auto_allocate_chunk_size = TRY(TRY(object.get("autoAllocateChunkSize")).to_bigint_int64(object.vm()));
+        underlying_source.auto_allocate_chunk_size = TRY(TRY(object.get("autoAllocateChunkSize")).to_bigint_int64(vm));
 
     return underlying_source;
 }