LibWeb: Make DecodedImageData an abstract class

The existing implementation moves down into a new subclass called
AnimatedBitmapDecodedImageData.

The purpose of this change is to create an extension point where we can
plug in an SVG renderer. :^)

Userland/Libraries/LibWeb/CMakeLists.txt

@@ -206,6 +206,7 @@ set(SOURCES
     Geometry/DOMRect.cpp
     Geometry/DOMRectList.cpp
     Geometry/DOMRectReadOnly.cpp
+    HTML/AnimatedBitmapDecodedImageData.cpp
     HTML/AttributeNames.cpp
     HTML/BrowsingContext.cpp
     HTML/BrowsingContextGroup.cpp

Userland/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibGfx/Bitmap.h>
+#include <LibWeb/HTML/AnimatedBitmapDecodedImageData.h>
+
+namespace Web::HTML {
+
+ErrorOr<NonnullRefPtr<AnimatedBitmapDecodedImageData>> AnimatedBitmapDecodedImageData::create(Vector<Frame>&& frames, size_t loop_count, bool animated)
+{
+    return adopt_nonnull_ref_or_enomem(new (nothrow) AnimatedBitmapDecodedImageData(move(frames), loop_count, animated));
+}
+
+AnimatedBitmapDecodedImageData::AnimatedBitmapDecodedImageData(Vector<Frame>&& frames, size_t loop_count, bool animated)
+    : m_frames(move(frames))
+    , m_loop_count(loop_count)
+    , m_animated(animated)
+{
+}
+
+AnimatedBitmapDecodedImageData::~AnimatedBitmapDecodedImageData() = default;
+
+RefPtr<Gfx::Bitmap const> AnimatedBitmapDecodedImageData::bitmap(size_t frame_index) const
+{
+    if (frame_index >= m_frames.size())
+        return nullptr;
+    return m_frames[frame_index].bitmap;
+}
+
+int AnimatedBitmapDecodedImageData::frame_duration(size_t frame_index) const
+{
+    if (frame_index >= m_frames.size())
+        return 0;
+    return m_frames[frame_index].duration;
+}
+
+Optional<int> AnimatedBitmapDecodedImageData::natural_width() const
+{
+    return m_frames.first().bitmap->width();
+}
+
+Optional<int> AnimatedBitmapDecodedImageData::natural_height() const
+{
+    return m_frames.first().bitmap->height();
+}
+
+}

Userland/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <LibWeb/HTML/DecodedImageData.h>
+
+namespace Web::HTML {
+
+class AnimatedBitmapDecodedImageData final : public DecodedImageData {
+public:
+    struct Frame {
+        RefPtr<Gfx::Bitmap const> bitmap;
+        int duration { 0 };
+    };
+
+    static ErrorOr<NonnullRefPtr<AnimatedBitmapDecodedImageData>> create(Vector<Frame>&&, size_t loop_count, bool animated);
+    virtual ~AnimatedBitmapDecodedImageData() override;
+
+    virtual RefPtr<Gfx::Bitmap const> bitmap(size_t frame_index) const override;
+    virtual int frame_duration(size_t frame_index) const override;
+
+    virtual size_t frame_count() const override { return m_frames.size(); }
+    virtual size_t loop_count() const override { return m_loop_count; }
+    virtual bool is_animated() const override { return m_animated; }
+
+    virtual Optional<int> natural_width() const override;
+    virtual Optional<int> natural_height() const override;
+
+private:
+    AnimatedBitmapDecodedImageData(Vector<Frame>&&, size_t loop_count, bool animated);
+
+    Vector<Frame> m_frames;
+    size_t m_loop_count { 0 };
+    bool m_animated { false };
+};
+
+}

Userland/Libraries/LibWeb/HTML/DecodedImageData.cpp

@@ -4,47 +4,12 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibGfx/Bitmap.h>
 #include <LibWeb/HTML/DecodedImageData.h>
 
 namespace Web::HTML {
 
-ErrorOr<NonnullRefPtr<DecodedImageData>> DecodedImageData::create(Vector<Frame>&& frames, size_t loop_count, bool animated)
+DecodedImageData::DecodedImageData() = default;
-{
-    return adopt_nonnull_ref_or_enomem(new (nothrow) DecodedImageData(move(frames), loop_count, animated));
-}
-
-DecodedImageData::DecodedImageData(Vector<Frame>&& frames, size_t loop_count, bool animated)
-    : m_frames(move(frames))
-    , m_loop_count(loop_count)
-    , m_animated(animated)
-{
-}
 
 DecodedImageData::~DecodedImageData() = default;
 
-RefPtr<Gfx::Bitmap const> DecodedImageData::bitmap(size_t frame_index) const
-{
-    if (frame_index >= m_frames.size())
-        return nullptr;
-    return m_frames[frame_index].bitmap;
-}
-
-int DecodedImageData::frame_duration(size_t frame_index) const
-{
-    if (frame_index >= m_frames.size())
-        return 0;
-    return m_frames[frame_index].duration;
-}
-
-Optional<int> DecodedImageData::natural_width() const
-{
-    return m_frames.first().bitmap->width();
-}
-
-Optional<int> DecodedImageData::natural_height() const
-{
-    return m_frames.first().bitmap->height();
-}
-
 }

Userland/Libraries/LibWeb/HTML/DecodedImageData.h

@@ -13,32 +13,22 @@
 namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/images.html#img-req-data
-class DecodedImageData final : public RefCounted<DecodedImageData> {
+class DecodedImageData : public RefCounted<DecodedImageData> {
 public:
-    struct Frame {
+    virtual ~DecodedImageData();
-        RefPtr<Gfx::Bitmap const> bitmap;
-        int duration { 0 };
-    };
 
-    static ErrorOr<NonnullRefPtr<DecodedImageData>> create(Vector<Frame>&&, size_t loop_count, bool animated);
+    virtual RefPtr<Gfx::Bitmap const> bitmap(size_t frame_index) const = 0;
-    ~DecodedImageData();
+    virtual int frame_duration(size_t frame_index) const = 0;
 
-    RefPtr<Gfx::Bitmap const> bitmap(size_t frame_index) const;
+    virtual size_t frame_count() const = 0;
-    int frame_duration(size_t frame_index) const;
+    virtual size_t loop_count() const = 0;
+    virtual bool is_animated() const = 0;
 
-    size_t frame_count() const { return m_frames.size(); }
+    virtual Optional<int> natural_width() const = 0;
-    size_t loop_count() const { return m_loop_count; }
+    virtual Optional<int> natural_height() const = 0;
-    bool is_animated() const { return m_animated; }
 
-    Optional<int> natural_width() const;
+protected:
-    Optional<int> natural_height() const;
+    DecodedImageData();
-
-private:
-    DecodedImageData(Vector<Frame>&&, size_t loop_count, bool animated);
-
-    Vector<Frame> m_frames;
-    size_t m_loop_count { 0 };
-    bool m_animated { false };
 };
 
 }

Userland/Libraries/LibWeb/HTML/HTMLImageElement.cpp

@@ -14,8 +14,8 @@
 #include <LibWeb/Fetch/Fetching/Fetching.h>
 #include <LibWeb/Fetch/Infrastructure/FetchController.h>
 #include <LibWeb/Fetch/Response.h>
+#include <LibWeb/HTML/AnimatedBitmapDecodedImageData.h>
 #include <LibWeb/HTML/CORSSettingAttribute.h>
-#include <LibWeb/HTML/DecodedImageData.h>
 #include <LibWeb/HTML/EventNames.h>
 #include <LibWeb/HTML/HTMLImageElement.h>
 #include <LibWeb/HTML/HTMLLinkElement.h>
@@ -530,15 +530,15 @@ void HTMLImageElement::handle_successful_fetch(AK::URL const& url_string, ImageR
         return;
     }
 
-    Vector<DecodedImageData::Frame> frames;
+    Vector<AnimatedBitmapDecodedImageData::Frame> frames;
     for (auto& frame : result.value().frames) {
-        frames.append(DecodedImageData::Frame {
+        frames.append(AnimatedBitmapDecodedImageData::Frame {
             .bitmap = frame.bitmap,
             .duration = static_cast<int>(frame.duration),
         });
     }
 
-    auto image_data = DecodedImageData::create(move(frames), result.value().loop_count, result.value().is_animated).release_value_but_fixme_should_propagate_errors();
+    auto image_data = AnimatedBitmapDecodedImageData::create(move(frames), result.value().loop_count, result.value().is_animated).release_value_but_fixme_should_propagate_errors();
     image_request.set_image_data(image_data);
 
     ListOfAvailableImages::Key key;