HTMLLinkElement.cpp 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553
  1. /*
  2. * Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, the SerenityOS developers.
  4. * Copyright (c) 2021, Sam Atkins <atkinssj@serenityos.org>
  5. * Copyright (c) 2023, Srikavin Ramkumar <me@srikavin.me>
  6. *
  7. * SPDX-License-Identifier: BSD-2-Clause
  8. */
  9. #include <AK/ByteBuffer.h>
  10. #include <AK/Debug.h>
  11. #include <LibTextCodec/Decoder.h>
  12. #include <LibURL/URL.h>
  13. #include <LibWeb/CSS/Parser/Parser.h>
  14. #include <LibWeb/DOM/Document.h>
  15. #include <LibWeb/DOM/Event.h>
  16. #include <LibWeb/DOM/ShadowRoot.h>
  17. #include <LibWeb/Fetch/Fetching/Fetching.h>
  18. #include <LibWeb/Fetch/Infrastructure/FetchAlgorithms.h>
  19. #include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
  20. #include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
  21. #include <LibWeb/HTML/EventNames.h>
  22. #include <LibWeb/HTML/HTMLLinkElement.h>
  23. #include <LibWeb/HTML/PotentialCORSRequest.h>
  24. #include <LibWeb/HTML/TraversableNavigable.h>
  25. #include <LibWeb/Infra/CharacterTypes.h>
  26. #include <LibWeb/Infra/Strings.h>
  27. #include <LibWeb/Loader/ResourceLoader.h>
  28. #include <LibWeb/Page/Page.h>
  29. #include <LibWeb/Platform/ImageCodecPlugin.h>
  30. namespace Web::HTML {
  31. JS_DEFINE_ALLOCATOR(HTMLLinkElement);
  32. HTMLLinkElement::HTMLLinkElement(DOM::Document& document, DOM::QualifiedName qualified_name)
  33. : HTMLElement(document, move(qualified_name))
  34. {
  35. }
  36. HTMLLinkElement::~HTMLLinkElement() = default;
  37. void HTMLLinkElement::initialize(JS::Realm& realm)
  38. {
  39. Base::initialize(realm);
  40. WEB_SET_PROTOTYPE_FOR_INTERFACE(HTMLLinkElement);
  41. }
  42. void HTMLLinkElement::removed_from(Node* old_parent)
  43. {
  44. Base::removed_from(old_parent);
  45. if (m_loaded_style_sheet) {
  46. document_or_shadow_root_style_sheets().remove_a_css_style_sheet(*m_loaded_style_sheet);
  47. m_loaded_style_sheet = nullptr;
  48. }
  49. }
  50. void HTMLLinkElement::inserted()
  51. {
  52. HTMLElement::inserted();
  53. if (!document().browsing_context()) {
  54. return;
  55. }
  56. if (m_relationship & Relationship::Stylesheet) {
  57. // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet:fetch-and-process-the-linked-resource
  58. // The appropriate times to fetch and process this type of link are:
  59. // - When the external resource link is created on a link element that is already browsing-context connected.
  60. // - When the external resource link's link element becomes browsing-context connected.
  61. fetch_and_process_linked_resource();
  62. }
  63. // FIXME: Follow spec for fetching and processing these attributes as well
  64. if (m_relationship & Relationship::Preload) {
  65. // FIXME: Respect the "as" attribute.
  66. LoadRequest request;
  67. request.set_url(document().parse_url(get_attribute_value(HTML::AttributeNames::href)));
  68. set_resource(ResourceLoader::the().load_resource(Resource::Type::Generic, request));
  69. } else if (m_relationship & Relationship::DNSPrefetch) {
  70. ResourceLoader::the().prefetch_dns(document().parse_url(get_attribute_value(HTML::AttributeNames::href)));
  71. } else if (m_relationship & Relationship::Preconnect) {
  72. ResourceLoader::the().preconnect(document().parse_url(get_attribute_value(HTML::AttributeNames::href)));
  73. } else if (m_relationship & Relationship::Icon) {
  74. auto favicon_url = document().parse_url(href());
  75. auto favicon_request = LoadRequest::create_for_url_on_page(favicon_url, &document().page());
  76. set_resource(ResourceLoader::the().load_resource(Resource::Type::Generic, favicon_request));
  77. }
  78. }
  79. bool HTMLLinkElement::has_loaded_icon() const
  80. {
  81. return m_relationship & Relationship::Icon && resource() && resource()->is_loaded() && resource()->has_encoded_data();
  82. }
  83. void HTMLLinkElement::attribute_changed(FlyString const& name, Optional<String> const& value)
  84. {
  85. HTMLElement::attribute_changed(name, value);
  86. // 4.6.7 Link types - https://html.spec.whatwg.org/multipage/links.html#linkTypes
  87. if (name == HTML::AttributeNames::rel) {
  88. m_relationship = 0;
  89. // Keywords are always ASCII case-insensitive, and must be compared as such.
  90. auto lowercased_value = MUST(Infra::to_ascii_lowercase(value.value_or(String {})));
  91. // To determine which link types apply to a link, a, area, or form element,
  92. // the element's rel attribute must be split on ASCII whitespace.
  93. // The resulting tokens are the keywords for the link types that apply to that element.
  94. auto parts = lowercased_value.bytes_as_string_view().split_view_if(Infra::is_ascii_whitespace);
  95. for (auto& part : parts) {
  96. if (part == "stylesheet"sv)
  97. m_relationship |= Relationship::Stylesheet;
  98. else if (part == "alternate"sv)
  99. m_relationship |= Relationship::Alternate;
  100. else if (part == "preload"sv)
  101. m_relationship |= Relationship::Preload;
  102. else if (part == "dns-prefetch"sv)
  103. m_relationship |= Relationship::DNSPrefetch;
  104. else if (part == "preconnect"sv)
  105. m_relationship |= Relationship::Preconnect;
  106. else if (part == "icon"sv)
  107. m_relationship |= Relationship::Icon;
  108. }
  109. }
  110. // https://html.spec.whatwg.org/multipage/semantics.html#the-link-element:explicitly-enabled
  111. // Whenever the disabled attribute is removed, set the link element's explicitly enabled attribute to true.
  112. if (!value.has_value() && name == HTML::AttributeNames::disabled)
  113. m_explicitly_enabled = true;
  114. if (m_relationship & Relationship::Stylesheet) {
  115. if (name == HTML::AttributeNames::disabled && m_loaded_style_sheet)
  116. document_or_shadow_root_style_sheets().remove_a_css_style_sheet(*m_loaded_style_sheet);
  117. // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet:fetch-and-process-the-linked-resource
  118. // The appropriate times to fetch and process this type of link are:
  119. if (
  120. // AD-HOC: When the rel attribute changes
  121. name == AttributeNames::rel ||
  122. // - When the href attribute of the link element of an external resource link that is already browsing-context connected is changed.
  123. name == AttributeNames::href ||
  124. // - When the disabled attribute of the link element of an external resource link that is already browsing-context connected is set, changed, or removed.
  125. name == AttributeNames::disabled ||
  126. // - When the crossorigin attribute of the link element of an external resource link that is already browsing-context connected is set, changed, or removed.
  127. name == AttributeNames::crossorigin
  128. // FIXME: - When the type attribute of the link element of an external resource link that is already browsing-context connected is set or changed to a value that does not or no longer matches the Content-Type metadata of the previous obtained external resource, if any.
  129. // FIXME: - When the type attribute of the link element of an external resource link that is already browsing-context connected, but was previously not obtained due to the type attribute specifying an unsupported type, is removed or changed.
  130. ) {
  131. fetch_and_process_linked_resource();
  132. }
  133. }
  134. }
  135. void HTMLLinkElement::resource_did_fail()
  136. {
  137. dbgln_if(CSS_LOADER_DEBUG, "HTMLLinkElement: Resource did fail. URL: {}", resource()->url());
  138. if (m_relationship & Relationship::Preload) {
  139. dispatch_event(*DOM::Event::create(realm(), HTML::EventNames::error));
  140. }
  141. }
  142. void HTMLLinkElement::resource_did_load()
  143. {
  144. VERIFY(resource());
  145. if (m_relationship & Relationship::Icon) {
  146. resource_did_load_favicon();
  147. m_document_load_event_delayer.clear();
  148. }
  149. if (m_relationship & Relationship::Preload) {
  150. dispatch_event(*DOM::Event::create(realm(), HTML::EventNames::load));
  151. }
  152. }
  153. // https://html.spec.whatwg.org/multipage/semantics.html#create-link-options-from-element
  154. HTMLLinkElement::LinkProcessingOptions HTMLLinkElement::create_link_options()
  155. {
  156. // 1. Let document be el's node document.
  157. auto& document = this->document();
  158. // 2. Let options be a new link processing options with
  159. LinkProcessingOptions options;
  160. // FIXME: destination the result of translating the state of el's as attribute
  161. // crossorigin the state of el's crossorigin content attribute
  162. options.crossorigin = cors_setting_attribute_from_keyword(get_attribute(AttributeNames::crossorigin));
  163. // FIXME: referrer policy the state of el's referrerpolicy content attribute
  164. // FIXME: source set el's source set
  165. // base URL document's URL
  166. options.base_url = document.url();
  167. // origin document's origin
  168. options.origin = document.origin();
  169. // environment document's relevant settings object
  170. options.environment = &document.relevant_settings_object();
  171. // policy container document's policy container
  172. options.policy_container = document.policy_container();
  173. // document document
  174. options.document = &document;
  175. // FIXME: cryptographic nonce metadata The current value of el's [[CryptographicNonce]] internal slot
  176. // 3. If el has an href attribute, then set options's href to the value of el's href attribute.
  177. if (auto maybe_href = get_attribute(AttributeNames::href); maybe_href.has_value())
  178. options.href = maybe_href.value();
  179. // 4. If el has an integrity attribute, then set options's integrity to the value of el's integrity content attribute.
  180. if (auto maybe_integrity = get_attribute(AttributeNames::integrity); maybe_integrity.has_value())
  181. options.integrity = maybe_integrity.value();
  182. // 5. If el has a type attribute, then set options's type to the value of el's type attribute.
  183. if (auto maybe_type = get_attribute(AttributeNames::type); maybe_type.has_value())
  184. options.type = maybe_type.value();
  185. // FIXME: 6. Assert: options's href is not the empty string, or options's source set is not null.
  186. // A link element with neither an href or an imagesrcset does not represent a link.
  187. // 7. Return options.
  188. return options;
  189. }
  190. // https://html.spec.whatwg.org/multipage/semantics.html#create-a-link-request
  191. JS::GCPtr<Fetch::Infrastructure::Request> HTMLLinkElement::create_link_request(HTMLLinkElement::LinkProcessingOptions const& options)
  192. {
  193. // 1. Assert: options's href is not the empty string.
  194. // FIXME: 2. If options's destination is not a destination, then return null.
  195. // 3. Parse a URL given options's href, relative to options's base URL. If that fails, then return null. Otherwise, let url be the resulting URL record.
  196. auto url = options.base_url.complete_url(options.href);
  197. if (!url.is_valid())
  198. return nullptr;
  199. // 4. Let request be the result of creating a potential-CORS request given url, options's destination, and options's crossorigin.
  200. auto request = create_potential_CORS_request(vm(), url, options.destination, options.crossorigin);
  201. // 5. Set request's policy container to options's policy container.
  202. request->set_policy_container(options.policy_container);
  203. // 6. Set request's integrity metadata to options's integrity.
  204. request->set_integrity_metadata(options.integrity);
  205. // 7. Set request's cryptographic nonce metadata to options's cryptographic nonce metadata.
  206. request->set_cryptographic_nonce_metadata(options.cryptographic_nonce_metadata);
  207. // 8. Set request's referrer policy to options's referrer policy.
  208. request->set_referrer_policy(options.referrer_policy);
  209. // 9. Set request's client to options's environment.
  210. request->set_client(options.environment);
  211. // 10. Return request.
  212. return request;
  213. }
  214. // https://html.spec.whatwg.org/multipage/semantics.html#fetch-and-process-the-linked-resource
  215. void HTMLLinkElement::fetch_and_process_linked_resource()
  216. {
  217. default_fetch_and_process_linked_resource();
  218. }
  219. // https://html.spec.whatwg.org/multipage/semantics.html#default-fetch-and-process-the-linked-resource
  220. void HTMLLinkElement::default_fetch_and_process_linked_resource()
  221. {
  222. // https://html.spec.whatwg.org/multipage/semantics.html#the-link-element:attr-link-href-4
  223. // If both the href and imagesrcset attributes are absent, then the element does not define a link.
  224. // FIXME: Support imagesrcset attribute
  225. if (!has_attribute(AttributeNames::href) || href().is_empty())
  226. return;
  227. // 1. Let options be the result of creating link options from el.
  228. auto options = create_link_options();
  229. // 2. Let request be the result of creating a link request given options.
  230. auto request = create_link_request(options);
  231. // 3. If request is null, then return.
  232. if (request == nullptr) {
  233. return;
  234. }
  235. // FIXME: 4. Set request's synchronous flag.
  236. // 5. Run the linked resource fetch setup steps, given el and request. If the result is false, then return.
  237. if (!linked_resource_fetch_setup_steps(*request))
  238. return;
  239. // 6. Set request's initiator type to "css" if el's rel attribute contains the keyword stylesheet; "link" otherwise.
  240. if (m_relationship & Relationship::Stylesheet) {
  241. request->set_initiator_type(Fetch::Infrastructure::Request::InitiatorType::CSS);
  242. } else {
  243. request->set_initiator_type(Fetch::Infrastructure::Request::InitiatorType::Link);
  244. }
  245. // 7. Fetch request with processResponseConsumeBody set to the following steps given response response and null, failure, or a byte sequence bodyBytes:
  246. Fetch::Infrastructure::FetchAlgorithms::Input fetch_algorithms_input {};
  247. fetch_algorithms_input.process_response_consume_body = [this, hr = options](auto response, auto body_bytes) {
  248. // FIXME: If the response is CORS cross-origin, we must use its internal response to query any of its data. See:
  249. // https://github.com/whatwg/html/issues/9355
  250. response = response->unsafe_response();
  251. // 1. Let success be true.
  252. bool success = true;
  253. // 2. If either of the following conditions are met:
  254. // - bodyBytes is null or failure; or
  255. // - response's status is not an ok status,
  256. if (body_bytes.template has<Empty>() || body_bytes.template has<Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag>() || !Fetch::Infrastructure::is_ok_status(response->status())) {
  257. // then set success to false.
  258. success = false;
  259. }
  260. // FIXME: 3. Otherwise, wait for the link resource's critical subresources to finish loading.
  261. // 4. Process the linked resource given el, success, response, and bodyBytes.
  262. process_linked_resource(success, response, body_bytes);
  263. };
  264. Fetch::Fetching::fetch(realm(), *request, Fetch::Infrastructure::FetchAlgorithms::create(vm(), move(fetch_algorithms_input))).release_value_but_fixme_should_propagate_errors();
  265. }
  266. // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet:process-the-linked-resource
  267. void HTMLLinkElement::process_stylesheet_resource(bool success, Fetch::Infrastructure::Response const& response, Variant<Empty, Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag, ByteBuffer> body_bytes)
  268. {
  269. // 1. If the resource's Content-Type metadata is not text/css, then set success to false.
  270. auto extracted_mime_type = response.header_list()->extract_mime_type().release_value_but_fixme_should_propagate_errors();
  271. if (!extracted_mime_type.has_value() || extracted_mime_type->essence() != "text/css") {
  272. success = false;
  273. }
  274. // FIXME: 2. If el no longer creates an external resource link that contributes to the styling processing model,
  275. // or if, since the resource in question was fetched, it has become appropriate to fetch it again, then return.
  276. // 3. If el has an associated CSS style sheet, remove the CSS style sheet.
  277. if (m_loaded_style_sheet) {
  278. document_or_shadow_root_style_sheets().remove_a_css_style_sheet(*m_loaded_style_sheet);
  279. m_loaded_style_sheet = nullptr;
  280. }
  281. // 4. If success is true, then:
  282. if (success) {
  283. // 1. Create a CSS style sheet with the following properties:
  284. // type
  285. // text/css
  286. // location
  287. // The resulting URL string determined during the fetch and process the linked resource algorithm.
  288. // owner node
  289. // element
  290. // media
  291. // The media attribute of element.
  292. // title
  293. // The title attribute of element, if element is in a document tree, or the empty string otherwise.
  294. // alternate flag
  295. // Set if the link is an alternative style sheet and element's explicitly enabled is false; unset otherwise.
  296. // origin-clean flag
  297. // Set if the resource is CORS-same-origin; unset otherwise.
  298. // parent CSS style sheet
  299. // owner CSS rule
  300. // null
  301. // disabled flag
  302. // Left at its default value.
  303. // CSS rules
  304. // Left uninitialized.
  305. //
  306. // The CSS environment encoding is the result of running the following steps: [CSSSYNTAX]
  307. // 1. If the element has a charset attribute, get an encoding from that attribute's value. If that succeeds, return the resulting encoding. [ENCODING]
  308. // 2. Otherwise, return the document's character encoding. [DOM]
  309. Optional<String> encoding;
  310. if (auto charset = attribute(HTML::AttributeNames::charset); charset.has_value())
  311. encoding = charset.release_value();
  312. if (!encoding.has_value())
  313. encoding = document().encoding_or_default();
  314. auto decoder = TextCodec::decoder_for(*encoding);
  315. if (!decoder.has_value()) {
  316. // If we don't support the encoding yet, let's error out instead of trying to decode it as something it's most likely not.
  317. dbgln("FIXME: Style sheet encoding '{}' is not supported yet", encoding);
  318. dispatch_event(*DOM::Event::create(realm(), HTML::EventNames::error));
  319. } else {
  320. auto const& encoded_string = body_bytes.get<ByteBuffer>();
  321. auto maybe_decoded_string = TextCodec::convert_input_to_utf8_using_given_decoder_unless_there_is_a_byte_order_mark(*decoder, encoded_string);
  322. if (maybe_decoded_string.is_error()) {
  323. dbgln("Style sheet {} claimed to be '{}' but decoding failed", response.url().value_or(URL::URL()), encoding);
  324. dispatch_event(*DOM::Event::create(realm(), HTML::EventNames::error));
  325. } else {
  326. auto const decoded_string = maybe_decoded_string.release_value();
  327. m_loaded_style_sheet = parse_css_stylesheet(CSS::Parser::ParsingContext(document(), *response.url()), decoded_string);
  328. if (m_loaded_style_sheet) {
  329. document().style_sheets().create_a_css_style_sheet(
  330. "text/css"_string,
  331. this,
  332. attribute(HTML::AttributeNames::media).value_or({}),
  333. in_a_document_tree() ? attribute(HTML::AttributeNames::title).value_or({}) : String {},
  334. m_relationship & Relationship::Alternate && !m_explicitly_enabled,
  335. true,
  336. {},
  337. nullptr,
  338. nullptr,
  339. *m_loaded_style_sheet);
  340. } else {
  341. dbgln_if(CSS_LOADER_DEBUG, "HTMLLinkElement: Failed to parse stylesheet: {}", resource()->url());
  342. }
  343. // 2. Fire an event named load at el.
  344. dispatch_event(*DOM::Event::create(realm(), HTML::EventNames::load));
  345. }
  346. }
  347. }
  348. // 5. Otherwise, fire an event named error at el.
  349. else {
  350. dispatch_event(*DOM::Event::create(realm(), HTML::EventNames::error));
  351. }
  352. // FIXME: 6. If el contributes a script-blocking style sheet, then:
  353. // FIXME: 1. Assert: el's node document's script-blocking style sheet counter is greater than 0.
  354. // FIXME: 2. Decrement el's node document's script-blocking style sheet counter by 1.
  355. // 7. Unblock rendering on el.
  356. m_document_load_event_delayer.clear();
  357. }
  358. // https://html.spec.whatwg.org/multipage/semantics.html#process-the-linked-resource
  359. void HTMLLinkElement::process_linked_resource(bool success, Fetch::Infrastructure::Response const& response, Variant<Empty, Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag, ByteBuffer> body_bytes)
  360. {
  361. if (m_relationship & Relationship::Stylesheet)
  362. process_stylesheet_resource(success, response, body_bytes);
  363. }
  364. // https://html.spec.whatwg.org/multipage/semantics.html#linked-resource-fetch-setup-steps
  365. bool HTMLLinkElement::linked_resource_fetch_setup_steps(Fetch::Infrastructure::Request& request)
  366. {
  367. if (m_relationship & Relationship::Stylesheet)
  368. return stylesheet_linked_resource_fetch_setup_steps(request);
  369. return true;
  370. }
  371. // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet:linked-resource-fetch-setup-steps
  372. bool HTMLLinkElement::stylesheet_linked_resource_fetch_setup_steps(Fetch::Infrastructure::Request& request)
  373. {
  374. // 1. If el's disabled attribute is set, then return false.
  375. if (has_attribute(AttributeNames::disabled))
  376. return false;
  377. // FIXME: 2. If el contributes a script-blocking style sheet, increment el's node document's script-blocking style sheet counter by 1.
  378. // 3. If el's media attribute's value matches the environment and el is potentially render-blocking, then block rendering on el.
  379. // FIXME: Check media attribute value.
  380. m_document_load_event_delayer.emplace(document());
  381. // 4. If el is currently render-blocking, then set request's render-blocking to true.
  382. // FIXME: Check if el is currently render-blocking.
  383. request.set_render_blocking(true);
  384. // 5. Return true.
  385. return true;
  386. }
  387. void HTMLLinkElement::resource_did_load_favicon()
  388. {
  389. VERIFY(m_relationship & (Relationship::Icon));
  390. if (!resource()->has_encoded_data()) {
  391. dbgln_if(SPAM_DEBUG, "Favicon downloaded, no encoded data");
  392. return;
  393. }
  394. dbgln_if(SPAM_DEBUG, "Favicon downloaded, {} bytes from {}", resource()->encoded_data().size(), resource()->url());
  395. document().check_favicon_after_loading_link_resource();
  396. }
  397. static NonnullRefPtr<Core::Promise<Web::Platform::DecodedImage>> decode_favicon(ReadonlyBytes favicon_data, URL::URL const& favicon_url, JS::GCPtr<Navigable> navigable)
  398. {
  399. auto on_failed_decode = [favicon_url]([[maybe_unused]] Error& error) {
  400. dbgln_if(IMAGE_DECODER_DEBUG, "Failed to decode favicon {}: {}", favicon_url, error);
  401. };
  402. auto on_successful_decode = [navigable = JS::Handle(*navigable)](Web::Platform::DecodedImage& decoded_image) -> ErrorOr<void> {
  403. auto favicon_bitmap = decoded_image.frames[0].bitmap;
  404. dbgln_if(IMAGE_DECODER_DEBUG, "Decoded favicon, {}", favicon_bitmap->size());
  405. if (navigable && navigable->is_traversable())
  406. navigable->traversable_navigable()->page().client().page_did_change_favicon(*favicon_bitmap);
  407. return {};
  408. };
  409. auto promise = Platform::ImageCodecPlugin::the().decode_image(favicon_data, move(on_successful_decode), move(on_failed_decode));
  410. return promise;
  411. }
  412. bool HTMLLinkElement::load_favicon_and_use_if_window_is_active()
  413. {
  414. if (!has_loaded_icon())
  415. return false;
  416. // FIXME: Refactor the caller(s) to handle the async nature of image loading
  417. auto promise = decode_favicon(resource()->encoded_data(), resource()->url(), navigable());
  418. auto result = promise->await();
  419. return !result.is_error();
  420. }
  421. // https://html.spec.whatwg.org/multipage/links.html#rel-icon:the-link-element-3
  422. WebIDL::ExceptionOr<void> HTMLLinkElement::load_fallback_favicon_if_needed(JS::NonnullGCPtr<DOM::Document> document)
  423. {
  424. auto& realm = document->realm();
  425. auto& vm = realm.vm();
  426. // In the absence of a link with the icon keyword, for Document objects whose URL's scheme is an HTTP(S) scheme,
  427. // user agents may instead run these steps in parallel:
  428. if (document->has_active_favicon())
  429. return {};
  430. if (!document->url().scheme().is_one_of("http"sv, "https"sv))
  431. return {};
  432. // 1. Let request be a new request whose URL is the URL record obtained by resolving the URL "/favicon.ico" against
  433. // the Document object's URL, client is the Document object's relevant settings object, destination is "image",
  434. // synchronous flag is set, credentials mode is "include", and whose use-URL-credentials flag is set.
  435. // NOTE: Fetch requests no longer have a synchronous flag, see https://github.com/whatwg/fetch/pull/1165
  436. auto request = Fetch::Infrastructure::Request::create(vm);
  437. request->set_url(document->parse_url("/favicon.ico"sv));
  438. request->set_client(&document->relevant_settings_object());
  439. request->set_destination(Fetch::Infrastructure::Request::Destination::Image);
  440. request->set_credentials_mode(Fetch::Infrastructure::Request::CredentialsMode::Include);
  441. request->set_use_url_credentials(true);
  442. // 2. Let response be the result of fetching request.
  443. Fetch::Infrastructure::FetchAlgorithms::Input fetch_algorithms_input {};
  444. fetch_algorithms_input.process_response = [document, request](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) {
  445. auto& realm = document->realm();
  446. auto global = JS::NonnullGCPtr { realm.global_object() };
  447. auto process_body = JS::create_heap_function(realm.heap(), [document, request](ByteBuffer body) {
  448. (void)decode_favicon(body, request->url(), document->navigable());
  449. });
  450. auto process_body_error = JS::create_heap_function(realm.heap(), [](JS::GCPtr<WebIDL::DOMException>) {
  451. });
  452. // 3. Use response's unsafe response as an icon as if it had been declared using the icon keyword.
  453. if (auto body = response->unsafe_response()->body())
  454. body->fully_read(realm, process_body, process_body_error, global).release_value_but_fixme_should_propagate_errors();
  455. };
  456. TRY(Fetch::Fetching::fetch(realm, request, Fetch::Infrastructure::FetchAlgorithms::create(vm, move(fetch_algorithms_input))));
  457. return {};
  458. }
  459. void HTMLLinkElement::visit_edges(Cell::Visitor& visitor)
  460. {
  461. Base::visit_edges(visitor);
  462. visitor.visit(m_loaded_style_sheet);
  463. }
  464. }