LibWeb: Rename SharedImageRequest to SharedResourceRequest

For the SVG <use> element, we want to support loading HTML documents
that have a SVG element inside of it pointed to by the URL fragment.

In this situation we would need to fetch and parse the entire document
in SharedImageRequest (so that we can still cache the SVGs). Rename
SharedImageRequest to SharedResourceRequest to make the class a little
more generic for future usecases.

Userland/Libraries/LibWeb/HTML/SharedResourceRequest.cpp

@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/HashTable.h>
+#include <LibGfx/Bitmap.h>
+#include <LibWeb/Fetch/Fetching/Fetching.h>
+#include <LibWeb/Fetch/Infrastructure/FetchAlgorithms.h>
+#include <LibWeb/Fetch/Infrastructure/FetchController.h>
+#include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
+#include <LibWeb/Fetch/Infrastructure/HTTP/Statuses.h>
+#include <LibWeb/HTML/AnimatedBitmapDecodedImageData.h>
+#include <LibWeb/HTML/DecodedImageData.h>
+#include <LibWeb/HTML/SharedResourceRequest.h>
+#include <LibWeb/Page/Page.h>
+#include <LibWeb/Platform/ImageCodecPlugin.h>
+#include <LibWeb/SVG/SVGDecodedImageData.h>
+
+namespace Web::HTML {
+
+JS_DEFINE_ALLOCATOR(SharedResourceRequest);
+
+JS::NonnullGCPtr<SharedResourceRequest> SharedResourceRequest::get_or_create(JS::Realm& realm, JS::NonnullGCPtr<Page> page, URL::URL const& url)
+{
+    auto document = Bindings::host_defined_environment_settings_object(realm).responsible_document();
+    VERIFY(document);
+    auto& shared_resource_requests = document->shared_resource_requests();
+    if (auto it = shared_resource_requests.find(url); it != shared_resource_requests.end())
+        return *it->value;
+    auto request = realm.heap().allocate<SharedResourceRequest>(realm, page, url, *document);
+    shared_resource_requests.set(url, request);
+    return request;
+}
+
+SharedResourceRequest::SharedResourceRequest(JS::NonnullGCPtr<Page> page, URL::URL url, JS::NonnullGCPtr<DOM::Document> document)
+    : m_page(page)
+    , m_url(move(url))
+    , m_document(document)
+{
+}
+
+SharedResourceRequest::~SharedResourceRequest() = default;
+
+void SharedResourceRequest::finalize()
+{
+    Base::finalize();
+    auto& shared_resource_requests = m_document->shared_resource_requests();
+    shared_resource_requests.remove(m_url);
+}
+
+void SharedResourceRequest::visit_edges(JS::Cell::Visitor& visitor)
+{
+    Base::visit_edges(visitor);
+    visitor.visit(m_fetch_controller);
+    visitor.visit(m_document);
+    visitor.visit(m_page);
+    for (auto& callback : m_callbacks) {
+        visitor.visit(callback.on_finish);
+        visitor.visit(callback.on_fail);
+    }
+    visitor.visit(m_image_data);
+}
+
+JS::GCPtr<DecodedImageData> SharedResourceRequest::image_data() const
+{
+    return m_image_data;
+}
+
+JS::GCPtr<Fetch::Infrastructure::FetchController> SharedResourceRequest::fetch_controller()
+{
+    return m_fetch_controller.ptr();
+}
+
+void SharedResourceRequest::set_fetch_controller(JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller)
+{
+    m_fetch_controller = move(fetch_controller);
+}
+
+void SharedResourceRequest::fetch_resource(JS::Realm& realm, JS::NonnullGCPtr<Fetch::Infrastructure::Request> request)
+{
+    Fetch::Infrastructure::FetchAlgorithms::Input fetch_algorithms_input {};
+    fetch_algorithms_input.process_response = [this, &realm, request](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) {
+        // FIXME: If the response is CORS cross-origin, we must use its internal response to query any of its data. See:
+        //        https://github.com/whatwg/html/issues/9355
+        response = response->unsafe_response();
+
+        auto process_body = JS::create_heap_function(heap(), [this, request, response](ByteBuffer data) {
+            auto extracted_mime_type = response->header_list()->extract_mime_type();
+            auto mime_type = extracted_mime_type.has_value() ? extracted_mime_type.value().essence().bytes_as_string_view() : StringView {};
+            handle_successful_fetch(request->url(), mime_type, move(data));
+        });
+        auto process_body_error = JS::create_heap_function(heap(), [this](JS::Value) {
+            handle_failed_fetch();
+        });
+
+        // Check for failed fetch response
+        if (!Fetch::Infrastructure::is_ok_status(response->status()) || !response->body()) {
+            handle_failed_fetch();
+            return;
+        }
+
+        response->body()->fully_read(realm, process_body, process_body_error, JS::NonnullGCPtr { realm.global_object() });
+    };
+
+    m_state = State::Fetching;
+
+    auto fetch_controller = Fetch::Fetching::fetch(
+        realm,
+        request,
+        Fetch::Infrastructure::FetchAlgorithms::create(realm.vm(), move(fetch_algorithms_input)))
+                                .release_value_but_fixme_should_propagate_errors();
+
+    set_fetch_controller(fetch_controller);
+}
+
+void SharedResourceRequest::add_callbacks(Function<void()> on_finish, Function<void()> on_fail)
+{
+    if (m_state == State::Finished) {
+        if (on_finish)
+            on_finish();
+        return;
+    }
+
+    if (m_state == State::Failed) {
+        if (on_fail)
+            on_fail();
+        return;
+    }
+
+    Callbacks callbacks;
+    if (on_finish)
+        callbacks.on_finish = JS::create_heap_function(vm().heap(), move(on_finish));
+    if (on_fail)
+        callbacks.on_fail = JS::create_heap_function(vm().heap(), move(on_fail));
+
+    m_callbacks.append(move(callbacks));
+}
+
+void SharedResourceRequest::handle_successful_fetch(URL::URL const& url_string, StringView mime_type, ByteBuffer data)
+{
+    // AD-HOC: At this point, things gets very ad-hoc.
+    // FIXME: Bring this closer to spec.
+
+    bool const is_svg_image = mime_type == "image/svg+xml"sv || url_string.basename().ends_with(".svg"sv);
+
+    if (is_svg_image) {
+        auto result = SVG::SVGDecodedImageData::create(m_document->realm(), m_page, url_string, data);
+        if (result.is_error()) {
+            handle_failed_fetch();
+        } else {
+            m_image_data = result.release_value();
+            handle_successful_resource_load();
+        }
+        return;
+    }
+
+    auto handle_successful_bitmap_decode = [strong_this = JS::Handle(*this)](Web::Platform::DecodedImage& result) -> ErrorOr<void> {
+        Vector<AnimatedBitmapDecodedImageData::Frame> frames;
+        for (auto& frame : result.frames) {
+            frames.append(AnimatedBitmapDecodedImageData::Frame {
+                .bitmap = Gfx::ImmutableBitmap::create(*frame.bitmap),
+                .duration = static_cast<int>(frame.duration),
+            });
+        }
+        strong_this->m_image_data = AnimatedBitmapDecodedImageData::create(strong_this->m_document->realm(), move(frames), result.loop_count, result.is_animated).release_value_but_fixme_should_propagate_errors();
+        strong_this->handle_successful_resource_load();
+        return {};
+    };
+
+    auto handle_failed_decode = [strong_this = JS::Handle(*this)](Error&) -> void {
+        strong_this->handle_failed_fetch();
+    };
+
+    (void)Web::Platform::ImageCodecPlugin::the().decode_image(data.bytes(), move(handle_successful_bitmap_decode), move(handle_failed_decode));
+}
+
+void SharedResourceRequest::handle_failed_fetch()
+{
+    m_state = State::Failed;
+    for (auto& callback : m_callbacks) {
+        if (callback.on_fail)
+            callback.on_fail->function()();
+    }
+    m_callbacks.clear();
+}
+
+void SharedResourceRequest::handle_successful_resource_load()
+{
+    m_state = State::Finished;
+    for (auto& callback : m_callbacks) {
+        if (callback.on_finish)
+            callback.on_finish->function()();
+    }
+    m_callbacks.clear();
+}
+
+bool SharedResourceRequest::needs_fetching() const
+{
+    return m_state == State::New;
+}
+
+bool SharedResourceRequest::is_fetching() const
+{
+    return m_state == State::Fetching;
+}
+
+}