BrowsingContext.cpp 61 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403
  1. /*
  2. * Copyright (c) 2018-2022, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <LibWeb/Bindings/MainThreadVM.h>
  7. #include <LibWeb/DOM/Document.h>
  8. #include <LibWeb/DOM/Event.h>
  9. #include <LibWeb/DOM/HTMLCollection.h>
  10. #include <LibWeb/DOM/Range.h>
  11. #include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
  12. #include <LibWeb/HTML/BrowsingContext.h>
  13. #include <LibWeb/HTML/BrowsingContextContainer.h>
  14. #include <LibWeb/HTML/BrowsingContextGroup.h>
  15. #include <LibWeb/HTML/CrossOrigin/CrossOriginOpenerPolicy.h>
  16. #include <LibWeb/HTML/EventLoop/EventLoop.h>
  17. #include <LibWeb/HTML/HTMLAnchorElement.h>
  18. #include <LibWeb/HTML/HTMLInputElement.h>
  19. #include <LibWeb/HTML/SandboxingFlagSet.h>
  20. #include <LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.h>
  21. #include <LibWeb/HTML/Window.h>
  22. #include <LibWeb/HTML/WindowProxy.h>
  23. #include <LibWeb/HighResolutionTime/TimeOrigin.h>
  24. #include <LibWeb/Infra/Strings.h>
  25. #include <LibWeb/Layout/BreakNode.h>
  26. #include <LibWeb/Layout/TextNode.h>
  27. #include <LibWeb/Layout/Viewport.h>
  28. #include <LibWeb/Page/Page.h>
  29. #include <LibWeb/URL/URL.h>
  30. namespace Web::HTML {
  31. // https://html.spec.whatwg.org/multipage/urls-and-fetching.html#matches-about:blank
  32. static bool url_matches_about_blank(AK::URL const& url)
  33. {
  34. // A URL matches about:blank if its scheme is "about", its path contains a single string "blank", its username and password are the empty string, and its host is null.
  35. return url.scheme() == "about"sv
  36. && url.path() == "blank"sv
  37. && url.username().is_empty()
  38. && url.password().is_empty()
  39. && url.host().is_null();
  40. }
  41. // https://html.spec.whatwg.org/multipage/browsers.html#determining-the-origin
  42. HTML::Origin determine_the_origin(BrowsingContext const& browsing_context, Optional<AK::URL> url, SandboxingFlagSet sandbox_flags, Optional<HTML::Origin> invocation_origin)
  43. {
  44. // 1. If sandboxFlags has its sandboxed origin browsing context flag set, then return a new opaque origin.
  45. if (sandbox_flags.flags & SandboxingFlagSet::SandboxedOrigin) {
  46. return HTML::Origin {};
  47. }
  48. // 2. If url is null, then return a new opaque origin.
  49. if (!url.has_value()) {
  50. return HTML::Origin {};
  51. }
  52. // 3. If invocationOrigin is non-null and url matches about:blank, then return invocationOrigin.
  53. if (invocation_origin.has_value() && url_matches_about_blank(*url)) {
  54. return invocation_origin.value();
  55. }
  56. // 4. If url is about:srcdoc, then return the origin of browsingContext's container document.
  57. if (url == AK::URL("about:srcdoc")) {
  58. VERIFY(browsing_context.container_document());
  59. return browsing_context.container_document()->origin();
  60. }
  61. // 5. Return url's origin.
  62. return URL::url_origin(*url);
  63. }
  64. // https://html.spec.whatwg.org/multipage/browsers.html#creating-a-new-top-level-browsing-context
  65. JS::NonnullGCPtr<BrowsingContext> BrowsingContext::create_a_new_top_level_browsing_context(Web::Page& page)
  66. {
  67. // 1. Let group be the result of creating a new browsing context group.
  68. auto group = BrowsingContextGroup::create_a_new_browsing_context_group(page);
  69. // 2. Return group's browsing context set[0].
  70. return *(*group->browsing_context_set().begin());
  71. }
  72. // https://html.spec.whatwg.org/multipage/browsers.html#creating-a-new-browsing-context
  73. JS::NonnullGCPtr<BrowsingContext> BrowsingContext::create_a_new_browsing_context(Page& page, JS::GCPtr<DOM::Document> creator, JS::GCPtr<DOM::Element> embedder, BrowsingContextGroup&)
  74. {
  75. // 1. Let browsingContext be a new browsing context.
  76. BrowsingContextContainer* container = (embedder && is<BrowsingContextContainer>(*embedder)) ? static_cast<BrowsingContextContainer*>(embedder.ptr()) : nullptr;
  77. auto browsing_context = Bindings::main_thread_vm().heap().allocate_without_realm<BrowsingContext>(page, container);
  78. // 2. Let unsafeContextCreationTime be the unsafe shared current time.
  79. [[maybe_unused]] auto unsafe_context_creation_time = HighResolutionTime::unsafe_shared_current_time();
  80. // 3. If creator is non-null, then set browsingContext's creator origin to return creator's origin,
  81. // browsingContext's creator URL to return creator's URL,
  82. // browsingContext's creator base URL to return creator's base URL,
  83. // FIXME: and browsingContext's virtual browsing context group ID to creator's top-level browsing context's virtual browsing context group ID.
  84. if (creator) {
  85. browsing_context->m_creator_origin = creator->origin();
  86. browsing_context->m_creator_url = creator->url();
  87. browsing_context->m_creator_base_url = creator->base_url();
  88. }
  89. // FIXME: 4. Let sandboxFlags be the result of determining the creation sandboxing flags given browsingContext and embedded.
  90. SandboxingFlagSet sandbox_flags;
  91. // 5. Let origin be the result of determining the origin given browsingContext, about:blank, sandboxFlags, and browsingContext's creator origin.
  92. auto origin = determine_the_origin(*browsing_context, AK::URL("about:blank"), sandbox_flags, browsing_context->m_creator_origin);
  93. // FIXME: 6. Let permissionsPolicy be the result of creating a permissions policy given browsingContext and origin. [PERMISSIONSPOLICY]
  94. // FIXME: 7. Let agent be the result of obtaining a similar-origin window agent given origin, group, and false.
  95. JS::GCPtr<Window> window;
  96. // 8. Let realm execution context be the result of creating a new JavaScript realm given agent and the following customizations:
  97. auto realm_execution_context = Bindings::create_a_new_javascript_realm(
  98. Bindings::main_thread_vm(),
  99. [&](JS::Realm& realm) -> JS::Object* {
  100. browsing_context->m_window_proxy = realm.heap().allocate<WindowProxy>(realm, realm).release_allocated_value_but_fixme_should_propagate_errors();
  101. // - For the global object, create a new Window object.
  102. window = HTML::Window::create(realm).release_value_but_fixme_should_propagate_errors();
  103. return window.ptr();
  104. },
  105. [&](JS::Realm&) -> JS::Object* {
  106. // - For the global this binding, use browsingContext's WindowProxy object.
  107. return browsing_context->m_window_proxy;
  108. });
  109. // 9. Let topLevelCreationURL be about:blank if embedder is null; otherwise embedder's relevant settings object's top-level creation URL.
  110. auto top_level_creation_url = !embedder ? AK::URL("about:blank") : relevant_settings_object(*embedder).top_level_creation_url;
  111. // 10. Let topLevelOrigin be origin if embedder is null; otherwise embedder's relevant settings object's top-level origin.
  112. auto top_level_origin = !embedder ? origin : relevant_settings_object(*embedder).origin();
  113. // 11. Set up a window environment settings object with about:blank, realm execution context, null, topLevelCreationURL, and topLevelOrigin.
  114. HTML::WindowEnvironmentSettingsObject::setup(
  115. AK::URL("about:blank"),
  116. move(realm_execution_context),
  117. {},
  118. top_level_creation_url,
  119. top_level_origin)
  120. .release_value_but_fixme_should_propagate_errors();
  121. // 12. Let loadTimingInfo be a new document load timing info with its navigation start time set to the result of calling
  122. // coarsen time with unsafeContextCreationTime and the new environment settings object's cross-origin isolated capability.
  123. auto load_timing_info = DOM::DocumentLoadTimingInfo();
  124. load_timing_info.navigation_start_time = HighResolutionTime::coarsen_time(
  125. unsafe_context_creation_time,
  126. verify_cast<WindowEnvironmentSettingsObject>(Bindings::host_defined_environment_settings_object(window->realm())).cross_origin_isolated_capability() == CanUseCrossOriginIsolatedAPIs::Yes);
  127. // 13. Let coop be a new cross-origin opener policy.
  128. auto coop = CrossOriginOpenerPolicy {};
  129. // 14. If creator is non-null and creator's origin is same origin with creator's relevant settings object's top-level origin,
  130. // then set coop to creator's browsing context's top-level browsing context's active document's cross-origin opener policy.
  131. if (creator && creator->origin().is_same_origin(relevant_settings_object(*creator).top_level_origin)) {
  132. VERIFY(creator->browsing_context());
  133. auto* top_level_document = creator->browsing_context()->top_level_browsing_context().active_document();
  134. VERIFY(top_level_document);
  135. coop = top_level_document->cross_origin_opener_policy();
  136. }
  137. // 15. Let document be a new Document, marked as an HTML document in quirks mode,
  138. // whose content type is "text/html",
  139. // origin is origin,
  140. // FIXME: active sandboxing flag set is sandboxFlags,
  141. // FIXME: permissions policy is permissionsPolicy,
  142. // cross-origin opener policy is coop,
  143. // load timing info is loadTimingInfo,
  144. // FIXME: navigation id is null,
  145. // and which is ready for post-load tasks.
  146. auto document = DOM::Document::create(window->realm()).release_value_but_fixme_should_propagate_errors();
  147. // Non-standard
  148. document->set_window({}, *window);
  149. window->set_associated_document(*document);
  150. document->set_quirks_mode(DOM::QuirksMode::Yes);
  151. document->set_content_type("text/html");
  152. document->set_origin(origin);
  153. document->set_url(AK::URL("about:blank"));
  154. document->set_cross_origin_opener_policy(coop);
  155. document->set_load_timing_info(load_timing_info);
  156. document->set_ready_for_post_load_tasks(true);
  157. // FIXME: 16. Assert: document's URL and document's relevant settings object's creation URL are about:blank.
  158. // 17. Set document's is initial about:blank to true.
  159. document->set_is_initial_about_blank(true);
  160. // 18. Ensure that document has a single child html node, which itself has two empty child nodes: a head element, and a body element.
  161. auto html_node = document->create_element(HTML::TagNames::html).release_value();
  162. MUST(html_node->append_child(document->create_element(HTML::TagNames::head).release_value()));
  163. MUST(html_node->append_child(document->create_element(HTML::TagNames::body).release_value()));
  164. MUST(document->append_child(html_node));
  165. // 19. Set the active document of browsingContext to document.
  166. browsing_context->set_active_document(*document);
  167. // 20. If browsingContext's creator URL is non-null, then set document's referrer to the serialization of it.
  168. if (browsing_context->m_creator_url.has_value()) {
  169. document->set_referrer(browsing_context->m_creator_url->serialize());
  170. }
  171. // FIXME: 21. If creator is non-null, then set document's policy container to a clone of creator's policy container.
  172. // 22. Append a new session history entry to browsingContext's session history whose URL is about:blank and document is document.
  173. browsing_context->m_session_history.append(HTML::SessionHistoryEntry {
  174. .url = AK::URL("about:blank"),
  175. .document = document.ptr(),
  176. .serialized_state = {},
  177. .policy_container = {},
  178. .scroll_restoration_mode = {},
  179. .browsing_context_name = {},
  180. .original_source_browsing_context = {},
  181. });
  182. // 23. Completely finish loading document.
  183. document->completely_finish_loading();
  184. // 24. Return browsingContext.
  185. return *browsing_context;
  186. }
  187. BrowsingContext::BrowsingContext(Page& page, HTML::BrowsingContextContainer* container)
  188. : m_page(page)
  189. , m_loader(*this)
  190. , m_event_handler({}, *this)
  191. , m_container(container)
  192. {
  193. m_cursor_blink_timer = Platform::Timer::create_repeating(500, [this] {
  194. if (!is_focused_context())
  195. return;
  196. if (m_cursor_position.node() && m_cursor_position.node()->layout_node()) {
  197. m_cursor_blink_state = !m_cursor_blink_state;
  198. m_cursor_position.node()->layout_node()->set_needs_display();
  199. }
  200. });
  201. }
  202. BrowsingContext::~BrowsingContext() = default;
  203. void BrowsingContext::visit_edges(Cell::Visitor& visitor)
  204. {
  205. Base::visit_edges(visitor);
  206. for (auto& entry : m_session_history)
  207. visitor.visit(entry.document);
  208. visitor.visit(m_container);
  209. visitor.visit(m_window_proxy);
  210. visitor.visit(m_opener_browsing_context);
  211. visitor.visit(m_group);
  212. visitor.visit(m_parent);
  213. visitor.visit(m_first_child);
  214. visitor.visit(m_last_child);
  215. visitor.visit(m_next_sibling);
  216. visitor.visit(m_previous_sibling);
  217. }
  218. void BrowsingContext::did_edit(Badge<EditEventHandler>)
  219. {
  220. reset_cursor_blink_cycle();
  221. if (m_cursor_position.node() && is<DOM::Text>(*m_cursor_position.node())) {
  222. auto& text_node = static_cast<DOM::Text&>(*m_cursor_position.node());
  223. if (auto* input_element = text_node.owner_input_element())
  224. input_element->did_edit_text_node({});
  225. }
  226. }
  227. void BrowsingContext::reset_cursor_blink_cycle()
  228. {
  229. m_cursor_blink_state = true;
  230. m_cursor_blink_timer->restart();
  231. if (m_cursor_position.is_valid() && m_cursor_position.node()->layout_node())
  232. m_cursor_position.node()->layout_node()->set_needs_display();
  233. }
  234. // https://html.spec.whatwg.org/multipage/browsers.html#top-level-browsing-context
  235. bool BrowsingContext::is_top_level() const
  236. {
  237. // A browsing context that has no parent browsing context is the top-level browsing context for itself and all of the browsing contexts for which it is an ancestor browsing context.
  238. return !parent();
  239. }
  240. bool BrowsingContext::is_focused_context() const
  241. {
  242. return m_page && &m_page->focused_context() == this;
  243. }
  244. // https://html.spec.whatwg.org/multipage/browsers.html#set-the-active-document
  245. void BrowsingContext::set_active_document(JS::NonnullGCPtr<DOM::Document> document)
  246. {
  247. auto previously_active_document = active_document();
  248. // 1. Let window be document's relevant global object.
  249. auto& window = verify_cast<HTML::Window>(relevant_global_object(document));
  250. // 2. Set document's visibility state to browsingContext's top-level browsing context's system visibility state.
  251. document->set_visibility_state({}, top_level_browsing_context().system_visibility_state());
  252. // 3. Set browsingContext's active window to window.
  253. m_window_proxy->set_window({}, window);
  254. // 4. Set window's associated Document to document.
  255. window.set_associated_document(document);
  256. // 5. Set window's relevant settings object's execution ready flag.
  257. relevant_settings_object(window).execution_ready = true;
  258. // AD-HOC:
  259. document->set_browsing_context(this);
  260. if (m_page && is_top_level())
  261. m_page->client().page_did_change_title(document->title());
  262. if (previously_active_document && previously_active_document != document.ptr())
  263. previously_active_document->did_stop_being_active_document_in_browsing_context({});
  264. }
  265. void BrowsingContext::set_viewport_rect(CSSPixelRect const& rect)
  266. {
  267. bool did_change = false;
  268. if (m_size != rect.size()) {
  269. m_size = rect.size();
  270. if (auto* document = active_document()) {
  271. // NOTE: Resizing the viewport changes the reference value for viewport-relative CSS lengths.
  272. document->invalidate_style();
  273. document->invalidate_layout();
  274. }
  275. did_change = true;
  276. }
  277. if (m_viewport_scroll_offset != rect.location()) {
  278. m_viewport_scroll_offset = rect.location();
  279. scroll_offset_did_change();
  280. did_change = true;
  281. }
  282. if (did_change) {
  283. for (auto* client : m_viewport_clients)
  284. client->browsing_context_did_set_viewport_rect(rect);
  285. }
  286. // Schedule the HTML event loop to ensure that a `resize` event gets fired.
  287. HTML::main_thread_event_loop().schedule();
  288. }
  289. void BrowsingContext::set_size(CSSPixelSize size)
  290. {
  291. if (m_size == size)
  292. return;
  293. m_size = size;
  294. if (auto* document = active_document()) {
  295. document->invalidate_style();
  296. document->invalidate_layout();
  297. }
  298. for (auto* client : m_viewport_clients)
  299. client->browsing_context_did_set_viewport_rect(viewport_rect());
  300. // Schedule the HTML event loop to ensure that a `resize` event gets fired.
  301. HTML::main_thread_event_loop().schedule();
  302. }
  303. void BrowsingContext::set_needs_display()
  304. {
  305. set_needs_display(viewport_rect());
  306. }
  307. void BrowsingContext::set_needs_display(CSSPixelRect const& rect)
  308. {
  309. if (!viewport_rect().intersects(rect))
  310. return;
  311. if (is_top_level()) {
  312. if (m_page)
  313. m_page->client().page_did_invalidate(to_top_level_rect(rect));
  314. return;
  315. }
  316. if (container() && container()->layout_node())
  317. container()->layout_node()->set_needs_display();
  318. }
  319. void BrowsingContext::scroll_to(CSSPixelPoint position)
  320. {
  321. if (active_document())
  322. active_document()->force_layout();
  323. if (m_page)
  324. m_page->client().page_did_request_scroll_to(position);
  325. }
  326. void BrowsingContext::scroll_to_anchor(DeprecatedString const& fragment)
  327. {
  328. JS::GCPtr<DOM::Document> document = active_document();
  329. if (!document)
  330. return;
  331. auto element = document->get_element_by_id(fragment);
  332. if (!element) {
  333. auto candidates = document->get_elements_by_name(fragment);
  334. for (auto& candidate : candidates->collect_matching_elements()) {
  335. if (is<HTML::HTMLAnchorElement>(*candidate)) {
  336. element = &verify_cast<HTML::HTMLAnchorElement>(*candidate);
  337. break;
  338. }
  339. }
  340. }
  341. if (!element)
  342. return;
  343. document->force_layout();
  344. if (!element->layout_node())
  345. return;
  346. auto& layout_node = *element->layout_node();
  347. CSSPixelRect target_rect { layout_node.box_type_agnostic_position(), { viewport_rect().width(), viewport_rect().height() } };
  348. if (is<Layout::Box>(layout_node)) {
  349. auto& layout_box = verify_cast<Layout::Box>(layout_node);
  350. auto padding_box = layout_box.box_model().padding_box();
  351. target_rect.translate_by(-padding_box.left, -padding_box.top);
  352. }
  353. if (m_page)
  354. m_page->client().page_did_request_scroll_into_view(target_rect);
  355. }
  356. CSSPixelRect BrowsingContext::to_top_level_rect(CSSPixelRect const& a_rect)
  357. {
  358. auto rect = a_rect;
  359. rect.set_location(to_top_level_position(a_rect.location()));
  360. return rect;
  361. }
  362. CSSPixelPoint BrowsingContext::to_top_level_position(CSSPixelPoint a_position)
  363. {
  364. auto position = a_position;
  365. for (auto ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
  366. if (ancestor->is_top_level())
  367. break;
  368. if (!ancestor->container())
  369. return {};
  370. if (!ancestor->container()->layout_node())
  371. return {};
  372. position.translate_by(ancestor->container()->layout_node()->box_type_agnostic_position());
  373. }
  374. return position;
  375. }
  376. void BrowsingContext::set_cursor_position(DOM::Position position)
  377. {
  378. if (m_cursor_position == position)
  379. return;
  380. if (m_cursor_position.node() && m_cursor_position.node()->layout_node())
  381. m_cursor_position.node()->layout_node()->set_needs_display();
  382. m_cursor_position = move(position);
  383. if (m_cursor_position.node() && m_cursor_position.node()->layout_node())
  384. m_cursor_position.node()->layout_node()->set_needs_display();
  385. reset_cursor_blink_cycle();
  386. }
  387. static DeprecatedString visible_text_in_range(DOM::Range const& range)
  388. {
  389. // NOTE: This is an adaption of Range stringification, but we skip over DOM nodes that don't have a corresponding layout node.
  390. StringBuilder builder;
  391. if (range.start_container() == range.end_container() && is<DOM::Text>(*range.start_container())) {
  392. if (!range.start_container()->layout_node())
  393. return ""sv;
  394. return static_cast<DOM::Text const&>(*range.start_container()).data().substring(range.start_offset(), range.end_offset() - range.start_offset());
  395. }
  396. if (is<DOM::Text>(*range.start_container()) && range.start_container()->layout_node())
  397. builder.append(static_cast<DOM::Text const&>(*range.start_container()).data().substring_view(range.start_offset()));
  398. for (DOM::Node const* node = range.start_container(); node != range.end_container()->next_sibling(); node = node->next_in_pre_order()) {
  399. if (is<DOM::Text>(*node) && range.contains_node(*node) && node->layout_node())
  400. builder.append(static_cast<DOM::Text const&>(*node).data());
  401. }
  402. if (is<DOM::Text>(*range.end_container()) && range.end_container()->layout_node())
  403. builder.append(static_cast<DOM::Text const&>(*range.end_container()).data().substring_view(0, range.end_offset()));
  404. return builder.to_deprecated_string();
  405. }
  406. DeprecatedString BrowsingContext::selected_text() const
  407. {
  408. auto* document = active_document();
  409. if (!document)
  410. return ""sv;
  411. auto selection = const_cast<DOM::Document&>(*document).get_selection();
  412. auto range = selection->range();
  413. if (!range)
  414. return ""sv;
  415. return visible_text_in_range(*range);
  416. }
  417. void BrowsingContext::select_all()
  418. {
  419. auto* document = active_document();
  420. if (!document)
  421. return;
  422. auto* body = document->body();
  423. if (!body)
  424. return;
  425. auto selection = document->get_selection();
  426. if (!selection)
  427. return;
  428. (void)selection->select_all_children(*document->body());
  429. }
  430. void BrowsingContext::register_viewport_client(ViewportClient& client)
  431. {
  432. auto result = m_viewport_clients.set(&client);
  433. VERIFY(result == AK::HashSetResult::InsertedNewEntry);
  434. }
  435. void BrowsingContext::unregister_viewport_client(ViewportClient& client)
  436. {
  437. bool was_removed = m_viewport_clients.remove(&client);
  438. VERIFY(was_removed);
  439. }
  440. void BrowsingContext::register_frame_nesting(AK::URL const& url)
  441. {
  442. m_frame_nesting_levels.ensure(url)++;
  443. }
  444. bool BrowsingContext::is_frame_nesting_allowed(AK::URL const& url) const
  445. {
  446. return m_frame_nesting_levels.get(url).value_or(0) < 3;
  447. }
  448. bool BrowsingContext::increment_cursor_position_offset()
  449. {
  450. if (!m_cursor_position.increment_offset())
  451. return false;
  452. reset_cursor_blink_cycle();
  453. return true;
  454. }
  455. bool BrowsingContext::decrement_cursor_position_offset()
  456. {
  457. if (!m_cursor_position.decrement_offset())
  458. return false;
  459. reset_cursor_blink_cycle();
  460. return true;
  461. }
  462. DOM::Document* BrowsingContext::container_document()
  463. {
  464. if (auto* container = this->container())
  465. return &container->document();
  466. return nullptr;
  467. }
  468. DOM::Document const* BrowsingContext::container_document() const
  469. {
  470. if (auto* container = this->container())
  471. return &container->document();
  472. return nullptr;
  473. }
  474. // https://html.spec.whatwg.org/#rendering-opportunity
  475. bool BrowsingContext::has_a_rendering_opportunity() const
  476. {
  477. // A browsing context has a rendering opportunity if the user agent is currently able to present the contents of the browsing context to the user,
  478. // accounting for hardware refresh rate constraints and user agent throttling for performance reasons, but considering content presentable even if it's outside the viewport.
  479. // FIXME: We should at the very least say `false` here if we're an inactive browser tab.
  480. return true;
  481. }
  482. // https://html.spec.whatwg.org/multipage/interaction.html#currently-focused-area-of-a-top-level-browsing-context
  483. JS::GCPtr<DOM::Node> BrowsingContext::currently_focused_area()
  484. {
  485. // 1. If topLevelBC does not have system focus, then return null.
  486. if (!is_focused_context())
  487. return nullptr;
  488. // 2. Let candidate be topLevelBC's active document.
  489. auto* candidate = active_document();
  490. // 3. While candidate's focused area is a browsing context container with a non-null nested browsing context:
  491. // set candidate to the active document of that browsing context container's nested browsing context.
  492. while (candidate->focused_element()
  493. && is<HTML::BrowsingContextContainer>(candidate->focused_element())
  494. && static_cast<HTML::BrowsingContextContainer&>(*candidate->focused_element()).nested_browsing_context()) {
  495. candidate = static_cast<HTML::BrowsingContextContainer&>(*candidate->focused_element()).nested_browsing_context()->active_document();
  496. }
  497. // 4. If candidate's focused area is non-null, set candidate to candidate's focused area.
  498. if (candidate->focused_element()) {
  499. // NOTE: We return right away here instead of assigning to candidate,
  500. // since that would require compromising type safety.
  501. return candidate->focused_element();
  502. }
  503. // 5. Return candidate.
  504. return candidate;
  505. }
  506. // https://html.spec.whatwg.org/#the-rules-for-choosing-a-browsing-context-given-a-browsing-context-name
  507. BrowsingContext::ChosenBrowsingContext BrowsingContext::choose_a_browsing_context(StringView name, bool no_opener)
  508. {
  509. // The rules for choosing a browsing context, given a browsing context name name, a browsing context current, and
  510. // a boolean noopener are as follows:
  511. // 1. Let chosen be null.
  512. JS::GCPtr<AbstractBrowsingContext> chosen = nullptr;
  513. // 2. Let windowType be "existing or none".
  514. auto window_type = WindowType::ExistingOrNone;
  515. // 3. Let sandboxingFlagSet be current's active document's active sandboxing flag set.
  516. auto sandboxing_flag_set = active_document()->active_sandboxing_flag_set();
  517. // 4. If name is the empty string or an ASCII case-insensitive match for "_self", then set chosen to current.
  518. if (name.is_empty() || Infra::is_ascii_case_insensitive_match(name, "_self"sv)) {
  519. chosen = this;
  520. }
  521. // 5. Otherwise, if name is an ASCII case-insensitive match for "_parent", set chosen to current's parent browsing
  522. // context, if any, and current otherwise.
  523. else if (Infra::is_ascii_case_insensitive_match(name, "_parent"sv)) {
  524. if (auto parent = this->parent())
  525. chosen = parent;
  526. else
  527. chosen = this;
  528. }
  529. // 6. Otherwise, if name is an ASCII case-insensitive match for "_top", set chosen to current's top-level browsing
  530. // context, if any, and current otherwise.
  531. else if (Infra::is_ascii_case_insensitive_match(name, "_top"sv)) {
  532. chosen = &top_level_browsing_context();
  533. }
  534. // FIXME: 7. Otherwise, if name is not an ASCII case-insensitive match for "_blank", there exists a browsing context
  535. // whose name is the same as name, current is familiar with that browsing context, and the user agent
  536. // determines that the two browsing contexts are related enough that it is ok if they reach each other,
  537. // set chosen to that browsing context. If there are multiple matching browsing contexts, the user agent
  538. // should set chosen to one in some arbitrary consistent manner, such as the most recently opened, most
  539. // recently focused, or more closely related.
  540. else if (!Infra::is_ascii_case_insensitive_match(name, "_blank"sv)) {
  541. dbgln("FIXME: Find matching browser context for name {}", name);
  542. chosen = this;
  543. } else {
  544. // 8. Otherwise, a new browsing context is being requested, and what happens depends on the user agent's
  545. // configuration and abilities — it is determined by the rules given for the first applicable option from
  546. // the following list:
  547. // --> If current's active window does not have transient activation and the user agent has been configured to
  548. // not show popups (i.e., the user agent has a "popup blocker" enabled)
  549. VERIFY(m_page);
  550. if (!active_window()->has_transient_activation() && m_page->should_block_pop_ups()) {
  551. // FIXME: The user agent may inform the user that a popup has been blocked.
  552. dbgln("Pop-up blocked!");
  553. }
  554. // --> If sandboxingFlagSet has the sandboxed auxiliary navigation browsing context flag set
  555. else if (sandboxing_flag_set.flags & SandboxingFlagSet::SandboxedAuxiliaryNavigation) {
  556. // FIXME: The user agent may report to a developer console that a popup has been blocked.
  557. dbgln("Pop-up blocked!");
  558. }
  559. // --> If the user agent has been configured such that in this instance it will create a new browsing context
  560. else if (true) { // FIXME: When is this the case?
  561. // 1. Set windowType to "new and unrestricted".
  562. window_type = WindowType::NewAndUnrestricted;
  563. // 2. If current's top-level browsing context's active document's cross-origin opener policy's value is
  564. // "same-origin" or "same-origin-plus-COEP", then:
  565. if (top_level_browsing_context().active_document()->cross_origin_opener_policy().value == CrossOriginOpenerPolicyValue::SameOrigin || top_level_browsing_context().active_document()->cross_origin_opener_policy().value == CrossOriginOpenerPolicyValue::SameOriginPlusCOEP) {
  566. // 1. Let currentDocument be current's active document.
  567. auto* current_document = top_level_browsing_context().active_document();
  568. // 2. If currentDocument's origin is not same origin with currentDocument's relevant settings object's
  569. // top-level origin, then set noopener to true, name to "_blank", and windowType to "new with no opener".
  570. if (!current_document->origin().is_same_origin(current_document->relevant_settings_object().top_level_origin)) {
  571. no_opener = true;
  572. name = "_blank"sv;
  573. window_type = WindowType::NewWithNoOpener;
  574. }
  575. }
  576. // 3. If noopener is true, then set chosen to the result of creating a new top-level browsing context.
  577. if (no_opener) {
  578. chosen = HTML::BrowsingContext::create_a_new_top_level_browsing_context(*m_page);
  579. }
  580. // 4. Otherwise:
  581. else {
  582. // 1. Set chosen to the result of creating a new auxiliary browsing context with current.
  583. // FIXME: We have no concept of auxiliary browsing context
  584. chosen = HTML::BrowsingContext::create_a_new_top_level_browsing_context(*m_page);
  585. // 2. If sandboxingFlagSet's sandboxed navigation browsing context flag is set, then current must be
  586. // set as chosen's one permitted sandboxed navigator.
  587. // FIXME: We have no concept of one permitted sandboxed navigator
  588. }
  589. // 5. If sandboxingFlagSet's sandbox propagates to auxiliary browsing contexts flag is set, then all the
  590. // flags that are set in sandboxingFlagSet must be set in chosen's popup sandboxing flag set.
  591. // FIXME: Our BrowsingContexts do not have SandboxingFlagSets yet, only documents do
  592. // 6. If name is not an ASCII case-insensitive match for "_blank", then set chosen's name to name.
  593. if (!Infra::is_ascii_case_insensitive_match(name, "_blank"sv))
  594. chosen->set_name(name);
  595. }
  596. // --> If the user agent has been configured such that in this instance t will reuse current
  597. else if (false) { // FIXME: When is this the case?
  598. // Set chosen to current.
  599. chosen = *this;
  600. }
  601. // --> If the user agent has been configured such that in this instance it will not find a browsing context
  602. else if (false) { // FIXME: When is this the case?
  603. // Do nothing.
  604. }
  605. }
  606. // 9. Return chosen and windowType.
  607. return { chosen.ptr(), window_type };
  608. }
  609. // https://html.spec.whatwg.org/multipage/browsers.html#document-tree-child-browsing-context
  610. size_t BrowsingContext::document_tree_child_browsing_context_count() const
  611. {
  612. size_t count = 0;
  613. // A browsing context child is a document-tree child browsing context of parent if child is a child browsing context and child's container is in a document tree.
  614. for_each_child([this, &count](BrowsingContext const& child) {
  615. if (child.is_child_of(*this) && child.container()->in_a_document_tree())
  616. ++count;
  617. });
  618. return count;
  619. }
  620. // https://html.spec.whatwg.org/multipage/browsers.html#child-browsing-context
  621. bool BrowsingContext::is_child_of(BrowsingContext const& parent) const
  622. {
  623. // A browsing context child is said to be a child browsing context of another browsing context parent,
  624. // if child's container document is non-null and child's container document's browsing context is parent.
  625. return container_document() && container_document()->browsing_context() == &parent;
  626. }
  627. // https://html.spec.whatwg.org/multipage/dom.html#still-on-its-initial-about:blank-document
  628. bool BrowsingContext::still_on_its_initial_about_blank_document() const
  629. {
  630. // A browsing context browsingContext is still on its initial about:blank Document
  631. // if browsingContext's session history's size is 1
  632. // and browsingContext's session history[0]'s document's is initial about:blank is true.
  633. return m_session_history.size() == 1
  634. && m_session_history[0].document
  635. && m_session_history[0].document->is_initial_about_blank();
  636. }
  637. DOM::Document const* BrowsingContext::active_document() const
  638. {
  639. auto* window = active_window();
  640. if (!window)
  641. return nullptr;
  642. return &window->associated_document();
  643. }
  644. DOM::Document* BrowsingContext::active_document()
  645. {
  646. auto* window = active_window();
  647. if (!window)
  648. return nullptr;
  649. return &window->associated_document();
  650. }
  651. // https://html.spec.whatwg.org/multipage/browsers.html#active-window
  652. HTML::Window* BrowsingContext::active_window()
  653. {
  654. return m_window_proxy->window();
  655. }
  656. // https://html.spec.whatwg.org/multipage/browsers.html#active-window
  657. HTML::Window const* BrowsingContext::active_window() const
  658. {
  659. return m_window_proxy->window();
  660. }
  661. HTML::WindowProxy* BrowsingContext::window_proxy()
  662. {
  663. return m_window_proxy.ptr();
  664. }
  665. HTML::WindowProxy const* BrowsingContext::window_proxy() const
  666. {
  667. return m_window_proxy.ptr();
  668. }
  669. void BrowsingContext::scroll_offset_did_change()
  670. {
  671. // https://w3c.github.io/csswg-drafts/cssom-view-1/#scrolling-events
  672. // Whenever a viewport gets scrolled (whether in response to user interaction or by an API), the user agent must run these steps:
  673. // 1. Let doc be the viewport’s associated Document.
  674. auto* doc = active_document();
  675. VERIFY(doc);
  676. // 2. If doc is already in doc’s pending scroll event targets, abort these steps.
  677. for (auto& target : doc->pending_scroll_event_targets()) {
  678. if (target.ptr() == doc)
  679. return;
  680. }
  681. // 3. Append doc to doc’s pending scroll event targets.
  682. doc->pending_scroll_event_targets().append(*doc);
  683. }
  684. BrowsingContextGroup* BrowsingContext::group()
  685. {
  686. return m_group;
  687. }
  688. void BrowsingContext::set_group(BrowsingContextGroup* group)
  689. {
  690. m_group = group;
  691. }
  692. // https://html.spec.whatwg.org/multipage/browsers.html#bcg-remove
  693. void BrowsingContext::remove()
  694. {
  695. // 1. Assert: browsingContext's group is non-null, because a browsing context only gets discarded once.
  696. VERIFY(group());
  697. // 2. Let group be browsingContext's group.
  698. JS::NonnullGCPtr<BrowsingContextGroup> group = *this->group();
  699. // 3. Set browsingContext's group to null.
  700. set_group(nullptr);
  701. // 4. Remove browsingContext from group's browsing context set.
  702. group->browsing_context_set().remove(this);
  703. // 5. If group's browsing context set is empty, then remove group from the user agent's browsing context group set.
  704. // NOTE: This is done by ~BrowsingContextGroup() when the refcount reaches 0.
  705. }
  706. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#navigate
  707. WebIDL::ExceptionOr<void> BrowsingContext::navigate(
  708. JS::NonnullGCPtr<Fetch::Infrastructure::Request> resource,
  709. BrowsingContext& source_browsing_context,
  710. bool exceptions_enabled,
  711. HistoryHandlingBehavior history_handling,
  712. Optional<PolicyContainer> history_policy_container,
  713. DeprecatedString navigation_type,
  714. Optional<DeprecatedString> navigation_id,
  715. Function<void(JS::NonnullGCPtr<Fetch::Infrastructure::Response>)> process_response_end_of_body)
  716. {
  717. // 1. If resource is a URL, then set resource to a new request whose URL is resource.
  718. // NOTE: This function only accepts resources that are already a request, so this is irrelevant.
  719. // 2. If resource is a request and historyHandling is "reload", then set resource's reload-navigation flag.
  720. if (history_handling == HistoryHandlingBehavior::Reload)
  721. resource->set_reload_navigation(true);
  722. // 3. If the source browsing context is not allowed to navigate browsingContext, then:
  723. if (!source_browsing_context.is_allowed_to_navigate(*this)) {
  724. // 1. If exceptionsEnabled is given and is true, then throw a "SecurityError" DOMException.
  725. if (exceptions_enabled) {
  726. VERIFY(source_browsing_context.active_document());
  727. return WebIDL::SecurityError::create(source_browsing_context.active_document()->realm(), "Source browsing context not allowed to navigate"sv);
  728. }
  729. // FIXME: 2. Otherwise, the user agent may instead offer to open resource in a new top-level browsing context
  730. // or in the top-level browsing context of the source browsing context, at the user's option,
  731. // in which case the user agent must navigate that designated top-level browsing context
  732. // to resource as if the user had requested it independently.
  733. }
  734. // 4. If navigationId is null:
  735. if (!navigation_id.has_value()) {
  736. // 1. If historyHandling is "reload", and browsingContext's active document's navigation id is not null,
  737. if (history_handling == HistoryHandlingBehavior::Reload && active_document()->navigation_id().has_value()) {
  738. // let navigationId be browsingContext's active document's navigation id.
  739. navigation_id = active_document()->navigation_id();
  740. } else {
  741. // Otherwise let navigation id be the result of generating a random UUID. [UUID]
  742. // FIXME: Generate a UUID.
  743. navigation_id = "FIXME";
  744. }
  745. }
  746. // FIXME: 5. If browsingContext's active document's unload counter is greater than 0,
  747. // then invoke WebDriver BiDi navigation failed
  748. // with a WebDriver BiDi navigation status whose id is navigationId, status is "canceled", and url is resource's url
  749. // and return.
  750. // 6. If historyHandling is "default", and any of the following are true:
  751. // - browsingContext is still on its initial about:blank Document
  752. // - resource is a request whose URL equals browsingContext's active document's URL
  753. // - resource is a request whose URL's scheme is "javascript"
  754. if (history_handling == HistoryHandlingBehavior::Default
  755. && (still_on_its_initial_about_blank_document()
  756. || resource->url().equals(active_document()->url())
  757. || resource->url().scheme() == "javascript"sv)) {
  758. // then set historyHandling to "replace".
  759. history_handling = HistoryHandlingBehavior::Replace;
  760. }
  761. // 7. If historyHandling is not "reload", resource is a request,
  762. // resource's URL equals browsingContext's active document's URL with exclude fragments set to true,
  763. // and resource's URL's fragment is non-null, then:
  764. if (history_handling != HistoryHandlingBehavior::Reload
  765. && resource->url().equals(active_document()->url(), AK::URL::ExcludeFragment::Yes)
  766. && !resource->url().fragment().is_null()) {
  767. // 1. Navigate to a fragment given browsingContext, resource's URL, historyHandling, and navigationId.
  768. TRY(navigate_to_a_fragment(resource->url(), history_handling, *navigation_id));
  769. // 2. Return.
  770. return {};
  771. }
  772. // FIXME: 8. Let incumbentNavigationOrigin be the origin of the incumbent settings object,
  773. // or if no script was involved, the origin of the node document of the element that initiated the navigation.
  774. // FIXME: 9. Let initiatorPolicyContainer be a clone of the source browsing context's active document's policy container.
  775. // FIXME: 10. If resource is a request, then set resource's policy container to initiatorPolicyContainer.
  776. // FIXME: 11. Cancel any preexisting but not yet mature attempt to navigate browsingContext,
  777. // including canceling any instances of the fetch algorithm started by those attempts.
  778. // If one of those attempts has already created and initialized a new Document object,
  779. // abort that Document also.
  780. // (Navigation attempts that have matured already have session history entries,
  781. // and are therefore handled during the update the session history with the new page algorithm, later.)
  782. // FIXME: 12. Let unloadPromptResult be the result of calling prompt to unload with the active document of browsingContext.
  783. // If this instance of the navigation algorithm gets canceled while this step is running,
  784. // the prompt to unload algorithm must nonetheless be run to completion.
  785. // FIXME: 13. If unloadPromptResult is "refuse", then return a new WebDriver BiDi navigation status whose id is navigationId and status is "canceled".
  786. // 14. Abort the active document of browsingContext.
  787. active_document()->abort();
  788. // FIXME: 15. If browsingContext is a child browsing context, then put it in the delaying load events mode.
  789. // The user agent must take this child browsing context out of the delaying load events mode when this navigation algorithm later matures,
  790. // or when it terminates (whether due to having run all the steps, or being canceled, or being aborted),
  791. // whichever happens first.
  792. // FIXME: 16. Let sandboxFlags be the result of determining the creation sandboxing flags given browsingContext and browsingContext's container.
  793. // FIXME: 17. Let allowedToDownload be the result of running the allowed to download algorithm given the source browsing context and browsingContext.
  794. // 18. Let hasTransientActivation be true if the source browsing context's active window has transient activation; otherwise false.
  795. [[maybe_unused]] bool has_transient_activation = source_browsing_context.active_window()->has_transient_activation();
  796. // FIXME: 19. Invoke WebDriver BiDi navigation started with browsingContext, and a new WebDriver BiDi navigation status whose id is navigationId, url is resource's url, and status is "pending".
  797. // 20. Return, and continue running these steps in parallel.
  798. // FIXME: Implement the rest of this algorithm
  799. (void)history_policy_container;
  800. (void)navigation_type;
  801. (void)process_response_end_of_body;
  802. // AD-HOC:
  803. loader().load(resource->url(), FrameLoader::Type::IFrame);
  804. return {};
  805. }
  806. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#navigate-fragid
  807. WebIDL::ExceptionOr<void> BrowsingContext::navigate_to_a_fragment(AK::URL const& url, HistoryHandlingBehavior history_handling, DeprecatedString navigation_id)
  808. {
  809. // 1. If historyHandling is not "replace",
  810. if (history_handling != HistoryHandlingBehavior::Replace) {
  811. // FIXME: then remove all the entries in browsingContext's session history after the current entry.
  812. // (If the current entry is the last entry in the session history, then no entries are removed.)
  813. }
  814. // 2. Remove any tasks queued by the history traversal task source that are associated with any Document objects
  815. // in browsingContext's top-level browsing context's document family.
  816. HTML::main_thread_event_loop().task_queue().remove_tasks_matching([&](HTML::Task const& task) {
  817. return task.source() == Task::Source::HistoryTraversal
  818. && task.document()
  819. && top_level_browsing_context().document_family_contains(*task.document());
  820. });
  821. // 3. Append a new session history entry to the session history whose URL is url,
  822. // document is the current entry's document,
  823. // policy container is the current entry's policy-container
  824. // and scroll restoration mode is the current entry's scroll restoration mode.
  825. m_session_history.append(SessionHistoryEntry {
  826. .url = url,
  827. .document = current_entry().document,
  828. .serialized_state = {},
  829. .policy_container = current_entry().policy_container,
  830. .scroll_restoration_mode = current_entry().scroll_restoration_mode,
  831. .browsing_context_name = {},
  832. .original_source_browsing_context = {},
  833. });
  834. // 4. Traverse the history to the new entry, with historyHandling set to historyHandling.
  835. // This will scroll to the fragment given in what is now the document's URL.
  836. TRY(traverse_the_history(m_session_history.size() - 1, history_handling));
  837. // FIXME: 5. Invoke WebDriver BiDi fragment navigated with browsingContext,
  838. // and a new WebDriver BiDi navigation status whose id is navigationId, url is resource's url, and status is "complete".
  839. (void)navigation_id;
  840. return {};
  841. }
  842. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#traverse-the-history
  843. WebIDL::ExceptionOr<void> BrowsingContext::traverse_the_history(size_t entry_index, HistoryHandlingBehavior history_handling, bool explicit_history_navigation)
  844. {
  845. auto* entry = &m_session_history[entry_index];
  846. // 1. If entry's document is null, then:
  847. if (!entry->document) {
  848. // 1. Assert: historyHandling is "default".
  849. VERIFY(history_handling == HistoryHandlingBehavior::Default);
  850. // 2. Let request be a new request whose URL is entry's URL.
  851. auto& vm = Bindings::main_thread_vm();
  852. auto request = Fetch::Infrastructure::Request::create(vm);
  853. request->set_url(entry->url);
  854. // 3. If explicitHistoryNavigation is true, then set request's history-navigation flag.
  855. if (explicit_history_navigation)
  856. request->set_history_navigation(true);
  857. // 4. Navigate the browsing context to request with historyHandling set to "entry update"
  858. // and with historyPolicyContainer set to entry's policy container.
  859. // The navigation must be done using the same source browsing context as was used the first time entry was created.
  860. VERIFY(entry->original_source_browsing_context);
  861. TRY(navigate(request, *entry->original_source_browsing_context, false, HistoryHandlingBehavior::EntryUpdate, entry->policy_container));
  862. // 5. Return.
  863. return {};
  864. }
  865. // FIXME: 2. Save persisted state to the current entry.
  866. // 3. Let newDocument be entry's document.
  867. JS::GCPtr<DOM::Document> new_document = entry->document.ptr();
  868. // 4. Assert: newDocument's is initial about:blank is false,
  869. // i.e., we never traverse back to the initial about:blank Document because it always gets replaced when we navigate away from it.
  870. VERIFY(!new_document->is_initial_about_blank());
  871. // 5. If newDocument is different than the current entry's document, or historyHandling is "entry update" or "reload", then:
  872. if (new_document.ptr() != current_entry().document.ptr()
  873. || history_handling == HistoryHandlingBehavior::EntryUpdate) {
  874. // FIXME: 1. If newDocument's suspended timer handles is not empty:
  875. // FIXME: 1. Assert: newDocument's suspension time is not zero.
  876. // FIXME: 2. Let suspendDuration be the current high resolution time minus newDocument's suspension time.
  877. // FIXME: 3. Let activeTimers be newDocument's relevant global object's map of active timers.
  878. // FIXME: 4. For each handle in newDocument's suspended timer handles, if activeTimers[handle] exists, then increase activeTimers[handle] by suspendDuration.
  879. }
  880. // 2. Remove any tasks queued by the history traversal task source
  881. // that are associated with any Document objects in the top-level browsing context's document family.
  882. HTML::main_thread_event_loop().task_queue().remove_tasks_matching([&](HTML::Task const& task) {
  883. return task.source() == Task::Source::HistoryTraversal
  884. && task.document()
  885. && top_level_browsing_context().document_family_contains(*task.document());
  886. });
  887. // 3. If newDocument's origin is not same origin with the current entry's document's origin, then:
  888. if (!new_document->origin().is_same_origin(current_entry().document->origin())) {
  889. // FIXME: 1. Let entriesToUpdate be all entries in the session history whose document's origin is same origin as the active document
  890. // and that are contiguous with the current entry.
  891. // FIXME: 2. For each entryToUpdate of entriesToUpdate, set entryToUpdate's browsing context name to the current browsing context name.
  892. // FIXME: 3. If the browsing context is a top-level browsing context, but not an auxiliary browsing context whose disowned is false, then set the browsing context's name to the empty string.
  893. }
  894. // 4. Set the active document of the browsing context to newDocument.
  895. set_active_document(*new_document);
  896. // 5. If entry's browsing context name is not null, then:
  897. if (entry->browsing_context_name.has_value()) {
  898. // 1. Set the browsing context's name to entry's browsing context name.
  899. m_name = *entry->browsing_context_name;
  900. // FIXME: 2. Let entriesToUpdate be all entries in the session history whose document's origin is same origin as the new active document's origin and that are contiguous with entry.
  901. // FIXME: 3. For each entryToUpdate of entriesToUpdate, set entryToUpdate's browsing context name to null.
  902. }
  903. // FIXME: 6. If newDocument has any form controls whose autofill field name is "off", invoke the reset algorithm of each of those elements.
  904. // 7. If newDocument's current document readiness "complete",
  905. if (new_document->ready_state() == "complete"sv) {
  906. // then queue a global task on the DOM manipulation task source given newDocument's relevant global object to run the following steps:
  907. queue_global_task(Task::Source::DOMManipulation, relevant_global_object(*new_document), [new_document] {
  908. // 1. If newDocument's page showing flag is true, then abort these steps.
  909. if (new_document->page_showing())
  910. return;
  911. // 2. Set newDocument's page showing flag to true.
  912. new_document->set_page_showing(true);
  913. // 3. Update the visibility state of newDocument to "hidden".
  914. new_document->update_the_visibility_state(VisibilityState::Hidden);
  915. // 4. Fire a page transition event named pageshow at newDocument's relevant global object with true.
  916. auto& window = verify_cast<HTML::Window>(relevant_global_object(*new_document));
  917. window.fire_a_page_transition_event(HTML::EventNames::pageshow, true);
  918. });
  919. }
  920. // 6. Set newDocument's URL to entry's URL.
  921. new_document->set_url(entry->url);
  922. // 7. Let hashChanged be false, and let oldURL and newURL be null.
  923. bool hash_changed = false;
  924. Optional<AK::URL> old_url;
  925. Optional<AK::URL> new_url;
  926. // 8. If entry's URL's fragment is not identical to the current entry's URL's fragment,
  927. // and entry's document equals the current entry's document,
  928. if (entry->url.fragment() != current_entry().url.fragment()
  929. && entry->document.ptr() == current_entry().document.ptr()) {
  930. // then set hashChanged to true, set oldURL to the current entry's URL, and set newURL to entry's URL.
  931. hash_changed = true;
  932. old_url = current_entry().url;
  933. new_url = entry->url;
  934. }
  935. // 9. If historyHandling is "replace", then remove the entry immediately before entry in the session history.
  936. if (history_handling == HistoryHandlingBehavior::Replace) {
  937. // FIXME: This is gnarly.
  938. m_session_history.remove(entry_index - 1);
  939. entry_index--;
  940. entry = &m_session_history[entry_index];
  941. }
  942. // 10. If entry's persisted user state is null, and its URL's fragment is non-null, then scroll to the fragment.
  943. if (!entry->url.fragment().is_null()) {
  944. // FIXME: Implement the full "scroll to the fragment" algorithm:
  945. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#scroll-to-the-fragment-identifier
  946. scroll_to_anchor(entry->url.fragment());
  947. }
  948. // 11. Set the current entry to entry.
  949. m_session_history_index = entry_index;
  950. // 12. Let targetRealm be the current Realm Record.
  951. auto* target_realm = Bindings::main_thread_vm().current_realm();
  952. VERIFY(target_realm);
  953. // FIXME: 13. Let state be null.
  954. // FIXME: 14. If entry's serialized state is not null, then set state to StructuredDeserialize(entry's serialized state, targetRealm).
  955. // If this throws an exception, catch it and ignore the exception.
  956. // FIXME: 15. Set newDocument's History object's state to state.
  957. // FIXME: 16. Let stateChanged be true if newDocument has a latest entry, and that entry is not entry; otherwise let it be false.
  958. // FIXME: 17. Set newDocument's latest entry to entry.
  959. // FIXME: 18. If stateChanged is true, then fire an event named popstate at newDocument's relevant global object, using PopStateEvent, with the state attribute initialized to state.
  960. // FIXME: 19. Restore persisted state from entry.
  961. // 20. If hashChanged is true,
  962. if (hash_changed) {
  963. // then queue a global task on the DOM manipulation task source given newDocument's relevant global object
  964. queue_global_task(Task::Source::DOMManipulation, relevant_global_object(*new_document), [new_document] {
  965. // to fire an event named hashchange at newDocument's relevant global object,
  966. // using HashChangeEvent, with the oldURL attribute initialized to oldURL
  967. // and the newURL attribute initialized to newURL.
  968. // FIXME: Implement a proper HashChangeEvent class.
  969. auto event = DOM::Event::create(verify_cast<HTML::Window>(relevant_global_object(*new_document)).realm(), HTML::EventNames::hashchange).release_value_but_fixme_should_propagate_errors();
  970. new_document->dispatch_event(event);
  971. });
  972. }
  973. return {};
  974. }
  975. // https://html.spec.whatwg.org/multipage/browsers.html#allowed-to-navigate
  976. bool BrowsingContext::is_allowed_to_navigate(BrowsingContext const& other) const
  977. {
  978. VERIFY(active_window());
  979. VERIFY(active_document());
  980. // 1. If A is not the same browsing context as B,
  981. // and A is not one of the ancestor browsing contexts of B,
  982. // and B is not a top-level browsing context,
  983. // FIXME: and A's active document's active sandboxing flag set has its sandboxed navigation browsing context flag set,
  984. // then return false.
  985. if (this != &other
  986. && !this->is_ancestor_of(other)
  987. && !other.is_top_level()) {
  988. return false;
  989. }
  990. // 2. Otherwise, if B is a top-level browsing context, and is one of the ancestor browsing contexts of A, then:
  991. if (other.is_top_level() && other.is_ancestor_of(*this)) {
  992. // 1. If A's active window has transient activation
  993. // and A's active document's active sandboxing flag set has its sandboxed top-level navigation with user activation browsing context flag set,
  994. // then return false.
  995. if (active_window()->has_transient_activation()
  996. && active_document()->active_sandboxing_flag_set().flags & SandboxingFlagSet::SandboxedTopLevelNavigationWithUserActivation) {
  997. return false;
  998. }
  999. // 2. Otherwise, if A's active window does not have transient activation
  1000. // and A's active document's active sandboxing flag set has its sandboxed top-level navigation without user activation browsing context flag set,
  1001. // then return false.
  1002. if (!active_window()->has_transient_activation()
  1003. && active_document()->active_sandboxing_flag_set().flags & SandboxingFlagSet::SandboxedTopLevelNavigationWithoutUserActivation) {
  1004. return false;
  1005. }
  1006. }
  1007. // 3. Otherwise, if B is a top-level browsing context,
  1008. // and is neither A nor one of the ancestor browsing contexts of A,
  1009. // and A's Document's active sandboxing flag set has its sandboxed navigation browsing context flag set,
  1010. // and A is not the one permitted sandboxed navigator of B,
  1011. // then return false.
  1012. if (other.is_top_level()
  1013. && &other != this
  1014. && !other.is_ancestor_of(*this)
  1015. && active_document()->active_sandboxing_flag_set().flags & SandboxingFlagSet::SandboxedNavigation
  1016. && this != other.the_one_permitted_sandboxed_navigator()) {
  1017. return false;
  1018. }
  1019. // 4. Return true.
  1020. return true;
  1021. }
  1022. // https://html.spec.whatwg.org/multipage/origin.html#one-permitted-sandboxed-navigator
  1023. BrowsingContext const* BrowsingContext::the_one_permitted_sandboxed_navigator() const
  1024. {
  1025. // FIXME: Implement this.
  1026. return nullptr;
  1027. }
  1028. // https://html.spec.whatwg.org/multipage/browsers.html#document-family
  1029. Vector<JS::Handle<DOM::Document>> BrowsingContext::document_family() const
  1030. {
  1031. HashTable<DOM::Document*> documents;
  1032. for (auto& entry : m_session_history) {
  1033. if (!entry.document)
  1034. continue;
  1035. if (documents.set(const_cast<DOM::Document*>(entry.document.ptr())) == AK::HashSetResult::ReplacedExistingEntry)
  1036. continue;
  1037. for (auto& context : entry.document->list_of_descendant_browsing_contexts()) {
  1038. for (auto& document : context->document_family()) {
  1039. documents.set(document.ptr());
  1040. }
  1041. }
  1042. }
  1043. Vector<JS::Handle<DOM::Document>> family;
  1044. for (auto* document : documents) {
  1045. family.append(*document);
  1046. }
  1047. return family;
  1048. }
  1049. // https://html.spec.whatwg.org/multipage/browsers.html#document-family
  1050. bool BrowsingContext::document_family_contains(DOM::Document const& document) const
  1051. {
  1052. return document_family().first_matching([&](auto& entry) { return entry.ptr() == &document; }).has_value();
  1053. }
  1054. VisibilityState BrowsingContext::system_visibility_state() const
  1055. {
  1056. return m_system_visibility_state;
  1057. }
  1058. // https://html.spec.whatwg.org/multipage/interaction.html#system-visibility-state
  1059. void BrowsingContext::set_system_visibility_state(VisibilityState visibility_state)
  1060. {
  1061. if (m_system_visibility_state == visibility_state)
  1062. return;
  1063. m_system_visibility_state = visibility_state;
  1064. // When a user-agent determines that the system visibility state for top-level browsing context context
  1065. // has changed to newState, it must queue a task on the user interaction task source to update
  1066. // the visibility state of all the Document objects in the top-level browsing context's document family with newState.
  1067. auto document_family = top_level_browsing_context().document_family();
  1068. // From the new navigable version, where it tells us what global object to use here:
  1069. // 1. Let document be navigable's active document.
  1070. // 2. Queue a global task on the user interaction task source given document's relevant global object to update the visibility state of document with newState.
  1071. // FIXME: Update this function to fully match the navigable version.
  1072. VERIFY(active_document());
  1073. queue_global_task(Task::Source::UserInteraction, relevant_global_object(*active_document()), [visibility_state, document_family = move(document_family)] {
  1074. for (auto& document : document_family) {
  1075. document->update_the_visibility_state(visibility_state);
  1076. }
  1077. });
  1078. }
  1079. // https://html.spec.whatwg.org/multipage/window-object.html#a-browsing-context-is-discarded
  1080. void BrowsingContext::discard()
  1081. {
  1082. m_has_been_discarded = true;
  1083. // 1. Discard all Document objects for all the entries in browsingContext's session history.
  1084. for (auto& entry : m_session_history) {
  1085. if (entry.document)
  1086. entry.document->discard();
  1087. }
  1088. // AD-HOC:
  1089. // FIXME: This should be in the session history!
  1090. if (auto* document = active_document())
  1091. document->discard();
  1092. // 2. If browsingContext is a top-level browsing context, then remove browsingContext.
  1093. if (is_top_level())
  1094. remove();
  1095. // AD-HOC:
  1096. if (parent())
  1097. parent()->remove_child(*this);
  1098. }
  1099. // https://html.spec.whatwg.org/multipage/window-object.html#close-a-browsing-context
  1100. void BrowsingContext::close()
  1101. {
  1102. VERIFY(active_document());
  1103. // FIXME: 1. If the result of calling prompt to unload with browsingContext's active document is "refuse", then return.
  1104. // 2. Unload browsingContext's active document.
  1105. active_document()->unload();
  1106. // 3. Remove browsingContext from the user interface (e.g., close or hide its tab in a tabbed browser).
  1107. if (m_page)
  1108. m_page->client().page_did_close_browsing_context(*this);
  1109. // 4. Discard browsingContext.
  1110. discard();
  1111. }
  1112. void BrowsingContext::append_child(JS::NonnullGCPtr<BrowsingContext> child)
  1113. {
  1114. VERIFY(!child->m_parent);
  1115. if (m_last_child)
  1116. m_last_child->m_next_sibling = child;
  1117. child->m_previous_sibling = m_last_child;
  1118. child->m_parent = this;
  1119. m_last_child = child;
  1120. if (!m_first_child)
  1121. m_first_child = m_last_child;
  1122. }
  1123. void BrowsingContext::remove_child(JS::NonnullGCPtr<BrowsingContext> child)
  1124. {
  1125. VERIFY(child->m_parent.ptr() == this);
  1126. if (m_first_child == child)
  1127. m_first_child = child->m_next_sibling;
  1128. if (m_last_child == child)
  1129. m_last_child = child->m_previous_sibling;
  1130. if (child->m_next_sibling)
  1131. child->m_next_sibling->m_previous_sibling = child->m_previous_sibling;
  1132. if (child->m_previous_sibling)
  1133. child->m_previous_sibling->m_next_sibling = child->m_next_sibling;
  1134. child->m_next_sibling = nullptr;
  1135. child->m_previous_sibling = nullptr;
  1136. child->m_parent = nullptr;
  1137. }
  1138. JS::GCPtr<BrowsingContext> BrowsingContext::first_child() const
  1139. {
  1140. return m_first_child;
  1141. }
  1142. JS::GCPtr<BrowsingContext> BrowsingContext::next_sibling() const
  1143. {
  1144. return m_next_sibling;
  1145. }
  1146. bool BrowsingContext::is_ancestor_of(BrowsingContext const& other) const
  1147. {
  1148. for (auto ancestor = other.parent(); ancestor; ancestor = ancestor->parent()) {
  1149. if (ancestor == this)
  1150. return true;
  1151. }
  1152. return false;
  1153. }
  1154. }