Window.cpp 68 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572
  1. /*
  2. * Copyright (c) 2020-2022, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021-2022, Sam Atkins <atkinssj@serenityos.org>
  4. * Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/Base64.h>
  9. #include <AK/DeprecatedString.h>
  10. #include <AK/GenericLexer.h>
  11. #include <AK/Utf8View.h>
  12. #include <LibJS/Runtime/AbstractOperations.h>
  13. #include <LibJS/Runtime/Accessor.h>
  14. #include <LibJS/Runtime/Completion.h>
  15. #include <LibJS/Runtime/Error.h>
  16. #include <LibJS/Runtime/FunctionObject.h>
  17. #include <LibJS/Runtime/GlobalEnvironment.h>
  18. #include <LibJS/Runtime/NativeFunction.h>
  19. #include <LibJS/Runtime/Shape.h>
  20. #include <LibTextCodec/Decoder.h>
  21. #include <LibWeb/Bindings/CSSNamespace.h>
  22. #include <LibWeb/Bindings/ExceptionOrUtils.h>
  23. #include <LibWeb/Bindings/Replaceable.h>
  24. #include <LibWeb/Bindings/WindowExposedInterfaces.h>
  25. #include <LibWeb/Bindings/WindowPrototype.h>
  26. #include <LibWeb/CSS/MediaQueryList.h>
  27. #include <LibWeb/CSS/Parser/Parser.h>
  28. #include <LibWeb/CSS/ResolvedCSSStyleDeclaration.h>
  29. #include <LibWeb/CSS/Screen.h>
  30. #include <LibWeb/Crypto/Crypto.h>
  31. #include <LibWeb/DOM/Document.h>
  32. #include <LibWeb/DOM/Event.h>
  33. #include <LibWeb/DOM/EventDispatcher.h>
  34. #include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
  35. #include <LibWeb/HTML/BrowsingContext.h>
  36. #include <LibWeb/HTML/EventHandler.h>
  37. #include <LibWeb/HTML/EventLoop/EventLoop.h>
  38. #include <LibWeb/HTML/Focus.h>
  39. #include <LibWeb/HTML/Location.h>
  40. #include <LibWeb/HTML/MessageEvent.h>
  41. #include <LibWeb/HTML/Navigator.h>
  42. #include <LibWeb/HTML/Origin.h>
  43. #include <LibWeb/HTML/PageTransitionEvent.h>
  44. #include <LibWeb/HTML/Scripting/ClassicScript.h>
  45. #include <LibWeb/HTML/Scripting/Environments.h>
  46. #include <LibWeb/HTML/Scripting/ExceptionReporter.h>
  47. #include <LibWeb/HTML/Storage.h>
  48. #include <LibWeb/HTML/Timer.h>
  49. #include <LibWeb/HTML/Window.h>
  50. #include <LibWeb/HTML/WindowProxy.h>
  51. #include <LibWeb/HighResolutionTime/Performance.h>
  52. #include <LibWeb/HighResolutionTime/TimeOrigin.h>
  53. #include <LibWeb/Infra/Base64.h>
  54. #include <LibWeb/Infra/CharacterTypes.h>
  55. #include <LibWeb/Layout/Viewport.h>
  56. #include <LibWeb/Page/Page.h>
  57. #include <LibWeb/RequestIdleCallback/IdleDeadline.h>
  58. #include <LibWeb/Selection/Selection.h>
  59. #include <LibWeb/WebAssembly/WebAssemblyObject.h>
  60. #include <LibWeb/WebIDL/AbstractOperations.h>
  61. namespace Web::HTML {
  62. // https://html.spec.whatwg.org/#run-the-animation-frame-callbacks
  63. void run_animation_frame_callbacks(DOM::Document& document, double)
  64. {
  65. // FIXME: Bring this closer to the spec.
  66. document.window().animation_frame_callback_driver().run();
  67. }
  68. class IdleCallback : public RefCounted<IdleCallback> {
  69. public:
  70. explicit IdleCallback(Function<JS::Completion(JS::NonnullGCPtr<RequestIdleCallback::IdleDeadline>)> handler, u32 handle)
  71. : m_handler(move(handler))
  72. , m_handle(handle)
  73. {
  74. }
  75. ~IdleCallback() = default;
  76. JS::Completion invoke(JS::NonnullGCPtr<RequestIdleCallback::IdleDeadline> deadline) { return m_handler(deadline); }
  77. u32 handle() const { return m_handle; }
  78. private:
  79. Function<JS::Completion(JS::NonnullGCPtr<RequestIdleCallback::IdleDeadline>)> m_handler;
  80. u32 m_handle { 0 };
  81. };
  82. WebIDL::ExceptionOr<JS::NonnullGCPtr<Window>> Window::create(JS::Realm& realm)
  83. {
  84. return MUST_OR_THROW_OOM(realm.heap().allocate<Window>(realm, realm));
  85. }
  86. Window::Window(JS::Realm& realm)
  87. : DOM::EventTarget(realm)
  88. {
  89. }
  90. void Window::visit_edges(JS::Cell::Visitor& visitor)
  91. {
  92. Base::visit_edges(visitor);
  93. visitor.visit(m_associated_document.ptr());
  94. visitor.visit(m_current_event.ptr());
  95. visitor.visit(m_performance.ptr());
  96. visitor.visit(m_screen.ptr());
  97. visitor.visit(m_location);
  98. visitor.visit(m_crypto);
  99. visitor.visit(m_navigator);
  100. for (auto& it : m_timers)
  101. visitor.visit(it.value.ptr());
  102. for (auto& plugin_object : m_pdf_viewer_plugin_objects)
  103. visitor.visit(plugin_object);
  104. for (auto& mime_type_object : m_pdf_viewer_mime_type_objects)
  105. visitor.visit(mime_type_object);
  106. }
  107. Window::~Window() = default;
  108. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#normalizing-the-feature-name
  109. static StringView normalize_feature_name(StringView name)
  110. {
  111. // For legacy reasons, there are some aliases of some feature names. To normalize a feature name name, switch on name:
  112. // "screenx"
  113. if (name == "screenx"sv) {
  114. // Return "left".
  115. return "left"sv;
  116. }
  117. // "screeny"
  118. else if (name == "screeny"sv) {
  119. // Return "top".
  120. return "top"sv;
  121. }
  122. // "innerwidth"
  123. else if (name == "innerwidth"sv) {
  124. // Return "width".
  125. return "width"sv;
  126. }
  127. // "innerheight"
  128. else if (name == "innerheight") {
  129. // Return "height".
  130. return "height"sv;
  131. }
  132. // Anything else
  133. else {
  134. // Return name.
  135. return name;
  136. }
  137. }
  138. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-window-open-features-tokenize
  139. static OrderedHashMap<DeprecatedString, DeprecatedString> tokenize_open_features(StringView features)
  140. {
  141. // 1. Let tokenizedFeatures be a new ordered map.
  142. OrderedHashMap<DeprecatedString, DeprecatedString> tokenized_features;
  143. // 2. Let position point at the first code point of features.
  144. GenericLexer lexer(features);
  145. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#feature-separator
  146. auto is_feature_separator = [](auto character) {
  147. return Infra::is_ascii_whitespace(character) || character == '=' || character == ',';
  148. };
  149. // 3. While position is not past the end of features:
  150. while (!lexer.is_eof()) {
  151. // 1. Let name be the empty string.
  152. DeprecatedString name;
  153. // 2. Let value be the empty string.
  154. DeprecatedString value;
  155. // 3. Collect a sequence of code points that are feature separators from features given position. This skips past leading separators before the name.
  156. lexer.ignore_while(is_feature_separator);
  157. // 4. Collect a sequence of code points that are not feature separators from features given position. Set name to the collected characters, converted to ASCII lowercase.
  158. name = lexer.consume_until(is_feature_separator).to_lowercase_string();
  159. // 5. Set name to the result of normalizing the feature name name.
  160. name = normalize_feature_name(name);
  161. // 6. While position is not past the end of features and the code point at position in features is not U+003D (=):
  162. // 1. If the code point at position in features is U+002C (,), or if it is not a feature separator, then break.
  163. // 2. Advance position by 1.
  164. lexer.ignore_while(Infra::is_ascii_whitespace);
  165. // 7. If the code point at position in features is a feature separator:
  166. // 1. While position is not past the end of features and the code point at position in features is a feature separator:
  167. // 1. If the code point at position in features is U+002C (,), then break.
  168. // 2. Advance position by 1.
  169. lexer.ignore_while([](auto character) { return Infra::is_ascii_whitespace(character) || character == '='; });
  170. // 2. Collect a sequence of code points that are not feature separators code points from features given position. Set value to the collected code points, converted to ASCII lowercase.
  171. value = lexer.consume_until(is_feature_separator).to_lowercase_string();
  172. // 8. If name is not the empty string, then set tokenizedFeatures[name] to value.
  173. if (!name.is_empty())
  174. tokenized_features.set(move(name), move(value));
  175. }
  176. // 4. Return tokenizedFeatures.
  177. return tokenized_features;
  178. }
  179. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-window-open-features-parse-boolean
  180. static bool parse_boolean_feature(StringView value)
  181. {
  182. // 1. If value is the empty string, then return true.
  183. if (value.is_empty())
  184. return true;
  185. // 2. If value is "yes", then return true.
  186. if (value == "yes"sv)
  187. return true;
  188. // 3. If value is "true", then return true.
  189. if (value == "true"sv)
  190. return true;
  191. // 4. Let parsed be the result of parsing value as an integer.
  192. auto parsed = value.to_int<i64>();
  193. // 5. If parsed is an error, then set it to 0.
  194. if (!parsed.has_value())
  195. parsed = 0;
  196. // 6. Return false if parsed is 0, and true otherwise.
  197. return *parsed != 0;
  198. }
  199. // https://html.spec.whatwg.org/multipage/window-object.html#popup-window-is-requested
  200. static bool check_if_a_popup_window_is_requested(OrderedHashMap<DeprecatedString, DeprecatedString> const& tokenized_features)
  201. {
  202. // 1. If tokenizedFeatures is empty, then return false.
  203. if (tokenized_features.is_empty())
  204. return false;
  205. // 2. If tokenizedFeatures["popup"] exists, then return the result of parsing tokenizedFeatures["popup"] as a boolean feature.
  206. if (auto popup_feature = tokenized_features.get("popup"sv); popup_feature.has_value())
  207. return parse_boolean_feature(*popup_feature);
  208. // https://html.spec.whatwg.org/multipage/window-object.html#window-feature-is-set
  209. auto check_if_a_window_feature_is_set = [&](StringView feature_name, bool default_value) {
  210. // 1. If tokenizedFeatures[featureName] exists, then return the result of parsing tokenizedFeatures[featureName] as a boolean feature.
  211. if (auto feature = tokenized_features.get(feature_name); feature.has_value())
  212. return parse_boolean_feature(*feature);
  213. // 2. Return defaultValue.
  214. return default_value;
  215. };
  216. // 3. Let location be the result of checking if a window feature is set, given tokenizedFeatures, "location", and false.
  217. auto location = check_if_a_window_feature_is_set("location"sv, false);
  218. // 4. Let toolbar be the result of checking if a window feature is set, given tokenizedFeatures, "toolbar", and false.
  219. auto toolbar = check_if_a_window_feature_is_set("toolbar"sv, false);
  220. // 5. If location and toolbar are both false, then return true.
  221. if (!location && !toolbar)
  222. return true;
  223. // 6. Let menubar be the result of checking if a window feature is set, given tokenizedFeatures, menubar", and false.
  224. auto menubar = check_if_a_window_feature_is_set("menubar"sv, false);
  225. // 7. If menubar is false, then return true.
  226. if (!menubar)
  227. return true;
  228. // 8. Let resizable be the result of checking if a window feature is set, given tokenizedFeatures, "resizable", and true.
  229. auto resizable = check_if_a_window_feature_is_set("resizable"sv, true);
  230. // 9. If resizable is false, then return true.
  231. if (!resizable)
  232. return true;
  233. // 10. Let scrollbars be the result of checking if a window feature is set, given tokenizedFeatures, "scrollbars", and false.
  234. auto scrollbars = check_if_a_window_feature_is_set("scrollbars"sv, false);
  235. // 11. If scrollbars is false, then return true.
  236. if (!scrollbars)
  237. return true;
  238. // 12. Let status be the result of checking if a window feature is set, given tokenizedFeatures, "status", and false.
  239. auto status = check_if_a_window_feature_is_set("status"sv, false);
  240. // 13. If status is false, then return true.
  241. if (!status)
  242. return true;
  243. // 14. Return false.
  244. return false;
  245. }
  246. // FIXME: This is based on the old 'browsing context' concept, which was replaced with 'navigable'
  247. // https://html.spec.whatwg.org/multipage/window-object.html#window-open-steps
  248. WebIDL::ExceptionOr<JS::GCPtr<HTML::WindowProxy>> Window::open_impl(StringView url, StringView target, StringView features)
  249. {
  250. auto& vm = this->vm();
  251. // 1. If the event loop's termination nesting level is nonzero, return null.
  252. if (HTML::main_thread_event_loop().termination_nesting_level() != 0)
  253. return nullptr;
  254. // 2. Let source browsing context be the entry global object's browsing context.
  255. auto* source_browsing_context = verify_cast<Window>(entry_global_object()).browsing_context();
  256. // 3. If target is the empty string, then set target to "_blank".
  257. if (target.is_empty())
  258. target = "_blank"sv;
  259. // 4. Let tokenizedFeatures be the result of tokenizing features.
  260. auto tokenized_features = tokenize_open_features(features);
  261. // 5. Let noopener and noreferrer be false.
  262. auto no_opener = false;
  263. auto no_referrer = false;
  264. // 6. If tokenizedFeatures["noopener"] exists, then:
  265. if (auto no_opener_feature = tokenized_features.get("noopener"sv); no_opener_feature.has_value()) {
  266. // 1. Set noopener to the result of parsing tokenizedFeatures["noopener"] as a boolean feature.
  267. no_opener = parse_boolean_feature(*no_opener_feature);
  268. // 2. Remove tokenizedFeatures["noopener"].
  269. tokenized_features.remove("noopener"sv);
  270. }
  271. // 7. If tokenizedFeatures["noreferrer"] exists, then:
  272. if (auto no_referrer_feature = tokenized_features.get("noreferrer"sv); no_referrer_feature.has_value()) {
  273. // 1. Set noreferrer to the result of parsing tokenizedFeatures["noreferrer"] as a boolean feature.
  274. no_referrer = parse_boolean_feature(*no_referrer_feature);
  275. // 2. Remove tokenizedFeatures["noreferrer"].
  276. tokenized_features.remove("noreferrer"sv);
  277. }
  278. // 8. If noreferrer is true, then set noopener to true.
  279. if (no_referrer)
  280. no_opener = true;
  281. // 9. Let target browsing context and windowType be the result of applying the rules for choosing a browsing context given target, source browsing context, and noopener.
  282. auto [target_browsing_context, window_type] = source_browsing_context->choose_a_browsing_context(target, no_opener);
  283. // 10. If target browsing context is null, then return null.
  284. if (target_browsing_context == nullptr)
  285. return nullptr;
  286. // 11. If windowType is either "new and unrestricted" or "new with no opener", then:
  287. if (window_type == BrowsingContext::WindowType::NewAndUnrestricted || window_type == BrowsingContext::WindowType::NewWithNoOpener) {
  288. // 1. Set the target browsing context's is popup to the result of checking if a popup window is requested, given tokenizedFeatures.
  289. target_browsing_context->set_is_popup(check_if_a_popup_window_is_requested(tokenized_features));
  290. // FIXME: 2. Set up browsing context features for target browsing context given tokenizedFeatures. [CSSOMVIEW]
  291. // NOTE: While this is not implemented yet, all of observable actions taken by this operation are optional (implementation-defined).
  292. // 3. Let urlRecord be the URL record about:blank.
  293. auto url_record = AK::URL("about:blank"sv);
  294. // 4. If url is not the empty string, then parse url relative to the entry settings object, and set urlRecord to the resulting URL record, if any. If the parse a URL algorithm failed, then throw a "SyntaxError" DOMException.
  295. if (!url.is_empty()) {
  296. url_record = entry_settings_object().parse_url(url);
  297. if (!url_record.is_valid())
  298. return WebIDL::SyntaxError::create(realm(), "URL is not valid");
  299. }
  300. // FIXME: 5. If urlRecord matches about:blank, then perform the URL and history update steps given target browsing context's active document and urlRecord.
  301. // 6. Otherwise:
  302. else {
  303. // 1. Let request be a new request whose URL is urlRecord.
  304. auto request = Fetch::Infrastructure::Request::create(vm);
  305. request->set_url(url_record);
  306. // 2. If noreferrer is true, then set request's referrer to "no-referrer".
  307. if (no_referrer)
  308. request->set_referrer(Fetch::Infrastructure::Request::Referrer::NoReferrer);
  309. // 3. Navigate target browsing context to request, with exceptionsEnabled set to true and the source browsing context set to source browsing context.
  310. TRY(target_browsing_context->navigate(request, *source_browsing_context, true));
  311. }
  312. }
  313. // 12. Otherwise:
  314. else {
  315. // 1. If url is not the empty string, then:
  316. if (!url.is_empty()) {
  317. // 1. Let urlRecord be the URL record about:blank.
  318. auto url_record = AK::URL("about:blank"sv);
  319. // 2. Parse url relative to the entry settings object, and set urlRecord to the resulting URL record, if any. If the parse a URL algorithm failed, then throw a "SyntaxError" DOMException.
  320. url_record = entry_settings_object().parse_url(url);
  321. if (!url_record.is_valid())
  322. return WebIDL::SyntaxError::create(realm(), "URL is not valid");
  323. // 3. Let request be a new request whose URL is urlRecord.
  324. auto request = Fetch::Infrastructure::Request::create(vm);
  325. request->set_url(url_record);
  326. // 4. If noreferrer is true, then set request's referrer to "noreferrer".
  327. if (no_referrer)
  328. request->set_referrer(Fetch::Infrastructure::Request::Referrer::NoReferrer);
  329. // 5. Navigate target browsing context to request, with exceptionsEnabled set to true and the source browsing context set to source browsing context.
  330. TRY(target_browsing_context->navigate(request, *source_browsing_context, true));
  331. }
  332. // 2. If noopener is false, then set target browsing context's opener browsing context to source browsing context.
  333. if (!no_opener)
  334. target_browsing_context->set_opener_browsing_context(source_browsing_context);
  335. }
  336. // 13. If noopener is true or windowType is "new with no opener", then return null.
  337. if (no_opener || window_type == BrowsingContext::WindowType::NewWithNoOpener)
  338. return nullptr;
  339. // 14. Return target browsing context's WindowProxy object.
  340. return target_browsing_context->window_proxy();
  341. }
  342. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
  343. i32 Window::set_timeout_impl(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
  344. {
  345. return run_timer_initialization_steps(move(handler), timeout, move(arguments), Repeat::No);
  346. }
  347. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
  348. i32 Window::set_interval_impl(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
  349. {
  350. return run_timer_initialization_steps(move(handler), timeout, move(arguments), Repeat::Yes);
  351. }
  352. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-cleartimeout
  353. void Window::clear_timeout_impl(i32 id)
  354. {
  355. m_timers.remove(id);
  356. }
  357. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-clearinterval
  358. void Window::clear_interval_impl(i32 id)
  359. {
  360. m_timers.remove(id);
  361. }
  362. void Window::deallocate_timer_id(Badge<Timer>, i32 id)
  363. {
  364. m_timer_id_allocator.deallocate(id);
  365. }
  366. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timer-initialisation-steps
  367. i32 Window::run_timer_initialization_steps(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id)
  368. {
  369. // 1. Let thisArg be global if that is a WorkerGlobalScope object; otherwise let thisArg be the WindowProxy that corresponds to global.
  370. // 2. If previousId was given, let id be previousId; otherwise, let id be an implementation-defined integer that is greater than zero and does not already exist in global's map of active timers.
  371. auto id = previous_id.has_value() ? previous_id.value() : m_timer_id_allocator.allocate();
  372. // FIXME: 3. If the surrounding agent's event loop's currently running task is a task that was created by this algorithm, then let nesting level be the task's timer nesting level. Otherwise, let nesting level be zero.
  373. // 4. If timeout is less than 0, then set timeout to 0.
  374. if (timeout < 0)
  375. timeout = 0;
  376. // FIXME: 5. If nesting level is greater than 5, and timeout is less than 4, then set timeout to 4.
  377. // 6. Let callerRealm be the current Realm Record, and calleeRealm be global's relevant Realm.
  378. // FIXME: Implement this when step 9.2 is implemented.
  379. // 7. Let initiating script be the active script.
  380. // 8. Assert: initiating script is not null, since this algorithm is always called from some script.
  381. // 9. Let task be a task that runs the following substeps:
  382. JS::SafeFunction<void()> task = [this, handler = move(handler), timeout, arguments = move(arguments), repeat, id] {
  383. // 1. If id does not exist in global's map of active timers, then abort these steps.
  384. if (!m_timers.contains(id))
  385. return;
  386. handler.visit(
  387. // 2. If handler is a Function, then invoke handler given arguments with the callback this value set to thisArg. If this throws an exception, catch it, and report the exception.
  388. [&](JS::Handle<WebIDL::CallbackType> callback) {
  389. if (auto result = WebIDL::invoke_callback(*callback, this, arguments); result.is_error())
  390. HTML::report_exception(result, realm());
  391. },
  392. // 3. Otherwise:
  393. [&](DeprecatedString const& source) {
  394. // 1. Assert: handler is a string.
  395. // FIXME: 2. Perform HostEnsureCanCompileStrings(callerRealm, calleeRealm). If this throws an exception, catch it, report the exception, and abort these steps.
  396. // 3. Let settings object be global's relevant settings object.
  397. auto& settings_object = associated_document().relevant_settings_object();
  398. // 4. Let base URL be initiating script's base URL.
  399. auto url = associated_document().url();
  400. // 5. Assert: base URL is not null, as initiating script is a classic script or a JavaScript module script.
  401. // 6. Let fetch options be a script fetch options whose cryptographic nonce is initiating script's fetch options's cryptographic nonce, integrity metadata is the empty string, parser metadata is "not-parser-inserted", credentials mode is initiating script's fetch options's credentials mode, and referrer policy is initiating script's fetch options's referrer policy.
  402. // 7. Let script be the result of creating a classic script given handler, settings object, base URL, and fetch options.
  403. auto script = HTML::ClassicScript::create(url.basename(), source, settings_object, url);
  404. // 8. Run the classic script script.
  405. (void)script->run();
  406. });
  407. // 4. If id does not exist in global's map of active timers, then abort these steps.
  408. if (!m_timers.contains(id))
  409. return;
  410. switch (repeat) {
  411. // 5. If repeat is true, then perform the timer initialization steps again, given global, handler, timeout, arguments, true, and id.
  412. case Repeat::Yes:
  413. run_timer_initialization_steps(handler, timeout, move(arguments), repeat, id);
  414. break;
  415. // 6. Otherwise, remove global's map of active timers[id].
  416. case Repeat::No:
  417. m_timers.remove(id);
  418. break;
  419. }
  420. };
  421. // FIXME: 10. Increment nesting level by one.
  422. // FIXME: 11. Set task's timer nesting level to nesting level.
  423. // 12. Let completionStep be an algorithm step which queues a global task on the timer task source given global to run task.
  424. JS::SafeFunction<void()> completion_step = [this, task = move(task)]() mutable {
  425. HTML::queue_global_task(HTML::Task::Source::TimerTask, *this, move(task));
  426. };
  427. // 13. Run steps after a timeout given global, "setTimeout/setInterval", timeout, completionStep, and id.
  428. auto timer = Timer::create(*this, timeout, move(completion_step), id);
  429. m_timers.set(id, timer);
  430. timer->start();
  431. // 14. Return id.
  432. return id;
  433. }
  434. void Window::did_set_location_href(Badge<HTML::Location>, AK::URL const& new_href)
  435. {
  436. auto* browsing_context = associated_document().browsing_context();
  437. if (!browsing_context)
  438. return;
  439. browsing_context->loader().load(new_href, FrameLoader::Type::Navigation);
  440. }
  441. void Window::did_call_location_reload(Badge<HTML::Location>)
  442. {
  443. auto* browsing_context = associated_document().browsing_context();
  444. if (!browsing_context)
  445. return;
  446. browsing_context->loader().load(associated_document().url(), FrameLoader::Type::Reload);
  447. }
  448. void Window::did_call_location_replace(Badge<HTML::Location>, DeprecatedString url)
  449. {
  450. auto* browsing_context = associated_document().browsing_context();
  451. if (!browsing_context)
  452. return;
  453. auto new_url = associated_document().parse_url(url);
  454. browsing_context->loader().load(move(new_url), FrameLoader::Type::Navigation);
  455. }
  456. bool Window::dispatch_event(DOM::Event& event)
  457. {
  458. return DOM::EventDispatcher::dispatch(*this, event, true);
  459. }
  460. Page* Window::page()
  461. {
  462. return associated_document().page();
  463. }
  464. Page const* Window::page() const
  465. {
  466. return associated_document().page();
  467. }
  468. Optional<CSS::MediaFeatureValue> Window::query_media_feature(CSS::MediaFeatureID media_feature) const
  469. {
  470. // FIXME: Many of these should be dependent on the hardware
  471. // https://www.w3.org/TR/mediaqueries-5/#media-descriptor-table
  472. switch (media_feature) {
  473. case CSS::MediaFeatureID::AnyHover:
  474. return CSS::MediaFeatureValue(CSS::ValueID::Hover);
  475. case CSS::MediaFeatureID::AnyPointer:
  476. return CSS::MediaFeatureValue(CSS::ValueID::Fine);
  477. case CSS::MediaFeatureID::AspectRatio:
  478. return CSS::MediaFeatureValue(CSS::Ratio(inner_width(), inner_height()));
  479. case CSS::MediaFeatureID::Color:
  480. return CSS::MediaFeatureValue(8);
  481. case CSS::MediaFeatureID::ColorGamut:
  482. return CSS::MediaFeatureValue(CSS::ValueID::Srgb);
  483. case CSS::MediaFeatureID::ColorIndex:
  484. return CSS::MediaFeatureValue(0);
  485. // FIXME: device-aspect-ratio
  486. case CSS::MediaFeatureID::DeviceHeight:
  487. if (auto* page = this->page()) {
  488. return CSS::MediaFeatureValue(CSS::Length::make_px(page->web_exposed_screen_area().height().value()));
  489. }
  490. return CSS::MediaFeatureValue(0);
  491. case CSS::MediaFeatureID::DeviceWidth:
  492. if (auto* page = this->page()) {
  493. return CSS::MediaFeatureValue(CSS::Length::make_px(page->web_exposed_screen_area().width().value()));
  494. }
  495. return CSS::MediaFeatureValue(0);
  496. case CSS::MediaFeatureID::DisplayMode:
  497. // FIXME: Detect if window is fullscreen
  498. return CSS::MediaFeatureValue(CSS::ValueID::Browser);
  499. case CSS::MediaFeatureID::DynamicRange:
  500. return CSS::MediaFeatureValue(CSS::ValueID::Standard);
  501. case CSS::MediaFeatureID::EnvironmentBlending:
  502. return CSS::MediaFeatureValue(CSS::ValueID::Opaque);
  503. case CSS::MediaFeatureID::ForcedColors:
  504. return CSS::MediaFeatureValue(CSS::ValueID::None);
  505. case CSS::MediaFeatureID::Grid:
  506. return CSS::MediaFeatureValue(0);
  507. case CSS::MediaFeatureID::Height:
  508. return CSS::MediaFeatureValue(CSS::Length::make_px(inner_height()));
  509. case CSS::MediaFeatureID::HorizontalViewportSegments:
  510. return CSS::MediaFeatureValue(1);
  511. case CSS::MediaFeatureID::Hover:
  512. return CSS::MediaFeatureValue(CSS::ValueID::Hover);
  513. case CSS::MediaFeatureID::InvertedColors:
  514. return CSS::MediaFeatureValue(CSS::ValueID::None);
  515. case CSS::MediaFeatureID::Monochrome:
  516. return CSS::MediaFeatureValue(0);
  517. case CSS::MediaFeatureID::NavControls:
  518. return CSS::MediaFeatureValue(CSS::ValueID::Back);
  519. case CSS::MediaFeatureID::Orientation:
  520. return CSS::MediaFeatureValue(inner_height() >= inner_width() ? CSS::ValueID::Portrait : CSS::ValueID::Landscape);
  521. case CSS::MediaFeatureID::OverflowBlock:
  522. return CSS::MediaFeatureValue(CSS::ValueID::Scroll);
  523. case CSS::MediaFeatureID::OverflowInline:
  524. return CSS::MediaFeatureValue(CSS::ValueID::Scroll);
  525. case CSS::MediaFeatureID::Pointer:
  526. return CSS::MediaFeatureValue(CSS::ValueID::Fine);
  527. case CSS::MediaFeatureID::PrefersColorScheme: {
  528. if (auto* page = this->page()) {
  529. switch (page->preferred_color_scheme()) {
  530. case CSS::PreferredColorScheme::Light:
  531. return CSS::MediaFeatureValue(CSS::ValueID::Light);
  532. case CSS::PreferredColorScheme::Dark:
  533. return CSS::MediaFeatureValue(CSS::ValueID::Dark);
  534. case CSS::PreferredColorScheme::Auto:
  535. default:
  536. return CSS::MediaFeatureValue(page->palette().is_dark() ? CSS::ValueID::Dark : CSS::ValueID::Light);
  537. }
  538. }
  539. return CSS::MediaFeatureValue(CSS::ValueID::Light);
  540. }
  541. case CSS::MediaFeatureID::PrefersContrast:
  542. // FIXME: Make this a preference
  543. return CSS::MediaFeatureValue(CSS::ValueID::NoPreference);
  544. case CSS::MediaFeatureID::PrefersReducedData:
  545. // FIXME: Make this a preference
  546. return CSS::MediaFeatureValue(CSS::ValueID::NoPreference);
  547. case CSS::MediaFeatureID::PrefersReducedMotion:
  548. // FIXME: Make this a preference
  549. return CSS::MediaFeatureValue(CSS::ValueID::NoPreference);
  550. case CSS::MediaFeatureID::PrefersReducedTransparency:
  551. // FIXME: Make this a preference
  552. return CSS::MediaFeatureValue(CSS::ValueID::NoPreference);
  553. // FIXME: resolution
  554. case CSS::MediaFeatureID::Scan:
  555. return CSS::MediaFeatureValue(CSS::ValueID::Progressive);
  556. case CSS::MediaFeatureID::Scripting:
  557. if (associated_document().is_scripting_enabled())
  558. return CSS::MediaFeatureValue(CSS::ValueID::Enabled);
  559. return CSS::MediaFeatureValue(CSS::ValueID::None);
  560. case CSS::MediaFeatureID::Update:
  561. return CSS::MediaFeatureValue(CSS::ValueID::Fast);
  562. case CSS::MediaFeatureID::VerticalViewportSegments:
  563. return CSS::MediaFeatureValue(1);
  564. case CSS::MediaFeatureID::VideoColorGamut:
  565. return CSS::MediaFeatureValue(CSS::ValueID::Srgb);
  566. case CSS::MediaFeatureID::VideoDynamicRange:
  567. return CSS::MediaFeatureValue(CSS::ValueID::Standard);
  568. case CSS::MediaFeatureID::Width:
  569. return CSS::MediaFeatureValue(CSS::Length::make_px(inner_width()));
  570. default:
  571. break;
  572. }
  573. return {};
  574. }
  575. // https://html.spec.whatwg.org/#fire-a-page-transition-event
  576. void Window::fire_a_page_transition_event(DeprecatedFlyString const& event_name, bool persisted)
  577. {
  578. // To fire a page transition event named eventName at a Window window with a boolean persisted,
  579. // fire an event named eventName at window, using PageTransitionEvent,
  580. // with the persisted attribute initialized to persisted,
  581. HTML::PageTransitionEventInit event_init {};
  582. event_init.persisted = persisted;
  583. auto event = HTML::PageTransitionEvent::create(associated_document().realm(), String::from_deprecated_string(event_name).release_value_but_fixme_should_propagate_errors(), event_init).release_value_but_fixme_should_propagate_errors();
  584. // ...the cancelable attribute initialized to true,
  585. event->set_cancelable(true);
  586. // the bubbles attribute initialized to true,
  587. event->set_bubbles(true);
  588. // and legacy target override flag set.
  589. dispatch_event(event);
  590. }
  591. // https://html.spec.whatwg.org/multipage/webstorage.html#dom-localstorage
  592. JS::NonnullGCPtr<HTML::Storage> Window::local_storage()
  593. {
  594. // FIXME: Implement according to spec.
  595. static HashMap<Origin, JS::Handle<HTML::Storage>> local_storage_per_origin;
  596. auto storage = local_storage_per_origin.ensure(associated_document().origin(), [this]() -> JS::Handle<HTML::Storage> {
  597. return *HTML::Storage::create(realm()).release_value_but_fixme_should_propagate_errors();
  598. });
  599. return *storage;
  600. }
  601. // https://html.spec.whatwg.org/multipage/webstorage.html#dom-sessionstorage
  602. JS::NonnullGCPtr<HTML::Storage> Window::session_storage()
  603. {
  604. // FIXME: Implement according to spec.
  605. static HashMap<Origin, JS::Handle<HTML::Storage>> session_storage_per_origin;
  606. auto storage = session_storage_per_origin.ensure(associated_document().origin(), [this]() -> JS::Handle<HTML::Storage> {
  607. return *HTML::Storage::create(realm()).release_value_but_fixme_should_propagate_errors();
  608. });
  609. return *storage;
  610. }
  611. // https://html.spec.whatwg.org/multipage/interaction.html#transient-activation
  612. bool Window::has_transient_activation() const
  613. {
  614. // FIXME: Implement this.
  615. return false;
  616. }
  617. // https://w3c.github.io/requestidlecallback/#start-an-idle-period-algorithm
  618. void Window::start_an_idle_period()
  619. {
  620. // 1. Optionally, if the user agent determines the idle period should be delayed, return from this algorithm.
  621. // 2. Let pending_list be window's list of idle request callbacks.
  622. auto& pending_list = m_idle_request_callbacks;
  623. // 3. Let run_list be window's list of runnable idle callbacks.
  624. auto& run_list = m_runnable_idle_callbacks;
  625. run_list.extend(pending_list);
  626. // 4. Clear pending_list.
  627. pending_list.clear();
  628. // FIXME: This might not agree with the spec, but currently we use 100% CPU if we keep queueing tasks
  629. if (run_list.is_empty())
  630. return;
  631. // 5. Queue a task on the queue associated with the idle-task task source,
  632. // which performs the steps defined in the invoke idle callbacks algorithm with window and getDeadline as parameters.
  633. HTML::queue_global_task(HTML::Task::Source::IdleTask, *this, [this] {
  634. invoke_idle_callbacks();
  635. });
  636. }
  637. // https://w3c.github.io/requestidlecallback/#invoke-idle-callbacks-algorithm
  638. void Window::invoke_idle_callbacks()
  639. {
  640. auto& event_loop = main_thread_event_loop();
  641. // 1. If the user-agent believes it should end the idle period early due to newly scheduled high-priority work, return from the algorithm.
  642. // 2. Let now be the current time.
  643. auto now = HighResolutionTime::unsafe_shared_current_time();
  644. // 3. If now is less than the result of calling getDeadline and the window's list of runnable idle callbacks is not empty:
  645. if (now < event_loop.compute_deadline() && !m_runnable_idle_callbacks.is_empty()) {
  646. // 1. Pop the top callback from window's list of runnable idle callbacks.
  647. auto callback = m_runnable_idle_callbacks.take_first();
  648. // 2. Let deadlineArg be a new IdleDeadline whose [get deadline time algorithm] is getDeadline.
  649. auto deadline_arg = RequestIdleCallback::IdleDeadline::create(realm()).release_value_but_fixme_should_propagate_errors();
  650. // 3. Call callback with deadlineArg as its argument. If an uncaught runtime script error occurs, then report the exception.
  651. auto result = callback->invoke(deadline_arg);
  652. if (result.is_error())
  653. HTML::report_exception(result, realm());
  654. // 4. If window's list of runnable idle callbacks is not empty, queue a task which performs the steps
  655. // in the invoke idle callbacks algorithm with getDeadline and window as a parameters and return from this algorithm
  656. HTML::queue_global_task(HTML::Task::Source::IdleTask, *this, [this] {
  657. invoke_idle_callbacks();
  658. });
  659. }
  660. }
  661. void Window::set_associated_document(DOM::Document& document)
  662. {
  663. m_associated_document = &document;
  664. }
  665. void Window::set_current_event(DOM::Event* event)
  666. {
  667. m_current_event = event;
  668. }
  669. HTML::BrowsingContext const* Window::browsing_context() const
  670. {
  671. return m_associated_document->browsing_context();
  672. }
  673. HTML::BrowsingContext* Window::browsing_context()
  674. {
  675. return m_associated_document->browsing_context();
  676. }
  677. // https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-plugin-objects
  678. Vector<JS::NonnullGCPtr<Plugin>> Window::pdf_viewer_plugin_objects()
  679. {
  680. // Each Window object has a PDF viewer plugin objects list. If the user agent's PDF viewer supported is false, then it is the empty list.
  681. // Otherwise, it is a list containing five Plugin objects, whose names are, respectively:
  682. // 0. "PDF Viewer"
  683. // 1. "Chrome PDF Viewer"
  684. // 2. "Chromium PDF Viewer"
  685. // 3. "Microsoft Edge PDF Viewer"
  686. // 4. "WebKit built-in PDF"
  687. // The values of the above list form the PDF viewer plugin names list. https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-plugin-names
  688. VERIFY(page());
  689. if (!page()->pdf_viewer_supported())
  690. return {};
  691. if (m_pdf_viewer_plugin_objects.is_empty()) {
  692. // FIXME: Propagate errors.
  693. m_pdf_viewer_plugin_objects.append(realm().heap().allocate<Plugin>(realm(), realm(), "PDF Viewer"_string.release_value_but_fixme_should_propagate_errors()).release_allocated_value_but_fixme_should_propagate_errors());
  694. m_pdf_viewer_plugin_objects.append(realm().heap().allocate<Plugin>(realm(), realm(), "Chrome PDF Viewer"_string.release_value_but_fixme_should_propagate_errors()).release_allocated_value_but_fixme_should_propagate_errors());
  695. m_pdf_viewer_plugin_objects.append(realm().heap().allocate<Plugin>(realm(), realm(), "Chromium PDF Viewer"_string.release_value_but_fixme_should_propagate_errors()).release_allocated_value_but_fixme_should_propagate_errors());
  696. m_pdf_viewer_plugin_objects.append(realm().heap().allocate<Plugin>(realm(), realm(), "Microsoft Edge PDF Viewer"_string.release_value_but_fixme_should_propagate_errors()).release_allocated_value_but_fixme_should_propagate_errors());
  697. m_pdf_viewer_plugin_objects.append(realm().heap().allocate<Plugin>(realm(), realm(), "WebKit built-in PDF"_string.release_value_but_fixme_should_propagate_errors()).release_allocated_value_but_fixme_should_propagate_errors());
  698. }
  699. return m_pdf_viewer_plugin_objects;
  700. }
  701. // https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-mime-type-objects
  702. Vector<JS::NonnullGCPtr<MimeType>> Window::pdf_viewer_mime_type_objects()
  703. {
  704. // Each Window object has a PDF viewer mime type objects list. If the user agent's PDF viewer supported is false, then it is the empty list.
  705. // Otherwise, it is a list containing two MimeType objects, whose types are, respectively:
  706. // 0. "application/pdf"
  707. // 1. "text/pdf"
  708. // The values of the above list form the PDF viewer mime types list. https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-mime-types
  709. VERIFY(page());
  710. if (!page()->pdf_viewer_supported())
  711. return {};
  712. if (m_pdf_viewer_mime_type_objects.is_empty()) {
  713. m_pdf_viewer_mime_type_objects.append(realm().heap().allocate<MimeType>(realm(), realm(), "application/pdf"_string.release_value_but_fixme_should_propagate_errors()).release_allocated_value_but_fixme_should_propagate_errors());
  714. m_pdf_viewer_mime_type_objects.append(realm().heap().allocate<MimeType>(realm(), realm(), "text/pdf"_string.release_value_but_fixme_should_propagate_errors()).release_allocated_value_but_fixme_should_propagate_errors());
  715. }
  716. return m_pdf_viewer_mime_type_objects;
  717. }
  718. WebIDL::ExceptionOr<void> Window::initialize_web_interfaces(Badge<WindowEnvironmentSettingsObject>)
  719. {
  720. auto& realm = this->realm();
  721. add_window_exposed_interfaces(*this);
  722. Object::set_prototype(&Bindings::ensure_web_prototype<Bindings::WindowPrototype>(realm, "Window"));
  723. m_location = MUST_OR_THROW_OOM(heap().allocate<Location>(realm, realm));
  724. m_navigator = MUST_OR_THROW_OOM(heap().allocate<Navigator>(realm, realm));
  725. MUST_OR_THROW_OOM(Bindings::WindowGlobalMixin::initialize(realm, *this));
  726. // FIXME: These should be native accessors, not properties
  727. u8 attr = JS::Attribute::Writable | JS::Attribute::Enumerable | JS::Attribute::Configurable;
  728. define_native_function(realm, "setInterval", set_interval, 1, attr);
  729. define_native_function(realm, "setTimeout", set_timeout, 1, attr);
  730. define_native_function(realm, "clearInterval", clear_interval, 1, attr);
  731. define_native_function(realm, "clearTimeout", clear_timeout, 1, attr);
  732. define_direct_property("CSS", MUST_OR_THROW_OOM(heap().allocate<Bindings::CSSNamespace>(realm, realm)), 0);
  733. // FIXME: Implement codegen for readonly properties with [PutForwards]
  734. auto& location_accessor = storage_get("location")->value.as_accessor();
  735. location_accessor.set_setter(JS::NativeFunction::create(realm, location_setter, 1, "location", &realm, {}, "set"sv));
  736. // WebAssembly "namespace"
  737. define_direct_property("WebAssembly", MUST_OR_THROW_OOM(heap().allocate<Bindings::WebAssemblyObject>(realm, realm)), JS::Attribute::Enumerable | JS::Attribute::Configurable);
  738. return {};
  739. }
  740. // https://webidl.spec.whatwg.org/#platform-object-setprototypeof
  741. JS::ThrowCompletionOr<bool> Window::internal_set_prototype_of(JS::Object* prototype)
  742. {
  743. // 1. Return ? SetImmutablePrototype(O, V).
  744. return set_immutable_prototype(prototype);
  745. }
  746. static JS::ThrowCompletionOr<HTML::Window*> impl_from(JS::VM& vm)
  747. {
  748. // Since this is a non built-in function we must treat it as non-strict mode
  749. // this means that a nullish this_value should be converted to the
  750. // global_object. Generally this does not matter as we try to convert the
  751. // this_value to a specific object type in the bindings. But since window is
  752. // the global object we make an exception here.
  753. // This allows calls like `setTimeout(f, 10)` to work.
  754. auto this_value = vm.this_value();
  755. if (this_value.is_nullish())
  756. this_value = &vm.current_realm()->global_object();
  757. auto* this_object = MUST(this_value.to_object(vm));
  758. if (is<WindowProxy>(*this_object))
  759. return static_cast<WindowProxy*>(this_object)->window().ptr();
  760. if (is<Window>(*this_object))
  761. return static_cast<Window*>(this_object);
  762. return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Window");
  763. }
  764. // https://html.spec.whatwg.org/multipage/window-object.html#dom-window
  765. JS::NonnullGCPtr<WindowProxy> Window::window() const
  766. {
  767. // The window, frames, and self getter steps are to return this's relevant realm.[[GlobalEnv]].[[GlobalThisValue]].
  768. return verify_cast<WindowProxy>(relevant_realm(*this).global_environment().global_this_value());
  769. }
  770. // https://html.spec.whatwg.org/multipage/window-object.html#dom-self
  771. JS::NonnullGCPtr<WindowProxy> Window::self() const
  772. {
  773. // The window, frames, and self getter steps are to return this's relevant realm.[[GlobalEnv]].[[GlobalThisValue]].
  774. return verify_cast<WindowProxy>(relevant_realm(*this).global_environment().global_this_value());
  775. }
  776. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-document-2
  777. JS::NonnullGCPtr<DOM::Document const> Window::document() const
  778. {
  779. // The document getter steps are to return this's associated Document.
  780. return associated_document();
  781. }
  782. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-name
  783. String Window::name() const
  784. {
  785. // 1. If this's navigable is null, then return the empty string.
  786. if (!browsing_context())
  787. return String {};
  788. // 2. Return this's navigable's target name.
  789. return String::from_deprecated_string(browsing_context()->name()).release_value_but_fixme_should_propagate_errors();
  790. }
  791. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#apis-for-creating-and-navigating-browsing-contexts-by-name:dom-name
  792. void Window::set_name(String const& name)
  793. {
  794. // 1. If this's navigable is null, then return.
  795. if (!browsing_context())
  796. return;
  797. // 2. Set this's navigable's active session history entry's document state's navigable target name to the given value.
  798. browsing_context()->set_name(name.to_deprecated_string());
  799. }
  800. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-location
  801. JS::NonnullGCPtr<Location> Window::location() const
  802. {
  803. // The Window object's location getter steps are to return this's Location object.
  804. return *m_location;
  805. }
  806. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-history
  807. JS::NonnullGCPtr<History> Window::history() const
  808. {
  809. // The history getter steps are to return this's associated Document's history object.
  810. return associated_document().history();
  811. }
  812. // https://html.spec.whatwg.org/multipage/interaction.html#dom-window-focus
  813. void Window::focus()
  814. {
  815. // 1. Let current be this Window object's navigable.
  816. auto* current = browsing_context();
  817. // 2. If current is null, then return.
  818. if (!current)
  819. return;
  820. // 3. Run the focusing steps with current.
  821. // FIXME: We should pass in the browsing context itself instead of the active document, however the focusing steps don't currently accept browsing contexts.
  822. // Passing in a browsing context always makes it resolve to its active document for focus, so this is fine for now.
  823. run_focusing_steps(current->active_document());
  824. // FIXME: 4. If current is a top-level traversable, user agents are encouraged to trigger some sort of notification to
  825. // indicate to the user that the page is attempting to gain focus.
  826. }
  827. // https://html.spec.whatwg.org/multipage/window-object.html#dom-frames
  828. JS::NonnullGCPtr<WindowProxy> Window::frames() const
  829. {
  830. // The window, frames, and self getter steps are to return this's relevant realm.[[GlobalEnv]].[[GlobalThisValue]].
  831. return verify_cast<WindowProxy>(relevant_realm(*this).global_environment().global_this_value());
  832. }
  833. // https://html.spec.whatwg.org/multipage/window-object.html#dom-length
  834. u32 Window::length() const
  835. {
  836. // The length getter steps are to return this's associated Document's document-tree child navigables's size.
  837. return static_cast<u32>(document_tree_child_browsing_context_count());
  838. }
  839. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-top
  840. JS::GCPtr<WindowProxy const> Window::top() const
  841. {
  842. // 1. If this's navigable is null, then return null.
  843. auto const* browsing_context = this->browsing_context();
  844. if (!browsing_context)
  845. return {};
  846. // 2. Return this's navigable's top-level traversable's active WindowProxy.
  847. return browsing_context->top_level_browsing_context().window_proxy();
  848. }
  849. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-parent
  850. JS::GCPtr<WindowProxy const> Window::parent() const
  851. {
  852. // 1. Let navigable be this's navigable.
  853. auto* navigable = browsing_context();
  854. // 2. If navigable is null, then return null.
  855. if (!navigable)
  856. return {};
  857. // 3. If navigable's parent is not null, then set navigable to navigable's parent.
  858. if (auto parent = navigable->parent())
  859. navigable = parent;
  860. // 4. Return navigable's active WindowProxy.
  861. return navigable->window_proxy();
  862. }
  863. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-frameelement
  864. JS::GCPtr<DOM::Element const> Window::frame_element() const
  865. {
  866. // 1. Let current be this's node navigable.
  867. auto* current = browsing_context();
  868. // 2. If current is null, then return null.
  869. if (!current)
  870. return {};
  871. // 3. Let container be current's container.
  872. auto* container = current->container();
  873. // 4. If container is null, then return null.
  874. if (!container)
  875. return {};
  876. // 5. If container's node document's origin is not same origin-domain with the current settings object's origin, then return null.
  877. if (!container->document().origin().is_same_origin_domain(current_settings_object().origin()))
  878. return {};
  879. // 6. Return container.
  880. return container;
  881. }
  882. // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-open
  883. WebIDL::ExceptionOr<JS::GCPtr<HTML::WindowProxy>> Window::open(Optional<String> const& url, Optional<String> const& target, Optional<String> const& features)
  884. {
  885. // The open(url, target, features) method steps are to run the window open steps with url, target, and features.
  886. return open_impl(*url, *target, *features);
  887. }
  888. // https://html.spec.whatwg.org/multipage/system-state.html#dom-navigator
  889. JS::NonnullGCPtr<Navigator> Window::navigator() const
  890. {
  891. // The navigator and clientInformation getter steps are to return this's associated Navigator.
  892. return *m_navigator;
  893. }
  894. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-alert
  895. void Window::alert(String const& message)
  896. {
  897. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#simple-dialogs
  898. // Note: This method is defined using two overloads, instead of using an optional argument,
  899. // for historical reasons. The practical impact of this is that alert(undefined) is
  900. // treated as alert("undefined"), but alert() is treated as alert("").
  901. // FIXME: Make this fully spec compliant.
  902. if (auto* page = this->page())
  903. page->did_request_alert(message.to_deprecated_string());
  904. }
  905. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-confirm
  906. bool Window::confirm(Optional<String> const& message)
  907. {
  908. // FIXME: Make this fully spec compliant.
  909. // NOTE: `message` has an IDL-provided default value and is never empty.
  910. if (auto* page = this->page())
  911. return page->did_request_confirm(message->to_deprecated_string());
  912. return false;
  913. }
  914. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-prompt
  915. Optional<String> Window::prompt(Optional<String> const& message, Optional<String> const& default_)
  916. {
  917. // FIXME: Make this fully spec compliant.
  918. if (auto* page = this->page()) {
  919. auto response = page->did_request_prompt(message->to_deprecated_string(), default_->to_deprecated_string());
  920. if (response.is_null())
  921. return {};
  922. return String::from_deprecated_string(response).release_value_but_fixme_should_propagate_errors();
  923. }
  924. return {};
  925. }
  926. // https://html.spec.whatwg.org/multipage/web-messaging.html#dom-window-postmessage
  927. void Window::post_message(JS::Value message, String const&)
  928. {
  929. // FIXME: This is an ad-hoc hack implementation instead, since we don't currently
  930. // have serialization and deserialization of messages.
  931. HTML::queue_global_task(HTML::Task::Source::PostedMessage, *this, [this, message] {
  932. HTML::MessageEventInit event_init {};
  933. event_init.data = message;
  934. event_init.origin = "<origin>"_string.release_value_but_fixme_should_propagate_errors();
  935. dispatch_event(HTML::MessageEvent::create(realm(), String::from_deprecated_string(HTML::EventNames::message).release_value_but_fixme_should_propagate_errors(), event_init).release_value_but_fixme_should_propagate_errors());
  936. });
  937. }
  938. // https://dom.spec.whatwg.org/#dom-window-event
  939. Variant<JS::Handle<DOM::Event>, JS::Value> Window::event() const
  940. {
  941. // The event getter steps are to return this’s current event.
  942. if (auto* current_event = this->current_event())
  943. return make_handle(const_cast<DOM::Event&>(*current_event));
  944. return JS::js_undefined();
  945. }
  946. // https://w3c.github.io/csswg-drafts/cssom/#dom-window-getcomputedstyle
  947. WebIDL::ExceptionOr<JS::NonnullGCPtr<CSS::CSSStyleDeclaration>> Window::get_computed_style(DOM::Element& element, Optional<String> const& pseudo_element) const
  948. {
  949. // FIXME: Make this fully spec compliant.
  950. (void)pseudo_element;
  951. return MUST_OR_THROW_OOM(heap().allocate<CSS::ResolvedCSSStyleDeclaration>(realm(), element));
  952. }
  953. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-matchmedia
  954. WebIDL::ExceptionOr<JS::NonnullGCPtr<CSS::MediaQueryList>> Window::match_media(String const& query)
  955. {
  956. // 1. Let parsed media query list be the result of parsing query.
  957. auto parsed_media_query_list = parse_media_query_list(CSS::Parser::ParsingContext(associated_document()), query);
  958. // 2. Return a new MediaQueryList object, with this's associated Document as the document, with parsed media query list as its associated media query list.
  959. auto media_query_list = MUST_OR_THROW_OOM(heap().allocate<CSS::MediaQueryList>(realm(), associated_document(), move(parsed_media_query_list)));
  960. associated_document().add_media_query_list(media_query_list);
  961. return media_query_list;
  962. }
  963. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-screen
  964. WebIDL::ExceptionOr<JS::NonnullGCPtr<CSS::Screen>> Window::screen()
  965. {
  966. // The screen attribute must return the Screen object associated with the Window object.
  967. if (!m_screen)
  968. m_screen = MUST_OR_THROW_OOM(heap().allocate<CSS::Screen>(realm(), *this));
  969. return JS::NonnullGCPtr { *m_screen };
  970. }
  971. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-innerwidth
  972. i32 Window::inner_width() const
  973. {
  974. // The innerWidth attribute must return the viewport width including the size of a rendered scroll bar (if any),
  975. // or zero if there is no viewport.
  976. if (auto const* browsing_context = associated_document().browsing_context())
  977. return browsing_context->viewport_rect().width().value();
  978. return 0;
  979. }
  980. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-innerheight
  981. i32 Window::inner_height() const
  982. {
  983. // The innerHeight attribute must return the viewport height including the size of a rendered scroll bar (if any),
  984. // or zero if there is no viewport.
  985. if (auto const* browsing_context = associated_document().browsing_context())
  986. return browsing_context->viewport_rect().height().value();
  987. return 0;
  988. }
  989. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-scrollx
  990. double Window::scroll_x() const
  991. {
  992. // The scrollX attribute must return the x-coordinate, relative to the initial containing block origin,
  993. // of the left of the viewport, or zero if there is no viewport.
  994. if (auto* page = this->page())
  995. return page->top_level_browsing_context().viewport_scroll_offset().x().value();
  996. return 0;
  997. }
  998. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-scrolly
  999. double Window::scroll_y() const
  1000. {
  1001. // The scrollY attribute must return the y-coordinate, relative to the initial containing block origin,
  1002. // of the top of the viewport, or zero if there is no viewport.
  1003. if (auto* page = this->page())
  1004. return page->top_level_browsing_context().viewport_scroll_offset().y().value();
  1005. return 0;
  1006. }
  1007. // https://w3c.github.io/csswg-drafts/cssom-view/#perform-a-scroll
  1008. static void perform_a_scroll(Page& page, double x, double y, JS::GCPtr<DOM::Node const> element, Bindings::ScrollBehavior behavior)
  1009. {
  1010. // FIXME: 1. Abort any ongoing smooth scroll for box.
  1011. // 2. If the user agent honors the scroll-behavior property and one of the following are true:
  1012. // - behavior is "auto" and element is not null and its computed value of the scroll-behavior property is smooth
  1013. // - behavior is smooth
  1014. // ...then perform a smooth scroll of box to position. Once the position has finished updating, emit the scrollend
  1015. // event. Otherwise, perform an instant scroll of box to position. After an instant scroll emit the scrollend event.
  1016. // FIXME: Support smooth scrolling.
  1017. (void)element;
  1018. (void)behavior;
  1019. page.client().page_did_request_scroll_to({ x, y });
  1020. }
  1021. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-scroll
  1022. void Window::scroll(ScrollToOptions const& options)
  1023. {
  1024. // 4. If there is no viewport, abort these steps.
  1025. auto* page = this->page();
  1026. if (!page)
  1027. return;
  1028. auto const& top_level_browsing_context = page->top_level_browsing_context();
  1029. // 1. If invoked with one argument, follow these substeps:
  1030. // 1. Let options be the argument.
  1031. auto viewport_rect = top_level_browsing_context.viewport_rect().to_type<float>();
  1032. // 2. Let x be the value of the left dictionary member of options, if present, or the viewport’s current scroll
  1033. // position on the x axis otherwise.
  1034. auto x = options.left.value_or(viewport_rect.x());
  1035. // 3. Let y be the value of the top dictionary member of options, if present, or the viewport’s current scroll
  1036. // position on the y axis otherwise.
  1037. auto y = options.top.value_or(viewport_rect.y());
  1038. // 3. Normalize non-finite values for x and y.
  1039. x = JS::Value(x).is_finite_number() ? x : 0;
  1040. y = JS::Value(y).is_finite_number() ? y : 0;
  1041. // 5. Let viewport width be the width of the viewport excluding the width of the scroll bar, if any.
  1042. auto viewport_width = viewport_rect.width();
  1043. // 6. Let viewport height be the height of the viewport excluding the height of the scroll bar, if any.
  1044. auto viewport_height = viewport_rect.height();
  1045. (void)viewport_width;
  1046. (void)viewport_height;
  1047. // FIXME: 7.
  1048. // -> If the viewport has rightward overflow direction
  1049. // Let x be max(0, min(x, viewport scrolling area width - viewport width)).
  1050. // -> If the viewport has leftward overflow direction
  1051. // Let x be min(0, max(x, viewport width - viewport scrolling area width)).
  1052. // FIXME: 8.
  1053. // -> If the viewport has downward overflow direction
  1054. // Let y be max(0, min(y, viewport scrolling area height - viewport height)).
  1055. // -> If the viewport has upward overflow direction
  1056. // Let y be min(0, max(y, viewport height - viewport scrolling area height)).
  1057. // FIXME: 9. Let position be the scroll position the viewport would have by aligning the x-coordinate x of the viewport
  1058. // scrolling area with the left of the viewport and aligning the y-coordinate y of the viewport scrolling area
  1059. // with the top of the viewport.
  1060. // FIXME: 10. If position is the same as the viewport’s current scroll position, and the viewport does not have an ongoing
  1061. // smooth scroll, abort these steps.
  1062. // 11. Let document be the viewport’s associated Document.
  1063. auto const* document = top_level_browsing_context.active_document();
  1064. // 12. Perform a scroll of the viewport to position, document’s root element as the associated element, if there is
  1065. // one, or null otherwise, and the scroll behavior being the value of the behavior dictionary member of options.
  1066. auto element = JS::GCPtr<DOM::Node const> { document ? &document->root() : nullptr };
  1067. perform_a_scroll(*page, x, y, element, options.behavior);
  1068. }
  1069. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-scroll
  1070. void Window::scroll(double x, double y)
  1071. {
  1072. // 2. If invoked with two arguments, follow these substeps:
  1073. // 1. Let options be null converted to a ScrollToOptions dictionary. [WEBIDL]
  1074. auto options = ScrollToOptions {};
  1075. // 2. Let x and y be the arguments, respectively.
  1076. options.left = x;
  1077. options.top = y;
  1078. scroll(options);
  1079. }
  1080. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-scrollby
  1081. void Window::scroll_by(ScrollToOptions options)
  1082. {
  1083. // 2. Normalize non-finite values for the left and top dictionary members of options.
  1084. auto x = options.left.value_or(0);
  1085. auto y = options.top.value_or(0);
  1086. x = JS::Value(x).is_finite_number() ? x : 0;
  1087. y = JS::Value(y).is_finite_number() ? y : 0;
  1088. // 3. Add the value of scrollX to the left dictionary member.
  1089. options.left = x + scroll_x();
  1090. // 4. Add the value of scrollY to the top dictionary member.
  1091. options.top = y + scroll_y();
  1092. // 5. Act as if the scroll() method was invoked with options as the only argument.
  1093. scroll(options);
  1094. }
  1095. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-scrollby
  1096. void Window::scroll_by(double x, double y)
  1097. {
  1098. // 1. If invoked with two arguments, follow these substeps:
  1099. // 1. Let options be null converted to a ScrollToOptions dictionary. [WEBIDL]
  1100. auto options = ScrollToOptions {};
  1101. // 2. Let x and y be the arguments, respectively.
  1102. // 3. Let the left dictionary member of options have the value x.
  1103. options.left = x;
  1104. // 4. Let the top dictionary member of options have the value y.
  1105. options.top = y;
  1106. scroll_by(options);
  1107. }
  1108. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-screenx
  1109. i32 Window::screen_x() const
  1110. {
  1111. // The screenX and screenLeft attributes must return the x-coordinate, relative to the origin of the Web-exposed
  1112. // screen area, of the left of the client window as number of CSS pixels, or zero if there is no such thing.
  1113. if (auto* page = this->page())
  1114. return page->window_position().x().value();
  1115. return 0;
  1116. }
  1117. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-screeny
  1118. i32 Window::screen_y() const
  1119. {
  1120. // The screenY and screenTop attributes must return the y-coordinate, relative to the origin of the screen of the
  1121. // Web-exposed screen area, of the top of the client window as number of CSS pixels, or zero if there is no such thing.
  1122. if (auto* page = this->page())
  1123. return page->window_position().y().value();
  1124. return 0;
  1125. }
  1126. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-outerwidth
  1127. i32 Window::outer_width() const
  1128. {
  1129. // The outerWidth attribute must return the width of the client window. If there is no client window this
  1130. // attribute must return zero.
  1131. if (auto* page = this->page())
  1132. return page->window_size().width().value();
  1133. return 0;
  1134. }
  1135. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-outerheight
  1136. i32 Window::outer_height() const
  1137. {
  1138. // The outerHeight attribute must return the height of the client window. If there is no client window this
  1139. // attribute must return zero.
  1140. if (auto* page = this->page())
  1141. return page->window_size().height().value();
  1142. return 0;
  1143. }
  1144. // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-devicepixelratio
  1145. double Window::device_pixel_ratio() const
  1146. {
  1147. // 1. If there is no output device, return 1 and abort these steps.
  1148. // 2. Let CSS pixel size be the size of a CSS pixel at the current page zoom and using a scale factor of 1.0.
  1149. // 3. Let device pixel size be the vertical size of a device pixel of the output device.
  1150. // 4. Return the result of dividing CSS pixel size by device pixel size.
  1151. if (auto* page = this->page())
  1152. return page->client().device_pixels_per_css_pixel();
  1153. return 1;
  1154. }
  1155. // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#dom-animationframeprovider-requestanimationframe
  1156. i32 Window::request_animation_frame(WebIDL::CallbackType& callback)
  1157. {
  1158. // FIXME: Make this fully spec compliant. Currently implements a mix of 'requestAnimationFrame()' and 'run the animation frame callbacks'.
  1159. auto now = HighResolutionTime::unsafe_shared_current_time();
  1160. return m_animation_frame_callback_driver.add([this, now, callback = JS::make_handle(callback)](auto) {
  1161. // 3. Invoke callback, passing now as the only argument, and if an exception is thrown, report the exception.
  1162. auto result = WebIDL::invoke_callback(*callback, {}, JS::Value(now));
  1163. if (result.is_error())
  1164. HTML::report_exception(result, realm());
  1165. });
  1166. }
  1167. // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#animationframeprovider-cancelanimationframe
  1168. void Window::cancel_animation_frame(i32 handle)
  1169. {
  1170. // 1. If this is not supported, then throw a "NotSupportedError" DOMException.
  1171. // NOTE: Doesn't apply in this Window-specific implementation.
  1172. // 2. Let callbacks be this's target object's map of animation frame callbacks.
  1173. // 3. Remove callbacks[handle].
  1174. m_animation_frame_callback_driver.remove(handle);
  1175. }
  1176. // https://w3c.github.io/requestidlecallback/#dom-window-requestidlecallback
  1177. u32 Window::request_idle_callback(WebIDL::CallbackType& callback, RequestIdleCallback::IdleRequestOptions const& options)
  1178. {
  1179. // 1. Let window be this Window object.
  1180. // 2. Increment the window's idle callback identifier by one.
  1181. m_idle_callback_identifier++;
  1182. // 3. Let handle be the current value of window's idle callback identifier.
  1183. auto handle = m_idle_callback_identifier;
  1184. // 4. Push callback to the end of window's list of idle request callbacks, associated with handle.
  1185. auto handler = [callback = JS::make_handle(callback)](JS::NonnullGCPtr<RequestIdleCallback::IdleDeadline> deadline) -> JS::Completion {
  1186. return WebIDL::invoke_callback(*callback, {}, deadline.ptr());
  1187. };
  1188. m_idle_request_callbacks.append(adopt_ref(*new IdleCallback(move(handler), handle)));
  1189. // 5. Return handle and then continue running this algorithm asynchronously.
  1190. return handle;
  1191. // FIXME: 6. If the timeout property is present in options and has a positive value:
  1192. // FIXME: 1. Wait for timeout milliseconds.
  1193. // FIXME: 2. Wait until all invocations of this algorithm, whose timeout added to their posted time occurred before this one's, have completed.
  1194. // FIXME: 3. Optionally, wait a further user-agent defined length of time.
  1195. // FIXME: 4. Queue a task on the queue associated with the idle-task task source, which performs the invoke idle callback timeout algorithm, passing handle and window as arguments.
  1196. (void)options;
  1197. }
  1198. // https://w3c.github.io/requestidlecallback/#dom-window-cancelidlecallback
  1199. void Window::cancel_idle_callback(u32 handle)
  1200. {
  1201. // 1. Let window be this Window object.
  1202. // 2. Find the entry in either the window's list of idle request callbacks or list of runnable idle callbacks
  1203. // that is associated with the value handle.
  1204. // 3. If there is such an entry, remove it from both window's list of idle request callbacks and the list of runnable idle callbacks.
  1205. m_idle_request_callbacks.remove_first_matching([&](auto& callback) {
  1206. return callback->handle() == handle;
  1207. });
  1208. m_runnable_idle_callbacks.remove_first_matching([&](auto& callback) {
  1209. return callback->handle() == handle;
  1210. });
  1211. }
  1212. // https://w3c.github.io/selection-api/#dom-window-getselection
  1213. JS::GCPtr<Selection::Selection> Window::get_selection() const
  1214. {
  1215. // The method must invoke and return the result of getSelection() on this's Window.document attribute.
  1216. return associated_document().get_selection();
  1217. }
  1218. // https://w3c.github.io/hr-time/#dom-windoworworkerglobalscope-performance
  1219. WebIDL::ExceptionOr<JS::NonnullGCPtr<HighResolutionTime::Performance>> Window::performance()
  1220. {
  1221. if (!m_performance)
  1222. m_performance = MUST_OR_THROW_OOM(heap().allocate<HighResolutionTime::Performance>(realm(), *this));
  1223. return JS::NonnullGCPtr { *m_performance };
  1224. }
  1225. // https://w3c.github.io/webcrypto/#dom-windoworworkerglobalscope-crypto
  1226. WebIDL::ExceptionOr<JS::NonnullGCPtr<Crypto::Crypto>> Window::crypto()
  1227. {
  1228. if (!m_crypto)
  1229. m_crypto = MUST_OR_THROW_OOM(heap().allocate<Crypto::Crypto>(realm(), realm()));
  1230. return JS::NonnullGCPtr { *m_crypto };
  1231. }
  1232. static JS::ThrowCompletionOr<TimerHandler> make_timer_handler(JS::VM& vm, JS::Value handler)
  1233. {
  1234. if (handler.is_function())
  1235. return JS::make_handle(vm.heap().allocate_without_realm<WebIDL::CallbackType>(handler.as_function(), HTML::incumbent_settings_object()));
  1236. return TRY(handler.to_deprecated_string(vm));
  1237. }
  1238. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
  1239. JS_DEFINE_NATIVE_FUNCTION(Window::set_timeout)
  1240. {
  1241. auto* impl = TRY(impl_from(vm));
  1242. if (!vm.argument_count())
  1243. return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountAtLeastOne, "setTimeout");
  1244. auto handler = TRY(make_timer_handler(vm, vm.argument(0)));
  1245. i32 timeout = 0;
  1246. if (vm.argument_count() >= 2)
  1247. timeout = TRY(vm.argument(1).to_i32(vm));
  1248. JS::MarkedVector<JS::Value> arguments { vm.heap() };
  1249. for (size_t i = 2; i < vm.argument_count(); ++i)
  1250. arguments.append(vm.argument(i));
  1251. auto id = impl->set_timeout_impl(move(handler), timeout, move(arguments));
  1252. return JS::Value(id);
  1253. }
  1254. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
  1255. JS_DEFINE_NATIVE_FUNCTION(Window::set_interval)
  1256. {
  1257. auto* impl = TRY(impl_from(vm));
  1258. if (!vm.argument_count())
  1259. return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountAtLeastOne, "setInterval");
  1260. auto handler = TRY(make_timer_handler(vm, vm.argument(0)));
  1261. i32 timeout = 0;
  1262. if (vm.argument_count() >= 2)
  1263. timeout = TRY(vm.argument(1).to_i32(vm));
  1264. JS::MarkedVector<JS::Value> arguments { vm.heap() };
  1265. for (size_t i = 2; i < vm.argument_count(); ++i)
  1266. arguments.append(vm.argument(i));
  1267. auto id = impl->set_interval_impl(move(handler), timeout, move(arguments));
  1268. return JS::Value(id);
  1269. }
  1270. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-cleartimeout
  1271. JS_DEFINE_NATIVE_FUNCTION(Window::clear_timeout)
  1272. {
  1273. auto* impl = TRY(impl_from(vm));
  1274. i32 id = 0;
  1275. if (vm.argument_count())
  1276. id = TRY(vm.argument(0).to_i32(vm));
  1277. impl->clear_timeout_impl(id);
  1278. return JS::js_undefined();
  1279. }
  1280. // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-clearinterval
  1281. JS_DEFINE_NATIVE_FUNCTION(Window::clear_interval)
  1282. {
  1283. auto* impl = TRY(impl_from(vm));
  1284. i32 id = 0;
  1285. if (vm.argument_count())
  1286. id = TRY(vm.argument(0).to_i32(vm));
  1287. impl->clear_interval_impl(id);
  1288. return JS::js_undefined();
  1289. }
  1290. // https://html.spec.whatwg.org/multipage/window-object.html#number-of-document-tree-child-browsing-contexts
  1291. size_t Window::document_tree_child_browsing_context_count() const
  1292. {
  1293. // 1. If W's browsing context is null, then return 0.
  1294. auto* this_browsing_context = associated_document().browsing_context();
  1295. if (!this_browsing_context)
  1296. return 0;
  1297. // 2. Return the number of document-tree child browsing contexts of W's browsing context.
  1298. return this_browsing_context->document_tree_child_browsing_context_count();
  1299. }
  1300. JS_DEFINE_NATIVE_FUNCTION(Window::location_setter)
  1301. {
  1302. auto* impl = TRY(impl_from(vm));
  1303. TRY(impl->m_location->set(JS::PropertyKey("href"), vm.argument(0), JS::Object::ShouldThrowExceptions::Yes));
  1304. return JS::js_undefined();
  1305. }
  1306. }