SVGDecodedImageData.cpp 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205
  1. /*
  2. * Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <LibGfx/Bitmap.h>
  7. #include <LibWeb/Bindings/MainThreadVM.h>
  8. #include <LibWeb/DOM/Document.h>
  9. #include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
  10. #include <LibWeb/HTML/BrowsingContext.h>
  11. #include <LibWeb/HTML/DocumentState.h>
  12. #include <LibWeb/HTML/NavigationParams.h>
  13. #include <LibWeb/HTML/Parser/HTMLParser.h>
  14. #include <LibWeb/HTML/TraversableNavigable.h>
  15. #include <LibWeb/Layout/Viewport.h>
  16. #include <LibWeb/Page/Page.h>
  17. #include <LibWeb/Painting/CommandExecutorCPU.h>
  18. #include <LibWeb/Painting/PaintContext.h>
  19. #include <LibWeb/Painting/ViewportPaintable.h>
  20. #include <LibWeb/SVG/SVGDecodedImageData.h>
  21. #include <LibWeb/SVG/SVGSVGElement.h>
  22. namespace Web::SVG {
  23. JS_DEFINE_ALLOCATOR(SVGDecodedImageData);
  24. class SVGDecodedImageData::SVGPageClient final : public PageClient {
  25. JS_CELL(SVGDecodedImageData::SVGPageClient, PageClient);
  26. public:
  27. static JS::NonnullGCPtr<SVGPageClient> create(JS::VM& vm, Page& page)
  28. {
  29. return vm.heap().allocate_without_realm<SVGPageClient>(page);
  30. }
  31. virtual ~SVGPageClient() override = default;
  32. Page& m_host_page;
  33. Page* m_svg_page { nullptr };
  34. virtual Page& page() override { return *m_svg_page; }
  35. virtual Page const& page() const override { return *m_svg_page; }
  36. virtual bool is_connection_open() const override { return false; }
  37. virtual Gfx::Palette palette() const override { return m_host_page.client().palette(); }
  38. virtual DevicePixelRect screen_rect() const override { return {}; }
  39. virtual double device_pixels_per_css_pixel() const override { return 1.0; }
  40. virtual CSS::PreferredColorScheme preferred_color_scheme() const override { return m_host_page.client().preferred_color_scheme(); }
  41. virtual void request_file(FileRequest) override { }
  42. virtual void paint(DevicePixelRect const&, Gfx::Bitmap&, Web::PaintOptions = {}) override { }
  43. virtual void schedule_repaint() override { }
  44. virtual bool is_ready_to_paint() const override { return true; }
  45. private:
  46. explicit SVGPageClient(Page& host_page)
  47. : m_host_page(host_page)
  48. {
  49. }
  50. };
  51. ErrorOr<JS::NonnullGCPtr<SVGDecodedImageData>> SVGDecodedImageData::create(JS::Realm& realm, JS::NonnullGCPtr<Page> host_page, URL::URL const& url, ByteBuffer data)
  52. {
  53. auto page_client = SVGPageClient::create(Bindings::main_thread_vm(), host_page);
  54. auto page = Page::create(Bindings::main_thread_vm(), *page_client);
  55. page_client->m_svg_page = page.ptr();
  56. page->set_top_level_traversable(MUST(Web::HTML::TraversableNavigable::create_a_new_top_level_traversable(*page, nullptr, {})));
  57. JS::NonnullGCPtr<HTML::Navigable> navigable = page->top_level_traversable();
  58. auto response = Fetch::Infrastructure::Response::create(navigable->vm());
  59. response->url_list().append(url);
  60. HTML::NavigationParams navigation_params {
  61. .id = {},
  62. .navigable = navigable,
  63. .request = nullptr,
  64. .response = response,
  65. .fetch_controller = nullptr,
  66. .commit_early_hints = nullptr,
  67. .coop_enforcement_result = HTML::CrossOriginOpenerPolicyEnforcementResult {},
  68. .reserved_environment = {},
  69. .origin = HTML::Origin {},
  70. .policy_container = HTML::PolicyContainer {},
  71. .final_sandboxing_flag_set = HTML::SandboxingFlagSet {},
  72. .cross_origin_opener_policy = HTML::CrossOriginOpenerPolicy {},
  73. .about_base_url = {},
  74. };
  75. // FIXME: Use Navigable::navigate() instead of manually replacing the navigable's document.
  76. auto document = DOM::Document::create_and_initialize(DOM::Document::Type::HTML, "text/html"_string, navigation_params).release_value_but_fixme_should_propagate_errors();
  77. navigable->set_ongoing_navigation({});
  78. navigable->active_document()->destroy();
  79. navigable->active_session_history_entry()->document_state->set_document(document);
  80. auto parser = HTML::HTMLParser::create_with_uncertain_encoding(document, data);
  81. parser->run(document->url());
  82. // Perform some DOM surgery to make the SVG root element be the first child of the Document.
  83. // FIXME: This is a huge hack until we figure out how to actually parse separate SVG files.
  84. auto* svg_root = document->body()->first_child_of_type<SVG::SVGSVGElement>();
  85. if (!svg_root)
  86. return Error::from_string_literal("SVGDecodedImageData: Invalid SVG input");
  87. svg_root->remove();
  88. document->remove_all_children();
  89. MUST(document->append_child(*svg_root));
  90. return realm.heap().allocate<SVGDecodedImageData>(realm, page, page_client, document, *svg_root);
  91. }
  92. SVGDecodedImageData::SVGDecodedImageData(JS::NonnullGCPtr<Page> page, JS::NonnullGCPtr<SVGPageClient> page_client, JS::NonnullGCPtr<DOM::Document> document, JS::NonnullGCPtr<SVG::SVGSVGElement> root_element)
  93. : m_page(page)
  94. , m_page_client(page_client)
  95. , m_document(document)
  96. , m_root_element(root_element)
  97. {
  98. }
  99. SVGDecodedImageData::~SVGDecodedImageData() = default;
  100. void SVGDecodedImageData::visit_edges(Cell::Visitor& visitor)
  101. {
  102. Base::visit_edges(visitor);
  103. visitor.visit(m_page);
  104. visitor.visit(m_document);
  105. visitor.visit(m_page_client);
  106. visitor.visit(m_root_element);
  107. }
  108. RefPtr<Gfx::Bitmap> SVGDecodedImageData::render(Gfx::IntSize size) const
  109. {
  110. auto bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::BGRA8888, size).release_value_but_fixme_should_propagate_errors();
  111. VERIFY(m_document->navigable());
  112. m_document->navigable()->set_viewport_rect({ 0, 0, size.width(), size.height() });
  113. m_document->update_layout();
  114. Painting::CommandList painting_commands;
  115. Painting::RecordingPainter recording_painter(painting_commands);
  116. PaintContext context(recording_painter, m_page_client->palette(), m_page_client->device_pixels_per_css_pixel());
  117. m_document->paintable()->paint_all_phases(context);
  118. Painting::CommandExecutorCPU executor { *bitmap };
  119. painting_commands.execute(executor);
  120. return bitmap;
  121. }
  122. RefPtr<Gfx::ImmutableBitmap> SVGDecodedImageData::bitmap(size_t, Gfx::IntSize size) const
  123. {
  124. if (size.is_empty())
  125. return nullptr;
  126. if (auto it = m_cached_rendered_bitmaps.find(size); it != m_cached_rendered_bitmaps.end())
  127. return it->value;
  128. // Prevent the cache from growing too big.
  129. // FIXME: Evict least used entries.
  130. if (m_cached_rendered_bitmaps.size() > 10)
  131. m_cached_rendered_bitmaps.remove(m_cached_rendered_bitmaps.begin());
  132. auto immutable_bitmap = Gfx::ImmutableBitmap::create(*render(size));
  133. m_cached_rendered_bitmaps.set(size, immutable_bitmap);
  134. return immutable_bitmap;
  135. }
  136. Optional<CSSPixels> SVGDecodedImageData::intrinsic_width() const
  137. {
  138. // https://www.w3.org/TR/SVG2/coords.html#SizingSVGInCSS
  139. m_document->update_style();
  140. auto const* root_element_style = m_root_element->computed_css_values();
  141. VERIFY(root_element_style);
  142. auto const& width_value = root_element_style->size_value(CSS::PropertyID::Width);
  143. if (width_value.is_length() && width_value.length().is_absolute())
  144. return width_value.length().absolute_length_to_px();
  145. return {};
  146. }
  147. Optional<CSSPixels> SVGDecodedImageData::intrinsic_height() const
  148. {
  149. // https://www.w3.org/TR/SVG2/coords.html#SizingSVGInCSS
  150. m_document->update_style();
  151. auto const* root_element_style = m_root_element->computed_css_values();
  152. VERIFY(root_element_style);
  153. auto const& height_value = root_element_style->size_value(CSS::PropertyID::Height);
  154. if (height_value.is_length() && height_value.length().is_absolute())
  155. return height_value.length().absolute_length_to_px();
  156. return {};
  157. }
  158. Optional<CSSPixelFraction> SVGDecodedImageData::intrinsic_aspect_ratio() const
  159. {
  160. // https://www.w3.org/TR/SVG2/coords.html#SizingSVGInCSS
  161. auto width = intrinsic_width();
  162. auto height = intrinsic_height();
  163. if (height.has_value() && *height == 0)
  164. return {};
  165. if (width.has_value() && height.has_value())
  166. return *width / *height;
  167. if (auto const& viewbox = m_root_element->view_box(); viewbox.has_value())
  168. return CSSPixels::nearest_value_for(viewbox->width) / CSSPixels::nearest_value_for(viewbox->height);
  169. return {};
  170. }
  171. }