LibWeb: Remove exceptional return types from infallible stream IDL

trflynn89 · awesomekling · commit 2d4d16ac377d · 2024-04-30T08:14:12.000+02:00
diff --git a/Userland/Libraries/LibWeb/FileAPI/FileReader.cpp b/Userland/Libraries/LibWeb/FileAPI/FileReader.cpp
@@ -139,7 +139,7 @@ WebIDL::ExceptionOr<void> FileReader::read_operation(Blob& blob, Type type, Opti
     ByteBuffer bytes;
 
     // 8. Let chunkPromise be the result of reading a chunk from stream with reader.
-    auto chunk_promise = TRY(reader->read());
+    auto chunk_promise = reader->read();
 
     // 9. Let isFirstChunk be true.
     bool is_first_chunk = true;
@@ -183,7 +183,7 @@ WebIDL::ExceptionOr<void> FileReader::read_operation(Blob& blob, Type type, Opti
                 // FIXME: 3. If roughly 50ms have passed since these steps were last invoked, queue a task to fire a progress event called progress at fr.
 
                 // 4. Set chunkPromise to the result of reading a chunk from stream with reader.
-                chunk_promise = MUST(reader->read());
+                chunk_promise = reader->read();
             }
             // 5. Otherwise, if chunkPromise is fulfilled with an object whose done property is true, queue a task to run the following steps and abort this algorithm:
             else if (chunk_promise->state() == JS::Promise::State::Fulfilled && done.as_bool()) {
diff --git a/Userland/Libraries/LibWeb/HTML/Window.cpp b/Userland/Libraries/LibWeb/HTML/Window.cpp
@@ -738,7 +738,7 @@ Vector<JS::NonnullGCPtr<MimeType>> Window::pdf_viewer_mime_type_objects()
 }
 
 // https://streams.spec.whatwg.org/#count-queuing-strategy-size-function
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> Window::count_queuing_strategy_size_function()
+JS::NonnullGCPtr<WebIDL::CallbackType> Window::count_queuing_strategy_size_function()
 {
     auto& realm = this->realm();
 
@@ -760,7 +760,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> Window::count_queuin
 }
 
 // https://streams.spec.whatwg.org/#byte-length-queuing-strategy-size-function
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> Window::byte_length_queuing_strategy_size_function()
+JS::NonnullGCPtr<WebIDL::CallbackType> Window::byte_length_queuing_strategy_size_function()
 {
     auto& realm = this->realm();
 
diff --git a/Userland/Libraries/LibWeb/HTML/Window.h b/Userland/Libraries/LibWeb/HTML/Window.h
@@ -127,8 +127,8 @@ class Window final
     CrossOriginPropertyDescriptorMap const& cross_origin_property_descriptor_map() const { return m_cross_origin_property_descriptor_map; }
     CrossOriginPropertyDescriptorMap& cross_origin_property_descriptor_map() { return m_cross_origin_property_descriptor_map; }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> count_queuing_strategy_size_function();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> byte_length_queuing_strategy_size_function();
+    JS::NonnullGCPtr<WebIDL::CallbackType> count_queuing_strategy_size_function();
+    JS::NonnullGCPtr<WebIDL::CallbackType> byte_length_queuing_strategy_size_function();
 
     // JS API functions
     JS::NonnullGCPtr<WindowProxy> window() const;
diff --git a/Userland/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.cpp b/Userland/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.cpp
@@ -9,14 +9,13 @@
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/HTML/Window.h>
 #include <LibWeb/Streams/ByteLengthQueuingStrategy.h>
-#include <LibWeb/WebIDL/ExceptionOr.h>
 
 namespace Web::Streams {
 
 JS_DEFINE_ALLOCATOR(ByteLengthQueuingStrategy);
 
 // https://streams.spec.whatwg.org/#blqs-constructor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ByteLengthQueuingStrategy>> ByteLengthQueuingStrategy::construct_impl(JS::Realm& realm, QueuingStrategyInit const& init)
+JS::NonnullGCPtr<ByteLengthQueuingStrategy> ByteLengthQueuingStrategy::construct_impl(JS::Realm& realm, QueuingStrategyInit const& init)
 {
     // The new ByteLengthQueuingStrategy(init) constructor steps are:
     // 1. Set this.[[highWaterMark]] to init["highWaterMark"].
@@ -32,7 +31,7 @@ ByteLengthQueuingStrategy::ByteLengthQueuingStrategy(JS::Realm& realm, double hi
 ByteLengthQueuingStrategy::~ByteLengthQueuingStrategy() = default;
 
 // https://streams.spec.whatwg.org/#blqs-size
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> ByteLengthQueuingStrategy::size()
+JS::NonnullGCPtr<WebIDL::CallbackType> ByteLengthQueuingStrategy::size()
 {
     // 1. Return this's relevant global object's byte length queuing strategy size function.
     return global_object().byte_length_queuing_strategy_size_function();
diff --git a/Userland/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.h b/Userland/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.h
@@ -20,7 +20,7 @@ class ByteLengthQueuingStrategy final : public Bindings::PlatformObject {
     JS_DECLARE_ALLOCATOR(ByteLengthQueuingStrategy);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ByteLengthQueuingStrategy>> construct_impl(JS::Realm&, QueuingStrategyInit const&);
+    static JS::NonnullGCPtr<ByteLengthQueuingStrategy> construct_impl(JS::Realm&, QueuingStrategyInit const&);
 
     virtual ~ByteLengthQueuingStrategy() override;
 
@@ -32,7 +32,7 @@ class ByteLengthQueuingStrategy final : public Bindings::PlatformObject {
         return m_high_water_mark;
     }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> size();
+    JS::NonnullGCPtr<WebIDL::CallbackType> size();
 
 private:
     explicit ByteLengthQueuingStrategy(JS::Realm&, double high_water_mark);
diff --git a/Userland/Libraries/LibWeb/Streams/CountQueuingStrategy.cpp b/Userland/Libraries/LibWeb/Streams/CountQueuingStrategy.cpp
@@ -9,14 +9,13 @@
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/HTML/Window.h>
 #include <LibWeb/Streams/CountQueuingStrategy.h>
-#include <LibWeb/WebIDL/ExceptionOr.h>
 
 namespace Web::Streams {
 
 JS_DEFINE_ALLOCATOR(CountQueuingStrategy);
 
 // https://streams.spec.whatwg.org/#blqs-constructor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CountQueuingStrategy>> CountQueuingStrategy::construct_impl(JS::Realm& realm, QueuingStrategyInit const& init)
+JS::NonnullGCPtr<CountQueuingStrategy> CountQueuingStrategy::construct_impl(JS::Realm& realm, QueuingStrategyInit const& init)
 {
     // The new CountQueuingStrategy(init) constructor steps are:
     // 1. Set this.[[highWaterMark]] to init["highWaterMark"].
@@ -32,7 +31,7 @@ CountQueuingStrategy::CountQueuingStrategy(JS::Realm& realm, double high_water_m
 CountQueuingStrategy::~CountQueuingStrategy() = default;
 
 // https://streams.spec.whatwg.org/#cqs-size
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> CountQueuingStrategy::size()
+JS::NonnullGCPtr<WebIDL::CallbackType> CountQueuingStrategy::size()
 {
     // 1. Return this's relevant global object's count queuing strategy size function.
     return global_object().count_queuing_strategy_size_function();
diff --git a/Userland/Libraries/LibWeb/Streams/CountQueuingStrategy.h b/Userland/Libraries/LibWeb/Streams/CountQueuingStrategy.h
@@ -20,7 +20,7 @@ class CountQueuingStrategy final : public Bindings::PlatformObject {
     JS_DECLARE_ALLOCATOR(CountQueuingStrategy);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CountQueuingStrategy>> construct_impl(JS::Realm&, QueuingStrategyInit const&);
+    static JS::NonnullGCPtr<CountQueuingStrategy> construct_impl(JS::Realm&, QueuingStrategyInit const&);
 
     virtual ~CountQueuingStrategy() override;
 
@@ -32,7 +32,7 @@ class CountQueuingStrategy final : public Bindings::PlatformObject {
         return m_high_water_mark;
     }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> size();
+    JS::NonnullGCPtr<WebIDL::CallbackType> size();
 
 private:
     explicit CountQueuingStrategy(JS::Realm&, double high_water_mark);
diff --git a/Userland/Libraries/LibWeb/Streams/ReadableStream.cpp b/Userland/Libraries/LibWeb/Streams/ReadableStream.cpp
@@ -83,7 +83,7 @@ bool ReadableStream::locked() const
 }
 
 // https://streams.spec.whatwg.org/#rs-cancel
-WebIDL::ExceptionOr<JS::GCPtr<JS::Object>> ReadableStream::cancel(JS::Value reason)
+JS::NonnullGCPtr<JS::Object> ReadableStream::cancel(JS::Value reason)
 {
     auto& realm = this->realm();
 
@@ -134,7 +134,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> ReadableStream::pipe_throu
     return JS::NonnullGCPtr { *transform.readable };
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> ReadableStream::pipe_to(WritableStream& destination, StreamPipeOptions const& options)
+JS::NonnullGCPtr<JS::Object> ReadableStream::pipe_to(WritableStream& destination, StreamPipeOptions const& options)
 {
     auto& realm = this->realm();
 
diff --git a/Userland/Libraries/LibWeb/Streams/ReadableStream.h b/Userland/Libraries/LibWeb/Streams/ReadableStream.h
@@ -73,10 +73,10 @@ class ReadableStream final : public Bindings::PlatformObject {
     virtual ~ReadableStream() override;
 
     bool locked() const;
-    WebIDL::ExceptionOr<JS::GCPtr<JS::Object>> cancel(JS::Value reason);
+    JS::NonnullGCPtr<JS::Object> cancel(JS::Value reason);
     WebIDL::ExceptionOr<ReadableStreamReader> get_reader(ReadableStreamGetReaderOptions const& = {});
     WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> pipe_through(ReadableWritablePair transform, StreamPipeOptions const& = {});
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> pipe_to(WritableStream& destination, StreamPipeOptions const& = {});
+    JS::NonnullGCPtr<JS::Object> pipe_to(WritableStream& destination, StreamPipeOptions const& = {});
     WebIDL::ExceptionOr<ReadableStreamPair> tee();
 
     Optional<ReadableStreamController>& controller() { return m_controller; }
diff --git a/Userland/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.cpp b/Userland/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.cpp
@@ -107,7 +107,7 @@ class BYOBReaderReadIntoRequest : public ReadIntoRequest {
 JS_DEFINE_ALLOCATOR(BYOBReaderReadIntoRequest);
 
 // https://streams.spec.whatwg.org/#byob-reader-read
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Promise>> ReadableStreamBYOBReader::read(JS::Handle<WebIDL::ArrayBufferView>& view)
+JS::NonnullGCPtr<JS::Promise> ReadableStreamBYOBReader::read(JS::Handle<WebIDL::ArrayBufferView>& view)
 {
     auto& realm = this->realm();
 
diff --git a/Userland/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.h b/Userland/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.h
@@ -45,7 +45,7 @@ class ReadableStreamBYOBReader final
 
     virtual ~ReadableStreamBYOBReader() override = default;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Promise>> read(JS::Handle<WebIDL::ArrayBufferView>&);
+    JS::NonnullGCPtr<JS::Promise> read(JS::Handle<WebIDL::ArrayBufferView>&);
 
     void release_lock();
 
diff --git a/Userland/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.cpp b/Userland/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.cpp
@@ -152,7 +152,7 @@ class DefaultReaderReadRequest final : public ReadRequest {
 JS_DEFINE_ALLOCATOR(DefaultReaderReadRequest);
 
 // https://streams.spec.whatwg.org/#default-reader-read
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Promise>> ReadableStreamDefaultReader::read()
+JS::NonnullGCPtr<JS::Promise> ReadableStreamDefaultReader::read()
 {
     auto& realm = this->realm();
 
diff --git a/Userland/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.h b/Userland/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.h
@@ -73,7 +73,7 @@ class ReadableStreamDefaultReader final
 
     virtual ~ReadableStreamDefaultReader() override = default;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Promise>> read();
+    JS::NonnullGCPtr<JS::Promise> read();
 
     void read_all_bytes(ReadLoopReadRequest::SuccessSteps, ReadLoopReadRequest::FailureSteps);
     JS::NonnullGCPtr<WebIDL::Promise> read_all_bytes_deprecated();
diff --git a/Userland/Libraries/LibWeb/Streams/ReadableStreamGenericReader.cpp b/Userland/Libraries/LibWeb/Streams/ReadableStreamGenericReader.cpp
@@ -9,20 +9,19 @@
 #include <LibWeb/Streams/AbstractOperations.h>
 #include <LibWeb/Streams/ReadableStream.h>
 #include <LibWeb/Streams/ReadableStreamGenericReader.h>
-#include <LibWeb/WebIDL/ExceptionOr.h>
 #include <LibWeb/WebIDL/Promise.h>
 
 namespace Web::Streams {
 
 // https://streams.spec.whatwg.org/#generic-reader-closed
-WebIDL::ExceptionOr<JS::GCPtr<JS::Promise>> ReadableStreamGenericReaderMixin::closed()
+JS::GCPtr<JS::Promise> ReadableStreamGenericReaderMixin::closed()
 {
     // 1. Return this.[[closedPromise]].
     return JS::GCPtr { verify_cast<JS::Promise>(*m_closed_promise->promise()) };
 }
 
 // https://streams.spec.whatwg.org/#generic-reader-cancel
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Promise>> ReadableStreamGenericReaderMixin::cancel(JS::Value reason)
+JS::NonnullGCPtr<JS::Promise> ReadableStreamGenericReaderMixin::cancel(JS::Value reason)
 {
     // 1. If this.[[stream]] is undefined, return a promise rejected with a TypeError exception.
     if (!m_stream) {
diff --git a/Userland/Libraries/LibWeb/Streams/ReadableStreamGenericReader.h b/Userland/Libraries/LibWeb/Streams/ReadableStreamGenericReader.h
@@ -19,9 +19,9 @@ class ReadableStreamGenericReaderMixin {
 public:
     virtual ~ReadableStreamGenericReaderMixin() = default;
 
-    WebIDL::ExceptionOr<JS::GCPtr<JS::Promise>> closed();
+    JS::GCPtr<JS::Promise> closed();
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Promise>> cancel(JS::Value reason);
+    JS::NonnullGCPtr<JS::Promise> cancel(JS::Value reason);
 
     JS::GCPtr<ReadableStream> stream() const { return m_stream; }
     void set_stream(JS::GCPtr<ReadableStream> stream) { m_stream = stream; }

Original file line number	Diff line number	Diff line change
`@@ -738,7 +738,7 @@ Vector<JS::NonnullGCPtr<MimeType>> Window::pdf_viewer_mime_type_objects()`
`738`	`738`	`}`
`739`	`739`
`740`	`740`	`// https://streams.spec.whatwg.org/#count-queuing-strategy-size-function`
`741`		`-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> Window::count_queuing_strategy_size_function()`
	`741`	`+JS::NonnullGCPtr<WebIDL::CallbackType> Window::count_queuing_strategy_size_function()`
`742`	`742`	`{`
`743`	`743`	`auto& realm = this->realm();`
`744`	`744`
`@@ -760,7 +760,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> Window::count_queuin`
`760`	`760`	`}`
`761`	`761`
`762`	`762`	`// https://streams.spec.whatwg.org/#byte-length-queuing-strategy-size-function`
`763`		`-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> Window::byte_length_queuing_strategy_size_function()`
	`763`	`+JS::NonnullGCPtr<WebIDL::CallbackType> Window::byte_length_queuing_strategy_size_function()`
`764`	`764`	`{`
`765`	`765`	`auto& realm = this->realm();`
`766`	`766`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ bool ReadableStream::locked() const`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`// https://streams.spec.whatwg.org/#rs-cancel`
`86`		`-WebIDL::ExceptionOr<JS::GCPtr<JS::Object>> ReadableStream::cancel(JS::Value reason)`
	`86`	`+JS::NonnullGCPtr<JS::Object> ReadableStream::cancel(JS::Value reason)`
`87`	`87`	`{`
`88`	`88`	`auto& realm = this->realm();`
`89`	`89`
`@@ -134,7 +134,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> ReadableStream::pipe_throu`
`134`	`134`	`return JS::NonnullGCPtr { *transform.readable };`
`135`	`135`	`}`
`136`	`136`
`137`		`-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> ReadableStream::pipe_to(WritableStream& destination, StreamPipeOptions const& options)`
	`137`	`+JS::NonnullGCPtr<JS::Object> ReadableStream::pipe_to(WritableStream& destination, StreamPipeOptions const& options)`
`138`	`138`	`{`
`139`	`139`	`auto& realm = this->realm();`
`140`	`140`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ class BYOBReaderReadIntoRequest : public ReadIntoRequest {`
`107`	`107`	`JS_DEFINE_ALLOCATOR(BYOBReaderReadIntoRequest);`
`108`	`108`
`109`	`109`	`// https://streams.spec.whatwg.org/#byob-reader-read`
`110`		`-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Promise>> ReadableStreamBYOBReader::read(JS::Handle<WebIDL::ArrayBufferView>& view)`
	`110`	`+JS::NonnullGCPtr<JS::Promise> ReadableStreamBYOBReader::read(JS::Handle<WebIDL::ArrayBufferView>& view)`
`111`	`111`	`{`
`112`	`112`	`auto& realm = this->realm();`
`113`	`113`