TraversableNavigable.cpp 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677
  1. /*
  2. * Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/QuickSort.h>
  7. #include <LibWeb/Bindings/MainThreadVM.h>
  8. #include <LibWeb/DOM/Document.h>
  9. #include <LibWeb/HTML/BrowsingContextGroup.h>
  10. #include <LibWeb/HTML/DocumentState.h>
  11. #include <LibWeb/HTML/NavigationParams.h>
  12. #include <LibWeb/HTML/SessionHistoryEntry.h>
  13. #include <LibWeb/HTML/TraversableNavigable.h>
  14. #include <LibWeb/Page/Page.h>
  15. #include <LibWeb/Platform/EventLoopPlugin.h>
  16. namespace Web::HTML {
  17. TraversableNavigable::TraversableNavigable(Page& page)
  18. : m_page(page)
  19. {
  20. }
  21. TraversableNavigable::~TraversableNavigable() = default;
  22. void TraversableNavigable::visit_edges(Cell::Visitor& visitor)
  23. {
  24. Base::visit_edges(visitor);
  25. for (auto& entry : m_session_history_entries)
  26. visitor.visit(entry);
  27. }
  28. static OrderedHashTable<TraversableNavigable*>& user_agent_top_level_traversable_set()
  29. {
  30. static OrderedHashTable<TraversableNavigable*> set;
  31. return set;
  32. }
  33. // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-top-level-browsing-context
  34. WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_top_level_browsing_context_and_document(Page& page)
  35. {
  36. // 1. Let group and document be the result of creating a new browsing context group and document.
  37. auto [group, document] = TRY(BrowsingContextGroup::create_a_new_browsing_context_group_and_document(page));
  38. // 2. Return group's browsing context set[0] and document.
  39. return BrowsingContextAndDocument { **group->browsing_context_set().begin(), document };
  40. }
  41. // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-top-level-traversable
  42. WebIDL::ExceptionOr<JS::NonnullGCPtr<TraversableNavigable>> TraversableNavigable::create_a_new_top_level_traversable(Page& page, JS::GCPtr<HTML::BrowsingContext> opener, String target_name)
  43. {
  44. auto& vm = Bindings::main_thread_vm();
  45. // 1. Let document be null.
  46. JS::GCPtr<DOM::Document> document = nullptr;
  47. // 2. If opener is null, then set document to the second return value of creating a new top-level browsing context and document.
  48. if (!opener) {
  49. document = TRY(create_a_new_top_level_browsing_context_and_document(page)).document;
  50. }
  51. // 3. Otherwise, set document to the second return value of creating a new auxiliary browsing context and document given opener.
  52. else {
  53. document = TRY(BrowsingContext::create_a_new_auxiliary_browsing_context_and_document(page, *opener)).document;
  54. }
  55. // 4. Let documentState be a new document state, with
  56. auto document_state = vm.heap().allocate_without_realm<DocumentState>();
  57. // document: document
  58. document_state->set_document(document);
  59. // initiator origin: null if opener is null; otherwise, document's origin
  60. document_state->set_initiator_origin(opener ? Optional<Origin> {} : document->origin());
  61. // origin: document's origin
  62. document_state->set_origin(document->origin());
  63. // navigable target name: targetName
  64. document_state->set_navigable_target_name(target_name);
  65. // about base URL: document's about base URL
  66. document_state->set_about_base_url(document->about_base_url());
  67. // 5. Let traversable be a new traversable navigable.
  68. auto traversable = vm.heap().allocate_without_realm<TraversableNavigable>(page);
  69. // 6. Initialize the navigable traversable given documentState.
  70. TRY_OR_THROW_OOM(vm, traversable->initialize_navigable(document_state, nullptr));
  71. // 7. Let initialHistoryEntry be traversable's active session history entry.
  72. auto initial_history_entry = traversable->active_session_history_entry();
  73. VERIFY(initial_history_entry);
  74. // 8. Set initialHistoryEntry's step to 0.
  75. initial_history_entry->step = 0;
  76. // 9. Append initialHistoryEntry to traversable's session history entries.
  77. traversable->m_session_history_entries.append(*initial_history_entry);
  78. // FIXME: 10. If opener is non-null, then legacy-clone a traversable storage shed given opener's top-level traversable and traversable. [STORAGE]
  79. // 11. Append traversable to the user agent's top-level traversable set.
  80. user_agent_top_level_traversable_set().set(traversable);
  81. // 12. Return traversable.
  82. return traversable;
  83. }
  84. // https://html.spec.whatwg.org/multipage/document-sequences.html#create-a-fresh-top-level-traversable
  85. WebIDL::ExceptionOr<JS::NonnullGCPtr<TraversableNavigable>> TraversableNavigable::create_a_fresh_top_level_traversable(Page& page, AK::URL const& initial_navigation_url, Variant<Empty, String, POSTResource> initial_navigation_post_resource)
  86. {
  87. // 1. Let traversable be the result of creating a new top-level traversable given null and the empty string.
  88. auto traversable = TRY(create_a_new_top_level_traversable(page, nullptr, {}));
  89. // 2. Navigate traversable to initialNavigationURL using traversable's active document, with documentResource set to initialNavigationPostResource.
  90. TRY(traversable->navigate(initial_navigation_url, *traversable->active_document(), initial_navigation_post_resource));
  91. // 3. Return traversable.
  92. return traversable;
  93. }
  94. // https://html.spec.whatwg.org/multipage/document-sequences.html#top-level-traversable
  95. bool TraversableNavigable::is_top_level_traversable() const
  96. {
  97. // A top-level traversable is a traversable navigable with a null parent.
  98. return parent() == nullptr;
  99. }
  100. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-all-used-history-steps
  101. Vector<int> TraversableNavigable::get_all_used_history_steps() const
  102. {
  103. // FIXME: 1. Assert: this is running within traversable's session history traversal queue.
  104. // 2. Let steps be an empty ordered set of non-negative integers.
  105. OrderedHashTable<int> steps;
  106. // 3. Let entryLists be the ordered set « traversable's session history entries ».
  107. Vector<Vector<JS::NonnullGCPtr<SessionHistoryEntry>>> entry_lists { session_history_entries() };
  108. // 4. For each entryList of entryLists:
  109. while (!entry_lists.is_empty()) {
  110. auto entry_list = entry_lists.take_first();
  111. // 1. For each entry of entryList:
  112. for (auto& entry : entry_list) {
  113. // 1. Append entry's step to steps.
  114. steps.set(entry->step.get<int>());
  115. // 2. For each nestedHistory of entry's document state's nested histories, append nestedHistory's entries list to entryLists.
  116. for (auto& nested_history : entry->document_state->nested_histories())
  117. entry_lists.append(nested_history.entries);
  118. }
  119. }
  120. // 5. Return steps, sorted.
  121. auto sorted_steps = steps.values();
  122. quick_sort(sorted_steps);
  123. return sorted_steps;
  124. }
  125. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-the-history-object-length-and-index
  126. TraversableNavigable::HistoryObjectLengthAndIndex TraversableNavigable::get_the_history_object_length_and_index(int step) const
  127. {
  128. // 1. Let steps be the result of getting all used history steps within traversable.
  129. auto steps = get_all_used_history_steps();
  130. // 2. Let scriptHistoryLength be the size of steps.
  131. auto script_history_length = steps.size();
  132. // 3. Assert: steps contains step.
  133. VERIFY(steps.contains_slow(step));
  134. // 4. Let scriptHistoryIndex be the index of step in steps.
  135. auto script_history_index = *steps.find_first_index(step);
  136. // 5. Return (scriptHistoryLength, scriptHistoryIndex).
  137. return HistoryObjectLengthAndIndex {
  138. .script_history_length = script_history_length,
  139. .script_history_index = script_history_index
  140. };
  141. }
  142. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-the-used-step
  143. int TraversableNavigable::get_the_used_step(int step) const
  144. {
  145. // 1. Let steps be the result of getting all used history steps within traversable.
  146. auto steps = get_all_used_history_steps();
  147. // 2. Return the greatest item in steps that is less than or equal to step.
  148. VERIFY(!steps.is_empty());
  149. Optional<int> result;
  150. for (size_t i = 0; i < steps.size(); i++) {
  151. if (steps[i] <= step) {
  152. if (!result.has_value() || (result.value() < steps[i])) {
  153. result = steps[i];
  154. }
  155. }
  156. }
  157. return result.value();
  158. }
  159. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#get-all-navigables-whose-current-session-history-entry-will-change-or-reload
  160. Vector<JS::Handle<Navigable>> TraversableNavigable::get_all_navigables_whose_current_session_history_entry_will_change_or_reload(int target_step) const
  161. {
  162. // 1. Let results be an empty list.
  163. Vector<JS::Handle<Navigable>> results;
  164. // 2. Let navigablesToCheck be « traversable ».
  165. Vector<JS::Handle<Navigable>> navigables_to_check;
  166. navigables_to_check.append(const_cast<TraversableNavigable&>(*this));
  167. // 3. For each navigable of navigablesToCheck:
  168. while (!navigables_to_check.is_empty()) {
  169. auto navigable = navigables_to_check.take_first();
  170. // 1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.
  171. auto target_entry = navigable->get_the_target_history_entry(target_step);
  172. // 2. If targetEntry is not navigable's current session history entry or targetEntry's document state's reload pending is true, then append navigable to results.
  173. if (target_entry != navigable->current_session_history_entry() || target_entry->document_state->reload_pending()) {
  174. results.append(*navigable);
  175. }
  176. // 3. If targetEntry's document is navigable's document, and targetEntry's document state's reload pending is false, then extend navigablesToCheck with the child navigables of navigable.
  177. if (target_entry->document_state->document() == navigable->active_document() && !target_entry->document_state->reload_pending()) {
  178. navigables_to_check.extend(navigable->child_navigables());
  179. }
  180. }
  181. // 4. Return results.
  182. return results;
  183. }
  184. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#apply-the-history-step
  185. void TraversableNavigable::apply_the_history_step(int step, Optional<SourceSnapshotParams> source_snapshot_params)
  186. {
  187. // FIXME: 1. Assert: This is running within traversable's session history traversal queue.
  188. // 2. Let targetStep be the result of getting the used step given traversable and step.
  189. auto target_step = get_the_used_step(step);
  190. // FIXME: 3. If initiatorToCheck is given, then:
  191. // FIXME: 4. Let navigablesCrossingDocuments be the result of getting all navigables that might experience a cross-document traversal given traversable and targetStep.
  192. // FIXME: 5. If checkForUserCancelation is true, and the result of checking if unloading is user-canceled given navigablesCrossingDocuments given traversable and targetStep is true, then return.
  193. // 6. Let changingNavigables be the result of get all navigables whose current session history entry will change or reload given traversable and targetStep.
  194. auto changing_navigables = get_all_navigables_whose_current_session_history_entry_will_change_or_reload(target_step);
  195. // FIXME: 7. Let nonchangingNavigablesThatStillNeedUpdates be the result of getting all navigables that only need history object length/index update given traversable and targetStep.
  196. // 8. For each navigable of changingNavigables:
  197. for (auto& navigable : changing_navigables) {
  198. // 1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.
  199. auto target_entry = navigable->get_the_target_history_entry(target_step);
  200. // 2. Set navigable's current session history entry to targetEntry.
  201. navigable->set_current_session_history_entry(target_entry);
  202. // 3. Set navigable's ongoing navigation to "traversal".
  203. navigable->set_ongoing_navigation(Traversal::Tag);
  204. }
  205. // 9. Let totalChangeJobs be the size of changingNavigables.
  206. auto total_change_jobs = changing_navigables.size();
  207. // 10. Let completedChangeJobs be 0.
  208. size_t completed_change_jobs = 0;
  209. struct ChangingNavigableContinuationState {
  210. JS::Handle<DOM::Document> displayed_document;
  211. JS::Handle<SessionHistoryEntry> target_entry;
  212. JS::Handle<Navigable> navigable;
  213. bool update_only;
  214. };
  215. // 11. Let changingNavigableContinuations be an empty queue of changing navigable continuation states.
  216. Queue<ChangingNavigableContinuationState> changing_navigable_continuations;
  217. // 12. For each navigable of changingNavigables, queue a global task on the navigation and traversal task source of navigable's active window to run the steps:
  218. for (auto& navigable : changing_navigables) {
  219. queue_global_task(Task::Source::NavigationAndTraversal, *navigable->active_window(), [&] {
  220. // NOTE: This check is not in the spec but we should not continue navigation if navigable has been destroyed.
  221. if (navigable->has_been_destroyed())
  222. return;
  223. // 1. Let displayedEntry be navigable's active session history entry.
  224. auto displayed_entry = navigable->active_session_history_entry();
  225. // 2. Let targetEntry be navigable's current session history entry.
  226. auto target_entry = navigable->current_session_history_entry();
  227. // 3. Let changingNavigableContinuation be a changing navigable continuation state with:
  228. auto changing_navigable_continuation = ChangingNavigableContinuationState {
  229. .displayed_document = displayed_entry->document_state->document(),
  230. .target_entry = target_entry,
  231. .navigable = navigable,
  232. .update_only = false
  233. };
  234. // 4. If displayedEntry is targetEntry and targetEntry's document state's reload pending is false, then:
  235. if (displayed_entry == target_entry && !target_entry->document_state->reload_pending()) {
  236. // 1. Set changingNavigableContinuation's update-only to true.
  237. changing_navigable_continuation.update_only = true;
  238. // 2. Enqueue changingNavigableContinuation on changingNavigableContinuations.
  239. changing_navigable_continuations.enqueue(move(changing_navigable_continuation));
  240. // 3. Abort these steps.
  241. return;
  242. }
  243. // 5. Let oldOrigin be targetEntry's document state's origin.
  244. [[maybe_unused]] auto old_origin = target_entry->document_state->origin();
  245. auto after_document_populated = [target_entry, changing_navigable_continuation, &changing_navigable_continuations]() mutable {
  246. // 1. If targetEntry's document is null, then set changingNavigableContinuation's update-only to true.
  247. if (!target_entry->document_state->document()) {
  248. changing_navigable_continuation.update_only = true;
  249. }
  250. // FIXME: 2. If targetEntry's document's origin is not oldOrigin, then set targetEntry's serialized state to StructuredSerializeForStorage(null).
  251. // FIXME: 3. If all of the following are true:
  252. // 4. Enqueue changingNavigableContinuation on changingNavigableContinuations.
  253. changing_navigable_continuations.enqueue(move(changing_navigable_continuation));
  254. };
  255. // 6. If targetEntry's document is null, or targetEntry's document state's reload pending is true, then:
  256. if (!target_entry->document_state->document() || target_entry->document_state->reload_pending()) {
  257. // FIXME: 1. Let navTimingType be "back_forward" if targetEntry's document is null; otherwise "reload".
  258. // 2. Let targetSnapshotParams be the result of snapshotting target snapshot params given navigable.
  259. auto target_snapshot_params = navigable->snapshot_target_snapshot_params();
  260. // 3. Let potentiallyTargetSpecificSourceSnapshotParams be sourceSnapshotParams.
  261. Optional<SourceSnapshotParams> potentially_target_specific_source_snapshot_params = source_snapshot_params;
  262. // 4. If potentiallyTargetSpecificSourceSnapshotParams is null, then set it to the result of snapshotting source snapshot params given navigable's active document.
  263. if (!potentially_target_specific_source_snapshot_params.has_value()) {
  264. potentially_target_specific_source_snapshot_params = navigable->active_document()->snapshot_source_snapshot_params();
  265. }
  266. // 5. Set targetEntry's document state's reload pending to false.
  267. target_entry->document_state->set_reload_pending(false);
  268. // 6. Let allowPOST be targetEntry's document state's reload pending.
  269. auto allow_POST = target_entry->document_state->reload_pending();
  270. // 7. In parallel, attempt to populate the history entry's document for targetEntry, given navigable, potentiallyTargetSpecificSourceSnapshotParams,
  271. // targetSnapshotParams, with allowPOST set to allowPOST and completionSteps set to queue a global task on the navigation and traversal task source given
  272. // navigable's active window to run afterDocumentPopulated.
  273. navigable->populate_session_history_entry_document(target_entry, *potentially_target_specific_source_snapshot_params, target_snapshot_params, {}, Empty {}, CSPNavigationType::Other, allow_POST, [this, after_document_populated]() mutable {
  274. queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), [after_document_populated]() mutable {
  275. after_document_populated();
  276. });
  277. })
  278. .release_value_but_fixme_should_propagate_errors();
  279. }
  280. // Otherwise, run afterDocumentPopulated immediately.
  281. else {
  282. after_document_populated();
  283. }
  284. });
  285. }
  286. // FIXME: 13. Let navigablesThatMustWaitBeforeHandlingSyncNavigation be an empty set.
  287. // FIXME: 14. While completedChangeJobs does not equal totalChangeJobs:
  288. while (completed_change_jobs != total_change_jobs) {
  289. // FIXME: 1. If traversable's running nested apply history step is false, then:
  290. // AD-HOC: Since currently populate_session_history_entry_document does not run in parallel
  291. // we call spin_until to interrupt execution of this function and let document population
  292. // to complete.
  293. Platform::EventLoopPlugin::the().spin_until([&] {
  294. return !changing_navigable_continuations.is_empty() || completed_change_jobs == total_change_jobs;
  295. });
  296. if (changing_navigable_continuations.is_empty()) {
  297. continue;
  298. }
  299. // 2. Let changingNavigableContinuation be the result of dequeuing from changingNavigableContinuations.
  300. auto changing_navigable_continuation = changing_navigable_continuations.dequeue();
  301. // 3. If changingNavigableContinuation is nothing, then continue.
  302. // 4. Let displayedDocument be changingNavigableContinuation's displayed document.
  303. auto displayed_document = changing_navigable_continuation.displayed_document;
  304. // 5. Let targetEntry be changingNavigableContinuation's target entry.
  305. auto target_entry = changing_navigable_continuation.target_entry;
  306. // 6. Let navigable be changingNavigableContinuation's navigable.
  307. auto navigable = changing_navigable_continuation.navigable;
  308. // NOTE: This check is not in the spec but we should not continue navigation if navigable has been destroyed.
  309. if (navigable->has_been_destroyed())
  310. continue;
  311. // 7. Set navigable's ongoing navigation to null.
  312. navigable->set_ongoing_navigation({});
  313. // 8. Let (scriptHistoryLength, scriptHistoryIndex) be the result of getting the history object length and index given traversable and targetStep.
  314. auto [script_history_length, script_history_index] = get_the_history_object_length_and_index(target_step);
  315. (void)script_history_length;
  316. (void)script_history_index;
  317. // FIXME: 9. Append navigable to navigablesThatMustWaitBeforeHandlingSyncNavigation.
  318. // 10. Queue a global task on the navigation and traversal task source given navigable's active window to run the steps:
  319. queue_global_task(Task::Source::NavigationAndTraversal, *navigable->active_window(), [&, target_entry, navigable, displayed_document, update_only = changing_navigable_continuation.update_only] {
  320. // NOTE: This check is not in the spec but we should not continue navigation if navigable has been destroyed.
  321. if (navigable->has_been_destroyed())
  322. return;
  323. // 1. If changingNavigableContinuation's update-only is false, then:
  324. if (!update_only) {
  325. // 1. Unload displayedDocument given targetEntry's document.
  326. displayed_document->unload(target_entry->document_state->document());
  327. // 2. For each childNavigable of displayedDocument's descendant navigables, queue a global task on the navigation and traversal task source given
  328. // childNavigable's active window to unload childNavigable's active document.
  329. for (auto child_navigable : displayed_document->descendant_navigables()) {
  330. queue_global_task(Task::Source::NavigationAndTraversal, *navigable->active_window(), [child_navigable] {
  331. child_navigable->active_document()->unload();
  332. });
  333. }
  334. // 3. Activate history entry targetEntry for navigable.
  335. navigable->activate_history_entry(*target_entry);
  336. }
  337. // FIXME: 2. If targetEntry's document is not equal to displayedDocument, then queue a global task on the navigation and traversal task source given targetEntry's document's
  338. // relevant global object to perform the following step. Otherwise, continue onward to perform the following step within the currently-queued task.
  339. // FIXME: 3. Update document for history step application given targetEntry's document, targetEntry, changingNavigableContinuation's update-only, scriptHistoryLength, and
  340. // scriptHistoryIndex.
  341. // 4. Increment completedChangeJobs.
  342. completed_change_jobs++;
  343. });
  344. }
  345. // FIXME: 15. Let totalNonchangingJobs be the size of nonchangingNavigablesThatStillNeedUpdates.
  346. // FIXME: 16. Let completedNonchangingJobs be 0.
  347. // FIXME: 17. Let (scriptHistoryLength, scriptHistoryIndex) be the result of getting the history object length and index given traversable and targetStep.
  348. // FIXME: 18. For each navigable of nonchangingNavigablesThatStillNeedUpdates, queue a global task on the navigation and traversal task source given navigable's active window to run the steps:
  349. // FIXME: 19. Wait for completedNonchangingJobs to equal totalNonchangingJobs.
  350. // 20. Set traversable's current session history step to targetStep.
  351. m_current_session_history_step = target_step;
  352. }
  353. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#clear-the-forward-session-history
  354. void TraversableNavigable::clear_the_forward_session_history()
  355. {
  356. // FIXME: 1. Assert: this is running within navigable's session history traversal queue.
  357. // 2. Let step be the navigable's current session history step.
  358. auto step = current_session_history_step();
  359. // 3. Let entryLists be the ordered set « navigable's session history entries ».
  360. Vector<Vector<JS::NonnullGCPtr<SessionHistoryEntry>>&> entry_lists;
  361. entry_lists.append(session_history_entries());
  362. // 4. For each entryList of entryLists:
  363. while (!entry_lists.is_empty()) {
  364. auto& entry_list = entry_lists.take_first();
  365. // 1. Remove every session history entry from entryList that has a step greater than step.
  366. entry_list.remove_all_matching([step](auto& entry) {
  367. return entry->step.template get<int>() > step;
  368. });
  369. // 2. For each entry of entryList:
  370. for (auto& entry : entry_list) {
  371. // 1. For each nestedHistory of entry's document state's nested histories, append nestedHistory's entries list to entryLists.
  372. for (auto& nested_history : entry->document_state->nested_histories()) {
  373. entry_lists.append(nested_history.entries);
  374. }
  375. }
  376. }
  377. }
  378. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#traverse-the-history-by-a-delta
  379. void TraversableNavigable::traverse_the_history_by_delta(int delta)
  380. {
  381. // FIXME: 1. Let sourceSnapshotParams and initiatorToCheck be null.
  382. // FIXME: 2. If sourceDocument is given, then:
  383. // 3. Append the following session history traversal steps to traversable:
  384. append_session_history_traversal_steps([this, delta] {
  385. // 1. Let allSteps be the result of getting all used history steps for traversable.
  386. auto all_steps = get_all_used_history_steps();
  387. // 2. Let currentStepIndex be the index of traversable's current session history step within allSteps.
  388. auto current_step_index = *all_steps.find_first_index(current_session_history_step());
  389. // 3. Let targetStepIndex be currentStepIndex plus delta
  390. auto target_step_index = current_step_index + delta;
  391. // 4. If allSteps[targetStepIndex] does not exist, then abort these steps.
  392. if (target_step_index >= all_steps.size()) {
  393. return;
  394. }
  395. // 5. Apply the history step allSteps[targetStepIndex] to traversable, with checkForUserCancelation set to true,
  396. // sourceSnapshotParams set to sourceSnapshotParams, and initiatorToCheck set to initiatorToCheck.
  397. apply_the_history_step(all_steps[target_step_index]);
  398. });
  399. }
  400. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#update-for-navigable-creation/destruction
  401. void TraversableNavigable::update_for_navigable_creation_or_destruction()
  402. {
  403. // 1. Let step be traversable's current session history step.
  404. auto step = current_session_history_step();
  405. // 2. Return the result of applying the history step step to traversable given false, false, null, null, and null.
  406. // FIXME: Pass false, false, null, null, and null as arguments.
  407. apply_the_history_step(step);
  408. }
  409. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#apply-the-reload-history-step
  410. void TraversableNavigable::apply_the_reload_history_step()
  411. {
  412. // 1. Let step be traversable's current session history step.
  413. auto step = current_session_history_step();
  414. // 2. Return the result of applying the history step step to traversable given true, false, null, null, and null.
  415. // FIXME: Pass true, false, null, null, and null as arguments.
  416. apply_the_history_step(step);
  417. }
  418. void TraversableNavigable::apply_the_push_or_replace_history_step(int step)
  419. {
  420. // 1. Return the result of applying the history step step to traversable given false, false, null, null, and null.
  421. // FIXME: Pass false, false, null, null, and null as arguments.
  422. // FIXME: Return result of history application.
  423. apply_the_history_step(step);
  424. }
  425. // https://html.spec.whatwg.org/multipage/document-sequences.html#close-a-top-level-traversable
  426. void TraversableNavigable::close_top_level_traversable()
  427. {
  428. VERIFY(is_top_level_traversable());
  429. // 1. Let toUnload be traversable's active document's inclusive descendant navigables.
  430. auto to_unload = active_document()->inclusive_descendant_navigables();
  431. // FIXME: 2. If the result of checking if unloading is user-canceled for toUnload is true, then return.
  432. // 3. Unload the active documents of each of toUnload.
  433. for (auto navigable : to_unload) {
  434. navigable->active_document()->unload();
  435. }
  436. // 4. Destroy traversable.
  437. destroy_top_level_traversable();
  438. }
  439. // https://html.spec.whatwg.org/multipage/document-sequences.html#destroy-a-top-level-traversable
  440. void TraversableNavigable::destroy_top_level_traversable()
  441. {
  442. VERIFY(is_top_level_traversable());
  443. // 1. Let browsingContext be traversable's active browsing context.
  444. auto browsing_context = active_browsing_context();
  445. // 2. For each historyEntry in traversable's session history entries:
  446. for (auto& history_entry : m_session_history_entries) {
  447. // 1. Let document be historyEntry's document.
  448. auto document = history_entry->document_state->document();
  449. // 2. If document is not null, then destroy document.
  450. if (document)
  451. document->destroy();
  452. }
  453. // 3. Remove browsingContext.
  454. browsing_context->remove();
  455. // FIXME: 4. Remove traversable from the user interface (e.g., close or hide its tab in a tabbed browser).
  456. // 5. Remove traversable from the user agent's top-level traversable set.
  457. user_agent_top_level_traversable_set().remove(this);
  458. }
  459. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#finalize-a-same-document-navigation
  460. void finalize_a_same_document_navigation(JS::NonnullGCPtr<TraversableNavigable> traversable, JS::NonnullGCPtr<Navigable> target_navigable, JS::NonnullGCPtr<SessionHistoryEntry> target_entry, JS::GCPtr<SessionHistoryEntry> entry_to_replace)
  461. {
  462. // NOTE: This is not in the spec but we should not navigate destroyed navigable.
  463. if (target_navigable->has_been_destroyed())
  464. return;
  465. // FIXME: 1. Assert: this is running on traversable's session history traversal queue.
  466. // 2. If targetNavigable's active session history entry is not targetEntry, then return.
  467. if (target_navigable->active_session_history_entry() != target_entry) {
  468. return;
  469. }
  470. // 3. Let targetStep be null.
  471. Optional<int> target_step;
  472. // 4. Let targetEntries be the result of getting session history entries for targetNavigable.
  473. auto& target_entries = target_navigable->get_session_history_entries();
  474. // 5. If entryToReplace is null, then:
  475. if (!entry_to_replace) {
  476. // 1. Clear the forward session history of traversable.
  477. traversable->clear_the_forward_session_history();
  478. // 2. Set targetStep to traversable's current session history step + 1.
  479. target_step = traversable->current_session_history_step() + 1;
  480. // 3. Set targetEntry's step to targetStep.
  481. target_entry->step = *target_step;
  482. // 4. Append targetEntry to targetEntries.
  483. target_entries.append(target_entry);
  484. } else {
  485. // 1. Replace entryToReplace with targetEntry in targetEntries.
  486. *(target_entries.find(*entry_to_replace)) = target_entry;
  487. // 2. Set targetEntry's step to entryToReplace's step.
  488. target_entry->step = entry_to_replace->step;
  489. // 3. Set targetStep to traversable's current session history step.
  490. target_step = traversable->current_session_history_step();
  491. }
  492. // 6. Apply the push/replace history step targetStep to traversable.
  493. traversable->apply_the_push_or_replace_history_step(*target_step);
  494. }
  495. // https://html.spec.whatwg.org/multipage/interaction.html#system-visibility-state
  496. void TraversableNavigable::set_system_visibility_state(VisibilityState visibility_state)
  497. {
  498. if (m_system_visibility_state == visibility_state)
  499. return;
  500. m_system_visibility_state = visibility_state;
  501. // When a user-agent determines that the system visibility state for
  502. // traversable navigable traversable has changed to newState, it must run the following steps:
  503. // 1. Let navigables be the inclusive descendant navigables of traversable.
  504. // FIXME: Spec bug: https://github.com/whatwg/html/issues/9758
  505. VERIFY(active_document());
  506. auto navigables = active_document()->inclusive_descendant_navigables();
  507. // 2. For each navigable of navigables:
  508. for (auto& navigable : navigables) {
  509. // 1. Let document be navigable's active document.
  510. auto document = navigable->active_document();
  511. VERIFY(document);
  512. // 2. Queue a global task on the user interaction task source given document's relevant global object
  513. // to update the visibility state of document with newState.
  514. queue_global_task(Task::Source::UserInteraction, relevant_global_object(*document), [visibility_state, document] {
  515. document->update_the_visibility_state(visibility_state);
  516. });
  517. }
  518. }
  519. }