BrowsingContext.cpp 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789
  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/ElementFactory.h>
  9. #include <LibWeb/DOM/Event.h>
  10. #include <LibWeb/DOM/HTMLCollection.h>
  11. #include <LibWeb/DOM/Range.h>
  12. #include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
  13. #include <LibWeb/HTML/BrowsingContext.h>
  14. #include <LibWeb/HTML/BrowsingContextGroup.h>
  15. #include <LibWeb/HTML/CrossOrigin/CrossOriginOpenerPolicy.h>
  16. #include <LibWeb/HTML/DocumentState.h>
  17. #include <LibWeb/HTML/EventLoop/EventLoop.h>
  18. #include <LibWeb/HTML/HTMLAnchorElement.h>
  19. #include <LibWeb/HTML/HTMLDocument.h>
  20. #include <LibWeb/HTML/HTMLInputElement.h>
  21. #include <LibWeb/HTML/NavigableContainer.h>
  22. #include <LibWeb/HTML/RemoteBrowsingContext.h>
  23. #include <LibWeb/HTML/SandboxingFlagSet.h>
  24. #include <LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.h>
  25. #include <LibWeb/HTML/TraversableNavigable.h>
  26. #include <LibWeb/HTML/Window.h>
  27. #include <LibWeb/HTML/WindowProxy.h>
  28. #include <LibWeb/HighResolutionTime/TimeOrigin.h>
  29. #include <LibWeb/Infra/Strings.h>
  30. #include <LibWeb/Layout/BreakNode.h>
  31. #include <LibWeb/Layout/TextNode.h>
  32. #include <LibWeb/Layout/Viewport.h>
  33. #include <LibWeb/Namespace.h>
  34. #include <LibWeb/Page/Page.h>
  35. #include <LibWeb/URL/URL.h>
  36. namespace Web::HTML {
  37. // https://html.spec.whatwg.org/multipage/urls-and-fetching.html#matches-about:blank
  38. bool url_matches_about_blank(AK::URL const& url)
  39. {
  40. // 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.
  41. return url.scheme() == "about"sv
  42. && url.serialize_path() == "blank"sv
  43. && url.raw_username().is_empty()
  44. && url.raw_password().is_empty()
  45. && url.host().has<Empty>();
  46. }
  47. // https://html.spec.whatwg.org/multipage/document-sequences.html#determining-the-origin
  48. HTML::Origin determine_the_origin(AK::URL const& url, SandboxingFlagSet sandbox_flags, Optional<HTML::Origin> source_origin)
  49. {
  50. // 1. If sandboxFlags has its sandboxed origin browsing context flag set, then return a new opaque origin.
  51. if (has_flag(sandbox_flags, SandboxingFlagSet::SandboxedOrigin)) {
  52. return HTML::Origin {};
  53. }
  54. // FIXME: 2. If url is null, then return a new opaque origin.
  55. // FIXME: There appears to be no way to get a null URL here, so it might be a spec bug.
  56. // 3. If url is about:srcdoc, then:
  57. if (url == "about:srcdoc"sv) {
  58. // 1. Assert: sourceOrigin is non-null.
  59. VERIFY(source_origin.has_value());
  60. // 2. Return sourceOrigin.
  61. return source_origin.release_value();
  62. }
  63. // 4. If url matches about:blank and sourceOrigin is non-null, then return sourceOrigin.
  64. if (url_matches_about_blank(url) && source_origin.has_value())
  65. return source_origin.release_value();
  66. // 5. Return url's origin.
  67. return URL::url_origin(url);
  68. }
  69. // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-auxiliary-browsing-context
  70. WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext::create_a_new_auxiliary_browsing_context_and_document(Page& page, JS::NonnullGCPtr<HTML::BrowsingContext> opener)
  71. {
  72. // 1. Let openerTopLevelBrowsingContext be opener's top-level traversable's active browsing context.
  73. auto opener_top_level_browsing_context = opener->top_level_traversable()->active_browsing_context();
  74. // 2. Let group be openerTopLevelBrowsingContext's group.
  75. auto group = opener_top_level_browsing_context->group();
  76. // 3. Assert: group is non-null, as navigating invokes this directly.
  77. VERIFY(group);
  78. // 4. Set browsingContext and document be the result of creating a new browsing context and document with opener's active document, null, and group.
  79. auto [browsing_context, document] = TRY(create_a_new_browsing_context_and_document(page, opener->active_document(), nullptr, *group));
  80. // FIXME: 5. Set browsingContext's is auxiliary to true.
  81. // 6. Append browsingContext to group.
  82. group->append(browsing_context);
  83. // 7. Set browsingContext's opener browsing context to opener.
  84. browsing_context->set_opener_browsing_context(opener);
  85. // FIXME: 8. Set browsingContext's virtual browsing context group ID to openerTopLevelBrowsingContext's virtual browsing context group ID.
  86. // FIXME: 9. Set browsingContext's opener origin at creation to opener's active document's origin.
  87. // 10. Return browsingContext and document.
  88. return BrowsingContext::BrowsingContextAndDocument { browsing_context, document };
  89. }
  90. // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-browsing-context
  91. WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext::create_a_new_browsing_context_and_document(Page& page, JS::GCPtr<DOM::Document> creator, JS::GCPtr<DOM::Element> embedder, JS::NonnullGCPtr<BrowsingContextGroup> group)
  92. {
  93. auto& vm = group->vm();
  94. // 1. Let browsingContext be a new browsing context.
  95. JS::NonnullGCPtr<BrowsingContext> browsing_context = *vm.heap().allocate_without_realm<BrowsingContext>(page, nullptr);
  96. // 2. Let unsafeContextCreationTime be the unsafe shared current time.
  97. [[maybe_unused]] auto unsafe_context_creation_time = HighResolutionTime::unsafe_shared_current_time();
  98. // 3. Let creatorOrigin be null.
  99. Optional<Origin> creator_origin = {};
  100. // FIXME: This algorithm needs re-aligned with the spec
  101. Optional<AK::URL> creator_base_url = {};
  102. // 4. If creator is non-null, then:
  103. if (creator) {
  104. // 1. Set creatorOrigin to creator's origin.
  105. creator_origin = creator->origin();
  106. // FIXME: This algorithm needs re-aligned with the spec
  107. creator_base_url = creator->base_url();
  108. // FIXME: 2. Set browsingContext's creator base URL to an algorithm which returns creator's base URL.
  109. // FIXME: 3. Set browsingContext's virtual browsing context group ID to creator's browsing context's top-level browsing context's virtual browsing context group ID.
  110. }
  111. // FIXME: 5. Let sandboxFlags be the result of determining the creation sandboxing flags given browsingContext and embedder.
  112. SandboxingFlagSet sandbox_flags = {};
  113. // 6. Let origin be the result of determining the origin given about:blank, sandboxFlags, and creatorOrigin.
  114. auto origin = determine_the_origin(AK::URL("about:blank"sv), sandbox_flags, creator_origin);
  115. // FIXME: 7. Let permissionsPolicy be the result of creating a permissions policy given browsingContext and origin. [PERMISSIONSPOLICY]
  116. // FIXME: 8. Let agent be the result of obtaining a similar-origin window agent given origin, group, and false.
  117. JS::GCPtr<Window> window;
  118. // 9. Let realm execution context be the result of creating a new JavaScript realm given agent and the following customizations:
  119. auto realm_execution_context = Bindings::create_a_new_javascript_realm(
  120. Bindings::main_thread_vm(),
  121. [&](JS::Realm& realm) -> JS::Object* {
  122. auto window_proxy = realm.heap().allocate<WindowProxy>(realm, realm);
  123. browsing_context->set_window_proxy(window_proxy);
  124. // - For the global object, create a new Window object.
  125. window = Window::create(realm);
  126. return window.ptr();
  127. },
  128. [&](JS::Realm&) -> JS::Object* {
  129. // - For the global this binding, use browsingContext's WindowProxy object.
  130. return browsing_context->window_proxy();
  131. });
  132. // 10. Let topLevelCreationURL be about:blank if embedder is null; otherwise embedder's relevant settings object's top-level creation URL.
  133. auto top_level_creation_url = !embedder ? AK::URL("about:blank") : relevant_settings_object(*embedder).top_level_creation_url;
  134. // 11. Let topLevelOrigin be origin if embedder is null; otherwise embedder's relevant settings object's top-level origin.
  135. auto top_level_origin = !embedder ? origin : relevant_settings_object(*embedder).origin();
  136. // 12. Set up a window environment settings object with about:blank, realm execution context, null, topLevelCreationURL, and topLevelOrigin.
  137. WindowEnvironmentSettingsObject::setup(
  138. AK::URL("about:blank"),
  139. move(realm_execution_context),
  140. {},
  141. top_level_creation_url,
  142. top_level_origin);
  143. // 13. Let loadTimingInfo be a new document load timing info with its navigation start time set to the result of calling
  144. // coarsen time with unsafeContextCreationTime and the new environment settings object's cross-origin isolated capability.
  145. auto load_timing_info = DOM::DocumentLoadTimingInfo();
  146. load_timing_info.navigation_start_time = HighResolutionTime::coarsen_time(
  147. unsafe_context_creation_time,
  148. verify_cast<WindowEnvironmentSettingsObject>(Bindings::host_defined_environment_settings_object(window->realm())).cross_origin_isolated_capability() == CanUseCrossOriginIsolatedAPIs::Yes);
  149. // 14. Let document be a new Document, with:
  150. auto document = HTML::HTMLDocument::create(window->realm());
  151. // Non-standard
  152. window->set_associated_document(*document);
  153. // type: "html"
  154. document->set_document_type(DOM::Document::Type::HTML);
  155. // content type: "text/html"
  156. document->set_content_type("text/html"_string);
  157. // mode: "quirks"
  158. document->set_quirks_mode(DOM::QuirksMode::Yes);
  159. // origin: origin
  160. document->set_origin(origin);
  161. // browsing context: browsingContext
  162. document->set_browsing_context(browsing_context);
  163. // FIXME: permissions policy: permissionsPolicy
  164. // FIXME: active sandboxing flag set: sandboxFlags
  165. // load timing info: loadTimingInfo
  166. document->set_load_timing_info(load_timing_info);
  167. // is initial about:blank: true
  168. document->set_is_initial_about_blank(true);
  169. // about base URL: creatorBaseURL
  170. document->set_about_base_url(creator_base_url);
  171. // 15. If creator is non-null, then:
  172. if (creator) {
  173. // 1. Set document's referrer to the serialization of creator's URL.
  174. document->set_referrer(creator->url().serialize());
  175. // FIXME: 2. Set document's policy container to a clone of creator's policy container.
  176. // 3. If creator's origin is same origin with creator's relevant settings object's top-level origin,
  177. if (creator->origin().is_same_origin(creator->relevant_settings_object().top_level_origin)) {
  178. // then set document's cross-origin opener policy to creator's browsing context's top-level browsing context's active document's cross-origin opener policy.
  179. VERIFY(creator->browsing_context());
  180. VERIFY(creator->browsing_context()->top_level_browsing_context()->active_document());
  181. document->set_cross_origin_opener_policy(creator->browsing_context()->top_level_browsing_context()->active_document()->cross_origin_opener_policy());
  182. }
  183. }
  184. // 16. Assert: document's URL and document's relevant settings object's creation URL are about:blank.
  185. VERIFY(document->url() == "about:blank"sv);
  186. VERIFY(document->relevant_settings_object().creation_url == "about:blank"sv);
  187. // 17. Mark document as ready for post-load tasks.
  188. document->set_ready_for_post_load_tasks(true);
  189. // 18. Ensure that document has a single child html node, which itself has two empty child nodes: a head element, and a body element.
  190. auto html_node = TRY(DOM::create_element(document, HTML::TagNames::html, Namespace::HTML));
  191. auto head_element = TRY(DOM::create_element(document, HTML::TagNames::head, Namespace::HTML));
  192. TRY(html_node->append_child(head_element));
  193. auto body_element = TRY(DOM::create_element(document, HTML::TagNames::body, Namespace::HTML));
  194. TRY(html_node->append_child(body_element));
  195. TRY(document->append_child(html_node));
  196. // 19. Make active document.
  197. document->make_active();
  198. // 20. Completely finish loading document.
  199. document->completely_finish_loading();
  200. // 21. Return browsingContext and document.
  201. return BrowsingContext::BrowsingContextAndDocument { browsing_context, document };
  202. }
  203. BrowsingContext::BrowsingContext(Page& page, HTML::NavigableContainer* container)
  204. : m_page(page)
  205. , m_event_handler({}, *this)
  206. , m_container(container)
  207. {
  208. m_cursor_blink_timer = Core::Timer::create_repeating(500, [this] {
  209. if (!is_focused_context())
  210. return;
  211. if (m_cursor_position.node() && m_cursor_position.node()->layout_node()) {
  212. m_cursor_blink_state = !m_cursor_blink_state;
  213. m_cursor_position.node()->layout_node()->set_needs_display();
  214. }
  215. }).release_value_but_fixme_should_propagate_errors();
  216. }
  217. BrowsingContext::~BrowsingContext() = default;
  218. void BrowsingContext::visit_edges(Cell::Visitor& visitor)
  219. {
  220. Base::visit_edges(visitor);
  221. for (auto& entry : m_session_history)
  222. visitor.visit(entry);
  223. visitor.visit(m_container);
  224. visitor.visit(m_window_proxy);
  225. visitor.visit(m_opener_browsing_context);
  226. visitor.visit(m_group);
  227. visitor.visit(m_parent);
  228. visitor.visit(m_first_child);
  229. visitor.visit(m_last_child);
  230. visitor.visit(m_next_sibling);
  231. visitor.visit(m_previous_sibling);
  232. }
  233. // https://html.spec.whatwg.org/multipage/document-sequences.html#bc-traversable
  234. JS::NonnullGCPtr<HTML::TraversableNavigable> BrowsingContext::top_level_traversable() const
  235. {
  236. // A browsing context's top-level traversable is its active document's node navigable's top-level traversable.
  237. auto traversable = active_document()->navigable()->top_level_traversable();
  238. VERIFY(traversable);
  239. VERIFY(traversable->is_top_level_traversable());
  240. return *traversable;
  241. }
  242. void BrowsingContext::did_edit(Badge<EditEventHandler>)
  243. {
  244. reset_cursor_blink_cycle();
  245. if (m_cursor_position.node() && is<DOM::Text>(*m_cursor_position.node())) {
  246. auto& text_node = static_cast<DOM::Text&>(*m_cursor_position.node());
  247. if (auto* text_node_owner = text_node.editable_text_node_owner())
  248. text_node_owner->did_edit_text_node({});
  249. }
  250. }
  251. void BrowsingContext::reset_cursor_blink_cycle()
  252. {
  253. m_cursor_blink_state = true;
  254. m_cursor_blink_timer->restart();
  255. if (m_cursor_position.is_valid() && m_cursor_position.node()->layout_node())
  256. m_cursor_position.node()->layout_node()->set_needs_display();
  257. }
  258. // https://html.spec.whatwg.org/multipage/browsers.html#top-level-browsing-context
  259. bool BrowsingContext::is_top_level() const
  260. {
  261. // 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.
  262. return !parent();
  263. }
  264. bool BrowsingContext::is_focused_context() const
  265. {
  266. return m_page && &m_page->focused_context() == this;
  267. }
  268. void BrowsingContext::scroll_to(CSSPixelPoint position)
  269. {
  270. // NOTE: Scrolling to a position requires up-to-date layout *unless* we're scrolling to (0, 0)
  271. // as (0, 0) is always guaranteed to be a valid scroll position.
  272. if (!position.is_zero()) {
  273. if (active_document())
  274. active_document()->update_layout();
  275. }
  276. if (m_page && this == &m_page->top_level_browsing_context())
  277. m_page->client().page_did_request_scroll_to(position);
  278. }
  279. JS::GCPtr<BrowsingContext> BrowsingContext::top_level_browsing_context() const
  280. {
  281. auto const* start = this;
  282. // 1. If start's active document is not fully active, then return null.
  283. if (!start->active_document()->is_fully_active()) {
  284. return nullptr;
  285. }
  286. // 2. Let navigable be start's active document's node navigable.
  287. auto navigable = start->active_document()->navigable();
  288. // 3. While navigable's parent is not null, set navigable to navigable's parent.
  289. while (navigable->parent()) {
  290. navigable = navigable->parent();
  291. }
  292. // 4. Return navigable's active browsing context.
  293. return navigable->active_browsing_context();
  294. }
  295. CSSPixelRect BrowsingContext::to_top_level_rect(CSSPixelRect const& a_rect)
  296. {
  297. auto rect = a_rect;
  298. rect.set_location(to_top_level_position(a_rect.location()));
  299. return rect;
  300. }
  301. CSSPixelPoint BrowsingContext::to_top_level_position(CSSPixelPoint a_position)
  302. {
  303. auto position = a_position;
  304. for (auto ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
  305. if (ancestor->is_top_level())
  306. break;
  307. if (!ancestor->container())
  308. return {};
  309. if (!ancestor->container()->layout_node())
  310. return {};
  311. position.translate_by(ancestor->container()->layout_node()->box_type_agnostic_position());
  312. }
  313. return position;
  314. }
  315. void BrowsingContext::set_cursor_position(DOM::Position position)
  316. {
  317. if (m_cursor_position == position)
  318. return;
  319. if (m_cursor_position.node() && m_cursor_position.node()->layout_node())
  320. m_cursor_position.node()->layout_node()->set_needs_display();
  321. m_cursor_position = move(position);
  322. if (m_cursor_position.node() && m_cursor_position.node()->layout_node())
  323. m_cursor_position.node()->layout_node()->set_needs_display();
  324. reset_cursor_blink_cycle();
  325. }
  326. static DeprecatedString visible_text_in_range(DOM::Range const& range)
  327. {
  328. // NOTE: This is an adaption of Range stringification, but we skip over DOM nodes that don't have a corresponding layout node.
  329. StringBuilder builder;
  330. if (range.start_container() == range.end_container() && is<DOM::Text>(*range.start_container())) {
  331. if (!range.start_container()->layout_node())
  332. return ""sv;
  333. return MUST(static_cast<DOM::Text const&>(*range.start_container()).data().substring_from_byte_offset(range.start_offset(), range.end_offset() - range.start_offset())).to_deprecated_string();
  334. }
  335. if (is<DOM::Text>(*range.start_container()) && range.start_container()->layout_node())
  336. builder.append(static_cast<DOM::Text const&>(*range.start_container()).data().bytes_as_string_view().substring_view(range.start_offset()));
  337. for (DOM::Node const* node = range.start_container(); node != range.end_container()->next_sibling(); node = node->next_in_pre_order()) {
  338. if (is<DOM::Text>(*node) && range.contains_node(*node) && node->layout_node())
  339. builder.append(static_cast<DOM::Text const&>(*node).data());
  340. }
  341. if (is<DOM::Text>(*range.end_container()) && range.end_container()->layout_node())
  342. builder.append(static_cast<DOM::Text const&>(*range.end_container()).data().bytes_as_string_view().substring_view(0, range.end_offset()));
  343. return builder.to_deprecated_string();
  344. }
  345. DeprecatedString BrowsingContext::selected_text() const
  346. {
  347. auto* document = active_document();
  348. if (!document)
  349. return ""sv;
  350. auto selection = const_cast<DOM::Document&>(*document).get_selection();
  351. auto range = selection->range();
  352. if (!range)
  353. return ""sv;
  354. return visible_text_in_range(*range);
  355. }
  356. void BrowsingContext::select_all()
  357. {
  358. auto* document = active_document();
  359. if (!document)
  360. return;
  361. auto* body = document->body();
  362. if (!body)
  363. return;
  364. auto selection = document->get_selection();
  365. if (!selection)
  366. return;
  367. (void)selection->select_all_children(*document->body());
  368. }
  369. bool BrowsingContext::increment_cursor_position_offset()
  370. {
  371. if (!m_cursor_position.increment_offset())
  372. return false;
  373. reset_cursor_blink_cycle();
  374. return true;
  375. }
  376. bool BrowsingContext::decrement_cursor_position_offset()
  377. {
  378. if (!m_cursor_position.decrement_offset())
  379. return false;
  380. reset_cursor_blink_cycle();
  381. return true;
  382. }
  383. // https://html.spec.whatwg.org/multipage/interaction.html#currently-focused-area-of-a-top-level-browsing-context
  384. JS::GCPtr<DOM::Node> BrowsingContext::currently_focused_area()
  385. {
  386. // 1. If topLevelBC does not have system focus, then return null.
  387. if (!is_focused_context())
  388. return nullptr;
  389. // 2. Let candidate be topLevelBC's active document.
  390. auto* candidate = active_document();
  391. // 3. While candidate's focused area is a browsing context container with a non-null nested browsing context:
  392. // set candidate to the active document of that browsing context container's nested browsing context.
  393. while (candidate->focused_element()
  394. && is<HTML::NavigableContainer>(candidate->focused_element())
  395. && static_cast<HTML::NavigableContainer&>(*candidate->focused_element()).nested_browsing_context()) {
  396. candidate = static_cast<HTML::NavigableContainer&>(*candidate->focused_element()).nested_browsing_context()->active_document();
  397. }
  398. // 4. If candidate's focused area is non-null, set candidate to candidate's focused area.
  399. if (candidate->focused_element()) {
  400. // NOTE: We return right away here instead of assigning to candidate,
  401. // since that would require compromising type safety.
  402. return candidate->focused_element();
  403. }
  404. // 5. Return candidate.
  405. return candidate;
  406. }
  407. // https://html.spec.whatwg.org/#the-rules-for-choosing-a-browsing-context-given-a-browsing-context-name
  408. BrowsingContext::ChosenBrowsingContext BrowsingContext::choose_a_browsing_context(StringView name, TokenizedFeature::NoOpener no_opener, ActivateTab activate_tab)
  409. {
  410. // The rules for choosing a browsing context, given a browsing context name name, a browsing context current, and
  411. // a boolean noopener are as follows:
  412. JS::GCPtr<AbstractBrowsingContext> matching_name_in_tree = nullptr;
  413. top_level_browsing_context()->for_each_in_subtree([&](auto& context) {
  414. if (context.name() == name) {
  415. matching_name_in_tree = &context;
  416. return IterationDecision::Break;
  417. }
  418. return IterationDecision::Continue;
  419. });
  420. // 1. Let chosen be null.
  421. JS::GCPtr<AbstractBrowsingContext> chosen = nullptr;
  422. // 2. Let windowType be "existing or none".
  423. auto window_type = WindowType::ExistingOrNone;
  424. // 3. Let sandboxingFlagSet be current's active document's active sandboxing flag set.
  425. auto sandboxing_flag_set = active_document()->active_sandboxing_flag_set();
  426. // 4. If name is the empty string or an ASCII case-insensitive match for "_self", then set chosen to current.
  427. if (name.is_empty() || Infra::is_ascii_case_insensitive_match(name, "_self"sv)) {
  428. chosen = this;
  429. }
  430. // 5. Otherwise, if name is an ASCII case-insensitive match for "_parent", set chosen to current's parent browsing
  431. // context, if any, and current otherwise.
  432. else if (Infra::is_ascii_case_insensitive_match(name, "_parent"sv)) {
  433. if (auto parent = this->parent())
  434. chosen = parent;
  435. else
  436. chosen = this;
  437. }
  438. // 6. Otherwise, if name is an ASCII case-insensitive match for "_top", set chosen to current's top-level browsing
  439. // context, if any, and current otherwise.
  440. else if (Infra::is_ascii_case_insensitive_match(name, "_top"sv)) {
  441. chosen = top_level_browsing_context();
  442. }
  443. // 7. Otherwise, if name is not an ASCII case-insensitive match for "_blank", there exists a browsing context
  444. // whose name is the same as name, current is familiar with that browsing context, and the user agent
  445. // determines that the two browsing contexts are related enough that it is ok if they reach each other,
  446. // set chosen to that browsing context. If there are multiple matching browsing contexts, the user agent
  447. // should set chosen to one in some arbitrary consistent manner, such as the most recently opened, most
  448. // recently focused, or more closely related.
  449. else if (!Infra::is_ascii_case_insensitive_match(name, "_blank"sv) && matching_name_in_tree) {
  450. chosen = matching_name_in_tree;
  451. } else {
  452. // 8. Otherwise, a new browsing context is being requested, and what happens depends on the user agent's
  453. // configuration and abilities — it is determined by the rules given for the first applicable option from
  454. // the following list:
  455. // --> If current's active window does not have transient activation and the user agent has been configured to
  456. // not show popups (i.e., the user agent has a "popup blocker" enabled)
  457. VERIFY(m_page);
  458. if (!active_window()->has_transient_activation() && m_page->should_block_pop_ups()) {
  459. // FIXME: The user agent may inform the user that a popup has been blocked.
  460. dbgln("Pop-up blocked!");
  461. }
  462. // --> If sandboxingFlagSet has the sandboxed auxiliary navigation browsing context flag set
  463. else if (has_flag(sandboxing_flag_set, SandboxingFlagSet::SandboxedAuxiliaryNavigation)) {
  464. // FIXME: The user agent may report to a developer console that a popup has been blocked.
  465. dbgln("Pop-up blocked!");
  466. }
  467. // --> If the user agent has been configured such that in this instance it will create a new browsing context
  468. else if (true) { // FIXME: When is this the case?
  469. // 1. Set windowType to "new and unrestricted".
  470. window_type = WindowType::NewAndUnrestricted;
  471. // 2. If current's top-level browsing context's active document's cross-origin opener policy's value is
  472. // "same-origin" or "same-origin-plus-COEP", then:
  473. 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) {
  474. // 1. Let currentDocument be current's active document.
  475. auto* current_document = top_level_browsing_context()->active_document();
  476. // 2. If currentDocument's origin is not same origin with currentDocument's relevant settings object's
  477. // top-level origin, then set noopener to true, name to "_blank", and windowType to "new with no opener".
  478. if (!current_document->origin().is_same_origin(current_document->relevant_settings_object().top_level_origin)) {
  479. no_opener = TokenizedFeature::NoOpener::Yes;
  480. name = "_blank"sv;
  481. window_type = WindowType::NewWithNoOpener;
  482. }
  483. }
  484. // 3. If noopener is true, then set chosen to the result of creating a new top-level browsing context.
  485. if (no_opener == TokenizedFeature::NoOpener::Yes) {
  486. auto handle = m_page->client().page_did_request_new_tab(activate_tab);
  487. chosen = RemoteBrowsingContext::create_a_new_remote_browsing_context(handle);
  488. }
  489. // 4. Otherwise:
  490. else {
  491. // 1. Set chosen to the result of creating a new auxiliary browsing context with current.
  492. // FIXME: We have no concept of auxiliary browsing context
  493. chosen = HTML::create_a_new_top_level_browsing_context_and_document(*m_page).release_value_but_fixme_should_propagate_errors().browsing_context;
  494. // 2. If sandboxingFlagSet's sandboxed navigation browsing context flag is set, then current must be
  495. // set as chosen's one permitted sandboxed navigator.
  496. // FIXME: We have no concept of one permitted sandboxed navigator
  497. }
  498. // 5. If sandboxingFlagSet's sandbox propagates to auxiliary browsing contexts flag is set, then all the
  499. // flags that are set in sandboxingFlagSet must be set in chosen's popup sandboxing flag set.
  500. // FIXME: Our BrowsingContexts do not have SandboxingFlagSets yet, only documents do
  501. // 6. If name is not an ASCII case-insensitive match for "_blank", then set chosen's name to name.
  502. if (!Infra::is_ascii_case_insensitive_match(name, "_blank"sv))
  503. chosen->set_name(String::from_utf8(name).release_value_but_fixme_should_propagate_errors());
  504. }
  505. // --> If the user agent has been configured such that in this instance t will reuse current
  506. else if (false) { // FIXME: When is this the case?
  507. // Set chosen to current.
  508. chosen = *this;
  509. }
  510. // --> If the user agent has been configured such that in this instance it will not find a browsing context
  511. else if (false) { // FIXME: When is this the case?
  512. // Do nothing.
  513. }
  514. }
  515. // 9. Return chosen and windowType.
  516. return { chosen.ptr(), window_type };
  517. }
  518. // https://html.spec.whatwg.org/multipage/dom.html#still-on-its-initial-about:blank-document
  519. bool BrowsingContext::still_on_its_initial_about_blank_document() const
  520. {
  521. // A browsing context browsingContext is still on its initial about:blank Document
  522. // if browsingContext's session history's size is 1
  523. // and browsingContext's session history[0]'s document's is initial about:blank is true.
  524. return m_session_history.size() == 1
  525. && m_session_history[0]->document_state->document()
  526. && m_session_history[0]->document_state->document()->is_initial_about_blank();
  527. }
  528. DOM::Document const* BrowsingContext::active_document() const
  529. {
  530. auto* window = active_window();
  531. if (!window)
  532. return nullptr;
  533. return &window->associated_document();
  534. }
  535. DOM::Document* BrowsingContext::active_document()
  536. {
  537. auto* window = active_window();
  538. if (!window)
  539. return nullptr;
  540. return &window->associated_document();
  541. }
  542. // https://html.spec.whatwg.org/multipage/browsers.html#active-window
  543. HTML::Window* BrowsingContext::active_window()
  544. {
  545. return m_window_proxy->window();
  546. }
  547. // https://html.spec.whatwg.org/multipage/browsers.html#active-window
  548. HTML::Window const* BrowsingContext::active_window() const
  549. {
  550. return m_window_proxy->window();
  551. }
  552. HTML::WindowProxy* BrowsingContext::window_proxy()
  553. {
  554. return m_window_proxy.ptr();
  555. }
  556. HTML::WindowProxy const* BrowsingContext::window_proxy() const
  557. {
  558. return m_window_proxy.ptr();
  559. }
  560. void BrowsingContext::set_window_proxy(JS::GCPtr<WindowProxy> window_proxy)
  561. {
  562. m_window_proxy = move(window_proxy);
  563. }
  564. BrowsingContextGroup* BrowsingContext::group()
  565. {
  566. return m_group;
  567. }
  568. void BrowsingContext::set_group(BrowsingContextGroup* group)
  569. {
  570. m_group = group;
  571. }
  572. // https://html.spec.whatwg.org/multipage/browsers.html#bcg-remove
  573. void BrowsingContext::remove()
  574. {
  575. // 1. Assert: browsingContext's group is non-null, because a browsing context only gets discarded once.
  576. VERIFY(group());
  577. // 2. Let group be browsingContext's group.
  578. JS::NonnullGCPtr<BrowsingContextGroup> group = *this->group();
  579. // 3. Set browsingContext's group to null.
  580. set_group(nullptr);
  581. // 4. Remove browsingContext from group's browsing context set.
  582. group->browsing_context_set().remove(*this);
  583. // 5. If group's browsing context set is empty, then remove group from the user agent's browsing context group set.
  584. // NOTE: This is done by ~BrowsingContextGroup() when the refcount reaches 0.
  585. }
  586. // https://html.spec.whatwg.org/multipage/origin.html#one-permitted-sandboxed-navigator
  587. BrowsingContext const* BrowsingContext::the_one_permitted_sandboxed_navigator() const
  588. {
  589. // FIXME: Implement this.
  590. return nullptr;
  591. }
  592. void BrowsingContext::append_child(JS::NonnullGCPtr<BrowsingContext> child)
  593. {
  594. VERIFY(!child->m_parent);
  595. if (m_last_child)
  596. m_last_child->m_next_sibling = child;
  597. child->m_previous_sibling = m_last_child;
  598. child->m_parent = this;
  599. m_last_child = child;
  600. if (!m_first_child)
  601. m_first_child = m_last_child;
  602. }
  603. void BrowsingContext::remove_child(JS::NonnullGCPtr<BrowsingContext> child)
  604. {
  605. VERIFY(child->m_parent.ptr() == this);
  606. if (m_first_child == child)
  607. m_first_child = child->m_next_sibling;
  608. if (m_last_child == child)
  609. m_last_child = child->m_previous_sibling;
  610. if (child->m_next_sibling)
  611. child->m_next_sibling->m_previous_sibling = child->m_previous_sibling;
  612. if (child->m_previous_sibling)
  613. child->m_previous_sibling->m_next_sibling = child->m_next_sibling;
  614. child->m_next_sibling = nullptr;
  615. child->m_previous_sibling = nullptr;
  616. child->m_parent = nullptr;
  617. }
  618. JS::GCPtr<BrowsingContext> BrowsingContext::first_child() const
  619. {
  620. return m_first_child;
  621. }
  622. JS::GCPtr<BrowsingContext> BrowsingContext::next_sibling() const
  623. {
  624. return m_next_sibling;
  625. }
  626. bool BrowsingContext::is_ancestor_of(BrowsingContext const& other) const
  627. {
  628. for (auto ancestor = other.parent(); ancestor; ancestor = ancestor->parent()) {
  629. if (ancestor == this)
  630. return true;
  631. }
  632. return false;
  633. }
  634. // https://html.spec.whatwg.org/multipage/browsing-the-web.html#snapshotting-target-snapshot-params
  635. SandboxingFlagSet determine_the_creation_sandboxing_flags(BrowsingContext const&, JS::GCPtr<DOM::Element>)
  636. {
  637. // FIXME: Populate this once we have the proper flag sets on BrowsingContext
  638. return {};
  639. }
  640. }