1/*
2 This file is part of the WebKit open source project.
3 This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public License
16 along with this library; see the file COPYING.LIB. If not, write to
17 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
19*/
20
21#include "config.h"
22#include "JSInternals.h"
23
24#include "Document.h"
25#include "JSCSSStyleDeclaration.h"
26#include "JSDOMAttribute.h"
27#include "JSDOMBinding.h"
28#include "JSDOMConvertAny.h"
29#include "JSDOMConvertBoolean.h"
30#include "JSDOMConvertBufferSource.h"
31#include "JSDOMConvertCallbacks.h"
32#include "JSDOMConvertInterface.h"
33#include "JSDOMConvertNullable.h"
34#include "JSDOMConvertNumbers.h"
35#include "JSDOMConvertSequences.h"
36#include "JSDOMConvertSerializedScriptValue.h"
37#include "JSDOMConvertStrings.h"
38#include "JSDOMExceptionHandling.h"
39#include "JSDOMGlobalObject.h"
40#include "JSDOMOperation.h"
41#include "JSDOMOperationReturningPromise.h"
42#include "JSDOMRect.h"
43#include "JSDOMRectList.h"
44#include "JSDOMURL.h"
45#include "JSDOMWrapperCache.h"
46#include "JSDocument.h"
47#include "JSElement.h"
48#include "JSFetchResponse.h"
49#include "JSFile.h"
50#include "JSGCObservation.h"
51#include "JSHTMLImageElement.h"
52#include "JSHTMLInputElement.h"
53#include "JSHTMLLinkElement.h"
54#include "JSHTMLSelectElement.h"
55#include "JSInternalSettings.h"
56#include "JSMallocStatistics.h"
57#include "JSMemoryInfo.h"
58#include "JSMockPageOverlay.h"
59#include "JSNode.h"
60#include "JSNodeList.h"
61#include "JSRange.h"
62#include "JSSVGSVGElement.h"
63#include "JSStringCallback.h"
64#include "JSStyleSheet.h"
65#include "JSTypeConversions.h"
66#include "JSVoidCallback.h"
67#include "JSWindowProxy.h"
68#include "JSXMLHttpRequest.h"
69#include "ScriptExecutionContext.h"
70#include "SerializedScriptValue.h"
71#include <JavaScriptCore/HeapSnapshotBuilder.h>
72#include <JavaScriptCore/JSArray.h>
73#include <JavaScriptCore/JSCInlines.h>
74#include <JavaScriptCore/JSString.h>
75#include <JavaScriptCore/ObjectConstructor.h>
76#include <wtf/GetPtr.h>
77#include <wtf/PointerPreparations.h>
78#include <wtf/URL.h>
79
80#if ENABLE(APPLE_PAY)
81#include "JSMockPaymentCoordinator.h"
82#endif
83
84#if ENABLE(CONTENT_FILTERING)
85#include "JSMockContentFilterSettings.h"
86#endif
87
88#if ENABLE(ENCRYPTED_MEDIA)
89#include "JSMockCDMFactory.h"
90#endif
91
92#if ENABLE(MEDIA_SESSION)
93#include "JSMediaSession.h"
94#endif
95
96#if ENABLE(MEDIA_SESSION) || ENABLE(VIDEO)
97#include "JSHTMLMediaElement.h"
98#endif
99
100#if ENABLE(MEDIA_SOURCE)
101#include "JSSourceBuffer.h"
102#endif
103
104#if ENABLE(MEDIA_STREAM)
105#include "JSMediaStream.h"
106#include "JSMediaStreamTrack.h"
107#endif
108
109#if ENABLE(SERVICE_WORKER)
110#include "JSServiceWorker.h"
111#endif
112
113#if ENABLE(VIDEO)
114#include "JSTimeRanges.h"
115#endif
116
117#if ENABLE(VIDEO_TRACK)
118#include "JSTextTrackCueGeneric.h"
119#endif
120
121#if ENABLE(WEBGL)
122#include "JSWebGLRenderingContext.h"
123#endif
124
125#if ENABLE(WEB_AUDIO)
126#include "JSAudioContext.h"
127#endif
128
129#if ENABLE(WEB_RTC)
130#include "JSRTCPeerConnection.h"
131#endif
132
133
134namespace WebCore {
135using namespace JSC;
136
137String convertEnumerationToString(Internals::PageOverlayType enumerationValue)
138{
139 static const NeverDestroyed<String> values[] = {
140 MAKE_STATIC_STRING_IMPL("view"),
141 MAKE_STATIC_STRING_IMPL("document"),
142 };
143 static_assert(static_cast<size_t>(Internals::PageOverlayType::View) == 0, "Internals::PageOverlayType::View is not 0 as expected");
144 static_assert(static_cast<size_t>(Internals::PageOverlayType::Document) == 1, "Internals::PageOverlayType::Document is not 1 as expected");
145 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
146 return values[static_cast<size_t>(enumerationValue)];
147}
148
149template<> JSString* convertEnumerationToJS(ExecState& state, Internals::PageOverlayType enumerationValue)
150{
151 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
152}
153
154template<> Optional<Internals::PageOverlayType> parseEnumeration<Internals::PageOverlayType>(ExecState& state, JSValue value)
155{
156 auto stringValue = value.toWTFString(&state);
157 if (stringValue == "view")
158 return Internals::PageOverlayType::View;
159 if (stringValue == "document")
160 return Internals::PageOverlayType::Document;
161 return WTF::nullopt;
162}
163
164template<> const char* expectedEnumerationValues<Internals::PageOverlayType>()
165{
166 return "\"view\", \"document\"";
167}
168
169String convertEnumerationToString(Internals::CachePolicy enumerationValue)
170{
171 static const NeverDestroyed<String> values[] = {
172 MAKE_STATIC_STRING_IMPL("UseProtocolCachePolicy"),
173 MAKE_STATIC_STRING_IMPL("ReloadIgnoringCacheData"),
174 MAKE_STATIC_STRING_IMPL("ReturnCacheDataElseLoad"),
175 MAKE_STATIC_STRING_IMPL("ReturnCacheDataDontLoad"),
176 };
177 static_assert(static_cast<size_t>(Internals::CachePolicy::UseProtocolCachePolicy) == 0, "Internals::CachePolicy::UseProtocolCachePolicy is not 0 as expected");
178 static_assert(static_cast<size_t>(Internals::CachePolicy::ReloadIgnoringCacheData) == 1, "Internals::CachePolicy::ReloadIgnoringCacheData is not 1 as expected");
179 static_assert(static_cast<size_t>(Internals::CachePolicy::ReturnCacheDataElseLoad) == 2, "Internals::CachePolicy::ReturnCacheDataElseLoad is not 2 as expected");
180 static_assert(static_cast<size_t>(Internals::CachePolicy::ReturnCacheDataDontLoad) == 3, "Internals::CachePolicy::ReturnCacheDataDontLoad is not 3 as expected");
181 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
182 return values[static_cast<size_t>(enumerationValue)];
183}
184
185template<> JSString* convertEnumerationToJS(ExecState& state, Internals::CachePolicy enumerationValue)
186{
187 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
188}
189
190template<> Optional<Internals::CachePolicy> parseEnumeration<Internals::CachePolicy>(ExecState& state, JSValue value)
191{
192 auto stringValue = value.toWTFString(&state);
193 if (stringValue == "UseProtocolCachePolicy")
194 return Internals::CachePolicy::UseProtocolCachePolicy;
195 if (stringValue == "ReloadIgnoringCacheData")
196 return Internals::CachePolicy::ReloadIgnoringCacheData;
197 if (stringValue == "ReturnCacheDataElseLoad")
198 return Internals::CachePolicy::ReturnCacheDataElseLoad;
199 if (stringValue == "ReturnCacheDataDontLoad")
200 return Internals::CachePolicy::ReturnCacheDataDontLoad;
201 return WTF::nullopt;
202}
203
204template<> const char* expectedEnumerationValues<Internals::CachePolicy>()
205{
206 return "\"UseProtocolCachePolicy\", \"ReloadIgnoringCacheData\", \"ReturnCacheDataElseLoad\", \"ReturnCacheDataDontLoad\"";
207}
208
209String convertEnumerationToString(Internals::ResourceLoadPriority enumerationValue)
210{
211 static const NeverDestroyed<String> values[] = {
212 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityVeryLow"),
213 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityLow"),
214 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityMedium"),
215 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityHigh"),
216 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityVeryHigh"),
217 };
218 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow) == 0, "Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow is not 0 as expected");
219 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityLow) == 1, "Internals::ResourceLoadPriority::ResourceLoadPriorityLow is not 1 as expected");
220 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityMedium) == 2, "Internals::ResourceLoadPriority::ResourceLoadPriorityMedium is not 2 as expected");
221 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityHigh) == 3, "Internals::ResourceLoadPriority::ResourceLoadPriorityHigh is not 3 as expected");
222 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh) == 4, "Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh is not 4 as expected");
223 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
224 return values[static_cast<size_t>(enumerationValue)];
225}
226
227template<> JSString* convertEnumerationToJS(ExecState& state, Internals::ResourceLoadPriority enumerationValue)
228{
229 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
230}
231
232template<> Optional<Internals::ResourceLoadPriority> parseEnumeration<Internals::ResourceLoadPriority>(ExecState& state, JSValue value)
233{
234 auto stringValue = value.toWTFString(&state);
235 if (stringValue == "ResourceLoadPriorityVeryLow")
236 return Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow;
237 if (stringValue == "ResourceLoadPriorityLow")
238 return Internals::ResourceLoadPriority::ResourceLoadPriorityLow;
239 if (stringValue == "ResourceLoadPriorityMedium")
240 return Internals::ResourceLoadPriority::ResourceLoadPriorityMedium;
241 if (stringValue == "ResourceLoadPriorityHigh")
242 return Internals::ResourceLoadPriority::ResourceLoadPriorityHigh;
243 if (stringValue == "ResourceLoadPriorityVeryHigh")
244 return Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh;
245 return WTF::nullopt;
246}
247
248template<> const char* expectedEnumerationValues<Internals::ResourceLoadPriority>()
249{
250 return "\"ResourceLoadPriorityVeryLow\", \"ResourceLoadPriorityLow\", \"ResourceLoadPriorityMedium\", \"ResourceLoadPriorityHigh\", \"ResourceLoadPriorityVeryHigh\"";
251}
252
253#if ENABLE(MEDIA_SESSION)
254
255String convertEnumerationToString(Internals::MediaSessionInterruptingCategory enumerationValue)
256{
257 static const NeverDestroyed<String> values[] = {
258 MAKE_STATIC_STRING_IMPL("content"),
259 MAKE_STATIC_STRING_IMPL("transient"),
260 MAKE_STATIC_STRING_IMPL("transient-solo"),
261 };
262 static_assert(static_cast<size_t>(Internals::MediaSessionInterruptingCategory::Content) == 0, "Internals::MediaSessionInterruptingCategory::Content is not 0 as expected");
263 static_assert(static_cast<size_t>(Internals::MediaSessionInterruptingCategory::Transient) == 1, "Internals::MediaSessionInterruptingCategory::Transient is not 1 as expected");
264 static_assert(static_cast<size_t>(Internals::MediaSessionInterruptingCategory::TransientSolo) == 2, "Internals::MediaSessionInterruptingCategory::TransientSolo is not 2 as expected");
265 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
266 return values[static_cast<size_t>(enumerationValue)];
267}
268
269template<> JSString* convertEnumerationToJS(ExecState& state, Internals::MediaSessionInterruptingCategory enumerationValue)
270{
271 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
272}
273
274template<> Optional<Internals::MediaSessionInterruptingCategory> parseEnumeration<Internals::MediaSessionInterruptingCategory>(ExecState& state, JSValue value)
275{
276 auto stringValue = value.toWTFString(&state);
277 if (stringValue == "content")
278 return Internals::MediaSessionInterruptingCategory::Content;
279 if (stringValue == "transient")
280 return Internals::MediaSessionInterruptingCategory::Transient;
281 if (stringValue == "transient-solo")
282 return Internals::MediaSessionInterruptingCategory::TransientSolo;
283 return WTF::nullopt;
284}
285
286template<> const char* expectedEnumerationValues<Internals::MediaSessionInterruptingCategory>()
287{
288 return "\"content\", \"transient\", \"transient-solo\"";
289}
290
291#endif
292
293#if ENABLE(MEDIA_SESSION)
294
295String convertEnumerationToString(Internals::MediaControlEvent enumerationValue)
296{
297 static const NeverDestroyed<String> values[] = {
298 MAKE_STATIC_STRING_IMPL("play-pause"),
299 MAKE_STATIC_STRING_IMPL("next-track"),
300 MAKE_STATIC_STRING_IMPL("previous-track"),
301 };
302 static_assert(static_cast<size_t>(Internals::MediaControlEvent::PlayPause) == 0, "Internals::MediaControlEvent::PlayPause is not 0 as expected");
303 static_assert(static_cast<size_t>(Internals::MediaControlEvent::NextTrack) == 1, "Internals::MediaControlEvent::NextTrack is not 1 as expected");
304 static_assert(static_cast<size_t>(Internals::MediaControlEvent::PreviousTrack) == 2, "Internals::MediaControlEvent::PreviousTrack is not 2 as expected");
305 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
306 return values[static_cast<size_t>(enumerationValue)];
307}
308
309template<> JSString* convertEnumerationToJS(ExecState& state, Internals::MediaControlEvent enumerationValue)
310{
311 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
312}
313
314template<> Optional<Internals::MediaControlEvent> parseEnumeration<Internals::MediaControlEvent>(ExecState& state, JSValue value)
315{
316 auto stringValue = value.toWTFString(&state);
317 if (stringValue == "play-pause")
318 return Internals::MediaControlEvent::PlayPause;
319 if (stringValue == "next-track")
320 return Internals::MediaControlEvent::NextTrack;
321 if (stringValue == "previous-track")
322 return Internals::MediaControlEvent::PreviousTrack;
323 return WTF::nullopt;
324}
325
326template<> const char* expectedEnumerationValues<Internals::MediaControlEvent>()
327{
328 return "\"play-pause\", \"next-track\", \"previous-track\"";
329}
330
331#endif
332
333String convertEnumerationToString(Internals::AutoFillButtonType enumerationValue)
334{
335 static const NeverDestroyed<String> values[] = {
336 MAKE_STATIC_STRING_IMPL("None"),
337 MAKE_STATIC_STRING_IMPL("Contacts"),
338 MAKE_STATIC_STRING_IMPL("Credentials"),
339 MAKE_STATIC_STRING_IMPL("StrongPassword"),
340 MAKE_STATIC_STRING_IMPL("CreditCard"),
341 };
342 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::None) == 0, "Internals::AutoFillButtonType::None is not 0 as expected");
343 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::Contacts) == 1, "Internals::AutoFillButtonType::Contacts is not 1 as expected");
344 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::Credentials) == 2, "Internals::AutoFillButtonType::Credentials is not 2 as expected");
345 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::StrongPassword) == 3, "Internals::AutoFillButtonType::StrongPassword is not 3 as expected");
346 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::CreditCard) == 4, "Internals::AutoFillButtonType::CreditCard is not 4 as expected");
347 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
348 return values[static_cast<size_t>(enumerationValue)];
349}
350
351template<> JSString* convertEnumerationToJS(ExecState& state, Internals::AutoFillButtonType enumerationValue)
352{
353 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
354}
355
356template<> Optional<Internals::AutoFillButtonType> parseEnumeration<Internals::AutoFillButtonType>(ExecState& state, JSValue value)
357{
358 auto stringValue = value.toWTFString(&state);
359 if (stringValue == "None")
360 return Internals::AutoFillButtonType::None;
361 if (stringValue == "Contacts")
362 return Internals::AutoFillButtonType::Contacts;
363 if (stringValue == "Credentials")
364 return Internals::AutoFillButtonType::Credentials;
365 if (stringValue == "StrongPassword")
366 return Internals::AutoFillButtonType::StrongPassword;
367 if (stringValue == "CreditCard")
368 return Internals::AutoFillButtonType::CreditCard;
369 return WTF::nullopt;
370}
371
372template<> const char* expectedEnumerationValues<Internals::AutoFillButtonType>()
373{
374 return "\"None\", \"Contacts\", \"Credentials\", \"StrongPassword\", \"CreditCard\"";
375}
376
377String convertEnumerationToString(Internals::UserInterfaceLayoutDirection enumerationValue)
378{
379 static const NeverDestroyed<String> values[] = {
380 MAKE_STATIC_STRING_IMPL("LTR"),
381 MAKE_STATIC_STRING_IMPL("RTL"),
382 };
383 static_assert(static_cast<size_t>(Internals::UserInterfaceLayoutDirection::LTR) == 0, "Internals::UserInterfaceLayoutDirection::LTR is not 0 as expected");
384 static_assert(static_cast<size_t>(Internals::UserInterfaceLayoutDirection::RTL) == 1, "Internals::UserInterfaceLayoutDirection::RTL is not 1 as expected");
385 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
386 return values[static_cast<size_t>(enumerationValue)];
387}
388
389template<> JSString* convertEnumerationToJS(ExecState& state, Internals::UserInterfaceLayoutDirection enumerationValue)
390{
391 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
392}
393
394template<> Optional<Internals::UserInterfaceLayoutDirection> parseEnumeration<Internals::UserInterfaceLayoutDirection>(ExecState& state, JSValue value)
395{
396 auto stringValue = value.toWTFString(&state);
397 if (stringValue == "LTR")
398 return Internals::UserInterfaceLayoutDirection::LTR;
399 if (stringValue == "RTL")
400 return Internals::UserInterfaceLayoutDirection::RTL;
401 return WTF::nullopt;
402}
403
404template<> const char* expectedEnumerationValues<Internals::UserInterfaceLayoutDirection>()
405{
406 return "\"LTR\", \"RTL\"";
407}
408
409String convertEnumerationToString(Internals::BaseWritingDirection enumerationValue)
410{
411 static const NeverDestroyed<String> values[] = {
412 MAKE_STATIC_STRING_IMPL("Natural"),
413 MAKE_STATIC_STRING_IMPL("Ltr"),
414 MAKE_STATIC_STRING_IMPL("Rtl"),
415 };
416 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Natural) == 0, "Internals::BaseWritingDirection::Natural is not 0 as expected");
417 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Ltr) == 1, "Internals::BaseWritingDirection::Ltr is not 1 as expected");
418 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Rtl) == 2, "Internals::BaseWritingDirection::Rtl is not 2 as expected");
419 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
420 return values[static_cast<size_t>(enumerationValue)];
421}
422
423template<> JSString* convertEnumerationToJS(ExecState& state, Internals::BaseWritingDirection enumerationValue)
424{
425 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
426}
427
428template<> Optional<Internals::BaseWritingDirection> parseEnumeration<Internals::BaseWritingDirection>(ExecState& state, JSValue value)
429{
430 auto stringValue = value.toWTFString(&state);
431 if (stringValue == "Natural")
432 return Internals::BaseWritingDirection::Natural;
433 if (stringValue == "Ltr")
434 return Internals::BaseWritingDirection::Ltr;
435 if (stringValue == "Rtl")
436 return Internals::BaseWritingDirection::Rtl;
437 return WTF::nullopt;
438}
439
440template<> const char* expectedEnumerationValues<Internals::BaseWritingDirection>()
441{
442 return "\"Natural\", \"Ltr\", \"Rtl\"";
443}
444
445String convertEnumerationToString(Internals::EventThrottlingBehavior enumerationValue)
446{
447 static const NeverDestroyed<String> values[] = {
448 MAKE_STATIC_STRING_IMPL("responsive"),
449 MAKE_STATIC_STRING_IMPL("unresponsive"),
450 };
451 static_assert(static_cast<size_t>(Internals::EventThrottlingBehavior::Responsive) == 0, "Internals::EventThrottlingBehavior::Responsive is not 0 as expected");
452 static_assert(static_cast<size_t>(Internals::EventThrottlingBehavior::Unresponsive) == 1, "Internals::EventThrottlingBehavior::Unresponsive is not 1 as expected");
453 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
454 return values[static_cast<size_t>(enumerationValue)];
455}
456
457template<> JSString* convertEnumerationToJS(ExecState& state, Internals::EventThrottlingBehavior enumerationValue)
458{
459 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
460}
461
462template<> Optional<Internals::EventThrottlingBehavior> parseEnumeration<Internals::EventThrottlingBehavior>(ExecState& state, JSValue value)
463{
464 auto stringValue = value.toWTFString(&state);
465 if (stringValue == "responsive")
466 return Internals::EventThrottlingBehavior::Responsive;
467 if (stringValue == "unresponsive")
468 return Internals::EventThrottlingBehavior::Unresponsive;
469 return WTF::nullopt;
470}
471
472template<> const char* expectedEnumerationValues<Internals::EventThrottlingBehavior>()
473{
474 return "\"responsive\", \"unresponsive\"";
475}
476
477String convertEnumerationToString(Internals::CompositingPolicy enumerationValue)
478{
479 static const NeverDestroyed<String> values[] = {
480 MAKE_STATIC_STRING_IMPL("normal"),
481 MAKE_STATIC_STRING_IMPL("conservative"),
482 };
483 static_assert(static_cast<size_t>(Internals::CompositingPolicy::Normal) == 0, "Internals::CompositingPolicy::Normal is not 0 as expected");
484 static_assert(static_cast<size_t>(Internals::CompositingPolicy::Conservative) == 1, "Internals::CompositingPolicy::Conservative is not 1 as expected");
485 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
486 return values[static_cast<size_t>(enumerationValue)];
487}
488
489template<> JSString* convertEnumerationToJS(ExecState& state, Internals::CompositingPolicy enumerationValue)
490{
491 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
492}
493
494template<> Optional<Internals::CompositingPolicy> parseEnumeration<Internals::CompositingPolicy>(ExecState& state, JSValue value)
495{
496 auto stringValue = value.toWTFString(&state);
497 if (stringValue == "normal")
498 return Internals::CompositingPolicy::Normal;
499 if (stringValue == "conservative")
500 return Internals::CompositingPolicy::Conservative;
501 return WTF::nullopt;
502}
503
504template<> const char* expectedEnumerationValues<Internals::CompositingPolicy>()
505{
506 return "\"normal\", \"conservative\"";
507}
508
509#if ENABLE(VIDEO)
510
511String convertEnumerationToString(Internals::PlaybackControlsPurpose enumerationValue)
512{
513 static const NeverDestroyed<String> values[] = {
514 MAKE_STATIC_STRING_IMPL("ControlsManager"),
515 MAKE_STATIC_STRING_IMPL("NowPlaying"),
516 };
517 static_assert(static_cast<size_t>(Internals::PlaybackControlsPurpose::ControlsManager) == 0, "Internals::PlaybackControlsPurpose::ControlsManager is not 0 as expected");
518 static_assert(static_cast<size_t>(Internals::PlaybackControlsPurpose::NowPlaying) == 1, "Internals::PlaybackControlsPurpose::NowPlaying is not 1 as expected");
519 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
520 return values[static_cast<size_t>(enumerationValue)];
521}
522
523template<> JSString* convertEnumerationToJS(ExecState& state, Internals::PlaybackControlsPurpose enumerationValue)
524{
525 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
526}
527
528template<> Optional<Internals::PlaybackControlsPurpose> parseEnumeration<Internals::PlaybackControlsPurpose>(ExecState& state, JSValue value)
529{
530 auto stringValue = value.toWTFString(&state);
531 if (stringValue == "ControlsManager")
532 return Internals::PlaybackControlsPurpose::ControlsManager;
533 if (stringValue == "NowPlaying")
534 return Internals::PlaybackControlsPurpose::NowPlaying;
535 return WTF::nullopt;
536}
537
538template<> const char* expectedEnumerationValues<Internals::PlaybackControlsPurpose>()
539{
540 return "\"ControlsManager\", \"NowPlaying\"";
541}
542
543#endif
544
545#if ENABLE(VIDEO)
546
547String convertEnumerationToString(Internals::MediaSessionState enumerationValue)
548{
549 static const NeverDestroyed<String> values[] = {
550 MAKE_STATIC_STRING_IMPL("Idle"),
551 MAKE_STATIC_STRING_IMPL("Autoplaying"),
552 MAKE_STATIC_STRING_IMPL("Playing"),
553 MAKE_STATIC_STRING_IMPL("Paused"),
554 MAKE_STATIC_STRING_IMPL("Interrupted"),
555 };
556 static_assert(static_cast<size_t>(Internals::MediaSessionState::Idle) == 0, "Internals::MediaSessionState::Idle is not 0 as expected");
557 static_assert(static_cast<size_t>(Internals::MediaSessionState::Autoplaying) == 1, "Internals::MediaSessionState::Autoplaying is not 1 as expected");
558 static_assert(static_cast<size_t>(Internals::MediaSessionState::Playing) == 2, "Internals::MediaSessionState::Playing is not 2 as expected");
559 static_assert(static_cast<size_t>(Internals::MediaSessionState::Paused) == 3, "Internals::MediaSessionState::Paused is not 3 as expected");
560 static_assert(static_cast<size_t>(Internals::MediaSessionState::Interrupted) == 4, "Internals::MediaSessionState::Interrupted is not 4 as expected");
561 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
562 return values[static_cast<size_t>(enumerationValue)];
563}
564
565template<> JSString* convertEnumerationToJS(ExecState& state, Internals::MediaSessionState enumerationValue)
566{
567 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
568}
569
570template<> Optional<Internals::MediaSessionState> parseEnumeration<Internals::MediaSessionState>(ExecState& state, JSValue value)
571{
572 auto stringValue = value.toWTFString(&state);
573 if (stringValue == "Idle")
574 return Internals::MediaSessionState::Idle;
575 if (stringValue == "Autoplaying")
576 return Internals::MediaSessionState::Autoplaying;
577 if (stringValue == "Playing")
578 return Internals::MediaSessionState::Playing;
579 if (stringValue == "Paused")
580 return Internals::MediaSessionState::Paused;
581 if (stringValue == "Interrupted")
582 return Internals::MediaSessionState::Interrupted;
583 return WTF::nullopt;
584}
585
586template<> const char* expectedEnumerationValues<Internals::MediaSessionState>()
587{
588 return "\"Idle\", \"Autoplaying\", \"Playing\", \"Paused\", \"Interrupted\"";
589}
590
591#endif
592
593#if ENABLE(VIDEO)
594
595template<> Internals::NowPlayingState convertDictionary<Internals::NowPlayingState>(ExecState& state, JSValue value)
596{
597 VM& vm = state.vm();
598 auto throwScope = DECLARE_THROW_SCOPE(vm);
599 bool isNullOrUndefined = value.isUndefinedOrNull();
600 auto* object = isNullOrUndefined ? nullptr : value.getObject();
601 if (UNLIKELY(!isNullOrUndefined && !object)) {
602 throwTypeError(&state, throwScope);
603 return { };
604 }
605 Internals::NowPlayingState result;
606 JSValue durationValue;
607 if (isNullOrUndefined)
608 durationValue = jsUndefined();
609 else {
610 durationValue = object->get(&state, Identifier::fromString(&state, "duration"));
611 RETURN_IF_EXCEPTION(throwScope, { });
612 }
613 if (!durationValue.isUndefined()) {
614 result.duration = convert<IDLUnrestrictedDouble>(state, durationValue);
615 RETURN_IF_EXCEPTION(throwScope, { });
616 }
617 JSValue elapsedTimeValue;
618 if (isNullOrUndefined)
619 elapsedTimeValue = jsUndefined();
620 else {
621 elapsedTimeValue = object->get(&state, Identifier::fromString(&state, "elapsedTime"));
622 RETURN_IF_EXCEPTION(throwScope, { });
623 }
624 if (!elapsedTimeValue.isUndefined()) {
625 result.elapsedTime = convert<IDLUnrestrictedDouble>(state, elapsedTimeValue);
626 RETURN_IF_EXCEPTION(throwScope, { });
627 }
628 JSValue hasActiveSessionValue;
629 if (isNullOrUndefined)
630 hasActiveSessionValue = jsUndefined();
631 else {
632 hasActiveSessionValue = object->get(&state, Identifier::fromString(&state, "hasActiveSession"));
633 RETURN_IF_EXCEPTION(throwScope, { });
634 }
635 if (!hasActiveSessionValue.isUndefined()) {
636 result.hasActiveSession = convert<IDLBoolean>(state, hasActiveSessionValue);
637 RETURN_IF_EXCEPTION(throwScope, { });
638 }
639 JSValue registeredAsNowPlayingApplicationValue;
640 if (isNullOrUndefined)
641 registeredAsNowPlayingApplicationValue = jsUndefined();
642 else {
643 registeredAsNowPlayingApplicationValue = object->get(&state, Identifier::fromString(&state, "registeredAsNowPlayingApplication"));
644 RETURN_IF_EXCEPTION(throwScope, { });
645 }
646 if (!registeredAsNowPlayingApplicationValue.isUndefined()) {
647 result.registeredAsNowPlayingApplication = convert<IDLBoolean>(state, registeredAsNowPlayingApplicationValue);
648 RETURN_IF_EXCEPTION(throwScope, { });
649 }
650 JSValue titleValue;
651 if (isNullOrUndefined)
652 titleValue = jsUndefined();
653 else {
654 titleValue = object->get(&state, Identifier::fromString(&state, "title"));
655 RETURN_IF_EXCEPTION(throwScope, { });
656 }
657 if (!titleValue.isUndefined()) {
658 result.title = convert<IDLDOMString>(state, titleValue);
659 RETURN_IF_EXCEPTION(throwScope, { });
660 }
661 JSValue uniqueIdentifierValue;
662 if (isNullOrUndefined)
663 uniqueIdentifierValue = jsUndefined();
664 else {
665 uniqueIdentifierValue = object->get(&state, Identifier::fromString(&state, "uniqueIdentifier"));
666 RETURN_IF_EXCEPTION(throwScope, { });
667 }
668 if (!uniqueIdentifierValue.isUndefined()) {
669 result.uniqueIdentifier = convert<IDLUnsignedLongLong>(state, uniqueIdentifierValue);
670 RETURN_IF_EXCEPTION(throwScope, { });
671 }
672 return result;
673}
674
675JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::NowPlayingState& dictionary)
676{
677 auto& vm = state.vm();
678
679 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
680
681 if (!IDLUnrestrictedDouble::isNullValue(dictionary.duration)) {
682 auto durationValue = toJS<IDLUnrestrictedDouble>(IDLUnrestrictedDouble::extractValueFromNullable(dictionary.duration));
683 result->putDirect(vm, JSC::Identifier::fromString(&vm, "duration"), durationValue);
684 }
685 if (!IDLUnrestrictedDouble::isNullValue(dictionary.elapsedTime)) {
686 auto elapsedTimeValue = toJS<IDLUnrestrictedDouble>(IDLUnrestrictedDouble::extractValueFromNullable(dictionary.elapsedTime));
687 result->putDirect(vm, JSC::Identifier::fromString(&vm, "elapsedTime"), elapsedTimeValue);
688 }
689 if (!IDLBoolean::isNullValue(dictionary.hasActiveSession)) {
690 auto hasActiveSessionValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.hasActiveSession));
691 result->putDirect(vm, JSC::Identifier::fromString(&vm, "hasActiveSession"), hasActiveSessionValue);
692 }
693 if (!IDLBoolean::isNullValue(dictionary.registeredAsNowPlayingApplication)) {
694 auto registeredAsNowPlayingApplicationValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.registeredAsNowPlayingApplication));
695 result->putDirect(vm, JSC::Identifier::fromString(&vm, "registeredAsNowPlayingApplication"), registeredAsNowPlayingApplicationValue);
696 }
697 if (!IDLDOMString::isNullValue(dictionary.title)) {
698 auto titleValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.title));
699 result->putDirect(vm, JSC::Identifier::fromString(&vm, "title"), titleValue);
700 }
701 if (!IDLUnsignedLongLong::isNullValue(dictionary.uniqueIdentifier)) {
702 auto uniqueIdentifierValue = toJS<IDLUnsignedLongLong>(IDLUnsignedLongLong::extractValueFromNullable(dictionary.uniqueIdentifier));
703 result->putDirect(vm, JSC::Identifier::fromString(&vm, "uniqueIdentifier"), uniqueIdentifierValue);
704 }
705 return result;
706}
707
708#endif
709
710template<> Internals::FullscreenInsets convertDictionary<Internals::FullscreenInsets>(ExecState& state, JSValue value)
711{
712 VM& vm = state.vm();
713 auto throwScope = DECLARE_THROW_SCOPE(vm);
714 bool isNullOrUndefined = value.isUndefinedOrNull();
715 auto* object = isNullOrUndefined ? nullptr : value.getObject();
716 if (UNLIKELY(!isNullOrUndefined && !object)) {
717 throwTypeError(&state, throwScope);
718 return { };
719 }
720 Internals::FullscreenInsets result;
721 JSValue bottomValue;
722 if (isNullOrUndefined)
723 bottomValue = jsUndefined();
724 else {
725 bottomValue = object->get(&state, Identifier::fromString(&state, "bottom"));
726 RETURN_IF_EXCEPTION(throwScope, { });
727 }
728 if (!bottomValue.isUndefined()) {
729 result.bottom = convert<IDLDouble>(state, bottomValue);
730 RETURN_IF_EXCEPTION(throwScope, { });
731 }
732 JSValue leftValue;
733 if (isNullOrUndefined)
734 leftValue = jsUndefined();
735 else {
736 leftValue = object->get(&state, Identifier::fromString(&state, "left"));
737 RETURN_IF_EXCEPTION(throwScope, { });
738 }
739 if (!leftValue.isUndefined()) {
740 result.left = convert<IDLDouble>(state, leftValue);
741 RETURN_IF_EXCEPTION(throwScope, { });
742 }
743 JSValue rightValue;
744 if (isNullOrUndefined)
745 rightValue = jsUndefined();
746 else {
747 rightValue = object->get(&state, Identifier::fromString(&state, "right"));
748 RETURN_IF_EXCEPTION(throwScope, { });
749 }
750 if (!rightValue.isUndefined()) {
751 result.right = convert<IDLDouble>(state, rightValue);
752 RETURN_IF_EXCEPTION(throwScope, { });
753 }
754 JSValue topValue;
755 if (isNullOrUndefined)
756 topValue = jsUndefined();
757 else {
758 topValue = object->get(&state, Identifier::fromString(&state, "top"));
759 RETURN_IF_EXCEPTION(throwScope, { });
760 }
761 if (!topValue.isUndefined()) {
762 result.top = convert<IDLDouble>(state, topValue);
763 RETURN_IF_EXCEPTION(throwScope, { });
764 }
765 return result;
766}
767
768JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::FullscreenInsets& dictionary)
769{
770 auto& vm = state.vm();
771
772 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
773
774 if (!IDLDouble::isNullValue(dictionary.bottom)) {
775 auto bottomValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.bottom));
776 result->putDirect(vm, JSC::Identifier::fromString(&vm, "bottom"), bottomValue);
777 }
778 if (!IDLDouble::isNullValue(dictionary.left)) {
779 auto leftValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.left));
780 result->putDirect(vm, JSC::Identifier::fromString(&vm, "left"), leftValue);
781 }
782 if (!IDLDouble::isNullValue(dictionary.right)) {
783 auto rightValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.right));
784 result->putDirect(vm, JSC::Identifier::fromString(&vm, "right"), rightValue);
785 }
786 if (!IDLDouble::isNullValue(dictionary.top)) {
787 auto topValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.top));
788 result->putDirect(vm, JSC::Identifier::fromString(&vm, "top"), topValue);
789 }
790 return result;
791}
792
793template<> Internals::HEVCParameterSet convertDictionary<Internals::HEVCParameterSet>(ExecState& state, JSValue value)
794{
795 VM& vm = state.vm();
796 auto throwScope = DECLARE_THROW_SCOPE(vm);
797 bool isNullOrUndefined = value.isUndefinedOrNull();
798 auto* object = isNullOrUndefined ? nullptr : value.getObject();
799 if (UNLIKELY(!isNullOrUndefined && !object)) {
800 throwTypeError(&state, throwScope);
801 return { };
802 }
803 Internals::HEVCParameterSet result;
804 JSValue codecNameValue;
805 if (isNullOrUndefined)
806 codecNameValue = jsUndefined();
807 else {
808 codecNameValue = object->get(&state, Identifier::fromString(&state, "codecName"));
809 RETURN_IF_EXCEPTION(throwScope, { });
810 }
811 if (!codecNameValue.isUndefined()) {
812 result.codecName = convert<IDLDOMString>(state, codecNameValue);
813 RETURN_IF_EXCEPTION(throwScope, { });
814 }
815 JSValue constraintFlagsValue;
816 if (isNullOrUndefined)
817 constraintFlagsValue = jsUndefined();
818 else {
819 constraintFlagsValue = object->get(&state, Identifier::fromString(&state, "constraintFlags"));
820 RETURN_IF_EXCEPTION(throwScope, { });
821 }
822 if (!constraintFlagsValue.isUndefined()) {
823 result.constraintFlags = convert<IDLSequence<IDLUnsignedShort>>(state, constraintFlagsValue);
824 RETURN_IF_EXCEPTION(throwScope, { });
825 }
826 JSValue generalLevelIDCValue;
827 if (isNullOrUndefined)
828 generalLevelIDCValue = jsUndefined();
829 else {
830 generalLevelIDCValue = object->get(&state, Identifier::fromString(&state, "generalLevelIDC"));
831 RETURN_IF_EXCEPTION(throwScope, { });
832 }
833 if (!generalLevelIDCValue.isUndefined()) {
834 result.generalLevelIDC = convert<IDLUnsignedShort>(state, generalLevelIDCValue);
835 RETURN_IF_EXCEPTION(throwScope, { });
836 }
837 JSValue generalProfileCompatibilityFlagsValue;
838 if (isNullOrUndefined)
839 generalProfileCompatibilityFlagsValue = jsUndefined();
840 else {
841 generalProfileCompatibilityFlagsValue = object->get(&state, Identifier::fromString(&state, "generalProfileCompatibilityFlags"));
842 RETURN_IF_EXCEPTION(throwScope, { });
843 }
844 if (!generalProfileCompatibilityFlagsValue.isUndefined()) {
845 result.generalProfileCompatibilityFlags = convert<IDLUnsignedLong>(state, generalProfileCompatibilityFlagsValue);
846 RETURN_IF_EXCEPTION(throwScope, { });
847 }
848 JSValue generalProfileIDCValue;
849 if (isNullOrUndefined)
850 generalProfileIDCValue = jsUndefined();
851 else {
852 generalProfileIDCValue = object->get(&state, Identifier::fromString(&state, "generalProfileIDC"));
853 RETURN_IF_EXCEPTION(throwScope, { });
854 }
855 if (!generalProfileIDCValue.isUndefined()) {
856 result.generalProfileIDC = convert<IDLUnsignedShort>(state, generalProfileIDCValue);
857 RETURN_IF_EXCEPTION(throwScope, { });
858 }
859 JSValue generalProfileSpaceValue;
860 if (isNullOrUndefined)
861 generalProfileSpaceValue = jsUndefined();
862 else {
863 generalProfileSpaceValue = object->get(&state, Identifier::fromString(&state, "generalProfileSpace"));
864 RETURN_IF_EXCEPTION(throwScope, { });
865 }
866 if (!generalProfileSpaceValue.isUndefined()) {
867 result.generalProfileSpace = convert<IDLUnsignedShort>(state, generalProfileSpaceValue);
868 RETURN_IF_EXCEPTION(throwScope, { });
869 }
870 JSValue generalTierFlagValue;
871 if (isNullOrUndefined)
872 generalTierFlagValue = jsUndefined();
873 else {
874 generalTierFlagValue = object->get(&state, Identifier::fromString(&state, "generalTierFlag"));
875 RETURN_IF_EXCEPTION(throwScope, { });
876 }
877 if (!generalTierFlagValue.isUndefined()) {
878 result.generalTierFlag = convert<IDLBoolean>(state, generalTierFlagValue);
879 RETURN_IF_EXCEPTION(throwScope, { });
880 }
881 return result;
882}
883
884JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::HEVCParameterSet& dictionary)
885{
886 auto& vm = state.vm();
887
888 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
889
890 if (!IDLDOMString::isNullValue(dictionary.codecName)) {
891 auto codecNameValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.codecName));
892 result->putDirect(vm, JSC::Identifier::fromString(&vm, "codecName"), codecNameValue);
893 }
894 if (!IDLSequence<IDLUnsignedShort>::isNullValue(dictionary.constraintFlags)) {
895 auto constraintFlagsValue = toJS<IDLSequence<IDLUnsignedShort>>(state, globalObject, IDLSequence<IDLUnsignedShort>::extractValueFromNullable(dictionary.constraintFlags));
896 result->putDirect(vm, JSC::Identifier::fromString(&vm, "constraintFlags"), constraintFlagsValue);
897 }
898 if (!IDLUnsignedShort::isNullValue(dictionary.generalLevelIDC)) {
899 auto generalLevelIDCValue = toJS<IDLUnsignedShort>(IDLUnsignedShort::extractValueFromNullable(dictionary.generalLevelIDC));
900 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalLevelIDC"), generalLevelIDCValue);
901 }
902 if (!IDLUnsignedLong::isNullValue(dictionary.generalProfileCompatibilityFlags)) {
903 auto generalProfileCompatibilityFlagsValue = toJS<IDLUnsignedLong>(IDLUnsignedLong::extractValueFromNullable(dictionary.generalProfileCompatibilityFlags));
904 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalProfileCompatibilityFlags"), generalProfileCompatibilityFlagsValue);
905 }
906 if (!IDLUnsignedShort::isNullValue(dictionary.generalProfileIDC)) {
907 auto generalProfileIDCValue = toJS<IDLUnsignedShort>(IDLUnsignedShort::extractValueFromNullable(dictionary.generalProfileIDC));
908 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalProfileIDC"), generalProfileIDCValue);
909 }
910 if (!IDLUnsignedShort::isNullValue(dictionary.generalProfileSpace)) {
911 auto generalProfileSpaceValue = toJS<IDLUnsignedShort>(IDLUnsignedShort::extractValueFromNullable(dictionary.generalProfileSpace));
912 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalProfileSpace"), generalProfileSpaceValue);
913 }
914 if (!IDLBoolean::isNullValue(dictionary.generalTierFlag)) {
915 auto generalTierFlagValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.generalTierFlag));
916 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalTierFlag"), generalTierFlagValue);
917 }
918 return result;
919}
920
921template<> Internals::AcceleratedAnimation convertDictionary<Internals::AcceleratedAnimation>(ExecState& state, JSValue value)
922{
923 VM& vm = state.vm();
924 auto throwScope = DECLARE_THROW_SCOPE(vm);
925 bool isNullOrUndefined = value.isUndefinedOrNull();
926 auto* object = isNullOrUndefined ? nullptr : value.getObject();
927 if (UNLIKELY(!isNullOrUndefined && !object)) {
928 throwTypeError(&state, throwScope);
929 return { };
930 }
931 Internals::AcceleratedAnimation result;
932 JSValue propertyValue;
933 if (isNullOrUndefined)
934 propertyValue = jsUndefined();
935 else {
936 propertyValue = object->get(&state, Identifier::fromString(&state, "property"));
937 RETURN_IF_EXCEPTION(throwScope, { });
938 }
939 if (!propertyValue.isUndefined()) {
940 result.property = convert<IDLDOMString>(state, propertyValue);
941 RETURN_IF_EXCEPTION(throwScope, { });
942 }
943 JSValue speedValue;
944 if (isNullOrUndefined)
945 speedValue = jsUndefined();
946 else {
947 speedValue = object->get(&state, Identifier::fromString(&state, "speed"));
948 RETURN_IF_EXCEPTION(throwScope, { });
949 }
950 if (!speedValue.isUndefined()) {
951 result.speed = convert<IDLDouble>(state, speedValue);
952 RETURN_IF_EXCEPTION(throwScope, { });
953 }
954 return result;
955}
956
957JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::AcceleratedAnimation& dictionary)
958{
959 auto& vm = state.vm();
960
961 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
962
963 if (!IDLDOMString::isNullValue(dictionary.property)) {
964 auto propertyValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.property));
965 result->putDirect(vm, JSC::Identifier::fromString(&vm, "property"), propertyValue);
966 }
967 if (!IDLDouble::isNullValue(dictionary.speed)) {
968 auto speedValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.speed));
969 result->putDirect(vm, JSC::Identifier::fromString(&vm, "speed"), speedValue);
970 }
971 return result;
972}
973
974template<> Internals::CookieData convertDictionary<Internals::CookieData>(ExecState& state, JSValue value)
975{
976 VM& vm = state.vm();
977 auto throwScope = DECLARE_THROW_SCOPE(vm);
978 bool isNullOrUndefined = value.isUndefinedOrNull();
979 auto* object = isNullOrUndefined ? nullptr : value.getObject();
980 if (UNLIKELY(!isNullOrUndefined && !object)) {
981 throwTypeError(&state, throwScope);
982 return { };
983 }
984 Internals::CookieData result;
985 JSValue domainValue;
986 if (isNullOrUndefined)
987 domainValue = jsUndefined();
988 else {
989 domainValue = object->get(&state, Identifier::fromString(&state, "domain"));
990 RETURN_IF_EXCEPTION(throwScope, { });
991 }
992 if (!domainValue.isUndefined()) {
993 result.domain = convert<IDLDOMString>(state, domainValue);
994 RETURN_IF_EXCEPTION(throwScope, { });
995 }
996 JSValue expiresValue;
997 if (isNullOrUndefined)
998 expiresValue = jsUndefined();
999 else {
1000 expiresValue = object->get(&state, Identifier::fromString(&state, "expires"));
1001 RETURN_IF_EXCEPTION(throwScope, { });
1002 }
1003 if (!expiresValue.isUndefined()) {
1004 result.expires = convert<IDLDouble>(state, expiresValue);
1005 RETURN_IF_EXCEPTION(throwScope, { });
1006 }
1007 JSValue isHttpOnlyValue;
1008 if (isNullOrUndefined)
1009 isHttpOnlyValue = jsUndefined();
1010 else {
1011 isHttpOnlyValue = object->get(&state, Identifier::fromString(&state, "isHttpOnly"));
1012 RETURN_IF_EXCEPTION(throwScope, { });
1013 }
1014 if (!isHttpOnlyValue.isUndefined()) {
1015 result.isHttpOnly = convert<IDLBoolean>(state, isHttpOnlyValue);
1016 RETURN_IF_EXCEPTION(throwScope, { });
1017 }
1018 JSValue isSameSiteLaxValue;
1019 if (isNullOrUndefined)
1020 isSameSiteLaxValue = jsUndefined();
1021 else {
1022 isSameSiteLaxValue = object->get(&state, Identifier::fromString(&state, "isSameSiteLax"));
1023 RETURN_IF_EXCEPTION(throwScope, { });
1024 }
1025 if (!isSameSiteLaxValue.isUndefined()) {
1026 result.isSameSiteLax = convert<IDLBoolean>(state, isSameSiteLaxValue);
1027 RETURN_IF_EXCEPTION(throwScope, { });
1028 }
1029 JSValue isSameSiteStrictValue;
1030 if (isNullOrUndefined)
1031 isSameSiteStrictValue = jsUndefined();
1032 else {
1033 isSameSiteStrictValue = object->get(&state, Identifier::fromString(&state, "isSameSiteStrict"));
1034 RETURN_IF_EXCEPTION(throwScope, { });
1035 }
1036 if (!isSameSiteStrictValue.isUndefined()) {
1037 result.isSameSiteStrict = convert<IDLBoolean>(state, isSameSiteStrictValue);
1038 RETURN_IF_EXCEPTION(throwScope, { });
1039 }
1040 JSValue isSecureValue;
1041 if (isNullOrUndefined)
1042 isSecureValue = jsUndefined();
1043 else {
1044 isSecureValue = object->get(&state, Identifier::fromString(&state, "isSecure"));
1045 RETURN_IF_EXCEPTION(throwScope, { });
1046 }
1047 if (!isSecureValue.isUndefined()) {
1048 result.isSecure = convert<IDLBoolean>(state, isSecureValue);
1049 RETURN_IF_EXCEPTION(throwScope, { });
1050 }
1051 JSValue isSessionValue;
1052 if (isNullOrUndefined)
1053 isSessionValue = jsUndefined();
1054 else {
1055 isSessionValue = object->get(&state, Identifier::fromString(&state, "isSession"));
1056 RETURN_IF_EXCEPTION(throwScope, { });
1057 }
1058 if (!isSessionValue.isUndefined()) {
1059 result.isSession = convert<IDLBoolean>(state, isSessionValue);
1060 RETURN_IF_EXCEPTION(throwScope, { });
1061 }
1062 JSValue nameValue;
1063 if (isNullOrUndefined)
1064 nameValue = jsUndefined();
1065 else {
1066 nameValue = object->get(&state, Identifier::fromString(&state, "name"));
1067 RETURN_IF_EXCEPTION(throwScope, { });
1068 }
1069 if (!nameValue.isUndefined()) {
1070 result.name = convert<IDLDOMString>(state, nameValue);
1071 RETURN_IF_EXCEPTION(throwScope, { });
1072 }
1073 JSValue valueValue;
1074 if (isNullOrUndefined)
1075 valueValue = jsUndefined();
1076 else {
1077 valueValue = object->get(&state, Identifier::fromString(&state, "value"));
1078 RETURN_IF_EXCEPTION(throwScope, { });
1079 }
1080 if (!valueValue.isUndefined()) {
1081 result.value = convert<IDLDOMString>(state, valueValue);
1082 RETURN_IF_EXCEPTION(throwScope, { });
1083 }
1084 return result;
1085}
1086
1087JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::CookieData& dictionary)
1088{
1089 auto& vm = state.vm();
1090
1091 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
1092
1093 if (!IDLDOMString::isNullValue(dictionary.domain)) {
1094 auto domainValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.domain));
1095 result->putDirect(vm, JSC::Identifier::fromString(&vm, "domain"), domainValue);
1096 }
1097 if (!IDLDouble::isNullValue(dictionary.expires)) {
1098 auto expiresValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.expires));
1099 result->putDirect(vm, JSC::Identifier::fromString(&vm, "expires"), expiresValue);
1100 }
1101 if (!IDLBoolean::isNullValue(dictionary.isHttpOnly)) {
1102 auto isHttpOnlyValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isHttpOnly));
1103 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isHttpOnly"), isHttpOnlyValue);
1104 }
1105 if (!IDLBoolean::isNullValue(dictionary.isSameSiteLax)) {
1106 auto isSameSiteLaxValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isSameSiteLax));
1107 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isSameSiteLax"), isSameSiteLaxValue);
1108 }
1109 if (!IDLBoolean::isNullValue(dictionary.isSameSiteStrict)) {
1110 auto isSameSiteStrictValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isSameSiteStrict));
1111 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isSameSiteStrict"), isSameSiteStrictValue);
1112 }
1113 if (!IDLBoolean::isNullValue(dictionary.isSecure)) {
1114 auto isSecureValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isSecure));
1115 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isSecure"), isSecureValue);
1116 }
1117 if (!IDLBoolean::isNullValue(dictionary.isSession)) {
1118 auto isSessionValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isSession));
1119 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isSession"), isSessionValue);
1120 }
1121 if (!IDLDOMString::isNullValue(dictionary.name)) {
1122 auto nameValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.name));
1123 result->putDirect(vm, JSC::Identifier::fromString(&vm, "name"), nameValue);
1124 }
1125 if (!IDLDOMString::isNullValue(dictionary.value)) {
1126 auto valueValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.value));
1127 result->putDirect(vm, JSC::Identifier::fromString(&vm, "value"), valueValue);
1128 }
1129 return result;
1130}
1131
1132// Functions
1133
1134JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAddress(JSC::ExecState*);
1135JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNodeNeedsStyleRecalc(JSC::ExecState*);
1136JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStyleChangeType(JSC::ExecState*);
1137JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDescription(JSC::ExecState*);
1138JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasPausedImageAnimations(JSC::ExecState*);
1139JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPaintingFrequently(JSC::ExecState*);
1140JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIncrementFrequentPaintCounter(JSC::ExecState*);
1141JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementRenderTreeAsText(JSC::ExecState*);
1142JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPreloaded(JSC::ExecState*);
1143JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsLoadingFromMemoryCache(JSC::ExecState*);
1144JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFetchResponseSource(JSC::ExecState*);
1145JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionXhrResponseSource(JSC::ExecState*);
1146JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSharingStyleSheetContents(JSC::ExecState*);
1147JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresources(JSC::ExecState*);
1148JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearMemoryCache(JSC::ExecState*);
1149JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPruneMemoryCacheToSize(JSC::ExecState*);
1150JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDestroyDecodedDataForAllImages(JSC::ExecState*);
1151JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMemoryCacheSize(JSC::ExecState*);
1152JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetOverrideCachePolicy(JSC::ExecState*);
1153JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetOverrideResourceLoadPriority(JSC::ExecState*);
1154JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabled(JSC::ExecState*);
1155JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearPageCache(JSC::ExecState*);
1156JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageCacheSize(JSC::ExecState*);
1157JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfo(JSC::ExecState*);
1158JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnsureUserAgentShadowRoot(JSC::ExecState*);
1159JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowRoot(JSC::ExecState*);
1160JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredStyleRulesCount(JSC::ExecState*);
1161JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredGroupRulesCount(JSC::ExecState*);
1162JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredKeyframesRulesCount(JSC::ExecState*);
1163JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowRootType(JSC::ExecState*);
1164JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowPseudoId(JSC::ExecState*);
1165JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShadowPseudoId(JSC::ExecState*);
1166JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTreeScopeRootNode(JSC::ExecState*);
1167JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParentTreeScope(JSC::ExecState*);
1168JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCount(JSC::ExecState*);
1169JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfActiveAnimations(JSC::ExecState*);
1170JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSuspendAnimations(JSC::ExecState*);
1171JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResumeAnimations(JSC::ExecState*);
1172JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAnimationsAreSuspended(JSC::ExecState*);
1173JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElement(JSC::ExecState*);
1174JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElement(JSC::ExecState*);
1175JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElement(JSC::ExecState*);
1176JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElement(JSC::ExecState*);
1177JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAcceleratedAnimationsForElement(JSC::ExecState*);
1178JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidations(JSC::ExecState*);
1179JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPseudoElement(JSC::ExecState*);
1180JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionVisiblePlaceholder(JSC::ExecState*);
1181JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSelectColorInColorChooser(JSC::ExecState*);
1182JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItem(JSC::ExecState*);
1183JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItem(JSC::ExecState*);
1184JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAbsoluteCaretBounds(JSC::ExecState*);
1185JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsCaretBlinkingSuspended(JSC::ExecState*);
1186JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBoundingBox(JSC::ExecState*);
1187JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInspectorHighlightRects(JSC::ExecState*);
1188JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerCountForNode(JSC::ExecState*);
1189JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerRangeForNode(JSC::ExecState*);
1190JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerDescriptionForNode(JSC::ExecState*);
1191JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDumpMarkerRects(JSC::ExecState*);
1192JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAddTextMatchMarker(JSC::ExecState*);
1193JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlighted(JSC::ExecState*);
1194JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInvalidateFontCache(JSC::ExecState*);
1195JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFontSmoothingEnabled(JSC::ExecState*);
1196JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetScrollViewPosition(JSC::ExecState*);
1197JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUnconstrainedScrollTo(JSC::ExecState*);
1198JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayoutViewportRect(JSC::ExecState*);
1199JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionVisualViewportRect(JSC::ExecState*);
1200JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewIsTransparent(JSC::ExecState*);
1201JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionViewBaseBackgroundColor(JSC::ExecState*);
1202JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewBaseBackgroundColor(JSC::ExecState*);
1203JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPagination(JSC::ExecState*);
1204JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPaginationLineGridEnabled(JSC::ExecState*);
1205JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionConfigurationForViewport(JSC::ExecState*);
1206JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWasLastChangeUserEdit(JSC::ExecState*);
1207JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementShouldAutoComplete(JSC::ExecState*);
1208JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutofilled(JSC::ExecState*);
1209JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShowAutoFillButton(JSC::ExecState*);
1210JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAutoFillButtonType(JSC::ExecState*);
1211JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastAutoFillButtonType(JSC::ExecState*);
1212JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeOfString(JSC::ExecState*);
1213JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCountMatchesForText(JSC::ExecState*);
1214JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCountFindMatches(JSC::ExecState*);
1215JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAutofillFieldName(JSC::ExecState*);
1216JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInvalidateControlTints(JSC::ExecState*);
1217JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollElementToRect(JSC::ExecState*);
1218JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeFromLocationAndLength(JSC::ExecState*);
1219JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLocationFromRange(JSC::ExecState*);
1220JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLengthFromRange(JSC::ExecState*);
1221JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeAsText(JSC::ExecState*);
1222JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIterator(JSC::ExecState*);
1223JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSubrange(JSC::ExecState*);
1224JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocation(JSC::ExecState*);
1225JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeOfStringNearLocation(JSC::ExecState*);
1226JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetDelegatesScrolling(JSC::ExecState*);
1227JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpellCheckRequestSequence(JSC::ExecState*);
1228JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpellCheckProcessedSequence(JSC::ExecState*);
1229JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPreferredLanguages(JSC::ExecState*);
1230JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserPreferredLanguages(JSC::ExecState*);
1231JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPreferredAudioCharacteristics(JSC::ExecState*);
1232JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristic(JSC::ExecState*);
1233JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWheelEventHandlerCount(JSC::ExecState*);
1234JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTouchEventHandlerCount(JSC::ExecState*);
1235JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTouchEventRectsForEvent(JSC::ExecState*);
1236JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPassiveTouchEventListenerRects(JSC::ExecState*);
1237JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNodesFromRect(JSC::ExecState*);
1238JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParserMetaData(JSC::ExecState*);
1239JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduled(JSC::ExecState*);
1240JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasSpellingMarker(JSC::ExecState*);
1241JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasGrammarMarker(JSC::ExecState*);
1242JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasAutocorrectedMarker(JSC::ExecState*);
1243JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabled(JSC::ExecState*);
1244JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabled(JSC::ExecState*);
1245JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabled(JSC::ExecState*);
1246JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabled(JSC::ExecState*);
1247JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabled(JSC::ExecState*);
1248JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabled(JSC::ExecState*);
1249JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHandleAcceptedCandidate(JSC::ExecState*);
1250JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionChangeSelectionListType(JSC::ExecState*);
1251JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsOverwriteModeEnabled(JSC::ExecState*);
1252JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionToggleOverwriteModeEnabled(JSC::ExecState*);
1253JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfScrollableAreas(JSC::ExecState*);
1254JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPageBoxVisible(JSC::ExecState*);
1255JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameIndex(JSC::ExecState*);
1256JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameCount(JSC::ExecState*);
1257JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameDurationAtIndex(JSC::ExecState*);
1258JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetImageFrameDecodingDuration(JSC::ExecState*);
1259JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResetImageAnimation(JSC::ExecState*);
1260JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsImageAnimating(JSC::ExecState*);
1261JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTesting(JSC::ExecState*);
1262JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageDecodeCount(JSC::ExecState*);
1263JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPdfDocumentCachingCount(JSC::ExecState*);
1264JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTesting(JSC::ExecState*);
1265JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTesting(JSC::ExecState*);
1266JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetGridMaxTracksLimit(JSC::ExecState*);
1267JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSVGAnimationsInterval(JSC::ExecState*);
1268JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerTreeAsText(JSC::ExecState*);
1269JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerIDForElement(JSC::ExecState*);
1270JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollbarOverlayStyle(JSC::ExecState*);
1271JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollbarUsingDarkAppearance(JSC::ExecState*);
1272JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollingStateTreeAsText(JSC::ExecState*);
1273JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMainThreadScrollingReasons(JSC::ExecState*);
1274JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNonFastScrollableRects(JSC::ExecState*);
1275JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRepaintRectsAsText(JSC::ExecState*);
1276JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawing(JSC::ExecState*);
1277JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetElementTracksDisplayListReplay(JSC::ExecState*);
1278JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDisplayListForElement(JSC::ExecState*);
1279JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReplayDisplayListForElement(JSC::ExecState*);
1280JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGarbageCollectDocumentResources(JSC::ExecState*);
1281JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInsertAuthorCSS(JSC::ExecState*);
1282JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInsertUserCSS(JSC::ExecState*);
1283JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginSimulatedMemoryPressure(JSC::ExecState*);
1284JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndSimulatedMemoryPressure(JSC::ExecState*);
1285JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfIDBTransactions(JSC::ExecState*);
1286JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfLiveNodes(JSC::ExecState*);
1287JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfLiveDocuments(JSC::ExecState*);
1288JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReferencingNodeCount(JSC::ExecState*);
1289#if ENABLE(INTERSECTION_OBSERVER)
1290JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfIntersectionObservers(JSC::ExecState*);
1291#endif
1292JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionOpenDummyInspectorFrontend(JSC::ExecState*);
1293JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCloseDummyInspectorFrontend(JSC::ExecState*);
1294JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetInspectorIsUnderTest(JSC::ExecState*);
1295JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCounterValue(JSC::ExecState*);
1296JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageNumber(JSC::ExecState*);
1297JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShortcutIconURLs(JSC::ExecState*);
1298JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfPages(JSC::ExecState*);
1299JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageProperty(JSC::ExecState*);
1300JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageSizeAndMarginsInPixels(JSC::ExecState*);
1301JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageScaleFactor(JSC::ExecState*);
1302JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageScaleFactor(JSC::ExecState*);
1303JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageZoomFactor(JSC::ExecState*);
1304JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetTextZoomFactor(JSC::ExecState*);
1305JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUseFixedLayout(JSC::ExecState*);
1306JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFixedLayoutSize(JSC::ExecState*);
1307JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPrinting(JSC::ExecState*);
1308JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewExposedRect(JSC::ExecState*);
1309JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetHeaderHeight(JSC::ExecState*);
1310JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFooterHeight(JSC::ExecState*);
1311JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetTopContentInset(JSC::ExecState*);
1312#if ENABLE(FULLSCREEN_API)
1313JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElement(JSC::ExecState*);
1314#endif
1315#if ENABLE(FULLSCREEN_API)
1316JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElement(JSC::ExecState*);
1317#endif
1318#if ENABLE(FULLSCREEN_API)
1319JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElement(JSC::ExecState*);
1320#endif
1321#if ENABLE(FULLSCREEN_API)
1322JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElement(JSC::ExecState*);
1323#endif
1324JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenInsets(JSC::ExecState*);
1325JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenAutoHideDuration(JSC::ExecState*);
1326JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenControlsHidden(JSC::ExecState*);
1327JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetApplicationCacheOriginQuota(JSC::ExecState*);
1328JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicy(JSC::ExecState*);
1329JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicy(JSC::ExecState*);
1330JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterDefaultPortForProtocol(JSC::ExecState*);
1331JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMallocStatistics(JSC::ExecState*);
1332JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTypeConversions(JSC::ExecState*);
1333JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMemoryInfo(JSC::ExecState*);
1334JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetReferencedFilePaths(JSC::ExecState*);
1335JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingRepaints(JSC::ExecState*);
1336JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStopTrackingRepaints(JSC::ExecState*);
1337JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingLayerFlushes(JSC::ExecState*);
1338JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerFlushCount(JSC::ExecState*);
1339JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsTimerThrottled(JSC::ExecState*);
1340JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottled(JSC::ExecState*);
1341JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAreTimersThrottled(JSC::ExecState*);
1342JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetLowPowerModeEnabled(JSC::ExecState*);
1343JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingStyleRecalcs(JSC::ExecState*);
1344JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStyleRecalcCount(JSC::ExecState*);
1345JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingCompositingUpdates(JSC::ExecState*);
1346JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCompositingUpdateCount(JSC::ExecState*);
1347JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(JSC::ExecState*);
1348JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCurrentCursorInfo(JSC::ExecState*);
1349JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerTextForListItem(JSC::ExecState*);
1350JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionToolTipFromElement(JSC::ExecState*);
1351JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeserializeBuffer(JSC::ExecState*);
1352JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSerializeObject(JSC::ExecState*);
1353JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsFromCurrentWorld(JSC::ExecState*);
1354JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUsesOverlayScrollbars(JSC::ExecState*);
1355JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUsesMockScrollAnimator(JSC::ExecState*);
1356JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionForceReload(JSC::ExecState*);
1357JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReloadExpiredOnly(JSC::ExecState*);
1358JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableAutoSizeMode(JSC::ExecState*);
1359#if ENABLE(VIDEO)
1360JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaResponseSources(JSC::ExecState*);
1361#endif
1362#if ENABLE(VIDEO)
1363JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaResponseContentRanges(JSC::ExecState*);
1364#endif
1365#if ENABLE(VIDEO)
1366JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateAudioInterruption(JSC::ExecState*);
1367#endif
1368#if ENABLE(VIDEO)
1369JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaElementHasCharacteristic(JSC::ExecState*);
1370#endif
1371#if ENABLE(VIDEO)
1372JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginSimulatedHDCPError(JSC::ExecState*);
1373#endif
1374#if ENABLE(VIDEO)
1375JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndSimulatedHDCPError(JSC::ExecState*);
1376#endif
1377#if ENABLE(VIDEO)
1378JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementShouldBufferData(JSC::ExecState*);
1379#endif
1380#if ENABLE(VIDEO)
1381JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementBufferingPolicy(JSC::ExecState*);
1382#endif
1383#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
1384JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInitializeMockCDM(JSC::ExecState*);
1385#endif
1386#if ENABLE(ENCRYPTED_MEDIA)
1387JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterMockCDM(JSC::ExecState*);
1388#endif
1389JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableMockMediaCapabilities(JSC::ExecState*);
1390#if ENABLE(SPEECH_SYNTHESIS)
1391JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableMockSpeechSynthesizer(JSC::ExecState*);
1392#endif
1393JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetImageSourceURL(JSC::ExecState*);
1394#if ENABLE(VIDEO_TRACK)
1395JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCaptionsStyleSheetOverride(JSC::ExecState*);
1396#endif
1397#if ENABLE(VIDEO_TRACK)
1398JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverride(JSC::ExecState*);
1399#endif
1400#if ENABLE(VIDEO_TRACK)
1401JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverride(JSC::ExecState*);
1402#endif
1403#if ENABLE(VIDEO_TRACK)
1404JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptionDisplayMode(JSC::ExecState*);
1405#endif
1406#if ENABLE(VIDEO_TRACK)
1407JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateGenericCue(JSC::ExecState*);
1408#endif
1409#if ENABLE(VIDEO)
1410JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateTimeRanges(JSC::ExecState*);
1411#endif
1412#if ENABLE(VIDEO)
1413JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClosestTimeToTimeRanges(JSC::ExecState*);
1414#endif
1415JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSelectPopupVisible(JSC::ExecState*);
1416JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscured(JSC::ExecState*);
1417JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUnavailablePluginReplacementText(JSC::ExecState*);
1418JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPluginSnapshotted(JSC::ExecState*);
1419JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPluginIsBelowSizeThreshold(JSC::ExecState*);
1420JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSelectionBounds(JSC::ExecState*);
1421JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetSelectionWithoutValidation(JSC::ExecState*);
1422#if ENABLE(MEDIA_SOURCE)
1423JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInitializeMockMediaSource(JSC::ExecState*);
1424#endif
1425#if ENABLE(MEDIA_SOURCE)
1426JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBufferedSamplesForTrackID(JSC::ExecState*);
1427#endif
1428#if ENABLE(MEDIA_SOURCE)
1429JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnqueuedSamplesForTrackID(JSC::ExecState*);
1430#endif
1431#if ENABLE(MEDIA_SOURCE)
1432JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShouldGenerateTimestamps(JSC::ExecState*);
1433#endif
1434#if ENABLE(VIDEO)
1435JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginMediaSessionInterruption(JSC::ExecState*);
1436#endif
1437#if ENABLE(VIDEO)
1438JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndMediaSessionInterruption(JSC::ExecState*);
1439#endif
1440#if ENABLE(MEDIA_SESSION)
1441JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotification(JSC::ExecState*);
1442#endif
1443#if ENABLE(MEDIA_SESSION)
1444JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotification(JSC::ExecState*);
1445#endif
1446#if ENABLE(MEDIA_SESSION)
1447JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionCurrentState(JSC::ExecState*);
1448#endif
1449#if ENABLE(MEDIA_SESSION)
1450JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaElementPlayerVolume(JSC::ExecState*);
1451#endif
1452#if ENABLE(MEDIA_SESSION)
1453JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaControlEvent(JSC::ExecState*);
1454#endif
1455#if ENABLE(VIDEO)
1456JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationWillBecomeInactive(JSC::ExecState*);
1457#endif
1458#if ENABLE(VIDEO)
1459JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationDidBecomeActive(JSC::ExecState*);
1460#endif
1461#if ENABLE(VIDEO)
1462JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationWillEnterForeground(JSC::ExecState*);
1463#endif
1464#if ENABLE(VIDEO)
1465JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationDidEnterBackground(JSC::ExecState*);
1466#endif
1467#if ENABLE(VIDEO)
1468JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaSessionRestrictions(JSC::ExecState*);
1469#endif
1470#if ENABLE(VIDEO)
1471JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionRestrictions(JSC::ExecState*);
1472#endif
1473#if ENABLE(VIDEO)
1474JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaElementRestrictions(JSC::ExecState*);
1475#endif
1476#if ENABLE(WEB_AUDIO)
1477JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAudioContextRestrictions(JSC::ExecState*);
1478#endif
1479#if ENABLE(VIDEO)
1480JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPostRemoteControlCommand(JSC::ExecState*);
1481#endif
1482#if ENABLE(WIRELESS_PLAYBACK_TARGET)
1483JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabled(JSC::ExecState*);
1484#endif
1485#if ENABLE(WIRELESS_PLAYBACK_TARGET)
1486JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerState(JSC::ExecState*);
1487#endif
1488#if ENABLE(MEDIA_STREAM)
1489JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabled(JSC::ExecState*);
1490#endif
1491#if ENABLE(MEDIA_STREAM)
1492JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreator(JSC::ExecState*);
1493#endif
1494#if ENABLE(WEB_RTC)
1495JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEvent(JSC::ExecState*);
1496#endif
1497#if ENABLE(WEB_RTC)
1498JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactory(JSC::ExecState*);
1499#endif
1500#if ENABLE(WEB_RTC)
1501JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetICECandidateFiltering(JSC::ExecState*);
1502#endif
1503#if ENABLE(WEB_RTC)
1504JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabled(JSC::ExecState*);
1505#endif
1506#if ENABLE(WEB_RTC)
1507JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStopPeerConnection(JSC::ExecState*);
1508#endif
1509#if ENABLE(WEB_RTC)
1510JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearPeerConnectionFactory(JSC::ExecState*);
1511#endif
1512#if ENABLE(VIDEO)
1513JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateSystemSleep(JSC::ExecState*);
1514#endif
1515#if ENABLE(VIDEO)
1516JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateSystemWake(JSC::ExecState*);
1517#endif
1518#if ENABLE(VIDEO)
1519JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementIsBlockingDisplaySleep(JSC::ExecState*);
1520#endif
1521JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInstallMockPageOverlay(JSC::ExecState*);
1522JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageOverlayLayerTreeAsText(JSC::ExecState*);
1523JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageMuted(JSC::ExecState*);
1524JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageMediaState(JSC::ExecState*);
1525JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageDefersLoading(JSC::ExecState*);
1526JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageDefersLoading(JSC::ExecState*);
1527JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateFile(JSC::ExecState*);
1528JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionQueueMicroTask(JSC::ExecState*);
1529JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTestPreloaderSettingViewport(JSC::ExecState*);
1530#if ENABLE(CSS_SCROLL_SNAP)
1531JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollSnapOffsets(JSC::ExecState*);
1532#endif
1533#if ENABLE(CSS_SCROLL_SNAP)
1534JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabled(JSC::ExecState*);
1535#endif
1536JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRects(JSC::ExecState*);
1537#if ENABLE(VIDEO)
1538JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElement(JSC::ExecState*);
1539#endif
1540JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserVisibleString(JSC::ExecState*);
1541JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShowAllPlugins(JSC::ExecState*);
1542#if ENABLE(STREAMS_API)
1543JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCloneArrayBuffer(JSC::ExecState*);
1544#endif
1545#if ENABLE(STREAMS_API)
1546JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsReadableStreamDisturbed(JSC::ExecState*);
1547#endif
1548JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResourceLoadStatisticsForURL(JSC::ExecState*);
1549JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabled(JSC::ExecState*);
1550JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCanShowModalDialogOverride(JSC::ExecState*);
1551JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionComposedTreeAsText(JSC::ExecState*);
1552JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsProcessingUserGesture(JSC::ExecState*);
1553JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastHandledUserGestureTimestamp(JSC::ExecState*);
1554JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWithUserGesture(JSC::ExecState*);
1555JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserIsInteracting(JSC::ExecState*);
1556JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionObserveGC(JSC::ExecState*);
1557JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirection(JSC::ExecState*);
1558JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetBaseWritingDirection(JSC::ExecState*);
1559JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPrefersReducedMotion(JSC::ExecState*);
1560JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReportBacktrace(JSC::ExecState*);
1561#if ENABLE(POINTER_LOCK)
1562JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageHasPendingPointerLock(JSC::ExecState*);
1563#endif
1564#if ENABLE(POINTER_LOCK)
1565JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageHasPointerLock(JSC::ExecState*);
1566#endif
1567JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAccessKeyModifiers(JSC::ExecState*);
1568JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetQuickLookPassword(JSC::ExecState*);
1569JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAsRunningUserScripts(JSC::ExecState*);
1570#if ENABLE(APPLE_PAY)
1571JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetApplePayIsActive(JSC::ExecState*);
1572#endif
1573JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDisableTileSizeUpdateDelay(JSC::ExecState*);
1574JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTesting(JSC::ExecState*);
1575#if ENABLE(WEBGL)
1576JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateWebGLContextChanged(JSC::ExecState*);
1577#endif
1578#if ENABLE(WEBGL)
1579JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFailNextGPUStatusCheck(JSC::ExecState*);
1580#endif
1581#if ENABLE(WEBGL)
1582JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasLowAndHighPowerGPUs(JSC::ExecState*);
1583#endif
1584JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageVisibility(JSC::ExecState*);
1585JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageIsFocusedAndActive(JSC::ExecState*);
1586#if ENABLE(WEB_RTC)
1587JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowed(JSC::ExecState*);
1588#endif
1589#if ENABLE(WEB_RTC)
1590JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSources(JSC::ExecState*);
1591#endif
1592#if ENABLE(MEDIA_STREAM)
1593JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShouldInterruptAudioOnPageVisibilityChange(JSC::ExecState*);
1594#endif
1595#if ENABLE(MEDIA_STREAM)
1596JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientation(JSC::ExecState*);
1597#endif
1598#if ENABLE(MEDIA_STREAM)
1599JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionObserveMediaStreamTrack(JSC::ExecState*);
1600#endif
1601#if ENABLE(MEDIA_STREAM)
1602JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrame(JSC::ExecState*);
1603#endif
1604#if ENABLE(MEDIA_STREAM)
1605JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDelayMediaStreamTrackSamples(JSC::ExecState*);
1606#endif
1607#if ENABLE(MEDIA_STREAM)
1608JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamTrackMuted(JSC::ExecState*);
1609#endif
1610#if ENABLE(MEDIA_STREAM)
1611JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRemoveMediaStreamTrack(JSC::ExecState*);
1612#endif
1613#if ENABLE(MEDIA_STREAM)
1614JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailure(JSC::ExecState*);
1615#endif
1616#if ENABLE(MEDIA_STREAM)
1617JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifier(JSC::ExecState*);
1618#endif
1619#if ENABLE(MEDIA_STREAM)
1620JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamSourceInterrupted(JSC::ExecState*);
1621#endif
1622#if ENABLE(MEDIA_STREAM)
1623JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraint(JSC::ExecState*);
1624#endif
1625JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDocumentIdentifier(JSC::ExecState*);
1626JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsDocumentAlive(JSC::ExecState*);
1627JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAlive(JSC::ExecState*);
1628JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionServiceWorkerClientIdentifier(JSC::ExecState*);
1629JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStoreRegistrationsOnDisk(JSC::ExecState*);
1630JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentation(JSC::ExecState*);
1631JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCacheStorageEngineRepresentation(JSC::ExecState*);
1632JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetResponseSizeWithPadding(JSC::ExecState*);
1633JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResponseSizeWithPadding(JSC::ExecState*);
1634JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsage(JSC::ExecState*);
1635JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetConsoleMessageListener(JSC::ExecState*);
1636JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAudioSessionCategory(JSC::ExecState*);
1637JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPreferredAudioBufferSize(JSC::ExecState*);
1638JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAudioSessionActive(JSC::ExecState*);
1639#if ENABLE(SERVICE_WORKER)
1640JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasServiceWorkerRegistration(JSC::ExecState*);
1641#endif
1642#if ENABLE(SERVICE_WORKER)
1643JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTerminateServiceWorker(JSC::ExecState*);
1644#endif
1645#if ENABLE(SERVICE_WORKER)
1646JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasServiceWorkerConnection(JSC::ExecState*);
1647#endif
1648JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSystemPreviewLink(JSC::ExecState*);
1649JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSystemPreviewImage(JSC::ExecState*);
1650JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUsingAppleInternalSDK(JSC::ExecState*);
1651JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPostTask(JSC::ExecState*);
1652JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkContextAsInsecure(JSC::ExecState*);
1653#if ENABLE(VIDEO)
1654JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManager(JSC::ExecState*);
1655#endif
1656#if ENABLE(VIDEO)
1657JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionState(JSC::ExecState*);
1658#endif
1659JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionOngoingLoadsDescriptions(JSC::ExecState*);
1660JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabled(JSC::ExecState*);
1661JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReloadWithoutContentExtensions(JSC::ExecState*);
1662JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUseSystemAppearance(JSC::ExecState*);
1663JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPluginCount(JSC::ExecState*);
1664JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNotifyResourceLoadObserver(JSC::ExecState*);
1665JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPrimaryScreenDisplayID(JSC::ExecState*);
1666JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCapsLockIsOn(JSC::ExecState*);
1667JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSupportsVCPEncoder(JSC::ExecState*);
1668JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParseHEVCCodecParameters(JSC::ExecState*);
1669JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCookies(JSC::ExecState*);
1670JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchive(JSC::ExecState*);
1671JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionProcessWillSuspend(JSC::ExecState*);
1672JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionProcessDidResume(JSC::ExecState*);
1673JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTestDictionaryLogging(JSC::ExecState*);
1674JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwarding(JSC::ExecState*);
1675JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetIsPlayingToAutomotiveHeadUnit(JSC::ExecState*);
1676
1677// Attributes
1678
1679JSC::EncodedJSValue jsInternalsAnimationsInterval(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1680JSC::EncodedJSValue jsInternalsSentenceRetroCorrectionEnabled(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1681JSC::EncodedJSValue jsInternalsSettings(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1682JSC::EncodedJSValue jsInternalsWorkerThreadCount(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1683JSC::EncodedJSValue jsInternalsAreSVGAnimationsPaused(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1684JSC::EncodedJSValue jsInternalsIsUnderMemoryPressure(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1685#if ENABLE(FULLSCREEN_API)
1686JSC::EncodedJSValue jsInternalsIsAnimatingFullScreen(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1687#endif
1688JSC::EncodedJSValue jsInternalsRequestAnimationFrameInterval(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1689JSC::EncodedJSValue jsInternalsScriptedAnimationsAreSuspended(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1690JSC::EncodedJSValue jsInternalsEventThrottlingBehaviorOverride(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1691bool setJSInternalsEventThrottlingBehaviorOverride(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
1692JSC::EncodedJSValue jsInternalsLastStyleUpdateSize(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1693JSC::EncodedJSValue jsInternalsCompositingPolicyOverride(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1694bool setJSInternalsCompositingPolicyOverride(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
1695JSC::EncodedJSValue jsInternalsLayoutCount(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1696#if ENABLE(CONTENT_FILTERING)
1697JSC::EncodedJSValue jsInternalsMockContentFilterSettings(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1698#endif
1699#if ENABLE(MEDIA_STREAM)
1700JSC::EncodedJSValue jsInternalsTrackAudioSampleCount(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1701#endif
1702#if ENABLE(MEDIA_STREAM)
1703JSC::EncodedJSValue jsInternalsTrackVideoSampleCount(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1704#endif
1705#if ENABLE(APPLE_PAY)
1706JSC::EncodedJSValue jsInternalsMockPaymentCoordinator(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1707#endif
1708#if ENABLE(VIDEO)
1709JSC::EncodedJSValue jsInternalsNowPlayingState(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1710#endif
1711
1712class JSInternalsPrototype : public JSC::JSNonFinalObject {
1713public:
1714 using Base = JSC::JSNonFinalObject;
1715 static JSInternalsPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
1716 {
1717 JSInternalsPrototype* ptr = new (NotNull, JSC::allocateCell<JSInternalsPrototype>(vm.heap)) JSInternalsPrototype(vm, globalObject, structure);
1718 ptr->finishCreation(vm);
1719 return ptr;
1720 }
1721
1722 DECLARE_INFO;
1723 static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
1724 {
1725 return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
1726 }
1727
1728private:
1729 JSInternalsPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
1730 : JSC::JSNonFinalObject(vm, structure)
1731 {
1732 }
1733
1734 void finishCreation(JSC::VM&);
1735};
1736
1737/* Hash table for prototype */
1738
1739static const HashTableValue JSInternalsPrototypeTableValues[] =
1740{
1741 { "animationsInterval", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsAnimationsInterval), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1742 { "sentenceRetroCorrectionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsSentenceRetroCorrectionEnabled), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1743 { "settings", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsSettings), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1744 { "workerThreadCount", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsWorkerThreadCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1745 { "areSVGAnimationsPaused", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsAreSVGAnimationsPaused), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1746 { "isUnderMemoryPressure", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsIsUnderMemoryPressure), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1747#if ENABLE(FULLSCREEN_API)
1748 { "isAnimatingFullScreen", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsIsAnimatingFullScreen), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1749#else
1750 { 0, 0, NoIntrinsic, { 0, 0 } },
1751#endif
1752 { "requestAnimationFrameInterval", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsRequestAnimationFrameInterval), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1753 { "scriptedAnimationsAreSuspended", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsScriptedAnimationsAreSuspended), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1754 { "eventThrottlingBehaviorOverride", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsEventThrottlingBehaviorOverride), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSInternalsEventThrottlingBehaviorOverride) } },
1755 { "lastStyleUpdateSize", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsLastStyleUpdateSize), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1756 { "compositingPolicyOverride", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsCompositingPolicyOverride), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSInternalsCompositingPolicyOverride) } },
1757 { "layoutCount", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsLayoutCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1758#if ENABLE(CONTENT_FILTERING)
1759 { "mockContentFilterSettings", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsMockContentFilterSettings), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1760#else
1761 { 0, 0, NoIntrinsic, { 0, 0 } },
1762#endif
1763#if ENABLE(MEDIA_STREAM)
1764 { "trackAudioSampleCount", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsTrackAudioSampleCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1765#else
1766 { 0, 0, NoIntrinsic, { 0, 0 } },
1767#endif
1768#if ENABLE(MEDIA_STREAM)
1769 { "trackVideoSampleCount", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsTrackVideoSampleCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1770#else
1771 { 0, 0, NoIntrinsic, { 0, 0 } },
1772#endif
1773#if ENABLE(APPLE_PAY)
1774 { "mockPaymentCoordinator", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsMockPaymentCoordinator), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1775#else
1776 { 0, 0, NoIntrinsic, { 0, 0 } },
1777#endif
1778#if ENABLE(VIDEO)
1779 { "nowPlayingState", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsNowPlayingState), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1780#else
1781 { 0, 0, NoIntrinsic, { 0, 0 } },
1782#endif
1783 { "address", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAddress), (intptr_t) (1) } },
1784 { "nodeNeedsStyleRecalc", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNodeNeedsStyleRecalc), (intptr_t) (1) } },
1785 { "styleChangeType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStyleChangeType), (intptr_t) (1) } },
1786 { "description", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDescription), (intptr_t) (1) } },
1787 { "hasPausedImageAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasPausedImageAnimations), (intptr_t) (1) } },
1788 { "isPaintingFrequently", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPaintingFrequently), (intptr_t) (1) } },
1789 { "incrementFrequentPaintCounter", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIncrementFrequentPaintCounter), (intptr_t) (1) } },
1790 { "elementRenderTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementRenderTreeAsText), (intptr_t) (1) } },
1791 { "isPreloaded", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPreloaded), (intptr_t) (1) } },
1792 { "isLoadingFromMemoryCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsLoadingFromMemoryCache), (intptr_t) (1) } },
1793 { "fetchResponseSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionFetchResponseSource), (intptr_t) (1) } },
1794 { "xhrResponseSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionXhrResponseSource), (intptr_t) (1) } },
1795 { "isSharingStyleSheetContents", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsSharingStyleSheetContents), (intptr_t) (2) } },
1796 { "isStyleSheetLoadingSubresources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresources), (intptr_t) (1) } },
1797 { "clearMemoryCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClearMemoryCache), (intptr_t) (0) } },
1798 { "pruneMemoryCacheToSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPruneMemoryCacheToSize), (intptr_t) (1) } },
1799 { "destroyDecodedDataForAllImages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDestroyDecodedDataForAllImages), (intptr_t) (0) } },
1800 { "memoryCacheSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMemoryCacheSize), (intptr_t) (0) } },
1801 { "setOverrideCachePolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetOverrideCachePolicy), (intptr_t) (1) } },
1802 { "setOverrideResourceLoadPriority", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetOverrideResourceLoadPriority), (intptr_t) (1) } },
1803 { "setStrictRawResourceValidationPolicyDisabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabled), (intptr_t) (1) } },
1804 { "clearPageCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClearPageCache), (intptr_t) (0) } },
1805 { "pageCacheSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageCacheSize), (intptr_t) (0) } },
1806 { "computedStyleIncludingVisitedInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfo), (intptr_t) (1) } },
1807 { "ensureUserAgentShadowRoot", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnsureUserAgentShadowRoot), (intptr_t) (1) } },
1808 { "shadowRoot", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionShadowRoot), (intptr_t) (1) } },
1809 { "deferredStyleRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDeferredStyleRulesCount), (intptr_t) (1) } },
1810 { "deferredGroupRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDeferredGroupRulesCount), (intptr_t) (1) } },
1811 { "deferredKeyframesRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDeferredKeyframesRulesCount), (intptr_t) (1) } },
1812 { "shadowRootType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionShadowRootType), (intptr_t) (1) } },
1813 { "shadowPseudoId", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionShadowPseudoId), (intptr_t) (1) } },
1814 { "setShadowPseudoId", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShadowPseudoId), (intptr_t) (2) } },
1815 { "treeScopeRootNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTreeScopeRootNode), (intptr_t) (1) } },
1816 { "parentTreeScope", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionParentTreeScope), (intptr_t) (1) } },
1817 { "lastSpatialNavigationCandidateCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCount), (intptr_t) (0) } },
1818 { "numberOfActiveAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfActiveAnimations), (intptr_t) (0) } },
1819 { "suspendAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSuspendAnimations), (intptr_t) (0) } },
1820 { "resumeAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionResumeAnimations), (intptr_t) (0) } },
1821 { "animationsAreSuspended", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAnimationsAreSuspended), (intptr_t) (0) } },
1822 { "pauseAnimationAtTimeOnElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElement), (intptr_t) (3) } },
1823 { "pauseAnimationAtTimeOnPseudoElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElement), (intptr_t) (4) } },
1824 { "pauseTransitionAtTimeOnElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElement), (intptr_t) (3) } },
1825 { "pauseTransitionAtTimeOnPseudoElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElement), (intptr_t) (4) } },
1826 { "acceleratedAnimationsForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAcceleratedAnimationsForElement), (intptr_t) (1) } },
1827 { "numberOfAnimationTimelineInvalidations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidations), (intptr_t) (0) } },
1828 { "pseudoElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPseudoElement), (intptr_t) (2) } },
1829 { "visiblePlaceholder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionVisiblePlaceholder), (intptr_t) (1) } },
1830 { "selectColorInColorChooser", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSelectColorInColorChooser), (intptr_t) (2) } },
1831 { "formControlStateOfPreviousHistoryItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItem), (intptr_t) (0) } },
1832 { "setFormControlStateOfPreviousHistoryItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItem), (intptr_t) (1) } },
1833 { "absoluteCaretBounds", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAbsoluteCaretBounds), (intptr_t) (0) } },
1834 { "isCaretBlinkingSuspended", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsCaretBlinkingSuspended), (intptr_t) (0) } },
1835 { "boundingBox", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBoundingBox), (intptr_t) (1) } },
1836 { "inspectorHighlightRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInspectorHighlightRects), (intptr_t) (0) } },
1837 { "markerCountForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkerCountForNode), (intptr_t) (2) } },
1838 { "markerRangeForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkerRangeForNode), (intptr_t) (3) } },
1839 { "markerDescriptionForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkerDescriptionForNode), (intptr_t) (3) } },
1840 { "dumpMarkerRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDumpMarkerRects), (intptr_t) (1) } },
1841 { "addTextMatchMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAddTextMatchMarker), (intptr_t) (2) } },
1842 { "setMarkedTextMatchesAreHighlighted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlighted), (intptr_t) (1) } },
1843 { "invalidateFontCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInvalidateFontCache), (intptr_t) (0) } },
1844 { "setFontSmoothingEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFontSmoothingEnabled), (intptr_t) (1) } },
1845 { "setScrollViewPosition", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetScrollViewPosition), (intptr_t) (2) } },
1846 { "unconstrainedScrollTo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUnconstrainedScrollTo), (intptr_t) (3) } },
1847 { "layoutViewportRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLayoutViewportRect), (intptr_t) (0) } },
1848 { "visualViewportRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionVisualViewportRect), (intptr_t) (0) } },
1849 { "setViewIsTransparent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetViewIsTransparent), (intptr_t) (1) } },
1850 { "viewBaseBackgroundColor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionViewBaseBackgroundColor), (intptr_t) (0) } },
1851 { "setViewBaseBackgroundColor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetViewBaseBackgroundColor), (intptr_t) (1) } },
1852 { "setPagination", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPagination), (intptr_t) (2) } },
1853 { "setPaginationLineGridEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPaginationLineGridEnabled), (intptr_t) (1) } },
1854 { "configurationForViewport", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionConfigurationForViewport), (intptr_t) (5) } },
1855 { "wasLastChangeUserEdit", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWasLastChangeUserEdit), (intptr_t) (1) } },
1856 { "elementShouldAutoComplete", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementShouldAutoComplete), (intptr_t) (1) } },
1857 { "setAutofilled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutofilled), (intptr_t) (2) } },
1858 { "setShowAutoFillButton", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShowAutoFillButton), (intptr_t) (2) } },
1859 { "autoFillButtonType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAutoFillButtonType), (intptr_t) (1) } },
1860 { "lastAutoFillButtonType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastAutoFillButtonType), (intptr_t) (1) } },
1861 { "rangeOfString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeOfString), (intptr_t) (3) } },
1862 { "countMatchesForText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCountMatchesForText), (intptr_t) (3) } },
1863 { "countFindMatches", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCountFindMatches), (intptr_t) (2) } },
1864 { "autofillFieldName", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAutofillFieldName), (intptr_t) (1) } },
1865 { "invalidateControlTints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInvalidateControlTints), (intptr_t) (0) } },
1866 { "scrollElementToRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollElementToRect), (intptr_t) (5) } },
1867 { "rangeFromLocationAndLength", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeFromLocationAndLength), (intptr_t) (3) } },
1868 { "locationFromRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLocationFromRange), (intptr_t) (2) } },
1869 { "lengthFromRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLengthFromRange), (intptr_t) (2) } },
1870 { "rangeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeAsText), (intptr_t) (1) } },
1871 { "rangeAsTextUsingBackwardsTextIterator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIterator), (intptr_t) (1) } },
1872 { "subrange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSubrange), (intptr_t) (3) } },
1873 { "rangeForDictionaryLookupAtLocation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocation), (intptr_t) (2) } },
1874 { "rangeOfStringNearLocation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeOfStringNearLocation), (intptr_t) (3) } },
1875 { "setDelegatesScrolling", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetDelegatesScrolling), (intptr_t) (1) } },
1876 { "lastSpellCheckRequestSequence", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastSpellCheckRequestSequence), (intptr_t) (0) } },
1877 { "lastSpellCheckProcessedSequence", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastSpellCheckProcessedSequence), (intptr_t) (0) } },
1878 { "userPreferredLanguages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserPreferredLanguages), (intptr_t) (0) } },
1879 { "setUserPreferredLanguages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUserPreferredLanguages), (intptr_t) (1) } },
1880 { "userPreferredAudioCharacteristics", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserPreferredAudioCharacteristics), (intptr_t) (0) } },
1881 { "setUserPreferredAudioCharacteristic", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristic), (intptr_t) (1) } },
1882 { "wheelEventHandlerCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWheelEventHandlerCount), (intptr_t) (0) } },
1883 { "touchEventHandlerCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTouchEventHandlerCount), (intptr_t) (0) } },
1884 { "touchEventRectsForEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTouchEventRectsForEvent), (intptr_t) (1) } },
1885 { "passiveTouchEventListenerRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPassiveTouchEventListenerRects), (intptr_t) (0) } },
1886 { "nodesFromRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNodesFromRect), (intptr_t) (10) } },
1887 { "parserMetaData", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionParserMetaData), (intptr_t) (0) } },
1888 { "updateEditorUINowIfScheduled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduled), (intptr_t) (0) } },
1889 { "hasSpellingMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasSpellingMarker), (intptr_t) (2) } },
1890 { "hasGrammarMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasGrammarMarker), (intptr_t) (2) } },
1891 { "hasAutocorrectedMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasAutocorrectedMarker), (intptr_t) (2) } },
1892 { "setContinuousSpellCheckingEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabled), (intptr_t) (1) } },
1893 { "setAutomaticQuoteSubstitutionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabled), (intptr_t) (1) } },
1894 { "setAutomaticLinkDetectionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabled), (intptr_t) (1) } },
1895 { "setAutomaticDashSubstitutionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabled), (intptr_t) (1) } },
1896 { "setAutomaticTextReplacementEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabled), (intptr_t) (1) } },
1897 { "setAutomaticSpellingCorrectionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabled), (intptr_t) (1) } },
1898 { "handleAcceptedCandidate", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHandleAcceptedCandidate), (intptr_t) (3) } },
1899 { "changeSelectionListType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionChangeSelectionListType), (intptr_t) (0) } },
1900 { "isOverwriteModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsOverwriteModeEnabled), (intptr_t) (0) } },
1901 { "toggleOverwriteModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionToggleOverwriteModeEnabled), (intptr_t) (0) } },
1902 { "numberOfScrollableAreas", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfScrollableAreas), (intptr_t) (0) } },
1903 { "isPageBoxVisible", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPageBoxVisible), (intptr_t) (1) } },
1904 { "imageFrameIndex", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionImageFrameIndex), (intptr_t) (1) } },
1905 { "imageFrameCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionImageFrameCount), (intptr_t) (1) } },
1906 { "imageFrameDurationAtIndex", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionImageFrameDurationAtIndex), (intptr_t) (2) } },
1907 { "setImageFrameDecodingDuration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetImageFrameDecodingDuration), (intptr_t) (2) } },
1908 { "resetImageAnimation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionResetImageAnimation), (intptr_t) (1) } },
1909 { "isImageAnimating", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsImageAnimating), (intptr_t) (1) } },
1910 { "setClearDecoderAfterAsyncFrameRequestForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTesting), (intptr_t) (2) } },
1911 { "imageDecodeCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionImageDecodeCount), (intptr_t) (1) } },
1912 { "pdfDocumentCachingCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPdfDocumentCachingCount), (intptr_t) (1) } },
1913 { "setLargeImageAsyncDecodingEnabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTesting), (intptr_t) (2) } },
1914 { "setForceUpdateImageDataEnabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTesting), (intptr_t) (2) } },
1915 { "setGridMaxTracksLimit", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetGridMaxTracksLimit), (intptr_t) (1) } },
1916 { "svgAnimationsInterval", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSVGAnimationsInterval), (intptr_t) (1) } },
1917 { "layerTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLayerTreeAsText), (intptr_t) (1) } },
1918 { "layerIDForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLayerIDForElement), (intptr_t) (1) } },
1919 { "scrollbarOverlayStyle", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollbarOverlayStyle), (intptr_t) (0) } },
1920 { "scrollbarUsingDarkAppearance", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollbarUsingDarkAppearance), (intptr_t) (0) } },
1921 { "scrollingStateTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollingStateTreeAsText), (intptr_t) (0) } },
1922 { "mainThreadScrollingReasons", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMainThreadScrollingReasons), (intptr_t) (0) } },
1923 { "nonFastScrollableRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNonFastScrollableRects), (intptr_t) (0) } },
1924 { "repaintRectsAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRepaintRectsAsText), (intptr_t) (0) } },
1925 { "setElementUsesDisplayListDrawing", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawing), (intptr_t) (2) } },
1926 { "setElementTracksDisplayListReplay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetElementTracksDisplayListReplay), (intptr_t) (2) } },
1927 { "displayListForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDisplayListForElement), (intptr_t) (1) } },
1928 { "replayDisplayListForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReplayDisplayListForElement), (intptr_t) (1) } },
1929 { "garbageCollectDocumentResources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGarbageCollectDocumentResources), (intptr_t) (0) } },
1930 { "insertAuthorCSS", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInsertAuthorCSS), (intptr_t) (1) } },
1931 { "insertUserCSS", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInsertUserCSS), (intptr_t) (1) } },
1932 { "beginSimulatedMemoryPressure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBeginSimulatedMemoryPressure), (intptr_t) (0) } },
1933 { "endSimulatedMemoryPressure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEndSimulatedMemoryPressure), (intptr_t) (0) } },
1934 { "numberOfIDBTransactions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfIDBTransactions), (intptr_t) (0) } },
1935 { "numberOfLiveNodes", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfLiveNodes), (intptr_t) (0) } },
1936 { "numberOfLiveDocuments", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfLiveDocuments), (intptr_t) (0) } },
1937 { "referencingNodeCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReferencingNodeCount), (intptr_t) (1) } },
1938#if ENABLE(INTERSECTION_OBSERVER)
1939 { "numberOfIntersectionObservers", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfIntersectionObservers), (intptr_t) (1) } },
1940#else
1941 { 0, 0, NoIntrinsic, { 0, 0 } },
1942#endif
1943 { "openDummyInspectorFrontend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionOpenDummyInspectorFrontend), (intptr_t) (1) } },
1944 { "closeDummyInspectorFrontend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCloseDummyInspectorFrontend), (intptr_t) (0) } },
1945 { "setInspectorIsUnderTest", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetInspectorIsUnderTest), (intptr_t) (1) } },
1946 { "counterValue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCounterValue), (intptr_t) (1) } },
1947 { "pageNumber", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageNumber), (intptr_t) (1) } },
1948 { "shortcutIconURLs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionShortcutIconURLs), (intptr_t) (0) } },
1949 { "numberOfPages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfPages), (intptr_t) (0) } },
1950 { "pageProperty", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageProperty), (intptr_t) (2) } },
1951 { "pageSizeAndMarginsInPixels", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageSizeAndMarginsInPixels), (intptr_t) (7) } },
1952 { "setPageScaleFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageScaleFactor), (intptr_t) (3) } },
1953 { "pageScaleFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageScaleFactor), (intptr_t) (0) } },
1954 { "setPageZoomFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageZoomFactor), (intptr_t) (1) } },
1955 { "setTextZoomFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetTextZoomFactor), (intptr_t) (1) } },
1956 { "setUseFixedLayout", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUseFixedLayout), (intptr_t) (1) } },
1957 { "setFixedLayoutSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFixedLayoutSize), (intptr_t) (2) } },
1958 { "setPrinting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPrinting), (intptr_t) (2) } },
1959 { "setViewExposedRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetViewExposedRect), (intptr_t) (4) } },
1960 { "setHeaderHeight", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetHeaderHeight), (intptr_t) (1) } },
1961 { "setFooterHeight", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFooterHeight), (intptr_t) (1) } },
1962 { "setTopContentInset", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetTopContentInset), (intptr_t) (1) } },
1963#if ENABLE(FULLSCREEN_API)
1964 { "webkitWillEnterFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElement), (intptr_t) (1) } },
1965#else
1966 { 0, 0, NoIntrinsic, { 0, 0 } },
1967#endif
1968#if ENABLE(FULLSCREEN_API)
1969 { "webkitDidEnterFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElement), (intptr_t) (1) } },
1970#else
1971 { 0, 0, NoIntrinsic, { 0, 0 } },
1972#endif
1973#if ENABLE(FULLSCREEN_API)
1974 { "webkitWillExitFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElement), (intptr_t) (1) } },
1975#else
1976 { 0, 0, NoIntrinsic, { 0, 0 } },
1977#endif
1978#if ENABLE(FULLSCREEN_API)
1979 { "webkitDidExitFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElement), (intptr_t) (1) } },
1980#else
1981 { 0, 0, NoIntrinsic, { 0, 0 } },
1982#endif
1983 { "setFullscreenInsets", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFullscreenInsets), (intptr_t) (1) } },
1984 { "setFullscreenAutoHideDuration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFullscreenAutoHideDuration), (intptr_t) (1) } },
1985 { "setFullscreenControlsHidden", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFullscreenControlsHidden), (intptr_t) (1) } },
1986 { "setApplicationCacheOriginQuota", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetApplicationCacheOriginQuota), (intptr_t) (1) } },
1987 { "registerURLSchemeAsBypassingContentSecurityPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicy), (intptr_t) (1) } },
1988 { "removeURLSchemeRegisteredAsBypassingContentSecurityPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicy), (intptr_t) (1) } },
1989 { "registerDefaultPortForProtocol", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRegisterDefaultPortForProtocol), (intptr_t) (2) } },
1990 { "mallocStatistics", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMallocStatistics), (intptr_t) (0) } },
1991 { "typeConversions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTypeConversions), (intptr_t) (0) } },
1992 { "memoryInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMemoryInfo), (intptr_t) (0) } },
1993 { "getReferencedFilePaths", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetReferencedFilePaths), (intptr_t) (0) } },
1994 { "startTrackingRepaints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStartTrackingRepaints), (intptr_t) (0) } },
1995 { "stopTrackingRepaints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStopTrackingRepaints), (intptr_t) (0) } },
1996 { "startTrackingLayerFlushes", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStartTrackingLayerFlushes), (intptr_t) (0) } },
1997 { "layerFlushCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLayerFlushCount), (intptr_t) (0) } },
1998 { "isTimerThrottled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsTimerThrottled), (intptr_t) (1) } },
1999 { "isRequestAnimationFrameThrottled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottled), (intptr_t) (0) } },
2000 { "areTimersThrottled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAreTimersThrottled), (intptr_t) (0) } },
2001 { "setLowPowerModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetLowPowerModeEnabled), (intptr_t) (1) } },
2002 { "startTrackingStyleRecalcs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStartTrackingStyleRecalcs), (intptr_t) (0) } },
2003 { "styleRecalcCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStyleRecalcCount), (intptr_t) (0) } },
2004 { "startTrackingCompositingUpdates", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStartTrackingCompositingUpdates), (intptr_t) (0) } },
2005 { "compositingUpdateCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCompositingUpdateCount), (intptr_t) (0) } },
2006 { "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks), (intptr_t) (0) } },
2007 { "getCurrentCursorInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetCurrentCursorInfo), (intptr_t) (0) } },
2008 { "markerTextForListItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkerTextForListItem), (intptr_t) (1) } },
2009 { "toolTipFromElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionToolTipFromElement), (intptr_t) (1) } },
2010 { "deserializeBuffer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDeserializeBuffer), (intptr_t) (1) } },
2011 { "serializeObject", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSerializeObject), (intptr_t) (1) } },
2012 { "isFromCurrentWorld", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsFromCurrentWorld), (intptr_t) (1) } },
2013 { "setUsesOverlayScrollbars", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUsesOverlayScrollbars), (intptr_t) (1) } },
2014 { "setUsesMockScrollAnimator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUsesMockScrollAnimator), (intptr_t) (1) } },
2015 { "forceReload", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionForceReload), (intptr_t) (1) } },
2016 { "reloadExpiredOnly", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReloadExpiredOnly), (intptr_t) (0) } },
2017 { "enableAutoSizeMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnableAutoSizeMode), (intptr_t) (3) } },
2018#if ENABLE(VIDEO)
2019 { "mediaResponseSources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaResponseSources), (intptr_t) (1) } },
2020#else
2021 { 0, 0, NoIntrinsic, { 0, 0 } },
2022#endif
2023#if ENABLE(VIDEO)
2024 { "mediaResponseContentRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaResponseContentRanges), (intptr_t) (1) } },
2025#else
2026 { 0, 0, NoIntrinsic, { 0, 0 } },
2027#endif
2028#if ENABLE(VIDEO)
2029 { "simulateAudioInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateAudioInterruption), (intptr_t) (1) } },
2030#else
2031 { 0, 0, NoIntrinsic, { 0, 0 } },
2032#endif
2033#if ENABLE(VIDEO)
2034 { "mediaElementHasCharacteristic", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaElementHasCharacteristic), (intptr_t) (2) } },
2035#else
2036 { 0, 0, NoIntrinsic, { 0, 0 } },
2037#endif
2038#if ENABLE(VIDEO)
2039 { "beginSimulatedHDCPError", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBeginSimulatedHDCPError), (intptr_t) (1) } },
2040#else
2041 { 0, 0, NoIntrinsic, { 0, 0 } },
2042#endif
2043#if ENABLE(VIDEO)
2044 { "endSimulatedHDCPError", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEndSimulatedHDCPError), (intptr_t) (1) } },
2045#else
2046 { 0, 0, NoIntrinsic, { 0, 0 } },
2047#endif
2048#if ENABLE(VIDEO)
2049 { "elementShouldBufferData", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementShouldBufferData), (intptr_t) (1) } },
2050#else
2051 { 0, 0, NoIntrinsic, { 0, 0 } },
2052#endif
2053#if ENABLE(VIDEO)
2054 { "elementBufferingPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementBufferingPolicy), (intptr_t) (1) } },
2055#else
2056 { 0, 0, NoIntrinsic, { 0, 0 } },
2057#endif
2058#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
2059 { "initializeMockCDM", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInitializeMockCDM), (intptr_t) (0) } },
2060#else
2061 { 0, 0, NoIntrinsic, { 0, 0 } },
2062#endif
2063#if ENABLE(ENCRYPTED_MEDIA)
2064 { "registerMockCDM", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRegisterMockCDM), (intptr_t) (0) } },
2065#else
2066 { 0, 0, NoIntrinsic, { 0, 0 } },
2067#endif
2068 { "enableMockMediaCapabilities", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnableMockMediaCapabilities), (intptr_t) (0) } },
2069#if ENABLE(SPEECH_SYNTHESIS)
2070 { "enableMockSpeechSynthesizer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnableMockSpeechSynthesizer), (intptr_t) (0) } },
2071#else
2072 { 0, 0, NoIntrinsic, { 0, 0 } },
2073#endif
2074 { "getImageSourceURL", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetImageSourceURL), (intptr_t) (1) } },
2075#if ENABLE(VIDEO_TRACK)
2076 { "captionsStyleSheetOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCaptionsStyleSheetOverride), (intptr_t) (0) } },
2077#else
2078 { 0, 0, NoIntrinsic, { 0, 0 } },
2079#endif
2080#if ENABLE(VIDEO_TRACK)
2081 { "setCaptionsStyleSheetOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverride), (intptr_t) (1) } },
2082#else
2083 { 0, 0, NoIntrinsic, { 0, 0 } },
2084#endif
2085#if ENABLE(VIDEO_TRACK)
2086 { "setPrimaryAudioTrackLanguageOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverride), (intptr_t) (1) } },
2087#else
2088 { 0, 0, NoIntrinsic, { 0, 0 } },
2089#endif
2090#if ENABLE(VIDEO_TRACK)
2091 { "setCaptionDisplayMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCaptionDisplayMode), (intptr_t) (1) } },
2092#else
2093 { 0, 0, NoIntrinsic, { 0, 0 } },
2094#endif
2095#if ENABLE(VIDEO_TRACK)
2096 { "createGenericCue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCreateGenericCue), (intptr_t) (3) } },
2097#else
2098 { 0, 0, NoIntrinsic, { 0, 0 } },
2099#endif
2100#if ENABLE(VIDEO)
2101 { "createTimeRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCreateTimeRanges), (intptr_t) (2) } },
2102#else
2103 { 0, 0, NoIntrinsic, { 0, 0 } },
2104#endif
2105#if ENABLE(VIDEO)
2106 { "closestTimeToTimeRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClosestTimeToTimeRanges), (intptr_t) (2) } },
2107#else
2108 { 0, 0, NoIntrinsic, { 0, 0 } },
2109#endif
2110 { "isSelectPopupVisible", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsSelectPopupVisible), (intptr_t) (1) } },
2111 { "isPluginUnavailabilityIndicatorObscured", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscured), (intptr_t) (1) } },
2112 { "unavailablePluginReplacementText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUnavailablePluginReplacementText), (intptr_t) (1) } },
2113 { "isPluginSnapshotted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPluginSnapshotted), (intptr_t) (1) } },
2114 { "pluginIsBelowSizeThreshold", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPluginIsBelowSizeThreshold), (intptr_t) (1) } },
2115 { "selectionBounds", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSelectionBounds), (intptr_t) (0) } },
2116 { "setSelectionWithoutValidation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetSelectionWithoutValidation), (intptr_t) (4) } },
2117#if ENABLE(MEDIA_SOURCE)
2118 { "initializeMockMediaSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInitializeMockMediaSource), (intptr_t) (0) } },
2119#else
2120 { 0, 0, NoIntrinsic, { 0, 0 } },
2121#endif
2122#if ENABLE(MEDIA_SOURCE)
2123 { "bufferedSamplesForTrackID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBufferedSamplesForTrackID), (intptr_t) (2) } },
2124#else
2125 { 0, 0, NoIntrinsic, { 0, 0 } },
2126#endif
2127#if ENABLE(MEDIA_SOURCE)
2128 { "enqueuedSamplesForTrackID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnqueuedSamplesForTrackID), (intptr_t) (2) } },
2129#else
2130 { 0, 0, NoIntrinsic, { 0, 0 } },
2131#endif
2132#if ENABLE(MEDIA_SOURCE)
2133 { "setShouldGenerateTimestamps", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShouldGenerateTimestamps), (intptr_t) (2) } },
2134#else
2135 { 0, 0, NoIntrinsic, { 0, 0 } },
2136#endif
2137#if ENABLE(VIDEO)
2138 { "beginMediaSessionInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBeginMediaSessionInterruption), (intptr_t) (1) } },
2139#else
2140 { 0, 0, NoIntrinsic, { 0, 0 } },
2141#endif
2142#if ENABLE(VIDEO)
2143 { "endMediaSessionInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEndMediaSessionInterruption), (intptr_t) (1) } },
2144#else
2145 { 0, 0, NoIntrinsic, { 0, 0 } },
2146#endif
2147#if ENABLE(MEDIA_SESSION)
2148 { "sendMediaSessionStartOfInterruptionNotification", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotification), (intptr_t) (1) } },
2149#else
2150 { 0, 0, NoIntrinsic, { 0, 0 } },
2151#endif
2152#if ENABLE(MEDIA_SESSION)
2153 { "sendMediaSessionEndOfInterruptionNotification", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotification), (intptr_t) (1) } },
2154#else
2155 { 0, 0, NoIntrinsic, { 0, 0 } },
2156#endif
2157#if ENABLE(MEDIA_SESSION)
2158 { "mediaSessionCurrentState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaSessionCurrentState), (intptr_t) (1) } },
2159#else
2160 { 0, 0, NoIntrinsic, { 0, 0 } },
2161#endif
2162#if ENABLE(MEDIA_SESSION)
2163 { "mediaElementPlayerVolume", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaElementPlayerVolume), (intptr_t) (1) } },
2164#else
2165 { 0, 0, NoIntrinsic, { 0, 0 } },
2166#endif
2167#if ENABLE(MEDIA_SESSION)
2168 { "sendMediaControlEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSendMediaControlEvent), (intptr_t) (1) } },
2169#else
2170 { 0, 0, NoIntrinsic, { 0, 0 } },
2171#endif
2172#if ENABLE(VIDEO)
2173 { "applicationWillBecomeInactive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplicationWillBecomeInactive), (intptr_t) (0) } },
2174#else
2175 { 0, 0, NoIntrinsic, { 0, 0 } },
2176#endif
2177#if ENABLE(VIDEO)
2178 { "applicationDidBecomeActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplicationDidBecomeActive), (intptr_t) (0) } },
2179#else
2180 { 0, 0, NoIntrinsic, { 0, 0 } },
2181#endif
2182#if ENABLE(VIDEO)
2183 { "applicationWillEnterForeground", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplicationWillEnterForeground), (intptr_t) (0) } },
2184#else
2185 { 0, 0, NoIntrinsic, { 0, 0 } },
2186#endif
2187#if ENABLE(VIDEO)
2188 { "applicationDidEnterBackground", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplicationDidEnterBackground), (intptr_t) (0) } },
2189#else
2190 { 0, 0, NoIntrinsic, { 0, 0 } },
2191#endif
2192#if ENABLE(VIDEO)
2193 { "setMediaSessionRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaSessionRestrictions), (intptr_t) (2) } },
2194#else
2195 { 0, 0, NoIntrinsic, { 0, 0 } },
2196#endif
2197#if ENABLE(VIDEO)
2198 { "mediaSessionRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaSessionRestrictions), (intptr_t) (1) } },
2199#else
2200 { 0, 0, NoIntrinsic, { 0, 0 } },
2201#endif
2202#if ENABLE(VIDEO)
2203 { "setMediaElementRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaElementRestrictions), (intptr_t) (2) } },
2204#else
2205 { 0, 0, NoIntrinsic, { 0, 0 } },
2206#endif
2207#if ENABLE(WEB_AUDIO)
2208 { "setAudioContextRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAudioContextRestrictions), (intptr_t) (2) } },
2209#else
2210 { 0, 0, NoIntrinsic, { 0, 0 } },
2211#endif
2212#if ENABLE(VIDEO)
2213 { "postRemoteControlCommand", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPostRemoteControlCommand), (intptr_t) (1) } },
2214#else
2215 { 0, 0, NoIntrinsic, { 0, 0 } },
2216#endif
2217#if ENABLE(WIRELESS_PLAYBACK_TARGET)
2218 { "setMockMediaPlaybackTargetPickerEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabled), (intptr_t) (1) } },
2219#else
2220 { 0, 0, NoIntrinsic, { 0, 0 } },
2221#endif
2222#if ENABLE(WIRELESS_PLAYBACK_TARGET)
2223 { "setMockMediaPlaybackTargetPickerState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerState), (intptr_t) (2) } },
2224#else
2225 { 0, 0, NoIntrinsic, { 0, 0 } },
2226#endif
2227#if ENABLE(MEDIA_STREAM)
2228 { "setMockMediaCaptureDevicesEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabled), (intptr_t) (1) } },
2229#else
2230 { 0, 0, NoIntrinsic, { 0, 0 } },
2231#endif
2232#if ENABLE(MEDIA_STREAM)
2233 { "setCustomPrivateRecorderCreator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreator), (intptr_t) (0) } },
2234#else
2235 { 0, 0, NoIntrinsic, { 0, 0 } },
2236#endif
2237#if ENABLE(WEB_RTC)
2238 { "emulateRTCPeerConnectionPlatformEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEvent), (intptr_t) (2) } },
2239#else
2240 { 0, 0, NoIntrinsic, { 0, 0 } },
2241#endif
2242#if ENABLE(WEB_RTC)
2243 { "useMockRTCPeerConnectionFactory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactory), (intptr_t) (1) } },
2244#else
2245 { 0, 0, NoIntrinsic, { 0, 0 } },
2246#endif
2247#if ENABLE(WEB_RTC)
2248 { "setICECandidateFiltering", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetICECandidateFiltering), (intptr_t) (1) } },
2249#else
2250 { 0, 0, NoIntrinsic, { 0, 0 } },
2251#endif
2252#if ENABLE(WEB_RTC)
2253 { "setEnumeratingAllNetworkInterfacesEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabled), (intptr_t) (1) } },
2254#else
2255 { 0, 0, NoIntrinsic, { 0, 0 } },
2256#endif
2257#if ENABLE(WEB_RTC)
2258 { "stopPeerConnection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStopPeerConnection), (intptr_t) (1) } },
2259#else
2260 { 0, 0, NoIntrinsic, { 0, 0 } },
2261#endif
2262#if ENABLE(WEB_RTC)
2263 { "clearPeerConnectionFactory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClearPeerConnectionFactory), (intptr_t) (0) } },
2264#else
2265 { 0, 0, NoIntrinsic, { 0, 0 } },
2266#endif
2267#if ENABLE(VIDEO)
2268 { "simulateSystemSleep", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateSystemSleep), (intptr_t) (0) } },
2269#else
2270 { 0, 0, NoIntrinsic, { 0, 0 } },
2271#endif
2272#if ENABLE(VIDEO)
2273 { "simulateSystemWake", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateSystemWake), (intptr_t) (0) } },
2274#else
2275 { 0, 0, NoIntrinsic, { 0, 0 } },
2276#endif
2277#if ENABLE(VIDEO)
2278 { "elementIsBlockingDisplaySleep", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementIsBlockingDisplaySleep), (intptr_t) (1) } },
2279#else
2280 { 0, 0, NoIntrinsic, { 0, 0 } },
2281#endif
2282 { "installMockPageOverlay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInstallMockPageOverlay), (intptr_t) (1) } },
2283 { "pageOverlayLayerTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageOverlayLayerTreeAsText), (intptr_t) (0) } },
2284 { "setPageMuted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageMuted), (intptr_t) (1) } },
2285 { "pageMediaState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageMediaState), (intptr_t) (0) } },
2286 { "setPageDefersLoading", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageDefersLoading), (intptr_t) (1) } },
2287 { "pageDefersLoading", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageDefersLoading), (intptr_t) (0) } },
2288 { "createFile", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCreateFile), (intptr_t) (1) } },
2289 { "queueMicroTask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionQueueMicroTask), (intptr_t) (1) } },
2290 { "testPreloaderSettingViewport", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTestPreloaderSettingViewport), (intptr_t) (0) } },
2291#if ENABLE(CSS_SCROLL_SNAP)
2292 { "scrollSnapOffsets", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollSnapOffsets), (intptr_t) (1) } },
2293#else
2294 { 0, 0, NoIntrinsic, { 0, 0 } },
2295#endif
2296#if ENABLE(CSS_SCROLL_SNAP)
2297 { "setPlatformMomentumScrollingPredictionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabled), (intptr_t) (1) } },
2298#else
2299 { 0, 0, NoIntrinsic, { 0, 0 } },
2300#endif
2301 { "pathStringWithShrinkWrappedRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRects), (intptr_t) (2) } },
2302#if ENABLE(VIDEO)
2303 { "getCurrentMediaControlsStatusForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElement), (intptr_t) (1) } },
2304#else
2305 { 0, 0, NoIntrinsic, { 0, 0 } },
2306#endif
2307 { "userVisibleString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserVisibleString), (intptr_t) (1) } },
2308 { "setShowAllPlugins", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShowAllPlugins), (intptr_t) (1) } },
2309#if ENABLE(STREAMS_API)
2310 { "cloneArrayBuffer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCloneArrayBuffer), (intptr_t) (3) } },
2311#else
2312 { 0, 0, NoIntrinsic, { 0, 0 } },
2313#endif
2314#if ENABLE(STREAMS_API)
2315 { "isReadableStreamDisturbed", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsReadableStreamDisturbed), (intptr_t) (1) } },
2316#else
2317 { 0, 0, NoIntrinsic, { 0, 0 } },
2318#endif
2319 { "resourceLoadStatisticsForURL", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionResourceLoadStatisticsForURL), (intptr_t) (1) } },
2320 { "setResourceLoadStatisticsEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabled), (intptr_t) (1) } },
2321 { "setCanShowModalDialogOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCanShowModalDialogOverride), (intptr_t) (1) } },
2322 { "composedTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionComposedTreeAsText), (intptr_t) (1) } },
2323 { "isProcessingUserGesture", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsProcessingUserGesture), (intptr_t) (0) } },
2324 { "lastHandledUserGestureTimestamp", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastHandledUserGestureTimestamp), (intptr_t) (0) } },
2325 { "withUserGesture", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWithUserGesture), (intptr_t) (1) } },
2326 { "userIsInteracting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserIsInteracting), (intptr_t) (0) } },
2327 { "observeGC", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionObserveGC), (intptr_t) (1) } },
2328 { "setUserInterfaceLayoutDirection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirection), (intptr_t) (1) } },
2329 { "setBaseWritingDirection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetBaseWritingDirection), (intptr_t) (1) } },
2330 { "userPrefersReducedMotion", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserPrefersReducedMotion), (intptr_t) (0) } },
2331 { "reportBacktrace", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReportBacktrace), (intptr_t) (0) } },
2332#if ENABLE(POINTER_LOCK)
2333 { "pageHasPendingPointerLock", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageHasPendingPointerLock), (intptr_t) (0) } },
2334#else
2335 { 0, 0, NoIntrinsic, { 0, 0 } },
2336#endif
2337#if ENABLE(POINTER_LOCK)
2338 { "pageHasPointerLock", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageHasPointerLock), (intptr_t) (0) } },
2339#else
2340 { 0, 0, NoIntrinsic, { 0, 0 } },
2341#endif
2342 { "accessKeyModifiers", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAccessKeyModifiers), (intptr_t) (0) } },
2343 { "setQuickLookPassword", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetQuickLookPassword), (intptr_t) (1) } },
2344 { "setAsRunningUserScripts", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAsRunningUserScripts), (intptr_t) (0) } },
2345#if ENABLE(APPLE_PAY)
2346 { "setApplePayIsActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetApplePayIsActive), (intptr_t) (0) } },
2347#else
2348 { 0, 0, NoIntrinsic, { 0, 0 } },
2349#endif
2350 { "disableTileSizeUpdateDelay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDisableTileSizeUpdateDelay), (intptr_t) (0) } },
2351 { "setSpeculativeTilingDelayDisabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTesting), (intptr_t) (1) } },
2352#if ENABLE(WEBGL)
2353 { "simulateWebGLContextChanged", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateWebGLContextChanged), (intptr_t) (1) } },
2354#else
2355 { 0, 0, NoIntrinsic, { 0, 0 } },
2356#endif
2357#if ENABLE(WEBGL)
2358 { "failNextGPUStatusCheck", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionFailNextGPUStatusCheck), (intptr_t) (1) } },
2359#else
2360 { 0, 0, NoIntrinsic, { 0, 0 } },
2361#endif
2362#if ENABLE(WEBGL)
2363 { "hasLowAndHighPowerGPUs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasLowAndHighPowerGPUs), (intptr_t) (0) } },
2364#else
2365 { 0, 0, NoIntrinsic, { 0, 0 } },
2366#endif
2367 { "setPageVisibility", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageVisibility), (intptr_t) (1) } },
2368 { "setPageIsFocusedAndActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageIsFocusedAndActive), (intptr_t) (1) } },
2369#if ENABLE(WEB_RTC)
2370 { "setH264HardwareEncoderAllowed", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowed), (intptr_t) (1) } },
2371#else
2372 { 0, 0, NoIntrinsic, { 0, 0 } },
2373#endif
2374#if ENABLE(WEB_RTC)
2375 { "applyRotationForOutgoingVideoSources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSources), (intptr_t) (1) } },
2376#else
2377 { 0, 0, NoIntrinsic, { 0, 0 } },
2378#endif
2379#if ENABLE(MEDIA_STREAM)
2380 { "setShouldInterruptAudioOnPageVisibilityChange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShouldInterruptAudioOnPageVisibilityChange), (intptr_t) (1) } },
2381#else
2382 { 0, 0, NoIntrinsic, { 0, 0 } },
2383#endif
2384#if ENABLE(MEDIA_STREAM)
2385 { "setCameraMediaStreamTrackOrientation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientation), (intptr_t) (2) } },
2386#else
2387 { 0, 0, NoIntrinsic, { 0, 0 } },
2388#endif
2389#if ENABLE(MEDIA_STREAM)
2390 { "observeMediaStreamTrack", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionObserveMediaStreamTrack), (intptr_t) (1) } },
2391#else
2392 { 0, 0, NoIntrinsic, { 0, 0 } },
2393#endif
2394#if ENABLE(MEDIA_STREAM)
2395 { "grabNextMediaStreamTrackFrame", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrame), (intptr_t) (0) } },
2396#else
2397 { 0, 0, NoIntrinsic, { 0, 0 } },
2398#endif
2399#if ENABLE(MEDIA_STREAM)
2400 { "delayMediaStreamTrackSamples", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDelayMediaStreamTrackSamples), (intptr_t) (2) } },
2401#else
2402 { 0, 0, NoIntrinsic, { 0, 0 } },
2403#endif
2404#if ENABLE(MEDIA_STREAM)
2405 { "setMediaStreamTrackMuted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaStreamTrackMuted), (intptr_t) (2) } },
2406#else
2407 { 0, 0, NoIntrinsic, { 0, 0 } },
2408#endif
2409#if ENABLE(MEDIA_STREAM)
2410 { "removeMediaStreamTrack", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRemoveMediaStreamTrack), (intptr_t) (2) } },
2411#else
2412 { 0, 0, NoIntrinsic, { 0, 0 } },
2413#endif
2414#if ENABLE(MEDIA_STREAM)
2415 { "simulateMediaStreamTrackCaptureSourceFailure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailure), (intptr_t) (1) } },
2416#else
2417 { 0, 0, NoIntrinsic, { 0, 0 } },
2418#endif
2419#if ENABLE(MEDIA_STREAM)
2420 { "setMediaStreamTrackIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifier), (intptr_t) (2) } },
2421#else
2422 { 0, 0, NoIntrinsic, { 0, 0 } },
2423#endif
2424#if ENABLE(MEDIA_STREAM)
2425 { "setMediaStreamSourceInterrupted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaStreamSourceInterrupted), (intptr_t) (2) } },
2426#else
2427 { 0, 0, NoIntrinsic, { 0, 0 } },
2428#endif
2429#if ENABLE(MEDIA_STREAM)
2430 { "setDisableGetDisplayMediaUserGestureConstraint", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraint), (intptr_t) (1) } },
2431#else
2432 { 0, 0, NoIntrinsic, { 0, 0 } },
2433#endif
2434 { "documentIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDocumentIdentifier), (intptr_t) (1) } },
2435 { "isDocumentAlive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsDocumentAlive), (intptr_t) (1) } },
2436 { "isAnyWorkletGlobalScopeAlive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAlive), (intptr_t) (0) } },
2437 { "serviceWorkerClientIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionServiceWorkerClientIdentifier), (intptr_t) (1) } },
2438 { "storeRegistrationsOnDisk", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStoreRegistrationsOnDisk), (intptr_t) (0) } },
2439 { "clearCacheStorageMemoryRepresentation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentation), (intptr_t) (0) } },
2440 { "cacheStorageEngineRepresentation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCacheStorageEngineRepresentation), (intptr_t) (0) } },
2441 { "setResponseSizeWithPadding", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetResponseSizeWithPadding), (intptr_t) (2) } },
2442 { "responseSizeWithPadding", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionResponseSizeWithPadding), (intptr_t) (1) } },
2443 { "updateQuotaBasedOnSpaceUsage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsage), (intptr_t) (0) } },
2444 { "setConsoleMessageListener", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetConsoleMessageListener), (intptr_t) (1) } },
2445 { "audioSessionCategory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAudioSessionCategory), (intptr_t) (0) } },
2446 { "preferredAudioBufferSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPreferredAudioBufferSize), (intptr_t) (0) } },
2447 { "audioSessionActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAudioSessionActive), (intptr_t) (0) } },
2448#if ENABLE(SERVICE_WORKER)
2449 { "hasServiceWorkerRegistration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasServiceWorkerRegistration), (intptr_t) (1) } },
2450#else
2451 { 0, 0, NoIntrinsic, { 0, 0 } },
2452#endif
2453#if ENABLE(SERVICE_WORKER)
2454 { "terminateServiceWorker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTerminateServiceWorker), (intptr_t) (1) } },
2455#else
2456 { 0, 0, NoIntrinsic, { 0, 0 } },
2457#endif
2458#if ENABLE(SERVICE_WORKER)
2459 { "hasServiceWorkerConnection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasServiceWorkerConnection), (intptr_t) (0) } },
2460#else
2461 { 0, 0, NoIntrinsic, { 0, 0 } },
2462#endif
2463 { "isSystemPreviewLink", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsSystemPreviewLink), (intptr_t) (1) } },
2464 { "isSystemPreviewImage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsSystemPreviewImage), (intptr_t) (1) } },
2465 { "usingAppleInternalSDK", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUsingAppleInternalSDK), (intptr_t) (0) } },
2466 { "postTask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPostTask), (intptr_t) (1) } },
2467 { "markContextAsInsecure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkContextAsInsecure), (intptr_t) (0) } },
2468#if ENABLE(VIDEO)
2469 { "bestMediaElementForShowingPlaybackControlsManager", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManager), (intptr_t) (1) } },
2470#else
2471 { 0, 0, NoIntrinsic, { 0, 0 } },
2472#endif
2473#if ENABLE(VIDEO)
2474 { "mediaSessionState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaSessionState), (intptr_t) (1) } },
2475#else
2476 { 0, 0, NoIntrinsic, { 0, 0 } },
2477#endif
2478 { "ongoingLoadsDescriptions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionOngoingLoadsDescriptions), (intptr_t) (0) } },
2479 { "setCaptureExtraNetworkLoadMetricsEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabled), (intptr_t) (1) } },
2480 { "reloadWithoutContentExtensions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReloadWithoutContentExtensions), (intptr_t) (0) } },
2481 { "setUseSystemAppearance", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUseSystemAppearance), (intptr_t) (1) } },
2482 { "pluginCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPluginCount), (intptr_t) (0) } },
2483 { "notifyResourceLoadObserver", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNotifyResourceLoadObserver), (intptr_t) (0) } },
2484 { "primaryScreenDisplayID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPrimaryScreenDisplayID), (intptr_t) (0) } },
2485 { "capsLockIsOn", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCapsLockIsOn), (intptr_t) (0) } },
2486 { "supportsVCPEncoder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSupportsVCPEncoder), (intptr_t) (0) } },
2487 { "parseHEVCCodecParameters", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionParseHEVCCodecParameters), (intptr_t) (1) } },
2488 { "getCookies", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetCookies), (intptr_t) (0) } },
2489 { "setAlwaysAllowLocalWebarchive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchive), (intptr_t) (1) } },
2490 { "processWillSuspend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionProcessWillSuspend), (intptr_t) (0) } },
2491 { "processDidResume", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionProcessDidResume), (intptr_t) (0) } },
2492 { "testDictionaryLogging", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTestDictionaryLogging), (intptr_t) (0) } },
2493 { "setXHRMaximumIntervalForUserGestureForwarding", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwarding), (intptr_t) (2) } },
2494 { "setIsPlayingToAutomotiveHeadUnit", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetIsPlayingToAutomotiveHeadUnit), (intptr_t) (1) } },
2495 { "LAYER_TREE_INCLUDES_VISIBLE_RECTS", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(1) } },
2496 { "LAYER_TREE_INCLUDES_TILE_CACHES", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(2) } },
2497 { "LAYER_TREE_INCLUDES_REPAINT_RECTS", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(4) } },
2498 { "LAYER_TREE_INCLUDES_PAINTING_PHASES", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(8) } },
2499 { "LAYER_TREE_INCLUDES_CONTENT_LAYERS", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(16) } },
2500 { "LAYER_TREE_INCLUDES_ACCELERATES_DRAWING", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(32) } },
2501 { "LAYER_TREE_INCLUDES_BACKING_STORE_ATTACHED", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(64) } },
2502 { "LAYER_TREE_INCLUDES_ROOT_LAYER_PROPERTIES", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(128) } },
2503 { "LAYER_TREE_INCLUDES_EVENT_REGION", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(256) } },
2504 { "DISPLAY_LIST_INCLUDES_PLATFORM_OPERATIONS", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(1) } },
2505};
2506
2507const ClassInfo JSInternalsPrototype::s_info = { "InternalsPrototype", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSInternalsPrototype) };
2508
2509void JSInternalsPrototype::finishCreation(VM& vm)
2510{
2511 Base::finishCreation(vm);
2512 reifyStaticProperties(vm, JSInternals::info(), JSInternalsPrototypeTableValues, *this);
2513}
2514
2515const ClassInfo JSInternals::s_info = { "Internals", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSInternals) };
2516
2517JSInternals::JSInternals(Structure* structure, JSDOMGlobalObject& globalObject, Ref<Internals>&& impl)
2518 : JSDOMWrapper<Internals>(structure, globalObject, WTFMove(impl))
2519{
2520}
2521
2522void JSInternals::finishCreation(VM& vm)
2523{
2524 Base::finishCreation(vm);
2525 ASSERT(inherits(vm, info()));
2526
2527}
2528
2529JSObject* JSInternals::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
2530{
2531 return JSInternalsPrototype::create(vm, &globalObject, JSInternalsPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
2532}
2533
2534JSObject* JSInternals::prototype(VM& vm, JSDOMGlobalObject& globalObject)
2535{
2536 return getDOMPrototype<JSInternals>(vm, globalObject);
2537}
2538
2539void JSInternals::destroy(JSC::JSCell* cell)
2540{
2541 JSInternals* thisObject = static_cast<JSInternals*>(cell);
2542 thisObject->JSInternals::~JSInternals();
2543}
2544
2545template<> inline JSInternals* IDLAttribute<JSInternals>::cast(ExecState& state, EncodedJSValue thisValue)
2546{
2547 return jsDynamicCast<JSInternals*>(state.vm(), JSValue::decode(thisValue));
2548}
2549
2550template<> inline JSInternals* IDLOperation<JSInternals>::cast(ExecState& state)
2551{
2552 return jsDynamicCast<JSInternals*>(state.vm(), state.thisValue());
2553}
2554
2555static inline JSValue jsInternalsAnimationsIntervalGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2556{
2557 UNUSED_PARAM(throwScope);
2558 UNUSED_PARAM(state);
2559 auto& impl = thisObject.wrapped();
2560 JSValue result = toJS<IDLDouble>(state, throwScope, impl.animationsInterval());
2561 return result;
2562}
2563
2564EncodedJSValue jsInternalsAnimationsInterval(ExecState* state, EncodedJSValue thisValue, PropertyName)
2565{
2566 return IDLAttribute<JSInternals>::get<jsInternalsAnimationsIntervalGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "animationsInterval");
2567}
2568
2569static inline JSValue jsInternalsSentenceRetroCorrectionEnabledGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2570{
2571 UNUSED_PARAM(throwScope);
2572 UNUSED_PARAM(state);
2573 auto& impl = thisObject.wrapped();
2574 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.sentenceRetroCorrectionEnabled());
2575 return result;
2576}
2577
2578EncodedJSValue jsInternalsSentenceRetroCorrectionEnabled(ExecState* state, EncodedJSValue thisValue, PropertyName)
2579{
2580 return IDLAttribute<JSInternals>::get<jsInternalsSentenceRetroCorrectionEnabledGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "sentenceRetroCorrectionEnabled");
2581}
2582
2583static inline JSValue jsInternalsSettingsGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2584{
2585 UNUSED_PARAM(throwScope);
2586 UNUSED_PARAM(state);
2587 auto& impl = thisObject.wrapped();
2588 JSValue result = toJS<IDLInterface<InternalSettings>>(state, *thisObject.globalObject(), throwScope, impl.settings());
2589 return result;
2590}
2591
2592EncodedJSValue jsInternalsSettings(ExecState* state, EncodedJSValue thisValue, PropertyName)
2593{
2594 return IDLAttribute<JSInternals>::get<jsInternalsSettingsGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "settings");
2595}
2596
2597static inline JSValue jsInternalsWorkerThreadCountGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2598{
2599 UNUSED_PARAM(throwScope);
2600 UNUSED_PARAM(state);
2601 auto& impl = thisObject.wrapped();
2602 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.workerThreadCount());
2603 return result;
2604}
2605
2606EncodedJSValue jsInternalsWorkerThreadCount(ExecState* state, EncodedJSValue thisValue, PropertyName)
2607{
2608 return IDLAttribute<JSInternals>::get<jsInternalsWorkerThreadCountGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "workerThreadCount");
2609}
2610
2611static inline JSValue jsInternalsAreSVGAnimationsPausedGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2612{
2613 UNUSED_PARAM(throwScope);
2614 UNUSED_PARAM(state);
2615 auto& impl = thisObject.wrapped();
2616 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.areSVGAnimationsPaused());
2617 return result;
2618}
2619
2620EncodedJSValue jsInternalsAreSVGAnimationsPaused(ExecState* state, EncodedJSValue thisValue, PropertyName)
2621{
2622 return IDLAttribute<JSInternals>::get<jsInternalsAreSVGAnimationsPausedGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "areSVGAnimationsPaused");
2623}
2624
2625static inline JSValue jsInternalsIsUnderMemoryPressureGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2626{
2627 UNUSED_PARAM(throwScope);
2628 UNUSED_PARAM(state);
2629 auto& impl = thisObject.wrapped();
2630 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.isUnderMemoryPressure());
2631 return result;
2632}
2633
2634EncodedJSValue jsInternalsIsUnderMemoryPressure(ExecState* state, EncodedJSValue thisValue, PropertyName)
2635{
2636 return IDLAttribute<JSInternals>::get<jsInternalsIsUnderMemoryPressureGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "isUnderMemoryPressure");
2637}
2638
2639#if ENABLE(FULLSCREEN_API)
2640static inline JSValue jsInternalsIsAnimatingFullScreenGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2641{
2642 UNUSED_PARAM(throwScope);
2643 UNUSED_PARAM(state);
2644 auto& impl = thisObject.wrapped();
2645 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.isAnimatingFullScreen());
2646 return result;
2647}
2648
2649EncodedJSValue jsInternalsIsAnimatingFullScreen(ExecState* state, EncodedJSValue thisValue, PropertyName)
2650{
2651 return IDLAttribute<JSInternals>::get<jsInternalsIsAnimatingFullScreenGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "isAnimatingFullScreen");
2652}
2653
2654#endif
2655
2656static inline JSValue jsInternalsRequestAnimationFrameIntervalGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2657{
2658 UNUSED_PARAM(throwScope);
2659 UNUSED_PARAM(state);
2660 auto& impl = thisObject.wrapped();
2661 JSValue result = toJS<IDLDouble>(state, throwScope, impl.requestAnimationFrameInterval());
2662 return result;
2663}
2664
2665EncodedJSValue jsInternalsRequestAnimationFrameInterval(ExecState* state, EncodedJSValue thisValue, PropertyName)
2666{
2667 return IDLAttribute<JSInternals>::get<jsInternalsRequestAnimationFrameIntervalGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "requestAnimationFrameInterval");
2668}
2669
2670static inline JSValue jsInternalsScriptedAnimationsAreSuspendedGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2671{
2672 UNUSED_PARAM(throwScope);
2673 UNUSED_PARAM(state);
2674 auto& impl = thisObject.wrapped();
2675 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.scriptedAnimationsAreSuspended());
2676 return result;
2677}
2678
2679EncodedJSValue jsInternalsScriptedAnimationsAreSuspended(ExecState* state, EncodedJSValue thisValue, PropertyName)
2680{
2681 return IDLAttribute<JSInternals>::get<jsInternalsScriptedAnimationsAreSuspendedGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "scriptedAnimationsAreSuspended");
2682}
2683
2684static inline JSValue jsInternalsEventThrottlingBehaviorOverrideGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2685{
2686 UNUSED_PARAM(throwScope);
2687 UNUSED_PARAM(state);
2688 auto& impl = thisObject.wrapped();
2689 JSValue result = toJS<IDLNullable<IDLEnumeration<Internals::EventThrottlingBehavior>>>(state, throwScope, impl.eventThrottlingBehaviorOverride());
2690 return result;
2691}
2692
2693EncodedJSValue jsInternalsEventThrottlingBehaviorOverride(ExecState* state, EncodedJSValue thisValue, PropertyName)
2694{
2695 return IDLAttribute<JSInternals>::get<jsInternalsEventThrottlingBehaviorOverrideGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "eventThrottlingBehaviorOverride");
2696}
2697
2698static inline bool setJSInternalsEventThrottlingBehaviorOverrideSetter(ExecState& state, JSInternals& thisObject, JSValue value, ThrowScope& throwScope)
2699{
2700 UNUSED_PARAM(throwScope);
2701 auto& impl = thisObject.wrapped();
2702 auto optionalNativeValue = parseEnumeration<Internals::EventThrottlingBehavior>(state, value);
2703 RETURN_IF_EXCEPTION(throwScope, false);
2704 if (UNLIKELY(!optionalNativeValue))
2705 return false;
2706 auto nativeValue = optionalNativeValue.value();
2707 AttributeSetter::call(state, throwScope, [&] {
2708 return impl.setEventThrottlingBehaviorOverride(WTFMove(nativeValue));
2709 });
2710 return true;
2711}
2712
2713bool setJSInternalsEventThrottlingBehaviorOverride(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2714{
2715 return IDLAttribute<JSInternals>::set<setJSInternalsEventThrottlingBehaviorOverrideSetter>(*state, thisValue, encodedValue, "eventThrottlingBehaviorOverride");
2716}
2717
2718static inline JSValue jsInternalsLastStyleUpdateSizeGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2719{
2720 UNUSED_PARAM(throwScope);
2721 UNUSED_PARAM(state);
2722 auto& impl = thisObject.wrapped();
2723 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.lastStyleUpdateSize());
2724 return result;
2725}
2726
2727EncodedJSValue jsInternalsLastStyleUpdateSize(ExecState* state, EncodedJSValue thisValue, PropertyName)
2728{
2729 return IDLAttribute<JSInternals>::get<jsInternalsLastStyleUpdateSizeGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "lastStyleUpdateSize");
2730}
2731
2732static inline JSValue jsInternalsCompositingPolicyOverrideGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2733{
2734 UNUSED_PARAM(throwScope);
2735 UNUSED_PARAM(state);
2736 auto& impl = thisObject.wrapped();
2737 JSValue result = toJS<IDLNullable<IDLEnumeration<Internals::CompositingPolicy>>>(state, throwScope, impl.compositingPolicyOverride());
2738 return result;
2739}
2740
2741EncodedJSValue jsInternalsCompositingPolicyOverride(ExecState* state, EncodedJSValue thisValue, PropertyName)
2742{
2743 return IDLAttribute<JSInternals>::get<jsInternalsCompositingPolicyOverrideGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "compositingPolicyOverride");
2744}
2745
2746static inline bool setJSInternalsCompositingPolicyOverrideSetter(ExecState& state, JSInternals& thisObject, JSValue value, ThrowScope& throwScope)
2747{
2748 UNUSED_PARAM(throwScope);
2749 auto& impl = thisObject.wrapped();
2750 auto optionalNativeValue = parseEnumeration<Internals::CompositingPolicy>(state, value);
2751 RETURN_IF_EXCEPTION(throwScope, false);
2752 if (UNLIKELY(!optionalNativeValue))
2753 return false;
2754 auto nativeValue = optionalNativeValue.value();
2755 AttributeSetter::call(state, throwScope, [&] {
2756 return impl.setCompositingPolicyOverride(WTFMove(nativeValue));
2757 });
2758 return true;
2759}
2760
2761bool setJSInternalsCompositingPolicyOverride(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2762{
2763 return IDLAttribute<JSInternals>::set<setJSInternalsCompositingPolicyOverrideSetter>(*state, thisValue, encodedValue, "compositingPolicyOverride");
2764}
2765
2766static inline JSValue jsInternalsLayoutCountGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2767{
2768 UNUSED_PARAM(throwScope);
2769 UNUSED_PARAM(state);
2770 auto& impl = thisObject.wrapped();
2771 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.layoutCount());
2772 return result;
2773}
2774
2775EncodedJSValue jsInternalsLayoutCount(ExecState* state, EncodedJSValue thisValue, PropertyName)
2776{
2777 return IDLAttribute<JSInternals>::get<jsInternalsLayoutCountGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "layoutCount");
2778}
2779
2780#if ENABLE(CONTENT_FILTERING)
2781static inline JSValue jsInternalsMockContentFilterSettingsGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2782{
2783 UNUSED_PARAM(throwScope);
2784 UNUSED_PARAM(state);
2785 auto& impl = thisObject.wrapped();
2786 JSValue result = toJS<IDLInterface<MockContentFilterSettings>>(state, *thisObject.globalObject(), throwScope, impl.mockContentFilterSettings());
2787 return result;
2788}
2789
2790EncodedJSValue jsInternalsMockContentFilterSettings(ExecState* state, EncodedJSValue thisValue, PropertyName)
2791{
2792 return IDLAttribute<JSInternals>::get<jsInternalsMockContentFilterSettingsGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "mockContentFilterSettings");
2793}
2794
2795#endif
2796
2797#if ENABLE(MEDIA_STREAM)
2798static inline JSValue jsInternalsTrackAudioSampleCountGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2799{
2800 UNUSED_PARAM(throwScope);
2801 UNUSED_PARAM(state);
2802 auto& impl = thisObject.wrapped();
2803 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.trackAudioSampleCount());
2804 return result;
2805}
2806
2807EncodedJSValue jsInternalsTrackAudioSampleCount(ExecState* state, EncodedJSValue thisValue, PropertyName)
2808{
2809 return IDLAttribute<JSInternals>::get<jsInternalsTrackAudioSampleCountGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "trackAudioSampleCount");
2810}
2811
2812#endif
2813
2814#if ENABLE(MEDIA_STREAM)
2815static inline JSValue jsInternalsTrackVideoSampleCountGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2816{
2817 UNUSED_PARAM(throwScope);
2818 UNUSED_PARAM(state);
2819 auto& impl = thisObject.wrapped();
2820 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.trackVideoSampleCount());
2821 return result;
2822}
2823
2824EncodedJSValue jsInternalsTrackVideoSampleCount(ExecState* state, EncodedJSValue thisValue, PropertyName)
2825{
2826 return IDLAttribute<JSInternals>::get<jsInternalsTrackVideoSampleCountGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "trackVideoSampleCount");
2827}
2828
2829#endif
2830
2831#if ENABLE(APPLE_PAY)
2832static inline JSValue jsInternalsMockPaymentCoordinatorGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2833{
2834 UNUSED_PARAM(throwScope);
2835 UNUSED_PARAM(state);
2836 auto* context = jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject())->scriptExecutionContext();
2837 if (UNLIKELY(!context))
2838 return jsUndefined();
2839 ASSERT(context->isDocument());
2840 auto& document = downcast<Document>(*context);
2841 auto& impl = thisObject.wrapped();
2842 JSValue result = toJS<IDLInterface<MockPaymentCoordinator>>(state, *thisObject.globalObject(), throwScope, impl.mockPaymentCoordinator(document));
2843 return result;
2844}
2845
2846EncodedJSValue jsInternalsMockPaymentCoordinator(ExecState* state, EncodedJSValue thisValue, PropertyName)
2847{
2848 return IDLAttribute<JSInternals>::get<jsInternalsMockPaymentCoordinatorGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "mockPaymentCoordinator");
2849}
2850
2851#endif
2852
2853#if ENABLE(VIDEO)
2854static inline JSValue jsInternalsNowPlayingStateGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2855{
2856 UNUSED_PARAM(throwScope);
2857 UNUSED_PARAM(state);
2858 auto& impl = thisObject.wrapped();
2859 JSValue result = toJS<IDLDictionary<Internals::NowPlayingState>>(state, *thisObject.globalObject(), throwScope, impl.nowPlayingState());
2860 return result;
2861}
2862
2863EncodedJSValue jsInternalsNowPlayingState(ExecState* state, EncodedJSValue thisValue, PropertyName)
2864{
2865 return IDLAttribute<JSInternals>::get<jsInternalsNowPlayingStateGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "nowPlayingState");
2866}
2867
2868#endif
2869
2870static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAddressBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2871{
2872 UNUSED_PARAM(state);
2873 UNUSED_PARAM(throwScope);
2874 auto& impl = castedThis->wrapped();
2875 if (UNLIKELY(state->argumentCount() < 1))
2876 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2877 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "address", "Node"); });
2878 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2879 return JSValue::encode(toJS<IDLDOMString>(*state, impl.address(*node)));
2880}
2881
2882EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAddress(ExecState* state)
2883{
2884 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAddressBody>(*state, "address");
2885}
2886
2887static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNodeNeedsStyleRecalcBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2888{
2889 UNUSED_PARAM(state);
2890 UNUSED_PARAM(throwScope);
2891 auto& impl = castedThis->wrapped();
2892 if (UNLIKELY(state->argumentCount() < 1))
2893 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2894 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "nodeNeedsStyleRecalc", "Node"); });
2895 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2896 return JSValue::encode(toJS<IDLBoolean>(impl.nodeNeedsStyleRecalc(*node)));
2897}
2898
2899EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNodeNeedsStyleRecalc(ExecState* state)
2900{
2901 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNodeNeedsStyleRecalcBody>(*state, "nodeNeedsStyleRecalc");
2902}
2903
2904static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStyleChangeTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2905{
2906 UNUSED_PARAM(state);
2907 UNUSED_PARAM(throwScope);
2908 auto& impl = castedThis->wrapped();
2909 if (UNLIKELY(state->argumentCount() < 1))
2910 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2911 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "styleChangeType", "Node"); });
2912 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2913 return JSValue::encode(toJS<IDLDOMString>(*state, impl.styleChangeType(*node)));
2914}
2915
2916EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStyleChangeType(ExecState* state)
2917{
2918 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStyleChangeTypeBody>(*state, "styleChangeType");
2919}
2920
2921static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDescriptionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2922{
2923 UNUSED_PARAM(state);
2924 UNUSED_PARAM(throwScope);
2925 auto& impl = castedThis->wrapped();
2926 if (UNLIKELY(state->argumentCount() < 1))
2927 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2928 auto value = convert<IDLAny>(*state, state->uncheckedArgument(0));
2929 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2930 return JSValue::encode(toJS<IDLDOMString>(*state, impl.description(WTFMove(value))));
2931}
2932
2933EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDescription(ExecState* state)
2934{
2935 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDescriptionBody>(*state, "description");
2936}
2937
2938static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasPausedImageAnimationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2939{
2940 UNUSED_PARAM(state);
2941 UNUSED_PARAM(throwScope);
2942 auto& impl = castedThis->wrapped();
2943 if (UNLIKELY(state->argumentCount() < 1))
2944 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2945 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "hasPausedImageAnimations", "Element"); });
2946 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2947 return JSValue::encode(toJS<IDLBoolean>(impl.hasPausedImageAnimations(*element)));
2948}
2949
2950EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasPausedImageAnimations(ExecState* state)
2951{
2952 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasPausedImageAnimationsBody>(*state, "hasPausedImageAnimations");
2953}
2954
2955static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPaintingFrequentlyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2956{
2957 UNUSED_PARAM(state);
2958 UNUSED_PARAM(throwScope);
2959 auto& impl = castedThis->wrapped();
2960 if (UNLIKELY(state->argumentCount() < 1))
2961 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2962 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isPaintingFrequently", "Element"); });
2963 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2964 return JSValue::encode(toJS<IDLBoolean>(impl.isPaintingFrequently(*element)));
2965}
2966
2967EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPaintingFrequently(ExecState* state)
2968{
2969 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPaintingFrequentlyBody>(*state, "isPaintingFrequently");
2970}
2971
2972static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIncrementFrequentPaintCounterBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2973{
2974 UNUSED_PARAM(state);
2975 UNUSED_PARAM(throwScope);
2976 auto& impl = castedThis->wrapped();
2977 if (UNLIKELY(state->argumentCount() < 1))
2978 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2979 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "incrementFrequentPaintCounter", "Element"); });
2980 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2981 impl.incrementFrequentPaintCounter(*element);
2982 return JSValue::encode(jsUndefined());
2983}
2984
2985EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIncrementFrequentPaintCounter(ExecState* state)
2986{
2987 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIncrementFrequentPaintCounterBody>(*state, "incrementFrequentPaintCounter");
2988}
2989
2990static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementRenderTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2991{
2992 UNUSED_PARAM(state);
2993 UNUSED_PARAM(throwScope);
2994 auto& impl = castedThis->wrapped();
2995 if (UNLIKELY(state->argumentCount() < 1))
2996 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2997 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "elementRenderTreeAsText", "Element"); });
2998 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2999 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.elementRenderTreeAsText(*element)));
3000}
3001
3002EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementRenderTreeAsText(ExecState* state)
3003{
3004 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementRenderTreeAsTextBody>(*state, "elementRenderTreeAsText");
3005}
3006
3007static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPreloadedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3008{
3009 UNUSED_PARAM(state);
3010 UNUSED_PARAM(throwScope);
3011 auto& impl = castedThis->wrapped();
3012 if (UNLIKELY(state->argumentCount() < 1))
3013 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3014 auto url = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3015 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3016 return JSValue::encode(toJS<IDLBoolean>(impl.isPreloaded(WTFMove(url))));
3017}
3018
3019EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPreloaded(ExecState* state)
3020{
3021 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPreloadedBody>(*state, "isPreloaded");
3022}
3023
3024static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsLoadingFromMemoryCacheBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3025{
3026 UNUSED_PARAM(state);
3027 UNUSED_PARAM(throwScope);
3028 auto& impl = castedThis->wrapped();
3029 if (UNLIKELY(state->argumentCount() < 1))
3030 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3031 auto url = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3032 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3033 return JSValue::encode(toJS<IDLBoolean>(impl.isLoadingFromMemoryCache(WTFMove(url))));
3034}
3035
3036EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsLoadingFromMemoryCache(ExecState* state)
3037{
3038 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsLoadingFromMemoryCacheBody>(*state, "isLoadingFromMemoryCache");
3039}
3040
3041static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionFetchResponseSourceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3042{
3043 UNUSED_PARAM(state);
3044 UNUSED_PARAM(throwScope);
3045 auto& impl = castedThis->wrapped();
3046 if (UNLIKELY(state->argumentCount() < 1))
3047 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3048 auto response = convert<IDLInterface<FetchResponse>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "response", "Internals", "fetchResponseSource", "FetchResponse"); });
3049 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3050 return JSValue::encode(toJS<IDLDOMString>(*state, impl.fetchResponseSource(*response)));
3051}
3052
3053EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFetchResponseSource(ExecState* state)
3054{
3055 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionFetchResponseSourceBody>(*state, "fetchResponseSource");
3056}
3057
3058static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionXhrResponseSourceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3059{
3060 UNUSED_PARAM(state);
3061 UNUSED_PARAM(throwScope);
3062 auto& impl = castedThis->wrapped();
3063 if (UNLIKELY(state->argumentCount() < 1))
3064 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3065 auto xhr = convert<IDLInterface<XMLHttpRequest>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "xhr", "Internals", "xhrResponseSource", "XMLHttpRequest"); });
3066 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3067 return JSValue::encode(toJS<IDLDOMString>(*state, impl.xhrResponseSource(*xhr)));
3068}
3069
3070EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionXhrResponseSource(ExecState* state)
3071{
3072 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionXhrResponseSourceBody>(*state, "xhrResponseSource");
3073}
3074
3075static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsSharingStyleSheetContentsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3076{
3077 UNUSED_PARAM(state);
3078 UNUSED_PARAM(throwScope);
3079 auto& impl = castedThis->wrapped();
3080 if (UNLIKELY(state->argumentCount() < 2))
3081 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3082 auto a = convert<IDLInterface<HTMLLinkElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "a", "Internals", "isSharingStyleSheetContents", "HTMLLinkElement"); });
3083 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3084 auto b = convert<IDLInterface<HTMLLinkElement>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "b", "Internals", "isSharingStyleSheetContents", "HTMLLinkElement"); });
3085 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3086 return JSValue::encode(toJS<IDLBoolean>(impl.isSharingStyleSheetContents(*a, *b)));
3087}
3088
3089EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSharingStyleSheetContents(ExecState* state)
3090{
3091 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsSharingStyleSheetContentsBody>(*state, "isSharingStyleSheetContents");
3092}
3093
3094static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresourcesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3095{
3096 UNUSED_PARAM(state);
3097 UNUSED_PARAM(throwScope);
3098 auto& impl = castedThis->wrapped();
3099 if (UNLIKELY(state->argumentCount() < 1))
3100 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3101 auto link = convert<IDLInterface<HTMLLinkElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "link", "Internals", "isStyleSheetLoadingSubresources", "HTMLLinkElement"); });
3102 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3103 return JSValue::encode(toJS<IDLBoolean>(impl.isStyleSheetLoadingSubresources(*link)));
3104}
3105
3106EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresources(ExecState* state)
3107{
3108 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresourcesBody>(*state, "isStyleSheetLoadingSubresources");
3109}
3110
3111static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClearMemoryCacheBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3112{
3113 UNUSED_PARAM(state);
3114 UNUSED_PARAM(throwScope);
3115 auto& impl = castedThis->wrapped();
3116 impl.clearMemoryCache();
3117 return JSValue::encode(jsUndefined());
3118}
3119
3120EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearMemoryCache(ExecState* state)
3121{
3122 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionClearMemoryCacheBody>(*state, "clearMemoryCache");
3123}
3124
3125static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPruneMemoryCacheToSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3126{
3127 UNUSED_PARAM(state);
3128 UNUSED_PARAM(throwScope);
3129 auto& impl = castedThis->wrapped();
3130 if (UNLIKELY(state->argumentCount() < 1))
3131 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3132 auto size = convert<IDLLong>(*state, state->uncheckedArgument(0));
3133 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3134 impl.pruneMemoryCacheToSize(WTFMove(size));
3135 return JSValue::encode(jsUndefined());
3136}
3137
3138EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPruneMemoryCacheToSize(ExecState* state)
3139{
3140 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPruneMemoryCacheToSizeBody>(*state, "pruneMemoryCacheToSize");
3141}
3142
3143static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDestroyDecodedDataForAllImagesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3144{
3145 UNUSED_PARAM(state);
3146 UNUSED_PARAM(throwScope);
3147 auto& impl = castedThis->wrapped();
3148 impl.destroyDecodedDataForAllImages();
3149 return JSValue::encode(jsUndefined());
3150}
3151
3152EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDestroyDecodedDataForAllImages(ExecState* state)
3153{
3154 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDestroyDecodedDataForAllImagesBody>(*state, "destroyDecodedDataForAllImages");
3155}
3156
3157static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMemoryCacheSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3158{
3159 UNUSED_PARAM(state);
3160 UNUSED_PARAM(throwScope);
3161 auto& impl = castedThis->wrapped();
3162 return JSValue::encode(toJS<IDLLong>(impl.memoryCacheSize()));
3163}
3164
3165EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMemoryCacheSize(ExecState* state)
3166{
3167 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMemoryCacheSizeBody>(*state, "memoryCacheSize");
3168}
3169
3170static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetOverrideCachePolicyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3171{
3172 UNUSED_PARAM(state);
3173 UNUSED_PARAM(throwScope);
3174 auto& impl = castedThis->wrapped();
3175 if (UNLIKELY(state->argumentCount() < 1))
3176 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3177 auto policy = convert<IDLEnumeration<Internals::CachePolicy>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "policy", "Internals", "setOverrideCachePolicy", expectedEnumerationValues<Internals::CachePolicy>()); });
3178 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3179 impl.setOverrideCachePolicy(WTFMove(policy));
3180 return JSValue::encode(jsUndefined());
3181}
3182
3183EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetOverrideCachePolicy(ExecState* state)
3184{
3185 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetOverrideCachePolicyBody>(*state, "setOverrideCachePolicy");
3186}
3187
3188static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetOverrideResourceLoadPriorityBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3189{
3190 UNUSED_PARAM(state);
3191 UNUSED_PARAM(throwScope);
3192 auto& impl = castedThis->wrapped();
3193 if (UNLIKELY(state->argumentCount() < 1))
3194 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3195 auto priority = convert<IDLEnumeration<Internals::ResourceLoadPriority>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "priority", "Internals", "setOverrideResourceLoadPriority", expectedEnumerationValues<Internals::ResourceLoadPriority>()); });
3196 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3197 impl.setOverrideResourceLoadPriority(WTFMove(priority));
3198 return JSValue::encode(jsUndefined());
3199}
3200
3201EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetOverrideResourceLoadPriority(ExecState* state)
3202{
3203 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetOverrideResourceLoadPriorityBody>(*state, "setOverrideResourceLoadPriority");
3204}
3205
3206static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3207{
3208 UNUSED_PARAM(state);
3209 UNUSED_PARAM(throwScope);
3210 auto& impl = castedThis->wrapped();
3211 if (UNLIKELY(state->argumentCount() < 1))
3212 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3213 auto disabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
3214 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3215 impl.setStrictRawResourceValidationPolicyDisabled(WTFMove(disabled));
3216 return JSValue::encode(jsUndefined());
3217}
3218
3219EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabled(ExecState* state)
3220{
3221 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabledBody>(*state, "setStrictRawResourceValidationPolicyDisabled");
3222}
3223
3224static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClearPageCacheBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3225{
3226 UNUSED_PARAM(state);
3227 UNUSED_PARAM(throwScope);
3228 auto& impl = castedThis->wrapped();
3229 impl.clearPageCache();
3230 return JSValue::encode(jsUndefined());
3231}
3232
3233EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearPageCache(ExecState* state)
3234{
3235 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionClearPageCacheBody>(*state, "clearPageCache");
3236}
3237
3238static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageCacheSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3239{
3240 UNUSED_PARAM(state);
3241 UNUSED_PARAM(throwScope);
3242 auto& impl = castedThis->wrapped();
3243 return JSValue::encode(toJS<IDLUnsignedLong>(impl.pageCacheSize()));
3244}
3245
3246EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageCacheSize(ExecState* state)
3247{
3248 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageCacheSizeBody>(*state, "pageCacheSize");
3249}
3250
3251static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfoBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3252{
3253 UNUSED_PARAM(state);
3254 UNUSED_PARAM(throwScope);
3255 auto& impl = castedThis->wrapped();
3256 if (UNLIKELY(state->argumentCount() < 1))
3257 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3258 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "computedStyleIncludingVisitedInfo", "Element"); });
3259 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3260 return JSValue::encode(toJS<IDLInterface<CSSStyleDeclaration>>(*state, *castedThis->globalObject(), impl.computedStyleIncludingVisitedInfo(*element)));
3261}
3262
3263EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfo(ExecState* state)
3264{
3265 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfoBody>(*state, "computedStyleIncludingVisitedInfo");
3266}
3267
3268static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnsureUserAgentShadowRootBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3269{
3270 UNUSED_PARAM(state);
3271 UNUSED_PARAM(throwScope);
3272 auto& impl = castedThis->wrapped();
3273 if (UNLIKELY(state->argumentCount() < 1))
3274 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3275 auto host = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "host", "Internals", "ensureUserAgentShadowRoot", "Element"); });
3276 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3277 return JSValue::encode(toJS<IDLInterface<Node>>(*state, *castedThis->globalObject(), impl.ensureUserAgentShadowRoot(*host)));
3278}
3279
3280EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnsureUserAgentShadowRoot(ExecState* state)
3281{
3282 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnsureUserAgentShadowRootBody>(*state, "ensureUserAgentShadowRoot");
3283}
3284
3285static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionShadowRootBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3286{
3287 UNUSED_PARAM(state);
3288 UNUSED_PARAM(throwScope);
3289 auto& impl = castedThis->wrapped();
3290 if (UNLIKELY(state->argumentCount() < 1))
3291 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3292 auto host = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "host", "Internals", "shadowRoot", "Element"); });
3293 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3294 return JSValue::encode(toJS<IDLInterface<Node>>(*state, *castedThis->globalObject(), impl.shadowRoot(*host)));
3295}
3296
3297EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowRoot(ExecState* state)
3298{
3299 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionShadowRootBody>(*state, "shadowRoot");
3300}
3301
3302static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDeferredStyleRulesCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3303{
3304 UNUSED_PARAM(state);
3305 UNUSED_PARAM(throwScope);
3306 auto& impl = castedThis->wrapped();
3307 if (UNLIKELY(state->argumentCount() < 1))
3308 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3309 auto sheet = convert<IDLInterface<StyleSheet>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "sheet", "Internals", "deferredStyleRulesCount", "StyleSheet"); });
3310 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3311 return JSValue::encode(toJS<IDLLong>(impl.deferredStyleRulesCount(*sheet)));
3312}
3313
3314EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredStyleRulesCount(ExecState* state)
3315{
3316 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDeferredStyleRulesCountBody>(*state, "deferredStyleRulesCount");
3317}
3318
3319static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDeferredGroupRulesCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3320{
3321 UNUSED_PARAM(state);
3322 UNUSED_PARAM(throwScope);
3323 auto& impl = castedThis->wrapped();
3324 if (UNLIKELY(state->argumentCount() < 1))
3325 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3326 auto sheet = convert<IDLInterface<StyleSheet>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "sheet", "Internals", "deferredGroupRulesCount", "StyleSheet"); });
3327 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3328 return JSValue::encode(toJS<IDLLong>(impl.deferredGroupRulesCount(*sheet)));
3329}
3330
3331EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredGroupRulesCount(ExecState* state)
3332{
3333 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDeferredGroupRulesCountBody>(*state, "deferredGroupRulesCount");
3334}
3335
3336static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDeferredKeyframesRulesCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3337{
3338 UNUSED_PARAM(state);
3339 UNUSED_PARAM(throwScope);
3340 auto& impl = castedThis->wrapped();
3341 if (UNLIKELY(state->argumentCount() < 1))
3342 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3343 auto sheet = convert<IDLInterface<StyleSheet>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "sheet", "Internals", "deferredKeyframesRulesCount", "StyleSheet"); });
3344 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3345 return JSValue::encode(toJS<IDLLong>(impl.deferredKeyframesRulesCount(*sheet)));
3346}
3347
3348EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredKeyframesRulesCount(ExecState* state)
3349{
3350 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDeferredKeyframesRulesCountBody>(*state, "deferredKeyframesRulesCount");
3351}
3352
3353static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionShadowRootTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3354{
3355 UNUSED_PARAM(state);
3356 UNUSED_PARAM(throwScope);
3357 auto& impl = castedThis->wrapped();
3358 if (UNLIKELY(state->argumentCount() < 1))
3359 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3360 auto root = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "root", "Internals", "shadowRootType", "Node"); });
3361 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3362 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.shadowRootType(*root)));
3363}
3364
3365EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowRootType(ExecState* state)
3366{
3367 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionShadowRootTypeBody>(*state, "shadowRootType");
3368}
3369
3370static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionShadowPseudoIdBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3371{
3372 UNUSED_PARAM(state);
3373 UNUSED_PARAM(throwScope);
3374 auto& impl = castedThis->wrapped();
3375 if (UNLIKELY(state->argumentCount() < 1))
3376 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3377 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "shadowPseudoId", "Element"); });
3378 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3379 return JSValue::encode(toJS<IDLDOMString>(*state, impl.shadowPseudoId(*element)));
3380}
3381
3382EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowPseudoId(ExecState* state)
3383{
3384 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionShadowPseudoIdBody>(*state, "shadowPseudoId");
3385}
3386
3387static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShadowPseudoIdBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3388{
3389 UNUSED_PARAM(state);
3390 UNUSED_PARAM(throwScope);
3391 auto& impl = castedThis->wrapped();
3392 if (UNLIKELY(state->argumentCount() < 2))
3393 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3394 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setShadowPseudoId", "Element"); });
3395 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3396 auto id = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3397 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3398 impl.setShadowPseudoId(*element, WTFMove(id));
3399 return JSValue::encode(jsUndefined());
3400}
3401
3402EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShadowPseudoId(ExecState* state)
3403{
3404 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShadowPseudoIdBody>(*state, "setShadowPseudoId");
3405}
3406
3407static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTreeScopeRootNodeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3408{
3409 UNUSED_PARAM(state);
3410 UNUSED_PARAM(throwScope);
3411 auto& impl = castedThis->wrapped();
3412 if (UNLIKELY(state->argumentCount() < 1))
3413 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3414 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "treeScopeRootNode", "Node"); });
3415 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3416 return JSValue::encode(toJS<IDLInterface<Node>>(*state, *castedThis->globalObject(), impl.treeScopeRootNode(*node)));
3417}
3418
3419EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTreeScopeRootNode(ExecState* state)
3420{
3421 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTreeScopeRootNodeBody>(*state, "treeScopeRootNode");
3422}
3423
3424static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionParentTreeScopeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3425{
3426 UNUSED_PARAM(state);
3427 UNUSED_PARAM(throwScope);
3428 auto& impl = castedThis->wrapped();
3429 if (UNLIKELY(state->argumentCount() < 1))
3430 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3431 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "parentTreeScope", "Node"); });
3432 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3433 return JSValue::encode(toJS<IDLInterface<Node>>(*state, *castedThis->globalObject(), impl.parentTreeScope(*node)));
3434}
3435
3436EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParentTreeScope(ExecState* state)
3437{
3438 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionParentTreeScopeBody>(*state, "parentTreeScope");
3439}
3440
3441static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3442{
3443 UNUSED_PARAM(state);
3444 UNUSED_PARAM(throwScope);
3445 auto& impl = castedThis->wrapped();
3446 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.lastSpatialNavigationCandidateCount()));
3447}
3448
3449EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCount(ExecState* state)
3450{
3451 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCountBody>(*state, "lastSpatialNavigationCandidateCount");
3452}
3453
3454static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfActiveAnimationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3455{
3456 UNUSED_PARAM(state);
3457 UNUSED_PARAM(throwScope);
3458 auto& impl = castedThis->wrapped();
3459 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfActiveAnimations()));
3460}
3461
3462EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfActiveAnimations(ExecState* state)
3463{
3464 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfActiveAnimationsBody>(*state, "numberOfActiveAnimations");
3465}
3466
3467static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSuspendAnimationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3468{
3469 UNUSED_PARAM(state);
3470 UNUSED_PARAM(throwScope);
3471 auto& impl = castedThis->wrapped();
3472 propagateException(*state, throwScope, impl.suspendAnimations());
3473 return JSValue::encode(jsUndefined());
3474}
3475
3476EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSuspendAnimations(ExecState* state)
3477{
3478 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSuspendAnimationsBody>(*state, "suspendAnimations");
3479}
3480
3481static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionResumeAnimationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3482{
3483 UNUSED_PARAM(state);
3484 UNUSED_PARAM(throwScope);
3485 auto& impl = castedThis->wrapped();
3486 propagateException(*state, throwScope, impl.resumeAnimations());
3487 return JSValue::encode(jsUndefined());
3488}
3489
3490EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResumeAnimations(ExecState* state)
3491{
3492 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionResumeAnimationsBody>(*state, "resumeAnimations");
3493}
3494
3495static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAnimationsAreSuspendedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3496{
3497 UNUSED_PARAM(state);
3498 UNUSED_PARAM(throwScope);
3499 auto& impl = castedThis->wrapped();
3500 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.animationsAreSuspended()));
3501}
3502
3503EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAnimationsAreSuspended(ExecState* state)
3504{
3505 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAnimationsAreSuspendedBody>(*state, "animationsAreSuspended");
3506}
3507
3508static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3509{
3510 UNUSED_PARAM(state);
3511 UNUSED_PARAM(throwScope);
3512 auto& impl = castedThis->wrapped();
3513 if (UNLIKELY(state->argumentCount() < 3))
3514 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3515 auto animationName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3516 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3517 auto pauseTime = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3518 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3519 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "element", "Internals", "pauseAnimationAtTimeOnElement", "Element"); });
3520 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3521 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pauseAnimationAtTimeOnElement(WTFMove(animationName), WTFMove(pauseTime), *element)));
3522}
3523
3524EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElement(ExecState* state)
3525{
3526 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElementBody>(*state, "pauseAnimationAtTimeOnElement");
3527}
3528
3529static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3530{
3531 UNUSED_PARAM(state);
3532 UNUSED_PARAM(throwScope);
3533 auto& impl = castedThis->wrapped();
3534 if (UNLIKELY(state->argumentCount() < 4))
3535 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3536 auto animationName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3537 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3538 auto pauseTime = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3539 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3540 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "element", "Internals", "pauseAnimationAtTimeOnPseudoElement", "Element"); });
3541 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3542 auto pseudoId = convert<IDLDOMString>(*state, state->uncheckedArgument(3));
3543 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3544 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pauseAnimationAtTimeOnPseudoElement(WTFMove(animationName), WTFMove(pauseTime), *element, WTFMove(pseudoId))));
3545}
3546
3547EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElement(ExecState* state)
3548{
3549 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElementBody>(*state, "pauseAnimationAtTimeOnPseudoElement");
3550}
3551
3552static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3553{
3554 UNUSED_PARAM(state);
3555 UNUSED_PARAM(throwScope);
3556 auto& impl = castedThis->wrapped();
3557 if (UNLIKELY(state->argumentCount() < 3))
3558 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3559 auto propertyName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3560 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3561 auto pauseTime = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3562 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3563 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "element", "Internals", "pauseTransitionAtTimeOnElement", "Element"); });
3564 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3565 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pauseTransitionAtTimeOnElement(WTFMove(propertyName), WTFMove(pauseTime), *element)));
3566}
3567
3568EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElement(ExecState* state)
3569{
3570 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElementBody>(*state, "pauseTransitionAtTimeOnElement");
3571}
3572
3573static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3574{
3575 UNUSED_PARAM(state);
3576 UNUSED_PARAM(throwScope);
3577 auto& impl = castedThis->wrapped();
3578 if (UNLIKELY(state->argumentCount() < 4))
3579 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3580 auto property = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3581 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3582 auto pauseTime = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3583 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3584 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "element", "Internals", "pauseTransitionAtTimeOnPseudoElement", "Element"); });
3585 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3586 auto pseudoId = convert<IDLDOMString>(*state, state->uncheckedArgument(3));
3587 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3588 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pauseTransitionAtTimeOnPseudoElement(WTFMove(property), WTFMove(pauseTime), *element, WTFMove(pseudoId))));
3589}
3590
3591EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElement(ExecState* state)
3592{
3593 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElementBody>(*state, "pauseTransitionAtTimeOnPseudoElement");
3594}
3595
3596static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAcceleratedAnimationsForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3597{
3598 UNUSED_PARAM(state);
3599 UNUSED_PARAM(throwScope);
3600 auto& impl = castedThis->wrapped();
3601 if (UNLIKELY(state->argumentCount() < 1))
3602 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3603 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "acceleratedAnimationsForElement", "Element"); });
3604 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3605 return JSValue::encode(toJS<IDLSequence<IDLDictionary<Internals::AcceleratedAnimation>>>(*state, *castedThis->globalObject(), impl.acceleratedAnimationsForElement(*element)));
3606}
3607
3608EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAcceleratedAnimationsForElement(ExecState* state)
3609{
3610 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAcceleratedAnimationsForElementBody>(*state, "acceleratedAnimationsForElement");
3611}
3612
3613static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3614{
3615 UNUSED_PARAM(state);
3616 UNUSED_PARAM(throwScope);
3617 auto& impl = castedThis->wrapped();
3618 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfAnimationTimelineInvalidations()));
3619}
3620
3621EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidations(ExecState* state)
3622{
3623 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidationsBody>(*state, "numberOfAnimationTimelineInvalidations");
3624}
3625
3626static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPseudoElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3627{
3628 UNUSED_PARAM(state);
3629 UNUSED_PARAM(throwScope);
3630 auto& impl = castedThis->wrapped();
3631 if (UNLIKELY(state->argumentCount() < 2))
3632 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3633 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "pseudoElement", "Element"); });
3634 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3635 auto pseudoId = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3636 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3637 return JSValue::encode(toJS<IDLNullable<IDLInterface<Element>>>(*state, *castedThis->globalObject(), throwScope, impl.pseudoElement(*element, WTFMove(pseudoId))));
3638}
3639
3640EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPseudoElement(ExecState* state)
3641{
3642 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPseudoElementBody>(*state, "pseudoElement");
3643}
3644
3645static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionVisiblePlaceholderBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3646{
3647 UNUSED_PARAM(state);
3648 UNUSED_PARAM(throwScope);
3649 auto& impl = castedThis->wrapped();
3650 if (UNLIKELY(state->argumentCount() < 1))
3651 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3652 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "visiblePlaceholder", "Element"); });
3653 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3654 return JSValue::encode(toJS<IDLDOMString>(*state, impl.visiblePlaceholder(*element)));
3655}
3656
3657EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionVisiblePlaceholder(ExecState* state)
3658{
3659 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionVisiblePlaceholderBody>(*state, "visiblePlaceholder");
3660}
3661
3662static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSelectColorInColorChooserBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3663{
3664 UNUSED_PARAM(state);
3665 UNUSED_PARAM(throwScope);
3666 auto& impl = castedThis->wrapped();
3667 if (UNLIKELY(state->argumentCount() < 2))
3668 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3669 auto element = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "selectColorInColorChooser", "HTMLInputElement"); });
3670 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3671 auto colorValue = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3672 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3673 impl.selectColorInColorChooser(*element, WTFMove(colorValue));
3674 return JSValue::encode(jsUndefined());
3675}
3676
3677EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSelectColorInColorChooser(ExecState* state)
3678{
3679 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSelectColorInColorChooserBody>(*state, "selectColorInColorChooser");
3680}
3681
3682static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItemBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3683{
3684 UNUSED_PARAM(state);
3685 UNUSED_PARAM(throwScope);
3686 auto& impl = castedThis->wrapped();
3687 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), throwScope, impl.formControlStateOfPreviousHistoryItem()));
3688}
3689
3690EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItem(ExecState* state)
3691{
3692 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItemBody>(*state, "formControlStateOfPreviousHistoryItem");
3693}
3694
3695static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItemBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3696{
3697 UNUSED_PARAM(state);
3698 UNUSED_PARAM(throwScope);
3699 auto& impl = castedThis->wrapped();
3700 if (UNLIKELY(state->argumentCount() < 1))
3701 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3702 auto values = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(0));
3703 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3704 propagateException(*state, throwScope, impl.setFormControlStateOfPreviousHistoryItem(WTFMove(values)));
3705 return JSValue::encode(jsUndefined());
3706}
3707
3708EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItem(ExecState* state)
3709{
3710 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItemBody>(*state, "setFormControlStateOfPreviousHistoryItem");
3711}
3712
3713static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAbsoluteCaretBoundsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3714{
3715 UNUSED_PARAM(state);
3716 UNUSED_PARAM(throwScope);
3717 auto& impl = castedThis->wrapped();
3718 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), throwScope, impl.absoluteCaretBounds()));
3719}
3720
3721EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAbsoluteCaretBounds(ExecState* state)
3722{
3723 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAbsoluteCaretBoundsBody>(*state, "absoluteCaretBounds");
3724}
3725
3726static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsCaretBlinkingSuspendedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3727{
3728 UNUSED_PARAM(state);
3729 UNUSED_PARAM(throwScope);
3730 auto& impl = castedThis->wrapped();
3731 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.isCaretBlinkingSuspended()));
3732}
3733
3734EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsCaretBlinkingSuspended(ExecState* state)
3735{
3736 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsCaretBlinkingSuspendedBody>(*state, "isCaretBlinkingSuspended");
3737}
3738
3739static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBoundingBoxBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3740{
3741 UNUSED_PARAM(state);
3742 UNUSED_PARAM(throwScope);
3743 auto& impl = castedThis->wrapped();
3744 if (UNLIKELY(state->argumentCount() < 1))
3745 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3746 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "boundingBox", "Element"); });
3747 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3748 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), impl.boundingBox(*element)));
3749}
3750
3751EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBoundingBox(ExecState* state)
3752{
3753 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBoundingBoxBody>(*state, "boundingBox");
3754}
3755
3756static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInspectorHighlightRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3757{
3758 UNUSED_PARAM(state);
3759 UNUSED_PARAM(throwScope);
3760 auto& impl = castedThis->wrapped();
3761 return JSValue::encode(toJS<IDLInterface<DOMRectList>>(*state, *castedThis->globalObject(), throwScope, impl.inspectorHighlightRects()));
3762}
3763
3764EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInspectorHighlightRects(ExecState* state)
3765{
3766 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInspectorHighlightRectsBody>(*state, "inspectorHighlightRects");
3767}
3768
3769static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkerCountForNodeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3770{
3771 UNUSED_PARAM(state);
3772 UNUSED_PARAM(throwScope);
3773 auto& impl = castedThis->wrapped();
3774 if (UNLIKELY(state->argumentCount() < 2))
3775 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3776 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "markerCountForNode", "Node"); });
3777 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3778 auto markerType = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3779 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3780 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.markerCountForNode(*node, WTFMove(markerType))));
3781}
3782
3783EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerCountForNode(ExecState* state)
3784{
3785 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkerCountForNodeBody>(*state, "markerCountForNode");
3786}
3787
3788static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkerRangeForNodeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3789{
3790 UNUSED_PARAM(state);
3791 UNUSED_PARAM(throwScope);
3792 auto& impl = castedThis->wrapped();
3793 if (UNLIKELY(state->argumentCount() < 3))
3794 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3795 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "markerRangeForNode", "Node"); });
3796 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3797 auto markerType = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3798 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3799 auto index = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(2));
3800 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3801 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), throwScope, impl.markerRangeForNode(*node, WTFMove(markerType), WTFMove(index))));
3802}
3803
3804EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerRangeForNode(ExecState* state)
3805{
3806 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkerRangeForNodeBody>(*state, "markerRangeForNode");
3807}
3808
3809static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkerDescriptionForNodeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3810{
3811 UNUSED_PARAM(state);
3812 UNUSED_PARAM(throwScope);
3813 auto& impl = castedThis->wrapped();
3814 if (UNLIKELY(state->argumentCount() < 3))
3815 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3816 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "markerDescriptionForNode", "Node"); });
3817 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3818 auto markerType = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3819 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3820 auto index = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(2));
3821 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3822 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.markerDescriptionForNode(*node, WTFMove(markerType), WTFMove(index))));
3823}
3824
3825EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerDescriptionForNode(ExecState* state)
3826{
3827 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkerDescriptionForNodeBody>(*state, "markerDescriptionForNode");
3828}
3829
3830static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDumpMarkerRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3831{
3832 UNUSED_PARAM(state);
3833 UNUSED_PARAM(throwScope);
3834 auto& impl = castedThis->wrapped();
3835 if (UNLIKELY(state->argumentCount() < 1))
3836 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3837 auto markerType = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3838 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3839 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.dumpMarkerRects(WTFMove(markerType))));
3840}
3841
3842EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDumpMarkerRects(ExecState* state)
3843{
3844 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDumpMarkerRectsBody>(*state, "dumpMarkerRects");
3845}
3846
3847static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAddTextMatchMarkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3848{
3849 UNUSED_PARAM(state);
3850 UNUSED_PARAM(throwScope);
3851 auto& impl = castedThis->wrapped();
3852 if (UNLIKELY(state->argumentCount() < 2))
3853 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3854 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "addTextMatchMarker", "Range"); });
3855 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3856 auto isActive = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
3857 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3858 impl.addTextMatchMarker(*range, WTFMove(isActive));
3859 return JSValue::encode(jsUndefined());
3860}
3861
3862EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAddTextMatchMarker(ExecState* state)
3863{
3864 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAddTextMatchMarkerBody>(*state, "addTextMatchMarker");
3865}
3866
3867static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlightedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3868{
3869 UNUSED_PARAM(state);
3870 UNUSED_PARAM(throwScope);
3871 auto& impl = castedThis->wrapped();
3872 if (UNLIKELY(state->argumentCount() < 1))
3873 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3874 auto flag = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
3875 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3876 propagateException(*state, throwScope, impl.setMarkedTextMatchesAreHighlighted(WTFMove(flag)));
3877 return JSValue::encode(jsUndefined());
3878}
3879
3880EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlighted(ExecState* state)
3881{
3882 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlightedBody>(*state, "setMarkedTextMatchesAreHighlighted");
3883}
3884
3885static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInvalidateFontCacheBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3886{
3887 UNUSED_PARAM(state);
3888 UNUSED_PARAM(throwScope);
3889 auto& impl = castedThis->wrapped();
3890 impl.invalidateFontCache();
3891 return JSValue::encode(jsUndefined());
3892}
3893
3894EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInvalidateFontCache(ExecState* state)
3895{
3896 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInvalidateFontCacheBody>(*state, "invalidateFontCache");
3897}
3898
3899static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFontSmoothingEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3900{
3901 UNUSED_PARAM(state);
3902 UNUSED_PARAM(throwScope);
3903 auto& impl = castedThis->wrapped();
3904 if (UNLIKELY(state->argumentCount() < 1))
3905 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3906 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
3907 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3908 impl.setFontSmoothingEnabled(WTFMove(enabled));
3909 return JSValue::encode(jsUndefined());
3910}
3911
3912EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFontSmoothingEnabled(ExecState* state)
3913{
3914 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFontSmoothingEnabledBody>(*state, "setFontSmoothingEnabled");
3915}
3916
3917static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetScrollViewPositionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3918{
3919 UNUSED_PARAM(state);
3920 UNUSED_PARAM(throwScope);
3921 auto& impl = castedThis->wrapped();
3922 if (UNLIKELY(state->argumentCount() < 2))
3923 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3924 auto x = convert<IDLLong>(*state, state->uncheckedArgument(0));
3925 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3926 auto y = convert<IDLLong>(*state, state->uncheckedArgument(1));
3927 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3928 propagateException(*state, throwScope, impl.setScrollViewPosition(WTFMove(x), WTFMove(y)));
3929 return JSValue::encode(jsUndefined());
3930}
3931
3932EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetScrollViewPosition(ExecState* state)
3933{
3934 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetScrollViewPositionBody>(*state, "setScrollViewPosition");
3935}
3936
3937static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUnconstrainedScrollToBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3938{
3939 UNUSED_PARAM(state);
3940 UNUSED_PARAM(throwScope);
3941 auto& impl = castedThis->wrapped();
3942 if (UNLIKELY(state->argumentCount() < 3))
3943 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3944 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "unconstrainedScrollTo", "Element"); });
3945 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3946 auto x = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3947 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3948 auto y = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(2));
3949 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3950 propagateException(*state, throwScope, impl.unconstrainedScrollTo(*element, WTFMove(x), WTFMove(y)));
3951 return JSValue::encode(jsUndefined());
3952}
3953
3954EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUnconstrainedScrollTo(ExecState* state)
3955{
3956 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUnconstrainedScrollToBody>(*state, "unconstrainedScrollTo");
3957}
3958
3959static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLayoutViewportRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3960{
3961 UNUSED_PARAM(state);
3962 UNUSED_PARAM(throwScope);
3963 auto& impl = castedThis->wrapped();
3964 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), throwScope, impl.layoutViewportRect()));
3965}
3966
3967EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayoutViewportRect(ExecState* state)
3968{
3969 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLayoutViewportRectBody>(*state, "layoutViewportRect");
3970}
3971
3972static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionVisualViewportRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3973{
3974 UNUSED_PARAM(state);
3975 UNUSED_PARAM(throwScope);
3976 auto& impl = castedThis->wrapped();
3977 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), throwScope, impl.visualViewportRect()));
3978}
3979
3980EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionVisualViewportRect(ExecState* state)
3981{
3982 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionVisualViewportRectBody>(*state, "visualViewportRect");
3983}
3984
3985static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetViewIsTransparentBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3986{
3987 UNUSED_PARAM(state);
3988 UNUSED_PARAM(throwScope);
3989 auto& impl = castedThis->wrapped();
3990 if (UNLIKELY(state->argumentCount() < 1))
3991 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3992 auto trnasparent = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
3993 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3994 propagateException(*state, throwScope, impl.setViewIsTransparent(WTFMove(trnasparent)));
3995 return JSValue::encode(jsUndefined());
3996}
3997
3998EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewIsTransparent(ExecState* state)
3999{
4000 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetViewIsTransparentBody>(*state, "setViewIsTransparent");
4001}
4002
4003static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionViewBaseBackgroundColorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4004{
4005 UNUSED_PARAM(state);
4006 UNUSED_PARAM(throwScope);
4007 auto& impl = castedThis->wrapped();
4008 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.viewBaseBackgroundColor()));
4009}
4010
4011EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionViewBaseBackgroundColor(ExecState* state)
4012{
4013 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionViewBaseBackgroundColorBody>(*state, "viewBaseBackgroundColor");
4014}
4015
4016static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetViewBaseBackgroundColorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4017{
4018 UNUSED_PARAM(state);
4019 UNUSED_PARAM(throwScope);
4020 auto& impl = castedThis->wrapped();
4021 if (UNLIKELY(state->argumentCount() < 1))
4022 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4023 auto colorValue = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4024 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4025 propagateException(*state, throwScope, impl.setViewBaseBackgroundColor(WTFMove(colorValue)));
4026 return JSValue::encode(jsUndefined());
4027}
4028
4029EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewBaseBackgroundColor(ExecState* state)
4030{
4031 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetViewBaseBackgroundColorBody>(*state, "setViewBaseBackgroundColor");
4032}
4033
4034static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPaginationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4035{
4036 UNUSED_PARAM(state);
4037 UNUSED_PARAM(throwScope);
4038 auto& impl = castedThis->wrapped();
4039 if (UNLIKELY(state->argumentCount() < 2))
4040 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4041 auto mode = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4042 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4043 auto gap = convert<IDLLong>(*state, state->uncheckedArgument(1));
4044 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4045 auto pageLength = convert<IDLLong>(*state, state->argument(2));
4046 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4047 propagateException(*state, throwScope, impl.setPagination(WTFMove(mode), WTFMove(gap), WTFMove(pageLength)));
4048 return JSValue::encode(jsUndefined());
4049}
4050
4051EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPagination(ExecState* state)
4052{
4053 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPaginationBody>(*state, "setPagination");
4054}
4055
4056static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPaginationLineGridEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4057{
4058 UNUSED_PARAM(state);
4059 UNUSED_PARAM(throwScope);
4060 auto& impl = castedThis->wrapped();
4061 if (UNLIKELY(state->argumentCount() < 1))
4062 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4063 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4064 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4065 propagateException(*state, throwScope, impl.setPaginationLineGridEnabled(WTFMove(enabled)));
4066 return JSValue::encode(jsUndefined());
4067}
4068
4069EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPaginationLineGridEnabled(ExecState* state)
4070{
4071 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPaginationLineGridEnabledBody>(*state, "setPaginationLineGridEnabled");
4072}
4073
4074static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionConfigurationForViewportBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4075{
4076 UNUSED_PARAM(state);
4077 UNUSED_PARAM(throwScope);
4078 auto& impl = castedThis->wrapped();
4079 if (UNLIKELY(state->argumentCount() < 5))
4080 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4081 auto devicePixelRatio = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
4082 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4083 auto deviceWidth = convert<IDLLong>(*state, state->uncheckedArgument(1));
4084 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4085 auto deviceHeight = convert<IDLLong>(*state, state->uncheckedArgument(2));
4086 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4087 auto availableWidth = convert<IDLLong>(*state, state->uncheckedArgument(3));
4088 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4089 auto availableHeight = convert<IDLLong>(*state, state->uncheckedArgument(4));
4090 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4091 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.configurationForViewport(WTFMove(devicePixelRatio), WTFMove(deviceWidth), WTFMove(deviceHeight), WTFMove(availableWidth), WTFMove(availableHeight))));
4092}
4093
4094EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionConfigurationForViewport(ExecState* state)
4095{
4096 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionConfigurationForViewportBody>(*state, "configurationForViewport");
4097}
4098
4099static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWasLastChangeUserEditBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4100{
4101 UNUSED_PARAM(state);
4102 UNUSED_PARAM(throwScope);
4103 auto& impl = castedThis->wrapped();
4104 if (UNLIKELY(state->argumentCount() < 1))
4105 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4106 auto textField = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "textField", "Internals", "wasLastChangeUserEdit", "Element"); });
4107 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4108 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.wasLastChangeUserEdit(*textField)));
4109}
4110
4111EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWasLastChangeUserEdit(ExecState* state)
4112{
4113 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWasLastChangeUserEditBody>(*state, "wasLastChangeUserEdit");
4114}
4115
4116static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementShouldAutoCompleteBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4117{
4118 UNUSED_PARAM(state);
4119 UNUSED_PARAM(throwScope);
4120 auto& impl = castedThis->wrapped();
4121 if (UNLIKELY(state->argumentCount() < 1))
4122 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4123 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "elementShouldAutoComplete", "HTMLInputElement"); });
4124 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4125 return JSValue::encode(toJS<IDLBoolean>(impl.elementShouldAutoComplete(*inputElement)));
4126}
4127
4128EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementShouldAutoComplete(ExecState* state)
4129{
4130 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementShouldAutoCompleteBody>(*state, "elementShouldAutoComplete");
4131}
4132
4133static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutofilledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4134{
4135 UNUSED_PARAM(state);
4136 UNUSED_PARAM(throwScope);
4137 auto& impl = castedThis->wrapped();
4138 if (UNLIKELY(state->argumentCount() < 2))
4139 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4140 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "setAutofilled", "HTMLInputElement"); });
4141 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4142 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
4143 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4144 impl.setAutofilled(*inputElement, WTFMove(enabled));
4145 return JSValue::encode(jsUndefined());
4146}
4147
4148EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutofilled(ExecState* state)
4149{
4150 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutofilledBody>(*state, "setAutofilled");
4151}
4152
4153static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShowAutoFillButtonBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4154{
4155 UNUSED_PARAM(state);
4156 UNUSED_PARAM(throwScope);
4157 auto& impl = castedThis->wrapped();
4158 if (UNLIKELY(state->argumentCount() < 2))
4159 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4160 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "setShowAutoFillButton", "HTMLInputElement"); });
4161 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4162 auto autoFillButtonType = convert<IDLEnumeration<Internals::AutoFillButtonType>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 1, "autoFillButtonType", "Internals", "setShowAutoFillButton", expectedEnumerationValues<Internals::AutoFillButtonType>()); });
4163 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4164 impl.setShowAutoFillButton(*inputElement, WTFMove(autoFillButtonType));
4165 return JSValue::encode(jsUndefined());
4166}
4167
4168EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShowAutoFillButton(ExecState* state)
4169{
4170 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShowAutoFillButtonBody>(*state, "setShowAutoFillButton");
4171}
4172
4173static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAutoFillButtonTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4174{
4175 UNUSED_PARAM(state);
4176 UNUSED_PARAM(throwScope);
4177 auto& impl = castedThis->wrapped();
4178 if (UNLIKELY(state->argumentCount() < 1))
4179 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4180 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "autoFillButtonType", "HTMLInputElement"); });
4181 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4182 return JSValue::encode(toJS<IDLEnumeration<Internals::AutoFillButtonType>>(*state, impl.autoFillButtonType(*inputElement)));
4183}
4184
4185EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAutoFillButtonType(ExecState* state)
4186{
4187 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAutoFillButtonTypeBody>(*state, "autoFillButtonType");
4188}
4189
4190static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastAutoFillButtonTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4191{
4192 UNUSED_PARAM(state);
4193 UNUSED_PARAM(throwScope);
4194 auto& impl = castedThis->wrapped();
4195 if (UNLIKELY(state->argumentCount() < 1))
4196 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4197 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "lastAutoFillButtonType", "HTMLInputElement"); });
4198 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4199 return JSValue::encode(toJS<IDLEnumeration<Internals::AutoFillButtonType>>(*state, impl.lastAutoFillButtonType(*inputElement)));
4200}
4201
4202EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastAutoFillButtonType(ExecState* state)
4203{
4204 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastAutoFillButtonTypeBody>(*state, "lastAutoFillButtonType");
4205}
4206
4207static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeOfStringBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4208{
4209 UNUSED_PARAM(state);
4210 UNUSED_PARAM(throwScope);
4211 auto& impl = castedThis->wrapped();
4212 if (UNLIKELY(state->argumentCount() < 3))
4213 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4214 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4215 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4216 auto referenceRange = convert<IDLNullable<IDLInterface<Range>>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "referenceRange", "Internals", "rangeOfString", "Range"); });
4217 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4218 auto findOptions = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(2));
4219 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4220 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), throwScope, impl.rangeOfString(WTFMove(text), WTFMove(referenceRange), WTFMove(findOptions))));
4221}
4222
4223EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeOfString(ExecState* state)
4224{
4225 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeOfStringBody>(*state, "rangeOfString");
4226}
4227
4228static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCountMatchesForTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4229{
4230 UNUSED_PARAM(state);
4231 UNUSED_PARAM(throwScope);
4232 auto& impl = castedThis->wrapped();
4233 if (UNLIKELY(state->argumentCount() < 3))
4234 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4235 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4236 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4237 auto findOptions = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(1));
4238 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4239 auto markMatches = convert<IDLDOMString>(*state, state->uncheckedArgument(2));
4240 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4241 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.countMatchesForText(WTFMove(text), WTFMove(findOptions), WTFMove(markMatches))));
4242}
4243
4244EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCountMatchesForText(ExecState* state)
4245{
4246 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCountMatchesForTextBody>(*state, "countMatchesForText");
4247}
4248
4249static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCountFindMatchesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4250{
4251 UNUSED_PARAM(state);
4252 UNUSED_PARAM(throwScope);
4253 auto& impl = castedThis->wrapped();
4254 if (UNLIKELY(state->argumentCount() < 2))
4255 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4256 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4257 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4258 auto findOptions = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(1));
4259 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4260 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.countFindMatches(WTFMove(text), WTFMove(findOptions))));
4261}
4262
4263EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCountFindMatches(ExecState* state)
4264{
4265 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCountFindMatchesBody>(*state, "countFindMatches");
4266}
4267
4268static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAutofillFieldNameBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4269{
4270 UNUSED_PARAM(state);
4271 UNUSED_PARAM(throwScope);
4272 auto& impl = castedThis->wrapped();
4273 if (UNLIKELY(state->argumentCount() < 1))
4274 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4275 auto formControlElement = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "formControlElement", "Internals", "autofillFieldName", "Element"); });
4276 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4277 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.autofillFieldName(*formControlElement)));
4278}
4279
4280EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAutofillFieldName(ExecState* state)
4281{
4282 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAutofillFieldNameBody>(*state, "autofillFieldName");
4283}
4284
4285static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInvalidateControlTintsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4286{
4287 UNUSED_PARAM(state);
4288 UNUSED_PARAM(throwScope);
4289 auto& impl = castedThis->wrapped();
4290 propagateException(*state, throwScope, impl.invalidateControlTints());
4291 return JSValue::encode(jsUndefined());
4292}
4293
4294EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInvalidateControlTints(ExecState* state)
4295{
4296 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInvalidateControlTintsBody>(*state, "invalidateControlTints");
4297}
4298
4299static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollElementToRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4300{
4301 UNUSED_PARAM(state);
4302 UNUSED_PARAM(throwScope);
4303 auto& impl = castedThis->wrapped();
4304 if (UNLIKELY(state->argumentCount() < 5))
4305 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4306 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "scrollElementToRect", "Element"); });
4307 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4308 auto x = convert<IDLLong>(*state, state->uncheckedArgument(1));
4309 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4310 auto y = convert<IDLLong>(*state, state->uncheckedArgument(2));
4311 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4312 auto w = convert<IDLLong>(*state, state->uncheckedArgument(3));
4313 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4314 auto h = convert<IDLLong>(*state, state->uncheckedArgument(4));
4315 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4316 propagateException(*state, throwScope, impl.scrollElementToRect(*element, WTFMove(x), WTFMove(y), WTFMove(w), WTFMove(h)));
4317 return JSValue::encode(jsUndefined());
4318}
4319
4320EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollElementToRect(ExecState* state)
4321{
4322 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollElementToRectBody>(*state, "scrollElementToRect");
4323}
4324
4325static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeFromLocationAndLengthBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4326{
4327 UNUSED_PARAM(state);
4328 UNUSED_PARAM(throwScope);
4329 auto& impl = castedThis->wrapped();
4330 if (UNLIKELY(state->argumentCount() < 3))
4331 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4332 auto scope = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "scope", "Internals", "rangeFromLocationAndLength", "Element"); });
4333 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4334 auto rangeLocation = convert<IDLLong>(*state, state->uncheckedArgument(1));
4335 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4336 auto rangeLength = convert<IDLLong>(*state, state->uncheckedArgument(2));
4337 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4338 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), impl.rangeFromLocationAndLength(*scope, WTFMove(rangeLocation), WTFMove(rangeLength))));
4339}
4340
4341EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeFromLocationAndLength(ExecState* state)
4342{
4343 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeFromLocationAndLengthBody>(*state, "rangeFromLocationAndLength");
4344}
4345
4346static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLocationFromRangeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4347{
4348 UNUSED_PARAM(state);
4349 UNUSED_PARAM(throwScope);
4350 auto& impl = castedThis->wrapped();
4351 if (UNLIKELY(state->argumentCount() < 2))
4352 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4353 auto scope = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "scope", "Internals", "locationFromRange", "Element"); });
4354 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4355 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "range", "Internals", "locationFromRange", "Range"); });
4356 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4357 return JSValue::encode(toJS<IDLUnsignedLong>(impl.locationFromRange(*scope, *range)));
4358}
4359
4360EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLocationFromRange(ExecState* state)
4361{
4362 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLocationFromRangeBody>(*state, "locationFromRange");
4363}
4364
4365static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLengthFromRangeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4366{
4367 UNUSED_PARAM(state);
4368 UNUSED_PARAM(throwScope);
4369 auto& impl = castedThis->wrapped();
4370 if (UNLIKELY(state->argumentCount() < 2))
4371 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4372 auto scope = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "scope", "Internals", "lengthFromRange", "Element"); });
4373 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4374 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "range", "Internals", "lengthFromRange", "Range"); });
4375 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4376 return JSValue::encode(toJS<IDLUnsignedLong>(impl.lengthFromRange(*scope, *range)));
4377}
4378
4379EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLengthFromRange(ExecState* state)
4380{
4381 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLengthFromRangeBody>(*state, "lengthFromRange");
4382}
4383
4384static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4385{
4386 UNUSED_PARAM(state);
4387 UNUSED_PARAM(throwScope);
4388 auto& impl = castedThis->wrapped();
4389 if (UNLIKELY(state->argumentCount() < 1))
4390 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4391 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "rangeAsText", "Range"); });
4392 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4393 return JSValue::encode(toJS<IDLDOMString>(*state, impl.rangeAsText(*range)));
4394}
4395
4396EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeAsText(ExecState* state)
4397{
4398 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeAsTextBody>(*state, "rangeAsText");
4399}
4400
4401static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIteratorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4402{
4403 UNUSED_PARAM(state);
4404 UNUSED_PARAM(throwScope);
4405 auto& impl = castedThis->wrapped();
4406 if (UNLIKELY(state->argumentCount() < 1))
4407 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4408 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "rangeAsTextUsingBackwardsTextIterator", "Range"); });
4409 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4410 return JSValue::encode(toJS<IDLDOMString>(*state, impl.rangeAsTextUsingBackwardsTextIterator(*range)));
4411}
4412
4413EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIterator(ExecState* state)
4414{
4415 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIteratorBody>(*state, "rangeAsTextUsingBackwardsTextIterator");
4416}
4417
4418static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSubrangeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4419{
4420 UNUSED_PARAM(state);
4421 UNUSED_PARAM(throwScope);
4422 auto& impl = castedThis->wrapped();
4423 if (UNLIKELY(state->argumentCount() < 3))
4424 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4425 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "subrange", "Range"); });
4426 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4427 auto rangeLocation = convert<IDLLong>(*state, state->uncheckedArgument(1));
4428 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4429 auto rangeLength = convert<IDLLong>(*state, state->uncheckedArgument(2));
4430 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4431 return JSValue::encode(toJS<IDLInterface<Range>>(*state, *castedThis->globalObject(), impl.subrange(*range, WTFMove(rangeLocation), WTFMove(rangeLength))));
4432}
4433
4434EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSubrange(ExecState* state)
4435{
4436 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSubrangeBody>(*state, "subrange");
4437}
4438
4439static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4440{
4441 UNUSED_PARAM(state);
4442 UNUSED_PARAM(throwScope);
4443 auto& impl = castedThis->wrapped();
4444 if (UNLIKELY(state->argumentCount() < 2))
4445 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4446 auto x = convert<IDLLong>(*state, state->uncheckedArgument(0));
4447 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4448 auto y = convert<IDLLong>(*state, state->uncheckedArgument(1));
4449 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4450 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), throwScope, impl.rangeForDictionaryLookupAtLocation(WTFMove(x), WTFMove(y))));
4451}
4452
4453EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocation(ExecState* state)
4454{
4455 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocationBody>(*state, "rangeForDictionaryLookupAtLocation");
4456}
4457
4458static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeOfStringNearLocationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4459{
4460 UNUSED_PARAM(state);
4461 UNUSED_PARAM(throwScope);
4462 auto& impl = castedThis->wrapped();
4463 if (UNLIKELY(state->argumentCount() < 3))
4464 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4465 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "rangeOfStringNearLocation", "Range"); });
4466 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4467 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
4468 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4469 auto targetOffset = convert<IDLLong>(*state, state->uncheckedArgument(2));
4470 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4471 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), impl.rangeOfStringNearLocation(*range, WTFMove(text), WTFMove(targetOffset))));
4472}
4473
4474EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeOfStringNearLocation(ExecState* state)
4475{
4476 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeOfStringNearLocationBody>(*state, "rangeOfStringNearLocation");
4477}
4478
4479static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetDelegatesScrollingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4480{
4481 UNUSED_PARAM(state);
4482 UNUSED_PARAM(throwScope);
4483 auto& impl = castedThis->wrapped();
4484 if (UNLIKELY(state->argumentCount() < 1))
4485 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4486 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4487 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4488 propagateException(*state, throwScope, impl.setDelegatesScrolling(WTFMove(enabled)));
4489 return JSValue::encode(jsUndefined());
4490}
4491
4492EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetDelegatesScrolling(ExecState* state)
4493{
4494 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetDelegatesScrollingBody>(*state, "setDelegatesScrolling");
4495}
4496
4497static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastSpellCheckRequestSequenceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4498{
4499 UNUSED_PARAM(state);
4500 UNUSED_PARAM(throwScope);
4501 auto& impl = castedThis->wrapped();
4502 return JSValue::encode(toJS<IDLLong>(*state, throwScope, impl.lastSpellCheckRequestSequence()));
4503}
4504
4505EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpellCheckRequestSequence(ExecState* state)
4506{
4507 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastSpellCheckRequestSequenceBody>(*state, "lastSpellCheckRequestSequence");
4508}
4509
4510static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastSpellCheckProcessedSequenceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4511{
4512 UNUSED_PARAM(state);
4513 UNUSED_PARAM(throwScope);
4514 auto& impl = castedThis->wrapped();
4515 return JSValue::encode(toJS<IDLLong>(*state, throwScope, impl.lastSpellCheckProcessedSequence()));
4516}
4517
4518EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpellCheckProcessedSequence(ExecState* state)
4519{
4520 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastSpellCheckProcessedSequenceBody>(*state, "lastSpellCheckProcessedSequence");
4521}
4522
4523static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserPreferredLanguagesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4524{
4525 UNUSED_PARAM(state);
4526 UNUSED_PARAM(throwScope);
4527 auto& impl = castedThis->wrapped();
4528 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.userPreferredLanguages()));
4529}
4530
4531EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPreferredLanguages(ExecState* state)
4532{
4533 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserPreferredLanguagesBody>(*state, "userPreferredLanguages");
4534}
4535
4536static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUserPreferredLanguagesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4537{
4538 UNUSED_PARAM(state);
4539 UNUSED_PARAM(throwScope);
4540 auto& impl = castedThis->wrapped();
4541 if (UNLIKELY(state->argumentCount() < 1))
4542 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4543 auto languages = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(0));
4544 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4545 impl.setUserPreferredLanguages(WTFMove(languages));
4546 return JSValue::encode(jsUndefined());
4547}
4548
4549EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserPreferredLanguages(ExecState* state)
4550{
4551 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUserPreferredLanguagesBody>(*state, "setUserPreferredLanguages");
4552}
4553
4554static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserPreferredAudioCharacteristicsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4555{
4556 UNUSED_PARAM(state);
4557 UNUSED_PARAM(throwScope);
4558 auto& impl = castedThis->wrapped();
4559 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.userPreferredAudioCharacteristics()));
4560}
4561
4562EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPreferredAudioCharacteristics(ExecState* state)
4563{
4564 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserPreferredAudioCharacteristicsBody>(*state, "userPreferredAudioCharacteristics");
4565}
4566
4567static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristicBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4568{
4569 UNUSED_PARAM(state);
4570 UNUSED_PARAM(throwScope);
4571 auto& impl = castedThis->wrapped();
4572 if (UNLIKELY(state->argumentCount() < 1))
4573 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4574 auto characteristic = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4575 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4576 impl.setUserPreferredAudioCharacteristic(WTFMove(characteristic));
4577 return JSValue::encode(jsUndefined());
4578}
4579
4580EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristic(ExecState* state)
4581{
4582 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristicBody>(*state, "setUserPreferredAudioCharacteristic");
4583}
4584
4585static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWheelEventHandlerCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4586{
4587 UNUSED_PARAM(state);
4588 UNUSED_PARAM(throwScope);
4589 auto& impl = castedThis->wrapped();
4590 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.wheelEventHandlerCount()));
4591}
4592
4593EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWheelEventHandlerCount(ExecState* state)
4594{
4595 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWheelEventHandlerCountBody>(*state, "wheelEventHandlerCount");
4596}
4597
4598static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTouchEventHandlerCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4599{
4600 UNUSED_PARAM(state);
4601 UNUSED_PARAM(throwScope);
4602 auto& impl = castedThis->wrapped();
4603 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.touchEventHandlerCount()));
4604}
4605
4606EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTouchEventHandlerCount(ExecState* state)
4607{
4608 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTouchEventHandlerCountBody>(*state, "touchEventHandlerCount");
4609}
4610
4611static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTouchEventRectsForEventBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4612{
4613 UNUSED_PARAM(state);
4614 UNUSED_PARAM(throwScope);
4615 auto& impl = castedThis->wrapped();
4616 if (UNLIKELY(state->argumentCount() < 1))
4617 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4618 auto eventName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4619 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4620 return JSValue::encode(toJS<IDLInterface<DOMRectList>>(*state, *castedThis->globalObject(), throwScope, impl.touchEventRectsForEvent(WTFMove(eventName))));
4621}
4622
4623EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTouchEventRectsForEvent(ExecState* state)
4624{
4625 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTouchEventRectsForEventBody>(*state, "touchEventRectsForEvent");
4626}
4627
4628static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPassiveTouchEventListenerRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4629{
4630 UNUSED_PARAM(state);
4631 UNUSED_PARAM(throwScope);
4632 auto& impl = castedThis->wrapped();
4633 return JSValue::encode(toJS<IDLInterface<DOMRectList>>(*state, *castedThis->globalObject(), throwScope, impl.passiveTouchEventListenerRects()));
4634}
4635
4636EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPassiveTouchEventListenerRects(ExecState* state)
4637{
4638 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPassiveTouchEventListenerRectsBody>(*state, "passiveTouchEventListenerRects");
4639}
4640
4641static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNodesFromRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4642{
4643 UNUSED_PARAM(state);
4644 UNUSED_PARAM(throwScope);
4645 auto& impl = castedThis->wrapped();
4646 if (UNLIKELY(state->argumentCount() < 10))
4647 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4648 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "nodesFromRect", "Document"); });
4649 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4650 auto x = convert<IDLLong>(*state, state->uncheckedArgument(1));
4651 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4652 auto y = convert<IDLLong>(*state, state->uncheckedArgument(2));
4653 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4654 auto topPadding = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(3));
4655 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4656 auto rightPadding = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(4));
4657 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4658 auto bottomPadding = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(5));
4659 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4660 auto leftPadding = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(6));
4661 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4662 auto ignoreClipping = convert<IDLBoolean>(*state, state->uncheckedArgument(7));
4663 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4664 auto allowShadowContent = convert<IDLBoolean>(*state, state->uncheckedArgument(8));
4665 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4666 auto allowChildFrameContent = convert<IDLBoolean>(*state, state->uncheckedArgument(9));
4667 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4668 return JSValue::encode(toJS<IDLNullable<IDLInterface<NodeList>>>(*state, *castedThis->globalObject(), throwScope, impl.nodesFromRect(*document, WTFMove(x), WTFMove(y), WTFMove(topPadding), WTFMove(rightPadding), WTFMove(bottomPadding), WTFMove(leftPadding), WTFMove(ignoreClipping), WTFMove(allowShadowContent), WTFMove(allowChildFrameContent))));
4669}
4670
4671EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNodesFromRect(ExecState* state)
4672{
4673 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNodesFromRectBody>(*state, "nodesFromRect");
4674}
4675
4676static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionParserMetaDataBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4677{
4678 UNUSED_PARAM(state);
4679 UNUSED_PARAM(throwScope);
4680 auto& impl = castedThis->wrapped();
4681 auto func = convert<IDLAny>(*state, state->argument(0));
4682 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4683 return JSValue::encode(toJS<IDLDOMString>(*state, impl.parserMetaData(WTFMove(func))));
4684}
4685
4686EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParserMetaData(ExecState* state)
4687{
4688 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionParserMetaDataBody>(*state, "parserMetaData");
4689}
4690
4691static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4692{
4693 UNUSED_PARAM(state);
4694 UNUSED_PARAM(throwScope);
4695 auto& impl = castedThis->wrapped();
4696 impl.updateEditorUINowIfScheduled();
4697 return JSValue::encode(jsUndefined());
4698}
4699
4700EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduled(ExecState* state)
4701{
4702 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduledBody>(*state, "updateEditorUINowIfScheduled");
4703}
4704
4705static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasSpellingMarkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4706{
4707 UNUSED_PARAM(state);
4708 UNUSED_PARAM(throwScope);
4709 auto& impl = castedThis->wrapped();
4710 if (UNLIKELY(state->argumentCount() < 2))
4711 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4712 auto from = convert<IDLLong>(*state, state->uncheckedArgument(0));
4713 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4714 auto length = convert<IDLLong>(*state, state->uncheckedArgument(1));
4715 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4716 return JSValue::encode(toJS<IDLBoolean>(impl.hasSpellingMarker(WTFMove(from), WTFMove(length))));
4717}
4718
4719EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasSpellingMarker(ExecState* state)
4720{
4721 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasSpellingMarkerBody>(*state, "hasSpellingMarker");
4722}
4723
4724static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasGrammarMarkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4725{
4726 UNUSED_PARAM(state);
4727 UNUSED_PARAM(throwScope);
4728 auto& impl = castedThis->wrapped();
4729 if (UNLIKELY(state->argumentCount() < 2))
4730 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4731 auto from = convert<IDLLong>(*state, state->uncheckedArgument(0));
4732 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4733 auto length = convert<IDLLong>(*state, state->uncheckedArgument(1));
4734 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4735 return JSValue::encode(toJS<IDLBoolean>(impl.hasGrammarMarker(WTFMove(from), WTFMove(length))));
4736}
4737
4738EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasGrammarMarker(ExecState* state)
4739{
4740 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasGrammarMarkerBody>(*state, "hasGrammarMarker");
4741}
4742
4743static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasAutocorrectedMarkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4744{
4745 UNUSED_PARAM(state);
4746 UNUSED_PARAM(throwScope);
4747 auto& impl = castedThis->wrapped();
4748 if (UNLIKELY(state->argumentCount() < 2))
4749 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4750 auto from = convert<IDLLong>(*state, state->uncheckedArgument(0));
4751 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4752 auto length = convert<IDLLong>(*state, state->uncheckedArgument(1));
4753 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4754 return JSValue::encode(toJS<IDLBoolean>(impl.hasAutocorrectedMarker(WTFMove(from), WTFMove(length))));
4755}
4756
4757EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasAutocorrectedMarker(ExecState* state)
4758{
4759 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasAutocorrectedMarkerBody>(*state, "hasAutocorrectedMarker");
4760}
4761
4762static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4763{
4764 UNUSED_PARAM(state);
4765 UNUSED_PARAM(throwScope);
4766 auto& impl = castedThis->wrapped();
4767 if (UNLIKELY(state->argumentCount() < 1))
4768 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4769 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4770 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4771 impl.setContinuousSpellCheckingEnabled(WTFMove(enabled));
4772 return JSValue::encode(jsUndefined());
4773}
4774
4775EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabled(ExecState* state)
4776{
4777 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabledBody>(*state, "setContinuousSpellCheckingEnabled");
4778}
4779
4780static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4781{
4782 UNUSED_PARAM(state);
4783 UNUSED_PARAM(throwScope);
4784 auto& impl = castedThis->wrapped();
4785 if (UNLIKELY(state->argumentCount() < 1))
4786 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4787 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4788 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4789 impl.setAutomaticQuoteSubstitutionEnabled(WTFMove(enabled));
4790 return JSValue::encode(jsUndefined());
4791}
4792
4793EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabled(ExecState* state)
4794{
4795 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabledBody>(*state, "setAutomaticQuoteSubstitutionEnabled");
4796}
4797
4798static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4799{
4800 UNUSED_PARAM(state);
4801 UNUSED_PARAM(throwScope);
4802 auto& impl = castedThis->wrapped();
4803 if (UNLIKELY(state->argumentCount() < 1))
4804 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4805 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4806 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4807 impl.setAutomaticLinkDetectionEnabled(WTFMove(enabled));
4808 return JSValue::encode(jsUndefined());
4809}
4810
4811EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabled(ExecState* state)
4812{
4813 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabledBody>(*state, "setAutomaticLinkDetectionEnabled");
4814}
4815
4816static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4817{
4818 UNUSED_PARAM(state);
4819 UNUSED_PARAM(throwScope);
4820 auto& impl = castedThis->wrapped();
4821 if (UNLIKELY(state->argumentCount() < 1))
4822 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4823 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4824 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4825 impl.setAutomaticDashSubstitutionEnabled(WTFMove(enabled));
4826 return JSValue::encode(jsUndefined());
4827}
4828
4829EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabled(ExecState* state)
4830{
4831 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabledBody>(*state, "setAutomaticDashSubstitutionEnabled");
4832}
4833
4834static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4835{
4836 UNUSED_PARAM(state);
4837 UNUSED_PARAM(throwScope);
4838 auto& impl = castedThis->wrapped();
4839 if (UNLIKELY(state->argumentCount() < 1))
4840 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4841 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4842 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4843 impl.setAutomaticTextReplacementEnabled(WTFMove(enabled));
4844 return JSValue::encode(jsUndefined());
4845}
4846
4847EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabled(ExecState* state)
4848{
4849 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabledBody>(*state, "setAutomaticTextReplacementEnabled");
4850}
4851
4852static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4853{
4854 UNUSED_PARAM(state);
4855 UNUSED_PARAM(throwScope);
4856 auto& impl = castedThis->wrapped();
4857 if (UNLIKELY(state->argumentCount() < 1))
4858 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4859 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4860 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4861 impl.setAutomaticSpellingCorrectionEnabled(WTFMove(enabled));
4862 return JSValue::encode(jsUndefined());
4863}
4864
4865EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabled(ExecState* state)
4866{
4867 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabledBody>(*state, "setAutomaticSpellingCorrectionEnabled");
4868}
4869
4870static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHandleAcceptedCandidateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4871{
4872 UNUSED_PARAM(state);
4873 UNUSED_PARAM(throwScope);
4874 auto& impl = castedThis->wrapped();
4875 if (UNLIKELY(state->argumentCount() < 3))
4876 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4877 auto candidate = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4878 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4879 auto location = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(1));
4880 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4881 auto length = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(2));
4882 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4883 impl.handleAcceptedCandidate(WTFMove(candidate), WTFMove(location), WTFMove(length));
4884 return JSValue::encode(jsUndefined());
4885}
4886
4887EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHandleAcceptedCandidate(ExecState* state)
4888{
4889 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHandleAcceptedCandidateBody>(*state, "handleAcceptedCandidate");
4890}
4891
4892static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionChangeSelectionListTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4893{
4894 UNUSED_PARAM(state);
4895 UNUSED_PARAM(throwScope);
4896 auto& impl = castedThis->wrapped();
4897 impl.changeSelectionListType();
4898 return JSValue::encode(jsUndefined());
4899}
4900
4901EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionChangeSelectionListType(ExecState* state)
4902{
4903 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionChangeSelectionListTypeBody>(*state, "changeSelectionListType");
4904}
4905
4906static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsOverwriteModeEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4907{
4908 UNUSED_PARAM(state);
4909 UNUSED_PARAM(throwScope);
4910 auto& impl = castedThis->wrapped();
4911 return JSValue::encode(toJS<IDLBoolean>(impl.isOverwriteModeEnabled()));
4912}
4913
4914EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsOverwriteModeEnabled(ExecState* state)
4915{
4916 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsOverwriteModeEnabledBody>(*state, "isOverwriteModeEnabled");
4917}
4918
4919static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionToggleOverwriteModeEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4920{
4921 UNUSED_PARAM(state);
4922 UNUSED_PARAM(throwScope);
4923 auto& impl = castedThis->wrapped();
4924 impl.toggleOverwriteModeEnabled();
4925 return JSValue::encode(jsUndefined());
4926}
4927
4928EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionToggleOverwriteModeEnabled(ExecState* state)
4929{
4930 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionToggleOverwriteModeEnabledBody>(*state, "toggleOverwriteModeEnabled");
4931}
4932
4933static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfScrollableAreasBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4934{
4935 UNUSED_PARAM(state);
4936 UNUSED_PARAM(throwScope);
4937 auto& impl = castedThis->wrapped();
4938 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfScrollableAreas()));
4939}
4940
4941EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfScrollableAreas(ExecState* state)
4942{
4943 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfScrollableAreasBody>(*state, "numberOfScrollableAreas");
4944}
4945
4946static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPageBoxVisibleBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4947{
4948 UNUSED_PARAM(state);
4949 UNUSED_PARAM(throwScope);
4950 auto& impl = castedThis->wrapped();
4951 if (UNLIKELY(state->argumentCount() < 1))
4952 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4953 auto pageNumber = convert<IDLLong>(*state, state->uncheckedArgument(0));
4954 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4955 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.isPageBoxVisible(WTFMove(pageNumber))));
4956}
4957
4958EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPageBoxVisible(ExecState* state)
4959{
4960 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPageBoxVisibleBody>(*state, "isPageBoxVisible");
4961}
4962
4963static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionImageFrameIndexBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4964{
4965 UNUSED_PARAM(state);
4966 UNUSED_PARAM(throwScope);
4967 auto& impl = castedThis->wrapped();
4968 if (UNLIKELY(state->argumentCount() < 1))
4969 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4970 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "imageFrameIndex", "HTMLImageElement"); });
4971 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4972 return JSValue::encode(toJS<IDLUnsignedLong>(impl.imageFrameIndex(*element)));
4973}
4974
4975EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameIndex(ExecState* state)
4976{
4977 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionImageFrameIndexBody>(*state, "imageFrameIndex");
4978}
4979
4980static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionImageFrameCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4981{
4982 UNUSED_PARAM(state);
4983 UNUSED_PARAM(throwScope);
4984 auto& impl = castedThis->wrapped();
4985 if (UNLIKELY(state->argumentCount() < 1))
4986 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4987 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "imageFrameCount", "HTMLImageElement"); });
4988 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4989 return JSValue::encode(toJS<IDLUnsignedLong>(impl.imageFrameCount(*element)));
4990}
4991
4992EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameCount(ExecState* state)
4993{
4994 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionImageFrameCountBody>(*state, "imageFrameCount");
4995}
4996
4997static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionImageFrameDurationAtIndexBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4998{
4999 UNUSED_PARAM(state);
5000 UNUSED_PARAM(throwScope);
5001 auto& impl = castedThis->wrapped();
5002 if (UNLIKELY(state->argumentCount() < 2))
5003 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5004 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "imageFrameDurationAtIndex", "HTMLImageElement"); });
5005 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5006 auto index = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(1));
5007 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5008 return JSValue::encode(toJS<IDLFloat>(impl.imageFrameDurationAtIndex(*element, WTFMove(index))));
5009}
5010
5011EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameDurationAtIndex(ExecState* state)
5012{
5013 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionImageFrameDurationAtIndexBody>(*state, "imageFrameDurationAtIndex");
5014}
5015
5016static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetImageFrameDecodingDurationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5017{
5018 UNUSED_PARAM(state);
5019 UNUSED_PARAM(throwScope);
5020 auto& impl = castedThis->wrapped();
5021 if (UNLIKELY(state->argumentCount() < 2))
5022 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5023 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setImageFrameDecodingDuration", "HTMLImageElement"); });
5024 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5025 auto duration = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(1));
5026 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5027 impl.setImageFrameDecodingDuration(*element, WTFMove(duration));
5028 return JSValue::encode(jsUndefined());
5029}
5030
5031EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetImageFrameDecodingDuration(ExecState* state)
5032{
5033 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetImageFrameDecodingDurationBody>(*state, "setImageFrameDecodingDuration");
5034}
5035
5036static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionResetImageAnimationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5037{
5038 UNUSED_PARAM(state);
5039 UNUSED_PARAM(throwScope);
5040 auto& impl = castedThis->wrapped();
5041 if (UNLIKELY(state->argumentCount() < 1))
5042 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5043 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "resetImageAnimation", "HTMLImageElement"); });
5044 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5045 impl.resetImageAnimation(*element);
5046 return JSValue::encode(jsUndefined());
5047}
5048
5049EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResetImageAnimation(ExecState* state)
5050{
5051 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionResetImageAnimationBody>(*state, "resetImageAnimation");
5052}
5053
5054static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsImageAnimatingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5055{
5056 UNUSED_PARAM(state);
5057 UNUSED_PARAM(throwScope);
5058 auto& impl = castedThis->wrapped();
5059 if (UNLIKELY(state->argumentCount() < 1))
5060 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5061 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isImageAnimating", "HTMLImageElement"); });
5062 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5063 return JSValue::encode(toJS<IDLBoolean>(impl.isImageAnimating(*element)));
5064}
5065
5066EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsImageAnimating(ExecState* state)
5067{
5068 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsImageAnimatingBody>(*state, "isImageAnimating");
5069}
5070
5071static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTestingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5072{
5073 UNUSED_PARAM(state);
5074 UNUSED_PARAM(throwScope);
5075 auto& impl = castedThis->wrapped();
5076 if (UNLIKELY(state->argumentCount() < 2))
5077 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5078 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setClearDecoderAfterAsyncFrameRequestForTesting", "HTMLImageElement"); });
5079 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5080 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5081 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5082 impl.setClearDecoderAfterAsyncFrameRequestForTesting(*element, WTFMove(enabled));
5083 return JSValue::encode(jsUndefined());
5084}
5085
5086EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTesting(ExecState* state)
5087{
5088 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTestingBody>(*state, "setClearDecoderAfterAsyncFrameRequestForTesting");
5089}
5090
5091static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionImageDecodeCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5092{
5093 UNUSED_PARAM(state);
5094 UNUSED_PARAM(throwScope);
5095 auto& impl = castedThis->wrapped();
5096 if (UNLIKELY(state->argumentCount() < 1))
5097 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5098 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "imageDecodeCount", "HTMLImageElement"); });
5099 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5100 return JSValue::encode(toJS<IDLUnsignedLong>(impl.imageDecodeCount(*element)));
5101}
5102
5103EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageDecodeCount(ExecState* state)
5104{
5105 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionImageDecodeCountBody>(*state, "imageDecodeCount");
5106}
5107
5108static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPdfDocumentCachingCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5109{
5110 UNUSED_PARAM(state);
5111 UNUSED_PARAM(throwScope);
5112 auto& impl = castedThis->wrapped();
5113 if (UNLIKELY(state->argumentCount() < 1))
5114 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5115 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "pdfDocumentCachingCount", "HTMLImageElement"); });
5116 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5117 return JSValue::encode(toJS<IDLUnsignedLong>(impl.pdfDocumentCachingCount(*element)));
5118}
5119
5120EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPdfDocumentCachingCount(ExecState* state)
5121{
5122 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPdfDocumentCachingCountBody>(*state, "pdfDocumentCachingCount");
5123}
5124
5125static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTestingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5126{
5127 UNUSED_PARAM(state);
5128 UNUSED_PARAM(throwScope);
5129 auto& impl = castedThis->wrapped();
5130 if (UNLIKELY(state->argumentCount() < 2))
5131 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5132 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setLargeImageAsyncDecodingEnabledForTesting", "HTMLImageElement"); });
5133 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5134 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5135 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5136 impl.setLargeImageAsyncDecodingEnabledForTesting(*element, WTFMove(enabled));
5137 return JSValue::encode(jsUndefined());
5138}
5139
5140EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTesting(ExecState* state)
5141{
5142 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTestingBody>(*state, "setLargeImageAsyncDecodingEnabledForTesting");
5143}
5144
5145static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTestingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5146{
5147 UNUSED_PARAM(state);
5148 UNUSED_PARAM(throwScope);
5149 auto& impl = castedThis->wrapped();
5150 if (UNLIKELY(state->argumentCount() < 2))
5151 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5152 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setForceUpdateImageDataEnabledForTesting", "HTMLImageElement"); });
5153 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5154 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5155 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5156 impl.setForceUpdateImageDataEnabledForTesting(*element, WTFMove(enabled));
5157 return JSValue::encode(jsUndefined());
5158}
5159
5160EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTesting(ExecState* state)
5161{
5162 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTestingBody>(*state, "setForceUpdateImageDataEnabledForTesting");
5163}
5164
5165static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetGridMaxTracksLimitBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5166{
5167 UNUSED_PARAM(state);
5168 UNUSED_PARAM(throwScope);
5169 auto& impl = castedThis->wrapped();
5170 if (UNLIKELY(state->argumentCount() < 1))
5171 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5172 auto maxTracksLimit = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(0));
5173 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5174 impl.setGridMaxTracksLimit(WTFMove(maxTracksLimit));
5175 return JSValue::encode(jsUndefined());
5176}
5177
5178EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetGridMaxTracksLimit(ExecState* state)
5179{
5180 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetGridMaxTracksLimitBody>(*state, "setGridMaxTracksLimit");
5181}
5182
5183static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSVGAnimationsIntervalBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5184{
5185 UNUSED_PARAM(state);
5186 UNUSED_PARAM(throwScope);
5187 auto& impl = castedThis->wrapped();
5188 if (UNLIKELY(state->argumentCount() < 1))
5189 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5190 auto element = convert<IDLInterface<SVGSVGElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "svgAnimationsInterval", "SVGSVGElement"); });
5191 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5192 return JSValue::encode(toJS<IDLDouble>(*state, throwScope, impl.svgAnimationsInterval(*element)));
5193}
5194
5195EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSVGAnimationsInterval(ExecState* state)
5196{
5197 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSVGAnimationsIntervalBody>(*state, "svgAnimationsInterval");
5198}
5199
5200static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLayerTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5201{
5202 UNUSED_PARAM(state);
5203 UNUSED_PARAM(throwScope);
5204 auto& impl = castedThis->wrapped();
5205 if (UNLIKELY(state->argumentCount() < 1))
5206 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5207 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "layerTreeAsText", "Document"); });
5208 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5209 auto flags = convert<IDLUnsignedShort>(*state, state->argument(1));
5210 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5211 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.layerTreeAsText(*document, WTFMove(flags))));
5212}
5213
5214EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerTreeAsText(ExecState* state)
5215{
5216 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLayerTreeAsTextBody>(*state, "layerTreeAsText");
5217}
5218
5219static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLayerIDForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5220{
5221 UNUSED_PARAM(state);
5222 UNUSED_PARAM(throwScope);
5223 auto& impl = castedThis->wrapped();
5224 if (UNLIKELY(state->argumentCount() < 1))
5225 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5226 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "layerIDForElement", "Element"); });
5227 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5228 return JSValue::encode(toJS<IDLUnsignedLongLong>(*state, throwScope, impl.layerIDForElement(*element)));
5229}
5230
5231EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerIDForElement(ExecState* state)
5232{
5233 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLayerIDForElementBody>(*state, "layerIDForElement");
5234}
5235
5236static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollbarOverlayStyleBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5237{
5238 UNUSED_PARAM(state);
5239 UNUSED_PARAM(throwScope);
5240 auto& impl = castedThis->wrapped();
5241 auto node = convert<IDLNullable<IDLInterface<Node>>>(*state, state->argument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "scrollbarOverlayStyle", "Node"); });
5242 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5243 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.scrollbarOverlayStyle(WTFMove(node))));
5244}
5245
5246EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollbarOverlayStyle(ExecState* state)
5247{
5248 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollbarOverlayStyleBody>(*state, "scrollbarOverlayStyle");
5249}
5250
5251static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollbarUsingDarkAppearanceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5252{
5253 UNUSED_PARAM(state);
5254 UNUSED_PARAM(throwScope);
5255 auto& impl = castedThis->wrapped();
5256 auto node = convert<IDLNullable<IDLInterface<Node>>>(*state, state->argument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "scrollbarUsingDarkAppearance", "Node"); });
5257 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5258 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.scrollbarUsingDarkAppearance(WTFMove(node))));
5259}
5260
5261EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollbarUsingDarkAppearance(ExecState* state)
5262{
5263 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollbarUsingDarkAppearanceBody>(*state, "scrollbarUsingDarkAppearance");
5264}
5265
5266static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollingStateTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5267{
5268 UNUSED_PARAM(state);
5269 UNUSED_PARAM(throwScope);
5270 auto& impl = castedThis->wrapped();
5271 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.scrollingStateTreeAsText()));
5272}
5273
5274EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollingStateTreeAsText(ExecState* state)
5275{
5276 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollingStateTreeAsTextBody>(*state, "scrollingStateTreeAsText");
5277}
5278
5279static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMainThreadScrollingReasonsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5280{
5281 UNUSED_PARAM(state);
5282 UNUSED_PARAM(throwScope);
5283 auto& impl = castedThis->wrapped();
5284 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.mainThreadScrollingReasons()));
5285}
5286
5287EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMainThreadScrollingReasons(ExecState* state)
5288{
5289 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMainThreadScrollingReasonsBody>(*state, "mainThreadScrollingReasons");
5290}
5291
5292static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNonFastScrollableRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5293{
5294 UNUSED_PARAM(state);
5295 UNUSED_PARAM(throwScope);
5296 auto& impl = castedThis->wrapped();
5297 return JSValue::encode(toJS<IDLInterface<DOMRectList>>(*state, *castedThis->globalObject(), throwScope, impl.nonFastScrollableRects()));
5298}
5299
5300EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNonFastScrollableRects(ExecState* state)
5301{
5302 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNonFastScrollableRectsBody>(*state, "nonFastScrollableRects");
5303}
5304
5305static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRepaintRectsAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5306{
5307 UNUSED_PARAM(state);
5308 UNUSED_PARAM(throwScope);
5309 auto& impl = castedThis->wrapped();
5310 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.repaintRectsAsText()));
5311}
5312
5313EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRepaintRectsAsText(ExecState* state)
5314{
5315 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRepaintRectsAsTextBody>(*state, "repaintRectsAsText");
5316}
5317
5318static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5319{
5320 UNUSED_PARAM(state);
5321 UNUSED_PARAM(throwScope);
5322 auto& impl = castedThis->wrapped();
5323 if (UNLIKELY(state->argumentCount() < 2))
5324 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5325 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setElementUsesDisplayListDrawing", "Element"); });
5326 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5327 auto usesDisplayListDrawing = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5328 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5329 propagateException(*state, throwScope, impl.setElementUsesDisplayListDrawing(*element, WTFMove(usesDisplayListDrawing)));
5330 return JSValue::encode(jsUndefined());
5331}
5332
5333EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawing(ExecState* state)
5334{
5335 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawingBody>(*state, "setElementUsesDisplayListDrawing");
5336}
5337
5338static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetElementTracksDisplayListReplayBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5339{
5340 UNUSED_PARAM(state);
5341 UNUSED_PARAM(throwScope);
5342 auto& impl = castedThis->wrapped();
5343 if (UNLIKELY(state->argumentCount() < 2))
5344 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5345 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setElementTracksDisplayListReplay", "Element"); });
5346 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5347 auto trackReplay = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5348 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5349 propagateException(*state, throwScope, impl.setElementTracksDisplayListReplay(*element, WTFMove(trackReplay)));
5350 return JSValue::encode(jsUndefined());
5351}
5352
5353EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetElementTracksDisplayListReplay(ExecState* state)
5354{
5355 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetElementTracksDisplayListReplayBody>(*state, "setElementTracksDisplayListReplay");
5356}
5357
5358static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDisplayListForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5359{
5360 UNUSED_PARAM(state);
5361 UNUSED_PARAM(throwScope);
5362 auto& impl = castedThis->wrapped();
5363 if (UNLIKELY(state->argumentCount() < 1))
5364 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5365 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "displayListForElement", "Element"); });
5366 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5367 auto flags = convert<IDLUnsignedShort>(*state, state->argument(1));
5368 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5369 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.displayListForElement(*element, WTFMove(flags))));
5370}
5371
5372EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDisplayListForElement(ExecState* state)
5373{
5374 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDisplayListForElementBody>(*state, "displayListForElement");
5375}
5376
5377static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReplayDisplayListForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5378{
5379 UNUSED_PARAM(state);
5380 UNUSED_PARAM(throwScope);
5381 auto& impl = castedThis->wrapped();
5382 if (UNLIKELY(state->argumentCount() < 1))
5383 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5384 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "replayDisplayListForElement", "Element"); });
5385 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5386 auto flags = convert<IDLUnsignedShort>(*state, state->argument(1));
5387 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5388 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.replayDisplayListForElement(*element, WTFMove(flags))));
5389}
5390
5391EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReplayDisplayListForElement(ExecState* state)
5392{
5393 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReplayDisplayListForElementBody>(*state, "replayDisplayListForElement");
5394}
5395
5396static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGarbageCollectDocumentResourcesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5397{
5398 UNUSED_PARAM(state);
5399 UNUSED_PARAM(throwScope);
5400 auto& impl = castedThis->wrapped();
5401 propagateException(*state, throwScope, impl.garbageCollectDocumentResources());
5402 return JSValue::encode(jsUndefined());
5403}
5404
5405EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGarbageCollectDocumentResources(ExecState* state)
5406{
5407 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGarbageCollectDocumentResourcesBody>(*state, "garbageCollectDocumentResources");
5408}
5409
5410static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInsertAuthorCSSBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5411{
5412 UNUSED_PARAM(state);
5413 UNUSED_PARAM(throwScope);
5414 auto& impl = castedThis->wrapped();
5415 if (UNLIKELY(state->argumentCount() < 1))
5416 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5417 auto css = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
5418 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5419 propagateException(*state, throwScope, impl.insertAuthorCSS(WTFMove(css)));
5420 return JSValue::encode(jsUndefined());
5421}
5422
5423EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInsertAuthorCSS(ExecState* state)
5424{
5425 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInsertAuthorCSSBody>(*state, "insertAuthorCSS");
5426}
5427
5428static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInsertUserCSSBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5429{
5430 UNUSED_PARAM(state);
5431 UNUSED_PARAM(throwScope);
5432 auto& impl = castedThis->wrapped();
5433 if (UNLIKELY(state->argumentCount() < 1))
5434 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5435 auto css = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
5436 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5437 propagateException(*state, throwScope, impl.insertUserCSS(WTFMove(css)));
5438 return JSValue::encode(jsUndefined());
5439}
5440
5441EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInsertUserCSS(ExecState* state)
5442{
5443 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInsertUserCSSBody>(*state, "insertUserCSS");
5444}
5445
5446static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBeginSimulatedMemoryPressureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5447{
5448 UNUSED_PARAM(state);
5449 UNUSED_PARAM(throwScope);
5450 auto& impl = castedThis->wrapped();
5451 impl.beginSimulatedMemoryPressure();
5452 return JSValue::encode(jsUndefined());
5453}
5454
5455EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginSimulatedMemoryPressure(ExecState* state)
5456{
5457 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBeginSimulatedMemoryPressureBody>(*state, "beginSimulatedMemoryPressure");
5458}
5459
5460static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEndSimulatedMemoryPressureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5461{
5462 UNUSED_PARAM(state);
5463 UNUSED_PARAM(throwScope);
5464 auto& impl = castedThis->wrapped();
5465 impl.endSimulatedMemoryPressure();
5466 return JSValue::encode(jsUndefined());
5467}
5468
5469EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndSimulatedMemoryPressure(ExecState* state)
5470{
5471 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEndSimulatedMemoryPressureBody>(*state, "endSimulatedMemoryPressure");
5472}
5473
5474static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfIDBTransactionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5475{
5476 UNUSED_PARAM(state);
5477 UNUSED_PARAM(throwScope);
5478 auto& impl = castedThis->wrapped();
5479 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfIDBTransactions()));
5480}
5481
5482EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfIDBTransactions(ExecState* state)
5483{
5484 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfIDBTransactionsBody>(*state, "numberOfIDBTransactions");
5485}
5486
5487static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfLiveNodesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5488{
5489 UNUSED_PARAM(state);
5490 UNUSED_PARAM(throwScope);
5491 auto& impl = castedThis->wrapped();
5492 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfLiveNodes()));
5493}
5494
5495EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfLiveNodes(ExecState* state)
5496{
5497 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfLiveNodesBody>(*state, "numberOfLiveNodes");
5498}
5499
5500static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfLiveDocumentsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5501{
5502 UNUSED_PARAM(state);
5503 UNUSED_PARAM(throwScope);
5504 auto& impl = castedThis->wrapped();
5505 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfLiveDocuments()));
5506}
5507
5508EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfLiveDocuments(ExecState* state)
5509{
5510 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfLiveDocumentsBody>(*state, "numberOfLiveDocuments");
5511}
5512
5513static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReferencingNodeCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5514{
5515 UNUSED_PARAM(state);
5516 UNUSED_PARAM(throwScope);
5517 auto& impl = castedThis->wrapped();
5518 if (UNLIKELY(state->argumentCount() < 1))
5519 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5520 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "referencingNodeCount", "Document"); });
5521 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5522 return JSValue::encode(toJS<IDLUnsignedLong>(impl.referencingNodeCount(*document)));
5523}
5524
5525EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReferencingNodeCount(ExecState* state)
5526{
5527 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReferencingNodeCountBody>(*state, "referencingNodeCount");
5528}
5529
5530#if ENABLE(INTERSECTION_OBSERVER)
5531static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfIntersectionObserversBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5532{
5533 UNUSED_PARAM(state);
5534 UNUSED_PARAM(throwScope);
5535 auto& impl = castedThis->wrapped();
5536 if (UNLIKELY(state->argumentCount() < 1))
5537 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5538 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "numberOfIntersectionObservers", "Document"); });
5539 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5540 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfIntersectionObservers(*document)));
5541}
5542
5543EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfIntersectionObservers(ExecState* state)
5544{
5545 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfIntersectionObserversBody>(*state, "numberOfIntersectionObservers");
5546}
5547
5548#endif
5549
5550static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionOpenDummyInspectorFrontendBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5551{
5552 UNUSED_PARAM(state);
5553 UNUSED_PARAM(throwScope);
5554 auto& impl = castedThis->wrapped();
5555 if (UNLIKELY(state->argumentCount() < 1))
5556 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5557 auto url = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
5558 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5559 return JSValue::encode(toJS<IDLNullable<IDLInterface<WindowProxy>>>(*state, *castedThis->globalObject(), impl.openDummyInspectorFrontend(WTFMove(url))));
5560}
5561
5562EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionOpenDummyInspectorFrontend(ExecState* state)
5563{
5564 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionOpenDummyInspectorFrontendBody>(*state, "openDummyInspectorFrontend");
5565}
5566
5567static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCloseDummyInspectorFrontendBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5568{
5569 UNUSED_PARAM(state);
5570 UNUSED_PARAM(throwScope);
5571 auto& impl = castedThis->wrapped();
5572 impl.closeDummyInspectorFrontend();
5573 return JSValue::encode(jsUndefined());
5574}
5575
5576EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCloseDummyInspectorFrontend(ExecState* state)
5577{
5578 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCloseDummyInspectorFrontendBody>(*state, "closeDummyInspectorFrontend");
5579}
5580
5581static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetInspectorIsUnderTestBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5582{
5583 UNUSED_PARAM(state);
5584 UNUSED_PARAM(throwScope);
5585 auto& impl = castedThis->wrapped();
5586 if (UNLIKELY(state->argumentCount() < 1))
5587 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5588 auto isUnderTest = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
5589 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5590 propagateException(*state, throwScope, impl.setInspectorIsUnderTest(WTFMove(isUnderTest)));
5591 return JSValue::encode(jsUndefined());
5592}
5593
5594EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetInspectorIsUnderTest(ExecState* state)
5595{
5596 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetInspectorIsUnderTestBody>(*state, "setInspectorIsUnderTest");
5597}
5598
5599static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCounterValueBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5600{
5601 UNUSED_PARAM(state);
5602 UNUSED_PARAM(throwScope);
5603 auto& impl = castedThis->wrapped();
5604 if (UNLIKELY(state->argumentCount() < 1))
5605 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5606 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "counterValue", "Element"); });
5607 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5608 return JSValue::encode(toJS<IDLDOMString>(*state, impl.counterValue(*element)));
5609}
5610
5611EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCounterValue(ExecState* state)
5612{
5613 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCounterValueBody>(*state, "counterValue");
5614}
5615
5616static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageNumberBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5617{
5618 UNUSED_PARAM(state);
5619 UNUSED_PARAM(throwScope);
5620 auto& impl = castedThis->wrapped();
5621 if (UNLIKELY(state->argumentCount() < 1))
5622 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5623 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "pageNumber", "Element"); });
5624 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5625 auto pageWidth = state->argument(1).isUndefined() ? 800 : convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(1));
5626 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5627 auto pageHeight = state->argument(2).isUndefined() ? 600 : convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(2));
5628 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5629 return JSValue::encode(toJS<IDLLong>(impl.pageNumber(*element, WTFMove(pageWidth), WTFMove(pageHeight))));
5630}
5631
5632EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageNumber(ExecState* state)
5633{
5634 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageNumberBody>(*state, "pageNumber");
5635}
5636
5637static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionShortcutIconURLsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5638{
5639 UNUSED_PARAM(state);
5640 UNUSED_PARAM(throwScope);
5641 auto& impl = castedThis->wrapped();
5642 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.shortcutIconURLs()));
5643}
5644
5645EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShortcutIconURLs(ExecState* state)
5646{
5647 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionShortcutIconURLsBody>(*state, "shortcutIconURLs");
5648}
5649
5650static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfPagesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5651{
5652 UNUSED_PARAM(state);
5653 UNUSED_PARAM(throwScope);
5654 auto& impl = castedThis->wrapped();
5655 auto pageWidthInPixels = state->argument(0).isUndefined() ? 800 : convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(0));
5656 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5657 auto pageHeightInPixels = state->argument(1).isUndefined() ? 600 : convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
5658 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5659 return JSValue::encode(toJS<IDLLong>(impl.numberOfPages(WTFMove(pageWidthInPixels), WTFMove(pageHeightInPixels))));
5660}
5661
5662EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfPages(ExecState* state)
5663{
5664 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfPagesBody>(*state, "numberOfPages");
5665}
5666
5667static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPagePropertyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5668{
5669 UNUSED_PARAM(state);
5670 UNUSED_PARAM(throwScope);
5671 auto& impl = castedThis->wrapped();
5672 if (UNLIKELY(state->argumentCount() < 2))
5673 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5674 auto propertyName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
5675 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5676 auto pageNumber = convert<IDLLong>(*state, state->uncheckedArgument(1));
5677 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5678 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.pageProperty(WTFMove(propertyName), WTFMove(pageNumber))));
5679}
5680
5681EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageProperty(ExecState* state)
5682{
5683 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPagePropertyBody>(*state, "pageProperty");
5684}
5685
5686static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageSizeAndMarginsInPixelsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5687{
5688 UNUSED_PARAM(state);
5689 UNUSED_PARAM(throwScope);
5690 auto& impl = castedThis->wrapped();
5691 if (UNLIKELY(state->argumentCount() < 7))
5692 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5693 auto pageIndex = convert<IDLLong>(*state, state->uncheckedArgument(0));
5694 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5695 auto width = convert<IDLLong>(*state, state->uncheckedArgument(1));
5696 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5697 auto height = convert<IDLLong>(*state, state->uncheckedArgument(2));
5698 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5699 auto marginTop = convert<IDLLong>(*state, state->uncheckedArgument(3));
5700 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5701 auto marginRight = convert<IDLLong>(*state, state->uncheckedArgument(4));
5702 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5703 auto marginBottom = convert<IDLLong>(*state, state->uncheckedArgument(5));
5704 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5705 auto marginLeft = convert<IDLLong>(*state, state->uncheckedArgument(6));
5706 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5707 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.pageSizeAndMarginsInPixels(WTFMove(pageIndex), WTFMove(width), WTFMove(height), WTFMove(marginTop), WTFMove(marginRight), WTFMove(marginBottom), WTFMove(marginLeft))));
5708}
5709
5710EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageSizeAndMarginsInPixels(ExecState* state)
5711{
5712 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageSizeAndMarginsInPixelsBody>(*state, "pageSizeAndMarginsInPixels");
5713}
5714
5715static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageScaleFactorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5716{
5717 UNUSED_PARAM(state);
5718 UNUSED_PARAM(throwScope);
5719 auto& impl = castedThis->wrapped();
5720 if (UNLIKELY(state->argumentCount() < 3))
5721 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5722 auto scaleFactor = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5723 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5724 auto x = convert<IDLLong>(*state, state->uncheckedArgument(1));
5725 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5726 auto y = convert<IDLLong>(*state, state->uncheckedArgument(2));
5727 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5728 propagateException(*state, throwScope, impl.setPageScaleFactor(WTFMove(scaleFactor), WTFMove(x), WTFMove(y)));
5729 return JSValue::encode(jsUndefined());
5730}
5731
5732EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageScaleFactor(ExecState* state)
5733{
5734 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageScaleFactorBody>(*state, "setPageScaleFactor");
5735}
5736
5737static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageScaleFactorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5738{
5739 UNUSED_PARAM(state);
5740 UNUSED_PARAM(throwScope);
5741 auto& impl = castedThis->wrapped();
5742 return JSValue::encode(toJS<IDLFloat>(*state, throwScope, impl.pageScaleFactor()));
5743}
5744
5745EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageScaleFactor(ExecState* state)
5746{
5747 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageScaleFactorBody>(*state, "pageScaleFactor");
5748}
5749
5750static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageZoomFactorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5751{
5752 UNUSED_PARAM(state);
5753 UNUSED_PARAM(throwScope);
5754 auto& impl = castedThis->wrapped();
5755 if (UNLIKELY(state->argumentCount() < 1))
5756 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5757 auto zoomFactor = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5758 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5759 propagateException(*state, throwScope, impl.setPageZoomFactor(WTFMove(zoomFactor)));
5760 return JSValue::encode(jsUndefined());
5761}
5762
5763EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageZoomFactor(ExecState* state)
5764{
5765 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageZoomFactorBody>(*state, "setPageZoomFactor");
5766}
5767
5768static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetTextZoomFactorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5769{
5770 UNUSED_PARAM(state);
5771 UNUSED_PARAM(throwScope);
5772 auto& impl = castedThis->wrapped();
5773 if (UNLIKELY(state->argumentCount() < 1))
5774 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5775 auto zoomFactor = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5776 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5777 propagateException(*state, throwScope, impl.setTextZoomFactor(WTFMove(zoomFactor)));
5778 return JSValue::encode(jsUndefined());
5779}
5780
5781EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetTextZoomFactor(ExecState* state)
5782{
5783 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetTextZoomFactorBody>(*state, "setTextZoomFactor");
5784}
5785
5786static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUseFixedLayoutBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5787{
5788 UNUSED_PARAM(state);
5789 UNUSED_PARAM(throwScope);
5790 auto& impl = castedThis->wrapped();
5791 if (UNLIKELY(state->argumentCount() < 1))
5792 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5793 auto useFixedLayout = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
5794 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5795 propagateException(*state, throwScope, impl.setUseFixedLayout(WTFMove(useFixedLayout)));
5796 return JSValue::encode(jsUndefined());
5797}
5798
5799EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUseFixedLayout(ExecState* state)
5800{
5801 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUseFixedLayoutBody>(*state, "setUseFixedLayout");
5802}
5803
5804static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFixedLayoutSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5805{
5806 UNUSED_PARAM(state);
5807 UNUSED_PARAM(throwScope);
5808 auto& impl = castedThis->wrapped();
5809 if (UNLIKELY(state->argumentCount() < 2))
5810 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5811 auto width = convert<IDLLong>(*state, state->uncheckedArgument(0));
5812 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5813 auto height = convert<IDLLong>(*state, state->uncheckedArgument(1));
5814 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5815 propagateException(*state, throwScope, impl.setFixedLayoutSize(WTFMove(width), WTFMove(height)));
5816 return JSValue::encode(jsUndefined());
5817}
5818
5819EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFixedLayoutSize(ExecState* state)
5820{
5821 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFixedLayoutSizeBody>(*state, "setFixedLayoutSize");
5822}
5823
5824static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPrintingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5825{
5826 UNUSED_PARAM(state);
5827 UNUSED_PARAM(throwScope);
5828 auto& impl = castedThis->wrapped();
5829 if (UNLIKELY(state->argumentCount() < 2))
5830 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5831 auto width = convert<IDLLong>(*state, state->uncheckedArgument(0));
5832 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5833 auto height = convert<IDLLong>(*state, state->uncheckedArgument(1));
5834 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5835 impl.setPrinting(WTFMove(width), WTFMove(height));
5836 return JSValue::encode(jsUndefined());
5837}
5838
5839EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPrinting(ExecState* state)
5840{
5841 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPrintingBody>(*state, "setPrinting");
5842}
5843
5844static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetViewExposedRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5845{
5846 UNUSED_PARAM(state);
5847 UNUSED_PARAM(throwScope);
5848 auto& impl = castedThis->wrapped();
5849 if (UNLIKELY(state->argumentCount() < 4))
5850 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5851 auto x = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5852 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5853 auto y = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(1));
5854 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5855 auto width = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(2));
5856 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5857 auto height = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(3));
5858 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5859 propagateException(*state, throwScope, impl.setViewExposedRect(WTFMove(x), WTFMove(y), WTFMove(width), WTFMove(height)));
5860 return JSValue::encode(jsUndefined());
5861}
5862
5863EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewExposedRect(ExecState* state)
5864{
5865 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetViewExposedRectBody>(*state, "setViewExposedRect");
5866}
5867
5868static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetHeaderHeightBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5869{
5870 UNUSED_PARAM(state);
5871 UNUSED_PARAM(throwScope);
5872 auto& impl = castedThis->wrapped();
5873 if (UNLIKELY(state->argumentCount() < 1))
5874 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5875 auto height = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5876 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5877 impl.setHeaderHeight(WTFMove(height));
5878 return JSValue::encode(jsUndefined());
5879}
5880
5881EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetHeaderHeight(ExecState* state)
5882{
5883 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetHeaderHeightBody>(*state, "setHeaderHeight");
5884}
5885
5886static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFooterHeightBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5887{
5888 UNUSED_PARAM(state);
5889 UNUSED_PARAM(throwScope);
5890 auto& impl = castedThis->wrapped();
5891 if (UNLIKELY(state->argumentCount() < 1))
5892 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5893 auto height = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5894 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5895 impl.setFooterHeight(WTFMove(height));
5896 return JSValue::encode(jsUndefined());
5897}
5898
5899EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFooterHeight(ExecState* state)
5900{
5901 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFooterHeightBody>(*state, "setFooterHeight");
5902}
5903
5904static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetTopContentInsetBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5905{
5906 UNUSED_PARAM(state);
5907 UNUSED_PARAM(throwScope);
5908 auto& impl = castedThis->wrapped();
5909 if (UNLIKELY(state->argumentCount() < 1))
5910 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5911 auto contentInset = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5912 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5913 impl.setTopContentInset(WTFMove(contentInset));
5914 return JSValue::encode(jsUndefined());
5915}
5916
5917EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetTopContentInset(ExecState* state)
5918{
5919 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetTopContentInsetBody>(*state, "setTopContentInset");
5920}
5921
5922#if ENABLE(FULLSCREEN_API)
5923static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5924{
5925 UNUSED_PARAM(state);
5926 UNUSED_PARAM(throwScope);
5927 auto& impl = castedThis->wrapped();
5928 if (UNLIKELY(state->argumentCount() < 1))
5929 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5930 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "webkitWillEnterFullScreenForElement", "Element"); });
5931 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5932 impl.webkitWillEnterFullScreenForElement(*element);
5933 return JSValue::encode(jsUndefined());
5934}
5935
5936EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElement(ExecState* state)
5937{
5938 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElementBody>(*state, "webkitWillEnterFullScreenForElement");
5939}
5940
5941#endif
5942
5943#if ENABLE(FULLSCREEN_API)
5944static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5945{
5946 UNUSED_PARAM(state);
5947 UNUSED_PARAM(throwScope);
5948 auto& impl = castedThis->wrapped();
5949 if (UNLIKELY(state->argumentCount() < 1))
5950 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5951 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "webkitDidEnterFullScreenForElement", "Element"); });
5952 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5953 impl.webkitDidEnterFullScreenForElement(*element);
5954 return JSValue::encode(jsUndefined());
5955}
5956
5957EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElement(ExecState* state)
5958{
5959 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElementBody>(*state, "webkitDidEnterFullScreenForElement");
5960}
5961
5962#endif
5963
5964#if ENABLE(FULLSCREEN_API)
5965static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5966{
5967 UNUSED_PARAM(state);
5968 UNUSED_PARAM(throwScope);
5969 auto& impl = castedThis->wrapped();
5970 if (UNLIKELY(state->argumentCount() < 1))
5971 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5972 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "webkitWillExitFullScreenForElement", "Element"); });
5973 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5974 impl.webkitWillExitFullScreenForElement(*element);
5975 return JSValue::encode(jsUndefined());
5976}
5977
5978EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElement(ExecState* state)
5979{
5980 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElementBody>(*state, "webkitWillExitFullScreenForElement");
5981}
5982
5983#endif
5984
5985#if ENABLE(FULLSCREEN_API)
5986static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5987{
5988 UNUSED_PARAM(state);
5989 UNUSED_PARAM(throwScope);
5990 auto& impl = castedThis->wrapped();
5991 if (UNLIKELY(state->argumentCount() < 1))
5992 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5993 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "webkitDidExitFullScreenForElement", "Element"); });
5994 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5995 impl.webkitDidExitFullScreenForElement(*element);
5996 return JSValue::encode(jsUndefined());
5997}
5998
5999EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElement(ExecState* state)
6000{
6001 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElementBody>(*state, "webkitDidExitFullScreenForElement");
6002}
6003
6004#endif
6005
6006static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFullscreenInsetsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6007{
6008 UNUSED_PARAM(state);
6009 UNUSED_PARAM(throwScope);
6010 auto& impl = castedThis->wrapped();
6011 if (UNLIKELY(state->argumentCount() < 1))
6012 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6013 auto insets = convert<IDLDictionary<Internals::FullscreenInsets>>(*state, state->uncheckedArgument(0));
6014 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6015 impl.setFullscreenInsets(WTFMove(insets));
6016 return JSValue::encode(jsUndefined());
6017}
6018
6019EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenInsets(ExecState* state)
6020{
6021 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFullscreenInsetsBody>(*state, "setFullscreenInsets");
6022}
6023
6024static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFullscreenAutoHideDurationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6025{
6026 UNUSED_PARAM(state);
6027 UNUSED_PARAM(throwScope);
6028 auto& impl = castedThis->wrapped();
6029 if (UNLIKELY(state->argumentCount() < 1))
6030 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6031 auto duration = convert<IDLDouble>(*state, state->uncheckedArgument(0));
6032 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6033 impl.setFullscreenAutoHideDuration(WTFMove(duration));
6034 return JSValue::encode(jsUndefined());
6035}
6036
6037EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenAutoHideDuration(ExecState* state)
6038{
6039 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFullscreenAutoHideDurationBody>(*state, "setFullscreenAutoHideDuration");
6040}
6041
6042static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFullscreenControlsHiddenBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6043{
6044 UNUSED_PARAM(state);
6045 UNUSED_PARAM(throwScope);
6046 auto& impl = castedThis->wrapped();
6047 if (UNLIKELY(state->argumentCount() < 1))
6048 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6049 auto hidden = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6050 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6051 impl.setFullscreenControlsHidden(WTFMove(hidden));
6052 return JSValue::encode(jsUndefined());
6053}
6054
6055EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenControlsHidden(ExecState* state)
6056{
6057 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFullscreenControlsHiddenBody>(*state, "setFullscreenControlsHidden");
6058}
6059
6060static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetApplicationCacheOriginQuotaBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6061{
6062 UNUSED_PARAM(state);
6063 UNUSED_PARAM(throwScope);
6064 auto& impl = castedThis->wrapped();
6065 if (UNLIKELY(state->argumentCount() < 1))
6066 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6067 auto quota = convert<IDLUnsignedLongLong>(*state, state->uncheckedArgument(0));
6068 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6069 impl.setApplicationCacheOriginQuota(WTFMove(quota));
6070 return JSValue::encode(jsUndefined());
6071}
6072
6073EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetApplicationCacheOriginQuota(ExecState* state)
6074{
6075 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetApplicationCacheOriginQuotaBody>(*state, "setApplicationCacheOriginQuota");
6076}
6077
6078static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6079{
6080 UNUSED_PARAM(state);
6081 UNUSED_PARAM(throwScope);
6082 auto& impl = castedThis->wrapped();
6083 if (UNLIKELY(state->argumentCount() < 1))
6084 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6085 auto scheme = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6086 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6087 impl.registerURLSchemeAsBypassingContentSecurityPolicy(WTFMove(scheme));
6088 return JSValue::encode(jsUndefined());
6089}
6090
6091EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicy(ExecState* state)
6092{
6093 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicyBody>(*state, "registerURLSchemeAsBypassingContentSecurityPolicy");
6094}
6095
6096static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6097{
6098 UNUSED_PARAM(state);
6099 UNUSED_PARAM(throwScope);
6100 auto& impl = castedThis->wrapped();
6101 if (UNLIKELY(state->argumentCount() < 1))
6102 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6103 auto scheme = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6104 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6105 impl.removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(WTFMove(scheme));
6106 return JSValue::encode(jsUndefined());
6107}
6108
6109EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicy(ExecState* state)
6110{
6111 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicyBody>(*state, "removeURLSchemeRegisteredAsBypassingContentSecurityPolicy");
6112}
6113
6114static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRegisterDefaultPortForProtocolBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6115{
6116 UNUSED_PARAM(state);
6117 UNUSED_PARAM(throwScope);
6118 auto& impl = castedThis->wrapped();
6119 if (UNLIKELY(state->argumentCount() < 2))
6120 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6121 auto port = convert<IDLUnsignedShort>(*state, state->uncheckedArgument(0));
6122 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6123 auto scheme = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
6124 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6125 impl.registerDefaultPortForProtocol(WTFMove(port), WTFMove(scheme));
6126 return JSValue::encode(jsUndefined());
6127}
6128
6129EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterDefaultPortForProtocol(ExecState* state)
6130{
6131 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRegisterDefaultPortForProtocolBody>(*state, "registerDefaultPortForProtocol");
6132}
6133
6134static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMallocStatisticsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6135{
6136 UNUSED_PARAM(state);
6137 UNUSED_PARAM(throwScope);
6138 auto& impl = castedThis->wrapped();
6139 return JSValue::encode(toJS<IDLInterface<MallocStatistics>>(*state, *castedThis->globalObject(), impl.mallocStatistics()));
6140}
6141
6142EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMallocStatistics(ExecState* state)
6143{
6144 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMallocStatisticsBody>(*state, "mallocStatistics");
6145}
6146
6147static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTypeConversionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6148{
6149 UNUSED_PARAM(state);
6150 UNUSED_PARAM(throwScope);
6151 auto& impl = castedThis->wrapped();
6152 return JSValue::encode(toJS<IDLInterface<TypeConversions>>(*state, *castedThis->globalObject(), impl.typeConversions()));
6153}
6154
6155EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTypeConversions(ExecState* state)
6156{
6157 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTypeConversionsBody>(*state, "typeConversions");
6158}
6159
6160static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMemoryInfoBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6161{
6162 UNUSED_PARAM(state);
6163 UNUSED_PARAM(throwScope);
6164 auto& impl = castedThis->wrapped();
6165 return JSValue::encode(toJS<IDLInterface<MemoryInfo>>(*state, *castedThis->globalObject(), impl.memoryInfo()));
6166}
6167
6168EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMemoryInfo(ExecState* state)
6169{
6170 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMemoryInfoBody>(*state, "memoryInfo");
6171}
6172
6173static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetReferencedFilePathsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6174{
6175 UNUSED_PARAM(state);
6176 UNUSED_PARAM(throwScope);
6177 auto& impl = castedThis->wrapped();
6178 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.getReferencedFilePaths()));
6179}
6180
6181EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetReferencedFilePaths(ExecState* state)
6182{
6183 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetReferencedFilePathsBody>(*state, "getReferencedFilePaths");
6184}
6185
6186static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStartTrackingRepaintsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6187{
6188 UNUSED_PARAM(state);
6189 UNUSED_PARAM(throwScope);
6190 auto& impl = castedThis->wrapped();
6191 propagateException(*state, throwScope, impl.startTrackingRepaints());
6192 return JSValue::encode(jsUndefined());
6193}
6194
6195EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingRepaints(ExecState* state)
6196{
6197 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStartTrackingRepaintsBody>(*state, "startTrackingRepaints");
6198}
6199
6200static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStopTrackingRepaintsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6201{
6202 UNUSED_PARAM(state);
6203 UNUSED_PARAM(throwScope);
6204 auto& impl = castedThis->wrapped();
6205 propagateException(*state, throwScope, impl.stopTrackingRepaints());
6206 return JSValue::encode(jsUndefined());
6207}
6208
6209EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStopTrackingRepaints(ExecState* state)
6210{
6211 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStopTrackingRepaintsBody>(*state, "stopTrackingRepaints");
6212}
6213
6214static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStartTrackingLayerFlushesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6215{
6216 UNUSED_PARAM(state);
6217 UNUSED_PARAM(throwScope);
6218 auto& impl = castedThis->wrapped();
6219 propagateException(*state, throwScope, impl.startTrackingLayerFlushes());
6220 return JSValue::encode(jsUndefined());
6221}
6222
6223EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingLayerFlushes(ExecState* state)
6224{
6225 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStartTrackingLayerFlushesBody>(*state, "startTrackingLayerFlushes");
6226}
6227
6228static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLayerFlushCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6229{
6230 UNUSED_PARAM(state);
6231 UNUSED_PARAM(throwScope);
6232 auto& impl = castedThis->wrapped();
6233 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.layerFlushCount()));
6234}
6235
6236EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerFlushCount(ExecState* state)
6237{
6238 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLayerFlushCountBody>(*state, "layerFlushCount");
6239}
6240
6241static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsTimerThrottledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6242{
6243 UNUSED_PARAM(state);
6244 UNUSED_PARAM(throwScope);
6245 auto& impl = castedThis->wrapped();
6246 if (UNLIKELY(state->argumentCount() < 1))
6247 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6248 auto timerHandle = convert<IDLLong>(*state, state->uncheckedArgument(0));
6249 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6250 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.isTimerThrottled(WTFMove(timerHandle))));
6251}
6252
6253EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsTimerThrottled(ExecState* state)
6254{
6255 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsTimerThrottledBody>(*state, "isTimerThrottled");
6256}
6257
6258static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6259{
6260 UNUSED_PARAM(state);
6261 UNUSED_PARAM(throwScope);
6262 auto& impl = castedThis->wrapped();
6263 return JSValue::encode(toJS<IDLBoolean>(impl.isRequestAnimationFrameThrottled()));
6264}
6265
6266EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottled(ExecState* state)
6267{
6268 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottledBody>(*state, "isRequestAnimationFrameThrottled");
6269}
6270
6271static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAreTimersThrottledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6272{
6273 UNUSED_PARAM(state);
6274 UNUSED_PARAM(throwScope);
6275 auto& impl = castedThis->wrapped();
6276 return JSValue::encode(toJS<IDLBoolean>(impl.areTimersThrottled()));
6277}
6278
6279EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAreTimersThrottled(ExecState* state)
6280{
6281 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAreTimersThrottledBody>(*state, "areTimersThrottled");
6282}
6283
6284static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetLowPowerModeEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6285{
6286 UNUSED_PARAM(state);
6287 UNUSED_PARAM(throwScope);
6288 auto& impl = castedThis->wrapped();
6289 if (UNLIKELY(state->argumentCount() < 1))
6290 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6291 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6292 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6293 propagateException(*state, throwScope, impl.setLowPowerModeEnabled(WTFMove(enabled)));
6294 return JSValue::encode(jsUndefined());
6295}
6296
6297EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetLowPowerModeEnabled(ExecState* state)
6298{
6299 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetLowPowerModeEnabledBody>(*state, "setLowPowerModeEnabled");
6300}
6301
6302static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStartTrackingStyleRecalcsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6303{
6304 UNUSED_PARAM(state);
6305 UNUSED_PARAM(throwScope);
6306 auto& impl = castedThis->wrapped();
6307 propagateException(*state, throwScope, impl.startTrackingStyleRecalcs());
6308 return JSValue::encode(jsUndefined());
6309}
6310
6311EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingStyleRecalcs(ExecState* state)
6312{
6313 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStartTrackingStyleRecalcsBody>(*state, "startTrackingStyleRecalcs");
6314}
6315
6316static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStyleRecalcCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6317{
6318 UNUSED_PARAM(state);
6319 UNUSED_PARAM(throwScope);
6320 auto& impl = castedThis->wrapped();
6321 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.styleRecalcCount()));
6322}
6323
6324EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStyleRecalcCount(ExecState* state)
6325{
6326 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStyleRecalcCountBody>(*state, "styleRecalcCount");
6327}
6328
6329static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStartTrackingCompositingUpdatesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6330{
6331 UNUSED_PARAM(state);
6332 UNUSED_PARAM(throwScope);
6333 auto& impl = castedThis->wrapped();
6334 propagateException(*state, throwScope, impl.startTrackingCompositingUpdates());
6335 return JSValue::encode(jsUndefined());
6336}
6337
6338EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingCompositingUpdates(ExecState* state)
6339{
6340 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStartTrackingCompositingUpdatesBody>(*state, "startTrackingCompositingUpdates");
6341}
6342
6343static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCompositingUpdateCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6344{
6345 UNUSED_PARAM(state);
6346 UNUSED_PARAM(throwScope);
6347 auto& impl = castedThis->wrapped();
6348 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.compositingUpdateCount()));
6349}
6350
6351EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCompositingUpdateCount(ExecState* state)
6352{
6353 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCompositingUpdateCountBody>(*state, "compositingUpdateCount");
6354}
6355
6356static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasksBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6357{
6358 UNUSED_PARAM(state);
6359 UNUSED_PARAM(throwScope);
6360 auto& impl = castedThis->wrapped();
6361 auto node = convert<IDLNullable<IDLInterface<Node>>>(*state, state->argument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks", "Node"); });
6362 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6363 propagateException(*state, throwScope, impl.updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(WTFMove(node)));
6364 return JSValue::encode(jsUndefined());
6365}
6366
6367EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(ExecState* state)
6368{
6369 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasksBody>(*state, "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks");
6370}
6371
6372static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetCurrentCursorInfoBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6373{
6374 UNUSED_PARAM(state);
6375 UNUSED_PARAM(throwScope);
6376 auto& impl = castedThis->wrapped();
6377 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.getCurrentCursorInfo()));
6378}
6379
6380EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCurrentCursorInfo(ExecState* state)
6381{
6382 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetCurrentCursorInfoBody>(*state, "getCurrentCursorInfo");
6383}
6384
6385static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkerTextForListItemBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6386{
6387 UNUSED_PARAM(state);
6388 UNUSED_PARAM(throwScope);
6389 auto& impl = castedThis->wrapped();
6390 if (UNLIKELY(state->argumentCount() < 1))
6391 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6392 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "markerTextForListItem", "Element"); });
6393 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6394 return JSValue::encode(toJS<IDLDOMString>(*state, impl.markerTextForListItem(*element)));
6395}
6396
6397EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerTextForListItem(ExecState* state)
6398{
6399 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkerTextForListItemBody>(*state, "markerTextForListItem");
6400}
6401
6402static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionToolTipFromElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6403{
6404 UNUSED_PARAM(state);
6405 UNUSED_PARAM(throwScope);
6406 auto& impl = castedThis->wrapped();
6407 if (UNLIKELY(state->argumentCount() < 1))
6408 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6409 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "toolTipFromElement", "Element"); });
6410 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6411 return JSValue::encode(toJS<IDLDOMString>(*state, impl.toolTipFromElement(*element)));
6412}
6413
6414EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionToolTipFromElement(ExecState* state)
6415{
6416 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionToolTipFromElementBody>(*state, "toolTipFromElement");
6417}
6418
6419static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDeserializeBufferBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6420{
6421 UNUSED_PARAM(state);
6422 UNUSED_PARAM(throwScope);
6423 auto& impl = castedThis->wrapped();
6424 if (UNLIKELY(state->argumentCount() < 1))
6425 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6426 auto buffer = convert<IDLArrayBuffer>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "buffer", "Internals", "deserializeBuffer", "ArrayBuffer"); });
6427 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6428 return JSValue::encode(toJS<IDLSerializedScriptValue<SerializedScriptValue>>(*state, *castedThis->globalObject(), impl.deserializeBuffer(*buffer)));
6429}
6430
6431EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeserializeBuffer(ExecState* state)
6432{
6433 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDeserializeBufferBody>(*state, "deserializeBuffer");
6434}
6435
6436static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSerializeObjectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6437{
6438 UNUSED_PARAM(state);
6439 UNUSED_PARAM(throwScope);
6440 auto& impl = castedThis->wrapped();
6441 if (UNLIKELY(state->argumentCount() < 1))
6442 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6443 auto object = convert<IDLSerializedScriptValue<SerializedScriptValue>>(*state, state->uncheckedArgument(0));
6444 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6445 return JSValue::encode(toJS<IDLArrayBuffer>(*state, *castedThis->globalObject(), impl.serializeObject(WTFMove(object))));
6446}
6447
6448EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSerializeObject(ExecState* state)
6449{
6450 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSerializeObjectBody>(*state, "serializeObject");
6451}
6452
6453static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsFromCurrentWorldBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6454{
6455 UNUSED_PARAM(state);
6456 UNUSED_PARAM(throwScope);
6457 auto& impl = castedThis->wrapped();
6458 if (UNLIKELY(state->argumentCount() < 1))
6459 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6460 auto obj = convert<IDLAny>(*state, state->uncheckedArgument(0));
6461 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6462 return JSValue::encode(toJS<IDLBoolean>(impl.isFromCurrentWorld(WTFMove(obj))));
6463}
6464
6465EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsFromCurrentWorld(ExecState* state)
6466{
6467 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsFromCurrentWorldBody>(*state, "isFromCurrentWorld");
6468}
6469
6470static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUsesOverlayScrollbarsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6471{
6472 UNUSED_PARAM(state);
6473 UNUSED_PARAM(throwScope);
6474 auto& impl = castedThis->wrapped();
6475 if (UNLIKELY(state->argumentCount() < 1))
6476 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6477 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6478 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6479 impl.setUsesOverlayScrollbars(WTFMove(enabled));
6480 return JSValue::encode(jsUndefined());
6481}
6482
6483EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUsesOverlayScrollbars(ExecState* state)
6484{
6485 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUsesOverlayScrollbarsBody>(*state, "setUsesOverlayScrollbars");
6486}
6487
6488static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUsesMockScrollAnimatorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6489{
6490 UNUSED_PARAM(state);
6491 UNUSED_PARAM(throwScope);
6492 auto& impl = castedThis->wrapped();
6493 if (UNLIKELY(state->argumentCount() < 1))
6494 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6495 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6496 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6497 impl.setUsesMockScrollAnimator(WTFMove(enabled));
6498 return JSValue::encode(jsUndefined());
6499}
6500
6501EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUsesMockScrollAnimator(ExecState* state)
6502{
6503 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUsesMockScrollAnimatorBody>(*state, "setUsesMockScrollAnimator");
6504}
6505
6506static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionForceReloadBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6507{
6508 UNUSED_PARAM(state);
6509 UNUSED_PARAM(throwScope);
6510 auto& impl = castedThis->wrapped();
6511 if (UNLIKELY(state->argumentCount() < 1))
6512 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6513 auto endToEnd = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6514 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6515 impl.forceReload(WTFMove(endToEnd));
6516 return JSValue::encode(jsUndefined());
6517}
6518
6519EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionForceReload(ExecState* state)
6520{
6521 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionForceReloadBody>(*state, "forceReload");
6522}
6523
6524static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReloadExpiredOnlyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6525{
6526 UNUSED_PARAM(state);
6527 UNUSED_PARAM(throwScope);
6528 auto& impl = castedThis->wrapped();
6529 impl.reloadExpiredOnly();
6530 return JSValue::encode(jsUndefined());
6531}
6532
6533EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReloadExpiredOnly(ExecState* state)
6534{
6535 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReloadExpiredOnlyBody>(*state, "reloadExpiredOnly");
6536}
6537
6538static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnableAutoSizeModeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6539{
6540 UNUSED_PARAM(state);
6541 UNUSED_PARAM(throwScope);
6542 auto& impl = castedThis->wrapped();
6543 if (UNLIKELY(state->argumentCount() < 3))
6544 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6545 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6546 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6547 auto width = convert<IDLLong>(*state, state->uncheckedArgument(1));
6548 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6549 auto height = convert<IDLLong>(*state, state->uncheckedArgument(2));
6550 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6551 impl.enableAutoSizeMode(WTFMove(enabled), WTFMove(width), WTFMove(height));
6552 return JSValue::encode(jsUndefined());
6553}
6554
6555EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableAutoSizeMode(ExecState* state)
6556{
6557 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnableAutoSizeModeBody>(*state, "enableAutoSizeMode");
6558}
6559
6560#if ENABLE(VIDEO)
6561static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaResponseSourcesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6562{
6563 UNUSED_PARAM(state);
6564 UNUSED_PARAM(throwScope);
6565 auto& impl = castedThis->wrapped();
6566 if (UNLIKELY(state->argumentCount() < 1))
6567 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6568 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "mediaResponseSources", "HTMLMediaElement"); });
6569 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6570 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.mediaResponseSources(*media)));
6571}
6572
6573EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaResponseSources(ExecState* state)
6574{
6575 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaResponseSourcesBody>(*state, "mediaResponseSources");
6576}
6577
6578#endif
6579
6580#if ENABLE(VIDEO)
6581static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaResponseContentRangesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6582{
6583 UNUSED_PARAM(state);
6584 UNUSED_PARAM(throwScope);
6585 auto& impl = castedThis->wrapped();
6586 if (UNLIKELY(state->argumentCount() < 1))
6587 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6588 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "mediaResponseContentRanges", "HTMLMediaElement"); });
6589 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6590 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.mediaResponseContentRanges(*media)));
6591}
6592
6593EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaResponseContentRanges(ExecState* state)
6594{
6595 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaResponseContentRangesBody>(*state, "mediaResponseContentRanges");
6596}
6597
6598#endif
6599
6600#if ENABLE(VIDEO)
6601static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateAudioInterruptionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6602{
6603 UNUSED_PARAM(state);
6604 UNUSED_PARAM(throwScope);
6605 auto& impl = castedThis->wrapped();
6606 if (UNLIKELY(state->argumentCount() < 1))
6607 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6608 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "simulateAudioInterruption", "HTMLMediaElement"); });
6609 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6610 impl.simulateAudioInterruption(*element);
6611 return JSValue::encode(jsUndefined());
6612}
6613
6614EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateAudioInterruption(ExecState* state)
6615{
6616 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateAudioInterruptionBody>(*state, "simulateAudioInterruption");
6617}
6618
6619#endif
6620
6621#if ENABLE(VIDEO)
6622static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaElementHasCharacteristicBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6623{
6624 UNUSED_PARAM(state);
6625 UNUSED_PARAM(throwScope);
6626 auto& impl = castedThis->wrapped();
6627 if (UNLIKELY(state->argumentCount() < 2))
6628 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6629 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "mediaElementHasCharacteristic", "HTMLMediaElement"); });
6630 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6631 auto characteristic = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
6632 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6633 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.mediaElementHasCharacteristic(*element, WTFMove(characteristic))));
6634}
6635
6636EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaElementHasCharacteristic(ExecState* state)
6637{
6638 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaElementHasCharacteristicBody>(*state, "mediaElementHasCharacteristic");
6639}
6640
6641#endif
6642
6643#if ENABLE(VIDEO)
6644static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBeginSimulatedHDCPErrorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6645{
6646 UNUSED_PARAM(state);
6647 UNUSED_PARAM(throwScope);
6648 auto& impl = castedThis->wrapped();
6649 if (UNLIKELY(state->argumentCount() < 1))
6650 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6651 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "beginSimulatedHDCPError", "HTMLMediaElement"); });
6652 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6653 impl.beginSimulatedHDCPError(*media);
6654 return JSValue::encode(jsUndefined());
6655}
6656
6657EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginSimulatedHDCPError(ExecState* state)
6658{
6659 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBeginSimulatedHDCPErrorBody>(*state, "beginSimulatedHDCPError");
6660}
6661
6662#endif
6663
6664#if ENABLE(VIDEO)
6665static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEndSimulatedHDCPErrorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6666{
6667 UNUSED_PARAM(state);
6668 UNUSED_PARAM(throwScope);
6669 auto& impl = castedThis->wrapped();
6670 if (UNLIKELY(state->argumentCount() < 1))
6671 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6672 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "endSimulatedHDCPError", "HTMLMediaElement"); });
6673 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6674 impl.endSimulatedHDCPError(*media);
6675 return JSValue::encode(jsUndefined());
6676}
6677
6678EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndSimulatedHDCPError(ExecState* state)
6679{
6680 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEndSimulatedHDCPErrorBody>(*state, "endSimulatedHDCPError");
6681}
6682
6683#endif
6684
6685#if ENABLE(VIDEO)
6686static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementShouldBufferDataBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6687{
6688 UNUSED_PARAM(state);
6689 UNUSED_PARAM(throwScope);
6690 auto& impl = castedThis->wrapped();
6691 if (UNLIKELY(state->argumentCount() < 1))
6692 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6693 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "elementShouldBufferData", "HTMLMediaElement"); });
6694 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6695 return JSValue::encode(toJS<IDLBoolean>(impl.elementShouldBufferData(*media)));
6696}
6697
6698EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementShouldBufferData(ExecState* state)
6699{
6700 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementShouldBufferDataBody>(*state, "elementShouldBufferData");
6701}
6702
6703#endif
6704
6705#if ENABLE(VIDEO)
6706static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementBufferingPolicyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6707{
6708 UNUSED_PARAM(state);
6709 UNUSED_PARAM(throwScope);
6710 auto& impl = castedThis->wrapped();
6711 if (UNLIKELY(state->argumentCount() < 1))
6712 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6713 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "elementBufferingPolicy", "HTMLMediaElement"); });
6714 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6715 return JSValue::encode(toJS<IDLDOMString>(*state, impl.elementBufferingPolicy(*media)));
6716}
6717
6718EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementBufferingPolicy(ExecState* state)
6719{
6720 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementBufferingPolicyBody>(*state, "elementBufferingPolicy");
6721}
6722
6723#endif
6724
6725#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
6726static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInitializeMockCDMBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6727{
6728 UNUSED_PARAM(state);
6729 UNUSED_PARAM(throwScope);
6730 auto& impl = castedThis->wrapped();
6731 impl.initializeMockCDM();
6732 return JSValue::encode(jsUndefined());
6733}
6734
6735EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInitializeMockCDM(ExecState* state)
6736{
6737 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInitializeMockCDMBody>(*state, "initializeMockCDM");
6738}
6739
6740#endif
6741
6742#if ENABLE(ENCRYPTED_MEDIA)
6743static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRegisterMockCDMBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6744{
6745 UNUSED_PARAM(state);
6746 UNUSED_PARAM(throwScope);
6747 auto& impl = castedThis->wrapped();
6748 return JSValue::encode(toJS<IDLInterface<MockCDMFactory>>(*state, *castedThis->globalObject(), impl.registerMockCDM()));
6749}
6750
6751EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterMockCDM(ExecState* state)
6752{
6753 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRegisterMockCDMBody>(*state, "registerMockCDM");
6754}
6755
6756#endif
6757
6758static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnableMockMediaCapabilitiesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6759{
6760 UNUSED_PARAM(state);
6761 UNUSED_PARAM(throwScope);
6762 auto& impl = castedThis->wrapped();
6763 impl.enableMockMediaCapabilities();
6764 return JSValue::encode(jsUndefined());
6765}
6766
6767EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableMockMediaCapabilities(ExecState* state)
6768{
6769 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnableMockMediaCapabilitiesBody>(*state, "enableMockMediaCapabilities");
6770}
6771
6772#if ENABLE(SPEECH_SYNTHESIS)
6773static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnableMockSpeechSynthesizerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6774{
6775 UNUSED_PARAM(state);
6776 UNUSED_PARAM(throwScope);
6777 auto& impl = castedThis->wrapped();
6778 impl.enableMockSpeechSynthesizer();
6779 return JSValue::encode(jsUndefined());
6780}
6781
6782EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableMockSpeechSynthesizer(ExecState* state)
6783{
6784 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnableMockSpeechSynthesizerBody>(*state, "enableMockSpeechSynthesizer");
6785}
6786
6787#endif
6788
6789static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetImageSourceURLBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6790{
6791 UNUSED_PARAM(state);
6792 UNUSED_PARAM(throwScope);
6793 auto& impl = castedThis->wrapped();
6794 if (UNLIKELY(state->argumentCount() < 1))
6795 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6796 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "getImageSourceURL", "Element"); });
6797 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6798 return JSValue::encode(toJS<IDLDOMString>(*state, impl.getImageSourceURL(*element)));
6799}
6800
6801EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetImageSourceURL(ExecState* state)
6802{
6803 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetImageSourceURLBody>(*state, "getImageSourceURL");
6804}
6805
6806#if ENABLE(VIDEO_TRACK)
6807static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCaptionsStyleSheetOverrideBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6808{
6809 UNUSED_PARAM(state);
6810 UNUSED_PARAM(throwScope);
6811 auto& impl = castedThis->wrapped();
6812 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.captionsStyleSheetOverride()));
6813}
6814
6815EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCaptionsStyleSheetOverride(ExecState* state)
6816{
6817 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCaptionsStyleSheetOverrideBody>(*state, "captionsStyleSheetOverride");
6818}
6819
6820#endif
6821
6822#if ENABLE(VIDEO_TRACK)
6823static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverrideBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6824{
6825 UNUSED_PARAM(state);
6826 UNUSED_PARAM(throwScope);
6827 auto& impl = castedThis->wrapped();
6828 if (UNLIKELY(state->argumentCount() < 1))
6829 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6830 auto override = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6831 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6832 propagateException(*state, throwScope, impl.setCaptionsStyleSheetOverride(WTFMove(override)));
6833 return JSValue::encode(jsUndefined());
6834}
6835
6836EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverride(ExecState* state)
6837{
6838 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverrideBody>(*state, "setCaptionsStyleSheetOverride");
6839}
6840
6841#endif
6842
6843#if ENABLE(VIDEO_TRACK)
6844static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverrideBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6845{
6846 UNUSED_PARAM(state);
6847 UNUSED_PARAM(throwScope);
6848 auto& impl = castedThis->wrapped();
6849 if (UNLIKELY(state->argumentCount() < 1))
6850 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6851 auto language = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6852 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6853 propagateException(*state, throwScope, impl.setPrimaryAudioTrackLanguageOverride(WTFMove(language)));
6854 return JSValue::encode(jsUndefined());
6855}
6856
6857EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverride(ExecState* state)
6858{
6859 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverrideBody>(*state, "setPrimaryAudioTrackLanguageOverride");
6860}
6861
6862#endif
6863
6864#if ENABLE(VIDEO_TRACK)
6865static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCaptionDisplayModeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6866{
6867 UNUSED_PARAM(state);
6868 UNUSED_PARAM(throwScope);
6869 auto& impl = castedThis->wrapped();
6870 if (UNLIKELY(state->argumentCount() < 1))
6871 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6872 auto mode = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6873 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6874 propagateException(*state, throwScope, impl.setCaptionDisplayMode(WTFMove(mode)));
6875 return JSValue::encode(jsUndefined());
6876}
6877
6878EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptionDisplayMode(ExecState* state)
6879{
6880 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCaptionDisplayModeBody>(*state, "setCaptionDisplayMode");
6881}
6882
6883#endif
6884
6885#if ENABLE(VIDEO_TRACK)
6886static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCreateGenericCueBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6887{
6888 UNUSED_PARAM(state);
6889 UNUSED_PARAM(throwScope);
6890 auto& impl = castedThis->wrapped();
6891 if (UNLIKELY(state->argumentCount() < 3))
6892 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6893 auto startTime = convert<IDLDouble>(*state, state->uncheckedArgument(0));
6894 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6895 auto endTime = convert<IDLDouble>(*state, state->uncheckedArgument(1));
6896 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6897 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(2));
6898 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6899 return JSValue::encode(toJS<IDLInterface<TextTrackCueGeneric>>(*state, *castedThis->globalObject(), impl.createGenericCue(WTFMove(startTime), WTFMove(endTime), WTFMove(text))));
6900}
6901
6902EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateGenericCue(ExecState* state)
6903{
6904 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCreateGenericCueBody>(*state, "createGenericCue");
6905}
6906
6907#endif
6908
6909#if ENABLE(VIDEO)
6910static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCreateTimeRangesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6911{
6912 UNUSED_PARAM(state);
6913 UNUSED_PARAM(throwScope);
6914 auto& impl = castedThis->wrapped();
6915 if (UNLIKELY(state->argumentCount() < 2))
6916 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6917 auto startTimes = convert<IDLFloat32Array>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "startTimes", "Internals", "createTimeRanges", "Float32Array"); });
6918 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6919 auto endTimes = convert<IDLFloat32Array>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "endTimes", "Internals", "createTimeRanges", "Float32Array"); });
6920 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6921 return JSValue::encode(toJS<IDLInterface<TimeRanges>>(*state, *castedThis->globalObject(), impl.createTimeRanges(startTimes.releaseNonNull(), endTimes.releaseNonNull())));
6922}
6923
6924EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateTimeRanges(ExecState* state)
6925{
6926 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCreateTimeRangesBody>(*state, "createTimeRanges");
6927}
6928
6929#endif
6930
6931#if ENABLE(VIDEO)
6932static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClosestTimeToTimeRangesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6933{
6934 UNUSED_PARAM(state);
6935 UNUSED_PARAM(throwScope);
6936 auto& impl = castedThis->wrapped();
6937 if (UNLIKELY(state->argumentCount() < 2))
6938 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6939 auto time = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(0));
6940 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6941 auto ranges = convert<IDLInterface<TimeRanges>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "ranges", "Internals", "closestTimeToTimeRanges", "TimeRanges"); });
6942 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6943 return JSValue::encode(toJS<IDLUnrestrictedDouble>(impl.closestTimeToTimeRanges(WTFMove(time), *ranges)));
6944}
6945
6946EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClosestTimeToTimeRanges(ExecState* state)
6947{
6948 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionClosestTimeToTimeRangesBody>(*state, "closestTimeToTimeRanges");
6949}
6950
6951#endif
6952
6953static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsSelectPopupVisibleBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6954{
6955 UNUSED_PARAM(state);
6956 UNUSED_PARAM(throwScope);
6957 auto& impl = castedThis->wrapped();
6958 if (UNLIKELY(state->argumentCount() < 1))
6959 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6960 auto element = convert<IDLInterface<HTMLSelectElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isSelectPopupVisible", "HTMLSelectElement"); });
6961 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6962 return JSValue::encode(toJS<IDLBoolean>(impl.isSelectPopupVisible(*element)));
6963}
6964
6965EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSelectPopupVisible(ExecState* state)
6966{
6967 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsSelectPopupVisibleBody>(*state, "isSelectPopupVisible");
6968}
6969
6970static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscuredBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6971{
6972 UNUSED_PARAM(state);
6973 UNUSED_PARAM(throwScope);
6974 auto& impl = castedThis->wrapped();
6975 if (UNLIKELY(state->argumentCount() < 1))
6976 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6977 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isPluginUnavailabilityIndicatorObscured", "Element"); });
6978 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6979 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.isPluginUnavailabilityIndicatorObscured(*element)));
6980}
6981
6982EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscured(ExecState* state)
6983{
6984 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscuredBody>(*state, "isPluginUnavailabilityIndicatorObscured");
6985}
6986
6987static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUnavailablePluginReplacementTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6988{
6989 UNUSED_PARAM(state);
6990 UNUSED_PARAM(throwScope);
6991 auto& impl = castedThis->wrapped();
6992 if (UNLIKELY(state->argumentCount() < 1))
6993 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6994 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "unavailablePluginReplacementText", "Element"); });
6995 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6996 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.unavailablePluginReplacementText(*element)));
6997}
6998
6999EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUnavailablePluginReplacementText(ExecState* state)
7000{
7001 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUnavailablePluginReplacementTextBody>(*state, "unavailablePluginReplacementText");
7002}
7003
7004static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPluginSnapshottedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7005{
7006 UNUSED_PARAM(state);
7007 UNUSED_PARAM(throwScope);
7008 auto& impl = castedThis->wrapped();
7009 if (UNLIKELY(state->argumentCount() < 1))
7010 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7011 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isPluginSnapshotted", "Element"); });
7012 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7013 return JSValue::encode(toJS<IDLBoolean>(impl.isPluginSnapshotted(*element)));
7014}
7015
7016EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPluginSnapshotted(ExecState* state)
7017{
7018 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPluginSnapshottedBody>(*state, "isPluginSnapshotted");
7019}
7020
7021static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPluginIsBelowSizeThresholdBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7022{
7023 UNUSED_PARAM(state);
7024 UNUSED_PARAM(throwScope);
7025 auto& impl = castedThis->wrapped();
7026 if (UNLIKELY(state->argumentCount() < 1))
7027 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7028 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "pluginIsBelowSizeThreshold", "Element"); });
7029 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7030 return JSValue::encode(toJS<IDLBoolean>(impl.pluginIsBelowSizeThreshold(*element)));
7031}
7032
7033EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPluginIsBelowSizeThreshold(ExecState* state)
7034{
7035 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPluginIsBelowSizeThresholdBody>(*state, "pluginIsBelowSizeThreshold");
7036}
7037
7038static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSelectionBoundsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7039{
7040 UNUSED_PARAM(state);
7041 UNUSED_PARAM(throwScope);
7042 auto& impl = castedThis->wrapped();
7043 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), throwScope, impl.selectionBounds()));
7044}
7045
7046EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSelectionBounds(ExecState* state)
7047{
7048 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSelectionBoundsBody>(*state, "selectionBounds");
7049}
7050
7051static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetSelectionWithoutValidationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7052{
7053 UNUSED_PARAM(state);
7054 UNUSED_PARAM(throwScope);
7055 auto& impl = castedThis->wrapped();
7056 if (UNLIKELY(state->argumentCount() < 4))
7057 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7058 auto baseNode = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "baseNode", "Internals", "setSelectionWithoutValidation", "Node"); });
7059 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7060 auto baseOffset = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(1));
7061 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7062 auto extentNode = convert<IDLNullable<IDLInterface<Node>>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "extentNode", "Internals", "setSelectionWithoutValidation", "Node"); });
7063 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7064 auto extentOffset = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(3));
7065 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7066 impl.setSelectionWithoutValidation(*baseNode, WTFMove(baseOffset), WTFMove(extentNode), WTFMove(extentOffset));
7067 return JSValue::encode(jsUndefined());
7068}
7069
7070EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetSelectionWithoutValidation(ExecState* state)
7071{
7072 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetSelectionWithoutValidationBody>(*state, "setSelectionWithoutValidation");
7073}
7074
7075#if ENABLE(MEDIA_SOURCE)
7076static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInitializeMockMediaSourceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7077{
7078 UNUSED_PARAM(state);
7079 UNUSED_PARAM(throwScope);
7080 auto& impl = castedThis->wrapped();
7081 impl.initializeMockMediaSource();
7082 return JSValue::encode(jsUndefined());
7083}
7084
7085EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInitializeMockMediaSource(ExecState* state)
7086{
7087 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInitializeMockMediaSourceBody>(*state, "initializeMockMediaSource");
7088}
7089
7090#endif
7091
7092#if ENABLE(MEDIA_SOURCE)
7093static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBufferedSamplesForTrackIDBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7094{
7095 UNUSED_PARAM(state);
7096 UNUSED_PARAM(throwScope);
7097 auto& impl = castedThis->wrapped();
7098 if (UNLIKELY(state->argumentCount() < 2))
7099 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7100 auto buffer = convert<IDLInterface<SourceBuffer>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "buffer", "Internals", "bufferedSamplesForTrackID", "SourceBuffer"); });
7101 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7102 auto trackID = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7103 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7104 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.bufferedSamplesForTrackID(*buffer, WTFMove(trackID))));
7105}
7106
7107EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBufferedSamplesForTrackID(ExecState* state)
7108{
7109 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBufferedSamplesForTrackIDBody>(*state, "bufferedSamplesForTrackID");
7110}
7111
7112#endif
7113
7114#if ENABLE(MEDIA_SOURCE)
7115static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnqueuedSamplesForTrackIDBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7116{
7117 UNUSED_PARAM(state);
7118 UNUSED_PARAM(throwScope);
7119 auto& impl = castedThis->wrapped();
7120 if (UNLIKELY(state->argumentCount() < 2))
7121 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7122 auto buffer = convert<IDLInterface<SourceBuffer>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "buffer", "Internals", "enqueuedSamplesForTrackID", "SourceBuffer"); });
7123 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7124 auto trackID = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7125 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7126 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.enqueuedSamplesForTrackID(*buffer, WTFMove(trackID))));
7127}
7128
7129EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnqueuedSamplesForTrackID(ExecState* state)
7130{
7131 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnqueuedSamplesForTrackIDBody>(*state, "enqueuedSamplesForTrackID");
7132}
7133
7134#endif
7135
7136#if ENABLE(MEDIA_SOURCE)
7137static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShouldGenerateTimestampsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7138{
7139 UNUSED_PARAM(state);
7140 UNUSED_PARAM(throwScope);
7141 auto& impl = castedThis->wrapped();
7142 if (UNLIKELY(state->argumentCount() < 2))
7143 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7144 auto buffer = convert<IDLInterface<SourceBuffer>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "buffer", "Internals", "setShouldGenerateTimestamps", "SourceBuffer"); });
7145 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7146 auto flag = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
7147 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7148 impl.setShouldGenerateTimestamps(*buffer, WTFMove(flag));
7149 return JSValue::encode(jsUndefined());
7150}
7151
7152EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShouldGenerateTimestamps(ExecState* state)
7153{
7154 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShouldGenerateTimestampsBody>(*state, "setShouldGenerateTimestamps");
7155}
7156
7157#endif
7158
7159#if ENABLE(VIDEO)
7160static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBeginMediaSessionInterruptionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7161{
7162 UNUSED_PARAM(state);
7163 UNUSED_PARAM(throwScope);
7164 auto& impl = castedThis->wrapped();
7165 if (UNLIKELY(state->argumentCount() < 1))
7166 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7167 auto interruptionType = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7168 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7169 propagateException(*state, throwScope, impl.beginMediaSessionInterruption(WTFMove(interruptionType)));
7170 return JSValue::encode(jsUndefined());
7171}
7172
7173EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginMediaSessionInterruption(ExecState* state)
7174{
7175 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBeginMediaSessionInterruptionBody>(*state, "beginMediaSessionInterruption");
7176}
7177
7178#endif
7179
7180#if ENABLE(VIDEO)
7181static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEndMediaSessionInterruptionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7182{
7183 UNUSED_PARAM(state);
7184 UNUSED_PARAM(throwScope);
7185 auto& impl = castedThis->wrapped();
7186 if (UNLIKELY(state->argumentCount() < 1))
7187 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7188 auto flags = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7189 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7190 impl.endMediaSessionInterruption(WTFMove(flags));
7191 return JSValue::encode(jsUndefined());
7192}
7193
7194EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndMediaSessionInterruption(ExecState* state)
7195{
7196 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEndMediaSessionInterruptionBody>(*state, "endMediaSessionInterruption");
7197}
7198
7199#endif
7200
7201#if ENABLE(MEDIA_SESSION)
7202static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotificationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7203{
7204 UNUSED_PARAM(state);
7205 UNUSED_PARAM(throwScope);
7206 auto& impl = castedThis->wrapped();
7207 if (UNLIKELY(state->argumentCount() < 1))
7208 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7209 auto category = convert<IDLEnumeration<Internals::MediaSessionInterruptingCategory>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "category", "Internals", "sendMediaSessionStartOfInterruptionNotification", expectedEnumerationValues<Internals::MediaSessionInterruptingCategory>()); });
7210 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7211 impl.sendMediaSessionStartOfInterruptionNotification(WTFMove(category));
7212 return JSValue::encode(jsUndefined());
7213}
7214
7215EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotification(ExecState* state)
7216{
7217 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotificationBody>(*state, "sendMediaSessionStartOfInterruptionNotification");
7218}
7219
7220#endif
7221
7222#if ENABLE(MEDIA_SESSION)
7223static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotificationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7224{
7225 UNUSED_PARAM(state);
7226 UNUSED_PARAM(throwScope);
7227 auto& impl = castedThis->wrapped();
7228 if (UNLIKELY(state->argumentCount() < 1))
7229 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7230 auto category = convert<IDLEnumeration<Internals::MediaSessionInterruptingCategory>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "category", "Internals", "sendMediaSessionEndOfInterruptionNotification", expectedEnumerationValues<Internals::MediaSessionInterruptingCategory>()); });
7231 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7232 impl.sendMediaSessionEndOfInterruptionNotification(WTFMove(category));
7233 return JSValue::encode(jsUndefined());
7234}
7235
7236EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotification(ExecState* state)
7237{
7238 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotificationBody>(*state, "sendMediaSessionEndOfInterruptionNotification");
7239}
7240
7241#endif
7242
7243#if ENABLE(MEDIA_SESSION)
7244static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaSessionCurrentStateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7245{
7246 UNUSED_PARAM(state);
7247 UNUSED_PARAM(throwScope);
7248 auto& impl = castedThis->wrapped();
7249 if (UNLIKELY(state->argumentCount() < 1))
7250 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7251 auto session = convert<IDLInterface<MediaSession>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "session", "Internals", "mediaSessionCurrentState", "MediaSession"); });
7252 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7253 return JSValue::encode(toJS<IDLDOMString>(*state, impl.mediaSessionCurrentState(*session)));
7254}
7255
7256EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionCurrentState(ExecState* state)
7257{
7258 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaSessionCurrentStateBody>(*state, "mediaSessionCurrentState");
7259}
7260
7261#endif
7262
7263#if ENABLE(MEDIA_SESSION)
7264static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaElementPlayerVolumeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7265{
7266 UNUSED_PARAM(state);
7267 UNUSED_PARAM(throwScope);
7268 auto& impl = castedThis->wrapped();
7269 if (UNLIKELY(state->argumentCount() < 1))
7270 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7271 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "mediaElementPlayerVolume", "HTMLMediaElement"); });
7272 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7273 return JSValue::encode(toJS<IDLDouble>(impl.mediaElementPlayerVolume(*element)));
7274}
7275
7276EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaElementPlayerVolume(ExecState* state)
7277{
7278 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaElementPlayerVolumeBody>(*state, "mediaElementPlayerVolume");
7279}
7280
7281#endif
7282
7283#if ENABLE(MEDIA_SESSION)
7284static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSendMediaControlEventBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7285{
7286 UNUSED_PARAM(state);
7287 UNUSED_PARAM(throwScope);
7288 auto& impl = castedThis->wrapped();
7289 if (UNLIKELY(state->argumentCount() < 1))
7290 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7291 auto event = convert<IDLEnumeration<Internals::MediaControlEvent>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "event", "Internals", "sendMediaControlEvent", expectedEnumerationValues<Internals::MediaControlEvent>()); });
7292 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7293 impl.sendMediaControlEvent(WTFMove(event));
7294 return JSValue::encode(jsUndefined());
7295}
7296
7297EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaControlEvent(ExecState* state)
7298{
7299 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSendMediaControlEventBody>(*state, "sendMediaControlEvent");
7300}
7301
7302#endif
7303
7304#if ENABLE(VIDEO)
7305static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplicationWillBecomeInactiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7306{
7307 UNUSED_PARAM(state);
7308 UNUSED_PARAM(throwScope);
7309 auto& impl = castedThis->wrapped();
7310 impl.applicationWillBecomeInactive();
7311 return JSValue::encode(jsUndefined());
7312}
7313
7314EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationWillBecomeInactive(ExecState* state)
7315{
7316 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplicationWillBecomeInactiveBody>(*state, "applicationWillBecomeInactive");
7317}
7318
7319#endif
7320
7321#if ENABLE(VIDEO)
7322static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplicationDidBecomeActiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7323{
7324 UNUSED_PARAM(state);
7325 UNUSED_PARAM(throwScope);
7326 auto& impl = castedThis->wrapped();
7327 impl.applicationDidBecomeActive();
7328 return JSValue::encode(jsUndefined());
7329}
7330
7331EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationDidBecomeActive(ExecState* state)
7332{
7333 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplicationDidBecomeActiveBody>(*state, "applicationDidBecomeActive");
7334}
7335
7336#endif
7337
7338#if ENABLE(VIDEO)
7339static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplicationWillEnterForegroundBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7340{
7341 UNUSED_PARAM(state);
7342 UNUSED_PARAM(throwScope);
7343 auto& impl = castedThis->wrapped();
7344 auto suspendedUnderLock = convert<IDLBoolean>(*state, state->argument(0));
7345 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7346 impl.applicationWillEnterForeground(WTFMove(suspendedUnderLock));
7347 return JSValue::encode(jsUndefined());
7348}
7349
7350EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationWillEnterForeground(ExecState* state)
7351{
7352 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplicationWillEnterForegroundBody>(*state, "applicationWillEnterForeground");
7353}
7354
7355#endif
7356
7357#if ENABLE(VIDEO)
7358static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplicationDidEnterBackgroundBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7359{
7360 UNUSED_PARAM(state);
7361 UNUSED_PARAM(throwScope);
7362 auto& impl = castedThis->wrapped();
7363 auto suspendedUnderLock = convert<IDLBoolean>(*state, state->argument(0));
7364 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7365 impl.applicationDidEnterBackground(WTFMove(suspendedUnderLock));
7366 return JSValue::encode(jsUndefined());
7367}
7368
7369EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationDidEnterBackground(ExecState* state)
7370{
7371 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplicationDidEnterBackgroundBody>(*state, "applicationDidEnterBackground");
7372}
7373
7374#endif
7375
7376#if ENABLE(VIDEO)
7377static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaSessionRestrictionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7378{
7379 UNUSED_PARAM(state);
7380 UNUSED_PARAM(throwScope);
7381 auto& impl = castedThis->wrapped();
7382 if (UNLIKELY(state->argumentCount() < 2))
7383 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7384 auto mediaType = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7385 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7386 auto restrictions = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7387 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7388 propagateException(*state, throwScope, impl.setMediaSessionRestrictions(WTFMove(mediaType), WTFMove(restrictions)));
7389 return JSValue::encode(jsUndefined());
7390}
7391
7392EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaSessionRestrictions(ExecState* state)
7393{
7394 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaSessionRestrictionsBody>(*state, "setMediaSessionRestrictions");
7395}
7396
7397#endif
7398
7399#if ENABLE(VIDEO)
7400static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaSessionRestrictionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7401{
7402 UNUSED_PARAM(state);
7403 UNUSED_PARAM(throwScope);
7404 auto& impl = castedThis->wrapped();
7405 if (UNLIKELY(state->argumentCount() < 1))
7406 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7407 auto mediaType = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7408 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7409 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.mediaSessionRestrictions(WTFMove(mediaType))));
7410}
7411
7412EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionRestrictions(ExecState* state)
7413{
7414 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaSessionRestrictionsBody>(*state, "mediaSessionRestrictions");
7415}
7416
7417#endif
7418
7419#if ENABLE(VIDEO)
7420static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaElementRestrictionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7421{
7422 UNUSED_PARAM(state);
7423 UNUSED_PARAM(throwScope);
7424 auto& impl = castedThis->wrapped();
7425 if (UNLIKELY(state->argumentCount() < 2))
7426 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7427 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setMediaElementRestrictions", "HTMLMediaElement"); });
7428 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7429 auto restrictions = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7430 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7431 impl.setMediaElementRestrictions(*element, WTFMove(restrictions));
7432 return JSValue::encode(jsUndefined());
7433}
7434
7435EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaElementRestrictions(ExecState* state)
7436{
7437 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaElementRestrictionsBody>(*state, "setMediaElementRestrictions");
7438}
7439
7440#endif
7441
7442#if ENABLE(WEB_AUDIO)
7443static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAudioContextRestrictionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7444{
7445 UNUSED_PARAM(state);
7446 UNUSED_PARAM(throwScope);
7447 auto& impl = castedThis->wrapped();
7448 if (UNLIKELY(state->argumentCount() < 2))
7449 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7450 auto context = convert<IDLInterface<AudioContext>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "context", "Internals", "setAudioContextRestrictions", "AudioContext"); });
7451 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7452 auto restrictions = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7453 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7454 impl.setAudioContextRestrictions(*context, WTFMove(restrictions));
7455 return JSValue::encode(jsUndefined());
7456}
7457
7458EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAudioContextRestrictions(ExecState* state)
7459{
7460 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAudioContextRestrictionsBody>(*state, "setAudioContextRestrictions");
7461}
7462
7463#endif
7464
7465#if ENABLE(VIDEO)
7466static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPostRemoteControlCommandBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7467{
7468 UNUSED_PARAM(state);
7469 UNUSED_PARAM(throwScope);
7470 auto& impl = castedThis->wrapped();
7471 if (UNLIKELY(state->argumentCount() < 1))
7472 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7473 auto command = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7474 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7475 auto argument = state->argument(1).isUndefined() ? 0 : convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(1));
7476 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7477 propagateException(*state, throwScope, impl.postRemoteControlCommand(WTFMove(command), WTFMove(argument)));
7478 return JSValue::encode(jsUndefined());
7479}
7480
7481EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPostRemoteControlCommand(ExecState* state)
7482{
7483 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPostRemoteControlCommandBody>(*state, "postRemoteControlCommand");
7484}
7485
7486#endif
7487
7488#if ENABLE(WIRELESS_PLAYBACK_TARGET)
7489static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7490{
7491 UNUSED_PARAM(state);
7492 UNUSED_PARAM(throwScope);
7493 auto& impl = castedThis->wrapped();
7494 if (UNLIKELY(state->argumentCount() < 1))
7495 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7496 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7497 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7498 impl.setMockMediaPlaybackTargetPickerEnabled(WTFMove(enabled));
7499 return JSValue::encode(jsUndefined());
7500}
7501
7502EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabled(ExecState* state)
7503{
7504 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabledBody>(*state, "setMockMediaPlaybackTargetPickerEnabled");
7505}
7506
7507#endif
7508
7509#if ENABLE(WIRELESS_PLAYBACK_TARGET)
7510static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerStateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7511{
7512 UNUSED_PARAM(state);
7513 UNUSED_PARAM(throwScope);
7514 auto& impl = castedThis->wrapped();
7515 if (UNLIKELY(state->argumentCount() < 2))
7516 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7517 auto deviceName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7518 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7519 auto deviceState = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7520 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7521 propagateException(*state, throwScope, impl.setMockMediaPlaybackTargetPickerState(WTFMove(deviceName), WTFMove(deviceState)));
7522 return JSValue::encode(jsUndefined());
7523}
7524
7525EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerState(ExecState* state)
7526{
7527 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerStateBody>(*state, "setMockMediaPlaybackTargetPickerState");
7528}
7529
7530#endif
7531
7532#if ENABLE(MEDIA_STREAM)
7533static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7534{
7535 UNUSED_PARAM(state);
7536 UNUSED_PARAM(throwScope);
7537 auto& impl = castedThis->wrapped();
7538 if (UNLIKELY(state->argumentCount() < 1))
7539 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7540 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7541 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7542 impl.setMockMediaCaptureDevicesEnabled(WTFMove(enabled));
7543 return JSValue::encode(jsUndefined());
7544}
7545
7546EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabled(ExecState* state)
7547{
7548 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabledBody>(*state, "setMockMediaCaptureDevicesEnabled");
7549}
7550
7551#endif
7552
7553#if ENABLE(MEDIA_STREAM)
7554static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreatorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7555{
7556 UNUSED_PARAM(state);
7557 UNUSED_PARAM(throwScope);
7558 auto& impl = castedThis->wrapped();
7559 impl.setCustomPrivateRecorderCreator();
7560 return JSValue::encode(jsUndefined());
7561}
7562
7563EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreator(ExecState* state)
7564{
7565 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreatorBody>(*state, "setCustomPrivateRecorderCreator");
7566}
7567
7568#endif
7569
7570#if ENABLE(WEB_RTC)
7571static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEventBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7572{
7573 UNUSED_PARAM(state);
7574 UNUSED_PARAM(throwScope);
7575 auto& impl = castedThis->wrapped();
7576 if (UNLIKELY(state->argumentCount() < 2))
7577 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7578 auto connection = convert<IDLInterface<RTCPeerConnection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "connection", "Internals", "emulateRTCPeerConnectionPlatformEvent", "RTCPeerConnection"); });
7579 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7580 auto action = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7581 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7582 impl.emulateRTCPeerConnectionPlatformEvent(*connection, WTFMove(action));
7583 return JSValue::encode(jsUndefined());
7584}
7585
7586EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEvent(ExecState* state)
7587{
7588 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEventBody>(*state, "emulateRTCPeerConnectionPlatformEvent");
7589}
7590
7591#endif
7592
7593#if ENABLE(WEB_RTC)
7594static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactoryBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7595{
7596 UNUSED_PARAM(state);
7597 UNUSED_PARAM(throwScope);
7598 auto& impl = castedThis->wrapped();
7599 if (UNLIKELY(state->argumentCount() < 1))
7600 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7601 auto testCase = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7602 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7603 impl.useMockRTCPeerConnectionFactory(WTFMove(testCase));
7604 return JSValue::encode(jsUndefined());
7605}
7606
7607EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactory(ExecState* state)
7608{
7609 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactoryBody>(*state, "useMockRTCPeerConnectionFactory");
7610}
7611
7612#endif
7613
7614#if ENABLE(WEB_RTC)
7615static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetICECandidateFilteringBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7616{
7617 UNUSED_PARAM(state);
7618 UNUSED_PARAM(throwScope);
7619 auto& impl = castedThis->wrapped();
7620 if (UNLIKELY(state->argumentCount() < 1))
7621 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7622 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7623 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7624 impl.setICECandidateFiltering(WTFMove(enabled));
7625 return JSValue::encode(jsUndefined());
7626}
7627
7628EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetICECandidateFiltering(ExecState* state)
7629{
7630 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetICECandidateFilteringBody>(*state, "setICECandidateFiltering");
7631}
7632
7633#endif
7634
7635#if ENABLE(WEB_RTC)
7636static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7637{
7638 UNUSED_PARAM(state);
7639 UNUSED_PARAM(throwScope);
7640 auto& impl = castedThis->wrapped();
7641 if (UNLIKELY(state->argumentCount() < 1))
7642 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7643 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7644 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7645 impl.setEnumeratingAllNetworkInterfacesEnabled(WTFMove(enabled));
7646 return JSValue::encode(jsUndefined());
7647}
7648
7649EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabled(ExecState* state)
7650{
7651 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabledBody>(*state, "setEnumeratingAllNetworkInterfacesEnabled");
7652}
7653
7654#endif
7655
7656#if ENABLE(WEB_RTC)
7657static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStopPeerConnectionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7658{
7659 UNUSED_PARAM(state);
7660 UNUSED_PARAM(throwScope);
7661 auto& impl = castedThis->wrapped();
7662 if (UNLIKELY(state->argumentCount() < 1))
7663 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7664 auto connection = convert<IDLInterface<RTCPeerConnection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "connection", "Internals", "stopPeerConnection", "RTCPeerConnection"); });
7665 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7666 impl.stopPeerConnection(*connection);
7667 return JSValue::encode(jsUndefined());
7668}
7669
7670EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStopPeerConnection(ExecState* state)
7671{
7672 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStopPeerConnectionBody>(*state, "stopPeerConnection");
7673}
7674
7675#endif
7676
7677#if ENABLE(WEB_RTC)
7678static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClearPeerConnectionFactoryBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7679{
7680 UNUSED_PARAM(state);
7681 UNUSED_PARAM(throwScope);
7682 auto& impl = castedThis->wrapped();
7683 impl.clearPeerConnectionFactory();
7684 return JSValue::encode(jsUndefined());
7685}
7686
7687EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearPeerConnectionFactory(ExecState* state)
7688{
7689 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionClearPeerConnectionFactoryBody>(*state, "clearPeerConnectionFactory");
7690}
7691
7692#endif
7693
7694#if ENABLE(VIDEO)
7695static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateSystemSleepBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7696{
7697 UNUSED_PARAM(state);
7698 UNUSED_PARAM(throwScope);
7699 auto& impl = castedThis->wrapped();
7700 impl.simulateSystemSleep();
7701 return JSValue::encode(jsUndefined());
7702}
7703
7704EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateSystemSleep(ExecState* state)
7705{
7706 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateSystemSleepBody>(*state, "simulateSystemSleep");
7707}
7708
7709#endif
7710
7711#if ENABLE(VIDEO)
7712static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateSystemWakeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7713{
7714 UNUSED_PARAM(state);
7715 UNUSED_PARAM(throwScope);
7716 auto& impl = castedThis->wrapped();
7717 impl.simulateSystemWake();
7718 return JSValue::encode(jsUndefined());
7719}
7720
7721EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateSystemWake(ExecState* state)
7722{
7723 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateSystemWakeBody>(*state, "simulateSystemWake");
7724}
7725
7726#endif
7727
7728#if ENABLE(VIDEO)
7729static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementIsBlockingDisplaySleepBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7730{
7731 UNUSED_PARAM(state);
7732 UNUSED_PARAM(throwScope);
7733 auto& impl = castedThis->wrapped();
7734 if (UNLIKELY(state->argumentCount() < 1))
7735 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7736 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "elementIsBlockingDisplaySleep", "HTMLMediaElement"); });
7737 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7738 return JSValue::encode(toJS<IDLBoolean>(impl.elementIsBlockingDisplaySleep(*element)));
7739}
7740
7741EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementIsBlockingDisplaySleep(ExecState* state)
7742{
7743 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementIsBlockingDisplaySleepBody>(*state, "elementIsBlockingDisplaySleep");
7744}
7745
7746#endif
7747
7748static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInstallMockPageOverlayBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7749{
7750 UNUSED_PARAM(state);
7751 UNUSED_PARAM(throwScope);
7752 auto& impl = castedThis->wrapped();
7753 if (UNLIKELY(state->argumentCount() < 1))
7754 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7755 auto type = convert<IDLEnumeration<Internals::PageOverlayType>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "type", "Internals", "installMockPageOverlay", expectedEnumerationValues<Internals::PageOverlayType>()); });
7756 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7757 return JSValue::encode(toJS<IDLInterface<MockPageOverlay>>(*state, *castedThis->globalObject(), throwScope, impl.installMockPageOverlay(WTFMove(type))));
7758}
7759
7760EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInstallMockPageOverlay(ExecState* state)
7761{
7762 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInstallMockPageOverlayBody>(*state, "installMockPageOverlay");
7763}
7764
7765static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageOverlayLayerTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7766{
7767 UNUSED_PARAM(state);
7768 UNUSED_PARAM(throwScope);
7769 auto& impl = castedThis->wrapped();
7770 auto flags = convert<IDLUnsignedShort>(*state, state->argument(0));
7771 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7772 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.pageOverlayLayerTreeAsText(WTFMove(flags))));
7773}
7774
7775EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageOverlayLayerTreeAsText(ExecState* state)
7776{
7777 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageOverlayLayerTreeAsTextBody>(*state, "pageOverlayLayerTreeAsText");
7778}
7779
7780static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageMutedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7781{
7782 UNUSED_PARAM(state);
7783 UNUSED_PARAM(throwScope);
7784 auto& impl = castedThis->wrapped();
7785 if (UNLIKELY(state->argumentCount() < 1))
7786 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7787 auto mutedState = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7788 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7789 impl.setPageMuted(WTFMove(mutedState));
7790 return JSValue::encode(jsUndefined());
7791}
7792
7793EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageMuted(ExecState* state)
7794{
7795 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageMutedBody>(*state, "setPageMuted");
7796}
7797
7798static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageMediaStateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7799{
7800 UNUSED_PARAM(state);
7801 UNUSED_PARAM(throwScope);
7802 auto& impl = castedThis->wrapped();
7803 return JSValue::encode(toJS<IDLDOMString>(*state, impl.pageMediaState()));
7804}
7805
7806EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageMediaState(ExecState* state)
7807{
7808 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageMediaStateBody>(*state, "pageMediaState");
7809}
7810
7811static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageDefersLoadingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7812{
7813 UNUSED_PARAM(state);
7814 UNUSED_PARAM(throwScope);
7815 auto& impl = castedThis->wrapped();
7816 if (UNLIKELY(state->argumentCount() < 1))
7817 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7818 auto defersLoading = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7819 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7820 impl.setPageDefersLoading(WTFMove(defersLoading));
7821 return JSValue::encode(jsUndefined());
7822}
7823
7824EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageDefersLoading(ExecState* state)
7825{
7826 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageDefersLoadingBody>(*state, "setPageDefersLoading");
7827}
7828
7829static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageDefersLoadingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7830{
7831 UNUSED_PARAM(state);
7832 UNUSED_PARAM(throwScope);
7833 auto& impl = castedThis->wrapped();
7834 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pageDefersLoading()));
7835}
7836
7837EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageDefersLoading(ExecState* state)
7838{
7839 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageDefersLoadingBody>(*state, "pageDefersLoading");
7840}
7841
7842static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCreateFileBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7843{
7844 UNUSED_PARAM(state);
7845 UNUSED_PARAM(throwScope);
7846 auto& impl = castedThis->wrapped();
7847 if (UNLIKELY(state->argumentCount() < 1))
7848 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7849 auto url = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7850 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7851 return JSValue::encode(toJS<IDLNullable<IDLInterface<File>>>(*state, *castedThis->globalObject(), impl.createFile(WTFMove(url))));
7852}
7853
7854EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateFile(ExecState* state)
7855{
7856 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCreateFileBody>(*state, "createFile");
7857}
7858
7859static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionQueueMicroTaskBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7860{
7861 UNUSED_PARAM(state);
7862 UNUSED_PARAM(throwScope);
7863 auto& impl = castedThis->wrapped();
7864 if (UNLIKELY(state->argumentCount() < 1))
7865 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7866 auto testNumber = convert<IDLLong>(*state, state->uncheckedArgument(0));
7867 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7868 impl.queueMicroTask(WTFMove(testNumber));
7869 return JSValue::encode(jsUndefined());
7870}
7871
7872EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionQueueMicroTask(ExecState* state)
7873{
7874 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionQueueMicroTaskBody>(*state, "queueMicroTask");
7875}
7876
7877static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTestPreloaderSettingViewportBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7878{
7879 UNUSED_PARAM(state);
7880 UNUSED_PARAM(throwScope);
7881 auto& impl = castedThis->wrapped();
7882 return JSValue::encode(toJS<IDLBoolean>(impl.testPreloaderSettingViewport()));
7883}
7884
7885EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTestPreloaderSettingViewport(ExecState* state)
7886{
7887 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTestPreloaderSettingViewportBody>(*state, "testPreloaderSettingViewport");
7888}
7889
7890#if ENABLE(CSS_SCROLL_SNAP)
7891static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollSnapOffsetsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7892{
7893 UNUSED_PARAM(state);
7894 UNUSED_PARAM(throwScope);
7895 auto& impl = castedThis->wrapped();
7896 if (UNLIKELY(state->argumentCount() < 1))
7897 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7898 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "scrollSnapOffsets", "Element"); });
7899 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7900 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.scrollSnapOffsets(*element)));
7901}
7902
7903EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollSnapOffsets(ExecState* state)
7904{
7905 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollSnapOffsetsBody>(*state, "scrollSnapOffsets");
7906}
7907
7908#endif
7909
7910#if ENABLE(CSS_SCROLL_SNAP)
7911static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7912{
7913 UNUSED_PARAM(state);
7914 UNUSED_PARAM(throwScope);
7915 auto& impl = castedThis->wrapped();
7916 if (UNLIKELY(state->argumentCount() < 1))
7917 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7918 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7919 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7920 impl.setPlatformMomentumScrollingPredictionEnabled(WTFMove(enabled));
7921 return JSValue::encode(jsUndefined());
7922}
7923
7924EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabled(ExecState* state)
7925{
7926 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabledBody>(*state, "setPlatformMomentumScrollingPredictionEnabled");
7927}
7928
7929#endif
7930
7931static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7932{
7933 UNUSED_PARAM(state);
7934 UNUSED_PARAM(throwScope);
7935 auto& impl = castedThis->wrapped();
7936 if (UNLIKELY(state->argumentCount() < 2))
7937 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7938 auto rectComponents = convert<IDLSequence<IDLDouble>>(*state, state->uncheckedArgument(0));
7939 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7940 auto radius = convert<IDLDouble>(*state, state->uncheckedArgument(1));
7941 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7942 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.pathStringWithShrinkWrappedRects(WTFMove(rectComponents), WTFMove(radius))));
7943}
7944
7945EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRects(ExecState* state)
7946{
7947 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRectsBody>(*state, "pathStringWithShrinkWrappedRects");
7948}
7949
7950#if ENABLE(VIDEO)
7951static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7952{
7953 UNUSED_PARAM(state);
7954 UNUSED_PARAM(throwScope);
7955 auto& impl = castedThis->wrapped();
7956 if (UNLIKELY(state->argumentCount() < 1))
7957 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7958 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "getCurrentMediaControlsStatusForElement", "HTMLMediaElement"); });
7959 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7960 return JSValue::encode(toJS<IDLDOMString>(*state, impl.getCurrentMediaControlsStatusForElement(*element)));
7961}
7962
7963EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElement(ExecState* state)
7964{
7965 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElementBody>(*state, "getCurrentMediaControlsStatusForElement");
7966}
7967
7968#endif
7969
7970static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserVisibleStringBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7971{
7972 UNUSED_PARAM(state);
7973 UNUSED_PARAM(throwScope);
7974 auto& impl = castedThis->wrapped();
7975 if (UNLIKELY(state->argumentCount() < 1))
7976 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7977 auto url = convert<IDLInterface<DOMURL>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "url", "Internals", "userVisibleString", "DOMURL"); });
7978 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7979 return JSValue::encode(toJS<IDLDOMString>(*state, impl.userVisibleString(*url)));
7980}
7981
7982EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserVisibleString(ExecState* state)
7983{
7984 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserVisibleStringBody>(*state, "userVisibleString");
7985}
7986
7987static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShowAllPluginsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7988{
7989 UNUSED_PARAM(state);
7990 UNUSED_PARAM(throwScope);
7991 auto& impl = castedThis->wrapped();
7992 if (UNLIKELY(state->argumentCount() < 1))
7993 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7994 auto showAll = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7995 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7996 impl.setShowAllPlugins(WTFMove(showAll));
7997 return JSValue::encode(jsUndefined());
7998}
7999
8000EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShowAllPlugins(ExecState* state)
8001{
8002 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShowAllPluginsBody>(*state, "setShowAllPlugins");
8003}
8004
8005#if ENABLE(STREAMS_API)
8006static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCloneArrayBufferBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8007{
8008 UNUSED_PARAM(state);
8009 UNUSED_PARAM(throwScope);
8010 auto& impl = castedThis->wrapped();
8011 if (UNLIKELY(state->argumentCount() < 3))
8012 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8013 auto buffer = convert<IDLAny>(*state, state->uncheckedArgument(0));
8014 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8015 auto srcByteOffset = convert<IDLAny>(*state, state->uncheckedArgument(1));
8016 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8017 auto byteLength = convert<IDLAny>(*state, state->uncheckedArgument(2));
8018 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8019 return JSValue::encode(toJS<IDLAny>(impl.cloneArrayBuffer(*state, WTFMove(buffer), WTFMove(srcByteOffset), WTFMove(byteLength))));
8020}
8021
8022EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCloneArrayBuffer(ExecState* state)
8023{
8024 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCloneArrayBufferBody>(*state, "cloneArrayBuffer");
8025}
8026
8027#endif
8028
8029#if ENABLE(STREAMS_API)
8030static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsReadableStreamDisturbedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8031{
8032 UNUSED_PARAM(state);
8033 UNUSED_PARAM(throwScope);
8034 auto& impl = castedThis->wrapped();
8035 if (UNLIKELY(state->argumentCount() < 1))
8036 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8037 auto stream = convert<IDLAny>(*state, state->uncheckedArgument(0));
8038 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8039 return JSValue::encode(toJS<IDLBoolean>(impl.isReadableStreamDisturbed(*state, WTFMove(stream))));
8040}
8041
8042EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsReadableStreamDisturbed(ExecState* state)
8043{
8044 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsReadableStreamDisturbedBody>(*state, "isReadableStreamDisturbed");
8045}
8046
8047#endif
8048
8049static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionResourceLoadStatisticsForURLBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8050{
8051 UNUSED_PARAM(state);
8052 UNUSED_PARAM(throwScope);
8053 auto& impl = castedThis->wrapped();
8054 if (UNLIKELY(state->argumentCount() < 1))
8055 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8056 auto url = convert<IDLInterface<DOMURL>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "url", "Internals", "resourceLoadStatisticsForURL", "DOMURL"); });
8057 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8058 return JSValue::encode(toJS<IDLDOMString>(*state, impl.resourceLoadStatisticsForURL(*url)));
8059}
8060
8061EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResourceLoadStatisticsForURL(ExecState* state)
8062{
8063 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionResourceLoadStatisticsForURLBody>(*state, "resourceLoadStatisticsForURL");
8064}
8065
8066static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8067{
8068 UNUSED_PARAM(state);
8069 UNUSED_PARAM(throwScope);
8070 auto& impl = castedThis->wrapped();
8071 if (UNLIKELY(state->argumentCount() < 1))
8072 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8073 auto enable = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8074 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8075 impl.setResourceLoadStatisticsEnabled(WTFMove(enable));
8076 return JSValue::encode(jsUndefined());
8077}
8078
8079EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabled(ExecState* state)
8080{
8081 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabledBody>(*state, "setResourceLoadStatisticsEnabled");
8082}
8083
8084static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCanShowModalDialogOverrideBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8085{
8086 UNUSED_PARAM(state);
8087 UNUSED_PARAM(throwScope);
8088 auto& impl = castedThis->wrapped();
8089 if (UNLIKELY(state->argumentCount() < 1))
8090 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8091 auto allow = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8092 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8093 propagateException(*state, throwScope, impl.setCanShowModalDialogOverride(WTFMove(allow)));
8094 return JSValue::encode(jsUndefined());
8095}
8096
8097EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCanShowModalDialogOverride(ExecState* state)
8098{
8099 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCanShowModalDialogOverrideBody>(*state, "setCanShowModalDialogOverride");
8100}
8101
8102static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionComposedTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8103{
8104 UNUSED_PARAM(state);
8105 UNUSED_PARAM(throwScope);
8106 auto& impl = castedThis->wrapped();
8107 if (UNLIKELY(state->argumentCount() < 1))
8108 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8109 auto parent = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "parent", "Internals", "composedTreeAsText", "Node"); });
8110 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8111 return JSValue::encode(toJS<IDLDOMString>(*state, impl.composedTreeAsText(*parent)));
8112}
8113
8114EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionComposedTreeAsText(ExecState* state)
8115{
8116 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionComposedTreeAsTextBody>(*state, "composedTreeAsText");
8117}
8118
8119static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsProcessingUserGestureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8120{
8121 UNUSED_PARAM(state);
8122 UNUSED_PARAM(throwScope);
8123 auto& impl = castedThis->wrapped();
8124 return JSValue::encode(toJS<IDLBoolean>(impl.isProcessingUserGesture()));
8125}
8126
8127EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsProcessingUserGesture(ExecState* state)
8128{
8129 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsProcessingUserGestureBody>(*state, "isProcessingUserGesture");
8130}
8131
8132static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastHandledUserGestureTimestampBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8133{
8134 UNUSED_PARAM(state);
8135 UNUSED_PARAM(throwScope);
8136 auto& impl = castedThis->wrapped();
8137 return JSValue::encode(toJS<IDLDouble>(impl.lastHandledUserGestureTimestamp()));
8138}
8139
8140EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastHandledUserGestureTimestamp(ExecState* state)
8141{
8142 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastHandledUserGestureTimestampBody>(*state, "lastHandledUserGestureTimestamp");
8143}
8144
8145static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWithUserGestureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8146{
8147 UNUSED_PARAM(state);
8148 UNUSED_PARAM(throwScope);
8149 auto& impl = castedThis->wrapped();
8150 if (UNLIKELY(state->argumentCount() < 1))
8151 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8152 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*state, state->uncheckedArgument(0), *castedThis->globalObject(), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(state, scope, 0, "callback", "Internals", "withUserGesture"); });
8153 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8154 impl.withUserGesture(callback.releaseNonNull());
8155 return JSValue::encode(jsUndefined());
8156}
8157
8158EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWithUserGesture(ExecState* state)
8159{
8160 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWithUserGestureBody>(*state, "withUserGesture");
8161}
8162
8163static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserIsInteractingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8164{
8165 UNUSED_PARAM(state);
8166 UNUSED_PARAM(throwScope);
8167 auto& impl = castedThis->wrapped();
8168 return JSValue::encode(toJS<IDLBoolean>(impl.userIsInteracting()));
8169}
8170
8171EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserIsInteracting(ExecState* state)
8172{
8173 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserIsInteractingBody>(*state, "userIsInteracting");
8174}
8175
8176static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionObserveGCBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8177{
8178 UNUSED_PARAM(state);
8179 UNUSED_PARAM(throwScope);
8180 auto& impl = castedThis->wrapped();
8181 if (UNLIKELY(state->argumentCount() < 1))
8182 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8183 auto observed = convert<IDLAny>(*state, state->uncheckedArgument(0));
8184 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8185 return JSValue::encode(toJS<IDLNullable<IDLInterface<GCObservation>>>(*state, *castedThis->globalObject(), impl.observeGC(WTFMove(observed))));
8186}
8187
8188EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionObserveGC(ExecState* state)
8189{
8190 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionObserveGCBody>(*state, "observeGC");
8191}
8192
8193static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirectionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8194{
8195 UNUSED_PARAM(state);
8196 UNUSED_PARAM(throwScope);
8197 auto& impl = castedThis->wrapped();
8198 if (UNLIKELY(state->argumentCount() < 1))
8199 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8200 auto userInterfaceLayoutDirection = convert<IDLEnumeration<Internals::UserInterfaceLayoutDirection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "userInterfaceLayoutDirection", "Internals", "setUserInterfaceLayoutDirection", expectedEnumerationValues<Internals::UserInterfaceLayoutDirection>()); });
8201 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8202 impl.setUserInterfaceLayoutDirection(WTFMove(userInterfaceLayoutDirection));
8203 return JSValue::encode(jsUndefined());
8204}
8205
8206EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirection(ExecState* state)
8207{
8208 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirectionBody>(*state, "setUserInterfaceLayoutDirection");
8209}
8210
8211static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetBaseWritingDirectionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8212{
8213 UNUSED_PARAM(state);
8214 UNUSED_PARAM(throwScope);
8215 auto& impl = castedThis->wrapped();
8216 if (UNLIKELY(state->argumentCount() < 1))
8217 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8218 auto direction = convert<IDLEnumeration<Internals::BaseWritingDirection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "direction", "Internals", "setBaseWritingDirection", expectedEnumerationValues<Internals::BaseWritingDirection>()); });
8219 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8220 impl.setBaseWritingDirection(WTFMove(direction));
8221 return JSValue::encode(jsUndefined());
8222}
8223
8224EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetBaseWritingDirection(ExecState* state)
8225{
8226 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetBaseWritingDirectionBody>(*state, "setBaseWritingDirection");
8227}
8228
8229static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserPrefersReducedMotionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8230{
8231 UNUSED_PARAM(state);
8232 UNUSED_PARAM(throwScope);
8233 auto& impl = castedThis->wrapped();
8234 return JSValue::encode(toJS<IDLBoolean>(impl.userPrefersReducedMotion()));
8235}
8236
8237EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPrefersReducedMotion(ExecState* state)
8238{
8239 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserPrefersReducedMotionBody>(*state, "userPrefersReducedMotion");
8240}
8241
8242static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReportBacktraceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8243{
8244 UNUSED_PARAM(state);
8245 UNUSED_PARAM(throwScope);
8246 auto& impl = castedThis->wrapped();
8247 impl.reportBacktrace();
8248 return JSValue::encode(jsUndefined());
8249}
8250
8251EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReportBacktrace(ExecState* state)
8252{
8253 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReportBacktraceBody>(*state, "reportBacktrace");
8254}
8255
8256#if ENABLE(POINTER_LOCK)
8257static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageHasPendingPointerLockBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8258{
8259 UNUSED_PARAM(state);
8260 UNUSED_PARAM(throwScope);
8261 auto& impl = castedThis->wrapped();
8262 return JSValue::encode(toJS<IDLBoolean>(impl.pageHasPendingPointerLock()));
8263}
8264
8265EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageHasPendingPointerLock(ExecState* state)
8266{
8267 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageHasPendingPointerLockBody>(*state, "pageHasPendingPointerLock");
8268}
8269
8270#endif
8271
8272#if ENABLE(POINTER_LOCK)
8273static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageHasPointerLockBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8274{
8275 UNUSED_PARAM(state);
8276 UNUSED_PARAM(throwScope);
8277 auto& impl = castedThis->wrapped();
8278 return JSValue::encode(toJS<IDLBoolean>(impl.pageHasPointerLock()));
8279}
8280
8281EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageHasPointerLock(ExecState* state)
8282{
8283 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageHasPointerLockBody>(*state, "pageHasPointerLock");
8284}
8285
8286#endif
8287
8288static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAccessKeyModifiersBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8289{
8290 UNUSED_PARAM(state);
8291 UNUSED_PARAM(throwScope);
8292 auto& impl = castedThis->wrapped();
8293 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.accessKeyModifiers()));
8294}
8295
8296EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAccessKeyModifiers(ExecState* state)
8297{
8298 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAccessKeyModifiersBody>(*state, "accessKeyModifiers");
8299}
8300
8301static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetQuickLookPasswordBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8302{
8303 UNUSED_PARAM(state);
8304 UNUSED_PARAM(throwScope);
8305 auto& impl = castedThis->wrapped();
8306 if (UNLIKELY(state->argumentCount() < 1))
8307 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8308 auto password = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
8309 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8310 impl.setQuickLookPassword(WTFMove(password));
8311 return JSValue::encode(jsUndefined());
8312}
8313
8314EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetQuickLookPassword(ExecState* state)
8315{
8316 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetQuickLookPasswordBody>(*state, "setQuickLookPassword");
8317}
8318
8319static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAsRunningUserScriptsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8320{
8321 UNUSED_PARAM(state);
8322 UNUSED_PARAM(throwScope);
8323 auto& impl = castedThis->wrapped();
8324 auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
8325 if (UNLIKELY(!context))
8326 return JSValue::encode(jsUndefined());
8327 ASSERT(context->isDocument());
8328 auto& document = downcast<Document>(*context);
8329 impl.setAsRunningUserScripts(document);
8330 return JSValue::encode(jsUndefined());
8331}
8332
8333EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAsRunningUserScripts(ExecState* state)
8334{
8335 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAsRunningUserScriptsBody>(*state, "setAsRunningUserScripts");
8336}
8337
8338#if ENABLE(APPLE_PAY)
8339static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetApplePayIsActiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8340{
8341 UNUSED_PARAM(state);
8342 UNUSED_PARAM(throwScope);
8343 auto& impl = castedThis->wrapped();
8344 auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
8345 if (UNLIKELY(!context))
8346 return JSValue::encode(jsUndefined());
8347 ASSERT(context->isDocument());
8348 auto& document = downcast<Document>(*context);
8349 impl.setApplePayIsActive(document);
8350 return JSValue::encode(jsUndefined());
8351}
8352
8353EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetApplePayIsActive(ExecState* state)
8354{
8355 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetApplePayIsActiveBody>(*state, "setApplePayIsActive");
8356}
8357
8358#endif
8359
8360static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDisableTileSizeUpdateDelayBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8361{
8362 UNUSED_PARAM(state);
8363 UNUSED_PARAM(throwScope);
8364 auto& impl = castedThis->wrapped();
8365 impl.disableTileSizeUpdateDelay();
8366 return JSValue::encode(jsUndefined());
8367}
8368
8369EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDisableTileSizeUpdateDelay(ExecState* state)
8370{
8371 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDisableTileSizeUpdateDelayBody>(*state, "disableTileSizeUpdateDelay");
8372}
8373
8374static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTestingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8375{
8376 UNUSED_PARAM(state);
8377 UNUSED_PARAM(throwScope);
8378 auto& impl = castedThis->wrapped();
8379 if (UNLIKELY(state->argumentCount() < 1))
8380 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8381 auto disabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8382 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8383 impl.setSpeculativeTilingDelayDisabledForTesting(WTFMove(disabled));
8384 return JSValue::encode(jsUndefined());
8385}
8386
8387EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTesting(ExecState* state)
8388{
8389 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTestingBody>(*state, "setSpeculativeTilingDelayDisabledForTesting");
8390}
8391
8392#if ENABLE(WEBGL)
8393static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateWebGLContextChangedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8394{
8395 UNUSED_PARAM(state);
8396 UNUSED_PARAM(throwScope);
8397 auto& impl = castedThis->wrapped();
8398 if (UNLIKELY(state->argumentCount() < 1))
8399 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8400 auto context = convert<IDLInterface<WebGLRenderingContext>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "context", "Internals", "simulateWebGLContextChanged", "WebGLRenderingContext"); });
8401 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8402 impl.simulateWebGLContextChanged(*context);
8403 return JSValue::encode(jsUndefined());
8404}
8405
8406EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateWebGLContextChanged(ExecState* state)
8407{
8408 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateWebGLContextChangedBody>(*state, "simulateWebGLContextChanged");
8409}
8410
8411#endif
8412
8413#if ENABLE(WEBGL)
8414static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionFailNextGPUStatusCheckBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8415{
8416 UNUSED_PARAM(state);
8417 UNUSED_PARAM(throwScope);
8418 auto& impl = castedThis->wrapped();
8419 if (UNLIKELY(state->argumentCount() < 1))
8420 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8421 auto context = convert<IDLInterface<WebGLRenderingContext>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "context", "Internals", "failNextGPUStatusCheck", "WebGLRenderingContext"); });
8422 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8423 impl.failNextGPUStatusCheck(*context);
8424 return JSValue::encode(jsUndefined());
8425}
8426
8427EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFailNextGPUStatusCheck(ExecState* state)
8428{
8429 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionFailNextGPUStatusCheckBody>(*state, "failNextGPUStatusCheck");
8430}
8431
8432#endif
8433
8434#if ENABLE(WEBGL)
8435static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasLowAndHighPowerGPUsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8436{
8437 UNUSED_PARAM(state);
8438 UNUSED_PARAM(throwScope);
8439 auto& impl = castedThis->wrapped();
8440 return JSValue::encode(toJS<IDLBoolean>(impl.hasLowAndHighPowerGPUs()));
8441}
8442
8443EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasLowAndHighPowerGPUs(ExecState* state)
8444{
8445 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasLowAndHighPowerGPUsBody>(*state, "hasLowAndHighPowerGPUs");
8446}
8447
8448#endif
8449
8450static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageVisibilityBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8451{
8452 UNUSED_PARAM(state);
8453 UNUSED_PARAM(throwScope);
8454 auto& impl = castedThis->wrapped();
8455 if (UNLIKELY(state->argumentCount() < 1))
8456 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8457 auto isVisible = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8458 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8459 impl.setPageVisibility(WTFMove(isVisible));
8460 return JSValue::encode(jsUndefined());
8461}
8462
8463EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageVisibility(ExecState* state)
8464{
8465 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageVisibilityBody>(*state, "setPageVisibility");
8466}
8467
8468static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageIsFocusedAndActiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8469{
8470 UNUSED_PARAM(state);
8471 UNUSED_PARAM(throwScope);
8472 auto& impl = castedThis->wrapped();
8473 if (UNLIKELY(state->argumentCount() < 1))
8474 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8475 auto isFocused = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8476 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8477 impl.setPageIsFocusedAndActive(WTFMove(isFocused));
8478 return JSValue::encode(jsUndefined());
8479}
8480
8481EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageIsFocusedAndActive(ExecState* state)
8482{
8483 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageIsFocusedAndActiveBody>(*state, "setPageIsFocusedAndActive");
8484}
8485
8486#if ENABLE(WEB_RTC)
8487static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8488{
8489 UNUSED_PARAM(state);
8490 UNUSED_PARAM(throwScope);
8491 auto& impl = castedThis->wrapped();
8492 if (UNLIKELY(state->argumentCount() < 1))
8493 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8494 auto allowed = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8495 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8496 impl.setH264HardwareEncoderAllowed(WTFMove(allowed));
8497 return JSValue::encode(jsUndefined());
8498}
8499
8500EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowed(ExecState* state)
8501{
8502 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowedBody>(*state, "setH264HardwareEncoderAllowed");
8503}
8504
8505#endif
8506
8507#if ENABLE(WEB_RTC)
8508static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSourcesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8509{
8510 UNUSED_PARAM(state);
8511 UNUSED_PARAM(throwScope);
8512 auto& impl = castedThis->wrapped();
8513 if (UNLIKELY(state->argumentCount() < 1))
8514 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8515 auto connection = convert<IDLInterface<RTCPeerConnection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "connection", "Internals", "applyRotationForOutgoingVideoSources", "RTCPeerConnection"); });
8516 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8517 impl.applyRotationForOutgoingVideoSources(*connection);
8518 return JSValue::encode(jsUndefined());
8519}
8520
8521EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSources(ExecState* state)
8522{
8523 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSourcesBody>(*state, "applyRotationForOutgoingVideoSources");
8524}
8525
8526#endif
8527
8528#if ENABLE(MEDIA_STREAM)
8529static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShouldInterruptAudioOnPageVisibilityChangeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8530{
8531 UNUSED_PARAM(state);
8532 UNUSED_PARAM(throwScope);
8533 auto& impl = castedThis->wrapped();
8534 if (UNLIKELY(state->argumentCount() < 1))
8535 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8536 auto shouldInterrupt = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8537 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8538 impl.setShouldInterruptAudioOnPageVisibilityChange(WTFMove(shouldInterrupt));
8539 return JSValue::encode(jsUndefined());
8540}
8541
8542EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShouldInterruptAudioOnPageVisibilityChange(ExecState* state)
8543{
8544 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShouldInterruptAudioOnPageVisibilityChangeBody>(*state, "setShouldInterruptAudioOnPageVisibilityChange");
8545}
8546
8547#endif
8548
8549#if ENABLE(MEDIA_STREAM)
8550static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8551{
8552 UNUSED_PARAM(state);
8553 UNUSED_PARAM(throwScope);
8554 auto& impl = castedThis->wrapped();
8555 if (UNLIKELY(state->argumentCount() < 2))
8556 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8557 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "setCameraMediaStreamTrackOrientation", "MediaStreamTrack"); });
8558 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8559 auto orientation = convert<IDLShort>(*state, state->uncheckedArgument(1));
8560 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8561 impl.setCameraMediaStreamTrackOrientation(*track, WTFMove(orientation));
8562 return JSValue::encode(jsUndefined());
8563}
8564
8565EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientation(ExecState* state)
8566{
8567 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientationBody>(*state, "setCameraMediaStreamTrackOrientation");
8568}
8569
8570#endif
8571
8572#if ENABLE(MEDIA_STREAM)
8573static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionObserveMediaStreamTrackBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8574{
8575 UNUSED_PARAM(state);
8576 UNUSED_PARAM(throwScope);
8577 auto& impl = castedThis->wrapped();
8578 if (UNLIKELY(state->argumentCount() < 1))
8579 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8580 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "observeMediaStreamTrack", "MediaStreamTrack"); });
8581 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8582 impl.observeMediaStreamTrack(*track);
8583 return JSValue::encode(jsUndefined());
8584}
8585
8586EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionObserveMediaStreamTrack(ExecState* state)
8587{
8588 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionObserveMediaStreamTrackBody>(*state, "observeMediaStreamTrack");
8589}
8590
8591#endif
8592
8593#if ENABLE(MEDIA_STREAM)
8594static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrameBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8595{
8596 UNUSED_PARAM(state);
8597 UNUSED_PARAM(throwScope);
8598 auto& impl = castedThis->wrapped();
8599 impl.grabNextMediaStreamTrackFrame(WTFMove(promise));
8600 return JSValue::encode(jsUndefined());
8601}
8602
8603EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrame(ExecState* state)
8604{
8605 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrameBody, PromiseExecutionScope::WindowOnly>(*state, "grabNextMediaStreamTrackFrame");
8606}
8607
8608#endif
8609
8610#if ENABLE(MEDIA_STREAM)
8611static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDelayMediaStreamTrackSamplesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8612{
8613 UNUSED_PARAM(state);
8614 UNUSED_PARAM(throwScope);
8615 auto& impl = castedThis->wrapped();
8616 if (UNLIKELY(state->argumentCount() < 2))
8617 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8618 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "delayMediaStreamTrackSamples", "MediaStreamTrack"); });
8619 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8620 auto delay = convert<IDLFloat>(*state, state->uncheckedArgument(1));
8621 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8622 impl.delayMediaStreamTrackSamples(*track, WTFMove(delay));
8623 return JSValue::encode(jsUndefined());
8624}
8625
8626EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDelayMediaStreamTrackSamples(ExecState* state)
8627{
8628 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDelayMediaStreamTrackSamplesBody>(*state, "delayMediaStreamTrackSamples");
8629}
8630
8631#endif
8632
8633#if ENABLE(MEDIA_STREAM)
8634static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaStreamTrackMutedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8635{
8636 UNUSED_PARAM(state);
8637 UNUSED_PARAM(throwScope);
8638 auto& impl = castedThis->wrapped();
8639 if (UNLIKELY(state->argumentCount() < 2))
8640 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8641 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "setMediaStreamTrackMuted", "MediaStreamTrack"); });
8642 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8643 auto muted = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
8644 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8645 impl.setMediaStreamTrackMuted(*track, WTFMove(muted));
8646 return JSValue::encode(jsUndefined());
8647}
8648
8649EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamTrackMuted(ExecState* state)
8650{
8651 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaStreamTrackMutedBody>(*state, "setMediaStreamTrackMuted");
8652}
8653
8654#endif
8655
8656#if ENABLE(MEDIA_STREAM)
8657static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRemoveMediaStreamTrackBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8658{
8659 UNUSED_PARAM(state);
8660 UNUSED_PARAM(throwScope);
8661 auto& impl = castedThis->wrapped();
8662 if (UNLIKELY(state->argumentCount() < 2))
8663 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8664 auto stream = convert<IDLInterface<MediaStream>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "stream", "Internals", "removeMediaStreamTrack", "MediaStream"); });
8665 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8666 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "track", "Internals", "removeMediaStreamTrack", "MediaStreamTrack"); });
8667 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8668 impl.removeMediaStreamTrack(*stream, *track);
8669 return JSValue::encode(jsUndefined());
8670}
8671
8672EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRemoveMediaStreamTrack(ExecState* state)
8673{
8674 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRemoveMediaStreamTrackBody>(*state, "removeMediaStreamTrack");
8675}
8676
8677#endif
8678
8679#if ENABLE(MEDIA_STREAM)
8680static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8681{
8682 UNUSED_PARAM(state);
8683 UNUSED_PARAM(throwScope);
8684 auto& impl = castedThis->wrapped();
8685 if (UNLIKELY(state->argumentCount() < 1))
8686 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8687 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "simulateMediaStreamTrackCaptureSourceFailure", "MediaStreamTrack"); });
8688 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8689 impl.simulateMediaStreamTrackCaptureSourceFailure(*track);
8690 return JSValue::encode(jsUndefined());
8691}
8692
8693EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailure(ExecState* state)
8694{
8695 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailureBody>(*state, "simulateMediaStreamTrackCaptureSourceFailure");
8696}
8697
8698#endif
8699
8700#if ENABLE(MEDIA_STREAM)
8701static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifierBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8702{
8703 UNUSED_PARAM(state);
8704 UNUSED_PARAM(throwScope);
8705 auto& impl = castedThis->wrapped();
8706 if (UNLIKELY(state->argumentCount() < 2))
8707 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8708 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "setMediaStreamTrackIdentifier", "MediaStreamTrack"); });
8709 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8710 auto identifier = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
8711 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8712 impl.setMediaStreamTrackIdentifier(*track, WTFMove(identifier));
8713 return JSValue::encode(jsUndefined());
8714}
8715
8716EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifier(ExecState* state)
8717{
8718 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifierBody>(*state, "setMediaStreamTrackIdentifier");
8719}
8720
8721#endif
8722
8723#if ENABLE(MEDIA_STREAM)
8724static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaStreamSourceInterruptedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8725{
8726 UNUSED_PARAM(state);
8727 UNUSED_PARAM(throwScope);
8728 auto& impl = castedThis->wrapped();
8729 if (UNLIKELY(state->argumentCount() < 2))
8730 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8731 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "setMediaStreamSourceInterrupted", "MediaStreamTrack"); });
8732 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8733 auto interrupted = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
8734 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8735 impl.setMediaStreamSourceInterrupted(*track, WTFMove(interrupted));
8736 return JSValue::encode(jsUndefined());
8737}
8738
8739EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamSourceInterrupted(ExecState* state)
8740{
8741 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaStreamSourceInterruptedBody>(*state, "setMediaStreamSourceInterrupted");
8742}
8743
8744#endif
8745
8746#if ENABLE(MEDIA_STREAM)
8747static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraintBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8748{
8749 UNUSED_PARAM(state);
8750 UNUSED_PARAM(throwScope);
8751 auto& impl = castedThis->wrapped();
8752 if (UNLIKELY(state->argumentCount() < 1))
8753 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8754 auto value = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8755 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8756 impl.setDisableGetDisplayMediaUserGestureConstraint(WTFMove(value));
8757 return JSValue::encode(jsUndefined());
8758}
8759
8760EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraint(ExecState* state)
8761{
8762 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraintBody>(*state, "setDisableGetDisplayMediaUserGestureConstraint");
8763}
8764
8765#endif
8766
8767static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDocumentIdentifierBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8768{
8769 UNUSED_PARAM(state);
8770 UNUSED_PARAM(throwScope);
8771 auto& impl = castedThis->wrapped();
8772 if (UNLIKELY(state->argumentCount() < 1))
8773 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8774 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "documentIdentifier", "Document"); });
8775 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8776 return JSValue::encode(toJS<IDLUnsignedLongLong>(impl.documentIdentifier(*document)));
8777}
8778
8779EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDocumentIdentifier(ExecState* state)
8780{
8781 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDocumentIdentifierBody>(*state, "documentIdentifier");
8782}
8783
8784static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsDocumentAliveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8785{
8786 UNUSED_PARAM(state);
8787 UNUSED_PARAM(throwScope);
8788 auto& impl = castedThis->wrapped();
8789 if (UNLIKELY(state->argumentCount() < 1))
8790 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8791 auto documentIdentifier = convert<IDLUnsignedLongLong>(*state, state->uncheckedArgument(0));
8792 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8793 return JSValue::encode(toJS<IDLBoolean>(impl.isDocumentAlive(WTFMove(documentIdentifier))));
8794}
8795
8796EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsDocumentAlive(ExecState* state)
8797{
8798 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsDocumentAliveBody>(*state, "isDocumentAlive");
8799}
8800
8801static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAliveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8802{
8803 UNUSED_PARAM(state);
8804 UNUSED_PARAM(throwScope);
8805 auto& impl = castedThis->wrapped();
8806 return JSValue::encode(toJS<IDLBoolean>(impl.isAnyWorkletGlobalScopeAlive()));
8807}
8808
8809EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAlive(ExecState* state)
8810{
8811 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAliveBody>(*state, "isAnyWorkletGlobalScopeAlive");
8812}
8813
8814static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionServiceWorkerClientIdentifierBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8815{
8816 UNUSED_PARAM(state);
8817 UNUSED_PARAM(throwScope);
8818 auto& impl = castedThis->wrapped();
8819 if (UNLIKELY(state->argumentCount() < 1))
8820 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8821 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "serviceWorkerClientIdentifier", "Document"); });
8822 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8823 return JSValue::encode(toJS<IDLDOMString>(*state, impl.serviceWorkerClientIdentifier(*document)));
8824}
8825
8826EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionServiceWorkerClientIdentifier(ExecState* state)
8827{
8828 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionServiceWorkerClientIdentifierBody>(*state, "serviceWorkerClientIdentifier");
8829}
8830
8831static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStoreRegistrationsOnDiskBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8832{
8833 UNUSED_PARAM(state);
8834 UNUSED_PARAM(throwScope);
8835 auto& impl = castedThis->wrapped();
8836 impl.storeRegistrationsOnDisk(WTFMove(promise));
8837 return JSValue::encode(jsUndefined());
8838}
8839
8840EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStoreRegistrationsOnDisk(ExecState* state)
8841{
8842 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionStoreRegistrationsOnDiskBody, PromiseExecutionScope::WindowOnly>(*state, "storeRegistrationsOnDisk");
8843}
8844
8845static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentationBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8846{
8847 UNUSED_PARAM(state);
8848 UNUSED_PARAM(throwScope);
8849 auto& impl = castedThis->wrapped();
8850 impl.clearCacheStorageMemoryRepresentation(WTFMove(promise));
8851 return JSValue::encode(jsUndefined());
8852}
8853
8854EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentation(ExecState* state)
8855{
8856 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentationBody, PromiseExecutionScope::WindowOnly>(*state, "clearCacheStorageMemoryRepresentation");
8857}
8858
8859static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCacheStorageEngineRepresentationBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8860{
8861 UNUSED_PARAM(state);
8862 UNUSED_PARAM(throwScope);
8863 auto& impl = castedThis->wrapped();
8864 impl.cacheStorageEngineRepresentation(WTFMove(promise));
8865 return JSValue::encode(jsUndefined());
8866}
8867
8868EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCacheStorageEngineRepresentation(ExecState* state)
8869{
8870 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionCacheStorageEngineRepresentationBody, PromiseExecutionScope::WindowOnly>(*state, "cacheStorageEngineRepresentation");
8871}
8872
8873static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetResponseSizeWithPaddingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8874{
8875 UNUSED_PARAM(state);
8876 UNUSED_PARAM(throwScope);
8877 auto& impl = castedThis->wrapped();
8878 if (UNLIKELY(state->argumentCount() < 2))
8879 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8880 auto response = convert<IDLInterface<FetchResponse>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "response", "Internals", "setResponseSizeWithPadding", "FetchResponse"); });
8881 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8882 auto size = convert<IDLUnsignedLongLong>(*state, state->uncheckedArgument(1));
8883 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8884 impl.setResponseSizeWithPadding(*response, WTFMove(size));
8885 return JSValue::encode(jsUndefined());
8886}
8887
8888EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetResponseSizeWithPadding(ExecState* state)
8889{
8890 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetResponseSizeWithPaddingBody>(*state, "setResponseSizeWithPadding");
8891}
8892
8893static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionResponseSizeWithPaddingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8894{
8895 UNUSED_PARAM(state);
8896 UNUSED_PARAM(throwScope);
8897 auto& impl = castedThis->wrapped();
8898 if (UNLIKELY(state->argumentCount() < 1))
8899 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8900 auto response = convert<IDLInterface<FetchResponse>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "response", "Internals", "responseSizeWithPadding", "FetchResponse"); });
8901 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8902 return JSValue::encode(toJS<IDLUnsignedLongLong>(impl.responseSizeWithPadding(*response)));
8903}
8904
8905EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResponseSizeWithPadding(ExecState* state)
8906{
8907 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionResponseSizeWithPaddingBody>(*state, "responseSizeWithPadding");
8908}
8909
8910static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsageBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8911{
8912 UNUSED_PARAM(state);
8913 UNUSED_PARAM(throwScope);
8914 auto& impl = castedThis->wrapped();
8915 impl.updateQuotaBasedOnSpaceUsage();
8916 return JSValue::encode(jsUndefined());
8917}
8918
8919EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsage(ExecState* state)
8920{
8921 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsageBody>(*state, "updateQuotaBasedOnSpaceUsage");
8922}
8923
8924static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetConsoleMessageListenerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8925{
8926 UNUSED_PARAM(state);
8927 UNUSED_PARAM(throwScope);
8928 auto& impl = castedThis->wrapped();
8929 if (UNLIKELY(state->argumentCount() < 1))
8930 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8931 auto callback = convert<IDLCallbackFunction<JSStringCallback>>(*state, state->uncheckedArgument(0), *castedThis->globalObject(), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(state, scope, 0, "callback", "Internals", "setConsoleMessageListener"); });
8932 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8933 impl.setConsoleMessageListener(callback.releaseNonNull());
8934 return JSValue::encode(jsUndefined());
8935}
8936
8937EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetConsoleMessageListener(ExecState* state)
8938{
8939 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetConsoleMessageListenerBody>(*state, "setConsoleMessageListener");
8940}
8941
8942static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAudioSessionCategoryBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8943{
8944 UNUSED_PARAM(state);
8945 UNUSED_PARAM(throwScope);
8946 auto& impl = castedThis->wrapped();
8947 return JSValue::encode(toJS<IDLDOMString>(*state, impl.audioSessionCategory()));
8948}
8949
8950EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAudioSessionCategory(ExecState* state)
8951{
8952 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAudioSessionCategoryBody>(*state, "audioSessionCategory");
8953}
8954
8955static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPreferredAudioBufferSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8956{
8957 UNUSED_PARAM(state);
8958 UNUSED_PARAM(throwScope);
8959 auto& impl = castedThis->wrapped();
8960 return JSValue::encode(toJS<IDLDouble>(impl.preferredAudioBufferSize()));
8961}
8962
8963EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPreferredAudioBufferSize(ExecState* state)
8964{
8965 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPreferredAudioBufferSizeBody>(*state, "preferredAudioBufferSize");
8966}
8967
8968static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAudioSessionActiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8969{
8970 UNUSED_PARAM(state);
8971 UNUSED_PARAM(throwScope);
8972 auto& impl = castedThis->wrapped();
8973 return JSValue::encode(toJS<IDLBoolean>(impl.audioSessionActive()));
8974}
8975
8976EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAudioSessionActive(ExecState* state)
8977{
8978 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAudioSessionActiveBody>(*state, "audioSessionActive");
8979}
8980
8981#if ENABLE(SERVICE_WORKER)
8982static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasServiceWorkerRegistrationBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8983{
8984 UNUSED_PARAM(state);
8985 UNUSED_PARAM(throwScope);
8986 auto& impl = castedThis->wrapped();
8987 if (UNLIKELY(state->argumentCount() < 1))
8988 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8989 auto scopeURL = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
8990 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8991 impl.hasServiceWorkerRegistration(WTFMove(scopeURL), WTFMove(promise));
8992 return JSValue::encode(jsUndefined());
8993}
8994
8995EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasServiceWorkerRegistration(ExecState* state)
8996{
8997 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionHasServiceWorkerRegistrationBody, PromiseExecutionScope::WindowOnly>(*state, "hasServiceWorkerRegistration");
8998}
8999
9000#endif
9001
9002#if ENABLE(SERVICE_WORKER)
9003static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTerminateServiceWorkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9004{
9005 UNUSED_PARAM(state);
9006 UNUSED_PARAM(throwScope);
9007 auto& impl = castedThis->wrapped();
9008 if (UNLIKELY(state->argumentCount() < 1))
9009 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9010 auto worker = convert<IDLInterface<ServiceWorker>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "worker", "Internals", "terminateServiceWorker", "ServiceWorker"); });
9011 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9012 impl.terminateServiceWorker(*worker);
9013 return JSValue::encode(jsUndefined());
9014}
9015
9016EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTerminateServiceWorker(ExecState* state)
9017{
9018 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTerminateServiceWorkerBody>(*state, "terminateServiceWorker");
9019}
9020
9021#endif
9022
9023#if ENABLE(SERVICE_WORKER)
9024static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasServiceWorkerConnectionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9025{
9026 UNUSED_PARAM(state);
9027 UNUSED_PARAM(throwScope);
9028 auto& impl = castedThis->wrapped();
9029 return JSValue::encode(toJS<IDLBoolean>(impl.hasServiceWorkerConnection()));
9030}
9031
9032EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasServiceWorkerConnection(ExecState* state)
9033{
9034 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasServiceWorkerConnectionBody>(*state, "hasServiceWorkerConnection");
9035}
9036
9037#endif
9038
9039static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsSystemPreviewLinkBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9040{
9041 UNUSED_PARAM(state);
9042 UNUSED_PARAM(throwScope);
9043 auto& impl = castedThis->wrapped();
9044 if (UNLIKELY(state->argumentCount() < 1))
9045 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9046 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isSystemPreviewLink", "Element"); });
9047 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9048 return JSValue::encode(toJS<IDLBoolean>(impl.isSystemPreviewLink(*element)));
9049}
9050
9051EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSystemPreviewLink(ExecState* state)
9052{
9053 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsSystemPreviewLinkBody>(*state, "isSystemPreviewLink");
9054}
9055
9056static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsSystemPreviewImageBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9057{
9058 UNUSED_PARAM(state);
9059 UNUSED_PARAM(throwScope);
9060 auto& impl = castedThis->wrapped();
9061 if (UNLIKELY(state->argumentCount() < 1))
9062 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9063 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isSystemPreviewImage", "Element"); });
9064 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9065 return JSValue::encode(toJS<IDLBoolean>(impl.isSystemPreviewImage(*element)));
9066}
9067
9068EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSystemPreviewImage(ExecState* state)
9069{
9070 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsSystemPreviewImageBody>(*state, "isSystemPreviewImage");
9071}
9072
9073static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUsingAppleInternalSDKBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9074{
9075 UNUSED_PARAM(state);
9076 UNUSED_PARAM(throwScope);
9077 auto& impl = castedThis->wrapped();
9078 return JSValue::encode(toJS<IDLBoolean>(impl.usingAppleInternalSDK()));
9079}
9080
9081EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUsingAppleInternalSDK(ExecState* state)
9082{
9083 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUsingAppleInternalSDKBody>(*state, "usingAppleInternalSDK");
9084}
9085
9086static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPostTaskBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9087{
9088 UNUSED_PARAM(state);
9089 UNUSED_PARAM(throwScope);
9090 auto& impl = castedThis->wrapped();
9091 if (UNLIKELY(state->argumentCount() < 1))
9092 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9093 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*state, state->uncheckedArgument(0), *castedThis->globalObject(), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(state, scope, 0, "callback", "Internals", "postTask"); });
9094 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9095 impl.postTask(callback.releaseNonNull());
9096 return JSValue::encode(jsUndefined());
9097}
9098
9099EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPostTask(ExecState* state)
9100{
9101 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPostTaskBody>(*state, "postTask");
9102}
9103
9104static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkContextAsInsecureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9105{
9106 UNUSED_PARAM(state);
9107 UNUSED_PARAM(throwScope);
9108 auto& impl = castedThis->wrapped();
9109 impl.markContextAsInsecure();
9110 return JSValue::encode(jsUndefined());
9111}
9112
9113EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkContextAsInsecure(ExecState* state)
9114{
9115 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkContextAsInsecureBody>(*state, "markContextAsInsecure");
9116}
9117
9118#if ENABLE(VIDEO)
9119static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManagerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9120{
9121 UNUSED_PARAM(state);
9122 UNUSED_PARAM(throwScope);
9123 auto& impl = castedThis->wrapped();
9124 if (UNLIKELY(state->argumentCount() < 1))
9125 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9126 auto purpose = convert<IDLEnumeration<Internals::PlaybackControlsPurpose>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "purpose", "Internals", "bestMediaElementForShowingPlaybackControlsManager", expectedEnumerationValues<Internals::PlaybackControlsPurpose>()); });
9127 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9128 return JSValue::encode(toJS<IDLInterface<HTMLMediaElement>>(*state, *castedThis->globalObject(), impl.bestMediaElementForShowingPlaybackControlsManager(WTFMove(purpose))));
9129}
9130
9131EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManager(ExecState* state)
9132{
9133 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManagerBody>(*state, "bestMediaElementForShowingPlaybackControlsManager");
9134}
9135
9136#endif
9137
9138#if ENABLE(VIDEO)
9139static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaSessionStateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9140{
9141 UNUSED_PARAM(state);
9142 UNUSED_PARAM(throwScope);
9143 auto& impl = castedThis->wrapped();
9144 if (UNLIKELY(state->argumentCount() < 1))
9145 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9146 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "mediaSessionState", "HTMLMediaElement"); });
9147 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9148 return JSValue::encode(toJS<IDLEnumeration<Internals::MediaSessionState>>(*state, impl.mediaSessionState(*element)));
9149}
9150
9151EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionState(ExecState* state)
9152{
9153 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaSessionStateBody>(*state, "mediaSessionState");
9154}
9155
9156#endif
9157
9158static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionOngoingLoadsDescriptionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9159{
9160 UNUSED_PARAM(state);
9161 UNUSED_PARAM(throwScope);
9162 auto& impl = castedThis->wrapped();
9163 return JSValue::encode(toJS<IDLDOMString>(*state, impl.ongoingLoadsDescriptions()));
9164}
9165
9166EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionOngoingLoadsDescriptions(ExecState* state)
9167{
9168 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionOngoingLoadsDescriptionsBody>(*state, "ongoingLoadsDescriptions");
9169}
9170
9171static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9172{
9173 UNUSED_PARAM(state);
9174 UNUSED_PARAM(throwScope);
9175 auto& impl = castedThis->wrapped();
9176 if (UNLIKELY(state->argumentCount() < 1))
9177 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9178 auto value = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
9179 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9180 impl.setCaptureExtraNetworkLoadMetricsEnabled(WTFMove(value));
9181 return JSValue::encode(jsUndefined());
9182}
9183
9184EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabled(ExecState* state)
9185{
9186 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabledBody>(*state, "setCaptureExtraNetworkLoadMetricsEnabled");
9187}
9188
9189static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReloadWithoutContentExtensionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9190{
9191 UNUSED_PARAM(state);
9192 UNUSED_PARAM(throwScope);
9193 auto& impl = castedThis->wrapped();
9194 impl.reloadWithoutContentExtensions();
9195 return JSValue::encode(jsUndefined());
9196}
9197
9198EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReloadWithoutContentExtensions(ExecState* state)
9199{
9200 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReloadWithoutContentExtensionsBody>(*state, "reloadWithoutContentExtensions");
9201}
9202
9203static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUseSystemAppearanceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9204{
9205 UNUSED_PARAM(state);
9206 UNUSED_PARAM(throwScope);
9207 auto& impl = castedThis->wrapped();
9208 if (UNLIKELY(state->argumentCount() < 1))
9209 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9210 auto value = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
9211 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9212 impl.setUseSystemAppearance(WTFMove(value));
9213 return JSValue::encode(jsUndefined());
9214}
9215
9216EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUseSystemAppearance(ExecState* state)
9217{
9218 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUseSystemAppearanceBody>(*state, "setUseSystemAppearance");
9219}
9220
9221static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPluginCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9222{
9223 UNUSED_PARAM(state);
9224 UNUSED_PARAM(throwScope);
9225 auto& impl = castedThis->wrapped();
9226 return JSValue::encode(toJS<IDLUnsignedLong>(impl.pluginCount()));
9227}
9228
9229EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPluginCount(ExecState* state)
9230{
9231 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPluginCountBody>(*state, "pluginCount");
9232}
9233
9234static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNotifyResourceLoadObserverBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9235{
9236 UNUSED_PARAM(state);
9237 UNUSED_PARAM(throwScope);
9238 auto& impl = castedThis->wrapped();
9239 impl.notifyResourceLoadObserver();
9240 return JSValue::encode(jsUndefined());
9241}
9242
9243EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNotifyResourceLoadObserver(ExecState* state)
9244{
9245 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNotifyResourceLoadObserverBody>(*state, "notifyResourceLoadObserver");
9246}
9247
9248static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPrimaryScreenDisplayIDBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9249{
9250 UNUSED_PARAM(state);
9251 UNUSED_PARAM(throwScope);
9252 auto& impl = castedThis->wrapped();
9253 return JSValue::encode(toJS<IDLUnsignedLong>(impl.primaryScreenDisplayID()));
9254}
9255
9256EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPrimaryScreenDisplayID(ExecState* state)
9257{
9258 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPrimaryScreenDisplayIDBody>(*state, "primaryScreenDisplayID");
9259}
9260
9261static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCapsLockIsOnBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9262{
9263 UNUSED_PARAM(state);
9264 UNUSED_PARAM(throwScope);
9265 auto& impl = castedThis->wrapped();
9266 return JSValue::encode(toJS<IDLBoolean>(impl.capsLockIsOn()));
9267}
9268
9269EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCapsLockIsOn(ExecState* state)
9270{
9271 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCapsLockIsOnBody>(*state, "capsLockIsOn");
9272}
9273
9274static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSupportsVCPEncoderBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9275{
9276 UNUSED_PARAM(state);
9277 UNUSED_PARAM(throwScope);
9278 auto& impl = castedThis->wrapped();
9279 return JSValue::encode(toJS<IDLBoolean>(impl.supportsVCPEncoder()));
9280}
9281
9282EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSupportsVCPEncoder(ExecState* state)
9283{
9284 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSupportsVCPEncoderBody>(*state, "supportsVCPEncoder");
9285}
9286
9287static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionParseHEVCCodecParametersBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9288{
9289 UNUSED_PARAM(state);
9290 UNUSED_PARAM(throwScope);
9291 auto& impl = castedThis->wrapped();
9292 if (UNLIKELY(state->argumentCount() < 1))
9293 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9294 auto codecParameters = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
9295 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9296 return JSValue::encode(toJS<IDLNullable<IDLDictionary<Internals::HEVCParameterSet>>>(*state, *castedThis->globalObject(), impl.parseHEVCCodecParameters(WTFMove(codecParameters))));
9297}
9298
9299EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParseHEVCCodecParameters(ExecState* state)
9300{
9301 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionParseHEVCCodecParametersBody>(*state, "parseHEVCCodecParameters");
9302}
9303
9304static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetCookiesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9305{
9306 UNUSED_PARAM(state);
9307 UNUSED_PARAM(throwScope);
9308 auto& impl = castedThis->wrapped();
9309 return JSValue::encode(toJS<IDLSequence<IDLDictionary<Internals::CookieData>>>(*state, *castedThis->globalObject(), impl.getCookies()));
9310}
9311
9312EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCookies(ExecState* state)
9313{
9314 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetCookiesBody>(*state, "getCookies");
9315}
9316
9317static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9318{
9319 UNUSED_PARAM(state);
9320 UNUSED_PARAM(throwScope);
9321 auto& impl = castedThis->wrapped();
9322 if (UNLIKELY(state->argumentCount() < 1))
9323 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9324 auto alwaysAllowLocalWebarchive = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
9325 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9326 impl.setAlwaysAllowLocalWebarchive(WTFMove(alwaysAllowLocalWebarchive));
9327 return JSValue::encode(jsUndefined());
9328}
9329
9330EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchive(ExecState* state)
9331{
9332 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchiveBody>(*state, "setAlwaysAllowLocalWebarchive");
9333}
9334
9335static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionProcessWillSuspendBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9336{
9337 UNUSED_PARAM(state);
9338 UNUSED_PARAM(throwScope);
9339 auto& impl = castedThis->wrapped();
9340 impl.processWillSuspend();
9341 return JSValue::encode(jsUndefined());
9342}
9343
9344EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionProcessWillSuspend(ExecState* state)
9345{
9346 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionProcessWillSuspendBody>(*state, "processWillSuspend");
9347}
9348
9349static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionProcessDidResumeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9350{
9351 UNUSED_PARAM(state);
9352 UNUSED_PARAM(throwScope);
9353 auto& impl = castedThis->wrapped();
9354 impl.processDidResume();
9355 return JSValue::encode(jsUndefined());
9356}
9357
9358EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionProcessDidResume(ExecState* state)
9359{
9360 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionProcessDidResumeBody>(*state, "processDidResume");
9361}
9362
9363static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTestDictionaryLoggingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9364{
9365 UNUSED_PARAM(state);
9366 UNUSED_PARAM(throwScope);
9367 auto& impl = castedThis->wrapped();
9368 impl.testDictionaryLogging();
9369 return JSValue::encode(jsUndefined());
9370}
9371
9372EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTestDictionaryLogging(ExecState* state)
9373{
9374 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTestDictionaryLoggingBody>(*state, "testDictionaryLogging");
9375}
9376
9377static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwardingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9378{
9379 UNUSED_PARAM(state);
9380 UNUSED_PARAM(throwScope);
9381 auto& impl = castedThis->wrapped();
9382 if (UNLIKELY(state->argumentCount() < 2))
9383 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9384 auto xhr = convert<IDLInterface<XMLHttpRequest>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "xhr", "Internals", "setXHRMaximumIntervalForUserGestureForwarding", "XMLHttpRequest"); });
9385 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9386 auto interval = convert<IDLDouble>(*state, state->uncheckedArgument(1));
9387 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9388 impl.setXHRMaximumIntervalForUserGestureForwarding(*xhr, WTFMove(interval));
9389 return JSValue::encode(jsUndefined());
9390}
9391
9392EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwarding(ExecState* state)
9393{
9394 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwardingBody>(*state, "setXHRMaximumIntervalForUserGestureForwarding");
9395}
9396
9397static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetIsPlayingToAutomotiveHeadUnitBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9398{
9399 UNUSED_PARAM(state);
9400 UNUSED_PARAM(throwScope);
9401 auto& impl = castedThis->wrapped();
9402 if (UNLIKELY(state->argumentCount() < 1))
9403 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9404 auto value = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
9405 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9406 impl.setIsPlayingToAutomotiveHeadUnit(WTFMove(value));
9407 return JSValue::encode(jsUndefined());
9408}
9409
9410EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetIsPlayingToAutomotiveHeadUnit(ExecState* state)
9411{
9412 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetIsPlayingToAutomotiveHeadUnitBody>(*state, "setIsPlayingToAutomotiveHeadUnit");
9413}
9414
9415void JSInternals::heapSnapshot(JSCell* cell, HeapSnapshotBuilder& builder)
9416{
9417 auto* thisObject = jsCast<JSInternals*>(cell);
9418 builder.setWrappedObjectForCell(cell, &thisObject->wrapped());
9419 if (thisObject->scriptExecutionContext())
9420 builder.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
9421 Base::heapSnapshot(cell, builder);
9422}
9423
9424bool JSInternalsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor, const char** reason)
9425{
9426 UNUSED_PARAM(handle);
9427 UNUSED_PARAM(visitor);
9428 UNUSED_PARAM(reason);
9429 return false;
9430}
9431
9432void JSInternalsOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
9433{
9434 auto* jsInternals = static_cast<JSInternals*>(handle.slot()->asCell());
9435 auto& world = *static_cast<DOMWrapperWorld*>(context);
9436 uncacheWrapper(world, &jsInternals->wrapped(), jsInternals);
9437}
9438
9439#if ENABLE(BINDING_INTEGRITY)
9440#if PLATFORM(WIN)
9441#pragma warning(disable: 4483)
9442extern "C" { extern void (*const __identifier("??_7Internals@WebCore@@6B@")[])(); }
9443#else
9444extern "C" { extern void* _ZTVN7WebCore9InternalsE[]; }
9445#endif
9446#endif
9447
9448JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject* globalObject, Ref<Internals>&& impl)
9449{
9450
9451#if ENABLE(BINDING_INTEGRITY)
9452 void* actualVTablePointer = *(reinterpret_cast<void**>(impl.ptr()));
9453#if PLATFORM(WIN)
9454 void* expectedVTablePointer = WTF_PREPARE_VTBL_POINTER_FOR_INSPECTION(__identifier("??_7Internals@WebCore@@6B@"));
9455#else
9456 void* expectedVTablePointer = WTF_PREPARE_VTBL_POINTER_FOR_INSPECTION(&_ZTVN7WebCore9InternalsE[2]);
9457#endif
9458
9459 // If this fails Internals does not have a vtable, so you need to add the
9460 // ImplementationLacksVTable attribute to the interface definition
9461 static_assert(std::is_polymorphic<Internals>::value, "Internals is not polymorphic");
9462
9463 // If you hit this assertion you either have a use after free bug, or
9464 // Internals has subclasses. If Internals has subclasses that get passed
9465 // to toJS() we currently require Internals you to opt out of binding hardening
9466 // by adding the SkipVTableValidation attribute to the interface IDL definition
9467 RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
9468#endif
9469 return createWrapper<Internals>(globalObject, WTFMove(impl));
9470}
9471
9472JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, Internals& impl)
9473{
9474 return wrap(state, globalObject, impl);
9475}
9476
9477Internals* JSInternals::toWrapped(JSC::VM& vm, JSC::JSValue value)
9478{
9479 if (auto* wrapper = jsDynamicCast<JSInternals*>(vm, value))
9480 return &wrapper->wrapped();
9481 return nullptr;
9482}
9483
9484}
9485