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.

Meta/gn/secondary/Userland/Libraries/LibWeb/HTML/BUILD.gn

@@ -159,7 +159,7 @@ source_set("HTML") {
     "SelectedFile.cpp",
     "SessionHistoryEntry.cpp",
     "SessionHistoryTraversalQueue.cpp",
-    "SharedImageRequest.cpp",
+    "SharedResourceRequest.cpp",
     "SourceSet.cpp",
     "Storage.cpp",
     "StructuredSerialize.cpp",

Userland/Libraries/LibWeb/CMakeLists.txt

@@ -434,7 +434,7 @@ set(SOURCES
     HTML/SelectItem.cpp
     HTML/SessionHistoryEntry.cpp
     HTML/SessionHistoryTraversalQueue.cpp
-    HTML/SharedImageRequest.cpp
+    HTML/SharedResourceRequest.cpp
     HTML/SourceSet.cpp
     HTML/Storage.cpp
     HTML/StructuredSerialize.cpp

Userland/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp

@@ -30,12 +30,12 @@ ImageStyleValue::~ImageStyleValue() = default;
 
 void ImageStyleValue::load_any_resources(DOM::Document& document)
 {
-    if (m_image_request)
+    if (m_resource_request)
         return;
     m_document = &document;
 
-    m_image_request = HTML::SharedImageRequest::get_or_create(document.realm(), document.page(), m_url);
-    m_image_request->add_callbacks(
+    m_resource_request = HTML::SharedResourceRequest::get_or_create(document.realm(), document.page(), m_url);
+    m_resource_request->add_callbacks(
         [this, weak_this = make_weak_ptr()] {
             if (!weak_this)
                 return;
@@ -47,7 +47,7 @@ void ImageStyleValue::load_any_resources(DOM::Document& document)
             if (auto navigable = m_document->navigable())
                 navigable->set_needs_display();
 
-            auto image_data = m_image_request->image_data();
+            auto image_data = m_resource_request->image_data();
             if (image_data->is_animated() && image_data->frame_count() > 1) {
                 m_timer = Platform::Timer::create();
                 m_timer->set_interval(image_data->frame_duration(0));
@@ -57,18 +57,18 @@ void ImageStyleValue::load_any_resources(DOM::Document& document)
         },
         nullptr);
 
-    if (m_image_request->needs_fetching()) {
+    if (m_resource_request->needs_fetching()) {
         auto request = HTML::create_potential_CORS_request(document.vm(), m_url, Fetch::Infrastructure::Request::Destination::Image, HTML::CORSSettingAttribute::NoCORS);
         request->set_client(&document.relevant_settings_object());
-        m_image_request->fetch_image(document.realm(), request);
+        m_resource_request->fetch_resource(document.realm(), request);
     }
 }
 
 void ImageStyleValue::animate()
 {
-    if (!m_image_request)
+    if (!m_resource_request)
         return;
-    auto image_data = m_image_request->image_data();
+    auto image_data = m_resource_request->image_data();
     if (!image_data)
         return;
 
@@ -148,9 +148,9 @@ Gfx::ImmutableBitmap const* ImageStyleValue::current_frame_bitmap(DevicePixelRec
 
 JS::GCPtr<HTML::DecodedImageData> ImageStyleValue::image_data() const
 {
-    if (!m_image_request)
+    if (!m_resource_request)
         return nullptr;
-    return m_image_request->image_data();
+    return m_resource_request->image_data();
 }
 
 Optional<Gfx::Color> ImageStyleValue::color_if_single_pixel_bitmap() const

Userland/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h

@@ -14,7 +14,7 @@
 #include <LibURL/URL.h>
 #include <LibWeb/CSS/Enums.h>
 #include <LibWeb/CSS/StyleValues/AbstractImageStyleValue.h>
-#include <LibWeb/HTML/SharedImageRequest.h>
+#include <LibWeb/HTML/SharedResourceRequest.h>
 
 namespace Web::CSS {
 
@@ -32,7 +32,7 @@ public:
     {
         // FIXME: visit_edges in non-GC allocated classes is confusing pattern.
         //        Consider making StyleValue to be GC allocated instead.
-        visitor.visit(m_image_request);
+        visitor.visit(m_resource_request);
     }
 
     virtual String to_string() const override;
@@ -57,7 +57,7 @@ public:
 private:
     ImageStyleValue(URL::URL const&);
 
-    JS::GCPtr<HTML::SharedImageRequest> m_image_request;
+    JS::GCPtr<HTML::SharedResourceRequest> m_resource_request;
 
     void animate();
     Gfx::ImmutableBitmap const* bitmap(size_t frame_index, Gfx::IntSize = {}) const;

Userland/Libraries/LibWeb/DOM/Document.cpp

@@ -99,6 +99,7 @@
 #include <LibWeb/HTML/Scripting/ClassicScript.h>
 #include <LibWeb/HTML/Scripting/ExceptionReporter.h>
 #include <LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.h>
+#include <LibWeb/HTML/SharedResourceRequest.h>
 #include <LibWeb/HTML/TraversableNavigable.h>
 #include <LibWeb/HTML/Window.h>
 #include <LibWeb/HTML/WindowProxy.h>
@@ -482,7 +483,7 @@ void Document::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_intersection_observers);
     visitor.visit(m_resize_observers);
 
-    visitor.visit(m_shared_image_requests);
+    visitor.visit(m_shared_resource_requests);
 
     visitor.visit(m_associated_animation_timelines);
     visitor.visit(m_list_of_available_images);
@@ -4304,9 +4305,9 @@ void Document::update_for_history_step_application(JS::NonnullGCPtr<HTML::Sessio
     }
 }
 
-HashMap<URL::URL, JS::GCPtr<HTML::SharedImageRequest>>& Document::shared_image_requests()
+HashMap<URL::URL, JS::GCPtr<HTML::SharedResourceRequest>>& Document::shared_resource_requests()
 {
-    return m_shared_image_requests;
+    return m_shared_resource_requests;
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-document-timeline

Userland/Libraries/LibWeb/DOM/Document.h

@@ -34,7 +34,6 @@
 #include <LibWeb/HTML/Origin.h>
 #include <LibWeb/HTML/SandboxingFlagSet.h>
 #include <LibWeb/HTML/Scripting/Environments.h>
-#include <LibWeb/HTML/SharedImageRequest.h>
 #include <LibWeb/HTML/VisibilityState.h>
 #include <LibWeb/WebIDL/ExceptionOr.h>
 #include <LibWeb/WebIDL/ObservableArray.h>
@@ -601,7 +600,7 @@ public:
 
     void update_for_history_step_application(JS::NonnullGCPtr<HTML::SessionHistoryEntry>, bool do_not_reactivate, size_t script_history_length, size_t script_history_index, Optional<Bindings::NavigationType> navigation_type, Optional<Vector<JS::NonnullGCPtr<HTML::SessionHistoryEntry>>> entries_for_navigation_api = {}, Optional<JS::NonnullGCPtr<HTML::SessionHistoryEntry>> previous_entry_for_activation = {}, bool update_navigation_api = true);
 
-    HashMap<URL::URL, JS::GCPtr<HTML::SharedImageRequest>>& shared_image_requests();
+    HashMap<URL::URL, JS::GCPtr<HTML::SharedResourceRequest>>& shared_resource_requests();
 
     void restore_the_history_object_state(JS::NonnullGCPtr<HTML::SessionHistoryEntry> entry);
 
@@ -917,7 +916,7 @@ private:
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#latest-entry
     JS::GCPtr<HTML::SessionHistoryEntry> m_latest_entry;
 
-    HashMap<URL::URL, JS::GCPtr<HTML::SharedImageRequest>> m_shared_image_requests;
+    HashMap<URL::URL, JS::GCPtr<HTML::SharedResourceRequest>> m_shared_resource_requests;
 
     // https://www.w3.org/TR/web-animations-1/#timeline-associated-with-a-document
     HashTable<JS::NonnullGCPtr<Animations::AnimationTimeline>> m_associated_animation_timelines;

Userland/Libraries/LibWeb/Forward.h

@@ -474,7 +474,7 @@ class Plugin;
 class PluginArray;
 class PromiseRejectionEvent;
 class SelectedFile;
-class SharedImageRequest;
+class SharedResourceRequest;
 class Storage;
 class SubmitEvent;
 class TextMetrics;

Userland/Libraries/LibWeb/HTML/HTMLImageElement.cpp

@@ -674,8 +674,8 @@ void HTMLImageElement::add_callbacks_to_image_request(JS::NonnullGCPtr<ImageRequ
     image_request->add_callbacks(
         [this, image_request, maybe_omit_events, url_string, previous_url]() {
             batching_dispatcher().enqueue([this, image_request, maybe_omit_events, url_string, previous_url] {
-                VERIFY(image_request->shared_image_request());
-                auto image_data = image_request->shared_image_request()->image_data();
+                VERIFY(image_request->shared_resource_request());
+                auto image_data = image_request->shared_resource_request()->image_data();
                 image_request->set_image_data(image_data);
 
                 ListOfAvailableImages::Key key;
@@ -884,8 +884,8 @@ void HTMLImageElement::react_to_changes_in_the_environment()
                 batching_dispatcher().enqueue([step_15, selected_source = move(selected_source), image_request, key] {
                     // 7. Otherwise, response's unsafe response is image request's image data. It can be either CORS-same-origin
                     //    or CORS-cross-origin; this affects the image's interaction with other APIs (e.g., when used on a canvas).
-                    VERIFY(image_request->shared_image_request());
-                    auto image_data = image_request->shared_image_request()->image_data();
+                    VERIFY(image_request->shared_resource_request());
+                    auto image_data = image_request->shared_resource_request()->image_data();
                     image_request->set_image_data(image_data);
                     step_15(selected_source, image_request, key, *image_data);
                 });

Userland/Libraries/LibWeb/HTML/HTMLInputElement.cpp

@@ -31,7 +31,7 @@
 #include <LibWeb/HTML/Parser/HTMLParser.h>
 #include <LibWeb/HTML/Scripting/Environments.h>
 #include <LibWeb/HTML/SelectedFile.h>
-#include <LibWeb/HTML/SharedImageRequest.h>
+#include <LibWeb/HTML/SharedResourceRequest.h>
 #include <LibWeb/HTML/ValidityState.h>
 #include <LibWeb/HTML/Window.h>
 #include <LibWeb/Infra/CharacterTypes.h>
@@ -80,7 +80,7 @@ void HTMLInputElement::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_selected_files);
     visitor.visit(m_slider_thumb);
     visitor.visit(m_slider_progress_element);
-    visitor.visit(m_image_request);
+    visitor.visit(m_resource_request);
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-cva-validity
@@ -1242,8 +1242,8 @@ WebIDL::ExceptionOr<void> HTMLInputElement::handle_src_attribute(String const& v
     request->set_use_url_credentials(true);
 
     // 4. Fetch request, with processResponseEndOfBody set to the following step given response response:
-    m_image_request = SharedImageRequest::get_or_create(realm, document().page(), request->url());
-    m_image_request->add_callbacks(
+    m_resource_request = SharedResourceRequest::get_or_create(realm, document().page(), request->url());
+    m_resource_request->add_callbacks(
         [this, &realm]() {
             // 1. If the download was successful and the image is available, queue an element task on the user interaction
             //    task source given the input element to fire an event named load at the input element.
@@ -1265,8 +1265,8 @@ WebIDL::ExceptionOr<void> HTMLInputElement::handle_src_attribute(String const& v
             m_load_event_delayer.clear();
         });
 
-    if (m_image_request->needs_fetching()) {
-        m_image_request->fetch_image(realm, request);
+    if (m_resource_request->needs_fetching()) {
+        m_resource_request->fetch_resource(realm, request);
     }
 
     // Fetching the image must delay the load event of the element's node document until the task that is queued by the
@@ -1563,8 +1563,8 @@ void HTMLInputElement::legacy_cancelled_activation_behavior_was_not_called()
 
 JS::GCPtr<DecodedImageData> HTMLInputElement::image_data() const
 {
-    if (m_image_request)
-        return m_image_request->image_data();
+    if (m_resource_request)
+        return m_resource_request->image_data();
     return nullptr;
 }
 

Userland/Libraries/LibWeb/HTML/HTMLInputElement.h

@@ -299,7 +299,7 @@ private:
     JS::GCPtr<DOM::Element> m_slider_progress_element;
 
     JS::GCPtr<DecodedImageData> image_data() const;
-    JS::GCPtr<SharedImageRequest> m_image_request;
+    JS::GCPtr<SharedResourceRequest> m_resource_request;
     SelectedCoordinate m_selected_coordinate;
 
     Optional<DOM::DocumentLoadEventDelayer> m_load_event_delayer;

Userland/Libraries/LibWeb/HTML/HTMLObjectElement.cpp

@@ -47,7 +47,7 @@ void HTMLObjectElement::initialize(JS::Realm& realm)
 void HTMLObjectElement::visit_edges(Cell::Visitor& visitor)
 {
     Base::visit_edges(visitor);
-    visitor.visit(m_image_request);
+    visitor.visit(m_resource_request);
 }
 
 void HTMLObjectElement::form_associated_element_attribute_changed(FlyString const& name, Optional<String> const&)
@@ -332,8 +332,8 @@ void HTMLObjectElement::load_image()
     // NOTE: This currently reloads the image instead of reusing the resource we've already downloaded.
     auto data = get_attribute_value(HTML::AttributeNames::data);
     auto url = document().parse_url(data);
-    m_image_request = HTML::SharedImageRequest::get_or_create(realm(), document().page(), url);
-    m_image_request->add_callbacks(
+    m_resource_request = HTML::SharedResourceRequest::get_or_create(realm(), document().page(), url);
+    m_resource_request->add_callbacks(
         [this] {
             run_object_representation_completed_steps(Representation::Image);
         },
@@ -341,10 +341,10 @@ void HTMLObjectElement::load_image()
             run_object_representation_fallback_steps();
         });
 
-    if (m_image_request->needs_fetching()) {
+    if (m_resource_request->needs_fetching()) {
         auto request = HTML::create_potential_CORS_request(vm(), url, Fetch::Infrastructure::Request::Destination::Image, HTML::CORSSettingAttribute::NoCORS);
         request->set_client(&document().relevant_settings_object());
-        m_image_request->fetch_image(realm(), request);
+        m_resource_request->fetch_resource(realm(), request);
     }
 }
 
@@ -372,9 +372,9 @@ i32 HTMLObjectElement::default_tab_index_value() const
 
 JS::GCPtr<DecodedImageData> HTMLObjectElement::image_data() const
 {
-    if (!m_image_request)
+    if (!m_resource_request)
         return nullptr;
-    return m_image_request->image_data();
+    return m_resource_request->image_data();
 }
 
 bool HTMLObjectElement::is_image_available() const

Userland/Libraries/LibWeb/HTML/HTMLObjectElement.h

@@ -88,7 +88,7 @@ private:
 
     JS::GCPtr<DecodedImageData> image_data() const;
 
-    JS::GCPtr<SharedImageRequest> m_image_request;
+    JS::GCPtr<SharedResourceRequest> m_resource_request;
 };
 
 }

Userland/Libraries/LibWeb/HTML/ImageRequest.cpp

@@ -14,6 +14,7 @@
 #include <LibWeb/HTML/DecodedImageData.h>
 #include <LibWeb/HTML/ImageRequest.h>
 #include <LibWeb/HTML/ListOfAvailableImages.h>
+#include <LibWeb/HTML/SharedResourceRequest.h>
 #include <LibWeb/Page/Page.h>
 #include <LibWeb/Platform/ImageCodecPlugin.h>
 #include <LibWeb/SVG/SVGDecodedImageData.h>
@@ -39,7 +40,7 @@ ImageRequest::~ImageRequest()
 void ImageRequest::visit_edges(JS::Cell::Visitor& visitor)
 {
     Base::visit_edges(visitor);
-    visitor.visit(m_shared_image_request);
+    visitor.visit(m_shared_resource_request);
     visitor.visit(m_page);
     visitor.visit(m_image_data);
 }
@@ -53,7 +54,7 @@ bool ImageRequest::is_available() const
 
 bool ImageRequest::is_fetching() const
 {
-    return m_shared_image_request && m_shared_image_request->is_fetching();
+    return m_shared_resource_request && m_shared_resource_request->is_fetching();
 }
 
 ImageRequest::State ImageRequest::state() const
@@ -75,7 +76,7 @@ void ImageRequest::set_current_url(JS::Realm& realm, URL::URL url)
 {
     m_current_url = move(url);
     if (m_current_url.is_valid())
-        m_shared_image_request = SharedImageRequest::get_or_create(realm, m_page, m_current_url);
+        m_shared_resource_request = SharedResourceRequest::get_or_create(realm, m_page, m_current_url);
 }
 
 // https://html.spec.whatwg.org/multipage/images.html#abort-the-image-request
@@ -90,7 +91,7 @@ void abort_the_image_request(JS::Realm&, ImageRequest* image_request)
 
     // 3. Abort any instance of the fetching algorithm for image request,
     //    discarding any pending tasks generated by that algorithm.
-    // AD-HOC: We simply don't do this, since our SharedImageRequest may be used by someone else.
+    // AD-HOC: We simply don't do this, since our SharedResourceRequest may be used by someone else.
 }
 
 JS::GCPtr<DecodedImageData> ImageRequest::image_data() const
@@ -126,14 +127,14 @@ void ImageRequest::prepare_for_presentation(HTMLImageElement&)
 
 void ImageRequest::fetch_image(JS::Realm& realm, JS::NonnullGCPtr<Fetch::Infrastructure::Request> request)
 {
-    VERIFY(m_shared_image_request);
-    m_shared_image_request->fetch_image(realm, request);
+    VERIFY(m_shared_resource_request);
+    m_shared_resource_request->fetch_resource(realm, request);
 }
 
 void ImageRequest::add_callbacks(Function<void()> on_finish, Function<void()> on_fail)
 {
-    VERIFY(m_shared_image_request);
-    m_shared_image_request->add_callbacks(move(on_finish), move(on_fail));
+    VERIFY(m_shared_resource_request);
+    m_shared_resource_request->add_callbacks(move(on_finish), move(on_fail));
 }
 
 }

Userland/Libraries/LibWeb/HTML/ImageRequest.h

@@ -12,7 +12,6 @@
 #include <LibJS/Heap/Handle.h>
 #include <LibURL/URL.h>
 #include <LibWeb/Forward.h>
-#include <LibWeb/HTML/SharedImageRequest.h>
 
 namespace Web::HTML {
 
@@ -58,7 +57,7 @@ public:
     void fetch_image(JS::Realm&, JS::NonnullGCPtr<Fetch::Infrastructure::Request>);
     void add_callbacks(Function<void()> on_finish, Function<void()> on_fail);
 
-    SharedImageRequest const* shared_image_request() const { return m_shared_image_request; }
+    JS::GCPtr<SharedResourceRequest const> shared_resource_request() const { return m_shared_resource_request; }
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
@@ -87,7 +86,7 @@ private:
     // which is either a struct consisting of a width and a height or is null. It must initially be null.
     Optional<Gfx::FloatSize> m_preferred_density_corrected_dimensions;
 
-    JS::GCPtr<SharedImageRequest> m_shared_image_request;
+    JS::GCPtr<SharedResourceRequest> m_shared_resource_request;
 };
 
 // https://html.spec.whatwg.org/multipage/images.html#abort-the-image-request

Userland/Libraries/LibWeb/HTML/SharedResourceRequest.cpp

@@ -13,44 +13,44 @@
 #include <LibWeb/Fetch/Infrastructure/HTTP/Statuses.h>
 #include <LibWeb/HTML/AnimatedBitmapDecodedImageData.h>
 #include <LibWeb/HTML/DecodedImageData.h>
-#include <LibWeb/HTML/SharedImageRequest.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(SharedImageRequest);
+JS_DEFINE_ALLOCATOR(SharedResourceRequest);
 
-JS::NonnullGCPtr<SharedImageRequest> SharedImageRequest::get_or_create(JS::Realm& realm, JS::NonnullGCPtr<Page> page, URL::URL const& url)
+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_image_requests = document->shared_image_requests();
-    if (auto it = shared_image_requests.find(url); it != shared_image_requests.end())
+    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<SharedImageRequest>(realm, page, url, *document);
-    shared_image_requests.set(url, request);
+    auto request = realm.heap().allocate<SharedResourceRequest>(realm, page, url, *document);
+    shared_resource_requests.set(url, request);
     return request;
 }
 
-SharedImageRequest::SharedImageRequest(JS::NonnullGCPtr<Page> page, URL::URL url, JS::NonnullGCPtr<DOM::Document> document)
+SharedResourceRequest::SharedResourceRequest(JS::NonnullGCPtr<Page> page, URL::URL url, JS::NonnullGCPtr<DOM::Document> document)
     : m_page(page)
     , m_url(move(url))
     , m_document(document)
 {
 }
 
-SharedImageRequest::~SharedImageRequest() = default;
+SharedResourceRequest::~SharedResourceRequest() = default;
 
-void SharedImageRequest::finalize()
+void SharedResourceRequest::finalize()
 {
     Base::finalize();
-    auto& shared_image_requests = m_document->shared_image_requests();
-    shared_image_requests.remove(m_url);
+    auto& shared_resource_requests = m_document->shared_resource_requests();
+    shared_resource_requests.remove(m_url);
 }
 
-void SharedImageRequest::visit_edges(JS::Cell::Visitor& visitor)
+void SharedResourceRequest::visit_edges(JS::Cell::Visitor& visitor)
 {
     Base::visit_edges(visitor);
     visitor.visit(m_fetch_controller);
@@ -63,22 +63,22 @@ void SharedImageRequest::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_image_data);
 }
 
-JS::GCPtr<DecodedImageData> SharedImageRequest::image_data() const
+JS::GCPtr<DecodedImageData> SharedResourceRequest::image_data() const
 {
     return m_image_data;
 }
 
-JS::GCPtr<Fetch::Infrastructure::FetchController> SharedImageRequest::fetch_controller()
+JS::GCPtr<Fetch::Infrastructure::FetchController> SharedResourceRequest::fetch_controller()
 {
     return m_fetch_controller.ptr();
 }
 
-void SharedImageRequest::set_fetch_controller(JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller)
+void SharedResourceRequest::set_fetch_controller(JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller)
 {
     m_fetch_controller = move(fetch_controller);
 }
 
-void SharedImageRequest::fetch_image(JS::Realm& realm, JS::NonnullGCPtr<Fetch::Infrastructure::Request> request)
+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) {
@@ -115,7 +115,7 @@ void SharedImageRequest::fetch_image(JS::Realm& realm, JS::NonnullGCPtr<Fetch::I
     set_fetch_controller(fetch_controller);
 }
 
-void SharedImageRequest::add_callbacks(Function<void()> on_finish, Function<void()> on_fail)
+void SharedResourceRequest::add_callbacks(Function<void()> on_finish, Function<void()> on_fail)
 {
     if (m_state == State::Finished) {
         if (on_finish)
@@ -138,7 +138,7 @@ void SharedImageRequest::add_callbacks(Function<void()> on_finish, Function<void
     m_callbacks.append(move(callbacks));
 }
 
-void SharedImageRequest::handle_successful_fetch(URL::URL const& url_string, StringView mime_type, ByteBuffer data)
+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.
@@ -176,7 +176,7 @@ void SharedImageRequest::handle_successful_fetch(URL::URL const& url_string, Str
     (void)Web::Platform::ImageCodecPlugin::the().decode_image(data.bytes(), move(handle_successful_bitmap_decode), move(handle_failed_decode));
 }
 
-void SharedImageRequest::handle_failed_fetch()
+void SharedResourceRequest::handle_failed_fetch()
 {
     m_state = State::Failed;
     for (auto& callback : m_callbacks) {
@@ -186,7 +186,7 @@ void SharedImageRequest::handle_failed_fetch()
     m_callbacks.clear();
 }
 
-void SharedImageRequest::handle_successful_resource_load()
+void SharedResourceRequest::handle_successful_resource_load()
 {
     m_state = State::Finished;
     for (auto& callback : m_callbacks) {
@@ -196,12 +196,12 @@ void SharedImageRequest::handle_successful_resource_load()
     m_callbacks.clear();
 }
 
-bool SharedImageRequest::needs_fetching() const
+bool SharedResourceRequest::needs_fetching() const
 {
     return m_state == State::New;
 }
 
-bool SharedImageRequest::is_fetching() const
+bool SharedResourceRequest::is_fetching() const
 {
     return m_state == State::Fetching;
 }

Userland/Libraries/LibWeb/HTML/SharedResourceRequest.h

@@ -17,14 +17,14 @@
 
 namespace Web::HTML {
 
-class SharedImageRequest final : public JS::Cell {
-    JS_CELL(SharedImageRequest, JS::Cell);
-    JS_DECLARE_ALLOCATOR(SharedImageRequest);
+class SharedResourceRequest final : public JS::Cell {
+    JS_CELL(SharedResourceRequest, JS::Cell);
+    JS_DECLARE_ALLOCATOR(SharedResourceRequest);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SharedImageRequest> get_or_create(JS::Realm&, JS::NonnullGCPtr<Page>, URL::URL const&);
+    [[nodiscard]] static JS::NonnullGCPtr<SharedResourceRequest> get_or_create(JS::Realm&, JS::NonnullGCPtr<Page>, URL::URL const&);
 
-    virtual ~SharedImageRequest() override;
+    virtual ~SharedResourceRequest() override;
 
     URL::URL const& url() const { return m_url; }
 
@@ -33,7 +33,7 @@ public:
     [[nodiscard]] JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller();
     void set_fetch_controller(JS::GCPtr<Fetch::Infrastructure::FetchController>);
 
-    void fetch_image(JS::Realm&, JS::NonnullGCPtr<Fetch::Infrastructure::Request>);
+    void fetch_resource(JS::Realm&, JS::NonnullGCPtr<Fetch::Infrastructure::Request>);
 
     void add_callbacks(Function<void()> on_finish, Function<void()> on_fail);
 
@@ -41,7 +41,7 @@ public:
     bool needs_fetching() const;
 
 private:
-    explicit SharedImageRequest(JS::NonnullGCPtr<Page>, URL::URL, JS::NonnullGCPtr<DOM::Document>);
+    explicit SharedResourceRequest(JS::NonnullGCPtr<Page>, URL::URL, JS::NonnullGCPtr<DOM::Document>);
 
     virtual void finalize() override;
     virtual void visit_edges(JS::Cell::Visitor&) override;

Userland/Libraries/LibWeb/SVG/SVGUseElement.cpp

@@ -52,7 +52,7 @@ void SVGUseElement::visit_edges(Cell::Visitor& visitor)
     Base::visit_edges(visitor);
     SVGURIReferenceMixin::visit_edges(visitor);
     visitor.visit(m_document_observer);
-    visitor.visit(m_image_request);
+    visitor.visit(m_resource_request);
 }
 
 void SVGUseElement::attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value)
@@ -142,10 +142,10 @@ JS::GCPtr<DOM::Element> SVGUseElement::referenced_element()
     if (is_referrenced_element_same_document())
         return document().get_element_by_id(*m_href.fragment());
 
-    if (!m_image_request)
+    if (!m_resource_request)
         return nullptr;
 
-    auto data = m_image_request->image_data();
+    auto data = m_resource_request->image_data();
     if (!data || !is<SVG::SVGDecodedImageData>(*data))
         return nullptr;
 
@@ -156,8 +156,8 @@ JS::GCPtr<DOM::Element> SVGUseElement::referenced_element()
 void SVGUseElement::fetch_the_document(URL::URL const& url)
 {
     m_load_event_delayer.emplace(document());
-    m_image_request = HTML::SharedImageRequest::get_or_create(realm(), document().page(), url);
-    m_image_request->add_callbacks(
+    m_resource_request = HTML::SharedResourceRequest::get_or_create(realm(), document().page(), url);
+    m_resource_request->add_callbacks(
         [this] {
             clone_element_tree_as_our_shadow_tree(referenced_element());
             m_load_event_delayer.clear();
@@ -166,10 +166,10 @@ void SVGUseElement::fetch_the_document(URL::URL const& url)
             m_load_event_delayer.clear();
         });
 
-    if (m_image_request->needs_fetching()) {
+    if (m_resource_request->needs_fetching()) {
         auto request = HTML::create_potential_CORS_request(vm(), url, Fetch::Infrastructure::Request::Destination::Image, HTML::CORSSettingAttribute::NoCORS);
         request->set_client(&document().relevant_settings_object());
-        m_image_request->fetch_image(realm(), request);
+        m_resource_request->fetch_resource(realm(), request);
     }
 }
 

Userland/Libraries/LibWeb/SVG/SVGUseElement.h

@@ -69,7 +69,7 @@ private:
     URL::URL m_href;
 
     JS::GCPtr<DOM::DocumentObserver> m_document_observer;
-    JS::GCPtr<HTML::SharedImageRequest> m_image_request;
+    JS::GCPtr<HTML::SharedResourceRequest> m_resource_request;
     Optional<DOM::DocumentLoadEventDelayer> m_load_event_delayer;
 };