1#![allow(non_camel_case_types,non_upper_case_globals,unsafe_op_in_unsafe_fn,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::enum_variant_names,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]
4
5use crate::codegen::GenericBindings::DocumentFragmentBinding::DocumentFragment_Binding;
6use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
7use crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull;
8use crate::codegen::GenericBindings::EventHandlerBinding::OnBeforeUnloadEventHandlerNonNull;
9use crate::codegen::GenericBindings::EventHandlerBinding::OnErrorEventHandlerNonNull;
10use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
11use crate::codegen::GenericBindings::FunctionBinding::Function;
12use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
13use crate::codegen::GenericBindings::HTMLMediaElementBinding::HTMLMediaElement_Binding;
14use crate::codegen::GenericBindings::ImageBitmapBinding::ColorSpaceConversion;
15use crate::codegen::GenericBindings::ImageBitmapBinding::ColorSpaceConversionValues;
16use crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions;
17use crate::codegen::GenericBindings::ImageBitmapBinding::ImageOrientation;
18use crate::codegen::GenericBindings::ImageBitmapBinding::ImageOrientationValues;
19use crate::codegen::GenericBindings::ImageBitmapBinding::PremultiplyAlpha;
20use crate::codegen::GenericBindings::ImageBitmapBinding::PremultiplyAlphaValues;
21use crate::codegen::GenericBindings::ImageBitmapBinding::ResizeQuality;
22use crate::codegen::GenericBindings::ImageBitmapBinding::ResizeQualityValues;
23use crate::codegen::GenericBindings::MessagePortBinding::StructuredSerializeOptions;
24use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
25use crate::codegen::GenericBindings::RequestBinding::ReferrerPolicy;
26use crate::codegen::GenericBindings::RequestBinding::ReferrerPolicyValues;
27use crate::codegen::GenericBindings::RequestBinding::RequestCache;
28use crate::codegen::GenericBindings::RequestBinding::RequestCacheValues;
29use crate::codegen::GenericBindings::RequestBinding::RequestCredentials;
30use crate::codegen::GenericBindings::RequestBinding::RequestCredentialsValues;
31use crate::codegen::GenericBindings::RequestBinding::RequestInit;
32use crate::codegen::GenericBindings::RequestBinding::RequestMode;
33use crate::codegen::GenericBindings::RequestBinding::RequestModeValues;
34use crate::codegen::GenericBindings::RequestBinding::RequestRedirect;
35use crate::codegen::GenericBindings::RequestBinding::RequestRedirectValues;
36use crate::codegen::GenericBindings::VoidFunctionBinding::VoidFunction;
37use crate::import::base::*;
38
39
40#[repr(usize)]
41#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
42pub enum ScrollBehavior {
43 Auto,
44 Instant,
45 Smooth
46}
47pub mod ScrollBehaviorValues {
48
49 use crate::utils::find_enum_value;
50 use js::conversions::ConversionResult;
51 use js::conversions::FromJSValConvertible;
52 use js::conversions::ToJSValConvertible;
53 use js::context::RawJSContext;
54 use js::rust::HandleValue;
55 use js::rust::MutableHandleValue;
56 use js::jsval::JSVal;
57
58 pub(crate) const pairs: &[(&str, super::ScrollBehavior)] = &[
59 ("auto", super::ScrollBehavior::Auto),
60 ("instant", super::ScrollBehavior::Instant),
61 ("smooth", super::ScrollBehavior::Smooth),
62 ];
63
64 impl super::ScrollBehavior {
65 pub fn as_str(&self) -> &'static str {
66 pairs[*self as usize].0
67 }
68 }
69
70 impl Default for super::ScrollBehavior {
71 fn default() -> super::ScrollBehavior {
72 pairs[0].1
73 }
74 }
75
76 impl std::str::FromStr for super::ScrollBehavior {
77 type Err = ();
78
79 fn from_str(s: &str) -> Result<Self, Self::Err> {
80 pairs
81 .iter()
82 .find(|&&(key, _)| s == key)
83 .map(|&(_, ev)| ev)
84 .ok_or(())
85 }
86 }
87
88 impl ToJSValConvertible for super::ScrollBehavior {
89 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
90 pairs[*self as usize].0.to_jsval(cx, rval);
91 }
92 }
93
94 impl FromJSValConvertible for super::ScrollBehavior {
95 type Config = ();
96 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
97 -> Result<ConversionResult<super::ScrollBehavior>, ()> {
98 match find_enum_value(cx, value, pairs) {
99 Err(_) => Err(()),
100 Ok((None, search)) => {
101 Ok(ConversionResult::Failure(
102 format!("'{}' is not a valid enum value for enumeration 'ScrollBehavior'.", search).into()
103 ))
104 }
105 Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
106 }
107 }
108 }
109 } #[derive(JSTraceable, Clone)]
112pub struct ScrollOptions {
113 pub behavior: ScrollBehavior,
114}
115impl Default for ScrollOptions {
116 fn default() -> Self {
117 Self::empty()
118 }
119}
120
121impl ScrollOptions {
122 pub fn empty() -> Self {
123 Self {
124 behavior: ScrollBehavior::Auto,
125 }
126 }
127 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
128 -> Result<ConversionResult<ScrollOptions>, ()> {
129 unsafe {
130 let object = if val.get().is_null_or_undefined() {
131 ptr::null_mut()
132 } else if val.get().is_object() {
133 val.get().to_object()
134 } else {
135 return Ok(ConversionResult::Failure("Value is not an object.".into()));
136 };
137 rooted!(&in(cx) let object = object);
138 let dictionary = ScrollOptions {
139 behavior: {
140 rooted!(&in(cx) let mut rval = UndefinedValue());
141 if get_dictionary_property(cx.raw_cx(), object.handle(), "behavior", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
142 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
143 Ok(ConversionResult::Success(value)) => value,
144 Ok(ConversionResult::Failure(error)) => {
145 throw_type_error(cx.raw_cx(), &error); return Err(());
146
147 }
148 _ => {
149 return Err(());
150
151 },
152 }
153
154 } else {
155 ScrollBehavior::Auto
156 }
157 },
158 };
159 Ok(ConversionResult::Success(dictionary))
160 }
161 }
162}
163
164impl FromJSValConvertible for ScrollOptions {
165 type Config = ();
166 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
167 -> Result<ConversionResult<ScrollOptions>, ()> {
168 ScrollOptions::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
169 }
170}
171
172impl ScrollOptions {
173 #[allow(clippy::wrong_self_convention)]
174 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
175 let behavior = &self.behavior;
176 rooted!(in(cx) let mut behavior_js = UndefinedValue());
177 behavior.to_jsval(cx, behavior_js.handle_mut());
178 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "behavior", behavior_js.handle()).unwrap();
179 }
180}
181
182impl ToJSValConvertible for ScrollOptions {
183 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
184 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
185 self.to_jsobject(cx, obj.handle_mut());
186 rval.set(ObjectOrNullValue(obj.get()))
187 }
188}
189
190
191#[derive(JSTraceable, Clone)]
192pub struct ScrollToOptions {
193 pub parent: crate::codegen::GenericBindings::WindowBinding::ScrollOptions,
194 pub left: Option<f64>,
195 pub top: Option<f64>,
196}
197impl Default for ScrollToOptions {
198 fn default() -> Self {
199 Self::empty()
200 }
201}
202
203impl ScrollToOptions {
204 pub fn empty() -> Self {
205 Self {
206 parent: crate::codegen::GenericBindings::WindowBinding::ScrollOptions::empty(),
207 left: None,
208 top: None,
209 }
210 }
211 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
212 -> Result<ConversionResult<ScrollToOptions>, ()> {
213 unsafe {
214 let object = if val.get().is_null_or_undefined() {
215 ptr::null_mut()
216 } else if val.get().is_object() {
217 val.get().to_object()
218 } else {
219 return Ok(ConversionResult::Failure("Value is not an object.".into()));
220 };
221 rooted!(&in(cx) let object = object);
222 let dictionary = ScrollToOptions {
223 parent: {
224 match crate::codegen::GenericBindings::WindowBinding::ScrollOptions::new(cx, val, can_gc)? {
225 ConversionResult::Success(v) => v,
226 ConversionResult::Failure(error) => {
227 throw_type_error(cx.raw_cx(), &error);
228 return Err(());
229 }
230 }
231 },
232 left: {
233 rooted!(&in(cx) let mut rval = UndefinedValue());
234 if get_dictionary_property(cx.raw_cx(), object.handle(), "left", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
235 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
236 Ok(ConversionResult::Success(value)) => value,
237 Ok(ConversionResult::Failure(error)) => {
238 throw_type_error(cx.raw_cx(), &error);
239 return Err(());
240
241 }
242 _ => {
243 return Err(());
244
245 },
246 }
247 )
248 } else {
249 None
250 }
251 },
252 top: {
253 rooted!(&in(cx) let mut rval = UndefinedValue());
254 if get_dictionary_property(cx.raw_cx(), object.handle(), "top", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
255 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
256 Ok(ConversionResult::Success(value)) => value,
257 Ok(ConversionResult::Failure(error)) => {
258 throw_type_error(cx.raw_cx(), &error);
259 return Err(());
260
261 }
262 _ => {
263 return Err(());
264
265 },
266 }
267 )
268 } else {
269 None
270 }
271 },
272 };
273 Ok(ConversionResult::Success(dictionary))
274 }
275 }
276}
277
278impl FromJSValConvertible for ScrollToOptions {
279 type Config = ();
280 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
281 -> Result<ConversionResult<ScrollToOptions>, ()> {
282 ScrollToOptions::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
283 }
284}
285
286impl ScrollToOptions {
287 #[allow(clippy::wrong_self_convention)]
288 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
289 self.parent.to_jsobject(cx, obj.reborrow());
290 if let Some(ref left) = self.left {
291 rooted!(in(cx) let mut left_js = UndefinedValue());
292 left.to_jsval(cx, left_js.handle_mut());
293 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "left", left_js.handle()).unwrap();
294 }
295 if let Some(ref top) = self.top {
296 rooted!(in(cx) let mut top_js = UndefinedValue());
297 top.to_jsval(cx, top_js.handle_mut());
298 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "top", top_js.handle()).unwrap();
299 }
300 }
301}
302
303impl ToJSValConvertible for ScrollToOptions {
304 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
305 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
306 self.to_jsobject(cx, obj.handle_mut());
307 rval.set(ObjectOrNullValue(obj.get()))
308 }
309}
310
311
312#[derive(JSTraceable)]
313#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
314pub struct WindowPostMessageOptions {
315 pub parent: RootedTraceableBox<crate::codegen::GenericBindings::MessagePortBinding::StructuredSerializeOptions>,
316 pub targetOrigin: USVString,
317}
318impl Default for WindowPostMessageOptions {
319 fn default() -> Self {
320 Self {
321 parent: Default::default(),
322 targetOrigin: Default::default(), }
323 }
324}
325
326impl WindowPostMessageOptions {
327 pub fn empty() -> RootedTraceableBox<Self> {
328 let mut dictionary = RootedTraceableBox::new(Self::default());
329 dictionary.parent = crate::codegen::GenericBindings::MessagePortBinding::StructuredSerializeOptions::empty();
330 dictionary.targetOrigin = USVString("/".to_owned());
331 dictionary
332 }
333 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
334 -> Result<ConversionResult<RootedTraceableBox<WindowPostMessageOptions>>, ()> {
335 unsafe {
336 let object = if val.get().is_null_or_undefined() {
337 ptr::null_mut()
338 } else if val.get().is_object() {
339 val.get().to_object()
340 } else {
341 return Ok(ConversionResult::Failure("Value is not an object.".into()));
342 };
343 rooted!(&in(cx) let object = object);
344 let dictionary = RootedTraceableBox::new(WindowPostMessageOptions {
345 parent: {
346 match crate::codegen::GenericBindings::MessagePortBinding::StructuredSerializeOptions::new(cx, val, can_gc)? {
347 ConversionResult::Success(v) => v,
348 ConversionResult::Failure(error) => {
349 throw_type_error(cx.raw_cx(), &error);
350 return Err(());
351 }
352 }
353 },
354 targetOrigin: {
355 rooted!(&in(cx) let mut rval = UndefinedValue());
356 if get_dictionary_property(cx.raw_cx(), object.handle(), "targetOrigin", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
357 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
358 Ok(ConversionResult::Success(value)) => value,
359 Ok(ConversionResult::Failure(error)) => {
360 throw_type_error(cx.raw_cx(), &error);
361 return Err(());
362
363 }
364 _ => {
365 return Err(());
366
367 },
368 }
369
370 } else {
371 USVString("/".to_owned())
372 }
373 },
374 });
375 Ok(ConversionResult::Success(dictionary))
376 }
377 }
378}
379
380impl FromJSValConvertible for RootedTraceableBox<WindowPostMessageOptions> {
381 type Config = ();
382 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
383 -> Result<ConversionResult<RootedTraceableBox<WindowPostMessageOptions>>, ()> {
384 WindowPostMessageOptions::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
385 }
386}
387
388impl WindowPostMessageOptions {
389 #[allow(clippy::wrong_self_convention)]
390 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
391 self.parent.to_jsobject(cx, obj.reborrow());
392 let targetOrigin = &self.targetOrigin;
393 rooted!(in(cx) let mut targetOrigin_js = UndefinedValue());
394 targetOrigin.to_jsval(cx, targetOrigin_js.handle_mut());
395 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "targetOrigin", targetOrigin_js.handle()).unwrap();
396 }
397}
398
399impl ToJSValConvertible for WindowPostMessageOptions {
400 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
401 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
402 self.to_jsobject(cx, obj.handle_mut());
403 rval.set(ObjectOrNullValue(obj.get()))
404 }
405}
406
407
408#[derive(JSTraceable)]
409#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
410pub struct DeferredRequestInit<D: DomTypes> {
411 pub parent: RootedTraceableBox<crate::codegen::GenericBindings::RequestBinding::RequestInit<D>>,
412 pub activateAfter: Option<Finite<f64>>,
413}
414impl<D: DomTypes> Default for DeferredRequestInit<D> {
415 fn default() -> Self {
416 Self {
417 parent: Default::default(),
418 activateAfter: Default::default(), }
419 }
420}
421
422impl<D: DomTypes> DeferredRequestInit<D> {
423 pub fn empty() -> RootedTraceableBox<Self> {
424 let mut dictionary = RootedTraceableBox::new(Self::default());
425 dictionary.parent = crate::codegen::GenericBindings::RequestBinding::RequestInit::empty();
426 dictionary.activateAfter = None;
427 dictionary
428 }
429 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
430 -> Result<ConversionResult<RootedTraceableBox<DeferredRequestInit<D>>>, ()> {
431 unsafe {
432 let object = if val.get().is_null_or_undefined() {
433 ptr::null_mut()
434 } else if val.get().is_object() {
435 val.get().to_object()
436 } else {
437 return Ok(ConversionResult::Failure("Value is not an object.".into()));
438 };
439 rooted!(&in(cx) let object = object);
440 let dictionary = RootedTraceableBox::new(DeferredRequestInit {
441 parent: {
442 match crate::codegen::GenericBindings::RequestBinding::RequestInit::new(cx, val, can_gc)? {
443 ConversionResult::Success(v) => v,
444 ConversionResult::Failure(error) => {
445 throw_type_error(cx.raw_cx(), &error);
446 return Err(());
447 }
448 }
449 },
450 activateAfter: {
451 rooted!(&in(cx) let mut rval = UndefinedValue());
452 if get_dictionary_property(cx.raw_cx(), object.handle(), "activateAfter", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
453 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
454 Ok(ConversionResult::Success(value)) => value,
455 Ok(ConversionResult::Failure(error)) => {
456 throw_type_error(cx.raw_cx(), &error);
457 return Err(());
458
459 }
460 _ => {
461 return Err(());
462
463 },
464 }
465 )
466 } else {
467 None
468 }
469 },
470 });
471 Ok(ConversionResult::Success(dictionary))
472 }
473 }
474}
475
476impl<D: DomTypes> FromJSValConvertible for RootedTraceableBox<DeferredRequestInit<D>> {
477 type Config = ();
478 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
479 -> Result<ConversionResult<RootedTraceableBox<DeferredRequestInit<D>>>, ()> {
480 DeferredRequestInit::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
481 }
482}
483
484impl<D: DomTypes> DeferredRequestInit<D> {
485 #[allow(clippy::wrong_self_convention)]
486 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
487 self.parent.to_jsobject(cx, obj.reborrow());
488 if let Some(ref activateAfter) = self.activateAfter {
489 rooted!(in(cx) let mut activateAfter_js = UndefinedValue());
490 activateAfter.to_jsval(cx, activateAfter_js.handle_mut());
491 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "activateAfter", activateAfter_js.handle()).unwrap();
492 }
493 }
494}
495
496impl<D: DomTypes> ToJSValConvertible for DeferredRequestInit<D> {
497 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
498 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
499 self.to_jsobject(cx, obj.handle_mut());
500 rval.set(ObjectOrNullValue(obj.get()))
501 }
502}
503
504
505#[derive(JSTraceable, MallocSizeOf, PartialEq)]
506#[cfg_attr(crown, allow(crown::unrooted_must_root))]
507#[cfg_attr(crown, crown::unrooted_must_root_lint::allow_unrooted_interior)]
508pub struct FrameRequestCallback<D: DomTypes> {
509 pub parent: CallbackFunction<D>,
510}
511
512impl<D: DomTypes> FrameRequestCallback<D> {
513
514 pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<FrameRequestCallback<D>> {
515 let mut ret = Rc::new(FrameRequestCallback {
516 parent: CallbackFunction::new()
517 });
518 match Rc::get_mut(&mut ret) {
520 Some(ref mut callback) => callback.parent.init(aCx, aCallback),
521 None => unreachable!(),
522 };
523 ret
524 }
525
526 pub fn Call_<T: ThisReflector>(&self, thisObj: &T, time: Finite<f64>, aExceptionHandling: ExceptionHandling, can_gc: CanGc) -> Fallible<()> {
527 let s = CallSetup::<D>::new(self, aExceptionHandling);
528 rooted!(in(*s.get_context()) let mut thisValue: JSVal);
529 let wrap_result = wrap_call_this_value(s.get_context(), thisObj, thisValue.handle_mut());
530 if !wrap_result {
531 return Err(JSFailed);
532 }
533 unsafe { self.Call(s.get_context(), thisValue.handle(), time, can_gc) }
534 }
535
536 pub fn Call__<>(&self, time: Finite<f64>, aExceptionHandling: ExceptionHandling, can_gc: CanGc) -> Fallible<()> {
537 let s = CallSetup::<D>::new(self, aExceptionHandling);
538
539 unsafe { self.Call(s.get_context(), HandleValue::undefined(), time, can_gc) }
540 }
541
542 unsafe fn Call<>(&self, cx: SafeJSContext, aThisObj: HandleValue, time: Finite<f64>, can_gc: CanGc) -> Fallible<()> {
543 rooted!(&in(cx) let mut rval = UndefinedValue());
544 rooted_vec!(let mut argv);
545 argv.extend((0..1).map(|_| Heap::default()));
546
547 let argc = 1;
548
549 rooted!(&in(cx) let mut argv_root = UndefinedValue());
550 (time).to_jsval(cx.raw_cx(), argv_root.handle_mut());
551 {
552 let arg = &mut argv[0];
553 *arg = Heap::default();
554 arg.set(argv_root.get());
555 }
556
557 rooted!(&in(cx) let callable = ObjectValue(self.callback()));
558 rooted!(&in(cx) let rootedThis = aThisObj.get());
559 let ok = Call(
560 cx.raw_cx(), rootedThis.handle(), callable.handle(),
561 &HandleValueArray {
562 length_: argc as ::libc::size_t,
563 elements_: argv.as_ptr() as *const JSVal
564 }, rval.handle_mut());
565 maybe_resume_unwind();
566 if !ok {
567 return Err(JSFailed);
568 }
569
570 Ok(())
571
572 }
573}
574
575impl<D: DomTypes> CallbackContainer<D> for FrameRequestCallback<D> {
576 unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<FrameRequestCallback<D>> {
577 FrameRequestCallback::new(cx, callback)
578 }
579
580 fn callback_holder(&self) -> &CallbackObject<D> {
581 self.parent.callback_holder()
582 }
583}
584
585impl<D: DomTypes> ToJSValConvertible for FrameRequestCallback<D> {
586 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
587 self.callback().to_jsval(cx, rval);
588 }
589}
590
591
592pub use self::Window_Binding::{Wrap, WindowMethods, GetProtoObject, DefineDOMInterface};
593pub mod Window_Binding {
594use crate::codegen::GenericBindings::DocumentFragmentBinding::DocumentFragment_Binding;
595use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
596use crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull;
597use crate::codegen::GenericBindings::EventHandlerBinding::OnBeforeUnloadEventHandlerNonNull;
598use crate::codegen::GenericBindings::EventHandlerBinding::OnErrorEventHandlerNonNull;
599use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
600use crate::codegen::GenericBindings::FunctionBinding::Function;
601use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
602use crate::codegen::GenericBindings::HTMLMediaElementBinding::HTMLMediaElement_Binding;
603use crate::codegen::GenericBindings::ImageBitmapBinding::ColorSpaceConversion;
604use crate::codegen::GenericBindings::ImageBitmapBinding::ColorSpaceConversionValues;
605use crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions;
606use crate::codegen::GenericBindings::ImageBitmapBinding::ImageOrientation;
607use crate::codegen::GenericBindings::ImageBitmapBinding::ImageOrientationValues;
608use crate::codegen::GenericBindings::ImageBitmapBinding::PremultiplyAlpha;
609use crate::codegen::GenericBindings::ImageBitmapBinding::PremultiplyAlphaValues;
610use crate::codegen::GenericBindings::ImageBitmapBinding::ResizeQuality;
611use crate::codegen::GenericBindings::ImageBitmapBinding::ResizeQualityValues;
612use crate::codegen::GenericBindings::MessagePortBinding::StructuredSerializeOptions;
613use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
614use crate::codegen::GenericBindings::RequestBinding::ReferrerPolicy;
615use crate::codegen::GenericBindings::RequestBinding::ReferrerPolicyValues;
616use crate::codegen::GenericBindings::RequestBinding::RequestCache;
617use crate::codegen::GenericBindings::RequestBinding::RequestCacheValues;
618use crate::codegen::GenericBindings::RequestBinding::RequestCredentials;
619use crate::codegen::GenericBindings::RequestBinding::RequestCredentialsValues;
620use crate::codegen::GenericBindings::RequestBinding::RequestInit;
621use crate::codegen::GenericBindings::RequestBinding::RequestMode;
622use crate::codegen::GenericBindings::RequestBinding::RequestModeValues;
623use crate::codegen::GenericBindings::RequestBinding::RequestRedirect;
624use crate::codegen::GenericBindings::RequestBinding::RequestRedirectValues;
625use crate::codegen::GenericBindings::VoidFunctionBinding::VoidFunction;
626use crate::codegen::GenericBindings::WindowBinding::DeferredRequestInit;
627use crate::codegen::GenericBindings::WindowBinding::FrameRequestCallback;
628use crate::codegen::GenericBindings::WindowBinding::ScrollBehavior;
629use crate::codegen::GenericBindings::WindowBinding::ScrollBehaviorValues;
630use crate::codegen::GenericBindings::WindowBinding::ScrollToOptions;
631use crate::codegen::GenericBindings::WindowBinding::WindowPostMessageOptions;
632use crate::import::module::*;
633
634unsafe extern "C" fn get_window<D: DomTypes>
635(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
636 let mut result = false;
637 wrap_panic(&mut || result = (|| {
638 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
639 let this = &*(this as *const D::Window);
640 let result: DomRoot<D::WindowProxy> = this.Window();
641
642 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
643 return true;
644 })());
645 result
646}
647
648
649static window_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
650
651pub(crate) fn init_window_getterinfo<D: DomTypes>() {
652 window_getterinfo.set(JSJitInfo {
653 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
654 getter: Some(get_window::<D>)
655 },
656 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
657 protoID: PrototypeList::ID::Window as u16,
658 },
659 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
660 _bitfield_align_1: [],
661 _bitfield_1: __BindgenBitfieldUnit::new(
662 new_jsjitinfo_bitfield_1!(
663 JSJitInfo_OpType::Getter as u8,
664 JSJitInfo_AliasSet::AliasEverything as u8,
665 JSValueType::JSVAL_TYPE_OBJECT as u8,
666 true,
667 false,
668 false,
669 false,
670 false,
671 false,
672 0,
673 ).to_ne_bytes()
674 ),
675});
676}
677unsafe extern "C" fn get_self<D: DomTypes>
678(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
679 let mut result = false;
680 wrap_panic(&mut || result = (|| {
681 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
682 let this = &*(this as *const D::Window);
683 let result: DomRoot<D::WindowProxy> = this.Self_();
684
685 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
686 return true;
687 })());
688 result
689}
690
691unsafe extern "C" fn set_self<D: DomTypes>
692(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
693 let mut result = false;
694 wrap_panic(&mut || result = {
695
696 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"self".as_ptr(),
697 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
698 });
699 result
700}
701
702
703static self_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
704
705pub(crate) fn init_self_getterinfo<D: DomTypes>() {
706 self_getterinfo.set(JSJitInfo {
707 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
708 getter: Some(get_self::<D>)
709 },
710 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
711 protoID: PrototypeList::ID::Window as u16,
712 },
713 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
714 _bitfield_align_1: [],
715 _bitfield_1: __BindgenBitfieldUnit::new(
716 new_jsjitinfo_bitfield_1!(
717 JSJitInfo_OpType::Getter as u8,
718 JSJitInfo_AliasSet::AliasEverything as u8,
719 JSValueType::JSVAL_TYPE_OBJECT as u8,
720 true,
721 false,
722 false,
723 false,
724 false,
725 false,
726 0,
727 ).to_ne_bytes()
728 ),
729});
730}
731static self_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
732
733pub(crate) fn init_self_setterinfo<D: DomTypes>() {
734 self_setterinfo.set(JSJitInfo {
735 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
736 setter: Some(set_self::<D>)
737 },
738 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
739 protoID: PrototypeList::ID::Window as u16,
740 },
741 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
742 _bitfield_align_1: [],
743 _bitfield_1: __BindgenBitfieldUnit::new(
744 new_jsjitinfo_bitfield_1!(
745 JSJitInfo_OpType::Setter as u8,
746 JSJitInfo_AliasSet::AliasEverything as u8,
747 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
748 false,
749 false,
750 false,
751 false,
752 false,
753 false,
754 0,
755 ).to_ne_bytes()
756 ),
757});
758}
759unsafe extern "C" fn get_document<D: DomTypes>
760(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
761 let mut result = false;
762 wrap_panic(&mut || result = (|| {
763 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
764 let this = &*(this as *const D::Window);
765 let result: DomRoot<D::Document> = this.Document();
766
767 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
768 return true;
769 })());
770 result
771}
772
773
774static document_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
775
776pub(crate) fn init_document_getterinfo<D: DomTypes>() {
777 document_getterinfo.set(JSJitInfo {
778 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
779 getter: Some(get_document::<D>)
780 },
781 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
782 protoID: PrototypeList::ID::Window as u16,
783 },
784 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
785 _bitfield_align_1: [],
786 _bitfield_1: __BindgenBitfieldUnit::new(
787 new_jsjitinfo_bitfield_1!(
788 JSJitInfo_OpType::Getter as u8,
789 JSJitInfo_AliasSet::AliasEverything as u8,
790 JSValueType::JSVAL_TYPE_OBJECT as u8,
791 true,
792 false,
793 false,
794 false,
795 false,
796 false,
797 0,
798 ).to_ne_bytes()
799 ),
800});
801}
802unsafe extern "C" fn get_name<D: DomTypes>
803(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
804 let mut result = false;
805 wrap_panic(&mut || result = (|| {
806 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
807 let this = &*(this as *const D::Window);
808 let result: DOMString = this.Name();
809
810 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
811 return true;
812 })());
813 result
814}
815
816unsafe extern "C" fn set_name<D: DomTypes>
817(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
818 let mut result = false;
819 wrap_panic(&mut || result = (|| {
820 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
821 let this = &*(this as *const D::Window);
822 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
823 Ok(ConversionResult::Success(value)) => value,
824 Ok(ConversionResult::Failure(error)) => {
825 throw_type_error(cx.raw_cx(), &error);
826 return false;
827
828 }
829 _ => {
830 return false;
831
832 },
833 }
834 ;
835 let result: () = this.SetName(arg0);
836
837 true
838 })());
839 result
840}
841
842
843static name_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
844
845pub(crate) fn init_name_getterinfo<D: DomTypes>() {
846 name_getterinfo.set(JSJitInfo {
847 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
848 getter: Some(get_name::<D>)
849 },
850 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
851 protoID: PrototypeList::ID::Window as u16,
852 },
853 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
854 _bitfield_align_1: [],
855 _bitfield_1: __BindgenBitfieldUnit::new(
856 new_jsjitinfo_bitfield_1!(
857 JSJitInfo_OpType::Getter as u8,
858 JSJitInfo_AliasSet::AliasEverything as u8,
859 JSValueType::JSVAL_TYPE_STRING as u8,
860 true,
861 false,
862 false,
863 false,
864 false,
865 false,
866 0,
867 ).to_ne_bytes()
868 ),
869});
870}
871static name_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
872
873pub(crate) fn init_name_setterinfo<D: DomTypes>() {
874 name_setterinfo.set(JSJitInfo {
875 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
876 setter: Some(set_name::<D>)
877 },
878 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
879 protoID: PrototypeList::ID::Window as u16,
880 },
881 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
882 _bitfield_align_1: [],
883 _bitfield_1: __BindgenBitfieldUnit::new(
884 new_jsjitinfo_bitfield_1!(
885 JSJitInfo_OpType::Setter as u8,
886 JSJitInfo_AliasSet::AliasEverything as u8,
887 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
888 false,
889 false,
890 false,
891 false,
892 false,
893 false,
894 0,
895 ).to_ne_bytes()
896 ),
897});
898}
899unsafe extern "C" fn get_location<D: DomTypes>
900(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
901 let mut result = false;
902 wrap_panic(&mut || result = (|| {
903 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
904 let this = &*(this as *const D::Window);
905 let result: DomRoot<D::Location> = this.Location();
906
907 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
908 return true;
909 })());
910 result
911}
912
913unsafe extern "C" fn set_location<D: DomTypes>
914(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
915 let mut result = false;
916 wrap_panic(&mut || result = (|| {
917
918 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
919 rooted!(&in(cx) let mut v = UndefinedValue());
920 if !JS_GetProperty(cx.raw_cx(), HandleObject::from_raw(obj), c"location".as_ptr(), v.handle_mut()) {
921 return false;
922 }
923 if !v.is_object() {
924 throw_type_error(cx.raw_cx(), "Value.location is not an object.");
925 return false;
926 }
927 rooted!(&in(cx) let target_obj = v.to_object());
928 JS_SetProperty(cx.raw_cx(), target_obj.handle(), c"href".as_ptr(), HandleValue::from_raw(args.get(0)))
929
930 })());
931 result
932}
933
934
935static location_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
936
937pub(crate) fn init_location_getterinfo<D: DomTypes>() {
938 location_getterinfo.set(JSJitInfo {
939 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
940 getter: Some(get_location::<D>)
941 },
942 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
943 protoID: PrototypeList::ID::Window as u16,
944 },
945 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
946 _bitfield_align_1: [],
947 _bitfield_1: __BindgenBitfieldUnit::new(
948 new_jsjitinfo_bitfield_1!(
949 JSJitInfo_OpType::Getter as u8,
950 JSJitInfo_AliasSet::AliasEverything as u8,
951 JSValueType::JSVAL_TYPE_OBJECT as u8,
952 true,
953 false,
954 false,
955 false,
956 false,
957 false,
958 0,
959 ).to_ne_bytes()
960 ),
961});
962}
963static location_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
964
965pub(crate) fn init_location_setterinfo<D: DomTypes>() {
966 location_setterinfo.set(JSJitInfo {
967 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
968 setter: Some(set_location::<D>)
969 },
970 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
971 protoID: PrototypeList::ID::Window as u16,
972 },
973 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
974 _bitfield_align_1: [],
975 _bitfield_1: __BindgenBitfieldUnit::new(
976 new_jsjitinfo_bitfield_1!(
977 JSJitInfo_OpType::Setter as u8,
978 JSJitInfo_AliasSet::AliasEverything as u8,
979 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
980 false,
981 false,
982 false,
983 false,
984 false,
985 false,
986 0,
987 ).to_ne_bytes()
988 ),
989});
990}
991unsafe extern "C" fn get_history<D: DomTypes>
992(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
993 let mut result = false;
994 wrap_panic(&mut || result = (|| {
995 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
996 let this = &*(this as *const D::Window);
997 let result: DomRoot<D::History> = this.History();
998
999 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1000 return true;
1001 })());
1002 result
1003}
1004
1005
1006static history_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1007
1008pub(crate) fn init_history_getterinfo<D: DomTypes>() {
1009 history_getterinfo.set(JSJitInfo {
1010 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1011 getter: Some(get_history::<D>)
1012 },
1013 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1014 protoID: PrototypeList::ID::Window as u16,
1015 },
1016 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1017 _bitfield_align_1: [],
1018 _bitfield_1: __BindgenBitfieldUnit::new(
1019 new_jsjitinfo_bitfield_1!(
1020 JSJitInfo_OpType::Getter as u8,
1021 JSJitInfo_AliasSet::AliasEverything as u8,
1022 JSValueType::JSVAL_TYPE_OBJECT as u8,
1023 true,
1024 false,
1025 false,
1026 false,
1027 false,
1028 false,
1029 0,
1030 ).to_ne_bytes()
1031 ),
1032});
1033}
1034unsafe extern "C" fn get_customElements<D: DomTypes>
1035(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1036 let mut result = false;
1037 wrap_panic(&mut || result = (|| {
1038 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1039 let this = &*(this as *const D::Window);
1040 let result: DomRoot<D::CustomElementRegistry> = this.CustomElements();
1041
1042 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1043 return true;
1044 })());
1045 result
1046}
1047
1048
1049static customElements_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1050
1051pub(crate) fn init_customElements_getterinfo<D: DomTypes>() {
1052 customElements_getterinfo.set(JSJitInfo {
1053 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1054 getter: Some(get_customElements::<D>)
1055 },
1056 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1057 protoID: PrototypeList::ID::Window as u16,
1058 },
1059 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1060 _bitfield_align_1: [],
1061 _bitfield_1: __BindgenBitfieldUnit::new(
1062 new_jsjitinfo_bitfield_1!(
1063 JSJitInfo_OpType::Getter as u8,
1064 JSJitInfo_AliasSet::AliasEverything as u8,
1065 JSValueType::JSVAL_TYPE_OBJECT as u8,
1066 true,
1067 false,
1068 false,
1069 false,
1070 false,
1071 false,
1072 0,
1073 ).to_ne_bytes()
1074 ),
1075});
1076}
1077unsafe extern "C" fn get_status<D: DomTypes>
1078(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1079 let mut result = false;
1080 wrap_panic(&mut || result = (|| {
1081 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1082 let this = &*(this as *const D::Window);
1083 let result: DOMString = this.Status();
1084
1085 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1086 return true;
1087 })());
1088 result
1089}
1090
1091unsafe extern "C" fn set_status<D: DomTypes>
1092(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1093 let mut result = false;
1094 wrap_panic(&mut || result = (|| {
1095 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1096 let this = &*(this as *const D::Window);
1097 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1098 Ok(ConversionResult::Success(value)) => value,
1099 Ok(ConversionResult::Failure(error)) => {
1100 throw_type_error(cx.raw_cx(), &error);
1101 return false;
1102
1103 }
1104 _ => {
1105 return false;
1106
1107 },
1108 }
1109 ;
1110 let result: () = this.SetStatus(arg0);
1111
1112 true
1113 })());
1114 result
1115}
1116
1117
1118static status_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1119
1120pub(crate) fn init_status_getterinfo<D: DomTypes>() {
1121 status_getterinfo.set(JSJitInfo {
1122 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1123 getter: Some(get_status::<D>)
1124 },
1125 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1126 protoID: PrototypeList::ID::Window as u16,
1127 },
1128 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1129 _bitfield_align_1: [],
1130 _bitfield_1: __BindgenBitfieldUnit::new(
1131 new_jsjitinfo_bitfield_1!(
1132 JSJitInfo_OpType::Getter as u8,
1133 JSJitInfo_AliasSet::AliasEverything as u8,
1134 JSValueType::JSVAL_TYPE_STRING as u8,
1135 true,
1136 false,
1137 false,
1138 false,
1139 false,
1140 false,
1141 0,
1142 ).to_ne_bytes()
1143 ),
1144});
1145}
1146static status_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1147
1148pub(crate) fn init_status_setterinfo<D: DomTypes>() {
1149 status_setterinfo.set(JSJitInfo {
1150 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1151 setter: Some(set_status::<D>)
1152 },
1153 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1154 protoID: PrototypeList::ID::Window as u16,
1155 },
1156 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1157 _bitfield_align_1: [],
1158 _bitfield_1: __BindgenBitfieldUnit::new(
1159 new_jsjitinfo_bitfield_1!(
1160 JSJitInfo_OpType::Setter as u8,
1161 JSJitInfo_AliasSet::AliasEverything as u8,
1162 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1163 false,
1164 false,
1165 false,
1166 false,
1167 false,
1168 false,
1169 0,
1170 ).to_ne_bytes()
1171 ),
1172});
1173}
1174unsafe extern "C" fn close<D: DomTypes>
1175(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1176 let mut result = false;
1177 wrap_panic(&mut || result = (|| {
1178 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1179 let this = &*(this as *const D::Window);
1180 let args = &*args;
1181 let argc = args.argc_;
1182 let result: () = this.Close();
1183
1184 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1185 return true;
1186 })());
1187 result
1188}
1189
1190
1191static close_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1192
1193pub(crate) fn init_close_methodinfo<D: DomTypes>() {
1194 close_methodinfo.set(JSJitInfo {
1195 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1196 method: Some(close::<D>)
1197 },
1198 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1199 protoID: PrototypeList::ID::Window as u16,
1200 },
1201 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1202 _bitfield_align_1: [],
1203 _bitfield_1: __BindgenBitfieldUnit::new(
1204 new_jsjitinfo_bitfield_1!(
1205 JSJitInfo_OpType::Method as u8,
1206 JSJitInfo_AliasSet::AliasEverything as u8,
1207 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1208 true,
1209 false,
1210 false,
1211 false,
1212 false,
1213 false,
1214 0,
1215 ).to_ne_bytes()
1216 ),
1217});
1218}
1219unsafe extern "C" fn get_closed<D: DomTypes>
1220(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1221 let mut result = false;
1222 wrap_panic(&mut || result = (|| {
1223 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1224 let this = &*(this as *const D::Window);
1225 let result: bool = this.Closed();
1226
1227 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1228 return true;
1229 })());
1230 result
1231}
1232
1233
1234static closed_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1235
1236pub(crate) fn init_closed_getterinfo<D: DomTypes>() {
1237 closed_getterinfo.set(JSJitInfo {
1238 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1239 getter: Some(get_closed::<D>)
1240 },
1241 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1242 protoID: PrototypeList::ID::Window as u16,
1243 },
1244 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1245 _bitfield_align_1: [],
1246 _bitfield_1: __BindgenBitfieldUnit::new(
1247 new_jsjitinfo_bitfield_1!(
1248 JSJitInfo_OpType::Getter as u8,
1249 JSJitInfo_AliasSet::AliasEverything as u8,
1250 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
1251 true,
1252 false,
1253 false,
1254 false,
1255 false,
1256 false,
1257 0,
1258 ).to_ne_bytes()
1259 ),
1260});
1261}
1262unsafe extern "C" fn stop<D: DomTypes>
1263(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1264 let mut result = false;
1265 wrap_panic(&mut || result = (|| {
1266 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1267 let this = &*(this as *const D::Window);
1268 let args = &*args;
1269 let argc = args.argc_;
1270 let result: () = this.Stop(CanGc::note());
1271
1272 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1273 return true;
1274 })());
1275 result
1276}
1277
1278
1279static stop_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1280
1281pub(crate) fn init_stop_methodinfo<D: DomTypes>() {
1282 stop_methodinfo.set(JSJitInfo {
1283 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1284 method: Some(stop::<D>)
1285 },
1286 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1287 protoID: PrototypeList::ID::Window as u16,
1288 },
1289 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1290 _bitfield_align_1: [],
1291 _bitfield_1: __BindgenBitfieldUnit::new(
1292 new_jsjitinfo_bitfield_1!(
1293 JSJitInfo_OpType::Method as u8,
1294 JSJitInfo_AliasSet::AliasEverything as u8,
1295 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1296 true,
1297 false,
1298 false,
1299 false,
1300 false,
1301 false,
1302 0,
1303 ).to_ne_bytes()
1304 ),
1305});
1306}
1307unsafe extern "C" fn focus<D: DomTypes>
1308(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1309 let mut result = false;
1310 wrap_panic(&mut || result = (|| {
1311 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1312 let this = &*(this as *const D::Window);
1313 let args = &*args;
1314 let argc = args.argc_;
1315 let result: () = this.Focus();
1316
1317 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1318 return true;
1319 })());
1320 result
1321}
1322
1323
1324static focus_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1325
1326pub(crate) fn init_focus_methodinfo<D: DomTypes>() {
1327 focus_methodinfo.set(JSJitInfo {
1328 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1329 method: Some(focus::<D>)
1330 },
1331 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1332 protoID: PrototypeList::ID::Window as u16,
1333 },
1334 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1335 _bitfield_align_1: [],
1336 _bitfield_1: __BindgenBitfieldUnit::new(
1337 new_jsjitinfo_bitfield_1!(
1338 JSJitInfo_OpType::Method as u8,
1339 JSJitInfo_AliasSet::AliasEverything as u8,
1340 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1341 true,
1342 false,
1343 false,
1344 false,
1345 false,
1346 false,
1347 0,
1348 ).to_ne_bytes()
1349 ),
1350});
1351}
1352unsafe extern "C" fn blur<D: DomTypes>
1353(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1354 let mut result = false;
1355 wrap_panic(&mut || result = (|| {
1356 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1357 let this = &*(this as *const D::Window);
1358 let args = &*args;
1359 let argc = args.argc_;
1360 let result: () = this.Blur();
1361
1362 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1363 return true;
1364 })());
1365 result
1366}
1367
1368
1369static blur_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1370
1371pub(crate) fn init_blur_methodinfo<D: DomTypes>() {
1372 blur_methodinfo.set(JSJitInfo {
1373 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1374 method: Some(blur::<D>)
1375 },
1376 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1377 protoID: PrototypeList::ID::Window as u16,
1378 },
1379 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1380 _bitfield_align_1: [],
1381 _bitfield_1: __BindgenBitfieldUnit::new(
1382 new_jsjitinfo_bitfield_1!(
1383 JSJitInfo_OpType::Method as u8,
1384 JSJitInfo_AliasSet::AliasEverything as u8,
1385 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1386 true,
1387 false,
1388 false,
1389 false,
1390 false,
1391 false,
1392 0,
1393 ).to_ne_bytes()
1394 ),
1395});
1396}
1397unsafe extern "C" fn get_frames<D: DomTypes>
1398(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1399 let mut result = false;
1400 wrap_panic(&mut || result = (|| {
1401 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1402 let this = &*(this as *const D::Window);
1403 let result: DomRoot<D::WindowProxy> = this.Frames();
1404
1405 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1406 return true;
1407 })());
1408 result
1409}
1410
1411unsafe extern "C" fn set_frames<D: DomTypes>
1412(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1413 let mut result = false;
1414 wrap_panic(&mut || result = {
1415
1416 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"frames".as_ptr(),
1417 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
1418 });
1419 result
1420}
1421
1422
1423static frames_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1424
1425pub(crate) fn init_frames_getterinfo<D: DomTypes>() {
1426 frames_getterinfo.set(JSJitInfo {
1427 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1428 getter: Some(get_frames::<D>)
1429 },
1430 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1431 protoID: PrototypeList::ID::Window as u16,
1432 },
1433 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1434 _bitfield_align_1: [],
1435 _bitfield_1: __BindgenBitfieldUnit::new(
1436 new_jsjitinfo_bitfield_1!(
1437 JSJitInfo_OpType::Getter as u8,
1438 JSJitInfo_AliasSet::AliasEverything as u8,
1439 JSValueType::JSVAL_TYPE_OBJECT as u8,
1440 true,
1441 false,
1442 false,
1443 false,
1444 false,
1445 false,
1446 0,
1447 ).to_ne_bytes()
1448 ),
1449});
1450}
1451static frames_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1452
1453pub(crate) fn init_frames_setterinfo<D: DomTypes>() {
1454 frames_setterinfo.set(JSJitInfo {
1455 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1456 setter: Some(set_frames::<D>)
1457 },
1458 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1459 protoID: PrototypeList::ID::Window as u16,
1460 },
1461 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1462 _bitfield_align_1: [],
1463 _bitfield_1: __BindgenBitfieldUnit::new(
1464 new_jsjitinfo_bitfield_1!(
1465 JSJitInfo_OpType::Setter as u8,
1466 JSJitInfo_AliasSet::AliasEverything as u8,
1467 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1468 false,
1469 false,
1470 false,
1471 false,
1472 false,
1473 false,
1474 0,
1475 ).to_ne_bytes()
1476 ),
1477});
1478}
1479unsafe extern "C" fn get_length<D: DomTypes>
1480(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1481 let mut result = false;
1482 wrap_panic(&mut || result = (|| {
1483 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1484 let this = &*(this as *const D::Window);
1485 let result: u32 = this.Length();
1486
1487 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1488 return true;
1489 })());
1490 result
1491}
1492
1493unsafe extern "C" fn set_length<D: DomTypes>
1494(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1495 let mut result = false;
1496 wrap_panic(&mut || result = {
1497
1498 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"length".as_ptr(),
1499 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
1500 });
1501 result
1502}
1503
1504
1505static length_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1506
1507pub(crate) fn init_length_getterinfo<D: DomTypes>() {
1508 length_getterinfo.set(JSJitInfo {
1509 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1510 getter: Some(get_length::<D>)
1511 },
1512 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1513 protoID: PrototypeList::ID::Window as u16,
1514 },
1515 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1516 _bitfield_align_1: [],
1517 _bitfield_1: __BindgenBitfieldUnit::new(
1518 new_jsjitinfo_bitfield_1!(
1519 JSJitInfo_OpType::Getter as u8,
1520 JSJitInfo_AliasSet::AliasEverything as u8,
1521 JSValueType::JSVAL_TYPE_DOUBLE as u8,
1522 true,
1523 false,
1524 false,
1525 false,
1526 false,
1527 false,
1528 0,
1529 ).to_ne_bytes()
1530 ),
1531});
1532}
1533static length_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1534
1535pub(crate) fn init_length_setterinfo<D: DomTypes>() {
1536 length_setterinfo.set(JSJitInfo {
1537 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1538 setter: Some(set_length::<D>)
1539 },
1540 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1541 protoID: PrototypeList::ID::Window as u16,
1542 },
1543 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1544 _bitfield_align_1: [],
1545 _bitfield_1: __BindgenBitfieldUnit::new(
1546 new_jsjitinfo_bitfield_1!(
1547 JSJitInfo_OpType::Setter as u8,
1548 JSJitInfo_AliasSet::AliasEverything as u8,
1549 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1550 false,
1551 false,
1552 false,
1553 false,
1554 false,
1555 false,
1556 0,
1557 ).to_ne_bytes()
1558 ),
1559});
1560}
1561unsafe extern "C" fn get_top<D: DomTypes>
1562(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1563 let mut result = false;
1564 wrap_panic(&mut || result = (|| {
1565 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1566 let this = &*(this as *const D::Window);
1567 let result: Option<DomRoot<D::WindowProxy>> = this.GetTop();
1568
1569 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1570 return true;
1571 })());
1572 result
1573}
1574
1575
1576static top_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1577
1578pub(crate) fn init_top_getterinfo<D: DomTypes>() {
1579 top_getterinfo.set(JSJitInfo {
1580 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1581 getter: Some(get_top::<D>)
1582 },
1583 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1584 protoID: PrototypeList::ID::Window as u16,
1585 },
1586 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1587 _bitfield_align_1: [],
1588 _bitfield_1: __BindgenBitfieldUnit::new(
1589 new_jsjitinfo_bitfield_1!(
1590 JSJitInfo_OpType::Getter as u8,
1591 JSJitInfo_AliasSet::AliasEverything as u8,
1592 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
1593 true,
1594 false,
1595 false,
1596 false,
1597 false,
1598 false,
1599 0,
1600 ).to_ne_bytes()
1601 ),
1602});
1603}
1604unsafe extern "C" fn get_opener<D: DomTypes>
1605(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1606 let mut result = false;
1607 wrap_panic(&mut || result = (|| {
1608 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1609 let this = &*(this as *const D::Window);
1610 rooted!(&in(cx) let mut retval: JSVal);
1611 let result: Result<(), Error> = this.GetOpener(SafeJSContext::from_ptr(cx.raw_cx()), InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), retval.handle_mut());
1612 let result = match result {
1613 Ok(result) => result,
1614 Err(e) => {
1615 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1616 return false;
1617 },
1618 };
1619
1620 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1621 return true;
1622 })());
1623 result
1624}
1625
1626unsafe extern "C" fn set_opener<D: DomTypes>
1627(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1628 let mut result = false;
1629 wrap_panic(&mut || result = (|| {
1630 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1631 let this = &*(this as *const D::Window);
1632 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
1633 let result: Result<(), Error> = this.SetOpener(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
1634 let result = match result {
1635 Ok(result) => result,
1636 Err(e) => {
1637 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1638 return false;
1639 },
1640 };
1641
1642 true
1643 })());
1644 result
1645}
1646
1647
1648static opener_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1649
1650pub(crate) fn init_opener_getterinfo<D: DomTypes>() {
1651 opener_getterinfo.set(JSJitInfo {
1652 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1653 getter: Some(get_opener::<D>)
1654 },
1655 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1656 protoID: PrototypeList::ID::Window as u16,
1657 },
1658 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1659 _bitfield_align_1: [],
1660 _bitfield_1: __BindgenBitfieldUnit::new(
1661 new_jsjitinfo_bitfield_1!(
1662 JSJitInfo_OpType::Getter as u8,
1663 JSJitInfo_AliasSet::AliasEverything as u8,
1664 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
1665 false,
1666 false,
1667 false,
1668 false,
1669 false,
1670 false,
1671 0,
1672 ).to_ne_bytes()
1673 ),
1674});
1675}
1676static opener_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1677
1678pub(crate) fn init_opener_setterinfo<D: DomTypes>() {
1679 opener_setterinfo.set(JSJitInfo {
1680 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1681 setter: Some(set_opener::<D>)
1682 },
1683 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1684 protoID: PrototypeList::ID::Window as u16,
1685 },
1686 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1687 _bitfield_align_1: [],
1688 _bitfield_1: __BindgenBitfieldUnit::new(
1689 new_jsjitinfo_bitfield_1!(
1690 JSJitInfo_OpType::Setter as u8,
1691 JSJitInfo_AliasSet::AliasEverything as u8,
1692 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1693 false,
1694 false,
1695 false,
1696 false,
1697 false,
1698 false,
1699 0,
1700 ).to_ne_bytes()
1701 ),
1702});
1703}
1704unsafe extern "C" fn get_parent<D: DomTypes>
1705(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1706 let mut result = false;
1707 wrap_panic(&mut || result = (|| {
1708 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1709 let this = &*(this as *const D::Window);
1710 let result: Option<DomRoot<D::WindowProxy>> = this.GetParent();
1711
1712 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1713 return true;
1714 })());
1715 result
1716}
1717
1718unsafe extern "C" fn set_parent<D: DomTypes>
1719(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1720 let mut result = false;
1721 wrap_panic(&mut || result = {
1722
1723 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"parent".as_ptr(),
1724 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
1725 });
1726 result
1727}
1728
1729
1730static parent_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1731
1732pub(crate) fn init_parent_getterinfo<D: DomTypes>() {
1733 parent_getterinfo.set(JSJitInfo {
1734 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1735 getter: Some(get_parent::<D>)
1736 },
1737 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1738 protoID: PrototypeList::ID::Window as u16,
1739 },
1740 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1741 _bitfield_align_1: [],
1742 _bitfield_1: __BindgenBitfieldUnit::new(
1743 new_jsjitinfo_bitfield_1!(
1744 JSJitInfo_OpType::Getter as u8,
1745 JSJitInfo_AliasSet::AliasEverything as u8,
1746 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
1747 true,
1748 false,
1749 false,
1750 false,
1751 false,
1752 false,
1753 0,
1754 ).to_ne_bytes()
1755 ),
1756});
1757}
1758static parent_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1759
1760pub(crate) fn init_parent_setterinfo<D: DomTypes>() {
1761 parent_setterinfo.set(JSJitInfo {
1762 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1763 setter: Some(set_parent::<D>)
1764 },
1765 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1766 protoID: PrototypeList::ID::Window as u16,
1767 },
1768 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1769 _bitfield_align_1: [],
1770 _bitfield_1: __BindgenBitfieldUnit::new(
1771 new_jsjitinfo_bitfield_1!(
1772 JSJitInfo_OpType::Setter as u8,
1773 JSJitInfo_AliasSet::AliasEverything as u8,
1774 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1775 false,
1776 false,
1777 false,
1778 false,
1779 false,
1780 false,
1781 0,
1782 ).to_ne_bytes()
1783 ),
1784});
1785}
1786unsafe extern "C" fn get_frameElement<D: DomTypes>
1787(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1788 let mut result = false;
1789 wrap_panic(&mut || result = (|| {
1790 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1791 let this = &*(this as *const D::Window);
1792 let result: Option<DomRoot<D::Element>> = this.GetFrameElement();
1793
1794 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1795 return true;
1796 })());
1797 result
1798}
1799
1800
1801static frameElement_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1802
1803pub(crate) fn init_frameElement_getterinfo<D: DomTypes>() {
1804 frameElement_getterinfo.set(JSJitInfo {
1805 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1806 getter: Some(get_frameElement::<D>)
1807 },
1808 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1809 protoID: PrototypeList::ID::Window as u16,
1810 },
1811 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1812 _bitfield_align_1: [],
1813 _bitfield_1: __BindgenBitfieldUnit::new(
1814 new_jsjitinfo_bitfield_1!(
1815 JSJitInfo_OpType::Getter as u8,
1816 JSJitInfo_AliasSet::AliasEverything as u8,
1817 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
1818 true,
1819 false,
1820 false,
1821 false,
1822 false,
1823 false,
1824 0,
1825 ).to_ne_bytes()
1826 ),
1827});
1828}
1829unsafe extern "C" fn open<D: DomTypes>
1830(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1831 let mut result = false;
1832 wrap_panic(&mut || result = (|| {
1833 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1834 let this = &*(this as *const D::Window);
1835 let args = &*args;
1836 let argc = args.argc_;
1837 let arg0: USVString = if args.get(0).is_undefined() {
1838 USVString("".to_owned())
1839 } else {
1840 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1841 Ok(ConversionResult::Success(value)) => value,
1842 Ok(ConversionResult::Failure(error)) => {
1843 throw_type_error(cx.raw_cx(), &error);
1844 return false;
1845
1846 }
1847 _ => {
1848 return false;
1849
1850 },
1851 }
1852
1853 };
1854 let arg1: DOMString = if args.get(1).is_undefined() {
1855 DOMString::from("_blank")
1856 } else {
1857 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
1858 Ok(ConversionResult::Success(value)) => value,
1859 Ok(ConversionResult::Failure(error)) => {
1860 throw_type_error(cx.raw_cx(), &error);
1861 return false;
1862
1863 }
1864 _ => {
1865 return false;
1866
1867 },
1868 }
1869
1870 };
1871 let arg2: DOMString = if args.get(2).is_undefined() {
1872 DOMString::from("")
1873 } else {
1874 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), StringificationBehavior::Default) {
1875 Ok(ConversionResult::Success(value)) => value,
1876 Ok(ConversionResult::Failure(error)) => {
1877 throw_type_error(cx.raw_cx(), &error);
1878 return false;
1879
1880 }
1881 _ => {
1882 return false;
1883
1884 },
1885 }
1886
1887 };
1888 let result: Result<Option<DomRoot<D::WindowProxy>>, Error> = this.Open(arg0, arg1, arg2, CanGc::note());
1889 let result = match result {
1890 Ok(result) => result,
1891 Err(e) => {
1892 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1893 return false;
1894 },
1895 };
1896
1897 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1898 return true;
1899 })());
1900 result
1901}
1902
1903
1904static open_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1905
1906pub(crate) fn init_open_methodinfo<D: DomTypes>() {
1907 open_methodinfo.set(JSJitInfo {
1908 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1909 method: Some(open::<D>)
1910 },
1911 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1912 protoID: PrototypeList::ID::Window as u16,
1913 },
1914 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1915 _bitfield_align_1: [],
1916 _bitfield_1: __BindgenBitfieldUnit::new(
1917 new_jsjitinfo_bitfield_1!(
1918 JSJitInfo_OpType::Method as u8,
1919 JSJitInfo_AliasSet::AliasEverything as u8,
1920 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
1921 false,
1922 false,
1923 false,
1924 false,
1925 false,
1926 false,
1927 0,
1928 ).to_ne_bytes()
1929 ),
1930});
1931}
1932unsafe extern "C" fn get_navigator<D: DomTypes>
1933(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1934 let mut result = false;
1935 wrap_panic(&mut || result = (|| {
1936 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1937 let this = &*(this as *const D::Window);
1938 let result: DomRoot<D::Navigator> = this.Navigator();
1939
1940 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1941 return true;
1942 })());
1943 result
1944}
1945
1946
1947static navigator_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1948
1949pub(crate) fn init_navigator_getterinfo<D: DomTypes>() {
1950 navigator_getterinfo.set(JSJitInfo {
1951 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1952 getter: Some(get_navigator::<D>)
1953 },
1954 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1955 protoID: PrototypeList::ID::Window as u16,
1956 },
1957 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1958 _bitfield_align_1: [],
1959 _bitfield_1: __BindgenBitfieldUnit::new(
1960 new_jsjitinfo_bitfield_1!(
1961 JSJitInfo_OpType::Getter as u8,
1962 JSJitInfo_AliasSet::AliasEverything as u8,
1963 JSValueType::JSVAL_TYPE_OBJECT as u8,
1964 true,
1965 false,
1966 false,
1967 false,
1968 false,
1969 false,
1970 0,
1971 ).to_ne_bytes()
1972 ),
1973});
1974}
1975unsafe extern "C" fn alert<D: DomTypes>
1976(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1977 let mut result = false;
1978 wrap_panic(&mut || result = (|| {
1979 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1980 let this = &*(this as *const D::Window);
1981 let args = &*args;
1982 let argc = args.argc_;
1983
1984 let argcount = cmp::min(argc, 1);
1985 match argcount {
1986 0 => {
1987 let result: () = this.Alert_();
1988
1989 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1990 return true;
1991 }
1992 1 => {
1993 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1994 Ok(ConversionResult::Success(value)) => value,
1995 Ok(ConversionResult::Failure(error)) => {
1996 throw_type_error(cx.raw_cx(), &error);
1997 return false;
1998
1999 }
2000 _ => {
2001 return false;
2002
2003 },
2004 }
2005 ;
2006 let result: () = this.Alert(arg0);
2007
2008 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2009 return true;
2010 }
2011 _ => {
2012 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.alert\".");
2013 return false;
2014 }
2015 }
2016 })());
2017 result
2018}
2019
2020
2021static alert_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2022
2023pub(crate) fn init_alert_methodinfo<D: DomTypes>() {
2024 alert_methodinfo.set(JSJitInfo {
2025 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2026 method: Some(alert::<D>)
2027 },
2028 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2029 protoID: PrototypeList::ID::Window as u16,
2030 },
2031 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2032 _bitfield_align_1: [],
2033 _bitfield_1: __BindgenBitfieldUnit::new(
2034 new_jsjitinfo_bitfield_1!(
2035 JSJitInfo_OpType::Method as u8,
2036 JSJitInfo_AliasSet::AliasEverything as u8,
2037 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2038 false,
2039 false,
2040 false,
2041 false,
2042 false,
2043 false,
2044 0,
2045 ).to_ne_bytes()
2046 ),
2047});
2048}
2049unsafe extern "C" fn confirm<D: DomTypes>
2050(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2051 let mut result = false;
2052 wrap_panic(&mut || result = (|| {
2053 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2054 let this = &*(this as *const D::Window);
2055 let args = &*args;
2056 let argc = args.argc_;
2057 let arg0: DOMString = if args.get(0).is_undefined() {
2058 DOMString::from("")
2059 } else {
2060 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2061 Ok(ConversionResult::Success(value)) => value,
2062 Ok(ConversionResult::Failure(error)) => {
2063 throw_type_error(cx.raw_cx(), &error);
2064 return false;
2065
2066 }
2067 _ => {
2068 return false;
2069
2070 },
2071 }
2072
2073 };
2074 let result: bool = this.Confirm(arg0);
2075
2076 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2077 return true;
2078 })());
2079 result
2080}
2081
2082
2083static confirm_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2084
2085pub(crate) fn init_confirm_methodinfo<D: DomTypes>() {
2086 confirm_methodinfo.set(JSJitInfo {
2087 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2088 method: Some(confirm::<D>)
2089 },
2090 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2091 protoID: PrototypeList::ID::Window as u16,
2092 },
2093 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2094 _bitfield_align_1: [],
2095 _bitfield_1: __BindgenBitfieldUnit::new(
2096 new_jsjitinfo_bitfield_1!(
2097 JSJitInfo_OpType::Method as u8,
2098 JSJitInfo_AliasSet::AliasEverything as u8,
2099 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
2100 false,
2101 false,
2102 false,
2103 false,
2104 false,
2105 false,
2106 0,
2107 ).to_ne_bytes()
2108 ),
2109});
2110}
2111unsafe extern "C" fn prompt<D: DomTypes>
2112(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2113 let mut result = false;
2114 wrap_panic(&mut || result = (|| {
2115 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2116 let this = &*(this as *const D::Window);
2117 let args = &*args;
2118 let argc = args.argc_;
2119 let arg0: DOMString = if args.get(0).is_undefined() {
2120 DOMString::from("")
2121 } else {
2122 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2123 Ok(ConversionResult::Success(value)) => value,
2124 Ok(ConversionResult::Failure(error)) => {
2125 throw_type_error(cx.raw_cx(), &error);
2126 return false;
2127
2128 }
2129 _ => {
2130 return false;
2131
2132 },
2133 }
2134
2135 };
2136 let arg1: DOMString = if args.get(1).is_undefined() {
2137 DOMString::from("")
2138 } else {
2139 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
2140 Ok(ConversionResult::Success(value)) => value,
2141 Ok(ConversionResult::Failure(error)) => {
2142 throw_type_error(cx.raw_cx(), &error);
2143 return false;
2144
2145 }
2146 _ => {
2147 return false;
2148
2149 },
2150 }
2151
2152 };
2153 let result: Option<DOMString> = this.Prompt(arg0, arg1);
2154
2155 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2156 return true;
2157 })());
2158 result
2159}
2160
2161
2162static prompt_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2163
2164pub(crate) fn init_prompt_methodinfo<D: DomTypes>() {
2165 prompt_methodinfo.set(JSJitInfo {
2166 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2167 method: Some(prompt::<D>)
2168 },
2169 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2170 protoID: PrototypeList::ID::Window as u16,
2171 },
2172 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2173 _bitfield_align_1: [],
2174 _bitfield_1: __BindgenBitfieldUnit::new(
2175 new_jsjitinfo_bitfield_1!(
2176 JSJitInfo_OpType::Method as u8,
2177 JSJitInfo_AliasSet::AliasEverything as u8,
2178 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2179 false,
2180 false,
2181 false,
2182 false,
2183 false,
2184 false,
2185 0,
2186 ).to_ne_bytes()
2187 ),
2188});
2189}
2190unsafe extern "C" fn requestAnimationFrame<D: DomTypes>
2191(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2192 let mut result = false;
2193 wrap_panic(&mut || result = (|| {
2194 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2195 let this = &*(this as *const D::Window);
2196 let args = &*args;
2197 let argc = args.argc_;
2198
2199 if argc < 1 {
2200 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.requestAnimationFrame\".");
2201 return false;
2202 }
2203 let arg0: Rc<FrameRequestCallback<D>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2204 if IsCallable(HandleValue::from_raw(args.get(0)).get().to_object()) {
2205 FrameRequestCallback::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object())
2206 } else {
2207 throw_type_error(cx.raw_cx(), "Value is not callable.");
2208 return false;
2209
2210 }
2211 } else {
2212 throw_type_error(cx.raw_cx(), "Value is not an object.");
2213 return false;
2214
2215 };
2216 let result: u32 = this.RequestAnimationFrame(arg0);
2217
2218 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2219 return true;
2220 })());
2221 result
2222}
2223
2224
2225static requestAnimationFrame_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2226
2227pub(crate) fn init_requestAnimationFrame_methodinfo<D: DomTypes>() {
2228 requestAnimationFrame_methodinfo.set(JSJitInfo {
2229 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2230 method: Some(requestAnimationFrame::<D>)
2231 },
2232 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2233 protoID: PrototypeList::ID::Window as u16,
2234 },
2235 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2236 _bitfield_align_1: [],
2237 _bitfield_1: __BindgenBitfieldUnit::new(
2238 new_jsjitinfo_bitfield_1!(
2239 JSJitInfo_OpType::Method as u8,
2240 JSJitInfo_AliasSet::AliasEverything as u8,
2241 JSValueType::JSVAL_TYPE_DOUBLE as u8,
2242 false,
2243 false,
2244 false,
2245 false,
2246 false,
2247 false,
2248 0,
2249 ).to_ne_bytes()
2250 ),
2251});
2252}
2253unsafe extern "C" fn cancelAnimationFrame<D: DomTypes>
2254(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2255 let mut result = false;
2256 wrap_panic(&mut || result = (|| {
2257 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2258 let this = &*(this as *const D::Window);
2259 let args = &*args;
2260 let argc = args.argc_;
2261
2262 if argc < 1 {
2263 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.cancelAnimationFrame\".");
2264 return false;
2265 }
2266 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2267 Ok(ConversionResult::Success(value)) => value,
2268 Ok(ConversionResult::Failure(error)) => {
2269 throw_type_error(cx.raw_cx(), &error);
2270 return false;
2271
2272 }
2273 _ => {
2274 return false;
2275
2276 },
2277 }
2278 ;
2279 let result: () = this.CancelAnimationFrame(arg0);
2280
2281 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2282 return true;
2283 })());
2284 result
2285}
2286
2287
2288static cancelAnimationFrame_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2289
2290pub(crate) fn init_cancelAnimationFrame_methodinfo<D: DomTypes>() {
2291 cancelAnimationFrame_methodinfo.set(JSJitInfo {
2292 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2293 method: Some(cancelAnimationFrame::<D>)
2294 },
2295 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2296 protoID: PrototypeList::ID::Window as u16,
2297 },
2298 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2299 _bitfield_align_1: [],
2300 _bitfield_1: __BindgenBitfieldUnit::new(
2301 new_jsjitinfo_bitfield_1!(
2302 JSJitInfo_OpType::Method as u8,
2303 JSJitInfo_AliasSet::AliasEverything as u8,
2304 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2305 false,
2306 false,
2307 false,
2308 false,
2309 false,
2310 false,
2311 0,
2312 ).to_ne_bytes()
2313 ),
2314});
2315}
2316unsafe extern "C" fn postMessage<D: DomTypes>
2317(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2318 let mut result = false;
2319 wrap_panic(&mut || result = (|| {
2320 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2321 let this = &*(this as *const D::Window);
2322 let args = &*args;
2323 let argc = args.argc_;
2324
2325 let argcount = cmp::min(argc, 3);
2326 match argcount {
2327 1 => {
2328 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
2329 let arg1: RootedTraceableBox<crate::codegen::GenericBindings::WindowBinding::WindowPostMessageOptions> = if args.get(1).is_undefined() {
2330 crate::codegen::GenericBindings::WindowBinding::WindowPostMessageOptions::empty()
2331 } else {
2332 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2333 Ok(ConversionResult::Success(value)) => value,
2334 Ok(ConversionResult::Failure(error)) => {
2335 throw_type_error(cx.raw_cx(), &error);
2336 return false;
2337
2338 }
2339 _ => {
2340 return false;
2341
2342 },
2343 }
2344
2345 };
2346 let result: Result<(), Error> = this.PostMessage_(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1);
2347 let result = match result {
2348 Ok(result) => result,
2349 Err(e) => {
2350 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2351 return false;
2352 },
2353 };
2354
2355 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2356 return true;
2357 }
2358 2 => {
2359 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
2360 if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
2361 let arg1: RootedTraceableBox<crate::codegen::GenericBindings::WindowBinding::WindowPostMessageOptions> = if args.get(1).is_undefined() {
2362 crate::codegen::GenericBindings::WindowBinding::WindowPostMessageOptions::empty()
2363 } else {
2364 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2365 Ok(ConversionResult::Success(value)) => value,
2366 Ok(ConversionResult::Failure(error)) => {
2367 throw_type_error(cx.raw_cx(), &error);
2368 return false;
2369
2370 }
2371 _ => {
2372 return false;
2373
2374 },
2375 }
2376
2377 };
2378 let result: Result<(), Error> = this.PostMessage_(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1);
2379 let result = match result {
2380 Ok(result) => result,
2381 Err(e) => {
2382 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2383 return false;
2384 },
2385 };
2386
2387 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2388 return true;
2389 }
2390 if HandleValue::from_raw(args.get(1)).get().is_object() {
2391 let arg1: RootedTraceableBox<crate::codegen::GenericBindings::WindowBinding::WindowPostMessageOptions> = if args.get(1).is_undefined() {
2392 crate::codegen::GenericBindings::WindowBinding::WindowPostMessageOptions::empty()
2393 } else {
2394 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2395 Ok(ConversionResult::Success(value)) => value,
2396 Ok(ConversionResult::Failure(error)) => {
2397 throw_type_error(cx.raw_cx(), &error);
2398 return false;
2399
2400 }
2401 _ => {
2402 return false;
2403
2404 },
2405 }
2406
2407 };
2408 let result: Result<(), Error> = this.PostMessage_(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1);
2409 let result = match result {
2410 Ok(result) => result,
2411 Err(e) => {
2412 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2413 return false;
2414 },
2415 };
2416
2417 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2418 return true;
2419 }
2420 let arg1: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2421 Ok(ConversionResult::Success(value)) => value,
2422 Ok(ConversionResult::Failure(error)) => {
2423 throw_type_error(cx.raw_cx(), &error);
2424 return false;
2425
2426 }
2427 _ => {
2428 return false;
2429
2430 },
2431 }
2432 ;
2433 let arg2: Vec<*mut JSObject> = if args.get(2).is_undefined() {
2434 Vec::new()
2435 } else {
2436 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
2437 Ok(ConversionResult::Success(value)) => value,
2438 Ok(ConversionResult::Failure(error)) => {
2439 throw_type_error(cx.raw_cx(), &error);
2440 return false;
2441
2442 }
2443 _ => {
2444 return false;
2445
2446 },
2447 }
2448
2449 };
2450 auto_root!(&in(cx) let arg2 = arg2);
2451 let result: Result<(), Error> = this.PostMessage(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, arg2);
2452 let result = match result {
2453 Ok(result) => result,
2454 Err(e) => {
2455 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2456 return false;
2457 },
2458 };
2459
2460 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2461 return true;
2462 }
2463 3 => {
2464 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
2465 let arg1: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2466 Ok(ConversionResult::Success(value)) => value,
2467 Ok(ConversionResult::Failure(error)) => {
2468 throw_type_error(cx.raw_cx(), &error);
2469 return false;
2470
2471 }
2472 _ => {
2473 return false;
2474
2475 },
2476 }
2477 ;
2478 let arg2: Vec<*mut JSObject> = if args.get(2).is_undefined() {
2479 Vec::new()
2480 } else {
2481 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
2482 Ok(ConversionResult::Success(value)) => value,
2483 Ok(ConversionResult::Failure(error)) => {
2484 throw_type_error(cx.raw_cx(), &error);
2485 return false;
2486
2487 }
2488 _ => {
2489 return false;
2490
2491 },
2492 }
2493
2494 };
2495 auto_root!(&in(cx) let arg2 = arg2);
2496 let result: Result<(), Error> = this.PostMessage(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, arg2);
2497 let result = match result {
2498 Ok(result) => result,
2499 Err(e) => {
2500 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2501 return false;
2502 },
2503 };
2504
2505 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2506 return true;
2507 }
2508 _ => {
2509 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.postMessage\".");
2510 return false;
2511 }
2512 }
2513 })());
2514 result
2515}
2516
2517
2518static postMessage_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2519
2520pub(crate) fn init_postMessage_methodinfo<D: DomTypes>() {
2521 postMessage_methodinfo.set(JSJitInfo {
2522 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2523 method: Some(postMessage::<D>)
2524 },
2525 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2526 protoID: PrototypeList::ID::Window as u16,
2527 },
2528 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2529 _bitfield_align_1: [],
2530 _bitfield_1: __BindgenBitfieldUnit::new(
2531 new_jsjitinfo_bitfield_1!(
2532 JSJitInfo_OpType::Method as u8,
2533 JSJitInfo_AliasSet::AliasEverything as u8,
2534 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2535 false,
2536 false,
2537 false,
2538 false,
2539 false,
2540 false,
2541 0,
2542 ).to_ne_bytes()
2543 ),
2544});
2545}
2546unsafe extern "C" fn captureEvents<D: DomTypes>
2547(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2548 let mut result = false;
2549 wrap_panic(&mut || result = (|| {
2550 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2551 let this = &*(this as *const D::Window);
2552 let args = &*args;
2553 let argc = args.argc_;
2554 let result: () = this.CaptureEvents();
2555
2556 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2557 return true;
2558 })());
2559 result
2560}
2561
2562
2563static captureEvents_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2564
2565pub(crate) fn init_captureEvents_methodinfo<D: DomTypes>() {
2566 captureEvents_methodinfo.set(JSJitInfo {
2567 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2568 method: Some(captureEvents::<D>)
2569 },
2570 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2571 protoID: PrototypeList::ID::Window as u16,
2572 },
2573 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2574 _bitfield_align_1: [],
2575 _bitfield_1: __BindgenBitfieldUnit::new(
2576 new_jsjitinfo_bitfield_1!(
2577 JSJitInfo_OpType::Method as u8,
2578 JSJitInfo_AliasSet::AliasEverything as u8,
2579 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2580 true,
2581 false,
2582 false,
2583 false,
2584 false,
2585 false,
2586 0,
2587 ).to_ne_bytes()
2588 ),
2589});
2590}
2591unsafe extern "C" fn releaseEvents<D: DomTypes>
2592(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2593 let mut result = false;
2594 wrap_panic(&mut || result = (|| {
2595 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2596 let this = &*(this as *const D::Window);
2597 let args = &*args;
2598 let argc = args.argc_;
2599 let result: () = this.ReleaseEvents();
2600
2601 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2602 return true;
2603 })());
2604 result
2605}
2606
2607
2608static releaseEvents_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2609
2610pub(crate) fn init_releaseEvents_methodinfo<D: DomTypes>() {
2611 releaseEvents_methodinfo.set(JSJitInfo {
2612 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2613 method: Some(releaseEvents::<D>)
2614 },
2615 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2616 protoID: PrototypeList::ID::Window as u16,
2617 },
2618 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2619 _bitfield_align_1: [],
2620 _bitfield_1: __BindgenBitfieldUnit::new(
2621 new_jsjitinfo_bitfield_1!(
2622 JSJitInfo_OpType::Method as u8,
2623 JSJitInfo_AliasSet::AliasEverything as u8,
2624 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2625 true,
2626 false,
2627 false,
2628 false,
2629 false,
2630 false,
2631 0,
2632 ).to_ne_bytes()
2633 ),
2634});
2635}
2636unsafe extern "C" fn getComputedStyle<D: DomTypes>
2637(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2638 let mut result = false;
2639 wrap_panic(&mut || result = (|| {
2640 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2641 let this = &*(this as *const D::Window);
2642 let args = &*args;
2643 let argc = args.argc_;
2644
2645 if argc < 1 {
2646 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.getComputedStyle\".");
2647 return false;
2648 }
2649 let arg0: DomRoot<D::Element> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2650 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2651 Ok(val) => val,
2652 Err(()) => {
2653 throw_type_error(cx.raw_cx(), "value does not implement interface Element.");
2654 return false;
2655
2656 }
2657 }
2658
2659 } else {
2660 throw_type_error(cx.raw_cx(), "Value is not an object.");
2661 return false;
2662
2663 };
2664 let arg1: Option<DOMString> = if args.get(1).is_undefined() {
2665 None
2666 } else {
2667 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
2668 Ok(ConversionResult::Success(value)) => value,
2669 Ok(ConversionResult::Failure(error)) => {
2670 throw_type_error(cx.raw_cx(), &error);
2671 return false;
2672
2673 }
2674 _ => {
2675 return false;
2676
2677 },
2678 }
2679 )
2680 };
2681 let result: DomRoot<D::CSSStyleDeclaration> = this.GetComputedStyle(&arg0, arg1);
2682
2683 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2684 return true;
2685 })());
2686 result
2687}
2688
2689
2690static getComputedStyle_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2691
2692pub(crate) fn init_getComputedStyle_methodinfo<D: DomTypes>() {
2693 getComputedStyle_methodinfo.set(JSJitInfo {
2694 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2695 method: Some(getComputedStyle::<D>)
2696 },
2697 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2698 protoID: PrototypeList::ID::Window as u16,
2699 },
2700 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2701 _bitfield_align_1: [],
2702 _bitfield_1: __BindgenBitfieldUnit::new(
2703 new_jsjitinfo_bitfield_1!(
2704 JSJitInfo_OpType::Method as u8,
2705 JSJitInfo_AliasSet::AliasEverything as u8,
2706 JSValueType::JSVAL_TYPE_OBJECT as u8,
2707 false,
2708 false,
2709 false,
2710 false,
2711 false,
2712 false,
2713 0,
2714 ).to_ne_bytes()
2715 ),
2716});
2717}
2718unsafe extern "C" fn matchMedia<D: DomTypes>
2719(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2720 let mut result = false;
2721 wrap_panic(&mut || result = (|| {
2722 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2723 let this = &*(this as *const D::Window);
2724 let args = &*args;
2725 let argc = args.argc_;
2726
2727 if argc < 1 {
2728 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.matchMedia\".");
2729 return false;
2730 }
2731 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2732 Ok(ConversionResult::Success(value)) => value,
2733 Ok(ConversionResult::Failure(error)) => {
2734 throw_type_error(cx.raw_cx(), &error);
2735 return false;
2736
2737 }
2738 _ => {
2739 return false;
2740
2741 },
2742 }
2743 ;
2744 let result: DomRoot<D::MediaQueryList> = this.MatchMedia(arg0);
2745
2746 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2747 return true;
2748 })());
2749 result
2750}
2751
2752
2753static matchMedia_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2754
2755pub(crate) fn init_matchMedia_methodinfo<D: DomTypes>() {
2756 matchMedia_methodinfo.set(JSJitInfo {
2757 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2758 method: Some(matchMedia::<D>)
2759 },
2760 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2761 protoID: PrototypeList::ID::Window as u16,
2762 },
2763 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2764 _bitfield_align_1: [],
2765 _bitfield_1: __BindgenBitfieldUnit::new(
2766 new_jsjitinfo_bitfield_1!(
2767 JSJitInfo_OpType::Method as u8,
2768 JSJitInfo_AliasSet::AliasEverything as u8,
2769 JSValueType::JSVAL_TYPE_OBJECT as u8,
2770 false,
2771 false,
2772 false,
2773 false,
2774 false,
2775 false,
2776 0,
2777 ).to_ne_bytes()
2778 ),
2779});
2780}
2781unsafe extern "C" fn get_screen<D: DomTypes>
2782(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2783 let mut result = false;
2784 wrap_panic(&mut || result = (|| {
2785 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2786 let this = &*(this as *const D::Window);
2787 let result: DomRoot<D::Screen> = this.Screen();
2788
2789 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2790 return true;
2791 })());
2792 result
2793}
2794
2795unsafe extern "C" fn set_screen<D: DomTypes>
2796(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2797 let mut result = false;
2798 wrap_panic(&mut || result = {
2799
2800 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"screen".as_ptr(),
2801 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
2802 });
2803 result
2804}
2805
2806
2807static screen_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2808
2809pub(crate) fn init_screen_getterinfo<D: DomTypes>() {
2810 screen_getterinfo.set(JSJitInfo {
2811 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2812 getter: Some(get_screen::<D>)
2813 },
2814 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2815 protoID: PrototypeList::ID::Window as u16,
2816 },
2817 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2818 _bitfield_align_1: [],
2819 _bitfield_1: __BindgenBitfieldUnit::new(
2820 new_jsjitinfo_bitfield_1!(
2821 JSJitInfo_OpType::Getter as u8,
2822 JSJitInfo_AliasSet::AliasNone as u8,
2823 JSValueType::JSVAL_TYPE_OBJECT as u8,
2824 true,
2825 true,
2826 false,
2827 false,
2828 false,
2829 false,
2830 0,
2831 ).to_ne_bytes()
2832 ),
2833});
2834}
2835static screen_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2836
2837pub(crate) fn init_screen_setterinfo<D: DomTypes>() {
2838 screen_setterinfo.set(JSJitInfo {
2839 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2840 setter: Some(set_screen::<D>)
2841 },
2842 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2843 protoID: PrototypeList::ID::Window as u16,
2844 },
2845 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2846 _bitfield_align_1: [],
2847 _bitfield_1: __BindgenBitfieldUnit::new(
2848 new_jsjitinfo_bitfield_1!(
2849 JSJitInfo_OpType::Setter as u8,
2850 JSJitInfo_AliasSet::AliasEverything as u8,
2851 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2852 false,
2853 false,
2854 false,
2855 false,
2856 false,
2857 false,
2858 0,
2859 ).to_ne_bytes()
2860 ),
2861});
2862}
2863unsafe extern "C" fn moveTo<D: DomTypes>
2864(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2865 let mut result = false;
2866 wrap_panic(&mut || result = (|| {
2867 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2868 let this = &*(this as *const D::Window);
2869 let args = &*args;
2870 let argc = args.argc_;
2871
2872 if argc < 2 {
2873 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.moveTo\".");
2874 return false;
2875 }
2876 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2877 Ok(ConversionResult::Success(value)) => value,
2878 Ok(ConversionResult::Failure(error)) => {
2879 throw_type_error(cx.raw_cx(), &error);
2880 return false;
2881
2882 }
2883 _ => {
2884 return false;
2885
2886 },
2887 }
2888 ;
2889 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
2890 Ok(ConversionResult::Success(value)) => value,
2891 Ok(ConversionResult::Failure(error)) => {
2892 throw_type_error(cx.raw_cx(), &error);
2893 return false;
2894
2895 }
2896 _ => {
2897 return false;
2898
2899 },
2900 }
2901 ;
2902 let result: () = this.MoveTo(arg0, arg1);
2903
2904 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2905 return true;
2906 })());
2907 result
2908}
2909
2910
2911static moveTo_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2912
2913pub(crate) fn init_moveTo_methodinfo<D: DomTypes>() {
2914 moveTo_methodinfo.set(JSJitInfo {
2915 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2916 method: Some(moveTo::<D>)
2917 },
2918 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2919 protoID: PrototypeList::ID::Window as u16,
2920 },
2921 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2922 _bitfield_align_1: [],
2923 _bitfield_1: __BindgenBitfieldUnit::new(
2924 new_jsjitinfo_bitfield_1!(
2925 JSJitInfo_OpType::Method as u8,
2926 JSJitInfo_AliasSet::AliasEverything as u8,
2927 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2928 false,
2929 false,
2930 false,
2931 false,
2932 false,
2933 false,
2934 0,
2935 ).to_ne_bytes()
2936 ),
2937});
2938}
2939unsafe extern "C" fn moveBy<D: DomTypes>
2940(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2941 let mut result = false;
2942 wrap_panic(&mut || result = (|| {
2943 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2944 let this = &*(this as *const D::Window);
2945 let args = &*args;
2946 let argc = args.argc_;
2947
2948 if argc < 2 {
2949 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.moveBy\".");
2950 return false;
2951 }
2952 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2953 Ok(ConversionResult::Success(value)) => value,
2954 Ok(ConversionResult::Failure(error)) => {
2955 throw_type_error(cx.raw_cx(), &error);
2956 return false;
2957
2958 }
2959 _ => {
2960 return false;
2961
2962 },
2963 }
2964 ;
2965 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
2966 Ok(ConversionResult::Success(value)) => value,
2967 Ok(ConversionResult::Failure(error)) => {
2968 throw_type_error(cx.raw_cx(), &error);
2969 return false;
2970
2971 }
2972 _ => {
2973 return false;
2974
2975 },
2976 }
2977 ;
2978 let result: () = this.MoveBy(arg0, arg1);
2979
2980 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2981 return true;
2982 })());
2983 result
2984}
2985
2986
2987static moveBy_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2988
2989pub(crate) fn init_moveBy_methodinfo<D: DomTypes>() {
2990 moveBy_methodinfo.set(JSJitInfo {
2991 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2992 method: Some(moveBy::<D>)
2993 },
2994 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2995 protoID: PrototypeList::ID::Window as u16,
2996 },
2997 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2998 _bitfield_align_1: [],
2999 _bitfield_1: __BindgenBitfieldUnit::new(
3000 new_jsjitinfo_bitfield_1!(
3001 JSJitInfo_OpType::Method as u8,
3002 JSJitInfo_AliasSet::AliasEverything as u8,
3003 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3004 false,
3005 false,
3006 false,
3007 false,
3008 false,
3009 false,
3010 0,
3011 ).to_ne_bytes()
3012 ),
3013});
3014}
3015unsafe extern "C" fn resizeTo<D: DomTypes>
3016(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3017 let mut result = false;
3018 wrap_panic(&mut || result = (|| {
3019 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3020 let this = &*(this as *const D::Window);
3021 let args = &*args;
3022 let argc = args.argc_;
3023
3024 if argc < 2 {
3025 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.resizeTo\".");
3026 return false;
3027 }
3028 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3029 Ok(ConversionResult::Success(value)) => value,
3030 Ok(ConversionResult::Failure(error)) => {
3031 throw_type_error(cx.raw_cx(), &error);
3032 return false;
3033
3034 }
3035 _ => {
3036 return false;
3037
3038 },
3039 }
3040 ;
3041 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3042 Ok(ConversionResult::Success(value)) => value,
3043 Ok(ConversionResult::Failure(error)) => {
3044 throw_type_error(cx.raw_cx(), &error);
3045 return false;
3046
3047 }
3048 _ => {
3049 return false;
3050
3051 },
3052 }
3053 ;
3054 let result: () = this.ResizeTo(arg0, arg1);
3055
3056 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3057 return true;
3058 })());
3059 result
3060}
3061
3062
3063static resizeTo_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3064
3065pub(crate) fn init_resizeTo_methodinfo<D: DomTypes>() {
3066 resizeTo_methodinfo.set(JSJitInfo {
3067 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3068 method: Some(resizeTo::<D>)
3069 },
3070 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3071 protoID: PrototypeList::ID::Window as u16,
3072 },
3073 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3074 _bitfield_align_1: [],
3075 _bitfield_1: __BindgenBitfieldUnit::new(
3076 new_jsjitinfo_bitfield_1!(
3077 JSJitInfo_OpType::Method as u8,
3078 JSJitInfo_AliasSet::AliasEverything as u8,
3079 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3080 false,
3081 false,
3082 false,
3083 false,
3084 false,
3085 false,
3086 0,
3087 ).to_ne_bytes()
3088 ),
3089});
3090}
3091unsafe extern "C" fn resizeBy<D: DomTypes>
3092(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3093 let mut result = false;
3094 wrap_panic(&mut || result = (|| {
3095 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3096 let this = &*(this as *const D::Window);
3097 let args = &*args;
3098 let argc = args.argc_;
3099
3100 if argc < 2 {
3101 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.resizeBy\".");
3102 return false;
3103 }
3104 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3105 Ok(ConversionResult::Success(value)) => value,
3106 Ok(ConversionResult::Failure(error)) => {
3107 throw_type_error(cx.raw_cx(), &error);
3108 return false;
3109
3110 }
3111 _ => {
3112 return false;
3113
3114 },
3115 }
3116 ;
3117 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3118 Ok(ConversionResult::Success(value)) => value,
3119 Ok(ConversionResult::Failure(error)) => {
3120 throw_type_error(cx.raw_cx(), &error);
3121 return false;
3122
3123 }
3124 _ => {
3125 return false;
3126
3127 },
3128 }
3129 ;
3130 let result: () = this.ResizeBy(arg0, arg1);
3131
3132 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3133 return true;
3134 })());
3135 result
3136}
3137
3138
3139static resizeBy_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3140
3141pub(crate) fn init_resizeBy_methodinfo<D: DomTypes>() {
3142 resizeBy_methodinfo.set(JSJitInfo {
3143 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3144 method: Some(resizeBy::<D>)
3145 },
3146 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3147 protoID: PrototypeList::ID::Window as u16,
3148 },
3149 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3150 _bitfield_align_1: [],
3151 _bitfield_1: __BindgenBitfieldUnit::new(
3152 new_jsjitinfo_bitfield_1!(
3153 JSJitInfo_OpType::Method as u8,
3154 JSJitInfo_AliasSet::AliasEverything as u8,
3155 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3156 false,
3157 false,
3158 false,
3159 false,
3160 false,
3161 false,
3162 0,
3163 ).to_ne_bytes()
3164 ),
3165});
3166}
3167unsafe extern "C" fn get_innerWidth<D: DomTypes>
3168(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3169 let mut result = false;
3170 wrap_panic(&mut || result = (|| {
3171 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3172 let this = &*(this as *const D::Window);
3173 let result: i32 = this.InnerWidth();
3174
3175 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3176 return true;
3177 })());
3178 result
3179}
3180
3181unsafe extern "C" fn set_innerWidth<D: DomTypes>
3182(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3183 let mut result = false;
3184 wrap_panic(&mut || result = {
3185
3186 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"innerWidth".as_ptr(),
3187 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
3188 });
3189 result
3190}
3191
3192
3193static innerWidth_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3194
3195pub(crate) fn init_innerWidth_getterinfo<D: DomTypes>() {
3196 innerWidth_getterinfo.set(JSJitInfo {
3197 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3198 getter: Some(get_innerWidth::<D>)
3199 },
3200 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3201 protoID: PrototypeList::ID::Window as u16,
3202 },
3203 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3204 _bitfield_align_1: [],
3205 _bitfield_1: __BindgenBitfieldUnit::new(
3206 new_jsjitinfo_bitfield_1!(
3207 JSJitInfo_OpType::Getter as u8,
3208 JSJitInfo_AliasSet::AliasEverything as u8,
3209 JSValueType::JSVAL_TYPE_INT32 as u8,
3210 true,
3211 false,
3212 false,
3213 false,
3214 false,
3215 false,
3216 0,
3217 ).to_ne_bytes()
3218 ),
3219});
3220}
3221static innerWidth_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3222
3223pub(crate) fn init_innerWidth_setterinfo<D: DomTypes>() {
3224 innerWidth_setterinfo.set(JSJitInfo {
3225 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3226 setter: Some(set_innerWidth::<D>)
3227 },
3228 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3229 protoID: PrototypeList::ID::Window as u16,
3230 },
3231 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3232 _bitfield_align_1: [],
3233 _bitfield_1: __BindgenBitfieldUnit::new(
3234 new_jsjitinfo_bitfield_1!(
3235 JSJitInfo_OpType::Setter as u8,
3236 JSJitInfo_AliasSet::AliasEverything as u8,
3237 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3238 false,
3239 false,
3240 false,
3241 false,
3242 false,
3243 false,
3244 0,
3245 ).to_ne_bytes()
3246 ),
3247});
3248}
3249unsafe extern "C" fn get_innerHeight<D: DomTypes>
3250(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3251 let mut result = false;
3252 wrap_panic(&mut || result = (|| {
3253 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3254 let this = &*(this as *const D::Window);
3255 let result: i32 = this.InnerHeight();
3256
3257 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3258 return true;
3259 })());
3260 result
3261}
3262
3263unsafe extern "C" fn set_innerHeight<D: DomTypes>
3264(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3265 let mut result = false;
3266 wrap_panic(&mut || result = {
3267
3268 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"innerHeight".as_ptr(),
3269 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
3270 });
3271 result
3272}
3273
3274
3275static innerHeight_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3276
3277pub(crate) fn init_innerHeight_getterinfo<D: DomTypes>() {
3278 innerHeight_getterinfo.set(JSJitInfo {
3279 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3280 getter: Some(get_innerHeight::<D>)
3281 },
3282 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3283 protoID: PrototypeList::ID::Window as u16,
3284 },
3285 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3286 _bitfield_align_1: [],
3287 _bitfield_1: __BindgenBitfieldUnit::new(
3288 new_jsjitinfo_bitfield_1!(
3289 JSJitInfo_OpType::Getter as u8,
3290 JSJitInfo_AliasSet::AliasEverything as u8,
3291 JSValueType::JSVAL_TYPE_INT32 as u8,
3292 true,
3293 false,
3294 false,
3295 false,
3296 false,
3297 false,
3298 0,
3299 ).to_ne_bytes()
3300 ),
3301});
3302}
3303static innerHeight_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3304
3305pub(crate) fn init_innerHeight_setterinfo<D: DomTypes>() {
3306 innerHeight_setterinfo.set(JSJitInfo {
3307 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3308 setter: Some(set_innerHeight::<D>)
3309 },
3310 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3311 protoID: PrototypeList::ID::Window as u16,
3312 },
3313 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3314 _bitfield_align_1: [],
3315 _bitfield_1: __BindgenBitfieldUnit::new(
3316 new_jsjitinfo_bitfield_1!(
3317 JSJitInfo_OpType::Setter as u8,
3318 JSJitInfo_AliasSet::AliasEverything as u8,
3319 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3320 false,
3321 false,
3322 false,
3323 false,
3324 false,
3325 false,
3326 0,
3327 ).to_ne_bytes()
3328 ),
3329});
3330}
3331unsafe extern "C" fn get_scrollX<D: DomTypes>
3332(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3333 let mut result = false;
3334 wrap_panic(&mut || result = (|| {
3335 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3336 let this = &*(this as *const D::Window);
3337 let result: i32 = this.ScrollX();
3338
3339 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3340 return true;
3341 })());
3342 result
3343}
3344
3345unsafe extern "C" fn set_scrollX<D: DomTypes>
3346(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3347 let mut result = false;
3348 wrap_panic(&mut || result = {
3349
3350 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"scrollX".as_ptr(),
3351 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
3352 });
3353 result
3354}
3355
3356
3357static scrollX_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3358
3359pub(crate) fn init_scrollX_getterinfo<D: DomTypes>() {
3360 scrollX_getterinfo.set(JSJitInfo {
3361 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3362 getter: Some(get_scrollX::<D>)
3363 },
3364 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3365 protoID: PrototypeList::ID::Window as u16,
3366 },
3367 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3368 _bitfield_align_1: [],
3369 _bitfield_1: __BindgenBitfieldUnit::new(
3370 new_jsjitinfo_bitfield_1!(
3371 JSJitInfo_OpType::Getter as u8,
3372 JSJitInfo_AliasSet::AliasEverything as u8,
3373 JSValueType::JSVAL_TYPE_INT32 as u8,
3374 true,
3375 false,
3376 false,
3377 false,
3378 false,
3379 false,
3380 0,
3381 ).to_ne_bytes()
3382 ),
3383});
3384}
3385static scrollX_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3386
3387pub(crate) fn init_scrollX_setterinfo<D: DomTypes>() {
3388 scrollX_setterinfo.set(JSJitInfo {
3389 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3390 setter: Some(set_scrollX::<D>)
3391 },
3392 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3393 protoID: PrototypeList::ID::Window as u16,
3394 },
3395 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3396 _bitfield_align_1: [],
3397 _bitfield_1: __BindgenBitfieldUnit::new(
3398 new_jsjitinfo_bitfield_1!(
3399 JSJitInfo_OpType::Setter as u8,
3400 JSJitInfo_AliasSet::AliasEverything as u8,
3401 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3402 false,
3403 false,
3404 false,
3405 false,
3406 false,
3407 false,
3408 0,
3409 ).to_ne_bytes()
3410 ),
3411});
3412}
3413unsafe extern "C" fn get_pageXOffset<D: DomTypes>
3414(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3415 let mut result = false;
3416 wrap_panic(&mut || result = (|| {
3417 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3418 let this = &*(this as *const D::Window);
3419 let result: i32 = this.PageXOffset();
3420
3421 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3422 return true;
3423 })());
3424 result
3425}
3426
3427unsafe extern "C" fn set_pageXOffset<D: DomTypes>
3428(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3429 let mut result = false;
3430 wrap_panic(&mut || result = {
3431
3432 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"pageXOffset".as_ptr(),
3433 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
3434 });
3435 result
3436}
3437
3438
3439static pageXOffset_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3440
3441pub(crate) fn init_pageXOffset_getterinfo<D: DomTypes>() {
3442 pageXOffset_getterinfo.set(JSJitInfo {
3443 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3444 getter: Some(get_pageXOffset::<D>)
3445 },
3446 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3447 protoID: PrototypeList::ID::Window as u16,
3448 },
3449 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3450 _bitfield_align_1: [],
3451 _bitfield_1: __BindgenBitfieldUnit::new(
3452 new_jsjitinfo_bitfield_1!(
3453 JSJitInfo_OpType::Getter as u8,
3454 JSJitInfo_AliasSet::AliasEverything as u8,
3455 JSValueType::JSVAL_TYPE_INT32 as u8,
3456 true,
3457 false,
3458 false,
3459 false,
3460 false,
3461 false,
3462 0,
3463 ).to_ne_bytes()
3464 ),
3465});
3466}
3467static pageXOffset_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3468
3469pub(crate) fn init_pageXOffset_setterinfo<D: DomTypes>() {
3470 pageXOffset_setterinfo.set(JSJitInfo {
3471 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3472 setter: Some(set_pageXOffset::<D>)
3473 },
3474 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3475 protoID: PrototypeList::ID::Window as u16,
3476 },
3477 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3478 _bitfield_align_1: [],
3479 _bitfield_1: __BindgenBitfieldUnit::new(
3480 new_jsjitinfo_bitfield_1!(
3481 JSJitInfo_OpType::Setter as u8,
3482 JSJitInfo_AliasSet::AliasEverything as u8,
3483 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3484 false,
3485 false,
3486 false,
3487 false,
3488 false,
3489 false,
3490 0,
3491 ).to_ne_bytes()
3492 ),
3493});
3494}
3495unsafe extern "C" fn get_scrollY<D: DomTypes>
3496(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3497 let mut result = false;
3498 wrap_panic(&mut || result = (|| {
3499 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3500 let this = &*(this as *const D::Window);
3501 let result: i32 = this.ScrollY();
3502
3503 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3504 return true;
3505 })());
3506 result
3507}
3508
3509unsafe extern "C" fn set_scrollY<D: DomTypes>
3510(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3511 let mut result = false;
3512 wrap_panic(&mut || result = {
3513
3514 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"scrollY".as_ptr(),
3515 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
3516 });
3517 result
3518}
3519
3520
3521static scrollY_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3522
3523pub(crate) fn init_scrollY_getterinfo<D: DomTypes>() {
3524 scrollY_getterinfo.set(JSJitInfo {
3525 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3526 getter: Some(get_scrollY::<D>)
3527 },
3528 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3529 protoID: PrototypeList::ID::Window as u16,
3530 },
3531 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3532 _bitfield_align_1: [],
3533 _bitfield_1: __BindgenBitfieldUnit::new(
3534 new_jsjitinfo_bitfield_1!(
3535 JSJitInfo_OpType::Getter as u8,
3536 JSJitInfo_AliasSet::AliasEverything as u8,
3537 JSValueType::JSVAL_TYPE_INT32 as u8,
3538 true,
3539 false,
3540 false,
3541 false,
3542 false,
3543 false,
3544 0,
3545 ).to_ne_bytes()
3546 ),
3547});
3548}
3549static scrollY_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3550
3551pub(crate) fn init_scrollY_setterinfo<D: DomTypes>() {
3552 scrollY_setterinfo.set(JSJitInfo {
3553 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3554 setter: Some(set_scrollY::<D>)
3555 },
3556 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3557 protoID: PrototypeList::ID::Window as u16,
3558 },
3559 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3560 _bitfield_align_1: [],
3561 _bitfield_1: __BindgenBitfieldUnit::new(
3562 new_jsjitinfo_bitfield_1!(
3563 JSJitInfo_OpType::Setter as u8,
3564 JSJitInfo_AliasSet::AliasEverything as u8,
3565 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3566 false,
3567 false,
3568 false,
3569 false,
3570 false,
3571 false,
3572 0,
3573 ).to_ne_bytes()
3574 ),
3575});
3576}
3577unsafe extern "C" fn get_pageYOffset<D: DomTypes>
3578(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3579 let mut result = false;
3580 wrap_panic(&mut || result = (|| {
3581 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3582 let this = &*(this as *const D::Window);
3583 let result: i32 = this.PageYOffset();
3584
3585 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3586 return true;
3587 })());
3588 result
3589}
3590
3591unsafe extern "C" fn set_pageYOffset<D: DomTypes>
3592(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3593 let mut result = false;
3594 wrap_panic(&mut || result = {
3595
3596 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"pageYOffset".as_ptr(),
3597 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
3598 });
3599 result
3600}
3601
3602
3603static pageYOffset_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3604
3605pub(crate) fn init_pageYOffset_getterinfo<D: DomTypes>() {
3606 pageYOffset_getterinfo.set(JSJitInfo {
3607 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3608 getter: Some(get_pageYOffset::<D>)
3609 },
3610 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3611 protoID: PrototypeList::ID::Window as u16,
3612 },
3613 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3614 _bitfield_align_1: [],
3615 _bitfield_1: __BindgenBitfieldUnit::new(
3616 new_jsjitinfo_bitfield_1!(
3617 JSJitInfo_OpType::Getter as u8,
3618 JSJitInfo_AliasSet::AliasEverything as u8,
3619 JSValueType::JSVAL_TYPE_INT32 as u8,
3620 true,
3621 false,
3622 false,
3623 false,
3624 false,
3625 false,
3626 0,
3627 ).to_ne_bytes()
3628 ),
3629});
3630}
3631static pageYOffset_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3632
3633pub(crate) fn init_pageYOffset_setterinfo<D: DomTypes>() {
3634 pageYOffset_setterinfo.set(JSJitInfo {
3635 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3636 setter: Some(set_pageYOffset::<D>)
3637 },
3638 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3639 protoID: PrototypeList::ID::Window as u16,
3640 },
3641 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3642 _bitfield_align_1: [],
3643 _bitfield_1: __BindgenBitfieldUnit::new(
3644 new_jsjitinfo_bitfield_1!(
3645 JSJitInfo_OpType::Setter as u8,
3646 JSJitInfo_AliasSet::AliasEverything as u8,
3647 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3648 false,
3649 false,
3650 false,
3651 false,
3652 false,
3653 false,
3654 0,
3655 ).to_ne_bytes()
3656 ),
3657});
3658}
3659unsafe extern "C" fn scroll<D: DomTypes>
3660(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3661 let mut result = false;
3662 wrap_panic(&mut || result = (|| {
3663 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3664 let this = &*(this as *const D::Window);
3665 let args = &*args;
3666 let argc = args.argc_;
3667
3668 let argcount = cmp::min(argc, 2);
3669 match argcount {
3670 0 => {
3671 let arg0: crate::codegen::GenericBindings::WindowBinding::ScrollToOptions = if args.get(0).is_undefined() {
3672 crate::codegen::GenericBindings::WindowBinding::ScrollToOptions::empty()
3673 } else {
3674 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3675 Ok(ConversionResult::Success(value)) => value,
3676 Ok(ConversionResult::Failure(error)) => {
3677 throw_type_error(cx.raw_cx(), &error);
3678 return false;
3679
3680 }
3681 _ => {
3682 return false;
3683
3684 },
3685 }
3686
3687 };
3688 let result: () = this.Scroll(&arg0);
3689
3690 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3691 return true;
3692 }
3693 1 => {
3694 let arg0: crate::codegen::GenericBindings::WindowBinding::ScrollToOptions = if args.get(0).is_undefined() {
3695 crate::codegen::GenericBindings::WindowBinding::ScrollToOptions::empty()
3696 } else {
3697 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3698 Ok(ConversionResult::Success(value)) => value,
3699 Ok(ConversionResult::Failure(error)) => {
3700 throw_type_error(cx.raw_cx(), &error);
3701 return false;
3702
3703 }
3704 _ => {
3705 return false;
3706
3707 },
3708 }
3709
3710 };
3711 let result: () = this.Scroll(&arg0);
3712
3713 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3714 return true;
3715 }
3716 2 => {
3717 let arg0: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3718 Ok(ConversionResult::Success(value)) => value,
3719 Ok(ConversionResult::Failure(error)) => {
3720 throw_type_error(cx.raw_cx(), &error);
3721 return false;
3722
3723 }
3724 _ => {
3725 return false;
3726
3727 },
3728 }
3729 ;
3730 let arg1: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
3731 Ok(ConversionResult::Success(value)) => value,
3732 Ok(ConversionResult::Failure(error)) => {
3733 throw_type_error(cx.raw_cx(), &error);
3734 return false;
3735
3736 }
3737 _ => {
3738 return false;
3739
3740 },
3741 }
3742 ;
3743 let result: () = this.Scroll_(arg0, arg1);
3744
3745 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3746 return true;
3747 }
3748 _ => {
3749 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.scroll\".");
3750 return false;
3751 }
3752 }
3753 })());
3754 result
3755}
3756
3757
3758static scroll_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3759
3760pub(crate) fn init_scroll_methodinfo<D: DomTypes>() {
3761 scroll_methodinfo.set(JSJitInfo {
3762 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3763 method: Some(scroll::<D>)
3764 },
3765 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3766 protoID: PrototypeList::ID::Window as u16,
3767 },
3768 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3769 _bitfield_align_1: [],
3770 _bitfield_1: __BindgenBitfieldUnit::new(
3771 new_jsjitinfo_bitfield_1!(
3772 JSJitInfo_OpType::Method as u8,
3773 JSJitInfo_AliasSet::AliasEverything as u8,
3774 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3775 false,
3776 false,
3777 false,
3778 false,
3779 false,
3780 false,
3781 0,
3782 ).to_ne_bytes()
3783 ),
3784});
3785}
3786unsafe extern "C" fn scrollTo<D: DomTypes>
3787(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3788 let mut result = false;
3789 wrap_panic(&mut || result = (|| {
3790 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3791 let this = &*(this as *const D::Window);
3792 let args = &*args;
3793 let argc = args.argc_;
3794
3795 let argcount = cmp::min(argc, 2);
3796 match argcount {
3797 0 => {
3798 let arg0: crate::codegen::GenericBindings::WindowBinding::ScrollToOptions = if args.get(0).is_undefined() {
3799 crate::codegen::GenericBindings::WindowBinding::ScrollToOptions::empty()
3800 } else {
3801 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3802 Ok(ConversionResult::Success(value)) => value,
3803 Ok(ConversionResult::Failure(error)) => {
3804 throw_type_error(cx.raw_cx(), &error);
3805 return false;
3806
3807 }
3808 _ => {
3809 return false;
3810
3811 },
3812 }
3813
3814 };
3815 let result: () = this.ScrollTo(&arg0);
3816
3817 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3818 return true;
3819 }
3820 1 => {
3821 let arg0: crate::codegen::GenericBindings::WindowBinding::ScrollToOptions = if args.get(0).is_undefined() {
3822 crate::codegen::GenericBindings::WindowBinding::ScrollToOptions::empty()
3823 } else {
3824 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3825 Ok(ConversionResult::Success(value)) => value,
3826 Ok(ConversionResult::Failure(error)) => {
3827 throw_type_error(cx.raw_cx(), &error);
3828 return false;
3829
3830 }
3831 _ => {
3832 return false;
3833
3834 },
3835 }
3836
3837 };
3838 let result: () = this.ScrollTo(&arg0);
3839
3840 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3841 return true;
3842 }
3843 2 => {
3844 let arg0: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3845 Ok(ConversionResult::Success(value)) => value,
3846 Ok(ConversionResult::Failure(error)) => {
3847 throw_type_error(cx.raw_cx(), &error);
3848 return false;
3849
3850 }
3851 _ => {
3852 return false;
3853
3854 },
3855 }
3856 ;
3857 let arg1: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
3858 Ok(ConversionResult::Success(value)) => value,
3859 Ok(ConversionResult::Failure(error)) => {
3860 throw_type_error(cx.raw_cx(), &error);
3861 return false;
3862
3863 }
3864 _ => {
3865 return false;
3866
3867 },
3868 }
3869 ;
3870 let result: () = this.ScrollTo_(arg0, arg1);
3871
3872 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3873 return true;
3874 }
3875 _ => {
3876 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.scrollTo\".");
3877 return false;
3878 }
3879 }
3880 })());
3881 result
3882}
3883
3884
3885static scrollTo_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3886
3887pub(crate) fn init_scrollTo_methodinfo<D: DomTypes>() {
3888 scrollTo_methodinfo.set(JSJitInfo {
3889 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3890 method: Some(scrollTo::<D>)
3891 },
3892 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3893 protoID: PrototypeList::ID::Window as u16,
3894 },
3895 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3896 _bitfield_align_1: [],
3897 _bitfield_1: __BindgenBitfieldUnit::new(
3898 new_jsjitinfo_bitfield_1!(
3899 JSJitInfo_OpType::Method as u8,
3900 JSJitInfo_AliasSet::AliasEverything as u8,
3901 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3902 false,
3903 false,
3904 false,
3905 false,
3906 false,
3907 false,
3908 0,
3909 ).to_ne_bytes()
3910 ),
3911});
3912}
3913unsafe extern "C" fn scrollBy<D: DomTypes>
3914(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3915 let mut result = false;
3916 wrap_panic(&mut || result = (|| {
3917 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3918 let this = &*(this as *const D::Window);
3919 let args = &*args;
3920 let argc = args.argc_;
3921
3922 let argcount = cmp::min(argc, 2);
3923 match argcount {
3924 0 => {
3925 let arg0: crate::codegen::GenericBindings::WindowBinding::ScrollToOptions = if args.get(0).is_undefined() {
3926 crate::codegen::GenericBindings::WindowBinding::ScrollToOptions::empty()
3927 } else {
3928 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3929 Ok(ConversionResult::Success(value)) => value,
3930 Ok(ConversionResult::Failure(error)) => {
3931 throw_type_error(cx.raw_cx(), &error);
3932 return false;
3933
3934 }
3935 _ => {
3936 return false;
3937
3938 },
3939 }
3940
3941 };
3942 let result: () = this.ScrollBy(&arg0);
3943
3944 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3945 return true;
3946 }
3947 1 => {
3948 let arg0: crate::codegen::GenericBindings::WindowBinding::ScrollToOptions = if args.get(0).is_undefined() {
3949 crate::codegen::GenericBindings::WindowBinding::ScrollToOptions::empty()
3950 } else {
3951 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3952 Ok(ConversionResult::Success(value)) => value,
3953 Ok(ConversionResult::Failure(error)) => {
3954 throw_type_error(cx.raw_cx(), &error);
3955 return false;
3956
3957 }
3958 _ => {
3959 return false;
3960
3961 },
3962 }
3963
3964 };
3965 let result: () = this.ScrollBy(&arg0);
3966
3967 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3968 return true;
3969 }
3970 2 => {
3971 let arg0: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3972 Ok(ConversionResult::Success(value)) => value,
3973 Ok(ConversionResult::Failure(error)) => {
3974 throw_type_error(cx.raw_cx(), &error);
3975 return false;
3976
3977 }
3978 _ => {
3979 return false;
3980
3981 },
3982 }
3983 ;
3984 let arg1: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
3985 Ok(ConversionResult::Success(value)) => value,
3986 Ok(ConversionResult::Failure(error)) => {
3987 throw_type_error(cx.raw_cx(), &error);
3988 return false;
3989
3990 }
3991 _ => {
3992 return false;
3993
3994 },
3995 }
3996 ;
3997 let result: () = this.ScrollBy_(arg0, arg1);
3998
3999 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4000 return true;
4001 }
4002 _ => {
4003 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.scrollBy\".");
4004 return false;
4005 }
4006 }
4007 })());
4008 result
4009}
4010
4011
4012static scrollBy_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4013
4014pub(crate) fn init_scrollBy_methodinfo<D: DomTypes>() {
4015 scrollBy_methodinfo.set(JSJitInfo {
4016 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4017 method: Some(scrollBy::<D>)
4018 },
4019 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4020 protoID: PrototypeList::ID::Window as u16,
4021 },
4022 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4023 _bitfield_align_1: [],
4024 _bitfield_1: __BindgenBitfieldUnit::new(
4025 new_jsjitinfo_bitfield_1!(
4026 JSJitInfo_OpType::Method as u8,
4027 JSJitInfo_AliasSet::AliasEverything as u8,
4028 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4029 false,
4030 false,
4031 false,
4032 false,
4033 false,
4034 false,
4035 0,
4036 ).to_ne_bytes()
4037 ),
4038});
4039}
4040unsafe extern "C" fn get_screenX<D: DomTypes>
4041(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4042 let mut result = false;
4043 wrap_panic(&mut || result = (|| {
4044 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4045 let this = &*(this as *const D::Window);
4046 let result: i32 = this.ScreenX();
4047
4048 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4049 return true;
4050 })());
4051 result
4052}
4053
4054unsafe extern "C" fn set_screenX<D: DomTypes>
4055(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4056 let mut result = false;
4057 wrap_panic(&mut || result = {
4058
4059 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"screenX".as_ptr(),
4060 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
4061 });
4062 result
4063}
4064
4065
4066static screenX_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4067
4068pub(crate) fn init_screenX_getterinfo<D: DomTypes>() {
4069 screenX_getterinfo.set(JSJitInfo {
4070 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4071 getter: Some(get_screenX::<D>)
4072 },
4073 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4074 protoID: PrototypeList::ID::Window as u16,
4075 },
4076 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4077 _bitfield_align_1: [],
4078 _bitfield_1: __BindgenBitfieldUnit::new(
4079 new_jsjitinfo_bitfield_1!(
4080 JSJitInfo_OpType::Getter as u8,
4081 JSJitInfo_AliasSet::AliasEverything as u8,
4082 JSValueType::JSVAL_TYPE_INT32 as u8,
4083 true,
4084 false,
4085 false,
4086 false,
4087 false,
4088 false,
4089 0,
4090 ).to_ne_bytes()
4091 ),
4092});
4093}
4094static screenX_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4095
4096pub(crate) fn init_screenX_setterinfo<D: DomTypes>() {
4097 screenX_setterinfo.set(JSJitInfo {
4098 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4099 setter: Some(set_screenX::<D>)
4100 },
4101 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4102 protoID: PrototypeList::ID::Window as u16,
4103 },
4104 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4105 _bitfield_align_1: [],
4106 _bitfield_1: __BindgenBitfieldUnit::new(
4107 new_jsjitinfo_bitfield_1!(
4108 JSJitInfo_OpType::Setter as u8,
4109 JSJitInfo_AliasSet::AliasEverything as u8,
4110 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4111 false,
4112 false,
4113 false,
4114 false,
4115 false,
4116 false,
4117 0,
4118 ).to_ne_bytes()
4119 ),
4120});
4121}
4122unsafe extern "C" fn get_screenY<D: DomTypes>
4123(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4124 let mut result = false;
4125 wrap_panic(&mut || result = (|| {
4126 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4127 let this = &*(this as *const D::Window);
4128 let result: i32 = this.ScreenY();
4129
4130 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4131 return true;
4132 })());
4133 result
4134}
4135
4136unsafe extern "C" fn set_screenY<D: DomTypes>
4137(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4138 let mut result = false;
4139 wrap_panic(&mut || result = {
4140
4141 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"screenY".as_ptr(),
4142 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
4143 });
4144 result
4145}
4146
4147
4148static screenY_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4149
4150pub(crate) fn init_screenY_getterinfo<D: DomTypes>() {
4151 screenY_getterinfo.set(JSJitInfo {
4152 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4153 getter: Some(get_screenY::<D>)
4154 },
4155 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4156 protoID: PrototypeList::ID::Window as u16,
4157 },
4158 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4159 _bitfield_align_1: [],
4160 _bitfield_1: __BindgenBitfieldUnit::new(
4161 new_jsjitinfo_bitfield_1!(
4162 JSJitInfo_OpType::Getter as u8,
4163 JSJitInfo_AliasSet::AliasEverything as u8,
4164 JSValueType::JSVAL_TYPE_INT32 as u8,
4165 true,
4166 false,
4167 false,
4168 false,
4169 false,
4170 false,
4171 0,
4172 ).to_ne_bytes()
4173 ),
4174});
4175}
4176static screenY_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4177
4178pub(crate) fn init_screenY_setterinfo<D: DomTypes>() {
4179 screenY_setterinfo.set(JSJitInfo {
4180 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4181 setter: Some(set_screenY::<D>)
4182 },
4183 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4184 protoID: PrototypeList::ID::Window as u16,
4185 },
4186 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4187 _bitfield_align_1: [],
4188 _bitfield_1: __BindgenBitfieldUnit::new(
4189 new_jsjitinfo_bitfield_1!(
4190 JSJitInfo_OpType::Setter as u8,
4191 JSJitInfo_AliasSet::AliasEverything as u8,
4192 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4193 false,
4194 false,
4195 false,
4196 false,
4197 false,
4198 false,
4199 0,
4200 ).to_ne_bytes()
4201 ),
4202});
4203}
4204unsafe extern "C" fn get_outerWidth<D: DomTypes>
4205(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4206 let mut result = false;
4207 wrap_panic(&mut || result = (|| {
4208 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4209 let this = &*(this as *const D::Window);
4210 let result: i32 = this.OuterWidth();
4211
4212 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4213 return true;
4214 })());
4215 result
4216}
4217
4218unsafe extern "C" fn set_outerWidth<D: DomTypes>
4219(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4220 let mut result = false;
4221 wrap_panic(&mut || result = {
4222
4223 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"outerWidth".as_ptr(),
4224 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
4225 });
4226 result
4227}
4228
4229
4230static outerWidth_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4231
4232pub(crate) fn init_outerWidth_getterinfo<D: DomTypes>() {
4233 outerWidth_getterinfo.set(JSJitInfo {
4234 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4235 getter: Some(get_outerWidth::<D>)
4236 },
4237 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4238 protoID: PrototypeList::ID::Window as u16,
4239 },
4240 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4241 _bitfield_align_1: [],
4242 _bitfield_1: __BindgenBitfieldUnit::new(
4243 new_jsjitinfo_bitfield_1!(
4244 JSJitInfo_OpType::Getter as u8,
4245 JSJitInfo_AliasSet::AliasEverything as u8,
4246 JSValueType::JSVAL_TYPE_INT32 as u8,
4247 true,
4248 false,
4249 false,
4250 false,
4251 false,
4252 false,
4253 0,
4254 ).to_ne_bytes()
4255 ),
4256});
4257}
4258static outerWidth_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4259
4260pub(crate) fn init_outerWidth_setterinfo<D: DomTypes>() {
4261 outerWidth_setterinfo.set(JSJitInfo {
4262 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4263 setter: Some(set_outerWidth::<D>)
4264 },
4265 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4266 protoID: PrototypeList::ID::Window as u16,
4267 },
4268 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4269 _bitfield_align_1: [],
4270 _bitfield_1: __BindgenBitfieldUnit::new(
4271 new_jsjitinfo_bitfield_1!(
4272 JSJitInfo_OpType::Setter as u8,
4273 JSJitInfo_AliasSet::AliasEverything as u8,
4274 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4275 false,
4276 false,
4277 false,
4278 false,
4279 false,
4280 false,
4281 0,
4282 ).to_ne_bytes()
4283 ),
4284});
4285}
4286unsafe extern "C" fn get_outerHeight<D: DomTypes>
4287(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4288 let mut result = false;
4289 wrap_panic(&mut || result = (|| {
4290 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4291 let this = &*(this as *const D::Window);
4292 let result: i32 = this.OuterHeight();
4293
4294 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4295 return true;
4296 })());
4297 result
4298}
4299
4300unsafe extern "C" fn set_outerHeight<D: DomTypes>
4301(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4302 let mut result = false;
4303 wrap_panic(&mut || result = {
4304
4305 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"outerHeight".as_ptr(),
4306 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
4307 });
4308 result
4309}
4310
4311
4312static outerHeight_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4313
4314pub(crate) fn init_outerHeight_getterinfo<D: DomTypes>() {
4315 outerHeight_getterinfo.set(JSJitInfo {
4316 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4317 getter: Some(get_outerHeight::<D>)
4318 },
4319 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4320 protoID: PrototypeList::ID::Window as u16,
4321 },
4322 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4323 _bitfield_align_1: [],
4324 _bitfield_1: __BindgenBitfieldUnit::new(
4325 new_jsjitinfo_bitfield_1!(
4326 JSJitInfo_OpType::Getter as u8,
4327 JSJitInfo_AliasSet::AliasEverything as u8,
4328 JSValueType::JSVAL_TYPE_INT32 as u8,
4329 true,
4330 false,
4331 false,
4332 false,
4333 false,
4334 false,
4335 0,
4336 ).to_ne_bytes()
4337 ),
4338});
4339}
4340static outerHeight_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4341
4342pub(crate) fn init_outerHeight_setterinfo<D: DomTypes>() {
4343 outerHeight_setterinfo.set(JSJitInfo {
4344 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4345 setter: Some(set_outerHeight::<D>)
4346 },
4347 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4348 protoID: PrototypeList::ID::Window as u16,
4349 },
4350 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4351 _bitfield_align_1: [],
4352 _bitfield_1: __BindgenBitfieldUnit::new(
4353 new_jsjitinfo_bitfield_1!(
4354 JSJitInfo_OpType::Setter as u8,
4355 JSJitInfo_AliasSet::AliasEverything as u8,
4356 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4357 false,
4358 false,
4359 false,
4360 false,
4361 false,
4362 false,
4363 0,
4364 ).to_ne_bytes()
4365 ),
4366});
4367}
4368unsafe extern "C" fn get_devicePixelRatio<D: DomTypes>
4369(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4370 let mut result = false;
4371 wrap_panic(&mut || result = (|| {
4372 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4373 let this = &*(this as *const D::Window);
4374 let result: Finite<f64> = this.DevicePixelRatio();
4375
4376 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4377 return true;
4378 })());
4379 result
4380}
4381
4382unsafe extern "C" fn set_devicePixelRatio<D: DomTypes>
4383(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4384 let mut result = false;
4385 wrap_panic(&mut || result = {
4386
4387 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"devicePixelRatio".as_ptr(),
4388 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
4389 });
4390 result
4391}
4392
4393
4394static devicePixelRatio_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4395
4396pub(crate) fn init_devicePixelRatio_getterinfo<D: DomTypes>() {
4397 devicePixelRatio_getterinfo.set(JSJitInfo {
4398 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4399 getter: Some(get_devicePixelRatio::<D>)
4400 },
4401 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4402 protoID: PrototypeList::ID::Window as u16,
4403 },
4404 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4405 _bitfield_align_1: [],
4406 _bitfield_1: __BindgenBitfieldUnit::new(
4407 new_jsjitinfo_bitfield_1!(
4408 JSJitInfo_OpType::Getter as u8,
4409 JSJitInfo_AliasSet::AliasEverything as u8,
4410 JSValueType::JSVAL_TYPE_DOUBLE as u8,
4411 true,
4412 false,
4413 false,
4414 false,
4415 false,
4416 false,
4417 0,
4418 ).to_ne_bytes()
4419 ),
4420});
4421}
4422static devicePixelRatio_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4423
4424pub(crate) fn init_devicePixelRatio_setterinfo<D: DomTypes>() {
4425 devicePixelRatio_setterinfo.set(JSJitInfo {
4426 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4427 setter: Some(set_devicePixelRatio::<D>)
4428 },
4429 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4430 protoID: PrototypeList::ID::Window as u16,
4431 },
4432 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4433 _bitfield_align_1: [],
4434 _bitfield_1: __BindgenBitfieldUnit::new(
4435 new_jsjitinfo_bitfield_1!(
4436 JSJitInfo_OpType::Setter as u8,
4437 JSJitInfo_AliasSet::AliasEverything as u8,
4438 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4439 false,
4440 false,
4441 false,
4442 false,
4443 false,
4444 false,
4445 0,
4446 ).to_ne_bytes()
4447 ),
4448});
4449}
4450unsafe extern "C" fn debug<D: DomTypes>
4451(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4452 let mut result = false;
4453 wrap_panic(&mut || result = (|| {
4454 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4455 let this = &*(this as *const D::Window);
4456 let args = &*args;
4457 let argc = args.argc_;
4458
4459 if argc < 1 {
4460 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.debug\".");
4461 return false;
4462 }
4463 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4464 Ok(ConversionResult::Success(value)) => value,
4465 Ok(ConversionResult::Failure(error)) => {
4466 throw_type_error(cx.raw_cx(), &error);
4467 return false;
4468
4469 }
4470 _ => {
4471 return false;
4472
4473 },
4474 }
4475 ;
4476 let result: () = this.Debug(arg0);
4477
4478 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4479 return true;
4480 })());
4481 result
4482}
4483
4484
4485static debug_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4486
4487pub(crate) fn init_debug_methodinfo<D: DomTypes>() {
4488 debug_methodinfo.set(JSJitInfo {
4489 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4490 method: Some(debug::<D>)
4491 },
4492 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4493 protoID: PrototypeList::ID::Window as u16,
4494 },
4495 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4496 _bitfield_align_1: [],
4497 _bitfield_1: __BindgenBitfieldUnit::new(
4498 new_jsjitinfo_bitfield_1!(
4499 JSJitInfo_OpType::Method as u8,
4500 JSJitInfo_AliasSet::AliasEverything as u8,
4501 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4502 false,
4503 false,
4504 false,
4505 false,
4506 false,
4507 false,
4508 0,
4509 ).to_ne_bytes()
4510 ),
4511});
4512}
4513unsafe extern "C" fn gc<D: DomTypes>
4514(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4515 let mut result = false;
4516 wrap_panic(&mut || result = (|| {
4517 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4518 let this = &*(this as *const D::Window);
4519 let args = &*args;
4520 let argc = args.argc_;
4521 let result: () = this.Gc();
4522
4523 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4524 return true;
4525 })());
4526 result
4527}
4528
4529
4530static gc_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4531
4532pub(crate) fn init_gc_methodinfo<D: DomTypes>() {
4533 gc_methodinfo.set(JSJitInfo {
4534 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4535 method: Some(gc::<D>)
4536 },
4537 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4538 protoID: PrototypeList::ID::Window as u16,
4539 },
4540 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4541 _bitfield_align_1: [],
4542 _bitfield_1: __BindgenBitfieldUnit::new(
4543 new_jsjitinfo_bitfield_1!(
4544 JSJitInfo_OpType::Method as u8,
4545 JSJitInfo_AliasSet::AliasEverything as u8,
4546 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4547 true,
4548 false,
4549 false,
4550 false,
4551 false,
4552 false,
4553 0,
4554 ).to_ne_bytes()
4555 ),
4556});
4557}
4558unsafe extern "C" fn js_backtrace<D: DomTypes>
4559(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4560 let mut result = false;
4561 wrap_panic(&mut || result = (|| {
4562 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4563 let this = &*(this as *const D::Window);
4564 let args = &*args;
4565 let argc = args.argc_;
4566 let result: () = this.Js_backtrace();
4567
4568 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4569 return true;
4570 })());
4571 result
4572}
4573
4574
4575static js_backtrace_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4576
4577pub(crate) fn init_js_backtrace_methodinfo<D: DomTypes>() {
4578 js_backtrace_methodinfo.set(JSJitInfo {
4579 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4580 method: Some(js_backtrace::<D>)
4581 },
4582 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4583 protoID: PrototypeList::ID::Window as u16,
4584 },
4585 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4586 _bitfield_align_1: [],
4587 _bitfield_1: __BindgenBitfieldUnit::new(
4588 new_jsjitinfo_bitfield_1!(
4589 JSJitInfo_OpType::Method as u8,
4590 JSJitInfo_AliasSet::AliasEverything as u8,
4591 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4592 true,
4593 false,
4594 false,
4595 false,
4596 false,
4597 false,
4598 0,
4599 ).to_ne_bytes()
4600 ),
4601});
4602}
4603unsafe extern "C" fn webdriverCallback<D: DomTypes>
4604(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4605 let mut result = false;
4606 wrap_panic(&mut || result = (|| {
4607 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4608 let this = &*(this as *const D::Window);
4609 let args = &*args;
4610 let argc = args.argc_;
4611 let arg0: HandleValue = if args.get(0).is_undefined() {
4612 HandleValue::undefined()
4613 } else {
4614 HandleValue::from_raw(args.get(0))
4615 };
4616 let result: () = this.WebdriverCallback(SafeJSContext::from_ptr(cx.raw_cx()), arg0, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());
4617
4618 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4619 return true;
4620 })());
4621 result
4622}
4623
4624
4625static webdriverCallback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4626
4627pub(crate) fn init_webdriverCallback_methodinfo<D: DomTypes>() {
4628 webdriverCallback_methodinfo.set(JSJitInfo {
4629 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4630 method: Some(webdriverCallback::<D>)
4631 },
4632 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4633 protoID: PrototypeList::ID::Window as u16,
4634 },
4635 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4636 _bitfield_align_1: [],
4637 _bitfield_1: __BindgenBitfieldUnit::new(
4638 new_jsjitinfo_bitfield_1!(
4639 JSJitInfo_OpType::Method as u8,
4640 JSJitInfo_AliasSet::AliasEverything as u8,
4641 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4642 false,
4643 false,
4644 false,
4645 false,
4646 false,
4647 false,
4648 0,
4649 ).to_ne_bytes()
4650 ),
4651});
4652}
4653unsafe extern "C" fn webdriverException<D: DomTypes>
4654(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4655 let mut result = false;
4656 wrap_panic(&mut || result = (|| {
4657 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4658 let this = &*(this as *const D::Window);
4659 let args = &*args;
4660 let argc = args.argc_;
4661 let arg0: HandleValue = if args.get(0).is_undefined() {
4662 HandleValue::undefined()
4663 } else {
4664 HandleValue::from_raw(args.get(0))
4665 };
4666 let result: () = this.WebdriverException(SafeJSContext::from_ptr(cx.raw_cx()), arg0, CanGc::note());
4667
4668 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4669 return true;
4670 })());
4671 result
4672}
4673
4674
4675static webdriverException_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4676
4677pub(crate) fn init_webdriverException_methodinfo<D: DomTypes>() {
4678 webdriverException_methodinfo.set(JSJitInfo {
4679 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4680 method: Some(webdriverException::<D>)
4681 },
4682 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4683 protoID: PrototypeList::ID::Window as u16,
4684 },
4685 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4686 _bitfield_align_1: [],
4687 _bitfield_1: __BindgenBitfieldUnit::new(
4688 new_jsjitinfo_bitfield_1!(
4689 JSJitInfo_OpType::Method as u8,
4690 JSJitInfo_AliasSet::AliasEverything as u8,
4691 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4692 false,
4693 false,
4694 false,
4695 false,
4696 false,
4697 false,
4698 0,
4699 ).to_ne_bytes()
4700 ),
4701});
4702}
4703unsafe extern "C" fn webdriverElement<D: DomTypes>
4704(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4705 let mut result = false;
4706 wrap_panic(&mut || result = (|| {
4707 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4708 let this = &*(this as *const D::Window);
4709 let args = &*args;
4710 let argc = args.argc_;
4711
4712 if argc < 1 {
4713 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.webdriverElement\".");
4714 return false;
4715 }
4716 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4717 Ok(ConversionResult::Success(value)) => value,
4718 Ok(ConversionResult::Failure(error)) => {
4719 throw_type_error(cx.raw_cx(), &error);
4720 return false;
4721
4722 }
4723 _ => {
4724 return false;
4725
4726 },
4727 }
4728 ;
4729 let result: Option<DomRoot<D::Element>> = this.WebdriverElement(arg0);
4730
4731 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4732 return true;
4733 })());
4734 result
4735}
4736
4737
4738static webdriverElement_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4739
4740pub(crate) fn init_webdriverElement_methodinfo<D: DomTypes>() {
4741 webdriverElement_methodinfo.set(JSJitInfo {
4742 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4743 method: Some(webdriverElement::<D>)
4744 },
4745 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4746 protoID: PrototypeList::ID::Window as u16,
4747 },
4748 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4749 _bitfield_align_1: [],
4750 _bitfield_1: __BindgenBitfieldUnit::new(
4751 new_jsjitinfo_bitfield_1!(
4752 JSJitInfo_OpType::Method as u8,
4753 JSJitInfo_AliasSet::AliasEverything as u8,
4754 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4755 false,
4756 false,
4757 false,
4758 false,
4759 false,
4760 false,
4761 0,
4762 ).to_ne_bytes()
4763 ),
4764});
4765}
4766unsafe extern "C" fn webdriverFrame<D: DomTypes>
4767(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4768 let mut result = false;
4769 wrap_panic(&mut || result = (|| {
4770 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4771 let this = &*(this as *const D::Window);
4772 let args = &*args;
4773 let argc = args.argc_;
4774
4775 if argc < 1 {
4776 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.webdriverFrame\".");
4777 return false;
4778 }
4779 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4780 Ok(ConversionResult::Success(value)) => value,
4781 Ok(ConversionResult::Failure(error)) => {
4782 throw_type_error(cx.raw_cx(), &error);
4783 return false;
4784
4785 }
4786 _ => {
4787 return false;
4788
4789 },
4790 }
4791 ;
4792 let result: Option<DomRoot<D::WindowProxy>> = this.WebdriverFrame(arg0);
4793
4794 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4795 return true;
4796 })());
4797 result
4798}
4799
4800
4801static webdriverFrame_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4802
4803pub(crate) fn init_webdriverFrame_methodinfo<D: DomTypes>() {
4804 webdriverFrame_methodinfo.set(JSJitInfo {
4805 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4806 method: Some(webdriverFrame::<D>)
4807 },
4808 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4809 protoID: PrototypeList::ID::Window as u16,
4810 },
4811 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4812 _bitfield_align_1: [],
4813 _bitfield_1: __BindgenBitfieldUnit::new(
4814 new_jsjitinfo_bitfield_1!(
4815 JSJitInfo_OpType::Method as u8,
4816 JSJitInfo_AliasSet::AliasEverything as u8,
4817 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4818 false,
4819 false,
4820 false,
4821 false,
4822 false,
4823 false,
4824 0,
4825 ).to_ne_bytes()
4826 ),
4827});
4828}
4829unsafe extern "C" fn webdriverWindow<D: DomTypes>
4830(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4831 let mut result = false;
4832 wrap_panic(&mut || result = (|| {
4833 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4834 let this = &*(this as *const D::Window);
4835 let args = &*args;
4836 let argc = args.argc_;
4837
4838 if argc < 1 {
4839 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.webdriverWindow\".");
4840 return false;
4841 }
4842 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4843 Ok(ConversionResult::Success(value)) => value,
4844 Ok(ConversionResult::Failure(error)) => {
4845 throw_type_error(cx.raw_cx(), &error);
4846 return false;
4847
4848 }
4849 _ => {
4850 return false;
4851
4852 },
4853 }
4854 ;
4855 let result: DomRoot<D::WindowProxy> = this.WebdriverWindow(arg0);
4856
4857 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4858 return true;
4859 })());
4860 result
4861}
4862
4863
4864static webdriverWindow_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4865
4866pub(crate) fn init_webdriverWindow_methodinfo<D: DomTypes>() {
4867 webdriverWindow_methodinfo.set(JSJitInfo {
4868 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4869 method: Some(webdriverWindow::<D>)
4870 },
4871 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4872 protoID: PrototypeList::ID::Window as u16,
4873 },
4874 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4875 _bitfield_align_1: [],
4876 _bitfield_1: __BindgenBitfieldUnit::new(
4877 new_jsjitinfo_bitfield_1!(
4878 JSJitInfo_OpType::Method as u8,
4879 JSJitInfo_AliasSet::AliasEverything as u8,
4880 JSValueType::JSVAL_TYPE_OBJECT as u8,
4881 false,
4882 false,
4883 false,
4884 false,
4885 false,
4886 false,
4887 0,
4888 ).to_ne_bytes()
4889 ),
4890});
4891}
4892unsafe extern "C" fn webdriverShadowRoot<D: DomTypes>
4893(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4894 let mut result = false;
4895 wrap_panic(&mut || result = (|| {
4896 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4897 let this = &*(this as *const D::Window);
4898 let args = &*args;
4899 let argc = args.argc_;
4900
4901 if argc < 1 {
4902 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.webdriverShadowRoot\".");
4903 return false;
4904 }
4905 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4906 Ok(ConversionResult::Success(value)) => value,
4907 Ok(ConversionResult::Failure(error)) => {
4908 throw_type_error(cx.raw_cx(), &error);
4909 return false;
4910
4911 }
4912 _ => {
4913 return false;
4914
4915 },
4916 }
4917 ;
4918 let result: Option<DomRoot<D::ShadowRoot>> = this.WebdriverShadowRoot(arg0);
4919
4920 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4921 return true;
4922 })());
4923 result
4924}
4925
4926
4927static webdriverShadowRoot_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4928
4929pub(crate) fn init_webdriverShadowRoot_methodinfo<D: DomTypes>() {
4930 webdriverShadowRoot_methodinfo.set(JSJitInfo {
4931 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4932 method: Some(webdriverShadowRoot::<D>)
4933 },
4934 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4935 protoID: PrototypeList::ID::Window as u16,
4936 },
4937 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4938 _bitfield_align_1: [],
4939 _bitfield_1: __BindgenBitfieldUnit::new(
4940 new_jsjitinfo_bitfield_1!(
4941 JSJitInfo_OpType::Method as u8,
4942 JSJitInfo_AliasSet::AliasEverything as u8,
4943 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4944 false,
4945 false,
4946 false,
4947 false,
4948 false,
4949 false,
4950 0,
4951 ).to_ne_bytes()
4952 ),
4953});
4954}
4955unsafe extern "C" fn get_runningAnimationCount<D: DomTypes>
4956(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4957 let mut result = false;
4958 wrap_panic(&mut || result = (|| {
4959 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4960 let this = &*(this as *const D::Window);
4961 let result: u32 = this.RunningAnimationCount();
4962
4963 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4964 return true;
4965 })());
4966 result
4967}
4968
4969
4970static runningAnimationCount_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4971
4972pub(crate) fn init_runningAnimationCount_getterinfo<D: DomTypes>() {
4973 runningAnimationCount_getterinfo.set(JSJitInfo {
4974 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4975 getter: Some(get_runningAnimationCount::<D>)
4976 },
4977 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4978 protoID: PrototypeList::ID::Window as u16,
4979 },
4980 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4981 _bitfield_align_1: [],
4982 _bitfield_1: __BindgenBitfieldUnit::new(
4983 new_jsjitinfo_bitfield_1!(
4984 JSJitInfo_OpType::Getter as u8,
4985 JSJitInfo_AliasSet::AliasEverything as u8,
4986 JSValueType::JSVAL_TYPE_DOUBLE as u8,
4987 true,
4988 false,
4989 false,
4990 false,
4991 false,
4992 false,
4993 0,
4994 ).to_ne_bytes()
4995 ),
4996});
4997}
4998unsafe extern "C" fn getSelection<D: DomTypes>
4999(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5000 let mut result = false;
5001 wrap_panic(&mut || result = (|| {
5002 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5003 let this = &*(this as *const D::Window);
5004 let args = &*args;
5005 let argc = args.argc_;
5006 let result: Option<DomRoot<D::Selection>> = this.GetSelection();
5007
5008 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5009 return true;
5010 })());
5011 result
5012}
5013
5014
5015static getSelection_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5016
5017pub(crate) fn init_getSelection_methodinfo<D: DomTypes>() {
5018 getSelection_methodinfo.set(JSJitInfo {
5019 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5020 method: Some(getSelection::<D>)
5021 },
5022 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5023 protoID: PrototypeList::ID::Window as u16,
5024 },
5025 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5026 _bitfield_align_1: [],
5027 _bitfield_1: __BindgenBitfieldUnit::new(
5028 new_jsjitinfo_bitfield_1!(
5029 JSJitInfo_OpType::Method as u8,
5030 JSJitInfo_AliasSet::AliasEverything as u8,
5031 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5032 true,
5033 false,
5034 false,
5035 false,
5036 false,
5037 false,
5038 0,
5039 ).to_ne_bytes()
5040 ),
5041});
5042}
5043unsafe extern "C" fn get_event<D: DomTypes>
5044(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5045 let mut result = false;
5046 wrap_panic(&mut || result = (|| {
5047 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5048 let this = &*(this as *const D::Window);
5049 rooted!(&in(cx) let mut retval: JSVal);
5050 let result: () = this.Event(SafeJSContext::from_ptr(cx.raw_cx()), retval.handle_mut());
5051
5052 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5053 return true;
5054 })());
5055 result
5056}
5057
5058unsafe extern "C" fn set_event<D: DomTypes>
5059(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5060 let mut result = false;
5061 wrap_panic(&mut || result = {
5062
5063 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"event".as_ptr(),
5064 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
5065 });
5066 result
5067}
5068
5069
5070static event_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5071
5072pub(crate) fn init_event_getterinfo<D: DomTypes>() {
5073 event_getterinfo.set(JSJitInfo {
5074 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5075 getter: Some(get_event::<D>)
5076 },
5077 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5078 protoID: PrototypeList::ID::Window as u16,
5079 },
5080 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5081 _bitfield_align_1: [],
5082 _bitfield_1: __BindgenBitfieldUnit::new(
5083 new_jsjitinfo_bitfield_1!(
5084 JSJitInfo_OpType::Getter as u8,
5085 JSJitInfo_AliasSet::AliasEverything as u8,
5086 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5087 true,
5088 false,
5089 false,
5090 false,
5091 false,
5092 false,
5093 0,
5094 ).to_ne_bytes()
5095 ),
5096});
5097}
5098static event_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5099
5100pub(crate) fn init_event_setterinfo<D: DomTypes>() {
5101 event_setterinfo.set(JSJitInfo {
5102 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5103 setter: Some(set_event::<D>)
5104 },
5105 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5106 protoID: PrototypeList::ID::Window as u16,
5107 },
5108 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5109 _bitfield_align_1: [],
5110 _bitfield_1: __BindgenBitfieldUnit::new(
5111 new_jsjitinfo_bitfield_1!(
5112 JSJitInfo_OpType::Setter as u8,
5113 JSJitInfo_AliasSet::AliasEverything as u8,
5114 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5115 false,
5116 false,
5117 false,
5118 false,
5119 false,
5120 false,
5121 0,
5122 ).to_ne_bytes()
5123 ),
5124});
5125}
5126unsafe extern "C" fn fetchLater<D: DomTypes>
5127(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5128 let mut result = false;
5129 wrap_panic(&mut || result = (|| {
5130 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5131 let this = &*(this as *const D::Window);
5132 let args = &*args;
5133 let argc = args.argc_;
5134
5135 if argc < 1 {
5136 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.fetchLater\".");
5137 return false;
5138 }
5139 let arg0: GenericUnionTypes::RequestOrUSVString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
5140 Ok(ConversionResult::Success(value)) => value,
5141 Ok(ConversionResult::Failure(error)) => {
5142 throw_type_error(cx.raw_cx(), &error);
5143 return false;
5144
5145 }
5146 _ => {
5147 return false;
5148
5149 },
5150 }
5151 ;
5152 let arg1: RootedTraceableBox<crate::codegen::GenericBindings::WindowBinding::DeferredRequestInit<D>> = if args.get(1).is_undefined() {
5153 crate::codegen::GenericBindings::WindowBinding::DeferredRequestInit::empty()
5154 } else {
5155 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
5156 Ok(ConversionResult::Success(value)) => value,
5157 Ok(ConversionResult::Failure(error)) => {
5158 throw_type_error(cx.raw_cx(), &error);
5159 return false;
5160
5161 }
5162 _ => {
5163 return false;
5164
5165 },
5166 }
5167
5168 };
5169 let result: Result<DomRoot<D::FetchLaterResult>, Error> = this.FetchLater(arg0, arg1, CanGc::note());
5170 let result = match result {
5171 Ok(result) => result,
5172 Err(e) => {
5173 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
5174 return false;
5175 },
5176 };
5177
5178 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5179 return true;
5180 })());
5181 result
5182}
5183
5184
5185static fetchLater_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5186
5187pub(crate) fn init_fetchLater_methodinfo<D: DomTypes>() {
5188 fetchLater_methodinfo.set(JSJitInfo {
5189 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5190 method: Some(fetchLater::<D>)
5191 },
5192 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5193 protoID: PrototypeList::ID::Window as u16,
5194 },
5195 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5196 _bitfield_align_1: [],
5197 _bitfield_1: __BindgenBitfieldUnit::new(
5198 new_jsjitinfo_bitfield_1!(
5199 JSJitInfo_OpType::Method as u8,
5200 JSJitInfo_AliasSet::AliasEverything as u8,
5201 JSValueType::JSVAL_TYPE_OBJECT as u8,
5202 false,
5203 false,
5204 false,
5205 false,
5206 false,
5207 false,
5208 0,
5209 ).to_ne_bytes()
5210 ),
5211});
5212}
5213unsafe extern "C" fn get_cookieStore<D: DomTypes>
5214(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5215 let mut result = false;
5216 wrap_panic(&mut || result = (|| {
5217 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5218 let this = &*(this as *const D::Window);
5219 let result: DomRoot<D::CookieStore> = this.CookieStore(CanGc::note());
5220
5221 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5222 return true;
5223 })());
5224 result
5225}
5226
5227
5228static cookieStore_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5229
5230pub(crate) fn init_cookieStore_getterinfo<D: DomTypes>() {
5231 cookieStore_getterinfo.set(JSJitInfo {
5232 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5233 getter: Some(get_cookieStore::<D>)
5234 },
5235 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5236 protoID: PrototypeList::ID::Window as u16,
5237 },
5238 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5239 _bitfield_align_1: [],
5240 _bitfield_1: __BindgenBitfieldUnit::new(
5241 new_jsjitinfo_bitfield_1!(
5242 JSJitInfo_OpType::Getter as u8,
5243 JSJitInfo_AliasSet::AliasNone as u8,
5244 JSValueType::JSVAL_TYPE_OBJECT as u8,
5245 true,
5246 true,
5247 false,
5248 false,
5249 false,
5250 false,
5251 0,
5252 ).to_ne_bytes()
5253 ),
5254});
5255}
5256unsafe extern "C" fn get_testRunner<D: DomTypes>
5257(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5258 let mut result = false;
5259 wrap_panic(&mut || result = (|| {
5260 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5261 let this = &*(this as *const D::Window);
5262 let result: DomRoot<D::TestRunner> = this.TestRunner();
5263
5264 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5265 return true;
5266 })());
5267 result
5268}
5269
5270
5271static testRunner_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5272
5273pub(crate) fn init_testRunner_getterinfo<D: DomTypes>() {
5274 testRunner_getterinfo.set(JSJitInfo {
5275 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5276 getter: Some(get_testRunner::<D>)
5277 },
5278 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5279 protoID: PrototypeList::ID::Window as u16,
5280 },
5281 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5282 _bitfield_align_1: [],
5283 _bitfield_1: __BindgenBitfieldUnit::new(
5284 new_jsjitinfo_bitfield_1!(
5285 JSJitInfo_OpType::Getter as u8,
5286 JSJitInfo_AliasSet::AliasEverything as u8,
5287 JSValueType::JSVAL_TYPE_OBJECT as u8,
5288 true,
5289 false,
5290 false,
5291 false,
5292 false,
5293 false,
5294 0,
5295 ).to_ne_bytes()
5296 ),
5297});
5298}
5299unsafe extern "C" fn get_onabort<D: DomTypes>
5300(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5301 let mut result = false;
5302 wrap_panic(&mut || result = (|| {
5303 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5304 let this = &*(this as *const D::Window);
5305 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnabort();
5306
5307 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5308 return true;
5309 })());
5310 result
5311}
5312
5313unsafe extern "C" fn set_onabort<D: DomTypes>
5314(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5315 let mut result = false;
5316 wrap_panic(&mut || result = {
5317 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5318 let this = &*(this as *const D::Window);
5319 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5320 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5321 } else {
5322 None
5323 };
5324 let result: () = this.SetOnabort(arg0);
5325
5326 true
5327 });
5328 result
5329}
5330
5331
5332static onabort_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5333
5334pub(crate) fn init_onabort_getterinfo<D: DomTypes>() {
5335 onabort_getterinfo.set(JSJitInfo {
5336 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5337 getter: Some(get_onabort::<D>)
5338 },
5339 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5340 protoID: PrototypeList::ID::Window as u16,
5341 },
5342 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5343 _bitfield_align_1: [],
5344 _bitfield_1: __BindgenBitfieldUnit::new(
5345 new_jsjitinfo_bitfield_1!(
5346 JSJitInfo_OpType::Getter as u8,
5347 JSJitInfo_AliasSet::AliasEverything as u8,
5348 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5349 true,
5350 false,
5351 false,
5352 false,
5353 false,
5354 false,
5355 0,
5356 ).to_ne_bytes()
5357 ),
5358});
5359}
5360static onabort_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5361
5362pub(crate) fn init_onabort_setterinfo<D: DomTypes>() {
5363 onabort_setterinfo.set(JSJitInfo {
5364 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5365 setter: Some(set_onabort::<D>)
5366 },
5367 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5368 protoID: PrototypeList::ID::Window as u16,
5369 },
5370 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5371 _bitfield_align_1: [],
5372 _bitfield_1: __BindgenBitfieldUnit::new(
5373 new_jsjitinfo_bitfield_1!(
5374 JSJitInfo_OpType::Setter as u8,
5375 JSJitInfo_AliasSet::AliasEverything as u8,
5376 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5377 false,
5378 false,
5379 false,
5380 false,
5381 false,
5382 false,
5383 0,
5384 ).to_ne_bytes()
5385 ),
5386});
5387}
5388unsafe extern "C" fn get_onauxclick<D: DomTypes>
5389(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5390 let mut result = false;
5391 wrap_panic(&mut || result = (|| {
5392 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5393 let this = &*(this as *const D::Window);
5394 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnauxclick();
5395
5396 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5397 return true;
5398 })());
5399 result
5400}
5401
5402unsafe extern "C" fn set_onauxclick<D: DomTypes>
5403(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5404 let mut result = false;
5405 wrap_panic(&mut || result = {
5406 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5407 let this = &*(this as *const D::Window);
5408 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5409 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5410 } else {
5411 None
5412 };
5413 let result: () = this.SetOnauxclick(arg0);
5414
5415 true
5416 });
5417 result
5418}
5419
5420
5421static onauxclick_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5422
5423pub(crate) fn init_onauxclick_getterinfo<D: DomTypes>() {
5424 onauxclick_getterinfo.set(JSJitInfo {
5425 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5426 getter: Some(get_onauxclick::<D>)
5427 },
5428 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5429 protoID: PrototypeList::ID::Window as u16,
5430 },
5431 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5432 _bitfield_align_1: [],
5433 _bitfield_1: __BindgenBitfieldUnit::new(
5434 new_jsjitinfo_bitfield_1!(
5435 JSJitInfo_OpType::Getter as u8,
5436 JSJitInfo_AliasSet::AliasEverything as u8,
5437 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5438 true,
5439 false,
5440 false,
5441 false,
5442 false,
5443 false,
5444 0,
5445 ).to_ne_bytes()
5446 ),
5447});
5448}
5449static onauxclick_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5450
5451pub(crate) fn init_onauxclick_setterinfo<D: DomTypes>() {
5452 onauxclick_setterinfo.set(JSJitInfo {
5453 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5454 setter: Some(set_onauxclick::<D>)
5455 },
5456 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5457 protoID: PrototypeList::ID::Window as u16,
5458 },
5459 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5460 _bitfield_align_1: [],
5461 _bitfield_1: __BindgenBitfieldUnit::new(
5462 new_jsjitinfo_bitfield_1!(
5463 JSJitInfo_OpType::Setter as u8,
5464 JSJitInfo_AliasSet::AliasEverything as u8,
5465 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5466 false,
5467 false,
5468 false,
5469 false,
5470 false,
5471 false,
5472 0,
5473 ).to_ne_bytes()
5474 ),
5475});
5476}
5477unsafe extern "C" fn get_onbeforeinput<D: DomTypes>
5478(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5479 let mut result = false;
5480 wrap_panic(&mut || result = (|| {
5481 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5482 let this = &*(this as *const D::Window);
5483 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnbeforeinput();
5484
5485 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5486 return true;
5487 })());
5488 result
5489}
5490
5491unsafe extern "C" fn set_onbeforeinput<D: DomTypes>
5492(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5493 let mut result = false;
5494 wrap_panic(&mut || result = {
5495 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5496 let this = &*(this as *const D::Window);
5497 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5498 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5499 } else {
5500 None
5501 };
5502 let result: () = this.SetOnbeforeinput(arg0);
5503
5504 true
5505 });
5506 result
5507}
5508
5509
5510static onbeforeinput_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5511
5512pub(crate) fn init_onbeforeinput_getterinfo<D: DomTypes>() {
5513 onbeforeinput_getterinfo.set(JSJitInfo {
5514 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5515 getter: Some(get_onbeforeinput::<D>)
5516 },
5517 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5518 protoID: PrototypeList::ID::Window as u16,
5519 },
5520 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5521 _bitfield_align_1: [],
5522 _bitfield_1: __BindgenBitfieldUnit::new(
5523 new_jsjitinfo_bitfield_1!(
5524 JSJitInfo_OpType::Getter as u8,
5525 JSJitInfo_AliasSet::AliasEverything as u8,
5526 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5527 true,
5528 false,
5529 false,
5530 false,
5531 false,
5532 false,
5533 0,
5534 ).to_ne_bytes()
5535 ),
5536});
5537}
5538static onbeforeinput_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5539
5540pub(crate) fn init_onbeforeinput_setterinfo<D: DomTypes>() {
5541 onbeforeinput_setterinfo.set(JSJitInfo {
5542 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5543 setter: Some(set_onbeforeinput::<D>)
5544 },
5545 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5546 protoID: PrototypeList::ID::Window as u16,
5547 },
5548 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5549 _bitfield_align_1: [],
5550 _bitfield_1: __BindgenBitfieldUnit::new(
5551 new_jsjitinfo_bitfield_1!(
5552 JSJitInfo_OpType::Setter as u8,
5553 JSJitInfo_AliasSet::AliasEverything as u8,
5554 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5555 false,
5556 false,
5557 false,
5558 false,
5559 false,
5560 false,
5561 0,
5562 ).to_ne_bytes()
5563 ),
5564});
5565}
5566unsafe extern "C" fn get_onbeforematch<D: DomTypes>
5567(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5568 let mut result = false;
5569 wrap_panic(&mut || result = (|| {
5570 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5571 let this = &*(this as *const D::Window);
5572 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnbeforematch();
5573
5574 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5575 return true;
5576 })());
5577 result
5578}
5579
5580unsafe extern "C" fn set_onbeforematch<D: DomTypes>
5581(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5582 let mut result = false;
5583 wrap_panic(&mut || result = {
5584 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5585 let this = &*(this as *const D::Window);
5586 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5587 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5588 } else {
5589 None
5590 };
5591 let result: () = this.SetOnbeforematch(arg0);
5592
5593 true
5594 });
5595 result
5596}
5597
5598
5599static onbeforematch_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5600
5601pub(crate) fn init_onbeforematch_getterinfo<D: DomTypes>() {
5602 onbeforematch_getterinfo.set(JSJitInfo {
5603 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5604 getter: Some(get_onbeforematch::<D>)
5605 },
5606 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5607 protoID: PrototypeList::ID::Window as u16,
5608 },
5609 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5610 _bitfield_align_1: [],
5611 _bitfield_1: __BindgenBitfieldUnit::new(
5612 new_jsjitinfo_bitfield_1!(
5613 JSJitInfo_OpType::Getter as u8,
5614 JSJitInfo_AliasSet::AliasEverything as u8,
5615 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5616 true,
5617 false,
5618 false,
5619 false,
5620 false,
5621 false,
5622 0,
5623 ).to_ne_bytes()
5624 ),
5625});
5626}
5627static onbeforematch_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5628
5629pub(crate) fn init_onbeforematch_setterinfo<D: DomTypes>() {
5630 onbeforematch_setterinfo.set(JSJitInfo {
5631 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5632 setter: Some(set_onbeforematch::<D>)
5633 },
5634 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5635 protoID: PrototypeList::ID::Window as u16,
5636 },
5637 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5638 _bitfield_align_1: [],
5639 _bitfield_1: __BindgenBitfieldUnit::new(
5640 new_jsjitinfo_bitfield_1!(
5641 JSJitInfo_OpType::Setter as u8,
5642 JSJitInfo_AliasSet::AliasEverything as u8,
5643 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5644 false,
5645 false,
5646 false,
5647 false,
5648 false,
5649 false,
5650 0,
5651 ).to_ne_bytes()
5652 ),
5653});
5654}
5655unsafe extern "C" fn get_onbeforetoggle<D: DomTypes>
5656(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5657 let mut result = false;
5658 wrap_panic(&mut || result = (|| {
5659 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5660 let this = &*(this as *const D::Window);
5661 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnbeforetoggle();
5662
5663 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5664 return true;
5665 })());
5666 result
5667}
5668
5669unsafe extern "C" fn set_onbeforetoggle<D: DomTypes>
5670(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5671 let mut result = false;
5672 wrap_panic(&mut || result = {
5673 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5674 let this = &*(this as *const D::Window);
5675 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5676 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5677 } else {
5678 None
5679 };
5680 let result: () = this.SetOnbeforetoggle(arg0);
5681
5682 true
5683 });
5684 result
5685}
5686
5687
5688static onbeforetoggle_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5689
5690pub(crate) fn init_onbeforetoggle_getterinfo<D: DomTypes>() {
5691 onbeforetoggle_getterinfo.set(JSJitInfo {
5692 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5693 getter: Some(get_onbeforetoggle::<D>)
5694 },
5695 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5696 protoID: PrototypeList::ID::Window as u16,
5697 },
5698 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5699 _bitfield_align_1: [],
5700 _bitfield_1: __BindgenBitfieldUnit::new(
5701 new_jsjitinfo_bitfield_1!(
5702 JSJitInfo_OpType::Getter as u8,
5703 JSJitInfo_AliasSet::AliasEverything as u8,
5704 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5705 true,
5706 false,
5707 false,
5708 false,
5709 false,
5710 false,
5711 0,
5712 ).to_ne_bytes()
5713 ),
5714});
5715}
5716static onbeforetoggle_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5717
5718pub(crate) fn init_onbeforetoggle_setterinfo<D: DomTypes>() {
5719 onbeforetoggle_setterinfo.set(JSJitInfo {
5720 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5721 setter: Some(set_onbeforetoggle::<D>)
5722 },
5723 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5724 protoID: PrototypeList::ID::Window as u16,
5725 },
5726 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5727 _bitfield_align_1: [],
5728 _bitfield_1: __BindgenBitfieldUnit::new(
5729 new_jsjitinfo_bitfield_1!(
5730 JSJitInfo_OpType::Setter as u8,
5731 JSJitInfo_AliasSet::AliasEverything as u8,
5732 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5733 false,
5734 false,
5735 false,
5736 false,
5737 false,
5738 false,
5739 0,
5740 ).to_ne_bytes()
5741 ),
5742});
5743}
5744unsafe extern "C" fn get_onblur<D: DomTypes>
5745(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5746 let mut result = false;
5747 wrap_panic(&mut || result = (|| {
5748 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5749 let this = &*(this as *const D::Window);
5750 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnblur();
5751
5752 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5753 return true;
5754 })());
5755 result
5756}
5757
5758unsafe extern "C" fn set_onblur<D: DomTypes>
5759(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5760 let mut result = false;
5761 wrap_panic(&mut || result = {
5762 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5763 let this = &*(this as *const D::Window);
5764 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5765 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5766 } else {
5767 None
5768 };
5769 let result: () = this.SetOnblur(arg0);
5770
5771 true
5772 });
5773 result
5774}
5775
5776
5777static onblur_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5778
5779pub(crate) fn init_onblur_getterinfo<D: DomTypes>() {
5780 onblur_getterinfo.set(JSJitInfo {
5781 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5782 getter: Some(get_onblur::<D>)
5783 },
5784 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5785 protoID: PrototypeList::ID::Window as u16,
5786 },
5787 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5788 _bitfield_align_1: [],
5789 _bitfield_1: __BindgenBitfieldUnit::new(
5790 new_jsjitinfo_bitfield_1!(
5791 JSJitInfo_OpType::Getter as u8,
5792 JSJitInfo_AliasSet::AliasEverything as u8,
5793 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5794 true,
5795 false,
5796 false,
5797 false,
5798 false,
5799 false,
5800 0,
5801 ).to_ne_bytes()
5802 ),
5803});
5804}
5805static onblur_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5806
5807pub(crate) fn init_onblur_setterinfo<D: DomTypes>() {
5808 onblur_setterinfo.set(JSJitInfo {
5809 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5810 setter: Some(set_onblur::<D>)
5811 },
5812 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5813 protoID: PrototypeList::ID::Window as u16,
5814 },
5815 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5816 _bitfield_align_1: [],
5817 _bitfield_1: __BindgenBitfieldUnit::new(
5818 new_jsjitinfo_bitfield_1!(
5819 JSJitInfo_OpType::Setter as u8,
5820 JSJitInfo_AliasSet::AliasEverything as u8,
5821 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5822 false,
5823 false,
5824 false,
5825 false,
5826 false,
5827 false,
5828 0,
5829 ).to_ne_bytes()
5830 ),
5831});
5832}
5833unsafe extern "C" fn get_oncancel<D: DomTypes>
5834(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5835 let mut result = false;
5836 wrap_panic(&mut || result = (|| {
5837 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5838 let this = &*(this as *const D::Window);
5839 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncancel();
5840
5841 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5842 return true;
5843 })());
5844 result
5845}
5846
5847unsafe extern "C" fn set_oncancel<D: DomTypes>
5848(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5849 let mut result = false;
5850 wrap_panic(&mut || result = {
5851 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5852 let this = &*(this as *const D::Window);
5853 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5854 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5855 } else {
5856 None
5857 };
5858 let result: () = this.SetOncancel(arg0);
5859
5860 true
5861 });
5862 result
5863}
5864
5865
5866static oncancel_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5867
5868pub(crate) fn init_oncancel_getterinfo<D: DomTypes>() {
5869 oncancel_getterinfo.set(JSJitInfo {
5870 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5871 getter: Some(get_oncancel::<D>)
5872 },
5873 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5874 protoID: PrototypeList::ID::Window as u16,
5875 },
5876 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5877 _bitfield_align_1: [],
5878 _bitfield_1: __BindgenBitfieldUnit::new(
5879 new_jsjitinfo_bitfield_1!(
5880 JSJitInfo_OpType::Getter as u8,
5881 JSJitInfo_AliasSet::AliasEverything as u8,
5882 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5883 true,
5884 false,
5885 false,
5886 false,
5887 false,
5888 false,
5889 0,
5890 ).to_ne_bytes()
5891 ),
5892});
5893}
5894static oncancel_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5895
5896pub(crate) fn init_oncancel_setterinfo<D: DomTypes>() {
5897 oncancel_setterinfo.set(JSJitInfo {
5898 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5899 setter: Some(set_oncancel::<D>)
5900 },
5901 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5902 protoID: PrototypeList::ID::Window as u16,
5903 },
5904 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5905 _bitfield_align_1: [],
5906 _bitfield_1: __BindgenBitfieldUnit::new(
5907 new_jsjitinfo_bitfield_1!(
5908 JSJitInfo_OpType::Setter as u8,
5909 JSJitInfo_AliasSet::AliasEverything as u8,
5910 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5911 false,
5912 false,
5913 false,
5914 false,
5915 false,
5916 false,
5917 0,
5918 ).to_ne_bytes()
5919 ),
5920});
5921}
5922unsafe extern "C" fn get_oncanplay<D: DomTypes>
5923(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5924 let mut result = false;
5925 wrap_panic(&mut || result = (|| {
5926 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5927 let this = &*(this as *const D::Window);
5928 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncanplay();
5929
5930 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5931 return true;
5932 })());
5933 result
5934}
5935
5936unsafe extern "C" fn set_oncanplay<D: DomTypes>
5937(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5938 let mut result = false;
5939 wrap_panic(&mut || result = {
5940 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5941 let this = &*(this as *const D::Window);
5942 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5943 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5944 } else {
5945 None
5946 };
5947 let result: () = this.SetOncanplay(arg0);
5948
5949 true
5950 });
5951 result
5952}
5953
5954
5955static oncanplay_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5956
5957pub(crate) fn init_oncanplay_getterinfo<D: DomTypes>() {
5958 oncanplay_getterinfo.set(JSJitInfo {
5959 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5960 getter: Some(get_oncanplay::<D>)
5961 },
5962 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5963 protoID: PrototypeList::ID::Window as u16,
5964 },
5965 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5966 _bitfield_align_1: [],
5967 _bitfield_1: __BindgenBitfieldUnit::new(
5968 new_jsjitinfo_bitfield_1!(
5969 JSJitInfo_OpType::Getter as u8,
5970 JSJitInfo_AliasSet::AliasEverything as u8,
5971 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5972 true,
5973 false,
5974 false,
5975 false,
5976 false,
5977 false,
5978 0,
5979 ).to_ne_bytes()
5980 ),
5981});
5982}
5983static oncanplay_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5984
5985pub(crate) fn init_oncanplay_setterinfo<D: DomTypes>() {
5986 oncanplay_setterinfo.set(JSJitInfo {
5987 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5988 setter: Some(set_oncanplay::<D>)
5989 },
5990 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5991 protoID: PrototypeList::ID::Window as u16,
5992 },
5993 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5994 _bitfield_align_1: [],
5995 _bitfield_1: __BindgenBitfieldUnit::new(
5996 new_jsjitinfo_bitfield_1!(
5997 JSJitInfo_OpType::Setter as u8,
5998 JSJitInfo_AliasSet::AliasEverything as u8,
5999 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6000 false,
6001 false,
6002 false,
6003 false,
6004 false,
6005 false,
6006 0,
6007 ).to_ne_bytes()
6008 ),
6009});
6010}
6011unsafe extern "C" fn get_oncanplaythrough<D: DomTypes>
6012(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6013 let mut result = false;
6014 wrap_panic(&mut || result = (|| {
6015 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6016 let this = &*(this as *const D::Window);
6017 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncanplaythrough();
6018
6019 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6020 return true;
6021 })());
6022 result
6023}
6024
6025unsafe extern "C" fn set_oncanplaythrough<D: DomTypes>
6026(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6027 let mut result = false;
6028 wrap_panic(&mut || result = {
6029 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6030 let this = &*(this as *const D::Window);
6031 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6032 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6033 } else {
6034 None
6035 };
6036 let result: () = this.SetOncanplaythrough(arg0);
6037
6038 true
6039 });
6040 result
6041}
6042
6043
6044static oncanplaythrough_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6045
6046pub(crate) fn init_oncanplaythrough_getterinfo<D: DomTypes>() {
6047 oncanplaythrough_getterinfo.set(JSJitInfo {
6048 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6049 getter: Some(get_oncanplaythrough::<D>)
6050 },
6051 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6052 protoID: PrototypeList::ID::Window as u16,
6053 },
6054 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6055 _bitfield_align_1: [],
6056 _bitfield_1: __BindgenBitfieldUnit::new(
6057 new_jsjitinfo_bitfield_1!(
6058 JSJitInfo_OpType::Getter as u8,
6059 JSJitInfo_AliasSet::AliasEverything as u8,
6060 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6061 true,
6062 false,
6063 false,
6064 false,
6065 false,
6066 false,
6067 0,
6068 ).to_ne_bytes()
6069 ),
6070});
6071}
6072static oncanplaythrough_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6073
6074pub(crate) fn init_oncanplaythrough_setterinfo<D: DomTypes>() {
6075 oncanplaythrough_setterinfo.set(JSJitInfo {
6076 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6077 setter: Some(set_oncanplaythrough::<D>)
6078 },
6079 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6080 protoID: PrototypeList::ID::Window as u16,
6081 },
6082 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6083 _bitfield_align_1: [],
6084 _bitfield_1: __BindgenBitfieldUnit::new(
6085 new_jsjitinfo_bitfield_1!(
6086 JSJitInfo_OpType::Setter as u8,
6087 JSJitInfo_AliasSet::AliasEverything as u8,
6088 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6089 false,
6090 false,
6091 false,
6092 false,
6093 false,
6094 false,
6095 0,
6096 ).to_ne_bytes()
6097 ),
6098});
6099}
6100unsafe extern "C" fn get_onchange<D: DomTypes>
6101(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6102 let mut result = false;
6103 wrap_panic(&mut || result = (|| {
6104 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6105 let this = &*(this as *const D::Window);
6106 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnchange();
6107
6108 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6109 return true;
6110 })());
6111 result
6112}
6113
6114unsafe extern "C" fn set_onchange<D: DomTypes>
6115(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6116 let mut result = false;
6117 wrap_panic(&mut || result = {
6118 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6119 let this = &*(this as *const D::Window);
6120 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6121 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6122 } else {
6123 None
6124 };
6125 let result: () = this.SetOnchange(arg0);
6126
6127 true
6128 });
6129 result
6130}
6131
6132
6133static onchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6134
6135pub(crate) fn init_onchange_getterinfo<D: DomTypes>() {
6136 onchange_getterinfo.set(JSJitInfo {
6137 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6138 getter: Some(get_onchange::<D>)
6139 },
6140 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6141 protoID: PrototypeList::ID::Window as u16,
6142 },
6143 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6144 _bitfield_align_1: [],
6145 _bitfield_1: __BindgenBitfieldUnit::new(
6146 new_jsjitinfo_bitfield_1!(
6147 JSJitInfo_OpType::Getter as u8,
6148 JSJitInfo_AliasSet::AliasEverything as u8,
6149 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6150 true,
6151 false,
6152 false,
6153 false,
6154 false,
6155 false,
6156 0,
6157 ).to_ne_bytes()
6158 ),
6159});
6160}
6161static onchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6162
6163pub(crate) fn init_onchange_setterinfo<D: DomTypes>() {
6164 onchange_setterinfo.set(JSJitInfo {
6165 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6166 setter: Some(set_onchange::<D>)
6167 },
6168 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6169 protoID: PrototypeList::ID::Window as u16,
6170 },
6171 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6172 _bitfield_align_1: [],
6173 _bitfield_1: __BindgenBitfieldUnit::new(
6174 new_jsjitinfo_bitfield_1!(
6175 JSJitInfo_OpType::Setter as u8,
6176 JSJitInfo_AliasSet::AliasEverything as u8,
6177 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6178 false,
6179 false,
6180 false,
6181 false,
6182 false,
6183 false,
6184 0,
6185 ).to_ne_bytes()
6186 ),
6187});
6188}
6189unsafe extern "C" fn get_onclick<D: DomTypes>
6190(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6191 let mut result = false;
6192 wrap_panic(&mut || result = (|| {
6193 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6194 let this = &*(this as *const D::Window);
6195 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnclick();
6196
6197 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6198 return true;
6199 })());
6200 result
6201}
6202
6203unsafe extern "C" fn set_onclick<D: DomTypes>
6204(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6205 let mut result = false;
6206 wrap_panic(&mut || result = {
6207 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6208 let this = &*(this as *const D::Window);
6209 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6210 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6211 } else {
6212 None
6213 };
6214 let result: () = this.SetOnclick(arg0);
6215
6216 true
6217 });
6218 result
6219}
6220
6221
6222static onclick_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6223
6224pub(crate) fn init_onclick_getterinfo<D: DomTypes>() {
6225 onclick_getterinfo.set(JSJitInfo {
6226 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6227 getter: Some(get_onclick::<D>)
6228 },
6229 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6230 protoID: PrototypeList::ID::Window as u16,
6231 },
6232 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6233 _bitfield_align_1: [],
6234 _bitfield_1: __BindgenBitfieldUnit::new(
6235 new_jsjitinfo_bitfield_1!(
6236 JSJitInfo_OpType::Getter as u8,
6237 JSJitInfo_AliasSet::AliasEverything as u8,
6238 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6239 true,
6240 false,
6241 false,
6242 false,
6243 false,
6244 false,
6245 0,
6246 ).to_ne_bytes()
6247 ),
6248});
6249}
6250static onclick_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6251
6252pub(crate) fn init_onclick_setterinfo<D: DomTypes>() {
6253 onclick_setterinfo.set(JSJitInfo {
6254 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6255 setter: Some(set_onclick::<D>)
6256 },
6257 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6258 protoID: PrototypeList::ID::Window as u16,
6259 },
6260 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6261 _bitfield_align_1: [],
6262 _bitfield_1: __BindgenBitfieldUnit::new(
6263 new_jsjitinfo_bitfield_1!(
6264 JSJitInfo_OpType::Setter as u8,
6265 JSJitInfo_AliasSet::AliasEverything as u8,
6266 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6267 false,
6268 false,
6269 false,
6270 false,
6271 false,
6272 false,
6273 0,
6274 ).to_ne_bytes()
6275 ),
6276});
6277}
6278unsafe extern "C" fn get_onclose<D: DomTypes>
6279(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6280 let mut result = false;
6281 wrap_panic(&mut || result = (|| {
6282 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6283 let this = &*(this as *const D::Window);
6284 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnclose();
6285
6286 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6287 return true;
6288 })());
6289 result
6290}
6291
6292unsafe extern "C" fn set_onclose<D: DomTypes>
6293(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6294 let mut result = false;
6295 wrap_panic(&mut || result = {
6296 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6297 let this = &*(this as *const D::Window);
6298 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6299 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6300 } else {
6301 None
6302 };
6303 let result: () = this.SetOnclose(arg0);
6304
6305 true
6306 });
6307 result
6308}
6309
6310
6311static onclose_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6312
6313pub(crate) fn init_onclose_getterinfo<D: DomTypes>() {
6314 onclose_getterinfo.set(JSJitInfo {
6315 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6316 getter: Some(get_onclose::<D>)
6317 },
6318 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6319 protoID: PrototypeList::ID::Window as u16,
6320 },
6321 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6322 _bitfield_align_1: [],
6323 _bitfield_1: __BindgenBitfieldUnit::new(
6324 new_jsjitinfo_bitfield_1!(
6325 JSJitInfo_OpType::Getter as u8,
6326 JSJitInfo_AliasSet::AliasEverything as u8,
6327 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6328 true,
6329 false,
6330 false,
6331 false,
6332 false,
6333 false,
6334 0,
6335 ).to_ne_bytes()
6336 ),
6337});
6338}
6339static onclose_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6340
6341pub(crate) fn init_onclose_setterinfo<D: DomTypes>() {
6342 onclose_setterinfo.set(JSJitInfo {
6343 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6344 setter: Some(set_onclose::<D>)
6345 },
6346 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6347 protoID: PrototypeList::ID::Window as u16,
6348 },
6349 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6350 _bitfield_align_1: [],
6351 _bitfield_1: __BindgenBitfieldUnit::new(
6352 new_jsjitinfo_bitfield_1!(
6353 JSJitInfo_OpType::Setter as u8,
6354 JSJitInfo_AliasSet::AliasEverything as u8,
6355 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6356 false,
6357 false,
6358 false,
6359 false,
6360 false,
6361 false,
6362 0,
6363 ).to_ne_bytes()
6364 ),
6365});
6366}
6367unsafe extern "C" fn get_oncommand<D: DomTypes>
6368(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6369 let mut result = false;
6370 wrap_panic(&mut || result = (|| {
6371 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6372 let this = &*(this as *const D::Window);
6373 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncommand();
6374
6375 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6376 return true;
6377 })());
6378 result
6379}
6380
6381unsafe extern "C" fn set_oncommand<D: DomTypes>
6382(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6383 let mut result = false;
6384 wrap_panic(&mut || result = {
6385 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6386 let this = &*(this as *const D::Window);
6387 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6388 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6389 } else {
6390 None
6391 };
6392 let result: () = this.SetOncommand(arg0);
6393
6394 true
6395 });
6396 result
6397}
6398
6399
6400static oncommand_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6401
6402pub(crate) fn init_oncommand_getterinfo<D: DomTypes>() {
6403 oncommand_getterinfo.set(JSJitInfo {
6404 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6405 getter: Some(get_oncommand::<D>)
6406 },
6407 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6408 protoID: PrototypeList::ID::Window as u16,
6409 },
6410 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6411 _bitfield_align_1: [],
6412 _bitfield_1: __BindgenBitfieldUnit::new(
6413 new_jsjitinfo_bitfield_1!(
6414 JSJitInfo_OpType::Getter as u8,
6415 JSJitInfo_AliasSet::AliasEverything as u8,
6416 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6417 true,
6418 false,
6419 false,
6420 false,
6421 false,
6422 false,
6423 0,
6424 ).to_ne_bytes()
6425 ),
6426});
6427}
6428static oncommand_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6429
6430pub(crate) fn init_oncommand_setterinfo<D: DomTypes>() {
6431 oncommand_setterinfo.set(JSJitInfo {
6432 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6433 setter: Some(set_oncommand::<D>)
6434 },
6435 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6436 protoID: PrototypeList::ID::Window as u16,
6437 },
6438 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6439 _bitfield_align_1: [],
6440 _bitfield_1: __BindgenBitfieldUnit::new(
6441 new_jsjitinfo_bitfield_1!(
6442 JSJitInfo_OpType::Setter as u8,
6443 JSJitInfo_AliasSet::AliasEverything as u8,
6444 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6445 false,
6446 false,
6447 false,
6448 false,
6449 false,
6450 false,
6451 0,
6452 ).to_ne_bytes()
6453 ),
6454});
6455}
6456unsafe extern "C" fn get_oncontextlost<D: DomTypes>
6457(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6458 let mut result = false;
6459 wrap_panic(&mut || result = (|| {
6460 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6461 let this = &*(this as *const D::Window);
6462 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncontextlost();
6463
6464 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6465 return true;
6466 })());
6467 result
6468}
6469
6470unsafe extern "C" fn set_oncontextlost<D: DomTypes>
6471(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6472 let mut result = false;
6473 wrap_panic(&mut || result = {
6474 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6475 let this = &*(this as *const D::Window);
6476 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6477 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6478 } else {
6479 None
6480 };
6481 let result: () = this.SetOncontextlost(arg0);
6482
6483 true
6484 });
6485 result
6486}
6487
6488
6489static oncontextlost_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6490
6491pub(crate) fn init_oncontextlost_getterinfo<D: DomTypes>() {
6492 oncontextlost_getterinfo.set(JSJitInfo {
6493 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6494 getter: Some(get_oncontextlost::<D>)
6495 },
6496 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6497 protoID: PrototypeList::ID::Window as u16,
6498 },
6499 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6500 _bitfield_align_1: [],
6501 _bitfield_1: __BindgenBitfieldUnit::new(
6502 new_jsjitinfo_bitfield_1!(
6503 JSJitInfo_OpType::Getter as u8,
6504 JSJitInfo_AliasSet::AliasEverything as u8,
6505 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6506 true,
6507 false,
6508 false,
6509 false,
6510 false,
6511 false,
6512 0,
6513 ).to_ne_bytes()
6514 ),
6515});
6516}
6517static oncontextlost_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6518
6519pub(crate) fn init_oncontextlost_setterinfo<D: DomTypes>() {
6520 oncontextlost_setterinfo.set(JSJitInfo {
6521 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6522 setter: Some(set_oncontextlost::<D>)
6523 },
6524 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6525 protoID: PrototypeList::ID::Window as u16,
6526 },
6527 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6528 _bitfield_align_1: [],
6529 _bitfield_1: __BindgenBitfieldUnit::new(
6530 new_jsjitinfo_bitfield_1!(
6531 JSJitInfo_OpType::Setter as u8,
6532 JSJitInfo_AliasSet::AliasEverything as u8,
6533 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6534 false,
6535 false,
6536 false,
6537 false,
6538 false,
6539 false,
6540 0,
6541 ).to_ne_bytes()
6542 ),
6543});
6544}
6545unsafe extern "C" fn get_oncontextmenu<D: DomTypes>
6546(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6547 let mut result = false;
6548 wrap_panic(&mut || result = (|| {
6549 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6550 let this = &*(this as *const D::Window);
6551 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncontextmenu();
6552
6553 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6554 return true;
6555 })());
6556 result
6557}
6558
6559unsafe extern "C" fn set_oncontextmenu<D: DomTypes>
6560(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6561 let mut result = false;
6562 wrap_panic(&mut || result = {
6563 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6564 let this = &*(this as *const D::Window);
6565 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6566 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6567 } else {
6568 None
6569 };
6570 let result: () = this.SetOncontextmenu(arg0);
6571
6572 true
6573 });
6574 result
6575}
6576
6577
6578static oncontextmenu_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6579
6580pub(crate) fn init_oncontextmenu_getterinfo<D: DomTypes>() {
6581 oncontextmenu_getterinfo.set(JSJitInfo {
6582 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6583 getter: Some(get_oncontextmenu::<D>)
6584 },
6585 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6586 protoID: PrototypeList::ID::Window as u16,
6587 },
6588 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6589 _bitfield_align_1: [],
6590 _bitfield_1: __BindgenBitfieldUnit::new(
6591 new_jsjitinfo_bitfield_1!(
6592 JSJitInfo_OpType::Getter as u8,
6593 JSJitInfo_AliasSet::AliasEverything as u8,
6594 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6595 true,
6596 false,
6597 false,
6598 false,
6599 false,
6600 false,
6601 0,
6602 ).to_ne_bytes()
6603 ),
6604});
6605}
6606static oncontextmenu_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6607
6608pub(crate) fn init_oncontextmenu_setterinfo<D: DomTypes>() {
6609 oncontextmenu_setterinfo.set(JSJitInfo {
6610 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6611 setter: Some(set_oncontextmenu::<D>)
6612 },
6613 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6614 protoID: PrototypeList::ID::Window as u16,
6615 },
6616 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6617 _bitfield_align_1: [],
6618 _bitfield_1: __BindgenBitfieldUnit::new(
6619 new_jsjitinfo_bitfield_1!(
6620 JSJitInfo_OpType::Setter as u8,
6621 JSJitInfo_AliasSet::AliasEverything as u8,
6622 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6623 false,
6624 false,
6625 false,
6626 false,
6627 false,
6628 false,
6629 0,
6630 ).to_ne_bytes()
6631 ),
6632});
6633}
6634unsafe extern "C" fn get_oncontextrestored<D: DomTypes>
6635(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6636 let mut result = false;
6637 wrap_panic(&mut || result = (|| {
6638 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6639 let this = &*(this as *const D::Window);
6640 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncontextrestored();
6641
6642 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6643 return true;
6644 })());
6645 result
6646}
6647
6648unsafe extern "C" fn set_oncontextrestored<D: DomTypes>
6649(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6650 let mut result = false;
6651 wrap_panic(&mut || result = {
6652 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6653 let this = &*(this as *const D::Window);
6654 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6655 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6656 } else {
6657 None
6658 };
6659 let result: () = this.SetOncontextrestored(arg0);
6660
6661 true
6662 });
6663 result
6664}
6665
6666
6667static oncontextrestored_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6668
6669pub(crate) fn init_oncontextrestored_getterinfo<D: DomTypes>() {
6670 oncontextrestored_getterinfo.set(JSJitInfo {
6671 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6672 getter: Some(get_oncontextrestored::<D>)
6673 },
6674 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6675 protoID: PrototypeList::ID::Window as u16,
6676 },
6677 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6678 _bitfield_align_1: [],
6679 _bitfield_1: __BindgenBitfieldUnit::new(
6680 new_jsjitinfo_bitfield_1!(
6681 JSJitInfo_OpType::Getter as u8,
6682 JSJitInfo_AliasSet::AliasEverything as u8,
6683 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6684 true,
6685 false,
6686 false,
6687 false,
6688 false,
6689 false,
6690 0,
6691 ).to_ne_bytes()
6692 ),
6693});
6694}
6695static oncontextrestored_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6696
6697pub(crate) fn init_oncontextrestored_setterinfo<D: DomTypes>() {
6698 oncontextrestored_setterinfo.set(JSJitInfo {
6699 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6700 setter: Some(set_oncontextrestored::<D>)
6701 },
6702 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6703 protoID: PrototypeList::ID::Window as u16,
6704 },
6705 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6706 _bitfield_align_1: [],
6707 _bitfield_1: __BindgenBitfieldUnit::new(
6708 new_jsjitinfo_bitfield_1!(
6709 JSJitInfo_OpType::Setter as u8,
6710 JSJitInfo_AliasSet::AliasEverything as u8,
6711 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6712 false,
6713 false,
6714 false,
6715 false,
6716 false,
6717 false,
6718 0,
6719 ).to_ne_bytes()
6720 ),
6721});
6722}
6723unsafe extern "C" fn get_oncopy<D: DomTypes>
6724(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6725 let mut result = false;
6726 wrap_panic(&mut || result = (|| {
6727 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6728 let this = &*(this as *const D::Window);
6729 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncopy();
6730
6731 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6732 return true;
6733 })());
6734 result
6735}
6736
6737unsafe extern "C" fn set_oncopy<D: DomTypes>
6738(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6739 let mut result = false;
6740 wrap_panic(&mut || result = {
6741 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6742 let this = &*(this as *const D::Window);
6743 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6744 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6745 } else {
6746 None
6747 };
6748 let result: () = this.SetOncopy(arg0);
6749
6750 true
6751 });
6752 result
6753}
6754
6755
6756static oncopy_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6757
6758pub(crate) fn init_oncopy_getterinfo<D: DomTypes>() {
6759 oncopy_getterinfo.set(JSJitInfo {
6760 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6761 getter: Some(get_oncopy::<D>)
6762 },
6763 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6764 protoID: PrototypeList::ID::Window as u16,
6765 },
6766 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6767 _bitfield_align_1: [],
6768 _bitfield_1: __BindgenBitfieldUnit::new(
6769 new_jsjitinfo_bitfield_1!(
6770 JSJitInfo_OpType::Getter as u8,
6771 JSJitInfo_AliasSet::AliasEverything as u8,
6772 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6773 true,
6774 false,
6775 false,
6776 false,
6777 false,
6778 false,
6779 0,
6780 ).to_ne_bytes()
6781 ),
6782});
6783}
6784static oncopy_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6785
6786pub(crate) fn init_oncopy_setterinfo<D: DomTypes>() {
6787 oncopy_setterinfo.set(JSJitInfo {
6788 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6789 setter: Some(set_oncopy::<D>)
6790 },
6791 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6792 protoID: PrototypeList::ID::Window as u16,
6793 },
6794 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6795 _bitfield_align_1: [],
6796 _bitfield_1: __BindgenBitfieldUnit::new(
6797 new_jsjitinfo_bitfield_1!(
6798 JSJitInfo_OpType::Setter as u8,
6799 JSJitInfo_AliasSet::AliasEverything as u8,
6800 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6801 false,
6802 false,
6803 false,
6804 false,
6805 false,
6806 false,
6807 0,
6808 ).to_ne_bytes()
6809 ),
6810});
6811}
6812unsafe extern "C" fn get_oncuechange<D: DomTypes>
6813(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6814 let mut result = false;
6815 wrap_panic(&mut || result = (|| {
6816 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6817 let this = &*(this as *const D::Window);
6818 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncuechange();
6819
6820 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6821 return true;
6822 })());
6823 result
6824}
6825
6826unsafe extern "C" fn set_oncuechange<D: DomTypes>
6827(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6828 let mut result = false;
6829 wrap_panic(&mut || result = {
6830 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6831 let this = &*(this as *const D::Window);
6832 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6833 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6834 } else {
6835 None
6836 };
6837 let result: () = this.SetOncuechange(arg0);
6838
6839 true
6840 });
6841 result
6842}
6843
6844
6845static oncuechange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6846
6847pub(crate) fn init_oncuechange_getterinfo<D: DomTypes>() {
6848 oncuechange_getterinfo.set(JSJitInfo {
6849 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6850 getter: Some(get_oncuechange::<D>)
6851 },
6852 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6853 protoID: PrototypeList::ID::Window as u16,
6854 },
6855 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6856 _bitfield_align_1: [],
6857 _bitfield_1: __BindgenBitfieldUnit::new(
6858 new_jsjitinfo_bitfield_1!(
6859 JSJitInfo_OpType::Getter as u8,
6860 JSJitInfo_AliasSet::AliasEverything as u8,
6861 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6862 true,
6863 false,
6864 false,
6865 false,
6866 false,
6867 false,
6868 0,
6869 ).to_ne_bytes()
6870 ),
6871});
6872}
6873static oncuechange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6874
6875pub(crate) fn init_oncuechange_setterinfo<D: DomTypes>() {
6876 oncuechange_setterinfo.set(JSJitInfo {
6877 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6878 setter: Some(set_oncuechange::<D>)
6879 },
6880 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6881 protoID: PrototypeList::ID::Window as u16,
6882 },
6883 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6884 _bitfield_align_1: [],
6885 _bitfield_1: __BindgenBitfieldUnit::new(
6886 new_jsjitinfo_bitfield_1!(
6887 JSJitInfo_OpType::Setter as u8,
6888 JSJitInfo_AliasSet::AliasEverything as u8,
6889 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6890 false,
6891 false,
6892 false,
6893 false,
6894 false,
6895 false,
6896 0,
6897 ).to_ne_bytes()
6898 ),
6899});
6900}
6901unsafe extern "C" fn get_oncut<D: DomTypes>
6902(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6903 let mut result = false;
6904 wrap_panic(&mut || result = (|| {
6905 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6906 let this = &*(this as *const D::Window);
6907 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncut();
6908
6909 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6910 return true;
6911 })());
6912 result
6913}
6914
6915unsafe extern "C" fn set_oncut<D: DomTypes>
6916(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6917 let mut result = false;
6918 wrap_panic(&mut || result = {
6919 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6920 let this = &*(this as *const D::Window);
6921 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6922 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6923 } else {
6924 None
6925 };
6926 let result: () = this.SetOncut(arg0);
6927
6928 true
6929 });
6930 result
6931}
6932
6933
6934static oncut_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6935
6936pub(crate) fn init_oncut_getterinfo<D: DomTypes>() {
6937 oncut_getterinfo.set(JSJitInfo {
6938 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6939 getter: Some(get_oncut::<D>)
6940 },
6941 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6942 protoID: PrototypeList::ID::Window as u16,
6943 },
6944 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6945 _bitfield_align_1: [],
6946 _bitfield_1: __BindgenBitfieldUnit::new(
6947 new_jsjitinfo_bitfield_1!(
6948 JSJitInfo_OpType::Getter as u8,
6949 JSJitInfo_AliasSet::AliasEverything as u8,
6950 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6951 true,
6952 false,
6953 false,
6954 false,
6955 false,
6956 false,
6957 0,
6958 ).to_ne_bytes()
6959 ),
6960});
6961}
6962static oncut_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6963
6964pub(crate) fn init_oncut_setterinfo<D: DomTypes>() {
6965 oncut_setterinfo.set(JSJitInfo {
6966 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6967 setter: Some(set_oncut::<D>)
6968 },
6969 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6970 protoID: PrototypeList::ID::Window as u16,
6971 },
6972 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6973 _bitfield_align_1: [],
6974 _bitfield_1: __BindgenBitfieldUnit::new(
6975 new_jsjitinfo_bitfield_1!(
6976 JSJitInfo_OpType::Setter as u8,
6977 JSJitInfo_AliasSet::AliasEverything as u8,
6978 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6979 false,
6980 false,
6981 false,
6982 false,
6983 false,
6984 false,
6985 0,
6986 ).to_ne_bytes()
6987 ),
6988});
6989}
6990unsafe extern "C" fn get_ondblclick<D: DomTypes>
6991(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6992 let mut result = false;
6993 wrap_panic(&mut || result = (|| {
6994 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6995 let this = &*(this as *const D::Window);
6996 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndblclick();
6997
6998 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6999 return true;
7000 })());
7001 result
7002}
7003
7004unsafe extern "C" fn set_ondblclick<D: DomTypes>
7005(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7006 let mut result = false;
7007 wrap_panic(&mut || result = {
7008 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7009 let this = &*(this as *const D::Window);
7010 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7011 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7012 } else {
7013 None
7014 };
7015 let result: () = this.SetOndblclick(arg0);
7016
7017 true
7018 });
7019 result
7020}
7021
7022
7023static ondblclick_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7024
7025pub(crate) fn init_ondblclick_getterinfo<D: DomTypes>() {
7026 ondblclick_getterinfo.set(JSJitInfo {
7027 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7028 getter: Some(get_ondblclick::<D>)
7029 },
7030 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7031 protoID: PrototypeList::ID::Window as u16,
7032 },
7033 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7034 _bitfield_align_1: [],
7035 _bitfield_1: __BindgenBitfieldUnit::new(
7036 new_jsjitinfo_bitfield_1!(
7037 JSJitInfo_OpType::Getter as u8,
7038 JSJitInfo_AliasSet::AliasEverything as u8,
7039 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7040 true,
7041 false,
7042 false,
7043 false,
7044 false,
7045 false,
7046 0,
7047 ).to_ne_bytes()
7048 ),
7049});
7050}
7051static ondblclick_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7052
7053pub(crate) fn init_ondblclick_setterinfo<D: DomTypes>() {
7054 ondblclick_setterinfo.set(JSJitInfo {
7055 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7056 setter: Some(set_ondblclick::<D>)
7057 },
7058 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7059 protoID: PrototypeList::ID::Window as u16,
7060 },
7061 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7062 _bitfield_align_1: [],
7063 _bitfield_1: __BindgenBitfieldUnit::new(
7064 new_jsjitinfo_bitfield_1!(
7065 JSJitInfo_OpType::Setter as u8,
7066 JSJitInfo_AliasSet::AliasEverything as u8,
7067 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7068 false,
7069 false,
7070 false,
7071 false,
7072 false,
7073 false,
7074 0,
7075 ).to_ne_bytes()
7076 ),
7077});
7078}
7079unsafe extern "C" fn get_ondrag<D: DomTypes>
7080(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7081 let mut result = false;
7082 wrap_panic(&mut || result = (|| {
7083 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7084 let this = &*(this as *const D::Window);
7085 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndrag();
7086
7087 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7088 return true;
7089 })());
7090 result
7091}
7092
7093unsafe extern "C" fn set_ondrag<D: DomTypes>
7094(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7095 let mut result = false;
7096 wrap_panic(&mut || result = {
7097 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7098 let this = &*(this as *const D::Window);
7099 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7100 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7101 } else {
7102 None
7103 };
7104 let result: () = this.SetOndrag(arg0);
7105
7106 true
7107 });
7108 result
7109}
7110
7111
7112static ondrag_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7113
7114pub(crate) fn init_ondrag_getterinfo<D: DomTypes>() {
7115 ondrag_getterinfo.set(JSJitInfo {
7116 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7117 getter: Some(get_ondrag::<D>)
7118 },
7119 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7120 protoID: PrototypeList::ID::Window as u16,
7121 },
7122 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7123 _bitfield_align_1: [],
7124 _bitfield_1: __BindgenBitfieldUnit::new(
7125 new_jsjitinfo_bitfield_1!(
7126 JSJitInfo_OpType::Getter as u8,
7127 JSJitInfo_AliasSet::AliasEverything as u8,
7128 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7129 true,
7130 false,
7131 false,
7132 false,
7133 false,
7134 false,
7135 0,
7136 ).to_ne_bytes()
7137 ),
7138});
7139}
7140static ondrag_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7141
7142pub(crate) fn init_ondrag_setterinfo<D: DomTypes>() {
7143 ondrag_setterinfo.set(JSJitInfo {
7144 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7145 setter: Some(set_ondrag::<D>)
7146 },
7147 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7148 protoID: PrototypeList::ID::Window as u16,
7149 },
7150 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7151 _bitfield_align_1: [],
7152 _bitfield_1: __BindgenBitfieldUnit::new(
7153 new_jsjitinfo_bitfield_1!(
7154 JSJitInfo_OpType::Setter as u8,
7155 JSJitInfo_AliasSet::AliasEverything as u8,
7156 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7157 false,
7158 false,
7159 false,
7160 false,
7161 false,
7162 false,
7163 0,
7164 ).to_ne_bytes()
7165 ),
7166});
7167}
7168unsafe extern "C" fn get_ondragend<D: DomTypes>
7169(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7170 let mut result = false;
7171 wrap_panic(&mut || result = (|| {
7172 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7173 let this = &*(this as *const D::Window);
7174 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragend();
7175
7176 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7177 return true;
7178 })());
7179 result
7180}
7181
7182unsafe extern "C" fn set_ondragend<D: DomTypes>
7183(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7184 let mut result = false;
7185 wrap_panic(&mut || result = {
7186 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7187 let this = &*(this as *const D::Window);
7188 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7189 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7190 } else {
7191 None
7192 };
7193 let result: () = this.SetOndragend(arg0);
7194
7195 true
7196 });
7197 result
7198}
7199
7200
7201static ondragend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7202
7203pub(crate) fn init_ondragend_getterinfo<D: DomTypes>() {
7204 ondragend_getterinfo.set(JSJitInfo {
7205 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7206 getter: Some(get_ondragend::<D>)
7207 },
7208 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7209 protoID: PrototypeList::ID::Window as u16,
7210 },
7211 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7212 _bitfield_align_1: [],
7213 _bitfield_1: __BindgenBitfieldUnit::new(
7214 new_jsjitinfo_bitfield_1!(
7215 JSJitInfo_OpType::Getter as u8,
7216 JSJitInfo_AliasSet::AliasEverything as u8,
7217 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7218 true,
7219 false,
7220 false,
7221 false,
7222 false,
7223 false,
7224 0,
7225 ).to_ne_bytes()
7226 ),
7227});
7228}
7229static ondragend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7230
7231pub(crate) fn init_ondragend_setterinfo<D: DomTypes>() {
7232 ondragend_setterinfo.set(JSJitInfo {
7233 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7234 setter: Some(set_ondragend::<D>)
7235 },
7236 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7237 protoID: PrototypeList::ID::Window as u16,
7238 },
7239 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7240 _bitfield_align_1: [],
7241 _bitfield_1: __BindgenBitfieldUnit::new(
7242 new_jsjitinfo_bitfield_1!(
7243 JSJitInfo_OpType::Setter as u8,
7244 JSJitInfo_AliasSet::AliasEverything as u8,
7245 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7246 false,
7247 false,
7248 false,
7249 false,
7250 false,
7251 false,
7252 0,
7253 ).to_ne_bytes()
7254 ),
7255});
7256}
7257unsafe extern "C" fn get_ondragenter<D: DomTypes>
7258(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7259 let mut result = false;
7260 wrap_panic(&mut || result = (|| {
7261 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7262 let this = &*(this as *const D::Window);
7263 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragenter();
7264
7265 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7266 return true;
7267 })());
7268 result
7269}
7270
7271unsafe extern "C" fn set_ondragenter<D: DomTypes>
7272(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7273 let mut result = false;
7274 wrap_panic(&mut || result = {
7275 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7276 let this = &*(this as *const D::Window);
7277 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7278 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7279 } else {
7280 None
7281 };
7282 let result: () = this.SetOndragenter(arg0);
7283
7284 true
7285 });
7286 result
7287}
7288
7289
7290static ondragenter_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7291
7292pub(crate) fn init_ondragenter_getterinfo<D: DomTypes>() {
7293 ondragenter_getterinfo.set(JSJitInfo {
7294 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7295 getter: Some(get_ondragenter::<D>)
7296 },
7297 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7298 protoID: PrototypeList::ID::Window as u16,
7299 },
7300 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7301 _bitfield_align_1: [],
7302 _bitfield_1: __BindgenBitfieldUnit::new(
7303 new_jsjitinfo_bitfield_1!(
7304 JSJitInfo_OpType::Getter as u8,
7305 JSJitInfo_AliasSet::AliasEverything as u8,
7306 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7307 true,
7308 false,
7309 false,
7310 false,
7311 false,
7312 false,
7313 0,
7314 ).to_ne_bytes()
7315 ),
7316});
7317}
7318static ondragenter_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7319
7320pub(crate) fn init_ondragenter_setterinfo<D: DomTypes>() {
7321 ondragenter_setterinfo.set(JSJitInfo {
7322 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7323 setter: Some(set_ondragenter::<D>)
7324 },
7325 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7326 protoID: PrototypeList::ID::Window as u16,
7327 },
7328 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7329 _bitfield_align_1: [],
7330 _bitfield_1: __BindgenBitfieldUnit::new(
7331 new_jsjitinfo_bitfield_1!(
7332 JSJitInfo_OpType::Setter as u8,
7333 JSJitInfo_AliasSet::AliasEverything as u8,
7334 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7335 false,
7336 false,
7337 false,
7338 false,
7339 false,
7340 false,
7341 0,
7342 ).to_ne_bytes()
7343 ),
7344});
7345}
7346unsafe extern "C" fn get_ondragleave<D: DomTypes>
7347(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7348 let mut result = false;
7349 wrap_panic(&mut || result = (|| {
7350 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7351 let this = &*(this as *const D::Window);
7352 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragleave();
7353
7354 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7355 return true;
7356 })());
7357 result
7358}
7359
7360unsafe extern "C" fn set_ondragleave<D: DomTypes>
7361(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7362 let mut result = false;
7363 wrap_panic(&mut || result = {
7364 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7365 let this = &*(this as *const D::Window);
7366 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7367 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7368 } else {
7369 None
7370 };
7371 let result: () = this.SetOndragleave(arg0);
7372
7373 true
7374 });
7375 result
7376}
7377
7378
7379static ondragleave_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7380
7381pub(crate) fn init_ondragleave_getterinfo<D: DomTypes>() {
7382 ondragleave_getterinfo.set(JSJitInfo {
7383 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7384 getter: Some(get_ondragleave::<D>)
7385 },
7386 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7387 protoID: PrototypeList::ID::Window as u16,
7388 },
7389 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7390 _bitfield_align_1: [],
7391 _bitfield_1: __BindgenBitfieldUnit::new(
7392 new_jsjitinfo_bitfield_1!(
7393 JSJitInfo_OpType::Getter as u8,
7394 JSJitInfo_AliasSet::AliasEverything as u8,
7395 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7396 true,
7397 false,
7398 false,
7399 false,
7400 false,
7401 false,
7402 0,
7403 ).to_ne_bytes()
7404 ),
7405});
7406}
7407static ondragleave_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7408
7409pub(crate) fn init_ondragleave_setterinfo<D: DomTypes>() {
7410 ondragleave_setterinfo.set(JSJitInfo {
7411 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7412 setter: Some(set_ondragleave::<D>)
7413 },
7414 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7415 protoID: PrototypeList::ID::Window as u16,
7416 },
7417 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7418 _bitfield_align_1: [],
7419 _bitfield_1: __BindgenBitfieldUnit::new(
7420 new_jsjitinfo_bitfield_1!(
7421 JSJitInfo_OpType::Setter as u8,
7422 JSJitInfo_AliasSet::AliasEverything as u8,
7423 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7424 false,
7425 false,
7426 false,
7427 false,
7428 false,
7429 false,
7430 0,
7431 ).to_ne_bytes()
7432 ),
7433});
7434}
7435unsafe extern "C" fn get_ondragover<D: DomTypes>
7436(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7437 let mut result = false;
7438 wrap_panic(&mut || result = (|| {
7439 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7440 let this = &*(this as *const D::Window);
7441 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragover();
7442
7443 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7444 return true;
7445 })());
7446 result
7447}
7448
7449unsafe extern "C" fn set_ondragover<D: DomTypes>
7450(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7451 let mut result = false;
7452 wrap_panic(&mut || result = {
7453 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7454 let this = &*(this as *const D::Window);
7455 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7456 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7457 } else {
7458 None
7459 };
7460 let result: () = this.SetOndragover(arg0);
7461
7462 true
7463 });
7464 result
7465}
7466
7467
7468static ondragover_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7469
7470pub(crate) fn init_ondragover_getterinfo<D: DomTypes>() {
7471 ondragover_getterinfo.set(JSJitInfo {
7472 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7473 getter: Some(get_ondragover::<D>)
7474 },
7475 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7476 protoID: PrototypeList::ID::Window as u16,
7477 },
7478 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7479 _bitfield_align_1: [],
7480 _bitfield_1: __BindgenBitfieldUnit::new(
7481 new_jsjitinfo_bitfield_1!(
7482 JSJitInfo_OpType::Getter as u8,
7483 JSJitInfo_AliasSet::AliasEverything as u8,
7484 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7485 true,
7486 false,
7487 false,
7488 false,
7489 false,
7490 false,
7491 0,
7492 ).to_ne_bytes()
7493 ),
7494});
7495}
7496static ondragover_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7497
7498pub(crate) fn init_ondragover_setterinfo<D: DomTypes>() {
7499 ondragover_setterinfo.set(JSJitInfo {
7500 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7501 setter: Some(set_ondragover::<D>)
7502 },
7503 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7504 protoID: PrototypeList::ID::Window as u16,
7505 },
7506 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7507 _bitfield_align_1: [],
7508 _bitfield_1: __BindgenBitfieldUnit::new(
7509 new_jsjitinfo_bitfield_1!(
7510 JSJitInfo_OpType::Setter as u8,
7511 JSJitInfo_AliasSet::AliasEverything as u8,
7512 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7513 false,
7514 false,
7515 false,
7516 false,
7517 false,
7518 false,
7519 0,
7520 ).to_ne_bytes()
7521 ),
7522});
7523}
7524unsafe extern "C" fn get_ondragstart<D: DomTypes>
7525(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7526 let mut result = false;
7527 wrap_panic(&mut || result = (|| {
7528 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7529 let this = &*(this as *const D::Window);
7530 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragstart();
7531
7532 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7533 return true;
7534 })());
7535 result
7536}
7537
7538unsafe extern "C" fn set_ondragstart<D: DomTypes>
7539(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7540 let mut result = false;
7541 wrap_panic(&mut || result = {
7542 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7543 let this = &*(this as *const D::Window);
7544 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7545 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7546 } else {
7547 None
7548 };
7549 let result: () = this.SetOndragstart(arg0);
7550
7551 true
7552 });
7553 result
7554}
7555
7556
7557static ondragstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7558
7559pub(crate) fn init_ondragstart_getterinfo<D: DomTypes>() {
7560 ondragstart_getterinfo.set(JSJitInfo {
7561 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7562 getter: Some(get_ondragstart::<D>)
7563 },
7564 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7565 protoID: PrototypeList::ID::Window as u16,
7566 },
7567 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7568 _bitfield_align_1: [],
7569 _bitfield_1: __BindgenBitfieldUnit::new(
7570 new_jsjitinfo_bitfield_1!(
7571 JSJitInfo_OpType::Getter as u8,
7572 JSJitInfo_AliasSet::AliasEverything as u8,
7573 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7574 true,
7575 false,
7576 false,
7577 false,
7578 false,
7579 false,
7580 0,
7581 ).to_ne_bytes()
7582 ),
7583});
7584}
7585static ondragstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7586
7587pub(crate) fn init_ondragstart_setterinfo<D: DomTypes>() {
7588 ondragstart_setterinfo.set(JSJitInfo {
7589 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7590 setter: Some(set_ondragstart::<D>)
7591 },
7592 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7593 protoID: PrototypeList::ID::Window as u16,
7594 },
7595 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7596 _bitfield_align_1: [],
7597 _bitfield_1: __BindgenBitfieldUnit::new(
7598 new_jsjitinfo_bitfield_1!(
7599 JSJitInfo_OpType::Setter as u8,
7600 JSJitInfo_AliasSet::AliasEverything as u8,
7601 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7602 false,
7603 false,
7604 false,
7605 false,
7606 false,
7607 false,
7608 0,
7609 ).to_ne_bytes()
7610 ),
7611});
7612}
7613unsafe extern "C" fn get_ondrop<D: DomTypes>
7614(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7615 let mut result = false;
7616 wrap_panic(&mut || result = (|| {
7617 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7618 let this = &*(this as *const D::Window);
7619 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndrop();
7620
7621 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7622 return true;
7623 })());
7624 result
7625}
7626
7627unsafe extern "C" fn set_ondrop<D: DomTypes>
7628(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7629 let mut result = false;
7630 wrap_panic(&mut || result = {
7631 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7632 let this = &*(this as *const D::Window);
7633 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7634 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7635 } else {
7636 None
7637 };
7638 let result: () = this.SetOndrop(arg0);
7639
7640 true
7641 });
7642 result
7643}
7644
7645
7646static ondrop_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7647
7648pub(crate) fn init_ondrop_getterinfo<D: DomTypes>() {
7649 ondrop_getterinfo.set(JSJitInfo {
7650 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7651 getter: Some(get_ondrop::<D>)
7652 },
7653 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7654 protoID: PrototypeList::ID::Window as u16,
7655 },
7656 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7657 _bitfield_align_1: [],
7658 _bitfield_1: __BindgenBitfieldUnit::new(
7659 new_jsjitinfo_bitfield_1!(
7660 JSJitInfo_OpType::Getter as u8,
7661 JSJitInfo_AliasSet::AliasEverything as u8,
7662 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7663 true,
7664 false,
7665 false,
7666 false,
7667 false,
7668 false,
7669 0,
7670 ).to_ne_bytes()
7671 ),
7672});
7673}
7674static ondrop_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7675
7676pub(crate) fn init_ondrop_setterinfo<D: DomTypes>() {
7677 ondrop_setterinfo.set(JSJitInfo {
7678 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7679 setter: Some(set_ondrop::<D>)
7680 },
7681 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7682 protoID: PrototypeList::ID::Window as u16,
7683 },
7684 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7685 _bitfield_align_1: [],
7686 _bitfield_1: __BindgenBitfieldUnit::new(
7687 new_jsjitinfo_bitfield_1!(
7688 JSJitInfo_OpType::Setter as u8,
7689 JSJitInfo_AliasSet::AliasEverything as u8,
7690 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7691 false,
7692 false,
7693 false,
7694 false,
7695 false,
7696 false,
7697 0,
7698 ).to_ne_bytes()
7699 ),
7700});
7701}
7702unsafe extern "C" fn get_ondurationchange<D: DomTypes>
7703(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7704 let mut result = false;
7705 wrap_panic(&mut || result = (|| {
7706 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7707 let this = &*(this as *const D::Window);
7708 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndurationchange();
7709
7710 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7711 return true;
7712 })());
7713 result
7714}
7715
7716unsafe extern "C" fn set_ondurationchange<D: DomTypes>
7717(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7718 let mut result = false;
7719 wrap_panic(&mut || result = {
7720 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7721 let this = &*(this as *const D::Window);
7722 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7723 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7724 } else {
7725 None
7726 };
7727 let result: () = this.SetOndurationchange(arg0);
7728
7729 true
7730 });
7731 result
7732}
7733
7734
7735static ondurationchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7736
7737pub(crate) fn init_ondurationchange_getterinfo<D: DomTypes>() {
7738 ondurationchange_getterinfo.set(JSJitInfo {
7739 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7740 getter: Some(get_ondurationchange::<D>)
7741 },
7742 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7743 protoID: PrototypeList::ID::Window as u16,
7744 },
7745 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7746 _bitfield_align_1: [],
7747 _bitfield_1: __BindgenBitfieldUnit::new(
7748 new_jsjitinfo_bitfield_1!(
7749 JSJitInfo_OpType::Getter as u8,
7750 JSJitInfo_AliasSet::AliasEverything as u8,
7751 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7752 true,
7753 false,
7754 false,
7755 false,
7756 false,
7757 false,
7758 0,
7759 ).to_ne_bytes()
7760 ),
7761});
7762}
7763static ondurationchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7764
7765pub(crate) fn init_ondurationchange_setterinfo<D: DomTypes>() {
7766 ondurationchange_setterinfo.set(JSJitInfo {
7767 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7768 setter: Some(set_ondurationchange::<D>)
7769 },
7770 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7771 protoID: PrototypeList::ID::Window as u16,
7772 },
7773 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7774 _bitfield_align_1: [],
7775 _bitfield_1: __BindgenBitfieldUnit::new(
7776 new_jsjitinfo_bitfield_1!(
7777 JSJitInfo_OpType::Setter as u8,
7778 JSJitInfo_AliasSet::AliasEverything as u8,
7779 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7780 false,
7781 false,
7782 false,
7783 false,
7784 false,
7785 false,
7786 0,
7787 ).to_ne_bytes()
7788 ),
7789});
7790}
7791unsafe extern "C" fn get_onemptied<D: DomTypes>
7792(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7793 let mut result = false;
7794 wrap_panic(&mut || result = (|| {
7795 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7796 let this = &*(this as *const D::Window);
7797 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnemptied();
7798
7799 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7800 return true;
7801 })());
7802 result
7803}
7804
7805unsafe extern "C" fn set_onemptied<D: DomTypes>
7806(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7807 let mut result = false;
7808 wrap_panic(&mut || result = {
7809 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7810 let this = &*(this as *const D::Window);
7811 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7812 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7813 } else {
7814 None
7815 };
7816 let result: () = this.SetOnemptied(arg0);
7817
7818 true
7819 });
7820 result
7821}
7822
7823
7824static onemptied_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7825
7826pub(crate) fn init_onemptied_getterinfo<D: DomTypes>() {
7827 onemptied_getterinfo.set(JSJitInfo {
7828 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7829 getter: Some(get_onemptied::<D>)
7830 },
7831 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7832 protoID: PrototypeList::ID::Window as u16,
7833 },
7834 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7835 _bitfield_align_1: [],
7836 _bitfield_1: __BindgenBitfieldUnit::new(
7837 new_jsjitinfo_bitfield_1!(
7838 JSJitInfo_OpType::Getter as u8,
7839 JSJitInfo_AliasSet::AliasEverything as u8,
7840 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7841 true,
7842 false,
7843 false,
7844 false,
7845 false,
7846 false,
7847 0,
7848 ).to_ne_bytes()
7849 ),
7850});
7851}
7852static onemptied_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7853
7854pub(crate) fn init_onemptied_setterinfo<D: DomTypes>() {
7855 onemptied_setterinfo.set(JSJitInfo {
7856 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7857 setter: Some(set_onemptied::<D>)
7858 },
7859 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7860 protoID: PrototypeList::ID::Window as u16,
7861 },
7862 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7863 _bitfield_align_1: [],
7864 _bitfield_1: __BindgenBitfieldUnit::new(
7865 new_jsjitinfo_bitfield_1!(
7866 JSJitInfo_OpType::Setter as u8,
7867 JSJitInfo_AliasSet::AliasEverything as u8,
7868 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7869 false,
7870 false,
7871 false,
7872 false,
7873 false,
7874 false,
7875 0,
7876 ).to_ne_bytes()
7877 ),
7878});
7879}
7880unsafe extern "C" fn get_onended<D: DomTypes>
7881(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7882 let mut result = false;
7883 wrap_panic(&mut || result = (|| {
7884 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7885 let this = &*(this as *const D::Window);
7886 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnended();
7887
7888 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7889 return true;
7890 })());
7891 result
7892}
7893
7894unsafe extern "C" fn set_onended<D: DomTypes>
7895(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7896 let mut result = false;
7897 wrap_panic(&mut || result = {
7898 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7899 let this = &*(this as *const D::Window);
7900 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7901 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7902 } else {
7903 None
7904 };
7905 let result: () = this.SetOnended(arg0);
7906
7907 true
7908 });
7909 result
7910}
7911
7912
7913static onended_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7914
7915pub(crate) fn init_onended_getterinfo<D: DomTypes>() {
7916 onended_getterinfo.set(JSJitInfo {
7917 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7918 getter: Some(get_onended::<D>)
7919 },
7920 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7921 protoID: PrototypeList::ID::Window as u16,
7922 },
7923 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7924 _bitfield_align_1: [],
7925 _bitfield_1: __BindgenBitfieldUnit::new(
7926 new_jsjitinfo_bitfield_1!(
7927 JSJitInfo_OpType::Getter as u8,
7928 JSJitInfo_AliasSet::AliasEverything as u8,
7929 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7930 true,
7931 false,
7932 false,
7933 false,
7934 false,
7935 false,
7936 0,
7937 ).to_ne_bytes()
7938 ),
7939});
7940}
7941static onended_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7942
7943pub(crate) fn init_onended_setterinfo<D: DomTypes>() {
7944 onended_setterinfo.set(JSJitInfo {
7945 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7946 setter: Some(set_onended::<D>)
7947 },
7948 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7949 protoID: PrototypeList::ID::Window as u16,
7950 },
7951 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7952 _bitfield_align_1: [],
7953 _bitfield_1: __BindgenBitfieldUnit::new(
7954 new_jsjitinfo_bitfield_1!(
7955 JSJitInfo_OpType::Setter as u8,
7956 JSJitInfo_AliasSet::AliasEverything as u8,
7957 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7958 false,
7959 false,
7960 false,
7961 false,
7962 false,
7963 false,
7964 0,
7965 ).to_ne_bytes()
7966 ),
7967});
7968}
7969unsafe extern "C" fn get_onerror<D: DomTypes>
7970(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7971 let mut result = false;
7972 wrap_panic(&mut || result = (|| {
7973 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7974 let this = &*(this as *const D::Window);
7975 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::OnErrorEventHandlerNonNull<D>>> = this.GetOnerror();
7976
7977 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7978 return true;
7979 })());
7980 result
7981}
7982
7983unsafe extern "C" fn set_onerror<D: DomTypes>
7984(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7985 let mut result = false;
7986 wrap_panic(&mut || result = {
7987 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7988 let this = &*(this as *const D::Window);
7989 let arg0: Option<Rc<OnErrorEventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7990 Some(OnErrorEventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7991 } else {
7992 None
7993 };
7994 let result: () = this.SetOnerror(arg0);
7995
7996 true
7997 });
7998 result
7999}
8000
8001
8002static onerror_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8003
8004pub(crate) fn init_onerror_getterinfo<D: DomTypes>() {
8005 onerror_getterinfo.set(JSJitInfo {
8006 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8007 getter: Some(get_onerror::<D>)
8008 },
8009 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8010 protoID: PrototypeList::ID::Window as u16,
8011 },
8012 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8013 _bitfield_align_1: [],
8014 _bitfield_1: __BindgenBitfieldUnit::new(
8015 new_jsjitinfo_bitfield_1!(
8016 JSJitInfo_OpType::Getter as u8,
8017 JSJitInfo_AliasSet::AliasEverything as u8,
8018 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8019 true,
8020 false,
8021 false,
8022 false,
8023 false,
8024 false,
8025 0,
8026 ).to_ne_bytes()
8027 ),
8028});
8029}
8030static onerror_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8031
8032pub(crate) fn init_onerror_setterinfo<D: DomTypes>() {
8033 onerror_setterinfo.set(JSJitInfo {
8034 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8035 setter: Some(set_onerror::<D>)
8036 },
8037 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8038 protoID: PrototypeList::ID::Window as u16,
8039 },
8040 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8041 _bitfield_align_1: [],
8042 _bitfield_1: __BindgenBitfieldUnit::new(
8043 new_jsjitinfo_bitfield_1!(
8044 JSJitInfo_OpType::Setter as u8,
8045 JSJitInfo_AliasSet::AliasEverything as u8,
8046 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8047 false,
8048 false,
8049 false,
8050 false,
8051 false,
8052 false,
8053 0,
8054 ).to_ne_bytes()
8055 ),
8056});
8057}
8058unsafe extern "C" fn get_onfocus<D: DomTypes>
8059(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8060 let mut result = false;
8061 wrap_panic(&mut || result = (|| {
8062 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8063 let this = &*(this as *const D::Window);
8064 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnfocus();
8065
8066 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8067 return true;
8068 })());
8069 result
8070}
8071
8072unsafe extern "C" fn set_onfocus<D: DomTypes>
8073(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8074 let mut result = false;
8075 wrap_panic(&mut || result = {
8076 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8077 let this = &*(this as *const D::Window);
8078 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8079 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8080 } else {
8081 None
8082 };
8083 let result: () = this.SetOnfocus(arg0);
8084
8085 true
8086 });
8087 result
8088}
8089
8090
8091static onfocus_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8092
8093pub(crate) fn init_onfocus_getterinfo<D: DomTypes>() {
8094 onfocus_getterinfo.set(JSJitInfo {
8095 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8096 getter: Some(get_onfocus::<D>)
8097 },
8098 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8099 protoID: PrototypeList::ID::Window as u16,
8100 },
8101 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8102 _bitfield_align_1: [],
8103 _bitfield_1: __BindgenBitfieldUnit::new(
8104 new_jsjitinfo_bitfield_1!(
8105 JSJitInfo_OpType::Getter as u8,
8106 JSJitInfo_AliasSet::AliasEverything as u8,
8107 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8108 true,
8109 false,
8110 false,
8111 false,
8112 false,
8113 false,
8114 0,
8115 ).to_ne_bytes()
8116 ),
8117});
8118}
8119static onfocus_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8120
8121pub(crate) fn init_onfocus_setterinfo<D: DomTypes>() {
8122 onfocus_setterinfo.set(JSJitInfo {
8123 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8124 setter: Some(set_onfocus::<D>)
8125 },
8126 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8127 protoID: PrototypeList::ID::Window as u16,
8128 },
8129 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8130 _bitfield_align_1: [],
8131 _bitfield_1: __BindgenBitfieldUnit::new(
8132 new_jsjitinfo_bitfield_1!(
8133 JSJitInfo_OpType::Setter as u8,
8134 JSJitInfo_AliasSet::AliasEverything as u8,
8135 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8136 false,
8137 false,
8138 false,
8139 false,
8140 false,
8141 false,
8142 0,
8143 ).to_ne_bytes()
8144 ),
8145});
8146}
8147unsafe extern "C" fn get_onformdata<D: DomTypes>
8148(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8149 let mut result = false;
8150 wrap_panic(&mut || result = (|| {
8151 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8152 let this = &*(this as *const D::Window);
8153 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnformdata();
8154
8155 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8156 return true;
8157 })());
8158 result
8159}
8160
8161unsafe extern "C" fn set_onformdata<D: DomTypes>
8162(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8163 let mut result = false;
8164 wrap_panic(&mut || result = {
8165 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8166 let this = &*(this as *const D::Window);
8167 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8168 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8169 } else {
8170 None
8171 };
8172 let result: () = this.SetOnformdata(arg0);
8173
8174 true
8175 });
8176 result
8177}
8178
8179
8180static onformdata_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8181
8182pub(crate) fn init_onformdata_getterinfo<D: DomTypes>() {
8183 onformdata_getterinfo.set(JSJitInfo {
8184 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8185 getter: Some(get_onformdata::<D>)
8186 },
8187 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8188 protoID: PrototypeList::ID::Window as u16,
8189 },
8190 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8191 _bitfield_align_1: [],
8192 _bitfield_1: __BindgenBitfieldUnit::new(
8193 new_jsjitinfo_bitfield_1!(
8194 JSJitInfo_OpType::Getter as u8,
8195 JSJitInfo_AliasSet::AliasEverything as u8,
8196 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8197 true,
8198 false,
8199 false,
8200 false,
8201 false,
8202 false,
8203 0,
8204 ).to_ne_bytes()
8205 ),
8206});
8207}
8208static onformdata_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8209
8210pub(crate) fn init_onformdata_setterinfo<D: DomTypes>() {
8211 onformdata_setterinfo.set(JSJitInfo {
8212 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8213 setter: Some(set_onformdata::<D>)
8214 },
8215 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8216 protoID: PrototypeList::ID::Window as u16,
8217 },
8218 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8219 _bitfield_align_1: [],
8220 _bitfield_1: __BindgenBitfieldUnit::new(
8221 new_jsjitinfo_bitfield_1!(
8222 JSJitInfo_OpType::Setter as u8,
8223 JSJitInfo_AliasSet::AliasEverything as u8,
8224 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8225 false,
8226 false,
8227 false,
8228 false,
8229 false,
8230 false,
8231 0,
8232 ).to_ne_bytes()
8233 ),
8234});
8235}
8236unsafe extern "C" fn get_oninput<D: DomTypes>
8237(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8238 let mut result = false;
8239 wrap_panic(&mut || result = (|| {
8240 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8241 let this = &*(this as *const D::Window);
8242 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOninput();
8243
8244 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8245 return true;
8246 })());
8247 result
8248}
8249
8250unsafe extern "C" fn set_oninput<D: DomTypes>
8251(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8252 let mut result = false;
8253 wrap_panic(&mut || result = {
8254 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8255 let this = &*(this as *const D::Window);
8256 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8257 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8258 } else {
8259 None
8260 };
8261 let result: () = this.SetOninput(arg0);
8262
8263 true
8264 });
8265 result
8266}
8267
8268
8269static oninput_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8270
8271pub(crate) fn init_oninput_getterinfo<D: DomTypes>() {
8272 oninput_getterinfo.set(JSJitInfo {
8273 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8274 getter: Some(get_oninput::<D>)
8275 },
8276 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8277 protoID: PrototypeList::ID::Window as u16,
8278 },
8279 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8280 _bitfield_align_1: [],
8281 _bitfield_1: __BindgenBitfieldUnit::new(
8282 new_jsjitinfo_bitfield_1!(
8283 JSJitInfo_OpType::Getter as u8,
8284 JSJitInfo_AliasSet::AliasEverything as u8,
8285 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8286 true,
8287 false,
8288 false,
8289 false,
8290 false,
8291 false,
8292 0,
8293 ).to_ne_bytes()
8294 ),
8295});
8296}
8297static oninput_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8298
8299pub(crate) fn init_oninput_setterinfo<D: DomTypes>() {
8300 oninput_setterinfo.set(JSJitInfo {
8301 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8302 setter: Some(set_oninput::<D>)
8303 },
8304 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8305 protoID: PrototypeList::ID::Window as u16,
8306 },
8307 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8308 _bitfield_align_1: [],
8309 _bitfield_1: __BindgenBitfieldUnit::new(
8310 new_jsjitinfo_bitfield_1!(
8311 JSJitInfo_OpType::Setter as u8,
8312 JSJitInfo_AliasSet::AliasEverything as u8,
8313 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8314 false,
8315 false,
8316 false,
8317 false,
8318 false,
8319 false,
8320 0,
8321 ).to_ne_bytes()
8322 ),
8323});
8324}
8325unsafe extern "C" fn get_oninvalid<D: DomTypes>
8326(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8327 let mut result = false;
8328 wrap_panic(&mut || result = (|| {
8329 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8330 let this = &*(this as *const D::Window);
8331 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOninvalid();
8332
8333 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8334 return true;
8335 })());
8336 result
8337}
8338
8339unsafe extern "C" fn set_oninvalid<D: DomTypes>
8340(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8341 let mut result = false;
8342 wrap_panic(&mut || result = {
8343 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8344 let this = &*(this as *const D::Window);
8345 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8346 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8347 } else {
8348 None
8349 };
8350 let result: () = this.SetOninvalid(arg0);
8351
8352 true
8353 });
8354 result
8355}
8356
8357
8358static oninvalid_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8359
8360pub(crate) fn init_oninvalid_getterinfo<D: DomTypes>() {
8361 oninvalid_getterinfo.set(JSJitInfo {
8362 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8363 getter: Some(get_oninvalid::<D>)
8364 },
8365 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8366 protoID: PrototypeList::ID::Window as u16,
8367 },
8368 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8369 _bitfield_align_1: [],
8370 _bitfield_1: __BindgenBitfieldUnit::new(
8371 new_jsjitinfo_bitfield_1!(
8372 JSJitInfo_OpType::Getter as u8,
8373 JSJitInfo_AliasSet::AliasEverything as u8,
8374 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8375 true,
8376 false,
8377 false,
8378 false,
8379 false,
8380 false,
8381 0,
8382 ).to_ne_bytes()
8383 ),
8384});
8385}
8386static oninvalid_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8387
8388pub(crate) fn init_oninvalid_setterinfo<D: DomTypes>() {
8389 oninvalid_setterinfo.set(JSJitInfo {
8390 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8391 setter: Some(set_oninvalid::<D>)
8392 },
8393 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8394 protoID: PrototypeList::ID::Window as u16,
8395 },
8396 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8397 _bitfield_align_1: [],
8398 _bitfield_1: __BindgenBitfieldUnit::new(
8399 new_jsjitinfo_bitfield_1!(
8400 JSJitInfo_OpType::Setter as u8,
8401 JSJitInfo_AliasSet::AliasEverything as u8,
8402 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8403 false,
8404 false,
8405 false,
8406 false,
8407 false,
8408 false,
8409 0,
8410 ).to_ne_bytes()
8411 ),
8412});
8413}
8414unsafe extern "C" fn get_onkeydown<D: DomTypes>
8415(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8416 let mut result = false;
8417 wrap_panic(&mut || result = (|| {
8418 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8419 let this = &*(this as *const D::Window);
8420 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnkeydown();
8421
8422 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8423 return true;
8424 })());
8425 result
8426}
8427
8428unsafe extern "C" fn set_onkeydown<D: DomTypes>
8429(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8430 let mut result = false;
8431 wrap_panic(&mut || result = {
8432 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8433 let this = &*(this as *const D::Window);
8434 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8435 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8436 } else {
8437 None
8438 };
8439 let result: () = this.SetOnkeydown(arg0);
8440
8441 true
8442 });
8443 result
8444}
8445
8446
8447static onkeydown_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8448
8449pub(crate) fn init_onkeydown_getterinfo<D: DomTypes>() {
8450 onkeydown_getterinfo.set(JSJitInfo {
8451 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8452 getter: Some(get_onkeydown::<D>)
8453 },
8454 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8455 protoID: PrototypeList::ID::Window as u16,
8456 },
8457 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8458 _bitfield_align_1: [],
8459 _bitfield_1: __BindgenBitfieldUnit::new(
8460 new_jsjitinfo_bitfield_1!(
8461 JSJitInfo_OpType::Getter as u8,
8462 JSJitInfo_AliasSet::AliasEverything as u8,
8463 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8464 true,
8465 false,
8466 false,
8467 false,
8468 false,
8469 false,
8470 0,
8471 ).to_ne_bytes()
8472 ),
8473});
8474}
8475static onkeydown_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8476
8477pub(crate) fn init_onkeydown_setterinfo<D: DomTypes>() {
8478 onkeydown_setterinfo.set(JSJitInfo {
8479 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8480 setter: Some(set_onkeydown::<D>)
8481 },
8482 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8483 protoID: PrototypeList::ID::Window as u16,
8484 },
8485 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8486 _bitfield_align_1: [],
8487 _bitfield_1: __BindgenBitfieldUnit::new(
8488 new_jsjitinfo_bitfield_1!(
8489 JSJitInfo_OpType::Setter as u8,
8490 JSJitInfo_AliasSet::AliasEverything as u8,
8491 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8492 false,
8493 false,
8494 false,
8495 false,
8496 false,
8497 false,
8498 0,
8499 ).to_ne_bytes()
8500 ),
8501});
8502}
8503unsafe extern "C" fn get_onkeypress<D: DomTypes>
8504(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8505 let mut result = false;
8506 wrap_panic(&mut || result = (|| {
8507 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8508 let this = &*(this as *const D::Window);
8509 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnkeypress();
8510
8511 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8512 return true;
8513 })());
8514 result
8515}
8516
8517unsafe extern "C" fn set_onkeypress<D: DomTypes>
8518(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8519 let mut result = false;
8520 wrap_panic(&mut || result = {
8521 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8522 let this = &*(this as *const D::Window);
8523 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8524 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8525 } else {
8526 None
8527 };
8528 let result: () = this.SetOnkeypress(arg0);
8529
8530 true
8531 });
8532 result
8533}
8534
8535
8536static onkeypress_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8537
8538pub(crate) fn init_onkeypress_getterinfo<D: DomTypes>() {
8539 onkeypress_getterinfo.set(JSJitInfo {
8540 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8541 getter: Some(get_onkeypress::<D>)
8542 },
8543 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8544 protoID: PrototypeList::ID::Window as u16,
8545 },
8546 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8547 _bitfield_align_1: [],
8548 _bitfield_1: __BindgenBitfieldUnit::new(
8549 new_jsjitinfo_bitfield_1!(
8550 JSJitInfo_OpType::Getter as u8,
8551 JSJitInfo_AliasSet::AliasEverything as u8,
8552 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8553 true,
8554 false,
8555 false,
8556 false,
8557 false,
8558 false,
8559 0,
8560 ).to_ne_bytes()
8561 ),
8562});
8563}
8564static onkeypress_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8565
8566pub(crate) fn init_onkeypress_setterinfo<D: DomTypes>() {
8567 onkeypress_setterinfo.set(JSJitInfo {
8568 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8569 setter: Some(set_onkeypress::<D>)
8570 },
8571 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8572 protoID: PrototypeList::ID::Window as u16,
8573 },
8574 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8575 _bitfield_align_1: [],
8576 _bitfield_1: __BindgenBitfieldUnit::new(
8577 new_jsjitinfo_bitfield_1!(
8578 JSJitInfo_OpType::Setter as u8,
8579 JSJitInfo_AliasSet::AliasEverything as u8,
8580 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8581 false,
8582 false,
8583 false,
8584 false,
8585 false,
8586 false,
8587 0,
8588 ).to_ne_bytes()
8589 ),
8590});
8591}
8592unsafe extern "C" fn get_onkeyup<D: DomTypes>
8593(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8594 let mut result = false;
8595 wrap_panic(&mut || result = (|| {
8596 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8597 let this = &*(this as *const D::Window);
8598 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnkeyup();
8599
8600 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8601 return true;
8602 })());
8603 result
8604}
8605
8606unsafe extern "C" fn set_onkeyup<D: DomTypes>
8607(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8608 let mut result = false;
8609 wrap_panic(&mut || result = {
8610 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8611 let this = &*(this as *const D::Window);
8612 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8613 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8614 } else {
8615 None
8616 };
8617 let result: () = this.SetOnkeyup(arg0);
8618
8619 true
8620 });
8621 result
8622}
8623
8624
8625static onkeyup_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8626
8627pub(crate) fn init_onkeyup_getterinfo<D: DomTypes>() {
8628 onkeyup_getterinfo.set(JSJitInfo {
8629 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8630 getter: Some(get_onkeyup::<D>)
8631 },
8632 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8633 protoID: PrototypeList::ID::Window as u16,
8634 },
8635 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8636 _bitfield_align_1: [],
8637 _bitfield_1: __BindgenBitfieldUnit::new(
8638 new_jsjitinfo_bitfield_1!(
8639 JSJitInfo_OpType::Getter as u8,
8640 JSJitInfo_AliasSet::AliasEverything as u8,
8641 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8642 true,
8643 false,
8644 false,
8645 false,
8646 false,
8647 false,
8648 0,
8649 ).to_ne_bytes()
8650 ),
8651});
8652}
8653static onkeyup_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8654
8655pub(crate) fn init_onkeyup_setterinfo<D: DomTypes>() {
8656 onkeyup_setterinfo.set(JSJitInfo {
8657 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8658 setter: Some(set_onkeyup::<D>)
8659 },
8660 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8661 protoID: PrototypeList::ID::Window as u16,
8662 },
8663 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8664 _bitfield_align_1: [],
8665 _bitfield_1: __BindgenBitfieldUnit::new(
8666 new_jsjitinfo_bitfield_1!(
8667 JSJitInfo_OpType::Setter as u8,
8668 JSJitInfo_AliasSet::AliasEverything as u8,
8669 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8670 false,
8671 false,
8672 false,
8673 false,
8674 false,
8675 false,
8676 0,
8677 ).to_ne_bytes()
8678 ),
8679});
8680}
8681unsafe extern "C" fn get_onload<D: DomTypes>
8682(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8683 let mut result = false;
8684 wrap_panic(&mut || result = (|| {
8685 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8686 let this = &*(this as *const D::Window);
8687 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnload();
8688
8689 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8690 return true;
8691 })());
8692 result
8693}
8694
8695unsafe extern "C" fn set_onload<D: DomTypes>
8696(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8697 let mut result = false;
8698 wrap_panic(&mut || result = {
8699 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8700 let this = &*(this as *const D::Window);
8701 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8702 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8703 } else {
8704 None
8705 };
8706 let result: () = this.SetOnload(arg0);
8707
8708 true
8709 });
8710 result
8711}
8712
8713
8714static onload_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8715
8716pub(crate) fn init_onload_getterinfo<D: DomTypes>() {
8717 onload_getterinfo.set(JSJitInfo {
8718 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8719 getter: Some(get_onload::<D>)
8720 },
8721 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8722 protoID: PrototypeList::ID::Window as u16,
8723 },
8724 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8725 _bitfield_align_1: [],
8726 _bitfield_1: __BindgenBitfieldUnit::new(
8727 new_jsjitinfo_bitfield_1!(
8728 JSJitInfo_OpType::Getter as u8,
8729 JSJitInfo_AliasSet::AliasEverything as u8,
8730 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8731 true,
8732 false,
8733 false,
8734 false,
8735 false,
8736 false,
8737 0,
8738 ).to_ne_bytes()
8739 ),
8740});
8741}
8742static onload_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8743
8744pub(crate) fn init_onload_setterinfo<D: DomTypes>() {
8745 onload_setterinfo.set(JSJitInfo {
8746 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8747 setter: Some(set_onload::<D>)
8748 },
8749 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8750 protoID: PrototypeList::ID::Window as u16,
8751 },
8752 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8753 _bitfield_align_1: [],
8754 _bitfield_1: __BindgenBitfieldUnit::new(
8755 new_jsjitinfo_bitfield_1!(
8756 JSJitInfo_OpType::Setter as u8,
8757 JSJitInfo_AliasSet::AliasEverything as u8,
8758 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8759 false,
8760 false,
8761 false,
8762 false,
8763 false,
8764 false,
8765 0,
8766 ).to_ne_bytes()
8767 ),
8768});
8769}
8770unsafe extern "C" fn get_onloadeddata<D: DomTypes>
8771(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8772 let mut result = false;
8773 wrap_panic(&mut || result = (|| {
8774 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8775 let this = &*(this as *const D::Window);
8776 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnloadeddata();
8777
8778 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8779 return true;
8780 })());
8781 result
8782}
8783
8784unsafe extern "C" fn set_onloadeddata<D: DomTypes>
8785(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8786 let mut result = false;
8787 wrap_panic(&mut || result = {
8788 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8789 let this = &*(this as *const D::Window);
8790 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8791 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8792 } else {
8793 None
8794 };
8795 let result: () = this.SetOnloadeddata(arg0);
8796
8797 true
8798 });
8799 result
8800}
8801
8802
8803static onloadeddata_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8804
8805pub(crate) fn init_onloadeddata_getterinfo<D: DomTypes>() {
8806 onloadeddata_getterinfo.set(JSJitInfo {
8807 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8808 getter: Some(get_onloadeddata::<D>)
8809 },
8810 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8811 protoID: PrototypeList::ID::Window as u16,
8812 },
8813 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8814 _bitfield_align_1: [],
8815 _bitfield_1: __BindgenBitfieldUnit::new(
8816 new_jsjitinfo_bitfield_1!(
8817 JSJitInfo_OpType::Getter as u8,
8818 JSJitInfo_AliasSet::AliasEverything as u8,
8819 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8820 true,
8821 false,
8822 false,
8823 false,
8824 false,
8825 false,
8826 0,
8827 ).to_ne_bytes()
8828 ),
8829});
8830}
8831static onloadeddata_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8832
8833pub(crate) fn init_onloadeddata_setterinfo<D: DomTypes>() {
8834 onloadeddata_setterinfo.set(JSJitInfo {
8835 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8836 setter: Some(set_onloadeddata::<D>)
8837 },
8838 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8839 protoID: PrototypeList::ID::Window as u16,
8840 },
8841 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8842 _bitfield_align_1: [],
8843 _bitfield_1: __BindgenBitfieldUnit::new(
8844 new_jsjitinfo_bitfield_1!(
8845 JSJitInfo_OpType::Setter as u8,
8846 JSJitInfo_AliasSet::AliasEverything as u8,
8847 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8848 false,
8849 false,
8850 false,
8851 false,
8852 false,
8853 false,
8854 0,
8855 ).to_ne_bytes()
8856 ),
8857});
8858}
8859unsafe extern "C" fn get_onloadedmetadata<D: DomTypes>
8860(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8861 let mut result = false;
8862 wrap_panic(&mut || result = (|| {
8863 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8864 let this = &*(this as *const D::Window);
8865 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnloadedmetadata();
8866
8867 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8868 return true;
8869 })());
8870 result
8871}
8872
8873unsafe extern "C" fn set_onloadedmetadata<D: DomTypes>
8874(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8875 let mut result = false;
8876 wrap_panic(&mut || result = {
8877 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8878 let this = &*(this as *const D::Window);
8879 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8880 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8881 } else {
8882 None
8883 };
8884 let result: () = this.SetOnloadedmetadata(arg0);
8885
8886 true
8887 });
8888 result
8889}
8890
8891
8892static onloadedmetadata_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8893
8894pub(crate) fn init_onloadedmetadata_getterinfo<D: DomTypes>() {
8895 onloadedmetadata_getterinfo.set(JSJitInfo {
8896 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8897 getter: Some(get_onloadedmetadata::<D>)
8898 },
8899 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8900 protoID: PrototypeList::ID::Window as u16,
8901 },
8902 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8903 _bitfield_align_1: [],
8904 _bitfield_1: __BindgenBitfieldUnit::new(
8905 new_jsjitinfo_bitfield_1!(
8906 JSJitInfo_OpType::Getter as u8,
8907 JSJitInfo_AliasSet::AliasEverything as u8,
8908 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8909 true,
8910 false,
8911 false,
8912 false,
8913 false,
8914 false,
8915 0,
8916 ).to_ne_bytes()
8917 ),
8918});
8919}
8920static onloadedmetadata_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8921
8922pub(crate) fn init_onloadedmetadata_setterinfo<D: DomTypes>() {
8923 onloadedmetadata_setterinfo.set(JSJitInfo {
8924 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8925 setter: Some(set_onloadedmetadata::<D>)
8926 },
8927 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8928 protoID: PrototypeList::ID::Window as u16,
8929 },
8930 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8931 _bitfield_align_1: [],
8932 _bitfield_1: __BindgenBitfieldUnit::new(
8933 new_jsjitinfo_bitfield_1!(
8934 JSJitInfo_OpType::Setter as u8,
8935 JSJitInfo_AliasSet::AliasEverything as u8,
8936 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8937 false,
8938 false,
8939 false,
8940 false,
8941 false,
8942 false,
8943 0,
8944 ).to_ne_bytes()
8945 ),
8946});
8947}
8948unsafe extern "C" fn get_onloadstart<D: DomTypes>
8949(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8950 let mut result = false;
8951 wrap_panic(&mut || result = (|| {
8952 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8953 let this = &*(this as *const D::Window);
8954 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnloadstart();
8955
8956 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8957 return true;
8958 })());
8959 result
8960}
8961
8962unsafe extern "C" fn set_onloadstart<D: DomTypes>
8963(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8964 let mut result = false;
8965 wrap_panic(&mut || result = {
8966 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8967 let this = &*(this as *const D::Window);
8968 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8969 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8970 } else {
8971 None
8972 };
8973 let result: () = this.SetOnloadstart(arg0);
8974
8975 true
8976 });
8977 result
8978}
8979
8980
8981static onloadstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8982
8983pub(crate) fn init_onloadstart_getterinfo<D: DomTypes>() {
8984 onloadstart_getterinfo.set(JSJitInfo {
8985 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8986 getter: Some(get_onloadstart::<D>)
8987 },
8988 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8989 protoID: PrototypeList::ID::Window as u16,
8990 },
8991 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8992 _bitfield_align_1: [],
8993 _bitfield_1: __BindgenBitfieldUnit::new(
8994 new_jsjitinfo_bitfield_1!(
8995 JSJitInfo_OpType::Getter as u8,
8996 JSJitInfo_AliasSet::AliasEverything as u8,
8997 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8998 true,
8999 false,
9000 false,
9001 false,
9002 false,
9003 false,
9004 0,
9005 ).to_ne_bytes()
9006 ),
9007});
9008}
9009static onloadstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9010
9011pub(crate) fn init_onloadstart_setterinfo<D: DomTypes>() {
9012 onloadstart_setterinfo.set(JSJitInfo {
9013 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9014 setter: Some(set_onloadstart::<D>)
9015 },
9016 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9017 protoID: PrototypeList::ID::Window as u16,
9018 },
9019 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9020 _bitfield_align_1: [],
9021 _bitfield_1: __BindgenBitfieldUnit::new(
9022 new_jsjitinfo_bitfield_1!(
9023 JSJitInfo_OpType::Setter as u8,
9024 JSJitInfo_AliasSet::AliasEverything as u8,
9025 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9026 false,
9027 false,
9028 false,
9029 false,
9030 false,
9031 false,
9032 0,
9033 ).to_ne_bytes()
9034 ),
9035});
9036}
9037unsafe extern "C" fn get_onmousedown<D: DomTypes>
9038(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9039 let mut result = false;
9040 wrap_panic(&mut || result = (|| {
9041 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9042 let this = &*(this as *const D::Window);
9043 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmousedown();
9044
9045 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9046 return true;
9047 })());
9048 result
9049}
9050
9051unsafe extern "C" fn set_onmousedown<D: DomTypes>
9052(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9053 let mut result = false;
9054 wrap_panic(&mut || result = {
9055 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9056 let this = &*(this as *const D::Window);
9057 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9058 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9059 } else {
9060 None
9061 };
9062 let result: () = this.SetOnmousedown(arg0);
9063
9064 true
9065 });
9066 result
9067}
9068
9069
9070static onmousedown_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9071
9072pub(crate) fn init_onmousedown_getterinfo<D: DomTypes>() {
9073 onmousedown_getterinfo.set(JSJitInfo {
9074 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9075 getter: Some(get_onmousedown::<D>)
9076 },
9077 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9078 protoID: PrototypeList::ID::Window as u16,
9079 },
9080 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9081 _bitfield_align_1: [],
9082 _bitfield_1: __BindgenBitfieldUnit::new(
9083 new_jsjitinfo_bitfield_1!(
9084 JSJitInfo_OpType::Getter as u8,
9085 JSJitInfo_AliasSet::AliasEverything as u8,
9086 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9087 true,
9088 false,
9089 false,
9090 false,
9091 false,
9092 false,
9093 0,
9094 ).to_ne_bytes()
9095 ),
9096});
9097}
9098static onmousedown_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9099
9100pub(crate) fn init_onmousedown_setterinfo<D: DomTypes>() {
9101 onmousedown_setterinfo.set(JSJitInfo {
9102 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9103 setter: Some(set_onmousedown::<D>)
9104 },
9105 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9106 protoID: PrototypeList::ID::Window as u16,
9107 },
9108 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9109 _bitfield_align_1: [],
9110 _bitfield_1: __BindgenBitfieldUnit::new(
9111 new_jsjitinfo_bitfield_1!(
9112 JSJitInfo_OpType::Setter as u8,
9113 JSJitInfo_AliasSet::AliasEverything as u8,
9114 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9115 false,
9116 false,
9117 false,
9118 false,
9119 false,
9120 false,
9121 0,
9122 ).to_ne_bytes()
9123 ),
9124});
9125}
9126unsafe extern "C" fn get_onmouseenter<D: DomTypes>
9127(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9128 let mut result = false;
9129 wrap_panic(&mut || result = (|| {
9130 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9131 let this = &*(this as *const D::Window);
9132 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseenter();
9133
9134 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9135 return true;
9136 })());
9137 result
9138}
9139
9140unsafe extern "C" fn set_onmouseenter<D: DomTypes>
9141(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9142 let mut result = false;
9143 wrap_panic(&mut || result = {
9144 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9145 let this = &*(this as *const D::Window);
9146 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9147 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9148 } else {
9149 None
9150 };
9151 let result: () = this.SetOnmouseenter(arg0);
9152
9153 true
9154 });
9155 result
9156}
9157
9158
9159static onmouseenter_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9160
9161pub(crate) fn init_onmouseenter_getterinfo<D: DomTypes>() {
9162 onmouseenter_getterinfo.set(JSJitInfo {
9163 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9164 getter: Some(get_onmouseenter::<D>)
9165 },
9166 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9167 protoID: PrototypeList::ID::Window as u16,
9168 },
9169 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9170 _bitfield_align_1: [],
9171 _bitfield_1: __BindgenBitfieldUnit::new(
9172 new_jsjitinfo_bitfield_1!(
9173 JSJitInfo_OpType::Getter as u8,
9174 JSJitInfo_AliasSet::AliasEverything as u8,
9175 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9176 true,
9177 false,
9178 false,
9179 false,
9180 false,
9181 false,
9182 0,
9183 ).to_ne_bytes()
9184 ),
9185});
9186}
9187static onmouseenter_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9188
9189pub(crate) fn init_onmouseenter_setterinfo<D: DomTypes>() {
9190 onmouseenter_setterinfo.set(JSJitInfo {
9191 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9192 setter: Some(set_onmouseenter::<D>)
9193 },
9194 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9195 protoID: PrototypeList::ID::Window as u16,
9196 },
9197 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9198 _bitfield_align_1: [],
9199 _bitfield_1: __BindgenBitfieldUnit::new(
9200 new_jsjitinfo_bitfield_1!(
9201 JSJitInfo_OpType::Setter as u8,
9202 JSJitInfo_AliasSet::AliasEverything as u8,
9203 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9204 false,
9205 false,
9206 false,
9207 false,
9208 false,
9209 false,
9210 0,
9211 ).to_ne_bytes()
9212 ),
9213});
9214}
9215unsafe extern "C" fn get_onmouseleave<D: DomTypes>
9216(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9217 let mut result = false;
9218 wrap_panic(&mut || result = (|| {
9219 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9220 let this = &*(this as *const D::Window);
9221 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseleave();
9222
9223 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9224 return true;
9225 })());
9226 result
9227}
9228
9229unsafe extern "C" fn set_onmouseleave<D: DomTypes>
9230(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9231 let mut result = false;
9232 wrap_panic(&mut || result = {
9233 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9234 let this = &*(this as *const D::Window);
9235 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9236 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9237 } else {
9238 None
9239 };
9240 let result: () = this.SetOnmouseleave(arg0);
9241
9242 true
9243 });
9244 result
9245}
9246
9247
9248static onmouseleave_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9249
9250pub(crate) fn init_onmouseleave_getterinfo<D: DomTypes>() {
9251 onmouseleave_getterinfo.set(JSJitInfo {
9252 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9253 getter: Some(get_onmouseleave::<D>)
9254 },
9255 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9256 protoID: PrototypeList::ID::Window as u16,
9257 },
9258 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9259 _bitfield_align_1: [],
9260 _bitfield_1: __BindgenBitfieldUnit::new(
9261 new_jsjitinfo_bitfield_1!(
9262 JSJitInfo_OpType::Getter as u8,
9263 JSJitInfo_AliasSet::AliasEverything as u8,
9264 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9265 true,
9266 false,
9267 false,
9268 false,
9269 false,
9270 false,
9271 0,
9272 ).to_ne_bytes()
9273 ),
9274});
9275}
9276static onmouseleave_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9277
9278pub(crate) fn init_onmouseleave_setterinfo<D: DomTypes>() {
9279 onmouseleave_setterinfo.set(JSJitInfo {
9280 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9281 setter: Some(set_onmouseleave::<D>)
9282 },
9283 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9284 protoID: PrototypeList::ID::Window as u16,
9285 },
9286 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9287 _bitfield_align_1: [],
9288 _bitfield_1: __BindgenBitfieldUnit::new(
9289 new_jsjitinfo_bitfield_1!(
9290 JSJitInfo_OpType::Setter as u8,
9291 JSJitInfo_AliasSet::AliasEverything as u8,
9292 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9293 false,
9294 false,
9295 false,
9296 false,
9297 false,
9298 false,
9299 0,
9300 ).to_ne_bytes()
9301 ),
9302});
9303}
9304unsafe extern "C" fn get_onmousemove<D: DomTypes>
9305(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9306 let mut result = false;
9307 wrap_panic(&mut || result = (|| {
9308 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9309 let this = &*(this as *const D::Window);
9310 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmousemove();
9311
9312 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9313 return true;
9314 })());
9315 result
9316}
9317
9318unsafe extern "C" fn set_onmousemove<D: DomTypes>
9319(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9320 let mut result = false;
9321 wrap_panic(&mut || result = {
9322 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9323 let this = &*(this as *const D::Window);
9324 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9325 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9326 } else {
9327 None
9328 };
9329 let result: () = this.SetOnmousemove(arg0);
9330
9331 true
9332 });
9333 result
9334}
9335
9336
9337static onmousemove_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9338
9339pub(crate) fn init_onmousemove_getterinfo<D: DomTypes>() {
9340 onmousemove_getterinfo.set(JSJitInfo {
9341 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9342 getter: Some(get_onmousemove::<D>)
9343 },
9344 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9345 protoID: PrototypeList::ID::Window as u16,
9346 },
9347 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9348 _bitfield_align_1: [],
9349 _bitfield_1: __BindgenBitfieldUnit::new(
9350 new_jsjitinfo_bitfield_1!(
9351 JSJitInfo_OpType::Getter as u8,
9352 JSJitInfo_AliasSet::AliasEverything as u8,
9353 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9354 true,
9355 false,
9356 false,
9357 false,
9358 false,
9359 false,
9360 0,
9361 ).to_ne_bytes()
9362 ),
9363});
9364}
9365static onmousemove_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9366
9367pub(crate) fn init_onmousemove_setterinfo<D: DomTypes>() {
9368 onmousemove_setterinfo.set(JSJitInfo {
9369 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9370 setter: Some(set_onmousemove::<D>)
9371 },
9372 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9373 protoID: PrototypeList::ID::Window as u16,
9374 },
9375 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9376 _bitfield_align_1: [],
9377 _bitfield_1: __BindgenBitfieldUnit::new(
9378 new_jsjitinfo_bitfield_1!(
9379 JSJitInfo_OpType::Setter as u8,
9380 JSJitInfo_AliasSet::AliasEverything as u8,
9381 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9382 false,
9383 false,
9384 false,
9385 false,
9386 false,
9387 false,
9388 0,
9389 ).to_ne_bytes()
9390 ),
9391});
9392}
9393unsafe extern "C" fn get_onmouseout<D: DomTypes>
9394(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9395 let mut result = false;
9396 wrap_panic(&mut || result = (|| {
9397 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9398 let this = &*(this as *const D::Window);
9399 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseout();
9400
9401 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9402 return true;
9403 })());
9404 result
9405}
9406
9407unsafe extern "C" fn set_onmouseout<D: DomTypes>
9408(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9409 let mut result = false;
9410 wrap_panic(&mut || result = {
9411 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9412 let this = &*(this as *const D::Window);
9413 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9414 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9415 } else {
9416 None
9417 };
9418 let result: () = this.SetOnmouseout(arg0);
9419
9420 true
9421 });
9422 result
9423}
9424
9425
9426static onmouseout_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9427
9428pub(crate) fn init_onmouseout_getterinfo<D: DomTypes>() {
9429 onmouseout_getterinfo.set(JSJitInfo {
9430 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9431 getter: Some(get_onmouseout::<D>)
9432 },
9433 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9434 protoID: PrototypeList::ID::Window as u16,
9435 },
9436 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9437 _bitfield_align_1: [],
9438 _bitfield_1: __BindgenBitfieldUnit::new(
9439 new_jsjitinfo_bitfield_1!(
9440 JSJitInfo_OpType::Getter as u8,
9441 JSJitInfo_AliasSet::AliasEverything as u8,
9442 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9443 true,
9444 false,
9445 false,
9446 false,
9447 false,
9448 false,
9449 0,
9450 ).to_ne_bytes()
9451 ),
9452});
9453}
9454static onmouseout_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9455
9456pub(crate) fn init_onmouseout_setterinfo<D: DomTypes>() {
9457 onmouseout_setterinfo.set(JSJitInfo {
9458 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9459 setter: Some(set_onmouseout::<D>)
9460 },
9461 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9462 protoID: PrototypeList::ID::Window as u16,
9463 },
9464 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9465 _bitfield_align_1: [],
9466 _bitfield_1: __BindgenBitfieldUnit::new(
9467 new_jsjitinfo_bitfield_1!(
9468 JSJitInfo_OpType::Setter as u8,
9469 JSJitInfo_AliasSet::AliasEverything as u8,
9470 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9471 false,
9472 false,
9473 false,
9474 false,
9475 false,
9476 false,
9477 0,
9478 ).to_ne_bytes()
9479 ),
9480});
9481}
9482unsafe extern "C" fn get_onmouseover<D: DomTypes>
9483(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9484 let mut result = false;
9485 wrap_panic(&mut || result = (|| {
9486 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9487 let this = &*(this as *const D::Window);
9488 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseover();
9489
9490 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9491 return true;
9492 })());
9493 result
9494}
9495
9496unsafe extern "C" fn set_onmouseover<D: DomTypes>
9497(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9498 let mut result = false;
9499 wrap_panic(&mut || result = {
9500 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9501 let this = &*(this as *const D::Window);
9502 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9503 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9504 } else {
9505 None
9506 };
9507 let result: () = this.SetOnmouseover(arg0);
9508
9509 true
9510 });
9511 result
9512}
9513
9514
9515static onmouseover_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9516
9517pub(crate) fn init_onmouseover_getterinfo<D: DomTypes>() {
9518 onmouseover_getterinfo.set(JSJitInfo {
9519 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9520 getter: Some(get_onmouseover::<D>)
9521 },
9522 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9523 protoID: PrototypeList::ID::Window as u16,
9524 },
9525 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9526 _bitfield_align_1: [],
9527 _bitfield_1: __BindgenBitfieldUnit::new(
9528 new_jsjitinfo_bitfield_1!(
9529 JSJitInfo_OpType::Getter as u8,
9530 JSJitInfo_AliasSet::AliasEverything as u8,
9531 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9532 true,
9533 false,
9534 false,
9535 false,
9536 false,
9537 false,
9538 0,
9539 ).to_ne_bytes()
9540 ),
9541});
9542}
9543static onmouseover_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9544
9545pub(crate) fn init_onmouseover_setterinfo<D: DomTypes>() {
9546 onmouseover_setterinfo.set(JSJitInfo {
9547 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9548 setter: Some(set_onmouseover::<D>)
9549 },
9550 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9551 protoID: PrototypeList::ID::Window as u16,
9552 },
9553 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9554 _bitfield_align_1: [],
9555 _bitfield_1: __BindgenBitfieldUnit::new(
9556 new_jsjitinfo_bitfield_1!(
9557 JSJitInfo_OpType::Setter as u8,
9558 JSJitInfo_AliasSet::AliasEverything as u8,
9559 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9560 false,
9561 false,
9562 false,
9563 false,
9564 false,
9565 false,
9566 0,
9567 ).to_ne_bytes()
9568 ),
9569});
9570}
9571unsafe extern "C" fn get_onmouseup<D: DomTypes>
9572(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9573 let mut result = false;
9574 wrap_panic(&mut || result = (|| {
9575 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9576 let this = &*(this as *const D::Window);
9577 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseup();
9578
9579 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9580 return true;
9581 })());
9582 result
9583}
9584
9585unsafe extern "C" fn set_onmouseup<D: DomTypes>
9586(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9587 let mut result = false;
9588 wrap_panic(&mut || result = {
9589 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9590 let this = &*(this as *const D::Window);
9591 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9592 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9593 } else {
9594 None
9595 };
9596 let result: () = this.SetOnmouseup(arg0);
9597
9598 true
9599 });
9600 result
9601}
9602
9603
9604static onmouseup_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9605
9606pub(crate) fn init_onmouseup_getterinfo<D: DomTypes>() {
9607 onmouseup_getterinfo.set(JSJitInfo {
9608 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9609 getter: Some(get_onmouseup::<D>)
9610 },
9611 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9612 protoID: PrototypeList::ID::Window as u16,
9613 },
9614 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9615 _bitfield_align_1: [],
9616 _bitfield_1: __BindgenBitfieldUnit::new(
9617 new_jsjitinfo_bitfield_1!(
9618 JSJitInfo_OpType::Getter as u8,
9619 JSJitInfo_AliasSet::AliasEverything as u8,
9620 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9621 true,
9622 false,
9623 false,
9624 false,
9625 false,
9626 false,
9627 0,
9628 ).to_ne_bytes()
9629 ),
9630});
9631}
9632static onmouseup_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9633
9634pub(crate) fn init_onmouseup_setterinfo<D: DomTypes>() {
9635 onmouseup_setterinfo.set(JSJitInfo {
9636 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9637 setter: Some(set_onmouseup::<D>)
9638 },
9639 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9640 protoID: PrototypeList::ID::Window as u16,
9641 },
9642 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9643 _bitfield_align_1: [],
9644 _bitfield_1: __BindgenBitfieldUnit::new(
9645 new_jsjitinfo_bitfield_1!(
9646 JSJitInfo_OpType::Setter as u8,
9647 JSJitInfo_AliasSet::AliasEverything as u8,
9648 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9649 false,
9650 false,
9651 false,
9652 false,
9653 false,
9654 false,
9655 0,
9656 ).to_ne_bytes()
9657 ),
9658});
9659}
9660unsafe extern "C" fn get_onpaste<D: DomTypes>
9661(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9662 let mut result = false;
9663 wrap_panic(&mut || result = (|| {
9664 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9665 let this = &*(this as *const D::Window);
9666 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpaste();
9667
9668 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9669 return true;
9670 })());
9671 result
9672}
9673
9674unsafe extern "C" fn set_onpaste<D: DomTypes>
9675(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9676 let mut result = false;
9677 wrap_panic(&mut || result = {
9678 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9679 let this = &*(this as *const D::Window);
9680 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9681 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9682 } else {
9683 None
9684 };
9685 let result: () = this.SetOnpaste(arg0);
9686
9687 true
9688 });
9689 result
9690}
9691
9692
9693static onpaste_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9694
9695pub(crate) fn init_onpaste_getterinfo<D: DomTypes>() {
9696 onpaste_getterinfo.set(JSJitInfo {
9697 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9698 getter: Some(get_onpaste::<D>)
9699 },
9700 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9701 protoID: PrototypeList::ID::Window as u16,
9702 },
9703 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9704 _bitfield_align_1: [],
9705 _bitfield_1: __BindgenBitfieldUnit::new(
9706 new_jsjitinfo_bitfield_1!(
9707 JSJitInfo_OpType::Getter as u8,
9708 JSJitInfo_AliasSet::AliasEverything as u8,
9709 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9710 true,
9711 false,
9712 false,
9713 false,
9714 false,
9715 false,
9716 0,
9717 ).to_ne_bytes()
9718 ),
9719});
9720}
9721static onpaste_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9722
9723pub(crate) fn init_onpaste_setterinfo<D: DomTypes>() {
9724 onpaste_setterinfo.set(JSJitInfo {
9725 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9726 setter: Some(set_onpaste::<D>)
9727 },
9728 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9729 protoID: PrototypeList::ID::Window as u16,
9730 },
9731 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9732 _bitfield_align_1: [],
9733 _bitfield_1: __BindgenBitfieldUnit::new(
9734 new_jsjitinfo_bitfield_1!(
9735 JSJitInfo_OpType::Setter as u8,
9736 JSJitInfo_AliasSet::AliasEverything as u8,
9737 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9738 false,
9739 false,
9740 false,
9741 false,
9742 false,
9743 false,
9744 0,
9745 ).to_ne_bytes()
9746 ),
9747});
9748}
9749unsafe extern "C" fn get_onpause<D: DomTypes>
9750(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9751 let mut result = false;
9752 wrap_panic(&mut || result = (|| {
9753 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9754 let this = &*(this as *const D::Window);
9755 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpause();
9756
9757 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9758 return true;
9759 })());
9760 result
9761}
9762
9763unsafe extern "C" fn set_onpause<D: DomTypes>
9764(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9765 let mut result = false;
9766 wrap_panic(&mut || result = {
9767 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9768 let this = &*(this as *const D::Window);
9769 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9770 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9771 } else {
9772 None
9773 };
9774 let result: () = this.SetOnpause(arg0);
9775
9776 true
9777 });
9778 result
9779}
9780
9781
9782static onpause_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9783
9784pub(crate) fn init_onpause_getterinfo<D: DomTypes>() {
9785 onpause_getterinfo.set(JSJitInfo {
9786 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9787 getter: Some(get_onpause::<D>)
9788 },
9789 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9790 protoID: PrototypeList::ID::Window as u16,
9791 },
9792 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9793 _bitfield_align_1: [],
9794 _bitfield_1: __BindgenBitfieldUnit::new(
9795 new_jsjitinfo_bitfield_1!(
9796 JSJitInfo_OpType::Getter as u8,
9797 JSJitInfo_AliasSet::AliasEverything as u8,
9798 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9799 true,
9800 false,
9801 false,
9802 false,
9803 false,
9804 false,
9805 0,
9806 ).to_ne_bytes()
9807 ),
9808});
9809}
9810static onpause_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9811
9812pub(crate) fn init_onpause_setterinfo<D: DomTypes>() {
9813 onpause_setterinfo.set(JSJitInfo {
9814 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9815 setter: Some(set_onpause::<D>)
9816 },
9817 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9818 protoID: PrototypeList::ID::Window as u16,
9819 },
9820 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9821 _bitfield_align_1: [],
9822 _bitfield_1: __BindgenBitfieldUnit::new(
9823 new_jsjitinfo_bitfield_1!(
9824 JSJitInfo_OpType::Setter as u8,
9825 JSJitInfo_AliasSet::AliasEverything as u8,
9826 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9827 false,
9828 false,
9829 false,
9830 false,
9831 false,
9832 false,
9833 0,
9834 ).to_ne_bytes()
9835 ),
9836});
9837}
9838unsafe extern "C" fn get_onplay<D: DomTypes>
9839(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9840 let mut result = false;
9841 wrap_panic(&mut || result = (|| {
9842 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9843 let this = &*(this as *const D::Window);
9844 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnplay();
9845
9846 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9847 return true;
9848 })());
9849 result
9850}
9851
9852unsafe extern "C" fn set_onplay<D: DomTypes>
9853(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9854 let mut result = false;
9855 wrap_panic(&mut || result = {
9856 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9857 let this = &*(this as *const D::Window);
9858 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9859 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9860 } else {
9861 None
9862 };
9863 let result: () = this.SetOnplay(arg0);
9864
9865 true
9866 });
9867 result
9868}
9869
9870
9871static onplay_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9872
9873pub(crate) fn init_onplay_getterinfo<D: DomTypes>() {
9874 onplay_getterinfo.set(JSJitInfo {
9875 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9876 getter: Some(get_onplay::<D>)
9877 },
9878 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9879 protoID: PrototypeList::ID::Window as u16,
9880 },
9881 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9882 _bitfield_align_1: [],
9883 _bitfield_1: __BindgenBitfieldUnit::new(
9884 new_jsjitinfo_bitfield_1!(
9885 JSJitInfo_OpType::Getter as u8,
9886 JSJitInfo_AliasSet::AliasEverything as u8,
9887 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9888 true,
9889 false,
9890 false,
9891 false,
9892 false,
9893 false,
9894 0,
9895 ).to_ne_bytes()
9896 ),
9897});
9898}
9899static onplay_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9900
9901pub(crate) fn init_onplay_setterinfo<D: DomTypes>() {
9902 onplay_setterinfo.set(JSJitInfo {
9903 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9904 setter: Some(set_onplay::<D>)
9905 },
9906 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9907 protoID: PrototypeList::ID::Window as u16,
9908 },
9909 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9910 _bitfield_align_1: [],
9911 _bitfield_1: __BindgenBitfieldUnit::new(
9912 new_jsjitinfo_bitfield_1!(
9913 JSJitInfo_OpType::Setter as u8,
9914 JSJitInfo_AliasSet::AliasEverything as u8,
9915 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9916 false,
9917 false,
9918 false,
9919 false,
9920 false,
9921 false,
9922 0,
9923 ).to_ne_bytes()
9924 ),
9925});
9926}
9927unsafe extern "C" fn get_onplaying<D: DomTypes>
9928(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9929 let mut result = false;
9930 wrap_panic(&mut || result = (|| {
9931 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9932 let this = &*(this as *const D::Window);
9933 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnplaying();
9934
9935 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9936 return true;
9937 })());
9938 result
9939}
9940
9941unsafe extern "C" fn set_onplaying<D: DomTypes>
9942(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9943 let mut result = false;
9944 wrap_panic(&mut || result = {
9945 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9946 let this = &*(this as *const D::Window);
9947 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9948 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9949 } else {
9950 None
9951 };
9952 let result: () = this.SetOnplaying(arg0);
9953
9954 true
9955 });
9956 result
9957}
9958
9959
9960static onplaying_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9961
9962pub(crate) fn init_onplaying_getterinfo<D: DomTypes>() {
9963 onplaying_getterinfo.set(JSJitInfo {
9964 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9965 getter: Some(get_onplaying::<D>)
9966 },
9967 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9968 protoID: PrototypeList::ID::Window as u16,
9969 },
9970 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9971 _bitfield_align_1: [],
9972 _bitfield_1: __BindgenBitfieldUnit::new(
9973 new_jsjitinfo_bitfield_1!(
9974 JSJitInfo_OpType::Getter as u8,
9975 JSJitInfo_AliasSet::AliasEverything as u8,
9976 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9977 true,
9978 false,
9979 false,
9980 false,
9981 false,
9982 false,
9983 0,
9984 ).to_ne_bytes()
9985 ),
9986});
9987}
9988static onplaying_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9989
9990pub(crate) fn init_onplaying_setterinfo<D: DomTypes>() {
9991 onplaying_setterinfo.set(JSJitInfo {
9992 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9993 setter: Some(set_onplaying::<D>)
9994 },
9995 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9996 protoID: PrototypeList::ID::Window as u16,
9997 },
9998 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9999 _bitfield_align_1: [],
10000 _bitfield_1: __BindgenBitfieldUnit::new(
10001 new_jsjitinfo_bitfield_1!(
10002 JSJitInfo_OpType::Setter as u8,
10003 JSJitInfo_AliasSet::AliasEverything as u8,
10004 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10005 false,
10006 false,
10007 false,
10008 false,
10009 false,
10010 false,
10011 0,
10012 ).to_ne_bytes()
10013 ),
10014});
10015}
10016unsafe extern "C" fn get_onprogress<D: DomTypes>
10017(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10018 let mut result = false;
10019 wrap_panic(&mut || result = (|| {
10020 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10021 let this = &*(this as *const D::Window);
10022 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnprogress();
10023
10024 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10025 return true;
10026 })());
10027 result
10028}
10029
10030unsafe extern "C" fn set_onprogress<D: DomTypes>
10031(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10032 let mut result = false;
10033 wrap_panic(&mut || result = {
10034 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10035 let this = &*(this as *const D::Window);
10036 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10037 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10038 } else {
10039 None
10040 };
10041 let result: () = this.SetOnprogress(arg0);
10042
10043 true
10044 });
10045 result
10046}
10047
10048
10049static onprogress_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10050
10051pub(crate) fn init_onprogress_getterinfo<D: DomTypes>() {
10052 onprogress_getterinfo.set(JSJitInfo {
10053 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10054 getter: Some(get_onprogress::<D>)
10055 },
10056 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10057 protoID: PrototypeList::ID::Window as u16,
10058 },
10059 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10060 _bitfield_align_1: [],
10061 _bitfield_1: __BindgenBitfieldUnit::new(
10062 new_jsjitinfo_bitfield_1!(
10063 JSJitInfo_OpType::Getter as u8,
10064 JSJitInfo_AliasSet::AliasEverything as u8,
10065 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10066 true,
10067 false,
10068 false,
10069 false,
10070 false,
10071 false,
10072 0,
10073 ).to_ne_bytes()
10074 ),
10075});
10076}
10077static onprogress_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10078
10079pub(crate) fn init_onprogress_setterinfo<D: DomTypes>() {
10080 onprogress_setterinfo.set(JSJitInfo {
10081 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10082 setter: Some(set_onprogress::<D>)
10083 },
10084 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10085 protoID: PrototypeList::ID::Window as u16,
10086 },
10087 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10088 _bitfield_align_1: [],
10089 _bitfield_1: __BindgenBitfieldUnit::new(
10090 new_jsjitinfo_bitfield_1!(
10091 JSJitInfo_OpType::Setter as u8,
10092 JSJitInfo_AliasSet::AliasEverything as u8,
10093 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10094 false,
10095 false,
10096 false,
10097 false,
10098 false,
10099 false,
10100 0,
10101 ).to_ne_bytes()
10102 ),
10103});
10104}
10105unsafe extern "C" fn get_onratechange<D: DomTypes>
10106(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10107 let mut result = false;
10108 wrap_panic(&mut || result = (|| {
10109 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10110 let this = &*(this as *const D::Window);
10111 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnratechange();
10112
10113 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10114 return true;
10115 })());
10116 result
10117}
10118
10119unsafe extern "C" fn set_onratechange<D: DomTypes>
10120(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10121 let mut result = false;
10122 wrap_panic(&mut || result = {
10123 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10124 let this = &*(this as *const D::Window);
10125 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10126 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10127 } else {
10128 None
10129 };
10130 let result: () = this.SetOnratechange(arg0);
10131
10132 true
10133 });
10134 result
10135}
10136
10137
10138static onratechange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10139
10140pub(crate) fn init_onratechange_getterinfo<D: DomTypes>() {
10141 onratechange_getterinfo.set(JSJitInfo {
10142 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10143 getter: Some(get_onratechange::<D>)
10144 },
10145 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10146 protoID: PrototypeList::ID::Window as u16,
10147 },
10148 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10149 _bitfield_align_1: [],
10150 _bitfield_1: __BindgenBitfieldUnit::new(
10151 new_jsjitinfo_bitfield_1!(
10152 JSJitInfo_OpType::Getter as u8,
10153 JSJitInfo_AliasSet::AliasEverything as u8,
10154 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10155 true,
10156 false,
10157 false,
10158 false,
10159 false,
10160 false,
10161 0,
10162 ).to_ne_bytes()
10163 ),
10164});
10165}
10166static onratechange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10167
10168pub(crate) fn init_onratechange_setterinfo<D: DomTypes>() {
10169 onratechange_setterinfo.set(JSJitInfo {
10170 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10171 setter: Some(set_onratechange::<D>)
10172 },
10173 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10174 protoID: PrototypeList::ID::Window as u16,
10175 },
10176 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10177 _bitfield_align_1: [],
10178 _bitfield_1: __BindgenBitfieldUnit::new(
10179 new_jsjitinfo_bitfield_1!(
10180 JSJitInfo_OpType::Setter as u8,
10181 JSJitInfo_AliasSet::AliasEverything as u8,
10182 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10183 false,
10184 false,
10185 false,
10186 false,
10187 false,
10188 false,
10189 0,
10190 ).to_ne_bytes()
10191 ),
10192});
10193}
10194unsafe extern "C" fn get_onreset<D: DomTypes>
10195(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10196 let mut result = false;
10197 wrap_panic(&mut || result = (|| {
10198 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10199 let this = &*(this as *const D::Window);
10200 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnreset();
10201
10202 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10203 return true;
10204 })());
10205 result
10206}
10207
10208unsafe extern "C" fn set_onreset<D: DomTypes>
10209(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10210 let mut result = false;
10211 wrap_panic(&mut || result = {
10212 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10213 let this = &*(this as *const D::Window);
10214 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10215 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10216 } else {
10217 None
10218 };
10219 let result: () = this.SetOnreset(arg0);
10220
10221 true
10222 });
10223 result
10224}
10225
10226
10227static onreset_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10228
10229pub(crate) fn init_onreset_getterinfo<D: DomTypes>() {
10230 onreset_getterinfo.set(JSJitInfo {
10231 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10232 getter: Some(get_onreset::<D>)
10233 },
10234 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10235 protoID: PrototypeList::ID::Window as u16,
10236 },
10237 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10238 _bitfield_align_1: [],
10239 _bitfield_1: __BindgenBitfieldUnit::new(
10240 new_jsjitinfo_bitfield_1!(
10241 JSJitInfo_OpType::Getter as u8,
10242 JSJitInfo_AliasSet::AliasEverything as u8,
10243 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10244 true,
10245 false,
10246 false,
10247 false,
10248 false,
10249 false,
10250 0,
10251 ).to_ne_bytes()
10252 ),
10253});
10254}
10255static onreset_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10256
10257pub(crate) fn init_onreset_setterinfo<D: DomTypes>() {
10258 onreset_setterinfo.set(JSJitInfo {
10259 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10260 setter: Some(set_onreset::<D>)
10261 },
10262 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10263 protoID: PrototypeList::ID::Window as u16,
10264 },
10265 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10266 _bitfield_align_1: [],
10267 _bitfield_1: __BindgenBitfieldUnit::new(
10268 new_jsjitinfo_bitfield_1!(
10269 JSJitInfo_OpType::Setter as u8,
10270 JSJitInfo_AliasSet::AliasEverything as u8,
10271 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10272 false,
10273 false,
10274 false,
10275 false,
10276 false,
10277 false,
10278 0,
10279 ).to_ne_bytes()
10280 ),
10281});
10282}
10283unsafe extern "C" fn get_onresize<D: DomTypes>
10284(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10285 let mut result = false;
10286 wrap_panic(&mut || result = (|| {
10287 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10288 let this = &*(this as *const D::Window);
10289 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnresize();
10290
10291 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10292 return true;
10293 })());
10294 result
10295}
10296
10297unsafe extern "C" fn set_onresize<D: DomTypes>
10298(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10299 let mut result = false;
10300 wrap_panic(&mut || result = {
10301 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10302 let this = &*(this as *const D::Window);
10303 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10304 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10305 } else {
10306 None
10307 };
10308 let result: () = this.SetOnresize(arg0);
10309
10310 true
10311 });
10312 result
10313}
10314
10315
10316static onresize_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10317
10318pub(crate) fn init_onresize_getterinfo<D: DomTypes>() {
10319 onresize_getterinfo.set(JSJitInfo {
10320 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10321 getter: Some(get_onresize::<D>)
10322 },
10323 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10324 protoID: PrototypeList::ID::Window as u16,
10325 },
10326 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10327 _bitfield_align_1: [],
10328 _bitfield_1: __BindgenBitfieldUnit::new(
10329 new_jsjitinfo_bitfield_1!(
10330 JSJitInfo_OpType::Getter as u8,
10331 JSJitInfo_AliasSet::AliasEverything as u8,
10332 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10333 true,
10334 false,
10335 false,
10336 false,
10337 false,
10338 false,
10339 0,
10340 ).to_ne_bytes()
10341 ),
10342});
10343}
10344static onresize_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10345
10346pub(crate) fn init_onresize_setterinfo<D: DomTypes>() {
10347 onresize_setterinfo.set(JSJitInfo {
10348 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10349 setter: Some(set_onresize::<D>)
10350 },
10351 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10352 protoID: PrototypeList::ID::Window as u16,
10353 },
10354 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10355 _bitfield_align_1: [],
10356 _bitfield_1: __BindgenBitfieldUnit::new(
10357 new_jsjitinfo_bitfield_1!(
10358 JSJitInfo_OpType::Setter as u8,
10359 JSJitInfo_AliasSet::AliasEverything as u8,
10360 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10361 false,
10362 false,
10363 false,
10364 false,
10365 false,
10366 false,
10367 0,
10368 ).to_ne_bytes()
10369 ),
10370});
10371}
10372unsafe extern "C" fn get_onscroll<D: DomTypes>
10373(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10374 let mut result = false;
10375 wrap_panic(&mut || result = (|| {
10376 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10377 let this = &*(this as *const D::Window);
10378 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnscroll();
10379
10380 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10381 return true;
10382 })());
10383 result
10384}
10385
10386unsafe extern "C" fn set_onscroll<D: DomTypes>
10387(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10388 let mut result = false;
10389 wrap_panic(&mut || result = {
10390 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10391 let this = &*(this as *const D::Window);
10392 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10393 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10394 } else {
10395 None
10396 };
10397 let result: () = this.SetOnscroll(arg0);
10398
10399 true
10400 });
10401 result
10402}
10403
10404
10405static onscroll_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10406
10407pub(crate) fn init_onscroll_getterinfo<D: DomTypes>() {
10408 onscroll_getterinfo.set(JSJitInfo {
10409 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10410 getter: Some(get_onscroll::<D>)
10411 },
10412 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10413 protoID: PrototypeList::ID::Window as u16,
10414 },
10415 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10416 _bitfield_align_1: [],
10417 _bitfield_1: __BindgenBitfieldUnit::new(
10418 new_jsjitinfo_bitfield_1!(
10419 JSJitInfo_OpType::Getter as u8,
10420 JSJitInfo_AliasSet::AliasEverything as u8,
10421 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10422 true,
10423 false,
10424 false,
10425 false,
10426 false,
10427 false,
10428 0,
10429 ).to_ne_bytes()
10430 ),
10431});
10432}
10433static onscroll_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10434
10435pub(crate) fn init_onscroll_setterinfo<D: DomTypes>() {
10436 onscroll_setterinfo.set(JSJitInfo {
10437 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10438 setter: Some(set_onscroll::<D>)
10439 },
10440 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10441 protoID: PrototypeList::ID::Window as u16,
10442 },
10443 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10444 _bitfield_align_1: [],
10445 _bitfield_1: __BindgenBitfieldUnit::new(
10446 new_jsjitinfo_bitfield_1!(
10447 JSJitInfo_OpType::Setter as u8,
10448 JSJitInfo_AliasSet::AliasEverything as u8,
10449 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10450 false,
10451 false,
10452 false,
10453 false,
10454 false,
10455 false,
10456 0,
10457 ).to_ne_bytes()
10458 ),
10459});
10460}
10461unsafe extern "C" fn get_onscrollend<D: DomTypes>
10462(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10463 let mut result = false;
10464 wrap_panic(&mut || result = (|| {
10465 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10466 let this = &*(this as *const D::Window);
10467 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnscrollend();
10468
10469 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10470 return true;
10471 })());
10472 result
10473}
10474
10475unsafe extern "C" fn set_onscrollend<D: DomTypes>
10476(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10477 let mut result = false;
10478 wrap_panic(&mut || result = {
10479 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10480 let this = &*(this as *const D::Window);
10481 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10482 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10483 } else {
10484 None
10485 };
10486 let result: () = this.SetOnscrollend(arg0);
10487
10488 true
10489 });
10490 result
10491}
10492
10493
10494static onscrollend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10495
10496pub(crate) fn init_onscrollend_getterinfo<D: DomTypes>() {
10497 onscrollend_getterinfo.set(JSJitInfo {
10498 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10499 getter: Some(get_onscrollend::<D>)
10500 },
10501 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10502 protoID: PrototypeList::ID::Window as u16,
10503 },
10504 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10505 _bitfield_align_1: [],
10506 _bitfield_1: __BindgenBitfieldUnit::new(
10507 new_jsjitinfo_bitfield_1!(
10508 JSJitInfo_OpType::Getter as u8,
10509 JSJitInfo_AliasSet::AliasEverything as u8,
10510 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10511 true,
10512 false,
10513 false,
10514 false,
10515 false,
10516 false,
10517 0,
10518 ).to_ne_bytes()
10519 ),
10520});
10521}
10522static onscrollend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10523
10524pub(crate) fn init_onscrollend_setterinfo<D: DomTypes>() {
10525 onscrollend_setterinfo.set(JSJitInfo {
10526 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10527 setter: Some(set_onscrollend::<D>)
10528 },
10529 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10530 protoID: PrototypeList::ID::Window as u16,
10531 },
10532 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10533 _bitfield_align_1: [],
10534 _bitfield_1: __BindgenBitfieldUnit::new(
10535 new_jsjitinfo_bitfield_1!(
10536 JSJitInfo_OpType::Setter as u8,
10537 JSJitInfo_AliasSet::AliasEverything as u8,
10538 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10539 false,
10540 false,
10541 false,
10542 false,
10543 false,
10544 false,
10545 0,
10546 ).to_ne_bytes()
10547 ),
10548});
10549}
10550unsafe extern "C" fn get_onsecuritypolicyviolation<D: DomTypes>
10551(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10552 let mut result = false;
10553 wrap_panic(&mut || result = (|| {
10554 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10555 let this = &*(this as *const D::Window);
10556 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnsecuritypolicyviolation();
10557
10558 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10559 return true;
10560 })());
10561 result
10562}
10563
10564unsafe extern "C" fn set_onsecuritypolicyviolation<D: DomTypes>
10565(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10566 let mut result = false;
10567 wrap_panic(&mut || result = {
10568 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10569 let this = &*(this as *const D::Window);
10570 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10571 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10572 } else {
10573 None
10574 };
10575 let result: () = this.SetOnsecuritypolicyviolation(arg0);
10576
10577 true
10578 });
10579 result
10580}
10581
10582
10583static onsecuritypolicyviolation_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10584
10585pub(crate) fn init_onsecuritypolicyviolation_getterinfo<D: DomTypes>() {
10586 onsecuritypolicyviolation_getterinfo.set(JSJitInfo {
10587 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10588 getter: Some(get_onsecuritypolicyviolation::<D>)
10589 },
10590 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10591 protoID: PrototypeList::ID::Window as u16,
10592 },
10593 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10594 _bitfield_align_1: [],
10595 _bitfield_1: __BindgenBitfieldUnit::new(
10596 new_jsjitinfo_bitfield_1!(
10597 JSJitInfo_OpType::Getter as u8,
10598 JSJitInfo_AliasSet::AliasEverything as u8,
10599 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10600 true,
10601 false,
10602 false,
10603 false,
10604 false,
10605 false,
10606 0,
10607 ).to_ne_bytes()
10608 ),
10609});
10610}
10611static onsecuritypolicyviolation_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10612
10613pub(crate) fn init_onsecuritypolicyviolation_setterinfo<D: DomTypes>() {
10614 onsecuritypolicyviolation_setterinfo.set(JSJitInfo {
10615 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10616 setter: Some(set_onsecuritypolicyviolation::<D>)
10617 },
10618 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10619 protoID: PrototypeList::ID::Window as u16,
10620 },
10621 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10622 _bitfield_align_1: [],
10623 _bitfield_1: __BindgenBitfieldUnit::new(
10624 new_jsjitinfo_bitfield_1!(
10625 JSJitInfo_OpType::Setter as u8,
10626 JSJitInfo_AliasSet::AliasEverything as u8,
10627 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10628 false,
10629 false,
10630 false,
10631 false,
10632 false,
10633 false,
10634 0,
10635 ).to_ne_bytes()
10636 ),
10637});
10638}
10639unsafe extern "C" fn get_onseeked<D: DomTypes>
10640(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10641 let mut result = false;
10642 wrap_panic(&mut || result = (|| {
10643 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10644 let this = &*(this as *const D::Window);
10645 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnseeked();
10646
10647 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10648 return true;
10649 })());
10650 result
10651}
10652
10653unsafe extern "C" fn set_onseeked<D: DomTypes>
10654(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10655 let mut result = false;
10656 wrap_panic(&mut || result = {
10657 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10658 let this = &*(this as *const D::Window);
10659 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10660 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10661 } else {
10662 None
10663 };
10664 let result: () = this.SetOnseeked(arg0);
10665
10666 true
10667 });
10668 result
10669}
10670
10671
10672static onseeked_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10673
10674pub(crate) fn init_onseeked_getterinfo<D: DomTypes>() {
10675 onseeked_getterinfo.set(JSJitInfo {
10676 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10677 getter: Some(get_onseeked::<D>)
10678 },
10679 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10680 protoID: PrototypeList::ID::Window as u16,
10681 },
10682 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10683 _bitfield_align_1: [],
10684 _bitfield_1: __BindgenBitfieldUnit::new(
10685 new_jsjitinfo_bitfield_1!(
10686 JSJitInfo_OpType::Getter as u8,
10687 JSJitInfo_AliasSet::AliasEverything as u8,
10688 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10689 true,
10690 false,
10691 false,
10692 false,
10693 false,
10694 false,
10695 0,
10696 ).to_ne_bytes()
10697 ),
10698});
10699}
10700static onseeked_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10701
10702pub(crate) fn init_onseeked_setterinfo<D: DomTypes>() {
10703 onseeked_setterinfo.set(JSJitInfo {
10704 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10705 setter: Some(set_onseeked::<D>)
10706 },
10707 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10708 protoID: PrototypeList::ID::Window as u16,
10709 },
10710 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10711 _bitfield_align_1: [],
10712 _bitfield_1: __BindgenBitfieldUnit::new(
10713 new_jsjitinfo_bitfield_1!(
10714 JSJitInfo_OpType::Setter as u8,
10715 JSJitInfo_AliasSet::AliasEverything as u8,
10716 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10717 false,
10718 false,
10719 false,
10720 false,
10721 false,
10722 false,
10723 0,
10724 ).to_ne_bytes()
10725 ),
10726});
10727}
10728unsafe extern "C" fn get_onseeking<D: DomTypes>
10729(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10730 let mut result = false;
10731 wrap_panic(&mut || result = (|| {
10732 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10733 let this = &*(this as *const D::Window);
10734 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnseeking();
10735
10736 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10737 return true;
10738 })());
10739 result
10740}
10741
10742unsafe extern "C" fn set_onseeking<D: DomTypes>
10743(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10744 let mut result = false;
10745 wrap_panic(&mut || result = {
10746 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10747 let this = &*(this as *const D::Window);
10748 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10749 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10750 } else {
10751 None
10752 };
10753 let result: () = this.SetOnseeking(arg0);
10754
10755 true
10756 });
10757 result
10758}
10759
10760
10761static onseeking_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10762
10763pub(crate) fn init_onseeking_getterinfo<D: DomTypes>() {
10764 onseeking_getterinfo.set(JSJitInfo {
10765 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10766 getter: Some(get_onseeking::<D>)
10767 },
10768 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10769 protoID: PrototypeList::ID::Window as u16,
10770 },
10771 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10772 _bitfield_align_1: [],
10773 _bitfield_1: __BindgenBitfieldUnit::new(
10774 new_jsjitinfo_bitfield_1!(
10775 JSJitInfo_OpType::Getter as u8,
10776 JSJitInfo_AliasSet::AliasEverything as u8,
10777 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10778 true,
10779 false,
10780 false,
10781 false,
10782 false,
10783 false,
10784 0,
10785 ).to_ne_bytes()
10786 ),
10787});
10788}
10789static onseeking_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10790
10791pub(crate) fn init_onseeking_setterinfo<D: DomTypes>() {
10792 onseeking_setterinfo.set(JSJitInfo {
10793 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10794 setter: Some(set_onseeking::<D>)
10795 },
10796 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10797 protoID: PrototypeList::ID::Window as u16,
10798 },
10799 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10800 _bitfield_align_1: [],
10801 _bitfield_1: __BindgenBitfieldUnit::new(
10802 new_jsjitinfo_bitfield_1!(
10803 JSJitInfo_OpType::Setter as u8,
10804 JSJitInfo_AliasSet::AliasEverything as u8,
10805 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10806 false,
10807 false,
10808 false,
10809 false,
10810 false,
10811 false,
10812 0,
10813 ).to_ne_bytes()
10814 ),
10815});
10816}
10817unsafe extern "C" fn get_onselect<D: DomTypes>
10818(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10819 let mut result = false;
10820 wrap_panic(&mut || result = (|| {
10821 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10822 let this = &*(this as *const D::Window);
10823 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnselect();
10824
10825 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10826 return true;
10827 })());
10828 result
10829}
10830
10831unsafe extern "C" fn set_onselect<D: DomTypes>
10832(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10833 let mut result = false;
10834 wrap_panic(&mut || result = {
10835 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10836 let this = &*(this as *const D::Window);
10837 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10838 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10839 } else {
10840 None
10841 };
10842 let result: () = this.SetOnselect(arg0);
10843
10844 true
10845 });
10846 result
10847}
10848
10849
10850static onselect_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10851
10852pub(crate) fn init_onselect_getterinfo<D: DomTypes>() {
10853 onselect_getterinfo.set(JSJitInfo {
10854 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10855 getter: Some(get_onselect::<D>)
10856 },
10857 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10858 protoID: PrototypeList::ID::Window as u16,
10859 },
10860 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10861 _bitfield_align_1: [],
10862 _bitfield_1: __BindgenBitfieldUnit::new(
10863 new_jsjitinfo_bitfield_1!(
10864 JSJitInfo_OpType::Getter as u8,
10865 JSJitInfo_AliasSet::AliasEverything as u8,
10866 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10867 true,
10868 false,
10869 false,
10870 false,
10871 false,
10872 false,
10873 0,
10874 ).to_ne_bytes()
10875 ),
10876});
10877}
10878static onselect_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10879
10880pub(crate) fn init_onselect_setterinfo<D: DomTypes>() {
10881 onselect_setterinfo.set(JSJitInfo {
10882 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10883 setter: Some(set_onselect::<D>)
10884 },
10885 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10886 protoID: PrototypeList::ID::Window as u16,
10887 },
10888 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10889 _bitfield_align_1: [],
10890 _bitfield_1: __BindgenBitfieldUnit::new(
10891 new_jsjitinfo_bitfield_1!(
10892 JSJitInfo_OpType::Setter as u8,
10893 JSJitInfo_AliasSet::AliasEverything as u8,
10894 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10895 false,
10896 false,
10897 false,
10898 false,
10899 false,
10900 false,
10901 0,
10902 ).to_ne_bytes()
10903 ),
10904});
10905}
10906unsafe extern "C" fn get_onslotchange<D: DomTypes>
10907(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10908 let mut result = false;
10909 wrap_panic(&mut || result = (|| {
10910 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10911 let this = &*(this as *const D::Window);
10912 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnslotchange();
10913
10914 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10915 return true;
10916 })());
10917 result
10918}
10919
10920unsafe extern "C" fn set_onslotchange<D: DomTypes>
10921(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10922 let mut result = false;
10923 wrap_panic(&mut || result = {
10924 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10925 let this = &*(this as *const D::Window);
10926 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10927 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10928 } else {
10929 None
10930 };
10931 let result: () = this.SetOnslotchange(arg0);
10932
10933 true
10934 });
10935 result
10936}
10937
10938
10939static onslotchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10940
10941pub(crate) fn init_onslotchange_getterinfo<D: DomTypes>() {
10942 onslotchange_getterinfo.set(JSJitInfo {
10943 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10944 getter: Some(get_onslotchange::<D>)
10945 },
10946 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10947 protoID: PrototypeList::ID::Window as u16,
10948 },
10949 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10950 _bitfield_align_1: [],
10951 _bitfield_1: __BindgenBitfieldUnit::new(
10952 new_jsjitinfo_bitfield_1!(
10953 JSJitInfo_OpType::Getter as u8,
10954 JSJitInfo_AliasSet::AliasEverything as u8,
10955 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10956 true,
10957 false,
10958 false,
10959 false,
10960 false,
10961 false,
10962 0,
10963 ).to_ne_bytes()
10964 ),
10965});
10966}
10967static onslotchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10968
10969pub(crate) fn init_onslotchange_setterinfo<D: DomTypes>() {
10970 onslotchange_setterinfo.set(JSJitInfo {
10971 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10972 setter: Some(set_onslotchange::<D>)
10973 },
10974 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10975 protoID: PrototypeList::ID::Window as u16,
10976 },
10977 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10978 _bitfield_align_1: [],
10979 _bitfield_1: __BindgenBitfieldUnit::new(
10980 new_jsjitinfo_bitfield_1!(
10981 JSJitInfo_OpType::Setter as u8,
10982 JSJitInfo_AliasSet::AliasEverything as u8,
10983 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10984 false,
10985 false,
10986 false,
10987 false,
10988 false,
10989 false,
10990 0,
10991 ).to_ne_bytes()
10992 ),
10993});
10994}
10995unsafe extern "C" fn get_onstalled<D: DomTypes>
10996(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10997 let mut result = false;
10998 wrap_panic(&mut || result = (|| {
10999 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11000 let this = &*(this as *const D::Window);
11001 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnstalled();
11002
11003 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11004 return true;
11005 })());
11006 result
11007}
11008
11009unsafe extern "C" fn set_onstalled<D: DomTypes>
11010(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11011 let mut result = false;
11012 wrap_panic(&mut || result = {
11013 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11014 let this = &*(this as *const D::Window);
11015 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11016 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11017 } else {
11018 None
11019 };
11020 let result: () = this.SetOnstalled(arg0);
11021
11022 true
11023 });
11024 result
11025}
11026
11027
11028static onstalled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11029
11030pub(crate) fn init_onstalled_getterinfo<D: DomTypes>() {
11031 onstalled_getterinfo.set(JSJitInfo {
11032 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11033 getter: Some(get_onstalled::<D>)
11034 },
11035 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11036 protoID: PrototypeList::ID::Window as u16,
11037 },
11038 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11039 _bitfield_align_1: [],
11040 _bitfield_1: __BindgenBitfieldUnit::new(
11041 new_jsjitinfo_bitfield_1!(
11042 JSJitInfo_OpType::Getter as u8,
11043 JSJitInfo_AliasSet::AliasEverything as u8,
11044 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11045 true,
11046 false,
11047 false,
11048 false,
11049 false,
11050 false,
11051 0,
11052 ).to_ne_bytes()
11053 ),
11054});
11055}
11056static onstalled_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11057
11058pub(crate) fn init_onstalled_setterinfo<D: DomTypes>() {
11059 onstalled_setterinfo.set(JSJitInfo {
11060 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11061 setter: Some(set_onstalled::<D>)
11062 },
11063 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11064 protoID: PrototypeList::ID::Window as u16,
11065 },
11066 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11067 _bitfield_align_1: [],
11068 _bitfield_1: __BindgenBitfieldUnit::new(
11069 new_jsjitinfo_bitfield_1!(
11070 JSJitInfo_OpType::Setter as u8,
11071 JSJitInfo_AliasSet::AliasEverything as u8,
11072 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11073 false,
11074 false,
11075 false,
11076 false,
11077 false,
11078 false,
11079 0,
11080 ).to_ne_bytes()
11081 ),
11082});
11083}
11084unsafe extern "C" fn get_onsubmit<D: DomTypes>
11085(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11086 let mut result = false;
11087 wrap_panic(&mut || result = (|| {
11088 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11089 let this = &*(this as *const D::Window);
11090 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnsubmit();
11091
11092 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11093 return true;
11094 })());
11095 result
11096}
11097
11098unsafe extern "C" fn set_onsubmit<D: DomTypes>
11099(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11100 let mut result = false;
11101 wrap_panic(&mut || result = {
11102 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11103 let this = &*(this as *const D::Window);
11104 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11105 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11106 } else {
11107 None
11108 };
11109 let result: () = this.SetOnsubmit(arg0);
11110
11111 true
11112 });
11113 result
11114}
11115
11116
11117static onsubmit_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11118
11119pub(crate) fn init_onsubmit_getterinfo<D: DomTypes>() {
11120 onsubmit_getterinfo.set(JSJitInfo {
11121 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11122 getter: Some(get_onsubmit::<D>)
11123 },
11124 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11125 protoID: PrototypeList::ID::Window as u16,
11126 },
11127 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11128 _bitfield_align_1: [],
11129 _bitfield_1: __BindgenBitfieldUnit::new(
11130 new_jsjitinfo_bitfield_1!(
11131 JSJitInfo_OpType::Getter as u8,
11132 JSJitInfo_AliasSet::AliasEverything as u8,
11133 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11134 true,
11135 false,
11136 false,
11137 false,
11138 false,
11139 false,
11140 0,
11141 ).to_ne_bytes()
11142 ),
11143});
11144}
11145static onsubmit_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11146
11147pub(crate) fn init_onsubmit_setterinfo<D: DomTypes>() {
11148 onsubmit_setterinfo.set(JSJitInfo {
11149 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11150 setter: Some(set_onsubmit::<D>)
11151 },
11152 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11153 protoID: PrototypeList::ID::Window as u16,
11154 },
11155 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11156 _bitfield_align_1: [],
11157 _bitfield_1: __BindgenBitfieldUnit::new(
11158 new_jsjitinfo_bitfield_1!(
11159 JSJitInfo_OpType::Setter as u8,
11160 JSJitInfo_AliasSet::AliasEverything as u8,
11161 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11162 false,
11163 false,
11164 false,
11165 false,
11166 false,
11167 false,
11168 0,
11169 ).to_ne_bytes()
11170 ),
11171});
11172}
11173unsafe extern "C" fn get_onsuspend<D: DomTypes>
11174(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11175 let mut result = false;
11176 wrap_panic(&mut || result = (|| {
11177 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11178 let this = &*(this as *const D::Window);
11179 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnsuspend();
11180
11181 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11182 return true;
11183 })());
11184 result
11185}
11186
11187unsafe extern "C" fn set_onsuspend<D: DomTypes>
11188(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11189 let mut result = false;
11190 wrap_panic(&mut || result = {
11191 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11192 let this = &*(this as *const D::Window);
11193 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11194 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11195 } else {
11196 None
11197 };
11198 let result: () = this.SetOnsuspend(arg0);
11199
11200 true
11201 });
11202 result
11203}
11204
11205
11206static onsuspend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11207
11208pub(crate) fn init_onsuspend_getterinfo<D: DomTypes>() {
11209 onsuspend_getterinfo.set(JSJitInfo {
11210 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11211 getter: Some(get_onsuspend::<D>)
11212 },
11213 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11214 protoID: PrototypeList::ID::Window as u16,
11215 },
11216 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11217 _bitfield_align_1: [],
11218 _bitfield_1: __BindgenBitfieldUnit::new(
11219 new_jsjitinfo_bitfield_1!(
11220 JSJitInfo_OpType::Getter as u8,
11221 JSJitInfo_AliasSet::AliasEverything as u8,
11222 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11223 true,
11224 false,
11225 false,
11226 false,
11227 false,
11228 false,
11229 0,
11230 ).to_ne_bytes()
11231 ),
11232});
11233}
11234static onsuspend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11235
11236pub(crate) fn init_onsuspend_setterinfo<D: DomTypes>() {
11237 onsuspend_setterinfo.set(JSJitInfo {
11238 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11239 setter: Some(set_onsuspend::<D>)
11240 },
11241 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11242 protoID: PrototypeList::ID::Window as u16,
11243 },
11244 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11245 _bitfield_align_1: [],
11246 _bitfield_1: __BindgenBitfieldUnit::new(
11247 new_jsjitinfo_bitfield_1!(
11248 JSJitInfo_OpType::Setter as u8,
11249 JSJitInfo_AliasSet::AliasEverything as u8,
11250 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11251 false,
11252 false,
11253 false,
11254 false,
11255 false,
11256 false,
11257 0,
11258 ).to_ne_bytes()
11259 ),
11260});
11261}
11262unsafe extern "C" fn get_ontimeupdate<D: DomTypes>
11263(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11264 let mut result = false;
11265 wrap_panic(&mut || result = (|| {
11266 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11267 let this = &*(this as *const D::Window);
11268 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntimeupdate();
11269
11270 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11271 return true;
11272 })());
11273 result
11274}
11275
11276unsafe extern "C" fn set_ontimeupdate<D: DomTypes>
11277(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11278 let mut result = false;
11279 wrap_panic(&mut || result = {
11280 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11281 let this = &*(this as *const D::Window);
11282 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11283 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11284 } else {
11285 None
11286 };
11287 let result: () = this.SetOntimeupdate(arg0);
11288
11289 true
11290 });
11291 result
11292}
11293
11294
11295static ontimeupdate_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11296
11297pub(crate) fn init_ontimeupdate_getterinfo<D: DomTypes>() {
11298 ontimeupdate_getterinfo.set(JSJitInfo {
11299 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11300 getter: Some(get_ontimeupdate::<D>)
11301 },
11302 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11303 protoID: PrototypeList::ID::Window as u16,
11304 },
11305 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11306 _bitfield_align_1: [],
11307 _bitfield_1: __BindgenBitfieldUnit::new(
11308 new_jsjitinfo_bitfield_1!(
11309 JSJitInfo_OpType::Getter as u8,
11310 JSJitInfo_AliasSet::AliasEverything as u8,
11311 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11312 true,
11313 false,
11314 false,
11315 false,
11316 false,
11317 false,
11318 0,
11319 ).to_ne_bytes()
11320 ),
11321});
11322}
11323static ontimeupdate_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11324
11325pub(crate) fn init_ontimeupdate_setterinfo<D: DomTypes>() {
11326 ontimeupdate_setterinfo.set(JSJitInfo {
11327 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11328 setter: Some(set_ontimeupdate::<D>)
11329 },
11330 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11331 protoID: PrototypeList::ID::Window as u16,
11332 },
11333 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11334 _bitfield_align_1: [],
11335 _bitfield_1: __BindgenBitfieldUnit::new(
11336 new_jsjitinfo_bitfield_1!(
11337 JSJitInfo_OpType::Setter as u8,
11338 JSJitInfo_AliasSet::AliasEverything as u8,
11339 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11340 false,
11341 false,
11342 false,
11343 false,
11344 false,
11345 false,
11346 0,
11347 ).to_ne_bytes()
11348 ),
11349});
11350}
11351unsafe extern "C" fn get_ontoggle<D: DomTypes>
11352(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11353 let mut result = false;
11354 wrap_panic(&mut || result = (|| {
11355 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11356 let this = &*(this as *const D::Window);
11357 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntoggle();
11358
11359 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11360 return true;
11361 })());
11362 result
11363}
11364
11365unsafe extern "C" fn set_ontoggle<D: DomTypes>
11366(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11367 let mut result = false;
11368 wrap_panic(&mut || result = {
11369 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11370 let this = &*(this as *const D::Window);
11371 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11372 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11373 } else {
11374 None
11375 };
11376 let result: () = this.SetOntoggle(arg0);
11377
11378 true
11379 });
11380 result
11381}
11382
11383
11384static ontoggle_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11385
11386pub(crate) fn init_ontoggle_getterinfo<D: DomTypes>() {
11387 ontoggle_getterinfo.set(JSJitInfo {
11388 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11389 getter: Some(get_ontoggle::<D>)
11390 },
11391 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11392 protoID: PrototypeList::ID::Window as u16,
11393 },
11394 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11395 _bitfield_align_1: [],
11396 _bitfield_1: __BindgenBitfieldUnit::new(
11397 new_jsjitinfo_bitfield_1!(
11398 JSJitInfo_OpType::Getter as u8,
11399 JSJitInfo_AliasSet::AliasEverything as u8,
11400 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11401 true,
11402 false,
11403 false,
11404 false,
11405 false,
11406 false,
11407 0,
11408 ).to_ne_bytes()
11409 ),
11410});
11411}
11412static ontoggle_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11413
11414pub(crate) fn init_ontoggle_setterinfo<D: DomTypes>() {
11415 ontoggle_setterinfo.set(JSJitInfo {
11416 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11417 setter: Some(set_ontoggle::<D>)
11418 },
11419 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11420 protoID: PrototypeList::ID::Window as u16,
11421 },
11422 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11423 _bitfield_align_1: [],
11424 _bitfield_1: __BindgenBitfieldUnit::new(
11425 new_jsjitinfo_bitfield_1!(
11426 JSJitInfo_OpType::Setter as u8,
11427 JSJitInfo_AliasSet::AliasEverything as u8,
11428 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11429 false,
11430 false,
11431 false,
11432 false,
11433 false,
11434 false,
11435 0,
11436 ).to_ne_bytes()
11437 ),
11438});
11439}
11440unsafe extern "C" fn get_onvolumechange<D: DomTypes>
11441(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11442 let mut result = false;
11443 wrap_panic(&mut || result = (|| {
11444 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11445 let this = &*(this as *const D::Window);
11446 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnvolumechange();
11447
11448 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11449 return true;
11450 })());
11451 result
11452}
11453
11454unsafe extern "C" fn set_onvolumechange<D: DomTypes>
11455(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11456 let mut result = false;
11457 wrap_panic(&mut || result = {
11458 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11459 let this = &*(this as *const D::Window);
11460 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11461 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11462 } else {
11463 None
11464 };
11465 let result: () = this.SetOnvolumechange(arg0);
11466
11467 true
11468 });
11469 result
11470}
11471
11472
11473static onvolumechange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11474
11475pub(crate) fn init_onvolumechange_getterinfo<D: DomTypes>() {
11476 onvolumechange_getterinfo.set(JSJitInfo {
11477 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11478 getter: Some(get_onvolumechange::<D>)
11479 },
11480 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11481 protoID: PrototypeList::ID::Window as u16,
11482 },
11483 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11484 _bitfield_align_1: [],
11485 _bitfield_1: __BindgenBitfieldUnit::new(
11486 new_jsjitinfo_bitfield_1!(
11487 JSJitInfo_OpType::Getter as u8,
11488 JSJitInfo_AliasSet::AliasEverything as u8,
11489 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11490 true,
11491 false,
11492 false,
11493 false,
11494 false,
11495 false,
11496 0,
11497 ).to_ne_bytes()
11498 ),
11499});
11500}
11501static onvolumechange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11502
11503pub(crate) fn init_onvolumechange_setterinfo<D: DomTypes>() {
11504 onvolumechange_setterinfo.set(JSJitInfo {
11505 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11506 setter: Some(set_onvolumechange::<D>)
11507 },
11508 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11509 protoID: PrototypeList::ID::Window as u16,
11510 },
11511 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11512 _bitfield_align_1: [],
11513 _bitfield_1: __BindgenBitfieldUnit::new(
11514 new_jsjitinfo_bitfield_1!(
11515 JSJitInfo_OpType::Setter as u8,
11516 JSJitInfo_AliasSet::AliasEverything as u8,
11517 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11518 false,
11519 false,
11520 false,
11521 false,
11522 false,
11523 false,
11524 0,
11525 ).to_ne_bytes()
11526 ),
11527});
11528}
11529unsafe extern "C" fn get_onwaiting<D: DomTypes>
11530(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11531 let mut result = false;
11532 wrap_panic(&mut || result = (|| {
11533 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11534 let this = &*(this as *const D::Window);
11535 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwaiting();
11536
11537 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11538 return true;
11539 })());
11540 result
11541}
11542
11543unsafe extern "C" fn set_onwaiting<D: DomTypes>
11544(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11545 let mut result = false;
11546 wrap_panic(&mut || result = {
11547 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11548 let this = &*(this as *const D::Window);
11549 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11550 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11551 } else {
11552 None
11553 };
11554 let result: () = this.SetOnwaiting(arg0);
11555
11556 true
11557 });
11558 result
11559}
11560
11561
11562static onwaiting_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11563
11564pub(crate) fn init_onwaiting_getterinfo<D: DomTypes>() {
11565 onwaiting_getterinfo.set(JSJitInfo {
11566 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11567 getter: Some(get_onwaiting::<D>)
11568 },
11569 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11570 protoID: PrototypeList::ID::Window as u16,
11571 },
11572 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11573 _bitfield_align_1: [],
11574 _bitfield_1: __BindgenBitfieldUnit::new(
11575 new_jsjitinfo_bitfield_1!(
11576 JSJitInfo_OpType::Getter as u8,
11577 JSJitInfo_AliasSet::AliasEverything as u8,
11578 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11579 true,
11580 false,
11581 false,
11582 false,
11583 false,
11584 false,
11585 0,
11586 ).to_ne_bytes()
11587 ),
11588});
11589}
11590static onwaiting_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11591
11592pub(crate) fn init_onwaiting_setterinfo<D: DomTypes>() {
11593 onwaiting_setterinfo.set(JSJitInfo {
11594 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11595 setter: Some(set_onwaiting::<D>)
11596 },
11597 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11598 protoID: PrototypeList::ID::Window as u16,
11599 },
11600 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11601 _bitfield_align_1: [],
11602 _bitfield_1: __BindgenBitfieldUnit::new(
11603 new_jsjitinfo_bitfield_1!(
11604 JSJitInfo_OpType::Setter as u8,
11605 JSJitInfo_AliasSet::AliasEverything as u8,
11606 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11607 false,
11608 false,
11609 false,
11610 false,
11611 false,
11612 false,
11613 0,
11614 ).to_ne_bytes()
11615 ),
11616});
11617}
11618unsafe extern "C" fn get_onwebkitanimationend<D: DomTypes>
11619(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11620 let mut result = false;
11621 wrap_panic(&mut || result = (|| {
11622 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11623 let this = &*(this as *const D::Window);
11624 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwebkitanimationend();
11625
11626 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11627 return true;
11628 })());
11629 result
11630}
11631
11632unsafe extern "C" fn set_onwebkitanimationend<D: DomTypes>
11633(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11634 let mut result = false;
11635 wrap_panic(&mut || result = {
11636 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11637 let this = &*(this as *const D::Window);
11638 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11639 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11640 } else {
11641 None
11642 };
11643 let result: () = this.SetOnwebkitanimationend(arg0);
11644
11645 true
11646 });
11647 result
11648}
11649
11650
11651static onwebkitanimationend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11652
11653pub(crate) fn init_onwebkitanimationend_getterinfo<D: DomTypes>() {
11654 onwebkitanimationend_getterinfo.set(JSJitInfo {
11655 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11656 getter: Some(get_onwebkitanimationend::<D>)
11657 },
11658 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11659 protoID: PrototypeList::ID::Window as u16,
11660 },
11661 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11662 _bitfield_align_1: [],
11663 _bitfield_1: __BindgenBitfieldUnit::new(
11664 new_jsjitinfo_bitfield_1!(
11665 JSJitInfo_OpType::Getter as u8,
11666 JSJitInfo_AliasSet::AliasEverything as u8,
11667 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11668 true,
11669 false,
11670 false,
11671 false,
11672 false,
11673 false,
11674 0,
11675 ).to_ne_bytes()
11676 ),
11677});
11678}
11679static onwebkitanimationend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11680
11681pub(crate) fn init_onwebkitanimationend_setterinfo<D: DomTypes>() {
11682 onwebkitanimationend_setterinfo.set(JSJitInfo {
11683 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11684 setter: Some(set_onwebkitanimationend::<D>)
11685 },
11686 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11687 protoID: PrototypeList::ID::Window as u16,
11688 },
11689 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11690 _bitfield_align_1: [],
11691 _bitfield_1: __BindgenBitfieldUnit::new(
11692 new_jsjitinfo_bitfield_1!(
11693 JSJitInfo_OpType::Setter as u8,
11694 JSJitInfo_AliasSet::AliasEverything as u8,
11695 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11696 false,
11697 false,
11698 false,
11699 false,
11700 false,
11701 false,
11702 0,
11703 ).to_ne_bytes()
11704 ),
11705});
11706}
11707unsafe extern "C" fn get_onwebkitanimationiteration<D: DomTypes>
11708(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11709 let mut result = false;
11710 wrap_panic(&mut || result = (|| {
11711 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11712 let this = &*(this as *const D::Window);
11713 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwebkitanimationiteration();
11714
11715 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11716 return true;
11717 })());
11718 result
11719}
11720
11721unsafe extern "C" fn set_onwebkitanimationiteration<D: DomTypes>
11722(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11723 let mut result = false;
11724 wrap_panic(&mut || result = {
11725 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11726 let this = &*(this as *const D::Window);
11727 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11728 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11729 } else {
11730 None
11731 };
11732 let result: () = this.SetOnwebkitanimationiteration(arg0);
11733
11734 true
11735 });
11736 result
11737}
11738
11739
11740static onwebkitanimationiteration_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11741
11742pub(crate) fn init_onwebkitanimationiteration_getterinfo<D: DomTypes>() {
11743 onwebkitanimationiteration_getterinfo.set(JSJitInfo {
11744 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11745 getter: Some(get_onwebkitanimationiteration::<D>)
11746 },
11747 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11748 protoID: PrototypeList::ID::Window as u16,
11749 },
11750 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11751 _bitfield_align_1: [],
11752 _bitfield_1: __BindgenBitfieldUnit::new(
11753 new_jsjitinfo_bitfield_1!(
11754 JSJitInfo_OpType::Getter as u8,
11755 JSJitInfo_AliasSet::AliasEverything as u8,
11756 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11757 true,
11758 false,
11759 false,
11760 false,
11761 false,
11762 false,
11763 0,
11764 ).to_ne_bytes()
11765 ),
11766});
11767}
11768static onwebkitanimationiteration_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11769
11770pub(crate) fn init_onwebkitanimationiteration_setterinfo<D: DomTypes>() {
11771 onwebkitanimationiteration_setterinfo.set(JSJitInfo {
11772 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11773 setter: Some(set_onwebkitanimationiteration::<D>)
11774 },
11775 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11776 protoID: PrototypeList::ID::Window as u16,
11777 },
11778 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11779 _bitfield_align_1: [],
11780 _bitfield_1: __BindgenBitfieldUnit::new(
11781 new_jsjitinfo_bitfield_1!(
11782 JSJitInfo_OpType::Setter as u8,
11783 JSJitInfo_AliasSet::AliasEverything as u8,
11784 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11785 false,
11786 false,
11787 false,
11788 false,
11789 false,
11790 false,
11791 0,
11792 ).to_ne_bytes()
11793 ),
11794});
11795}
11796unsafe extern "C" fn get_onwebkitanimationstart<D: DomTypes>
11797(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11798 let mut result = false;
11799 wrap_panic(&mut || result = (|| {
11800 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11801 let this = &*(this as *const D::Window);
11802 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwebkitanimationstart();
11803
11804 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11805 return true;
11806 })());
11807 result
11808}
11809
11810unsafe extern "C" fn set_onwebkitanimationstart<D: DomTypes>
11811(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11812 let mut result = false;
11813 wrap_panic(&mut || result = {
11814 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11815 let this = &*(this as *const D::Window);
11816 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11817 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11818 } else {
11819 None
11820 };
11821 let result: () = this.SetOnwebkitanimationstart(arg0);
11822
11823 true
11824 });
11825 result
11826}
11827
11828
11829static onwebkitanimationstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11830
11831pub(crate) fn init_onwebkitanimationstart_getterinfo<D: DomTypes>() {
11832 onwebkitanimationstart_getterinfo.set(JSJitInfo {
11833 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11834 getter: Some(get_onwebkitanimationstart::<D>)
11835 },
11836 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11837 protoID: PrototypeList::ID::Window as u16,
11838 },
11839 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11840 _bitfield_align_1: [],
11841 _bitfield_1: __BindgenBitfieldUnit::new(
11842 new_jsjitinfo_bitfield_1!(
11843 JSJitInfo_OpType::Getter as u8,
11844 JSJitInfo_AliasSet::AliasEverything as u8,
11845 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11846 true,
11847 false,
11848 false,
11849 false,
11850 false,
11851 false,
11852 0,
11853 ).to_ne_bytes()
11854 ),
11855});
11856}
11857static onwebkitanimationstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11858
11859pub(crate) fn init_onwebkitanimationstart_setterinfo<D: DomTypes>() {
11860 onwebkitanimationstart_setterinfo.set(JSJitInfo {
11861 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11862 setter: Some(set_onwebkitanimationstart::<D>)
11863 },
11864 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11865 protoID: PrototypeList::ID::Window as u16,
11866 },
11867 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11868 _bitfield_align_1: [],
11869 _bitfield_1: __BindgenBitfieldUnit::new(
11870 new_jsjitinfo_bitfield_1!(
11871 JSJitInfo_OpType::Setter as u8,
11872 JSJitInfo_AliasSet::AliasEverything as u8,
11873 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11874 false,
11875 false,
11876 false,
11877 false,
11878 false,
11879 false,
11880 0,
11881 ).to_ne_bytes()
11882 ),
11883});
11884}
11885unsafe extern "C" fn get_onwebkittransitionend<D: DomTypes>
11886(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11887 let mut result = false;
11888 wrap_panic(&mut || result = (|| {
11889 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11890 let this = &*(this as *const D::Window);
11891 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwebkittransitionend();
11892
11893 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11894 return true;
11895 })());
11896 result
11897}
11898
11899unsafe extern "C" fn set_onwebkittransitionend<D: DomTypes>
11900(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11901 let mut result = false;
11902 wrap_panic(&mut || result = {
11903 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11904 let this = &*(this as *const D::Window);
11905 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11906 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11907 } else {
11908 None
11909 };
11910 let result: () = this.SetOnwebkittransitionend(arg0);
11911
11912 true
11913 });
11914 result
11915}
11916
11917
11918static onwebkittransitionend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11919
11920pub(crate) fn init_onwebkittransitionend_getterinfo<D: DomTypes>() {
11921 onwebkittransitionend_getterinfo.set(JSJitInfo {
11922 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11923 getter: Some(get_onwebkittransitionend::<D>)
11924 },
11925 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11926 protoID: PrototypeList::ID::Window as u16,
11927 },
11928 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11929 _bitfield_align_1: [],
11930 _bitfield_1: __BindgenBitfieldUnit::new(
11931 new_jsjitinfo_bitfield_1!(
11932 JSJitInfo_OpType::Getter as u8,
11933 JSJitInfo_AliasSet::AliasEverything as u8,
11934 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11935 true,
11936 false,
11937 false,
11938 false,
11939 false,
11940 false,
11941 0,
11942 ).to_ne_bytes()
11943 ),
11944});
11945}
11946static onwebkittransitionend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11947
11948pub(crate) fn init_onwebkittransitionend_setterinfo<D: DomTypes>() {
11949 onwebkittransitionend_setterinfo.set(JSJitInfo {
11950 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11951 setter: Some(set_onwebkittransitionend::<D>)
11952 },
11953 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11954 protoID: PrototypeList::ID::Window as u16,
11955 },
11956 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11957 _bitfield_align_1: [],
11958 _bitfield_1: __BindgenBitfieldUnit::new(
11959 new_jsjitinfo_bitfield_1!(
11960 JSJitInfo_OpType::Setter as u8,
11961 JSJitInfo_AliasSet::AliasEverything as u8,
11962 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11963 false,
11964 false,
11965 false,
11966 false,
11967 false,
11968 false,
11969 0,
11970 ).to_ne_bytes()
11971 ),
11972});
11973}
11974unsafe extern "C" fn get_onwheel<D: DomTypes>
11975(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11976 let mut result = false;
11977 wrap_panic(&mut || result = (|| {
11978 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11979 let this = &*(this as *const D::Window);
11980 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwheel();
11981
11982 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11983 return true;
11984 })());
11985 result
11986}
11987
11988unsafe extern "C" fn set_onwheel<D: DomTypes>
11989(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11990 let mut result = false;
11991 wrap_panic(&mut || result = {
11992 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11993 let this = &*(this as *const D::Window);
11994 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11995 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11996 } else {
11997 None
11998 };
11999 let result: () = this.SetOnwheel(arg0);
12000
12001 true
12002 });
12003 result
12004}
12005
12006
12007static onwheel_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12008
12009pub(crate) fn init_onwheel_getterinfo<D: DomTypes>() {
12010 onwheel_getterinfo.set(JSJitInfo {
12011 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12012 getter: Some(get_onwheel::<D>)
12013 },
12014 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12015 protoID: PrototypeList::ID::Window as u16,
12016 },
12017 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12018 _bitfield_align_1: [],
12019 _bitfield_1: __BindgenBitfieldUnit::new(
12020 new_jsjitinfo_bitfield_1!(
12021 JSJitInfo_OpType::Getter as u8,
12022 JSJitInfo_AliasSet::AliasEverything as u8,
12023 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12024 true,
12025 false,
12026 false,
12027 false,
12028 false,
12029 false,
12030 0,
12031 ).to_ne_bytes()
12032 ),
12033});
12034}
12035static onwheel_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12036
12037pub(crate) fn init_onwheel_setterinfo<D: DomTypes>() {
12038 onwheel_setterinfo.set(JSJitInfo {
12039 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12040 setter: Some(set_onwheel::<D>)
12041 },
12042 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12043 protoID: PrototypeList::ID::Window as u16,
12044 },
12045 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12046 _bitfield_align_1: [],
12047 _bitfield_1: __BindgenBitfieldUnit::new(
12048 new_jsjitinfo_bitfield_1!(
12049 JSJitInfo_OpType::Setter as u8,
12050 JSJitInfo_AliasSet::AliasEverything as u8,
12051 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12052 false,
12053 false,
12054 false,
12055 false,
12056 false,
12057 false,
12058 0,
12059 ).to_ne_bytes()
12060 ),
12061});
12062}
12063unsafe extern "C" fn get_onanimationstart<D: DomTypes>
12064(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12065 let mut result = false;
12066 wrap_panic(&mut || result = (|| {
12067 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12068 let this = &*(this as *const D::Window);
12069 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnanimationstart();
12070
12071 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12072 return true;
12073 })());
12074 result
12075}
12076
12077unsafe extern "C" fn set_onanimationstart<D: DomTypes>
12078(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12079 let mut result = false;
12080 wrap_panic(&mut || result = {
12081 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12082 let this = &*(this as *const D::Window);
12083 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12084 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12085 } else {
12086 None
12087 };
12088 let result: () = this.SetOnanimationstart(arg0);
12089
12090 true
12091 });
12092 result
12093}
12094
12095
12096static onanimationstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12097
12098pub(crate) fn init_onanimationstart_getterinfo<D: DomTypes>() {
12099 onanimationstart_getterinfo.set(JSJitInfo {
12100 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12101 getter: Some(get_onanimationstart::<D>)
12102 },
12103 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12104 protoID: PrototypeList::ID::Window as u16,
12105 },
12106 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12107 _bitfield_align_1: [],
12108 _bitfield_1: __BindgenBitfieldUnit::new(
12109 new_jsjitinfo_bitfield_1!(
12110 JSJitInfo_OpType::Getter as u8,
12111 JSJitInfo_AliasSet::AliasEverything as u8,
12112 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12113 true,
12114 false,
12115 false,
12116 false,
12117 false,
12118 false,
12119 0,
12120 ).to_ne_bytes()
12121 ),
12122});
12123}
12124static onanimationstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12125
12126pub(crate) fn init_onanimationstart_setterinfo<D: DomTypes>() {
12127 onanimationstart_setterinfo.set(JSJitInfo {
12128 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12129 setter: Some(set_onanimationstart::<D>)
12130 },
12131 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12132 protoID: PrototypeList::ID::Window as u16,
12133 },
12134 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12135 _bitfield_align_1: [],
12136 _bitfield_1: __BindgenBitfieldUnit::new(
12137 new_jsjitinfo_bitfield_1!(
12138 JSJitInfo_OpType::Setter as u8,
12139 JSJitInfo_AliasSet::AliasEverything as u8,
12140 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12141 false,
12142 false,
12143 false,
12144 false,
12145 false,
12146 false,
12147 0,
12148 ).to_ne_bytes()
12149 ),
12150});
12151}
12152unsafe extern "C" fn get_onanimationiteration<D: DomTypes>
12153(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12154 let mut result = false;
12155 wrap_panic(&mut || result = (|| {
12156 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12157 let this = &*(this as *const D::Window);
12158 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnanimationiteration();
12159
12160 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12161 return true;
12162 })());
12163 result
12164}
12165
12166unsafe extern "C" fn set_onanimationiteration<D: DomTypes>
12167(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12168 let mut result = false;
12169 wrap_panic(&mut || result = {
12170 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12171 let this = &*(this as *const D::Window);
12172 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12173 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12174 } else {
12175 None
12176 };
12177 let result: () = this.SetOnanimationiteration(arg0);
12178
12179 true
12180 });
12181 result
12182}
12183
12184
12185static onanimationiteration_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12186
12187pub(crate) fn init_onanimationiteration_getterinfo<D: DomTypes>() {
12188 onanimationiteration_getterinfo.set(JSJitInfo {
12189 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12190 getter: Some(get_onanimationiteration::<D>)
12191 },
12192 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12193 protoID: PrototypeList::ID::Window as u16,
12194 },
12195 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12196 _bitfield_align_1: [],
12197 _bitfield_1: __BindgenBitfieldUnit::new(
12198 new_jsjitinfo_bitfield_1!(
12199 JSJitInfo_OpType::Getter as u8,
12200 JSJitInfo_AliasSet::AliasEverything as u8,
12201 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12202 true,
12203 false,
12204 false,
12205 false,
12206 false,
12207 false,
12208 0,
12209 ).to_ne_bytes()
12210 ),
12211});
12212}
12213static onanimationiteration_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12214
12215pub(crate) fn init_onanimationiteration_setterinfo<D: DomTypes>() {
12216 onanimationiteration_setterinfo.set(JSJitInfo {
12217 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12218 setter: Some(set_onanimationiteration::<D>)
12219 },
12220 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12221 protoID: PrototypeList::ID::Window as u16,
12222 },
12223 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12224 _bitfield_align_1: [],
12225 _bitfield_1: __BindgenBitfieldUnit::new(
12226 new_jsjitinfo_bitfield_1!(
12227 JSJitInfo_OpType::Setter as u8,
12228 JSJitInfo_AliasSet::AliasEverything as u8,
12229 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12230 false,
12231 false,
12232 false,
12233 false,
12234 false,
12235 false,
12236 0,
12237 ).to_ne_bytes()
12238 ),
12239});
12240}
12241unsafe extern "C" fn get_onanimationend<D: DomTypes>
12242(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12243 let mut result = false;
12244 wrap_panic(&mut || result = (|| {
12245 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12246 let this = &*(this as *const D::Window);
12247 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnanimationend();
12248
12249 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12250 return true;
12251 })());
12252 result
12253}
12254
12255unsafe extern "C" fn set_onanimationend<D: DomTypes>
12256(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12257 let mut result = false;
12258 wrap_panic(&mut || result = {
12259 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12260 let this = &*(this as *const D::Window);
12261 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12262 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12263 } else {
12264 None
12265 };
12266 let result: () = this.SetOnanimationend(arg0);
12267
12268 true
12269 });
12270 result
12271}
12272
12273
12274static onanimationend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12275
12276pub(crate) fn init_onanimationend_getterinfo<D: DomTypes>() {
12277 onanimationend_getterinfo.set(JSJitInfo {
12278 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12279 getter: Some(get_onanimationend::<D>)
12280 },
12281 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12282 protoID: PrototypeList::ID::Window as u16,
12283 },
12284 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12285 _bitfield_align_1: [],
12286 _bitfield_1: __BindgenBitfieldUnit::new(
12287 new_jsjitinfo_bitfield_1!(
12288 JSJitInfo_OpType::Getter as u8,
12289 JSJitInfo_AliasSet::AliasEverything as u8,
12290 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12291 true,
12292 false,
12293 false,
12294 false,
12295 false,
12296 false,
12297 0,
12298 ).to_ne_bytes()
12299 ),
12300});
12301}
12302static onanimationend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12303
12304pub(crate) fn init_onanimationend_setterinfo<D: DomTypes>() {
12305 onanimationend_setterinfo.set(JSJitInfo {
12306 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12307 setter: Some(set_onanimationend::<D>)
12308 },
12309 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12310 protoID: PrototypeList::ID::Window as u16,
12311 },
12312 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12313 _bitfield_align_1: [],
12314 _bitfield_1: __BindgenBitfieldUnit::new(
12315 new_jsjitinfo_bitfield_1!(
12316 JSJitInfo_OpType::Setter as u8,
12317 JSJitInfo_AliasSet::AliasEverything as u8,
12318 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12319 false,
12320 false,
12321 false,
12322 false,
12323 false,
12324 false,
12325 0,
12326 ).to_ne_bytes()
12327 ),
12328});
12329}
12330unsafe extern "C" fn get_onanimationcancel<D: DomTypes>
12331(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12332 let mut result = false;
12333 wrap_panic(&mut || result = (|| {
12334 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12335 let this = &*(this as *const D::Window);
12336 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnanimationcancel();
12337
12338 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12339 return true;
12340 })());
12341 result
12342}
12343
12344unsafe extern "C" fn set_onanimationcancel<D: DomTypes>
12345(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12346 let mut result = false;
12347 wrap_panic(&mut || result = {
12348 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12349 let this = &*(this as *const D::Window);
12350 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12351 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12352 } else {
12353 None
12354 };
12355 let result: () = this.SetOnanimationcancel(arg0);
12356
12357 true
12358 });
12359 result
12360}
12361
12362
12363static onanimationcancel_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12364
12365pub(crate) fn init_onanimationcancel_getterinfo<D: DomTypes>() {
12366 onanimationcancel_getterinfo.set(JSJitInfo {
12367 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12368 getter: Some(get_onanimationcancel::<D>)
12369 },
12370 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12371 protoID: PrototypeList::ID::Window as u16,
12372 },
12373 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12374 _bitfield_align_1: [],
12375 _bitfield_1: __BindgenBitfieldUnit::new(
12376 new_jsjitinfo_bitfield_1!(
12377 JSJitInfo_OpType::Getter as u8,
12378 JSJitInfo_AliasSet::AliasEverything as u8,
12379 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12380 true,
12381 false,
12382 false,
12383 false,
12384 false,
12385 false,
12386 0,
12387 ).to_ne_bytes()
12388 ),
12389});
12390}
12391static onanimationcancel_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12392
12393pub(crate) fn init_onanimationcancel_setterinfo<D: DomTypes>() {
12394 onanimationcancel_setterinfo.set(JSJitInfo {
12395 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12396 setter: Some(set_onanimationcancel::<D>)
12397 },
12398 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12399 protoID: PrototypeList::ID::Window as u16,
12400 },
12401 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12402 _bitfield_align_1: [],
12403 _bitfield_1: __BindgenBitfieldUnit::new(
12404 new_jsjitinfo_bitfield_1!(
12405 JSJitInfo_OpType::Setter as u8,
12406 JSJitInfo_AliasSet::AliasEverything as u8,
12407 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12408 false,
12409 false,
12410 false,
12411 false,
12412 false,
12413 false,
12414 0,
12415 ).to_ne_bytes()
12416 ),
12417});
12418}
12419unsafe extern "C" fn get_ontransitionrun<D: DomTypes>
12420(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12421 let mut result = false;
12422 wrap_panic(&mut || result = (|| {
12423 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12424 let this = &*(this as *const D::Window);
12425 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntransitionrun();
12426
12427 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12428 return true;
12429 })());
12430 result
12431}
12432
12433unsafe extern "C" fn set_ontransitionrun<D: DomTypes>
12434(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12435 let mut result = false;
12436 wrap_panic(&mut || result = {
12437 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12438 let this = &*(this as *const D::Window);
12439 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12440 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12441 } else {
12442 None
12443 };
12444 let result: () = this.SetOntransitionrun(arg0);
12445
12446 true
12447 });
12448 result
12449}
12450
12451
12452static ontransitionrun_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12453
12454pub(crate) fn init_ontransitionrun_getterinfo<D: DomTypes>() {
12455 ontransitionrun_getterinfo.set(JSJitInfo {
12456 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12457 getter: Some(get_ontransitionrun::<D>)
12458 },
12459 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12460 protoID: PrototypeList::ID::Window as u16,
12461 },
12462 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12463 _bitfield_align_1: [],
12464 _bitfield_1: __BindgenBitfieldUnit::new(
12465 new_jsjitinfo_bitfield_1!(
12466 JSJitInfo_OpType::Getter as u8,
12467 JSJitInfo_AliasSet::AliasEverything as u8,
12468 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12469 true,
12470 false,
12471 false,
12472 false,
12473 false,
12474 false,
12475 0,
12476 ).to_ne_bytes()
12477 ),
12478});
12479}
12480static ontransitionrun_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12481
12482pub(crate) fn init_ontransitionrun_setterinfo<D: DomTypes>() {
12483 ontransitionrun_setterinfo.set(JSJitInfo {
12484 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12485 setter: Some(set_ontransitionrun::<D>)
12486 },
12487 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12488 protoID: PrototypeList::ID::Window as u16,
12489 },
12490 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12491 _bitfield_align_1: [],
12492 _bitfield_1: __BindgenBitfieldUnit::new(
12493 new_jsjitinfo_bitfield_1!(
12494 JSJitInfo_OpType::Setter as u8,
12495 JSJitInfo_AliasSet::AliasEverything as u8,
12496 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12497 false,
12498 false,
12499 false,
12500 false,
12501 false,
12502 false,
12503 0,
12504 ).to_ne_bytes()
12505 ),
12506});
12507}
12508unsafe extern "C" fn get_ontransitionend<D: DomTypes>
12509(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12510 let mut result = false;
12511 wrap_panic(&mut || result = (|| {
12512 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12513 let this = &*(this as *const D::Window);
12514 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntransitionend();
12515
12516 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12517 return true;
12518 })());
12519 result
12520}
12521
12522unsafe extern "C" fn set_ontransitionend<D: DomTypes>
12523(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12524 let mut result = false;
12525 wrap_panic(&mut || result = {
12526 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12527 let this = &*(this as *const D::Window);
12528 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12529 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12530 } else {
12531 None
12532 };
12533 let result: () = this.SetOntransitionend(arg0);
12534
12535 true
12536 });
12537 result
12538}
12539
12540
12541static ontransitionend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12542
12543pub(crate) fn init_ontransitionend_getterinfo<D: DomTypes>() {
12544 ontransitionend_getterinfo.set(JSJitInfo {
12545 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12546 getter: Some(get_ontransitionend::<D>)
12547 },
12548 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12549 protoID: PrototypeList::ID::Window as u16,
12550 },
12551 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12552 _bitfield_align_1: [],
12553 _bitfield_1: __BindgenBitfieldUnit::new(
12554 new_jsjitinfo_bitfield_1!(
12555 JSJitInfo_OpType::Getter as u8,
12556 JSJitInfo_AliasSet::AliasEverything as u8,
12557 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12558 true,
12559 false,
12560 false,
12561 false,
12562 false,
12563 false,
12564 0,
12565 ).to_ne_bytes()
12566 ),
12567});
12568}
12569static ontransitionend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12570
12571pub(crate) fn init_ontransitionend_setterinfo<D: DomTypes>() {
12572 ontransitionend_setterinfo.set(JSJitInfo {
12573 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12574 setter: Some(set_ontransitionend::<D>)
12575 },
12576 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12577 protoID: PrototypeList::ID::Window as u16,
12578 },
12579 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12580 _bitfield_align_1: [],
12581 _bitfield_1: __BindgenBitfieldUnit::new(
12582 new_jsjitinfo_bitfield_1!(
12583 JSJitInfo_OpType::Setter as u8,
12584 JSJitInfo_AliasSet::AliasEverything as u8,
12585 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12586 false,
12587 false,
12588 false,
12589 false,
12590 false,
12591 false,
12592 0,
12593 ).to_ne_bytes()
12594 ),
12595});
12596}
12597unsafe extern "C" fn get_ontransitioncancel<D: DomTypes>
12598(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12599 let mut result = false;
12600 wrap_panic(&mut || result = (|| {
12601 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12602 let this = &*(this as *const D::Window);
12603 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntransitioncancel();
12604
12605 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12606 return true;
12607 })());
12608 result
12609}
12610
12611unsafe extern "C" fn set_ontransitioncancel<D: DomTypes>
12612(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12613 let mut result = false;
12614 wrap_panic(&mut || result = {
12615 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12616 let this = &*(this as *const D::Window);
12617 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12618 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12619 } else {
12620 None
12621 };
12622 let result: () = this.SetOntransitioncancel(arg0);
12623
12624 true
12625 });
12626 result
12627}
12628
12629
12630static ontransitioncancel_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12631
12632pub(crate) fn init_ontransitioncancel_getterinfo<D: DomTypes>() {
12633 ontransitioncancel_getterinfo.set(JSJitInfo {
12634 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12635 getter: Some(get_ontransitioncancel::<D>)
12636 },
12637 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12638 protoID: PrototypeList::ID::Window as u16,
12639 },
12640 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12641 _bitfield_align_1: [],
12642 _bitfield_1: __BindgenBitfieldUnit::new(
12643 new_jsjitinfo_bitfield_1!(
12644 JSJitInfo_OpType::Getter as u8,
12645 JSJitInfo_AliasSet::AliasEverything as u8,
12646 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12647 true,
12648 false,
12649 false,
12650 false,
12651 false,
12652 false,
12653 0,
12654 ).to_ne_bytes()
12655 ),
12656});
12657}
12658static ontransitioncancel_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12659
12660pub(crate) fn init_ontransitioncancel_setterinfo<D: DomTypes>() {
12661 ontransitioncancel_setterinfo.set(JSJitInfo {
12662 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12663 setter: Some(set_ontransitioncancel::<D>)
12664 },
12665 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12666 protoID: PrototypeList::ID::Window as u16,
12667 },
12668 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12669 _bitfield_align_1: [],
12670 _bitfield_1: __BindgenBitfieldUnit::new(
12671 new_jsjitinfo_bitfield_1!(
12672 JSJitInfo_OpType::Setter as u8,
12673 JSJitInfo_AliasSet::AliasEverything as u8,
12674 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12675 false,
12676 false,
12677 false,
12678 false,
12679 false,
12680 false,
12681 0,
12682 ).to_ne_bytes()
12683 ),
12684});
12685}
12686unsafe extern "C" fn get_onselectstart<D: DomTypes>
12687(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12688 let mut result = false;
12689 wrap_panic(&mut || result = (|| {
12690 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12691 let this = &*(this as *const D::Window);
12692 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnselectstart();
12693
12694 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12695 return true;
12696 })());
12697 result
12698}
12699
12700unsafe extern "C" fn set_onselectstart<D: DomTypes>
12701(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12702 let mut result = false;
12703 wrap_panic(&mut || result = {
12704 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12705 let this = &*(this as *const D::Window);
12706 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12707 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12708 } else {
12709 None
12710 };
12711 let result: () = this.SetOnselectstart(arg0);
12712
12713 true
12714 });
12715 result
12716}
12717
12718
12719static onselectstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12720
12721pub(crate) fn init_onselectstart_getterinfo<D: DomTypes>() {
12722 onselectstart_getterinfo.set(JSJitInfo {
12723 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12724 getter: Some(get_onselectstart::<D>)
12725 },
12726 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12727 protoID: PrototypeList::ID::Window as u16,
12728 },
12729 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12730 _bitfield_align_1: [],
12731 _bitfield_1: __BindgenBitfieldUnit::new(
12732 new_jsjitinfo_bitfield_1!(
12733 JSJitInfo_OpType::Getter as u8,
12734 JSJitInfo_AliasSet::AliasEverything as u8,
12735 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12736 true,
12737 false,
12738 false,
12739 false,
12740 false,
12741 false,
12742 0,
12743 ).to_ne_bytes()
12744 ),
12745});
12746}
12747static onselectstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12748
12749pub(crate) fn init_onselectstart_setterinfo<D: DomTypes>() {
12750 onselectstart_setterinfo.set(JSJitInfo {
12751 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12752 setter: Some(set_onselectstart::<D>)
12753 },
12754 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12755 protoID: PrototypeList::ID::Window as u16,
12756 },
12757 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12758 _bitfield_align_1: [],
12759 _bitfield_1: __BindgenBitfieldUnit::new(
12760 new_jsjitinfo_bitfield_1!(
12761 JSJitInfo_OpType::Setter as u8,
12762 JSJitInfo_AliasSet::AliasEverything as u8,
12763 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12764 false,
12765 false,
12766 false,
12767 false,
12768 false,
12769 false,
12770 0,
12771 ).to_ne_bytes()
12772 ),
12773});
12774}
12775unsafe extern "C" fn get_onselectionchange<D: DomTypes>
12776(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12777 let mut result = false;
12778 wrap_panic(&mut || result = (|| {
12779 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12780 let this = &*(this as *const D::Window);
12781 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnselectionchange();
12782
12783 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12784 return true;
12785 })());
12786 result
12787}
12788
12789unsafe extern "C" fn set_onselectionchange<D: DomTypes>
12790(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12791 let mut result = false;
12792 wrap_panic(&mut || result = {
12793 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12794 let this = &*(this as *const D::Window);
12795 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12796 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12797 } else {
12798 None
12799 };
12800 let result: () = this.SetOnselectionchange(arg0);
12801
12802 true
12803 });
12804 result
12805}
12806
12807
12808static onselectionchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12809
12810pub(crate) fn init_onselectionchange_getterinfo<D: DomTypes>() {
12811 onselectionchange_getterinfo.set(JSJitInfo {
12812 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12813 getter: Some(get_onselectionchange::<D>)
12814 },
12815 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12816 protoID: PrototypeList::ID::Window as u16,
12817 },
12818 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12819 _bitfield_align_1: [],
12820 _bitfield_1: __BindgenBitfieldUnit::new(
12821 new_jsjitinfo_bitfield_1!(
12822 JSJitInfo_OpType::Getter as u8,
12823 JSJitInfo_AliasSet::AliasEverything as u8,
12824 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12825 true,
12826 false,
12827 false,
12828 false,
12829 false,
12830 false,
12831 0,
12832 ).to_ne_bytes()
12833 ),
12834});
12835}
12836static onselectionchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12837
12838pub(crate) fn init_onselectionchange_setterinfo<D: DomTypes>() {
12839 onselectionchange_setterinfo.set(JSJitInfo {
12840 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12841 setter: Some(set_onselectionchange::<D>)
12842 },
12843 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12844 protoID: PrototypeList::ID::Window as u16,
12845 },
12846 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12847 _bitfield_align_1: [],
12848 _bitfield_1: __BindgenBitfieldUnit::new(
12849 new_jsjitinfo_bitfield_1!(
12850 JSJitInfo_OpType::Setter as u8,
12851 JSJitInfo_AliasSet::AliasEverything as u8,
12852 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12853 false,
12854 false,
12855 false,
12856 false,
12857 false,
12858 false,
12859 0,
12860 ).to_ne_bytes()
12861 ),
12862});
12863}
12864unsafe extern "C" fn get_onafterprint<D: DomTypes>
12865(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12866 let mut result = false;
12867 wrap_panic(&mut || result = (|| {
12868 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12869 let this = &*(this as *const D::Window);
12870 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnafterprint();
12871
12872 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12873 return true;
12874 })());
12875 result
12876}
12877
12878unsafe extern "C" fn set_onafterprint<D: DomTypes>
12879(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12880 let mut result = false;
12881 wrap_panic(&mut || result = {
12882 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12883 let this = &*(this as *const D::Window);
12884 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12885 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12886 } else {
12887 None
12888 };
12889 let result: () = this.SetOnafterprint(arg0);
12890
12891 true
12892 });
12893 result
12894}
12895
12896
12897static onafterprint_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12898
12899pub(crate) fn init_onafterprint_getterinfo<D: DomTypes>() {
12900 onafterprint_getterinfo.set(JSJitInfo {
12901 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12902 getter: Some(get_onafterprint::<D>)
12903 },
12904 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12905 protoID: PrototypeList::ID::Window as u16,
12906 },
12907 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12908 _bitfield_align_1: [],
12909 _bitfield_1: __BindgenBitfieldUnit::new(
12910 new_jsjitinfo_bitfield_1!(
12911 JSJitInfo_OpType::Getter as u8,
12912 JSJitInfo_AliasSet::AliasEverything as u8,
12913 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12914 true,
12915 false,
12916 false,
12917 false,
12918 false,
12919 false,
12920 0,
12921 ).to_ne_bytes()
12922 ),
12923});
12924}
12925static onafterprint_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12926
12927pub(crate) fn init_onafterprint_setterinfo<D: DomTypes>() {
12928 onafterprint_setterinfo.set(JSJitInfo {
12929 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12930 setter: Some(set_onafterprint::<D>)
12931 },
12932 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12933 protoID: PrototypeList::ID::Window as u16,
12934 },
12935 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12936 _bitfield_align_1: [],
12937 _bitfield_1: __BindgenBitfieldUnit::new(
12938 new_jsjitinfo_bitfield_1!(
12939 JSJitInfo_OpType::Setter as u8,
12940 JSJitInfo_AliasSet::AliasEverything as u8,
12941 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12942 false,
12943 false,
12944 false,
12945 false,
12946 false,
12947 false,
12948 0,
12949 ).to_ne_bytes()
12950 ),
12951});
12952}
12953unsafe extern "C" fn get_onbeforeprint<D: DomTypes>
12954(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12955 let mut result = false;
12956 wrap_panic(&mut || result = (|| {
12957 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12958 let this = &*(this as *const D::Window);
12959 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnbeforeprint();
12960
12961 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12962 return true;
12963 })());
12964 result
12965}
12966
12967unsafe extern "C" fn set_onbeforeprint<D: DomTypes>
12968(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12969 let mut result = false;
12970 wrap_panic(&mut || result = {
12971 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12972 let this = &*(this as *const D::Window);
12973 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12974 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12975 } else {
12976 None
12977 };
12978 let result: () = this.SetOnbeforeprint(arg0);
12979
12980 true
12981 });
12982 result
12983}
12984
12985
12986static onbeforeprint_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12987
12988pub(crate) fn init_onbeforeprint_getterinfo<D: DomTypes>() {
12989 onbeforeprint_getterinfo.set(JSJitInfo {
12990 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12991 getter: Some(get_onbeforeprint::<D>)
12992 },
12993 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12994 protoID: PrototypeList::ID::Window as u16,
12995 },
12996 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12997 _bitfield_align_1: [],
12998 _bitfield_1: __BindgenBitfieldUnit::new(
12999 new_jsjitinfo_bitfield_1!(
13000 JSJitInfo_OpType::Getter as u8,
13001 JSJitInfo_AliasSet::AliasEverything as u8,
13002 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13003 true,
13004 false,
13005 false,
13006 false,
13007 false,
13008 false,
13009 0,
13010 ).to_ne_bytes()
13011 ),
13012});
13013}
13014static onbeforeprint_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13015
13016pub(crate) fn init_onbeforeprint_setterinfo<D: DomTypes>() {
13017 onbeforeprint_setterinfo.set(JSJitInfo {
13018 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13019 setter: Some(set_onbeforeprint::<D>)
13020 },
13021 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13022 protoID: PrototypeList::ID::Window as u16,
13023 },
13024 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13025 _bitfield_align_1: [],
13026 _bitfield_1: __BindgenBitfieldUnit::new(
13027 new_jsjitinfo_bitfield_1!(
13028 JSJitInfo_OpType::Setter as u8,
13029 JSJitInfo_AliasSet::AliasEverything as u8,
13030 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13031 false,
13032 false,
13033 false,
13034 false,
13035 false,
13036 false,
13037 0,
13038 ).to_ne_bytes()
13039 ),
13040});
13041}
13042unsafe extern "C" fn get_onbeforeunload<D: DomTypes>
13043(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13044 let mut result = false;
13045 wrap_panic(&mut || result = (|| {
13046 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13047 let this = &*(this as *const D::Window);
13048 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::OnBeforeUnloadEventHandlerNonNull<D>>> = this.GetOnbeforeunload();
13049
13050 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13051 return true;
13052 })());
13053 result
13054}
13055
13056unsafe extern "C" fn set_onbeforeunload<D: DomTypes>
13057(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13058 let mut result = false;
13059 wrap_panic(&mut || result = {
13060 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13061 let this = &*(this as *const D::Window);
13062 let arg0: Option<Rc<OnBeforeUnloadEventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13063 Some(OnBeforeUnloadEventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13064 } else {
13065 None
13066 };
13067 let result: () = this.SetOnbeforeunload(arg0);
13068
13069 true
13070 });
13071 result
13072}
13073
13074
13075static onbeforeunload_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13076
13077pub(crate) fn init_onbeforeunload_getterinfo<D: DomTypes>() {
13078 onbeforeunload_getterinfo.set(JSJitInfo {
13079 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13080 getter: Some(get_onbeforeunload::<D>)
13081 },
13082 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13083 protoID: PrototypeList::ID::Window as u16,
13084 },
13085 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13086 _bitfield_align_1: [],
13087 _bitfield_1: __BindgenBitfieldUnit::new(
13088 new_jsjitinfo_bitfield_1!(
13089 JSJitInfo_OpType::Getter as u8,
13090 JSJitInfo_AliasSet::AliasEverything as u8,
13091 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13092 true,
13093 false,
13094 false,
13095 false,
13096 false,
13097 false,
13098 0,
13099 ).to_ne_bytes()
13100 ),
13101});
13102}
13103static onbeforeunload_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13104
13105pub(crate) fn init_onbeforeunload_setterinfo<D: DomTypes>() {
13106 onbeforeunload_setterinfo.set(JSJitInfo {
13107 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13108 setter: Some(set_onbeforeunload::<D>)
13109 },
13110 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13111 protoID: PrototypeList::ID::Window as u16,
13112 },
13113 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13114 _bitfield_align_1: [],
13115 _bitfield_1: __BindgenBitfieldUnit::new(
13116 new_jsjitinfo_bitfield_1!(
13117 JSJitInfo_OpType::Setter as u8,
13118 JSJitInfo_AliasSet::AliasEverything as u8,
13119 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13120 false,
13121 false,
13122 false,
13123 false,
13124 false,
13125 false,
13126 0,
13127 ).to_ne_bytes()
13128 ),
13129});
13130}
13131unsafe extern "C" fn get_onhashchange<D: DomTypes>
13132(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13133 let mut result = false;
13134 wrap_panic(&mut || result = (|| {
13135 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13136 let this = &*(this as *const D::Window);
13137 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnhashchange();
13138
13139 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13140 return true;
13141 })());
13142 result
13143}
13144
13145unsafe extern "C" fn set_onhashchange<D: DomTypes>
13146(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13147 let mut result = false;
13148 wrap_panic(&mut || result = {
13149 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13150 let this = &*(this as *const D::Window);
13151 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13152 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13153 } else {
13154 None
13155 };
13156 let result: () = this.SetOnhashchange(arg0);
13157
13158 true
13159 });
13160 result
13161}
13162
13163
13164static onhashchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13165
13166pub(crate) fn init_onhashchange_getterinfo<D: DomTypes>() {
13167 onhashchange_getterinfo.set(JSJitInfo {
13168 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13169 getter: Some(get_onhashchange::<D>)
13170 },
13171 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13172 protoID: PrototypeList::ID::Window as u16,
13173 },
13174 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13175 _bitfield_align_1: [],
13176 _bitfield_1: __BindgenBitfieldUnit::new(
13177 new_jsjitinfo_bitfield_1!(
13178 JSJitInfo_OpType::Getter as u8,
13179 JSJitInfo_AliasSet::AliasEverything as u8,
13180 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13181 true,
13182 false,
13183 false,
13184 false,
13185 false,
13186 false,
13187 0,
13188 ).to_ne_bytes()
13189 ),
13190});
13191}
13192static onhashchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13193
13194pub(crate) fn init_onhashchange_setterinfo<D: DomTypes>() {
13195 onhashchange_setterinfo.set(JSJitInfo {
13196 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13197 setter: Some(set_onhashchange::<D>)
13198 },
13199 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13200 protoID: PrototypeList::ID::Window as u16,
13201 },
13202 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13203 _bitfield_align_1: [],
13204 _bitfield_1: __BindgenBitfieldUnit::new(
13205 new_jsjitinfo_bitfield_1!(
13206 JSJitInfo_OpType::Setter as u8,
13207 JSJitInfo_AliasSet::AliasEverything as u8,
13208 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13209 false,
13210 false,
13211 false,
13212 false,
13213 false,
13214 false,
13215 0,
13216 ).to_ne_bytes()
13217 ),
13218});
13219}
13220unsafe extern "C" fn get_onlanguagechange<D: DomTypes>
13221(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13222 let mut result = false;
13223 wrap_panic(&mut || result = (|| {
13224 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13225 let this = &*(this as *const D::Window);
13226 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnlanguagechange();
13227
13228 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13229 return true;
13230 })());
13231 result
13232}
13233
13234unsafe extern "C" fn set_onlanguagechange<D: DomTypes>
13235(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13236 let mut result = false;
13237 wrap_panic(&mut || result = {
13238 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13239 let this = &*(this as *const D::Window);
13240 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13241 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13242 } else {
13243 None
13244 };
13245 let result: () = this.SetOnlanguagechange(arg0);
13246
13247 true
13248 });
13249 result
13250}
13251
13252
13253static onlanguagechange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13254
13255pub(crate) fn init_onlanguagechange_getterinfo<D: DomTypes>() {
13256 onlanguagechange_getterinfo.set(JSJitInfo {
13257 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13258 getter: Some(get_onlanguagechange::<D>)
13259 },
13260 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13261 protoID: PrototypeList::ID::Window as u16,
13262 },
13263 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13264 _bitfield_align_1: [],
13265 _bitfield_1: __BindgenBitfieldUnit::new(
13266 new_jsjitinfo_bitfield_1!(
13267 JSJitInfo_OpType::Getter as u8,
13268 JSJitInfo_AliasSet::AliasEverything as u8,
13269 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13270 true,
13271 false,
13272 false,
13273 false,
13274 false,
13275 false,
13276 0,
13277 ).to_ne_bytes()
13278 ),
13279});
13280}
13281static onlanguagechange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13282
13283pub(crate) fn init_onlanguagechange_setterinfo<D: DomTypes>() {
13284 onlanguagechange_setterinfo.set(JSJitInfo {
13285 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13286 setter: Some(set_onlanguagechange::<D>)
13287 },
13288 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13289 protoID: PrototypeList::ID::Window as u16,
13290 },
13291 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13292 _bitfield_align_1: [],
13293 _bitfield_1: __BindgenBitfieldUnit::new(
13294 new_jsjitinfo_bitfield_1!(
13295 JSJitInfo_OpType::Setter as u8,
13296 JSJitInfo_AliasSet::AliasEverything as u8,
13297 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13298 false,
13299 false,
13300 false,
13301 false,
13302 false,
13303 false,
13304 0,
13305 ).to_ne_bytes()
13306 ),
13307});
13308}
13309unsafe extern "C" fn get_onmessage<D: DomTypes>
13310(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13311 let mut result = false;
13312 wrap_panic(&mut || result = (|| {
13313 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13314 let this = &*(this as *const D::Window);
13315 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmessage();
13316
13317 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13318 return true;
13319 })());
13320 result
13321}
13322
13323unsafe extern "C" fn set_onmessage<D: DomTypes>
13324(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13325 let mut result = false;
13326 wrap_panic(&mut || result = {
13327 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13328 let this = &*(this as *const D::Window);
13329 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13330 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13331 } else {
13332 None
13333 };
13334 let result: () = this.SetOnmessage(arg0);
13335
13336 true
13337 });
13338 result
13339}
13340
13341
13342static onmessage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13343
13344pub(crate) fn init_onmessage_getterinfo<D: DomTypes>() {
13345 onmessage_getterinfo.set(JSJitInfo {
13346 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13347 getter: Some(get_onmessage::<D>)
13348 },
13349 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13350 protoID: PrototypeList::ID::Window as u16,
13351 },
13352 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13353 _bitfield_align_1: [],
13354 _bitfield_1: __BindgenBitfieldUnit::new(
13355 new_jsjitinfo_bitfield_1!(
13356 JSJitInfo_OpType::Getter as u8,
13357 JSJitInfo_AliasSet::AliasEverything as u8,
13358 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13359 true,
13360 false,
13361 false,
13362 false,
13363 false,
13364 false,
13365 0,
13366 ).to_ne_bytes()
13367 ),
13368});
13369}
13370static onmessage_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13371
13372pub(crate) fn init_onmessage_setterinfo<D: DomTypes>() {
13373 onmessage_setterinfo.set(JSJitInfo {
13374 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13375 setter: Some(set_onmessage::<D>)
13376 },
13377 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13378 protoID: PrototypeList::ID::Window as u16,
13379 },
13380 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13381 _bitfield_align_1: [],
13382 _bitfield_1: __BindgenBitfieldUnit::new(
13383 new_jsjitinfo_bitfield_1!(
13384 JSJitInfo_OpType::Setter as u8,
13385 JSJitInfo_AliasSet::AliasEverything as u8,
13386 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13387 false,
13388 false,
13389 false,
13390 false,
13391 false,
13392 false,
13393 0,
13394 ).to_ne_bytes()
13395 ),
13396});
13397}
13398unsafe extern "C" fn get_onmessageerror<D: DomTypes>
13399(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13400 let mut result = false;
13401 wrap_panic(&mut || result = (|| {
13402 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13403 let this = &*(this as *const D::Window);
13404 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmessageerror();
13405
13406 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13407 return true;
13408 })());
13409 result
13410}
13411
13412unsafe extern "C" fn set_onmessageerror<D: DomTypes>
13413(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13414 let mut result = false;
13415 wrap_panic(&mut || result = {
13416 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13417 let this = &*(this as *const D::Window);
13418 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13419 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13420 } else {
13421 None
13422 };
13423 let result: () = this.SetOnmessageerror(arg0);
13424
13425 true
13426 });
13427 result
13428}
13429
13430
13431static onmessageerror_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13432
13433pub(crate) fn init_onmessageerror_getterinfo<D: DomTypes>() {
13434 onmessageerror_getterinfo.set(JSJitInfo {
13435 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13436 getter: Some(get_onmessageerror::<D>)
13437 },
13438 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13439 protoID: PrototypeList::ID::Window as u16,
13440 },
13441 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13442 _bitfield_align_1: [],
13443 _bitfield_1: __BindgenBitfieldUnit::new(
13444 new_jsjitinfo_bitfield_1!(
13445 JSJitInfo_OpType::Getter as u8,
13446 JSJitInfo_AliasSet::AliasEverything as u8,
13447 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13448 true,
13449 false,
13450 false,
13451 false,
13452 false,
13453 false,
13454 0,
13455 ).to_ne_bytes()
13456 ),
13457});
13458}
13459static onmessageerror_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13460
13461pub(crate) fn init_onmessageerror_setterinfo<D: DomTypes>() {
13462 onmessageerror_setterinfo.set(JSJitInfo {
13463 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13464 setter: Some(set_onmessageerror::<D>)
13465 },
13466 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13467 protoID: PrototypeList::ID::Window as u16,
13468 },
13469 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13470 _bitfield_align_1: [],
13471 _bitfield_1: __BindgenBitfieldUnit::new(
13472 new_jsjitinfo_bitfield_1!(
13473 JSJitInfo_OpType::Setter as u8,
13474 JSJitInfo_AliasSet::AliasEverything as u8,
13475 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13476 false,
13477 false,
13478 false,
13479 false,
13480 false,
13481 false,
13482 0,
13483 ).to_ne_bytes()
13484 ),
13485});
13486}
13487unsafe extern "C" fn get_onoffline<D: DomTypes>
13488(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13489 let mut result = false;
13490 wrap_panic(&mut || result = (|| {
13491 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13492 let this = &*(this as *const D::Window);
13493 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnoffline();
13494
13495 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13496 return true;
13497 })());
13498 result
13499}
13500
13501unsafe extern "C" fn set_onoffline<D: DomTypes>
13502(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13503 let mut result = false;
13504 wrap_panic(&mut || result = {
13505 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13506 let this = &*(this as *const D::Window);
13507 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13508 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13509 } else {
13510 None
13511 };
13512 let result: () = this.SetOnoffline(arg0);
13513
13514 true
13515 });
13516 result
13517}
13518
13519
13520static onoffline_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13521
13522pub(crate) fn init_onoffline_getterinfo<D: DomTypes>() {
13523 onoffline_getterinfo.set(JSJitInfo {
13524 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13525 getter: Some(get_onoffline::<D>)
13526 },
13527 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13528 protoID: PrototypeList::ID::Window as u16,
13529 },
13530 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13531 _bitfield_align_1: [],
13532 _bitfield_1: __BindgenBitfieldUnit::new(
13533 new_jsjitinfo_bitfield_1!(
13534 JSJitInfo_OpType::Getter as u8,
13535 JSJitInfo_AliasSet::AliasEverything as u8,
13536 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13537 true,
13538 false,
13539 false,
13540 false,
13541 false,
13542 false,
13543 0,
13544 ).to_ne_bytes()
13545 ),
13546});
13547}
13548static onoffline_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13549
13550pub(crate) fn init_onoffline_setterinfo<D: DomTypes>() {
13551 onoffline_setterinfo.set(JSJitInfo {
13552 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13553 setter: Some(set_onoffline::<D>)
13554 },
13555 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13556 protoID: PrototypeList::ID::Window as u16,
13557 },
13558 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13559 _bitfield_align_1: [],
13560 _bitfield_1: __BindgenBitfieldUnit::new(
13561 new_jsjitinfo_bitfield_1!(
13562 JSJitInfo_OpType::Setter as u8,
13563 JSJitInfo_AliasSet::AliasEverything as u8,
13564 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13565 false,
13566 false,
13567 false,
13568 false,
13569 false,
13570 false,
13571 0,
13572 ).to_ne_bytes()
13573 ),
13574});
13575}
13576unsafe extern "C" fn get_ononline<D: DomTypes>
13577(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13578 let mut result = false;
13579 wrap_panic(&mut || result = (|| {
13580 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13581 let this = &*(this as *const D::Window);
13582 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnonline();
13583
13584 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13585 return true;
13586 })());
13587 result
13588}
13589
13590unsafe extern "C" fn set_ononline<D: DomTypes>
13591(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13592 let mut result = false;
13593 wrap_panic(&mut || result = {
13594 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13595 let this = &*(this as *const D::Window);
13596 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13597 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13598 } else {
13599 None
13600 };
13601 let result: () = this.SetOnonline(arg0);
13602
13603 true
13604 });
13605 result
13606}
13607
13608
13609static ononline_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13610
13611pub(crate) fn init_ononline_getterinfo<D: DomTypes>() {
13612 ononline_getterinfo.set(JSJitInfo {
13613 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13614 getter: Some(get_ononline::<D>)
13615 },
13616 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13617 protoID: PrototypeList::ID::Window as u16,
13618 },
13619 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13620 _bitfield_align_1: [],
13621 _bitfield_1: __BindgenBitfieldUnit::new(
13622 new_jsjitinfo_bitfield_1!(
13623 JSJitInfo_OpType::Getter as u8,
13624 JSJitInfo_AliasSet::AliasEverything as u8,
13625 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13626 true,
13627 false,
13628 false,
13629 false,
13630 false,
13631 false,
13632 0,
13633 ).to_ne_bytes()
13634 ),
13635});
13636}
13637static ononline_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13638
13639pub(crate) fn init_ononline_setterinfo<D: DomTypes>() {
13640 ononline_setterinfo.set(JSJitInfo {
13641 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13642 setter: Some(set_ononline::<D>)
13643 },
13644 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13645 protoID: PrototypeList::ID::Window as u16,
13646 },
13647 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13648 _bitfield_align_1: [],
13649 _bitfield_1: __BindgenBitfieldUnit::new(
13650 new_jsjitinfo_bitfield_1!(
13651 JSJitInfo_OpType::Setter as u8,
13652 JSJitInfo_AliasSet::AliasEverything as u8,
13653 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13654 false,
13655 false,
13656 false,
13657 false,
13658 false,
13659 false,
13660 0,
13661 ).to_ne_bytes()
13662 ),
13663});
13664}
13665unsafe extern "C" fn get_onpagehide<D: DomTypes>
13666(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13667 let mut result = false;
13668 wrap_panic(&mut || result = (|| {
13669 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13670 let this = &*(this as *const D::Window);
13671 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpagehide();
13672
13673 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13674 return true;
13675 })());
13676 result
13677}
13678
13679unsafe extern "C" fn set_onpagehide<D: DomTypes>
13680(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13681 let mut result = false;
13682 wrap_panic(&mut || result = {
13683 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13684 let this = &*(this as *const D::Window);
13685 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13686 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13687 } else {
13688 None
13689 };
13690 let result: () = this.SetOnpagehide(arg0);
13691
13692 true
13693 });
13694 result
13695}
13696
13697
13698static onpagehide_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13699
13700pub(crate) fn init_onpagehide_getterinfo<D: DomTypes>() {
13701 onpagehide_getterinfo.set(JSJitInfo {
13702 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13703 getter: Some(get_onpagehide::<D>)
13704 },
13705 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13706 protoID: PrototypeList::ID::Window as u16,
13707 },
13708 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13709 _bitfield_align_1: [],
13710 _bitfield_1: __BindgenBitfieldUnit::new(
13711 new_jsjitinfo_bitfield_1!(
13712 JSJitInfo_OpType::Getter as u8,
13713 JSJitInfo_AliasSet::AliasEverything as u8,
13714 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13715 true,
13716 false,
13717 false,
13718 false,
13719 false,
13720 false,
13721 0,
13722 ).to_ne_bytes()
13723 ),
13724});
13725}
13726static onpagehide_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13727
13728pub(crate) fn init_onpagehide_setterinfo<D: DomTypes>() {
13729 onpagehide_setterinfo.set(JSJitInfo {
13730 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13731 setter: Some(set_onpagehide::<D>)
13732 },
13733 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13734 protoID: PrototypeList::ID::Window as u16,
13735 },
13736 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13737 _bitfield_align_1: [],
13738 _bitfield_1: __BindgenBitfieldUnit::new(
13739 new_jsjitinfo_bitfield_1!(
13740 JSJitInfo_OpType::Setter as u8,
13741 JSJitInfo_AliasSet::AliasEverything as u8,
13742 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13743 false,
13744 false,
13745 false,
13746 false,
13747 false,
13748 false,
13749 0,
13750 ).to_ne_bytes()
13751 ),
13752});
13753}
13754unsafe extern "C" fn get_onpagereveal<D: DomTypes>
13755(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13756 let mut result = false;
13757 wrap_panic(&mut || result = (|| {
13758 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13759 let this = &*(this as *const D::Window);
13760 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpagereveal();
13761
13762 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13763 return true;
13764 })());
13765 result
13766}
13767
13768unsafe extern "C" fn set_onpagereveal<D: DomTypes>
13769(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13770 let mut result = false;
13771 wrap_panic(&mut || result = {
13772 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13773 let this = &*(this as *const D::Window);
13774 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13775 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13776 } else {
13777 None
13778 };
13779 let result: () = this.SetOnpagereveal(arg0);
13780
13781 true
13782 });
13783 result
13784}
13785
13786
13787static onpagereveal_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13788
13789pub(crate) fn init_onpagereveal_getterinfo<D: DomTypes>() {
13790 onpagereveal_getterinfo.set(JSJitInfo {
13791 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13792 getter: Some(get_onpagereveal::<D>)
13793 },
13794 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13795 protoID: PrototypeList::ID::Window as u16,
13796 },
13797 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13798 _bitfield_align_1: [],
13799 _bitfield_1: __BindgenBitfieldUnit::new(
13800 new_jsjitinfo_bitfield_1!(
13801 JSJitInfo_OpType::Getter as u8,
13802 JSJitInfo_AliasSet::AliasEverything as u8,
13803 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13804 true,
13805 false,
13806 false,
13807 false,
13808 false,
13809 false,
13810 0,
13811 ).to_ne_bytes()
13812 ),
13813});
13814}
13815static onpagereveal_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13816
13817pub(crate) fn init_onpagereveal_setterinfo<D: DomTypes>() {
13818 onpagereveal_setterinfo.set(JSJitInfo {
13819 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13820 setter: Some(set_onpagereveal::<D>)
13821 },
13822 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13823 protoID: PrototypeList::ID::Window as u16,
13824 },
13825 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13826 _bitfield_align_1: [],
13827 _bitfield_1: __BindgenBitfieldUnit::new(
13828 new_jsjitinfo_bitfield_1!(
13829 JSJitInfo_OpType::Setter as u8,
13830 JSJitInfo_AliasSet::AliasEverything as u8,
13831 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13832 false,
13833 false,
13834 false,
13835 false,
13836 false,
13837 false,
13838 0,
13839 ).to_ne_bytes()
13840 ),
13841});
13842}
13843unsafe extern "C" fn get_onpageshow<D: DomTypes>
13844(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13845 let mut result = false;
13846 wrap_panic(&mut || result = (|| {
13847 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13848 let this = &*(this as *const D::Window);
13849 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpageshow();
13850
13851 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13852 return true;
13853 })());
13854 result
13855}
13856
13857unsafe extern "C" fn set_onpageshow<D: DomTypes>
13858(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13859 let mut result = false;
13860 wrap_panic(&mut || result = {
13861 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13862 let this = &*(this as *const D::Window);
13863 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13864 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13865 } else {
13866 None
13867 };
13868 let result: () = this.SetOnpageshow(arg0);
13869
13870 true
13871 });
13872 result
13873}
13874
13875
13876static onpageshow_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13877
13878pub(crate) fn init_onpageshow_getterinfo<D: DomTypes>() {
13879 onpageshow_getterinfo.set(JSJitInfo {
13880 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13881 getter: Some(get_onpageshow::<D>)
13882 },
13883 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13884 protoID: PrototypeList::ID::Window as u16,
13885 },
13886 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13887 _bitfield_align_1: [],
13888 _bitfield_1: __BindgenBitfieldUnit::new(
13889 new_jsjitinfo_bitfield_1!(
13890 JSJitInfo_OpType::Getter as u8,
13891 JSJitInfo_AliasSet::AliasEverything as u8,
13892 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13893 true,
13894 false,
13895 false,
13896 false,
13897 false,
13898 false,
13899 0,
13900 ).to_ne_bytes()
13901 ),
13902});
13903}
13904static onpageshow_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13905
13906pub(crate) fn init_onpageshow_setterinfo<D: DomTypes>() {
13907 onpageshow_setterinfo.set(JSJitInfo {
13908 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13909 setter: Some(set_onpageshow::<D>)
13910 },
13911 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13912 protoID: PrototypeList::ID::Window as u16,
13913 },
13914 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13915 _bitfield_align_1: [],
13916 _bitfield_1: __BindgenBitfieldUnit::new(
13917 new_jsjitinfo_bitfield_1!(
13918 JSJitInfo_OpType::Setter as u8,
13919 JSJitInfo_AliasSet::AliasEverything as u8,
13920 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13921 false,
13922 false,
13923 false,
13924 false,
13925 false,
13926 false,
13927 0,
13928 ).to_ne_bytes()
13929 ),
13930});
13931}
13932unsafe extern "C" fn get_onpageswap<D: DomTypes>
13933(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13934 let mut result = false;
13935 wrap_panic(&mut || result = (|| {
13936 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13937 let this = &*(this as *const D::Window);
13938 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpageswap();
13939
13940 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13941 return true;
13942 })());
13943 result
13944}
13945
13946unsafe extern "C" fn set_onpageswap<D: DomTypes>
13947(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
13948 let mut result = false;
13949 wrap_panic(&mut || result = {
13950 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13951 let this = &*(this as *const D::Window);
13952 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13953 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
13954 } else {
13955 None
13956 };
13957 let result: () = this.SetOnpageswap(arg0);
13958
13959 true
13960 });
13961 result
13962}
13963
13964
13965static onpageswap_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13966
13967pub(crate) fn init_onpageswap_getterinfo<D: DomTypes>() {
13968 onpageswap_getterinfo.set(JSJitInfo {
13969 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13970 getter: Some(get_onpageswap::<D>)
13971 },
13972 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13973 protoID: PrototypeList::ID::Window as u16,
13974 },
13975 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13976 _bitfield_align_1: [],
13977 _bitfield_1: __BindgenBitfieldUnit::new(
13978 new_jsjitinfo_bitfield_1!(
13979 JSJitInfo_OpType::Getter as u8,
13980 JSJitInfo_AliasSet::AliasEverything as u8,
13981 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13982 true,
13983 false,
13984 false,
13985 false,
13986 false,
13987 false,
13988 0,
13989 ).to_ne_bytes()
13990 ),
13991});
13992}
13993static onpageswap_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13994
13995pub(crate) fn init_onpageswap_setterinfo<D: DomTypes>() {
13996 onpageswap_setterinfo.set(JSJitInfo {
13997 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13998 setter: Some(set_onpageswap::<D>)
13999 },
14000 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14001 protoID: PrototypeList::ID::Window as u16,
14002 },
14003 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14004 _bitfield_align_1: [],
14005 _bitfield_1: __BindgenBitfieldUnit::new(
14006 new_jsjitinfo_bitfield_1!(
14007 JSJitInfo_OpType::Setter as u8,
14008 JSJitInfo_AliasSet::AliasEverything as u8,
14009 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14010 false,
14011 false,
14012 false,
14013 false,
14014 false,
14015 false,
14016 0,
14017 ).to_ne_bytes()
14018 ),
14019});
14020}
14021unsafe extern "C" fn get_onpopstate<D: DomTypes>
14022(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14023 let mut result = false;
14024 wrap_panic(&mut || result = (|| {
14025 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14026 let this = &*(this as *const D::Window);
14027 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpopstate();
14028
14029 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14030 return true;
14031 })());
14032 result
14033}
14034
14035unsafe extern "C" fn set_onpopstate<D: DomTypes>
14036(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
14037 let mut result = false;
14038 wrap_panic(&mut || result = {
14039 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14040 let this = &*(this as *const D::Window);
14041 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
14042 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
14043 } else {
14044 None
14045 };
14046 let result: () = this.SetOnpopstate(arg0);
14047
14048 true
14049 });
14050 result
14051}
14052
14053
14054static onpopstate_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14055
14056pub(crate) fn init_onpopstate_getterinfo<D: DomTypes>() {
14057 onpopstate_getterinfo.set(JSJitInfo {
14058 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14059 getter: Some(get_onpopstate::<D>)
14060 },
14061 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14062 protoID: PrototypeList::ID::Window as u16,
14063 },
14064 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14065 _bitfield_align_1: [],
14066 _bitfield_1: __BindgenBitfieldUnit::new(
14067 new_jsjitinfo_bitfield_1!(
14068 JSJitInfo_OpType::Getter as u8,
14069 JSJitInfo_AliasSet::AliasEverything as u8,
14070 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
14071 true,
14072 false,
14073 false,
14074 false,
14075 false,
14076 false,
14077 0,
14078 ).to_ne_bytes()
14079 ),
14080});
14081}
14082static onpopstate_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14083
14084pub(crate) fn init_onpopstate_setterinfo<D: DomTypes>() {
14085 onpopstate_setterinfo.set(JSJitInfo {
14086 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14087 setter: Some(set_onpopstate::<D>)
14088 },
14089 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14090 protoID: PrototypeList::ID::Window as u16,
14091 },
14092 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14093 _bitfield_align_1: [],
14094 _bitfield_1: __BindgenBitfieldUnit::new(
14095 new_jsjitinfo_bitfield_1!(
14096 JSJitInfo_OpType::Setter as u8,
14097 JSJitInfo_AliasSet::AliasEverything as u8,
14098 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14099 false,
14100 false,
14101 false,
14102 false,
14103 false,
14104 false,
14105 0,
14106 ).to_ne_bytes()
14107 ),
14108});
14109}
14110unsafe extern "C" fn get_onrejectionhandled<D: DomTypes>
14111(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14112 let mut result = false;
14113 wrap_panic(&mut || result = (|| {
14114 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14115 let this = &*(this as *const D::Window);
14116 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnrejectionhandled();
14117
14118 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14119 return true;
14120 })());
14121 result
14122}
14123
14124unsafe extern "C" fn set_onrejectionhandled<D: DomTypes>
14125(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
14126 let mut result = false;
14127 wrap_panic(&mut || result = {
14128 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14129 let this = &*(this as *const D::Window);
14130 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
14131 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
14132 } else {
14133 None
14134 };
14135 let result: () = this.SetOnrejectionhandled(arg0);
14136
14137 true
14138 });
14139 result
14140}
14141
14142
14143static onrejectionhandled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14144
14145pub(crate) fn init_onrejectionhandled_getterinfo<D: DomTypes>() {
14146 onrejectionhandled_getterinfo.set(JSJitInfo {
14147 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14148 getter: Some(get_onrejectionhandled::<D>)
14149 },
14150 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14151 protoID: PrototypeList::ID::Window as u16,
14152 },
14153 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14154 _bitfield_align_1: [],
14155 _bitfield_1: __BindgenBitfieldUnit::new(
14156 new_jsjitinfo_bitfield_1!(
14157 JSJitInfo_OpType::Getter as u8,
14158 JSJitInfo_AliasSet::AliasEverything as u8,
14159 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
14160 true,
14161 false,
14162 false,
14163 false,
14164 false,
14165 false,
14166 0,
14167 ).to_ne_bytes()
14168 ),
14169});
14170}
14171static onrejectionhandled_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14172
14173pub(crate) fn init_onrejectionhandled_setterinfo<D: DomTypes>() {
14174 onrejectionhandled_setterinfo.set(JSJitInfo {
14175 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14176 setter: Some(set_onrejectionhandled::<D>)
14177 },
14178 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14179 protoID: PrototypeList::ID::Window as u16,
14180 },
14181 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14182 _bitfield_align_1: [],
14183 _bitfield_1: __BindgenBitfieldUnit::new(
14184 new_jsjitinfo_bitfield_1!(
14185 JSJitInfo_OpType::Setter as u8,
14186 JSJitInfo_AliasSet::AliasEverything as u8,
14187 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14188 false,
14189 false,
14190 false,
14191 false,
14192 false,
14193 false,
14194 0,
14195 ).to_ne_bytes()
14196 ),
14197});
14198}
14199unsafe extern "C" fn get_onstorage<D: DomTypes>
14200(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14201 let mut result = false;
14202 wrap_panic(&mut || result = (|| {
14203 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14204 let this = &*(this as *const D::Window);
14205 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnstorage();
14206
14207 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14208 return true;
14209 })());
14210 result
14211}
14212
14213unsafe extern "C" fn set_onstorage<D: DomTypes>
14214(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
14215 let mut result = false;
14216 wrap_panic(&mut || result = {
14217 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14218 let this = &*(this as *const D::Window);
14219 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
14220 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
14221 } else {
14222 None
14223 };
14224 let result: () = this.SetOnstorage(arg0);
14225
14226 true
14227 });
14228 result
14229}
14230
14231
14232static onstorage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14233
14234pub(crate) fn init_onstorage_getterinfo<D: DomTypes>() {
14235 onstorage_getterinfo.set(JSJitInfo {
14236 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14237 getter: Some(get_onstorage::<D>)
14238 },
14239 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14240 protoID: PrototypeList::ID::Window as u16,
14241 },
14242 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14243 _bitfield_align_1: [],
14244 _bitfield_1: __BindgenBitfieldUnit::new(
14245 new_jsjitinfo_bitfield_1!(
14246 JSJitInfo_OpType::Getter as u8,
14247 JSJitInfo_AliasSet::AliasEverything as u8,
14248 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
14249 true,
14250 false,
14251 false,
14252 false,
14253 false,
14254 false,
14255 0,
14256 ).to_ne_bytes()
14257 ),
14258});
14259}
14260static onstorage_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14261
14262pub(crate) fn init_onstorage_setterinfo<D: DomTypes>() {
14263 onstorage_setterinfo.set(JSJitInfo {
14264 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14265 setter: Some(set_onstorage::<D>)
14266 },
14267 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14268 protoID: PrototypeList::ID::Window as u16,
14269 },
14270 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14271 _bitfield_align_1: [],
14272 _bitfield_1: __BindgenBitfieldUnit::new(
14273 new_jsjitinfo_bitfield_1!(
14274 JSJitInfo_OpType::Setter as u8,
14275 JSJitInfo_AliasSet::AliasEverything as u8,
14276 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14277 false,
14278 false,
14279 false,
14280 false,
14281 false,
14282 false,
14283 0,
14284 ).to_ne_bytes()
14285 ),
14286});
14287}
14288unsafe extern "C" fn get_onunhandledrejection<D: DomTypes>
14289(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14290 let mut result = false;
14291 wrap_panic(&mut || result = (|| {
14292 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14293 let this = &*(this as *const D::Window);
14294 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnunhandledrejection();
14295
14296 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14297 return true;
14298 })());
14299 result
14300}
14301
14302unsafe extern "C" fn set_onunhandledrejection<D: DomTypes>
14303(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
14304 let mut result = false;
14305 wrap_panic(&mut || result = {
14306 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14307 let this = &*(this as *const D::Window);
14308 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
14309 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
14310 } else {
14311 None
14312 };
14313 let result: () = this.SetOnunhandledrejection(arg0);
14314
14315 true
14316 });
14317 result
14318}
14319
14320
14321static onunhandledrejection_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14322
14323pub(crate) fn init_onunhandledrejection_getterinfo<D: DomTypes>() {
14324 onunhandledrejection_getterinfo.set(JSJitInfo {
14325 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14326 getter: Some(get_onunhandledrejection::<D>)
14327 },
14328 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14329 protoID: PrototypeList::ID::Window as u16,
14330 },
14331 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14332 _bitfield_align_1: [],
14333 _bitfield_1: __BindgenBitfieldUnit::new(
14334 new_jsjitinfo_bitfield_1!(
14335 JSJitInfo_OpType::Getter as u8,
14336 JSJitInfo_AliasSet::AliasEverything as u8,
14337 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
14338 true,
14339 false,
14340 false,
14341 false,
14342 false,
14343 false,
14344 0,
14345 ).to_ne_bytes()
14346 ),
14347});
14348}
14349static onunhandledrejection_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14350
14351pub(crate) fn init_onunhandledrejection_setterinfo<D: DomTypes>() {
14352 onunhandledrejection_setterinfo.set(JSJitInfo {
14353 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14354 setter: Some(set_onunhandledrejection::<D>)
14355 },
14356 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14357 protoID: PrototypeList::ID::Window as u16,
14358 },
14359 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14360 _bitfield_align_1: [],
14361 _bitfield_1: __BindgenBitfieldUnit::new(
14362 new_jsjitinfo_bitfield_1!(
14363 JSJitInfo_OpType::Setter as u8,
14364 JSJitInfo_AliasSet::AliasEverything as u8,
14365 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14366 false,
14367 false,
14368 false,
14369 false,
14370 false,
14371 false,
14372 0,
14373 ).to_ne_bytes()
14374 ),
14375});
14376}
14377unsafe extern "C" fn get_onunload<D: DomTypes>
14378(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14379 let mut result = false;
14380 wrap_panic(&mut || result = (|| {
14381 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14382 let this = &*(this as *const D::Window);
14383 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnunload();
14384
14385 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14386 return true;
14387 })());
14388 result
14389}
14390
14391unsafe extern "C" fn set_onunload<D: DomTypes>
14392(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
14393 let mut result = false;
14394 wrap_panic(&mut || result = {
14395 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14396 let this = &*(this as *const D::Window);
14397 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
14398 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
14399 } else {
14400 None
14401 };
14402 let result: () = this.SetOnunload(arg0);
14403
14404 true
14405 });
14406 result
14407}
14408
14409
14410static onunload_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14411
14412pub(crate) fn init_onunload_getterinfo<D: DomTypes>() {
14413 onunload_getterinfo.set(JSJitInfo {
14414 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14415 getter: Some(get_onunload::<D>)
14416 },
14417 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14418 protoID: PrototypeList::ID::Window as u16,
14419 },
14420 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14421 _bitfield_align_1: [],
14422 _bitfield_1: __BindgenBitfieldUnit::new(
14423 new_jsjitinfo_bitfield_1!(
14424 JSJitInfo_OpType::Getter as u8,
14425 JSJitInfo_AliasSet::AliasEverything as u8,
14426 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
14427 true,
14428 false,
14429 false,
14430 false,
14431 false,
14432 false,
14433 0,
14434 ).to_ne_bytes()
14435 ),
14436});
14437}
14438static onunload_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14439
14440pub(crate) fn init_onunload_setterinfo<D: DomTypes>() {
14441 onunload_setterinfo.set(JSJitInfo {
14442 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14443 setter: Some(set_onunload::<D>)
14444 },
14445 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14446 protoID: PrototypeList::ID::Window as u16,
14447 },
14448 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14449 _bitfield_align_1: [],
14450 _bitfield_1: __BindgenBitfieldUnit::new(
14451 new_jsjitinfo_bitfield_1!(
14452 JSJitInfo_OpType::Setter as u8,
14453 JSJitInfo_AliasSet::AliasEverything as u8,
14454 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14455 false,
14456 false,
14457 false,
14458 false,
14459 false,
14460 false,
14461 0,
14462 ).to_ne_bytes()
14463 ),
14464});
14465}
14466unsafe extern "C" fn get_ongamepadconnected<D: DomTypes>
14467(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14468 let mut result = false;
14469 wrap_panic(&mut || result = (|| {
14470 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14471 let this = &*(this as *const D::Window);
14472 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOngamepadconnected();
14473
14474 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14475 return true;
14476 })());
14477 result
14478}
14479
14480unsafe extern "C" fn set_ongamepadconnected<D: DomTypes>
14481(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
14482 let mut result = false;
14483 wrap_panic(&mut || result = {
14484 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14485 let this = &*(this as *const D::Window);
14486 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
14487 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
14488 } else {
14489 None
14490 };
14491 let result: () = this.SetOngamepadconnected(arg0);
14492
14493 true
14494 });
14495 result
14496}
14497
14498
14499static ongamepadconnected_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14500
14501pub(crate) fn init_ongamepadconnected_getterinfo<D: DomTypes>() {
14502 ongamepadconnected_getterinfo.set(JSJitInfo {
14503 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14504 getter: Some(get_ongamepadconnected::<D>)
14505 },
14506 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14507 protoID: PrototypeList::ID::Window as u16,
14508 },
14509 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14510 _bitfield_align_1: [],
14511 _bitfield_1: __BindgenBitfieldUnit::new(
14512 new_jsjitinfo_bitfield_1!(
14513 JSJitInfo_OpType::Getter as u8,
14514 JSJitInfo_AliasSet::AliasEverything as u8,
14515 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
14516 true,
14517 false,
14518 false,
14519 false,
14520 false,
14521 false,
14522 0,
14523 ).to_ne_bytes()
14524 ),
14525});
14526}
14527static ongamepadconnected_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14528
14529pub(crate) fn init_ongamepadconnected_setterinfo<D: DomTypes>() {
14530 ongamepadconnected_setterinfo.set(JSJitInfo {
14531 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14532 setter: Some(set_ongamepadconnected::<D>)
14533 },
14534 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14535 protoID: PrototypeList::ID::Window as u16,
14536 },
14537 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14538 _bitfield_align_1: [],
14539 _bitfield_1: __BindgenBitfieldUnit::new(
14540 new_jsjitinfo_bitfield_1!(
14541 JSJitInfo_OpType::Setter as u8,
14542 JSJitInfo_AliasSet::AliasEverything as u8,
14543 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14544 false,
14545 false,
14546 false,
14547 false,
14548 false,
14549 false,
14550 0,
14551 ).to_ne_bytes()
14552 ),
14553});
14554}
14555unsafe extern "C" fn get_ongamepaddisconnected<D: DomTypes>
14556(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14557 let mut result = false;
14558 wrap_panic(&mut || result = (|| {
14559 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14560 let this = &*(this as *const D::Window);
14561 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOngamepaddisconnected();
14562
14563 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14564 return true;
14565 })());
14566 result
14567}
14568
14569unsafe extern "C" fn set_ongamepaddisconnected<D: DomTypes>
14570(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
14571 let mut result = false;
14572 wrap_panic(&mut || result = {
14573 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14574 let this = &*(this as *const D::Window);
14575 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
14576 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
14577 } else {
14578 None
14579 };
14580 let result: () = this.SetOngamepaddisconnected(arg0);
14581
14582 true
14583 });
14584 result
14585}
14586
14587
14588static ongamepaddisconnected_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14589
14590pub(crate) fn init_ongamepaddisconnected_getterinfo<D: DomTypes>() {
14591 ongamepaddisconnected_getterinfo.set(JSJitInfo {
14592 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14593 getter: Some(get_ongamepaddisconnected::<D>)
14594 },
14595 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14596 protoID: PrototypeList::ID::Window as u16,
14597 },
14598 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14599 _bitfield_align_1: [],
14600 _bitfield_1: __BindgenBitfieldUnit::new(
14601 new_jsjitinfo_bitfield_1!(
14602 JSJitInfo_OpType::Getter as u8,
14603 JSJitInfo_AliasSet::AliasEverything as u8,
14604 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
14605 true,
14606 false,
14607 false,
14608 false,
14609 false,
14610 false,
14611 0,
14612 ).to_ne_bytes()
14613 ),
14614});
14615}
14616static ongamepaddisconnected_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14617
14618pub(crate) fn init_ongamepaddisconnected_setterinfo<D: DomTypes>() {
14619 ongamepaddisconnected_setterinfo.set(JSJitInfo {
14620 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14621 setter: Some(set_ongamepaddisconnected::<D>)
14622 },
14623 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14624 protoID: PrototypeList::ID::Window as u16,
14625 },
14626 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14627 _bitfield_align_1: [],
14628 _bitfield_1: __BindgenBitfieldUnit::new(
14629 new_jsjitinfo_bitfield_1!(
14630 JSJitInfo_OpType::Setter as u8,
14631 JSJitInfo_AliasSet::AliasEverything as u8,
14632 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14633 false,
14634 false,
14635 false,
14636 false,
14637 false,
14638 false,
14639 0,
14640 ).to_ne_bytes()
14641 ),
14642});
14643}
14644unsafe extern "C" fn get_localStorage<D: DomTypes>
14645(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14646 let mut result = false;
14647 wrap_panic(&mut || result = (|| {
14648 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14649 let this = &*(this as *const D::Window);
14650 let result: DomRoot<D::Storage> = this.LocalStorage();
14651
14652 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14653 return true;
14654 })());
14655 result
14656}
14657
14658
14659static localStorage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14660
14661pub(crate) fn init_localStorage_getterinfo<D: DomTypes>() {
14662 localStorage_getterinfo.set(JSJitInfo {
14663 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14664 getter: Some(get_localStorage::<D>)
14665 },
14666 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14667 protoID: PrototypeList::ID::Window as u16,
14668 },
14669 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14670 _bitfield_align_1: [],
14671 _bitfield_1: __BindgenBitfieldUnit::new(
14672 new_jsjitinfo_bitfield_1!(
14673 JSJitInfo_OpType::Getter as u8,
14674 JSJitInfo_AliasSet::AliasEverything as u8,
14675 JSValueType::JSVAL_TYPE_OBJECT as u8,
14676 true,
14677 false,
14678 false,
14679 false,
14680 false,
14681 false,
14682 0,
14683 ).to_ne_bytes()
14684 ),
14685});
14686}
14687unsafe extern "C" fn get_origin<D: DomTypes>
14688(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
14689 let mut result = false;
14690 wrap_panic(&mut || result = (|| {
14691 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14692 let this = &*(this as *const D::Window);
14693 let result: USVString = this.Origin();
14694
14695 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14696 return true;
14697 })());
14698 result
14699}
14700
14701unsafe extern "C" fn set_origin<D: DomTypes>
14702(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
14703 let mut result = false;
14704 wrap_panic(&mut || result = {
14705
14706 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"origin".as_ptr(),
14707 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
14708 });
14709 result
14710}
14711
14712
14713static origin_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14714
14715pub(crate) fn init_origin_getterinfo<D: DomTypes>() {
14716 origin_getterinfo.set(JSJitInfo {
14717 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14718 getter: Some(get_origin::<D>)
14719 },
14720 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14721 protoID: PrototypeList::ID::Window as u16,
14722 },
14723 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14724 _bitfield_align_1: [],
14725 _bitfield_1: __BindgenBitfieldUnit::new(
14726 new_jsjitinfo_bitfield_1!(
14727 JSJitInfo_OpType::Getter as u8,
14728 JSJitInfo_AliasSet::AliasEverything as u8,
14729 JSValueType::JSVAL_TYPE_STRING as u8,
14730 true,
14731 false,
14732 false,
14733 false,
14734 false,
14735 false,
14736 0,
14737 ).to_ne_bytes()
14738 ),
14739});
14740}
14741static origin_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14742
14743pub(crate) fn init_origin_setterinfo<D: DomTypes>() {
14744 origin_setterinfo.set(JSJitInfo {
14745 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14746 setter: Some(set_origin::<D>)
14747 },
14748 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14749 protoID: PrototypeList::ID::Window as u16,
14750 },
14751 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14752 _bitfield_align_1: [],
14753 _bitfield_1: __BindgenBitfieldUnit::new(
14754 new_jsjitinfo_bitfield_1!(
14755 JSJitInfo_OpType::Setter as u8,
14756 JSJitInfo_AliasSet::AliasEverything as u8,
14757 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14758 false,
14759 false,
14760 false,
14761 false,
14762 false,
14763 false,
14764 0,
14765 ).to_ne_bytes()
14766 ),
14767});
14768}
14769unsafe extern "C" fn reportError<D: DomTypes>
14770(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14771 let mut result = false;
14772 wrap_panic(&mut || result = (|| {
14773 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14774 let this = &*(this as *const D::Window);
14775 let args = &*args;
14776 let argc = args.argc_;
14777
14778 if argc < 1 {
14779 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.reportError\".");
14780 return false;
14781 }
14782 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
14783 let result: () = this.ReportError(SafeJSContext::from_ptr(cx.raw_cx()), arg0, CanGc::note());
14784
14785 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14786 return true;
14787 })());
14788 result
14789}
14790
14791
14792static reportError_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14793
14794pub(crate) fn init_reportError_methodinfo<D: DomTypes>() {
14795 reportError_methodinfo.set(JSJitInfo {
14796 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14797 method: Some(reportError::<D>)
14798 },
14799 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14800 protoID: PrototypeList::ID::Window as u16,
14801 },
14802 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14803 _bitfield_align_1: [],
14804 _bitfield_1: __BindgenBitfieldUnit::new(
14805 new_jsjitinfo_bitfield_1!(
14806 JSJitInfo_OpType::Method as u8,
14807 JSJitInfo_AliasSet::AliasEverything as u8,
14808 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14809 false,
14810 false,
14811 false,
14812 false,
14813 false,
14814 false,
14815 0,
14816 ).to_ne_bytes()
14817 ),
14818});
14819}
14820unsafe extern "C" fn btoa<D: DomTypes>
14821(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14822 let mut result = false;
14823 wrap_panic(&mut || result = (|| {
14824 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14825 let this = &*(this as *const D::Window);
14826 let args = &*args;
14827 let argc = args.argc_;
14828
14829 if argc < 1 {
14830 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.btoa\".");
14831 return false;
14832 }
14833 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
14834 Ok(ConversionResult::Success(value)) => value,
14835 Ok(ConversionResult::Failure(error)) => {
14836 throw_type_error(cx.raw_cx(), &error);
14837 return false;
14838
14839 }
14840 _ => {
14841 return false;
14842
14843 },
14844 }
14845 ;
14846 let result: Result<DOMString, Error> = this.Btoa(arg0);
14847 let result = match result {
14848 Ok(result) => result,
14849 Err(e) => {
14850 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
14851 return false;
14852 },
14853 };
14854
14855 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14856 return true;
14857 })());
14858 result
14859}
14860
14861
14862static btoa_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14863
14864pub(crate) fn init_btoa_methodinfo<D: DomTypes>() {
14865 btoa_methodinfo.set(JSJitInfo {
14866 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14867 method: Some(btoa::<D>)
14868 },
14869 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14870 protoID: PrototypeList::ID::Window as u16,
14871 },
14872 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14873 _bitfield_align_1: [],
14874 _bitfield_1: __BindgenBitfieldUnit::new(
14875 new_jsjitinfo_bitfield_1!(
14876 JSJitInfo_OpType::Method as u8,
14877 JSJitInfo_AliasSet::AliasEverything as u8,
14878 JSValueType::JSVAL_TYPE_STRING as u8,
14879 false,
14880 false,
14881 false,
14882 false,
14883 false,
14884 false,
14885 0,
14886 ).to_ne_bytes()
14887 ),
14888});
14889}
14890unsafe extern "C" fn atob<D: DomTypes>
14891(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14892 let mut result = false;
14893 wrap_panic(&mut || result = (|| {
14894 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14895 let this = &*(this as *const D::Window);
14896 let args = &*args;
14897 let argc = args.argc_;
14898
14899 if argc < 1 {
14900 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.atob\".");
14901 return false;
14902 }
14903 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
14904 Ok(ConversionResult::Success(value)) => value,
14905 Ok(ConversionResult::Failure(error)) => {
14906 throw_type_error(cx.raw_cx(), &error);
14907 return false;
14908
14909 }
14910 _ => {
14911 return false;
14912
14913 },
14914 }
14915 ;
14916 let result: Result<DOMString, Error> = this.Atob(arg0);
14917 let result = match result {
14918 Ok(result) => result,
14919 Err(e) => {
14920 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
14921 return false;
14922 },
14923 };
14924
14925 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14926 return true;
14927 })());
14928 result
14929}
14930
14931
14932static atob_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14933
14934pub(crate) fn init_atob_methodinfo<D: DomTypes>() {
14935 atob_methodinfo.set(JSJitInfo {
14936 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14937 method: Some(atob::<D>)
14938 },
14939 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14940 protoID: PrototypeList::ID::Window as u16,
14941 },
14942 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
14943 _bitfield_align_1: [],
14944 _bitfield_1: __BindgenBitfieldUnit::new(
14945 new_jsjitinfo_bitfield_1!(
14946 JSJitInfo_OpType::Method as u8,
14947 JSJitInfo_AliasSet::AliasEverything as u8,
14948 JSValueType::JSVAL_TYPE_STRING as u8,
14949 false,
14950 false,
14951 false,
14952 false,
14953 false,
14954 false,
14955 0,
14956 ).to_ne_bytes()
14957 ),
14958});
14959}
14960unsafe extern "C" fn setTimeout<D: DomTypes>
14961(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14962 let mut result = false;
14963 wrap_panic(&mut || result = (|| {
14964 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14965 let this = &*(this as *const D::Window);
14966 let args = &*args;
14967 let argc = args.argc_;
14968
14969 if argc < 1 {
14970 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.setTimeout\".");
14971 return false;
14972 }
14973 let arg0: GenericUnionTypes::TrustedScriptOrStringOrFunction::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14974 Ok(ConversionResult::Success(value)) => value,
14975 Ok(ConversionResult::Failure(error)) => {
14976 throw_type_error(cx.raw_cx(), &error);
14977 return false;
14978
14979 }
14980 _ => {
14981 return false;
14982
14983 },
14984 }
14985 ;
14986 let arg1: i32 = if args.get(1).is_undefined() {
14987 0
14988 } else {
14989 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
14990 Ok(ConversionResult::Success(value)) => value,
14991 Ok(ConversionResult::Failure(error)) => {
14992 throw_type_error(cx.raw_cx(), &error);
14993 return false;
14994
14995 }
14996 _ => {
14997 return false;
14998
14999 },
15000 }
15001
15002 };
15003
15004 let mut arg2 = vec![];
15005 if argc > 2 {
15006 arg2.reserve(argc as usize- 2);
15007 for variadicArg in 2..argc {
15008 let slot: HandleValue = HandleValue::from_raw(args.get(variadicArg));
15009 arg2.push(slot);
15010 }
15011 }
15012 let result: Result<i32, Error> = this.SetTimeout(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, arg2, CanGc::note());
15013 let result = match result {
15014 Ok(result) => result,
15015 Err(e) => {
15016 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
15017 return false;
15018 },
15019 };
15020
15021 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15022 return true;
15023 })());
15024 result
15025}
15026
15027
15028static setTimeout_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15029
15030pub(crate) fn init_setTimeout_methodinfo<D: DomTypes>() {
15031 setTimeout_methodinfo.set(JSJitInfo {
15032 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15033 method: Some(setTimeout::<D>)
15034 },
15035 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15036 protoID: PrototypeList::ID::Window as u16,
15037 },
15038 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15039 _bitfield_align_1: [],
15040 _bitfield_1: __BindgenBitfieldUnit::new(
15041 new_jsjitinfo_bitfield_1!(
15042 JSJitInfo_OpType::Method as u8,
15043 JSJitInfo_AliasSet::AliasEverything as u8,
15044 JSValueType::JSVAL_TYPE_INT32 as u8,
15045 false,
15046 false,
15047 false,
15048 false,
15049 false,
15050 false,
15051 0,
15052 ).to_ne_bytes()
15053 ),
15054});
15055}
15056unsafe extern "C" fn clearTimeout<D: DomTypes>
15057(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15058 let mut result = false;
15059 wrap_panic(&mut || result = (|| {
15060 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15061 let this = &*(this as *const D::Window);
15062 let args = &*args;
15063 let argc = args.argc_;
15064 let arg0: i32 = if args.get(0).is_undefined() {
15065 0
15066 } else {
15067 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15068 Ok(ConversionResult::Success(value)) => value,
15069 Ok(ConversionResult::Failure(error)) => {
15070 throw_type_error(cx.raw_cx(), &error);
15071 return false;
15072
15073 }
15074 _ => {
15075 return false;
15076
15077 },
15078 }
15079
15080 };
15081 let result: () = this.ClearTimeout(arg0);
15082
15083 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15084 return true;
15085 })());
15086 result
15087}
15088
15089
15090static clearTimeout_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15091
15092pub(crate) fn init_clearTimeout_methodinfo<D: DomTypes>() {
15093 clearTimeout_methodinfo.set(JSJitInfo {
15094 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15095 method: Some(clearTimeout::<D>)
15096 },
15097 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15098 protoID: PrototypeList::ID::Window as u16,
15099 },
15100 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15101 _bitfield_align_1: [],
15102 _bitfield_1: __BindgenBitfieldUnit::new(
15103 new_jsjitinfo_bitfield_1!(
15104 JSJitInfo_OpType::Method as u8,
15105 JSJitInfo_AliasSet::AliasEverything as u8,
15106 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15107 false,
15108 false,
15109 false,
15110 false,
15111 false,
15112 false,
15113 0,
15114 ).to_ne_bytes()
15115 ),
15116});
15117}
15118unsafe extern "C" fn setInterval<D: DomTypes>
15119(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15120 let mut result = false;
15121 wrap_panic(&mut || result = (|| {
15122 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15123 let this = &*(this as *const D::Window);
15124 let args = &*args;
15125 let argc = args.argc_;
15126
15127 if argc < 1 {
15128 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.setInterval\".");
15129 return false;
15130 }
15131 let arg0: GenericUnionTypes::TrustedScriptOrStringOrFunction::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15132 Ok(ConversionResult::Success(value)) => value,
15133 Ok(ConversionResult::Failure(error)) => {
15134 throw_type_error(cx.raw_cx(), &error);
15135 return false;
15136
15137 }
15138 _ => {
15139 return false;
15140
15141 },
15142 }
15143 ;
15144 let arg1: i32 = if args.get(1).is_undefined() {
15145 0
15146 } else {
15147 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15148 Ok(ConversionResult::Success(value)) => value,
15149 Ok(ConversionResult::Failure(error)) => {
15150 throw_type_error(cx.raw_cx(), &error);
15151 return false;
15152
15153 }
15154 _ => {
15155 return false;
15156
15157 },
15158 }
15159
15160 };
15161
15162 let mut arg2 = vec![];
15163 if argc > 2 {
15164 arg2.reserve(argc as usize- 2);
15165 for variadicArg in 2..argc {
15166 let slot: HandleValue = HandleValue::from_raw(args.get(variadicArg));
15167 arg2.push(slot);
15168 }
15169 }
15170 let result: Result<i32, Error> = this.SetInterval(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, arg2, CanGc::note());
15171 let result = match result {
15172 Ok(result) => result,
15173 Err(e) => {
15174 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
15175 return false;
15176 },
15177 };
15178
15179 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15180 return true;
15181 })());
15182 result
15183}
15184
15185
15186static setInterval_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15187
15188pub(crate) fn init_setInterval_methodinfo<D: DomTypes>() {
15189 setInterval_methodinfo.set(JSJitInfo {
15190 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15191 method: Some(setInterval::<D>)
15192 },
15193 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15194 protoID: PrototypeList::ID::Window as u16,
15195 },
15196 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15197 _bitfield_align_1: [],
15198 _bitfield_1: __BindgenBitfieldUnit::new(
15199 new_jsjitinfo_bitfield_1!(
15200 JSJitInfo_OpType::Method as u8,
15201 JSJitInfo_AliasSet::AliasEverything as u8,
15202 JSValueType::JSVAL_TYPE_INT32 as u8,
15203 false,
15204 false,
15205 false,
15206 false,
15207 false,
15208 false,
15209 0,
15210 ).to_ne_bytes()
15211 ),
15212});
15213}
15214unsafe extern "C" fn clearInterval<D: DomTypes>
15215(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15216 let mut result = false;
15217 wrap_panic(&mut || result = (|| {
15218 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15219 let this = &*(this as *const D::Window);
15220 let args = &*args;
15221 let argc = args.argc_;
15222 let arg0: i32 = if args.get(0).is_undefined() {
15223 0
15224 } else {
15225 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15226 Ok(ConversionResult::Success(value)) => value,
15227 Ok(ConversionResult::Failure(error)) => {
15228 throw_type_error(cx.raw_cx(), &error);
15229 return false;
15230
15231 }
15232 _ => {
15233 return false;
15234
15235 },
15236 }
15237
15238 };
15239 let result: () = this.ClearInterval(arg0);
15240
15241 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15242 return true;
15243 })());
15244 result
15245}
15246
15247
15248static clearInterval_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15249
15250pub(crate) fn init_clearInterval_methodinfo<D: DomTypes>() {
15251 clearInterval_methodinfo.set(JSJitInfo {
15252 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15253 method: Some(clearInterval::<D>)
15254 },
15255 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15256 protoID: PrototypeList::ID::Window as u16,
15257 },
15258 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15259 _bitfield_align_1: [],
15260 _bitfield_1: __BindgenBitfieldUnit::new(
15261 new_jsjitinfo_bitfield_1!(
15262 JSJitInfo_OpType::Method as u8,
15263 JSJitInfo_AliasSet::AliasEverything as u8,
15264 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15265 false,
15266 false,
15267 false,
15268 false,
15269 false,
15270 false,
15271 0,
15272 ).to_ne_bytes()
15273 ),
15274});
15275}
15276unsafe extern "C" fn queueMicrotask<D: DomTypes>
15277(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15278 let mut result = false;
15279 wrap_panic(&mut || result = (|| {
15280 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15281 let this = &*(this as *const D::Window);
15282 let args = &*args;
15283 let argc = args.argc_;
15284
15285 if argc < 1 {
15286 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.queueMicrotask\".");
15287 return false;
15288 }
15289 let arg0: Rc<VoidFunction<D>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15290 if IsCallable(HandleValue::from_raw(args.get(0)).get().to_object()) {
15291 VoidFunction::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object())
15292 } else {
15293 throw_type_error(cx.raw_cx(), "Value is not callable.");
15294 return false;
15295
15296 }
15297 } else {
15298 throw_type_error(cx.raw_cx(), "Value is not an object.");
15299 return false;
15300
15301 };
15302 let result: () = this.QueueMicrotask(arg0);
15303
15304 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15305 return true;
15306 })());
15307 result
15308}
15309
15310
15311static queueMicrotask_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15312
15313pub(crate) fn init_queueMicrotask_methodinfo<D: DomTypes>() {
15314 queueMicrotask_methodinfo.set(JSJitInfo {
15315 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15316 method: Some(queueMicrotask::<D>)
15317 },
15318 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15319 protoID: PrototypeList::ID::Window as u16,
15320 },
15321 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15322 _bitfield_align_1: [],
15323 _bitfield_1: __BindgenBitfieldUnit::new(
15324 new_jsjitinfo_bitfield_1!(
15325 JSJitInfo_OpType::Method as u8,
15326 JSJitInfo_AliasSet::AliasEverything as u8,
15327 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15328 false,
15329 false,
15330 false,
15331 false,
15332 false,
15333 false,
15334 0,
15335 ).to_ne_bytes()
15336 ),
15337});
15338}
15339unsafe extern "C" fn createImageBitmap<D: DomTypes>
15340(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15341 let mut result = false;
15342 wrap_panic(&mut || result = (|| {
15343 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15344 let this = &*(this as *const D::Window);
15345 let args = &*args;
15346 let argc = args.argc_;
15347
15348 let argcount = cmp::min(argc, 6);
15349 match argcount {
15350 1 => {
15351 let arg0: GenericUnionTypes::HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15352 Ok(ConversionResult::Success(value)) => value,
15353 Ok(ConversionResult::Failure(error)) => {
15354 throw_type_error(cx.raw_cx(), &error);
15355 return false;
15356
15357 }
15358 _ => {
15359 return false;
15360
15361 },
15362 }
15363 ;
15364 let arg1: crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions = if args.get(1).is_undefined() {
15365 crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions::empty()
15366 } else {
15367 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
15368 Ok(ConversionResult::Success(value)) => value,
15369 Ok(ConversionResult::Failure(error)) => {
15370 throw_type_error(cx.raw_cx(), &error);
15371 return false;
15372
15373 }
15374 _ => {
15375 return false;
15376
15377 },
15378 }
15379
15380 };
15381 let result: Rc<D::Promise> = this.CreateImageBitmap(arg0, &arg1, CanGc::note());
15382
15383 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15384 return true;
15385 }
15386 2 => {
15387 let arg0: GenericUnionTypes::HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15388 Ok(ConversionResult::Success(value)) => value,
15389 Ok(ConversionResult::Failure(error)) => {
15390 throw_type_error(cx.raw_cx(), &error);
15391 return false;
15392
15393 }
15394 _ => {
15395 return false;
15396
15397 },
15398 }
15399 ;
15400 let arg1: crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions = if args.get(1).is_undefined() {
15401 crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions::empty()
15402 } else {
15403 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
15404 Ok(ConversionResult::Success(value)) => value,
15405 Ok(ConversionResult::Failure(error)) => {
15406 throw_type_error(cx.raw_cx(), &error);
15407 return false;
15408
15409 }
15410 _ => {
15411 return false;
15412
15413 },
15414 }
15415
15416 };
15417 let result: Rc<D::Promise> = this.CreateImageBitmap(arg0, &arg1, CanGc::note());
15418
15419 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15420 return true;
15421 }
15422 5 => {
15423 let arg0: GenericUnionTypes::HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15424 Ok(ConversionResult::Success(value)) => value,
15425 Ok(ConversionResult::Failure(error)) => {
15426 throw_type_error(cx.raw_cx(), &error);
15427 return false;
15428
15429 }
15430 _ => {
15431 return false;
15432
15433 },
15434 }
15435 ;
15436 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15437 Ok(ConversionResult::Success(value)) => value,
15438 Ok(ConversionResult::Failure(error)) => {
15439 throw_type_error(cx.raw_cx(), &error);
15440 return false;
15441
15442 }
15443 _ => {
15444 return false;
15445
15446 },
15447 }
15448 ;
15449 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
15450 Ok(ConversionResult::Success(value)) => value,
15451 Ok(ConversionResult::Failure(error)) => {
15452 throw_type_error(cx.raw_cx(), &error);
15453 return false;
15454
15455 }
15456 _ => {
15457 return false;
15458
15459 },
15460 }
15461 ;
15462 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
15463 Ok(ConversionResult::Success(value)) => value,
15464 Ok(ConversionResult::Failure(error)) => {
15465 throw_type_error(cx.raw_cx(), &error);
15466 return false;
15467
15468 }
15469 _ => {
15470 return false;
15471
15472 },
15473 }
15474 ;
15475 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
15476 Ok(ConversionResult::Success(value)) => value,
15477 Ok(ConversionResult::Failure(error)) => {
15478 throw_type_error(cx.raw_cx(), &error);
15479 return false;
15480
15481 }
15482 _ => {
15483 return false;
15484
15485 },
15486 }
15487 ;
15488 let arg5: crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions = if args.get(5).is_undefined() {
15489 crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions::empty()
15490 } else {
15491 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ()) {
15492 Ok(ConversionResult::Success(value)) => value,
15493 Ok(ConversionResult::Failure(error)) => {
15494 throw_type_error(cx.raw_cx(), &error);
15495 return false;
15496
15497 }
15498 _ => {
15499 return false;
15500
15501 },
15502 }
15503
15504 };
15505 let result: Rc<D::Promise> = this.CreateImageBitmap_(arg0, arg1, arg2, arg3, arg4, &arg5, CanGc::note());
15506
15507 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15508 return true;
15509 }
15510 6 => {
15511 let arg0: GenericUnionTypes::HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15512 Ok(ConversionResult::Success(value)) => value,
15513 Ok(ConversionResult::Failure(error)) => {
15514 throw_type_error(cx.raw_cx(), &error);
15515 return false;
15516
15517 }
15518 _ => {
15519 return false;
15520
15521 },
15522 }
15523 ;
15524 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15525 Ok(ConversionResult::Success(value)) => value,
15526 Ok(ConversionResult::Failure(error)) => {
15527 throw_type_error(cx.raw_cx(), &error);
15528 return false;
15529
15530 }
15531 _ => {
15532 return false;
15533
15534 },
15535 }
15536 ;
15537 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
15538 Ok(ConversionResult::Success(value)) => value,
15539 Ok(ConversionResult::Failure(error)) => {
15540 throw_type_error(cx.raw_cx(), &error);
15541 return false;
15542
15543 }
15544 _ => {
15545 return false;
15546
15547 },
15548 }
15549 ;
15550 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
15551 Ok(ConversionResult::Success(value)) => value,
15552 Ok(ConversionResult::Failure(error)) => {
15553 throw_type_error(cx.raw_cx(), &error);
15554 return false;
15555
15556 }
15557 _ => {
15558 return false;
15559
15560 },
15561 }
15562 ;
15563 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
15564 Ok(ConversionResult::Success(value)) => value,
15565 Ok(ConversionResult::Failure(error)) => {
15566 throw_type_error(cx.raw_cx(), &error);
15567 return false;
15568
15569 }
15570 _ => {
15571 return false;
15572
15573 },
15574 }
15575 ;
15576 let arg5: crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions = if args.get(5).is_undefined() {
15577 crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions::empty()
15578 } else {
15579 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ()) {
15580 Ok(ConversionResult::Success(value)) => value,
15581 Ok(ConversionResult::Failure(error)) => {
15582 throw_type_error(cx.raw_cx(), &error);
15583 return false;
15584
15585 }
15586 _ => {
15587 return false;
15588
15589 },
15590 }
15591
15592 };
15593 let result: Rc<D::Promise> = this.CreateImageBitmap_(arg0, arg1, arg2, arg3, arg4, &arg5, CanGc::note());
15594
15595 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15596 return true;
15597 }
15598 _ => {
15599 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.createImageBitmap\".");
15600 return false;
15601 }
15602 }
15603 })());
15604 result
15605}
15606
15607unsafe extern "C" fn createImageBitmap_promise_wrapper<D: DomTypes>
15608(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15609 let mut result = false;
15610 wrap_panic(&mut || result = (|| {
15611 let ok = createImageBitmap::<D>(cx, _obj, this, args);
15612 if ok {
15613 return true;
15614 }
15615 return exception_to_promise(cx, (*args).rval(), CanGc::note());
15616
15617 })());
15618 result
15619}
15620
15621
15622static createImageBitmap_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15623
15624pub(crate) fn init_createImageBitmap_methodinfo<D: DomTypes>() {
15625 createImageBitmap_methodinfo.set(JSJitInfo {
15626 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15627 method: Some(createImageBitmap_promise_wrapper::<D>)
15628 },
15629 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15630 protoID: PrototypeList::ID::Window as u16,
15631 },
15632 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15633 _bitfield_align_1: [],
15634 _bitfield_1: __BindgenBitfieldUnit::new(
15635 new_jsjitinfo_bitfield_1!(
15636 JSJitInfo_OpType::Method as u8,
15637 JSJitInfo_AliasSet::AliasEverything as u8,
15638 JSValueType::JSVAL_TYPE_OBJECT as u8,
15639 false,
15640 false,
15641 false,
15642 false,
15643 false,
15644 false,
15645 0,
15646 ).to_ne_bytes()
15647 ),
15648});
15649}
15650unsafe extern "C" fn structuredClone<D: DomTypes>
15651(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15652 let mut result = false;
15653 wrap_panic(&mut || result = (|| {
15654 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15655 let this = &*(this as *const D::Window);
15656 let args = &*args;
15657 let argc = args.argc_;
15658
15659 if argc < 1 {
15660 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.structuredClone\".");
15661 return false;
15662 }
15663 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
15664 let arg1: RootedTraceableBox<crate::codegen::GenericBindings::MessagePortBinding::StructuredSerializeOptions> = if args.get(1).is_undefined() {
15665 crate::codegen::GenericBindings::MessagePortBinding::StructuredSerializeOptions::empty()
15666 } else {
15667 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
15668 Ok(ConversionResult::Success(value)) => value,
15669 Ok(ConversionResult::Failure(error)) => {
15670 throw_type_error(cx.raw_cx(), &error);
15671 return false;
15672
15673 }
15674 _ => {
15675 return false;
15676
15677 },
15678 }
15679
15680 };
15681 rooted!(&in(cx) let mut retval: JSVal);
15682 let result: Result<(), Error> = this.StructuredClone(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, CanGc::note(), retval.handle_mut());
15683 let result = match result {
15684 Ok(result) => result,
15685 Err(e) => {
15686 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
15687 return false;
15688 },
15689 };
15690
15691 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15692 return true;
15693 })());
15694 result
15695}
15696
15697
15698static structuredClone_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15699
15700pub(crate) fn init_structuredClone_methodinfo<D: DomTypes>() {
15701 structuredClone_methodinfo.set(JSJitInfo {
15702 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15703 method: Some(structuredClone::<D>)
15704 },
15705 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15706 protoID: PrototypeList::ID::Window as u16,
15707 },
15708 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15709 _bitfield_align_1: [],
15710 _bitfield_1: __BindgenBitfieldUnit::new(
15711 new_jsjitinfo_bitfield_1!(
15712 JSJitInfo_OpType::Method as u8,
15713 JSJitInfo_AliasSet::AliasEverything as u8,
15714 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15715 false,
15716 false,
15717 false,
15718 false,
15719 false,
15720 false,
15721 0,
15722 ).to_ne_bytes()
15723 ),
15724});
15725}
15726unsafe extern "C" fn get_indexedDB<D: DomTypes>
15727(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
15728 let mut result = false;
15729 wrap_panic(&mut || result = (|| {
15730 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15731 let this = &*(this as *const D::Window);
15732 let result: DomRoot<D::IDBFactory> = this.IndexedDB();
15733
15734 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15735 return true;
15736 })());
15737 result
15738}
15739
15740
15741static indexedDB_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15742
15743pub(crate) fn init_indexedDB_getterinfo<D: DomTypes>() {
15744 indexedDB_getterinfo.set(JSJitInfo {
15745 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15746 getter: Some(get_indexedDB::<D>)
15747 },
15748 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15749 protoID: PrototypeList::ID::Window as u16,
15750 },
15751 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15752 _bitfield_align_1: [],
15753 _bitfield_1: __BindgenBitfieldUnit::new(
15754 new_jsjitinfo_bitfield_1!(
15755 JSJitInfo_OpType::Getter as u8,
15756 JSJitInfo_AliasSet::AliasNone as u8,
15757 JSValueType::JSVAL_TYPE_OBJECT as u8,
15758 true,
15759 true,
15760 false,
15761 false,
15762 false,
15763 false,
15764 0,
15765 ).to_ne_bytes()
15766 ),
15767});
15768}
15769unsafe extern "C" fn get_performance<D: DomTypes>
15770(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
15771 let mut result = false;
15772 wrap_panic(&mut || result = (|| {
15773 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15774 let this = &*(this as *const D::Window);
15775 let result: DomRoot<D::Performance> = this.Performance();
15776
15777 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15778 return true;
15779 })());
15780 result
15781}
15782
15783unsafe extern "C" fn set_performance<D: DomTypes>
15784(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
15785 let mut result = false;
15786 wrap_panic(&mut || result = {
15787
15788 JS_DefineProperty(cx, HandleObject::from_raw(obj), c"performance".as_ptr(),
15789 HandleValue::from_raw(args.get(0)), JSPROP_ENUMERATE as u32)
15790 });
15791 result
15792}
15793
15794
15795static performance_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15796
15797pub(crate) fn init_performance_getterinfo<D: DomTypes>() {
15798 performance_getterinfo.set(JSJitInfo {
15799 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15800 getter: Some(get_performance::<D>)
15801 },
15802 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15803 protoID: PrototypeList::ID::Window as u16,
15804 },
15805 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15806 _bitfield_align_1: [],
15807 _bitfield_1: __BindgenBitfieldUnit::new(
15808 new_jsjitinfo_bitfield_1!(
15809 JSJitInfo_OpType::Getter as u8,
15810 JSJitInfo_AliasSet::AliasEverything as u8,
15811 JSValueType::JSVAL_TYPE_OBJECT as u8,
15812 true,
15813 false,
15814 false,
15815 false,
15816 false,
15817 false,
15818 0,
15819 ).to_ne_bytes()
15820 ),
15821});
15822}
15823static performance_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15824
15825pub(crate) fn init_performance_setterinfo<D: DomTypes>() {
15826 performance_setterinfo.set(JSJitInfo {
15827 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15828 setter: Some(set_performance::<D>)
15829 },
15830 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15831 protoID: PrototypeList::ID::Window as u16,
15832 },
15833 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15834 _bitfield_align_1: [],
15835 _bitfield_1: __BindgenBitfieldUnit::new(
15836 new_jsjitinfo_bitfield_1!(
15837 JSJitInfo_OpType::Setter as u8,
15838 JSJitInfo_AliasSet::AliasEverything as u8,
15839 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15840 false,
15841 false,
15842 false,
15843 false,
15844 false,
15845 false,
15846 0,
15847 ).to_ne_bytes()
15848 ),
15849});
15850}
15851unsafe extern "C" fn get_isSecureContext<D: DomTypes>
15852(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
15853 let mut result = false;
15854 wrap_panic(&mut || result = (|| {
15855 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15856 let this = &*(this as *const D::Window);
15857 let result: bool = this.IsSecureContext();
15858
15859 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15860 return true;
15861 })());
15862 result
15863}
15864
15865
15866static isSecureContext_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15867
15868pub(crate) fn init_isSecureContext_getterinfo<D: DomTypes>() {
15869 isSecureContext_getterinfo.set(JSJitInfo {
15870 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15871 getter: Some(get_isSecureContext::<D>)
15872 },
15873 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15874 protoID: PrototypeList::ID::Window as u16,
15875 },
15876 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15877 _bitfield_align_1: [],
15878 _bitfield_1: __BindgenBitfieldUnit::new(
15879 new_jsjitinfo_bitfield_1!(
15880 JSJitInfo_OpType::Getter as u8,
15881 JSJitInfo_AliasSet::AliasEverything as u8,
15882 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
15883 true,
15884 false,
15885 false,
15886 false,
15887 false,
15888 false,
15889 0,
15890 ).to_ne_bytes()
15891 ),
15892});
15893}
15894unsafe extern "C" fn get_trustedTypes<D: DomTypes>
15895(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
15896 let mut result = false;
15897 wrap_panic(&mut || result = (|| {
15898 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15899 let this = &*(this as *const D::Window);
15900 let result: DomRoot<D::TrustedTypePolicyFactory> = this.TrustedTypes(CanGc::note());
15901
15902 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15903 return true;
15904 })());
15905 result
15906}
15907
15908
15909static trustedTypes_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15910
15911pub(crate) fn init_trustedTypes_getterinfo<D: DomTypes>() {
15912 trustedTypes_getterinfo.set(JSJitInfo {
15913 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15914 getter: Some(get_trustedTypes::<D>)
15915 },
15916 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15917 protoID: PrototypeList::ID::Window as u16,
15918 },
15919 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
15920 _bitfield_align_1: [],
15921 _bitfield_1: __BindgenBitfieldUnit::new(
15922 new_jsjitinfo_bitfield_1!(
15923 JSJitInfo_OpType::Getter as u8,
15924 JSJitInfo_AliasSet::AliasEverything as u8,
15925 JSValueType::JSVAL_TYPE_OBJECT as u8,
15926 true,
15927 false,
15928 false,
15929 false,
15930 false,
15931 false,
15932 0,
15933 ).to_ne_bytes()
15934 ),
15935});
15936}
15937unsafe extern "C" fn fetch<D: DomTypes>
15938(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15939 let mut result = false;
15940 wrap_panic(&mut || result = (|| {
15941 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15942 let this = &*(this as *const D::Window);
15943 let args = &*args;
15944 let argc = args.argc_;
15945
15946 if argc < 1 {
15947 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Window.fetch\".");
15948 return false;
15949 }
15950 let arg0: GenericUnionTypes::RequestOrUSVString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15951 Ok(ConversionResult::Success(value)) => value,
15952 Ok(ConversionResult::Failure(error)) => {
15953 throw_type_error(cx.raw_cx(), &error);
15954 return false;
15955
15956 }
15957 _ => {
15958 return false;
15959
15960 },
15961 }
15962 ;
15963 let arg1: RootedTraceableBox<crate::codegen::GenericBindings::RequestBinding::RequestInit<D>> = if args.get(1).is_undefined() {
15964 crate::codegen::GenericBindings::RequestBinding::RequestInit::empty()
15965 } else {
15966 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
15967 Ok(ConversionResult::Success(value)) => value,
15968 Ok(ConversionResult::Failure(error)) => {
15969 throw_type_error(cx.raw_cx(), &error);
15970 return false;
15971
15972 }
15973 _ => {
15974 return false;
15975
15976 },
15977 }
15978
15979 };
15980 let result: Rc<D::Promise> = this.Fetch(arg0, arg1, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());
15981
15982 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15983 return true;
15984 })());
15985 result
15986}
15987
15988unsafe extern "C" fn fetch_promise_wrapper<D: DomTypes>
15989(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15990 let mut result = false;
15991 wrap_panic(&mut || result = (|| {
15992 let ok = fetch::<D>(cx, _obj, this, args);
15993 if ok {
15994 return true;
15995 }
15996 return exception_to_promise(cx, (*args).rval(), CanGc::note());
15997
15998 })());
15999 result
16000}
16001
16002
16003static fetch_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16004
16005pub(crate) fn init_fetch_methodinfo<D: DomTypes>() {
16006 fetch_methodinfo.set(JSJitInfo {
16007 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16008 method: Some(fetch_promise_wrapper::<D>)
16009 },
16010 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16011 protoID: PrototypeList::ID::Window as u16,
16012 },
16013 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
16014 _bitfield_align_1: [],
16015 _bitfield_1: __BindgenBitfieldUnit::new(
16016 new_jsjitinfo_bitfield_1!(
16017 JSJitInfo_OpType::Method as u8,
16018 JSJitInfo_AliasSet::AliasEverything as u8,
16019 JSValueType::JSVAL_TYPE_OBJECT as u8,
16020 false,
16021 false,
16022 false,
16023 false,
16024 false,
16025 false,
16026 0,
16027 ).to_ne_bytes()
16028 ),
16029});
16030}
16031unsafe extern "C" fn get_crypto<D: DomTypes>
16032(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
16033 let mut result = false;
16034 wrap_panic(&mut || result = (|| {
16035 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16036 let this = &*(this as *const D::Window);
16037 let result: DomRoot<D::Crypto> = this.Crypto();
16038
16039 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16040 return true;
16041 })());
16042 result
16043}
16044
16045
16046static crypto_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16047
16048pub(crate) fn init_crypto_getterinfo<D: DomTypes>() {
16049 crypto_getterinfo.set(JSJitInfo {
16050 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16051 getter: Some(get_crypto::<D>)
16052 },
16053 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16054 protoID: PrototypeList::ID::Window as u16,
16055 },
16056 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
16057 _bitfield_align_1: [],
16058 _bitfield_1: __BindgenBitfieldUnit::new(
16059 new_jsjitinfo_bitfield_1!(
16060 JSJitInfo_OpType::Getter as u8,
16061 JSJitInfo_AliasSet::AliasNone as u8,
16062 JSValueType::JSVAL_TYPE_OBJECT as u8,
16063 true,
16064 true,
16065 false,
16066 false,
16067 false,
16068 false,
16069 0,
16070 ).to_ne_bytes()
16071 ),
16072});
16073}
16074unsafe extern "C" fn get_sessionStorage<D: DomTypes>
16075(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
16076 let mut result = false;
16077 wrap_panic(&mut || result = (|| {
16078 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16079 let this = &*(this as *const D::Window);
16080 let result: DomRoot<D::Storage> = this.SessionStorage();
16081
16082 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16083 return true;
16084 })());
16085 result
16086}
16087
16088
16089static sessionStorage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16090
16091pub(crate) fn init_sessionStorage_getterinfo<D: DomTypes>() {
16092 sessionStorage_getterinfo.set(JSJitInfo {
16093 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16094 getter: Some(get_sessionStorage::<D>)
16095 },
16096 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16097 protoID: PrototypeList::ID::Window as u16,
16098 },
16099 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
16100 _bitfield_align_1: [],
16101 _bitfield_1: __BindgenBitfieldUnit::new(
16102 new_jsjitinfo_bitfield_1!(
16103 JSJitInfo_OpType::Getter as u8,
16104 JSJitInfo_AliasSet::AliasEverything as u8,
16105 JSValueType::JSVAL_TYPE_OBJECT as u8,
16106 true,
16107 false,
16108 false,
16109 false,
16110 false,
16111 false,
16112 0,
16113 ).to_ne_bytes()
16114 ),
16115});
16116}
16117unsafe extern "C" fn _finalize<D: DomTypes>
16118(_cx: *mut GCContext, obj: *mut JSObject){
16119 wrap_panic(&mut || {
16120
16121 let this = native_from_object_static::<D::Window>(obj).unwrap();
16122 finalize_global(obj, this);
16123 })
16124}
16125
16126unsafe extern "C" fn _trace<D: DomTypes>
16127(trc: *mut JSTracer, obj: *mut JSObject){
16128 wrap_panic(&mut || {
16129
16130 let this = native_from_object_static::<D::Window>(obj).unwrap();
16131 if this.is_null() { return; } (*this).trace(trc);
16133 trace_global(trc, obj);
16134 })
16135}
16136
16137
16138static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();
16139
16140pub(crate) fn init_class_ops<D: DomTypes>() {
16141 CLASS_OPS.set(JSClassOps {
16142 addProperty: None,
16143 delProperty: None,
16144 enumerate: None,
16145 newEnumerate: Some(enumerate_window::<D>),
16146 resolve: Some(resolve_window::<D>),
16147 mayResolve: Some(may_resolve_window::<D>),
16148 finalize: Some(_finalize::<D>),
16149 call: None,
16150 construct: None,
16151 trace: Some(js::jsapi::JS_GlobalObjectTraceHook),
16152 });
16153}
16154
16155pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();
16156
16157pub(crate) fn init_domjs_class<D: DomTypes>() {
16158 init_class_ops::<D>();
16159 Class.set(DOMJSClass {
16160 base: JSClass {
16161 name: c"Window".as_ptr(),
16162 flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_IS_GLOBAL | JSCLASS_DOM_GLOBAL | JSCLASS_FOREGROUND_FINALIZE |
16163 (((JSCLASS_GLOBAL_SLOT_COUNT + 1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
16164 ,
16165 cOps: unsafe { CLASS_OPS.get() },
16166 spec: ptr::null(),
16167 ext: ptr::null(),
16168 oOps: ptr::null(),
16169 },
16170 dom_class:
16171DOMClass {
16172 interface_chain: [ PrototypeList::ID::EventTarget, PrototypeList::ID::GlobalScope, PrototypeList::ID::Window, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
16173 depth: 2,
16174 type_id: crate::codegen::InheritTypes::TopTypeId { eventtarget: (crate::codegen::InheritTypes::EventTargetTypeId::GlobalScope(crate::codegen::InheritTypes::GlobalScopeTypeId::Window)) },
16175 malloc_size_of: malloc_size_of_including_raw_self::<D::Window> as unsafe fn(&mut _, _) -> _,
16176 global: Globals::WINDOW,
16177},
16178 });
16179}
16180
16181#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub fn Wrap<D: DomTypes>
16182(cx: SafeJSContext, object: Box<D::Window>) -> DomRoot<D::Window>{
16183
16184 unsafe {
16185 let raw = Root::new(MaybeUnreflectedDom::from_box(object));
16186 let origin = (*raw.as_ptr()).upcast::<D::GlobalScope>().origin();
16187
16188 rooted!(&in(cx) let mut obj = ptr::null_mut::<JSObject>());
16189 create_global_object::<D>(
16190 cx,
16191 &Class.get().base,
16192 raw.as_ptr() as *const libc::c_void,
16193 _trace::<D>,
16194 obj.handle_mut(),
16195 origin,
16196 false);
16197 assert!(!obj.is_null());
16198
16199 let root = raw.reflect_with(obj.get());
16200
16201 let _ac = JSAutoRealm::new(cx.raw_cx(), obj.get());
16202 rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
16203 GetProtoObject::<D>(cx, obj.handle(), canonical_proto.handle_mut());
16204 assert!(JS_SetPrototype(cx.raw_cx(), obj.handle(), canonical_proto.handle()));
16205 let mut immutable = false;
16206 assert!(JS_SetImmutablePrototype(cx.raw_cx(), obj.handle(), &mut immutable));
16207 assert!(immutable);
16208
16209 define_guarded_properties::<D>(cx, obj.handle(), sAttributes.get(), obj.handle());
16210 define_guarded_methods::<D>(cx, obj.handle(), sMethods.get(), obj.handle());
16211
16212
16213 let mut slot = UndefinedValue();
16214 JS_GetReservedSlot(canonical_proto.get(), DOM_PROTO_UNFORGEABLE_HOLDER_SLOT, &mut slot);
16215 rooted!(&in(cx) let mut unforgeable_holder = ptr::null_mut::<JSObject>());
16216 unforgeable_holder.handle_mut().set(slot.to_object());
16217 assert!(JS_CopyOwnPropertiesAndPrivateFields(cx.raw_cx(), obj.handle(), unforgeable_holder.handle()));
16218
16219
16220 DomRoot::from_ref(&*root)
16221 }
16222
16223}
16224
16225pub trait WindowMethods<D: DomTypes> {
16226 fn Window(&self, ) -> DomRoot<D::WindowProxy>;
16227 fn Self_(&self, ) -> DomRoot<D::WindowProxy>;
16228 fn Document(&self, ) -> DomRoot<D::Document>;
16229 fn Name(&self, ) -> DOMString;
16230 fn SetName(&self, r#value: DOMString);
16231 fn Location(&self, ) -> DomRoot<D::Location>;
16232 fn History(&self, ) -> DomRoot<D::History>;
16233 fn CustomElements(&self, ) -> DomRoot<D::CustomElementRegistry>;
16234 fn Status(&self, ) -> DOMString;
16235 fn SetStatus(&self, r#value: DOMString);
16236 fn Close(&self, );
16237 fn Closed(&self, ) -> bool;
16238 fn Stop(&self, r#_can_gc: CanGc);
16239 fn Focus(&self, );
16240 fn Blur(&self, );
16241 fn Frames(&self, ) -> DomRoot<D::WindowProxy>;
16242 fn Length(&self, ) -> u32;
16243 fn GetTop(&self, ) -> Option<DomRoot<D::WindowProxy>>;
16244 fn GetOpener(&self, r#cx: SafeJSContext, r#_comp: InRealm, r#retval: MutableHandleValue) -> Fallible<()>;
16245 fn SetOpener(&self, r#cx: SafeJSContext, r#value: HandleValue) -> ErrorResult;
16246 fn GetParent(&self, ) -> Option<DomRoot<D::WindowProxy>>;
16247 fn GetFrameElement(&self, ) -> Option<DomRoot<D::Element>>;
16248 fn Open(&self, r#url: USVString, r#target: DOMString, r#features: DOMString, r#_can_gc: CanGc) -> Fallible<Option<DomRoot<D::WindowProxy>>>;
16249 fn Navigator(&self, ) -> DomRoot<D::Navigator>;
16250 fn Alert(&self, r#message: DOMString);
16251 fn Alert_(&self, );
16252 fn Confirm(&self, r#message: DOMString) -> bool;
16253 fn Prompt(&self, r#message: DOMString, r#default: DOMString) -> Option<DOMString>;
16254 fn RequestAnimationFrame(&self, r#callback: Rc<FrameRequestCallback<D>>) -> u32;
16255 fn CancelAnimationFrame(&self, r#handle: u32);
16256 fn PostMessage(&self, r#cx: SafeJSContext, r#message: HandleValue, r#targetOrigin: USVString, r#transfer: CustomAutoRooterGuard<Vec<*mut JSObject>>) -> Fallible<()>;
16257 fn PostMessage_(&self, r#cx: SafeJSContext, r#message: HandleValue, r#options: RootedTraceableBox<crate::codegen::GenericBindings::WindowBinding::WindowPostMessageOptions>) -> Fallible<()>;
16258 fn CaptureEvents(&self, );
16259 fn ReleaseEvents(&self, );
16260 fn GetComputedStyle(&self, r#elt: &D::Element, r#pseudoElt: Option<DOMString>) -> DomRoot<D::CSSStyleDeclaration>;
16261 fn MatchMedia(&self, r#query: DOMString) -> DomRoot<D::MediaQueryList>;
16262 fn Screen(&self, ) -> DomRoot<D::Screen>;
16263 fn MoveTo(&self, r#x: i32, r#y: i32);
16264 fn MoveBy(&self, r#x: i32, r#y: i32);
16265 fn ResizeTo(&self, r#x: i32, r#y: i32);
16266 fn ResizeBy(&self, r#x: i32, r#y: i32);
16267 fn InnerWidth(&self, ) -> i32;
16268 fn InnerHeight(&self, ) -> i32;
16269 fn ScrollX(&self, ) -> i32;
16270 fn PageXOffset(&self, ) -> i32;
16271 fn ScrollY(&self, ) -> i32;
16272 fn PageYOffset(&self, ) -> i32;
16273 fn Scroll(&self, r#options: &crate::codegen::GenericBindings::WindowBinding::ScrollToOptions);
16274 fn Scroll_(&self, r#x: f64, r#y: f64);
16275 fn ScrollTo(&self, r#options: &crate::codegen::GenericBindings::WindowBinding::ScrollToOptions);
16276 fn ScrollTo_(&self, r#x: f64, r#y: f64);
16277 fn ScrollBy(&self, r#options: &crate::codegen::GenericBindings::WindowBinding::ScrollToOptions);
16278 fn ScrollBy_(&self, r#x: f64, r#y: f64);
16279 fn ScreenX(&self, ) -> i32;
16280 fn ScreenY(&self, ) -> i32;
16281 fn OuterWidth(&self, ) -> i32;
16282 fn OuterHeight(&self, ) -> i32;
16283 fn DevicePixelRatio(&self, ) -> Finite<f64>;
16284 fn Debug(&self, r#arg: DOMString);
16285 fn Gc(&self, );
16286 fn Js_backtrace(&self, );
16287 fn WebdriverCallback(&self, r#cx: SafeJSContext, r#result: HandleValue, r#_comp: InRealm, r#_can_gc: CanGc);
16288 fn WebdriverException(&self, r#cx: SafeJSContext, r#result: HandleValue, r#_can_gc: CanGc);
16289 fn WebdriverElement(&self, r#id: DOMString) -> Option<DomRoot<D::Element>>;
16290 fn WebdriverFrame(&self, r#id: DOMString) -> Option<DomRoot<D::WindowProxy>>;
16291 fn WebdriverWindow(&self, r#id: DOMString) -> DomRoot<D::WindowProxy>;
16292 fn WebdriverShadowRoot(&self, r#id: DOMString) -> Option<DomRoot<D::ShadowRoot>>;
16293 fn RunningAnimationCount(&self, ) -> u32;
16294 fn GetSelection(&self, ) -> Option<DomRoot<D::Selection>>;
16295 fn Event(&self, r#cx: SafeJSContext, r#retval: MutableHandleValue);
16296 fn FetchLater(&self, r#input: GenericUnionTypes::RequestOrUSVString::<D>, r#init: RootedTraceableBox<crate::codegen::GenericBindings::WindowBinding::DeferredRequestInit<D>>, r#_can_gc: CanGc) -> Fallible<DomRoot<D::FetchLaterResult>>;
16297 fn CookieStore(&self, r#_can_gc: CanGc) -> DomRoot<D::CookieStore>;
16298 fn TestRunner(&self, ) -> DomRoot<D::TestRunner>;
16299 fn GetOnabort(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16300 fn SetOnabort(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16301 fn GetOnauxclick(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16302 fn SetOnauxclick(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16303 fn GetOnbeforeinput(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16304 fn SetOnbeforeinput(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16305 fn GetOnbeforematch(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16306 fn SetOnbeforematch(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16307 fn GetOnbeforetoggle(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16308 fn SetOnbeforetoggle(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16309 fn GetOnblur(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16310 fn SetOnblur(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16311 fn GetOncancel(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16312 fn SetOncancel(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16313 fn GetOncanplay(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16314 fn SetOncanplay(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16315 fn GetOncanplaythrough(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16316 fn SetOncanplaythrough(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16317 fn GetOnchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16318 fn SetOnchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16319 fn GetOnclick(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16320 fn SetOnclick(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16321 fn GetOnclose(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16322 fn SetOnclose(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16323 fn GetOncommand(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16324 fn SetOncommand(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16325 fn GetOncontextlost(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16326 fn SetOncontextlost(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16327 fn GetOncontextmenu(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16328 fn SetOncontextmenu(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16329 fn GetOncontextrestored(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16330 fn SetOncontextrestored(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16331 fn GetOncopy(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16332 fn SetOncopy(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16333 fn GetOncuechange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16334 fn SetOncuechange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16335 fn GetOncut(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16336 fn SetOncut(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16337 fn GetOndblclick(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16338 fn SetOndblclick(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16339 fn GetOndrag(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16340 fn SetOndrag(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16341 fn GetOndragend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16342 fn SetOndragend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16343 fn GetOndragenter(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16344 fn SetOndragenter(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16345 fn GetOndragleave(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16346 fn SetOndragleave(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16347 fn GetOndragover(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16348 fn SetOndragover(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16349 fn GetOndragstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16350 fn SetOndragstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16351 fn GetOndrop(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16352 fn SetOndrop(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16353 fn GetOndurationchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16354 fn SetOndurationchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16355 fn GetOnemptied(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16356 fn SetOnemptied(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16357 fn GetOnended(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16358 fn SetOnended(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16359 fn GetOnerror(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::OnErrorEventHandlerNonNull<D>>>;
16360 fn SetOnerror(&self, r#value: Option<Rc<OnErrorEventHandlerNonNull<D>>>);
16361 fn GetOnfocus(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16362 fn SetOnfocus(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16363 fn GetOnformdata(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16364 fn SetOnformdata(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16365 fn GetOninput(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16366 fn SetOninput(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16367 fn GetOninvalid(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16368 fn SetOninvalid(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16369 fn GetOnkeydown(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16370 fn SetOnkeydown(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16371 fn GetOnkeypress(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16372 fn SetOnkeypress(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16373 fn GetOnkeyup(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16374 fn SetOnkeyup(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16375 fn GetOnload(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16376 fn SetOnload(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16377 fn GetOnloadeddata(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16378 fn SetOnloadeddata(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16379 fn GetOnloadedmetadata(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16380 fn SetOnloadedmetadata(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16381 fn GetOnloadstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16382 fn SetOnloadstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16383 fn GetOnmousedown(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16384 fn SetOnmousedown(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16385 fn GetOnmouseenter(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16386 fn SetOnmouseenter(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16387 fn GetOnmouseleave(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16388 fn SetOnmouseleave(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16389 fn GetOnmousemove(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16390 fn SetOnmousemove(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16391 fn GetOnmouseout(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16392 fn SetOnmouseout(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16393 fn GetOnmouseover(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16394 fn SetOnmouseover(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16395 fn GetOnmouseup(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16396 fn SetOnmouseup(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16397 fn GetOnpaste(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16398 fn SetOnpaste(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16399 fn GetOnpause(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16400 fn SetOnpause(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16401 fn GetOnplay(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16402 fn SetOnplay(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16403 fn GetOnplaying(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16404 fn SetOnplaying(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16405 fn GetOnprogress(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16406 fn SetOnprogress(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16407 fn GetOnratechange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16408 fn SetOnratechange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16409 fn GetOnreset(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16410 fn SetOnreset(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16411 fn GetOnresize(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16412 fn SetOnresize(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16413 fn GetOnscroll(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16414 fn SetOnscroll(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16415 fn GetOnscrollend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16416 fn SetOnscrollend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16417 fn GetOnsecuritypolicyviolation(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16418 fn SetOnsecuritypolicyviolation(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16419 fn GetOnseeked(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16420 fn SetOnseeked(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16421 fn GetOnseeking(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16422 fn SetOnseeking(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16423 fn GetOnselect(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16424 fn SetOnselect(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16425 fn GetOnslotchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16426 fn SetOnslotchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16427 fn GetOnstalled(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16428 fn SetOnstalled(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16429 fn GetOnsubmit(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16430 fn SetOnsubmit(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16431 fn GetOnsuspend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16432 fn SetOnsuspend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16433 fn GetOntimeupdate(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16434 fn SetOntimeupdate(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16435 fn GetOntoggle(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16436 fn SetOntoggle(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16437 fn GetOnvolumechange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16438 fn SetOnvolumechange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16439 fn GetOnwaiting(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16440 fn SetOnwaiting(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16441 fn GetOnwebkitanimationend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16442 fn SetOnwebkitanimationend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16443 fn GetOnwebkitanimationiteration(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16444 fn SetOnwebkitanimationiteration(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16445 fn GetOnwebkitanimationstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16446 fn SetOnwebkitanimationstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16447 fn GetOnwebkittransitionend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16448 fn SetOnwebkittransitionend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16449 fn GetOnwheel(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16450 fn SetOnwheel(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16451 fn GetOnanimationstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16452 fn SetOnanimationstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16453 fn GetOnanimationiteration(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16454 fn SetOnanimationiteration(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16455 fn GetOnanimationend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16456 fn SetOnanimationend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16457 fn GetOnanimationcancel(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16458 fn SetOnanimationcancel(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16459 fn GetOntransitionrun(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16460 fn SetOntransitionrun(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16461 fn GetOntransitionend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16462 fn SetOntransitionend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16463 fn GetOntransitioncancel(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16464 fn SetOntransitioncancel(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16465 fn GetOnselectstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16466 fn SetOnselectstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16467 fn GetOnselectionchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16468 fn SetOnselectionchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16469 fn GetOnafterprint(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16470 fn SetOnafterprint(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16471 fn GetOnbeforeprint(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16472 fn SetOnbeforeprint(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16473 fn GetOnbeforeunload(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::OnBeforeUnloadEventHandlerNonNull<D>>>;
16474 fn SetOnbeforeunload(&self, r#value: Option<Rc<OnBeforeUnloadEventHandlerNonNull<D>>>);
16475 fn GetOnhashchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16476 fn SetOnhashchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16477 fn GetOnlanguagechange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16478 fn SetOnlanguagechange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16479 fn GetOnmessage(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16480 fn SetOnmessage(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16481 fn GetOnmessageerror(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16482 fn SetOnmessageerror(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16483 fn GetOnoffline(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16484 fn SetOnoffline(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16485 fn GetOnonline(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16486 fn SetOnonline(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16487 fn GetOnpagehide(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16488 fn SetOnpagehide(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16489 fn GetOnpagereveal(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16490 fn SetOnpagereveal(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16491 fn GetOnpageshow(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16492 fn SetOnpageshow(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16493 fn GetOnpageswap(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16494 fn SetOnpageswap(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16495 fn GetOnpopstate(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16496 fn SetOnpopstate(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16497 fn GetOnrejectionhandled(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16498 fn SetOnrejectionhandled(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16499 fn GetOnstorage(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16500 fn SetOnstorage(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16501 fn GetOnunhandledrejection(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16502 fn SetOnunhandledrejection(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16503 fn GetOnunload(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16504 fn SetOnunload(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16505 fn GetOngamepadconnected(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16506 fn SetOngamepadconnected(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16507 fn GetOngamepaddisconnected(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
16508 fn SetOngamepaddisconnected(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
16509 fn LocalStorage(&self, ) -> DomRoot<D::Storage>;
16510 fn Origin(&self, ) -> USVString;
16511 fn ReportError(&self, r#cx: SafeJSContext, r#e: HandleValue, r#_can_gc: CanGc);
16512 fn Btoa(&self, r#data: DOMString) -> Fallible<DOMString>;
16513 fn Atob(&self, r#data: DOMString) -> Fallible<DOMString>;
16514 fn SetTimeout(&self, r#cx: SafeJSContext, r#handler: GenericUnionTypes::TrustedScriptOrStringOrFunction::<D>, r#timeout: i32, r#arguments: Vec<HandleValue>, r#_can_gc: CanGc) -> Fallible<i32>;
16515 fn ClearTimeout(&self, r#handle: i32);
16516 fn SetInterval(&self, r#cx: SafeJSContext, r#handler: GenericUnionTypes::TrustedScriptOrStringOrFunction::<D>, r#timeout: i32, r#arguments: Vec<HandleValue>, r#_can_gc: CanGc) -> Fallible<i32>;
16517 fn ClearInterval(&self, r#handle: i32);
16518 fn QueueMicrotask(&self, r#callback: Rc<VoidFunction<D>>);
16519 fn CreateImageBitmap(&self, r#image: GenericUnionTypes::HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>, r#options: &crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions, r#_can_gc: CanGc) -> Rc<D::Promise>;
16520 fn CreateImageBitmap_(&self, r#image: GenericUnionTypes::HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>, r#sx: i32, r#sy: i32, r#sw: i32, r#sh: i32, r#options: &crate::codegen::GenericBindings::ImageBitmapBinding::ImageBitmapOptions, r#_can_gc: CanGc) -> Rc<D::Promise>;
16521 fn StructuredClone(&self, r#cx: SafeJSContext, r#value: HandleValue, r#options: RootedTraceableBox<crate::codegen::GenericBindings::MessagePortBinding::StructuredSerializeOptions>, r#_can_gc: CanGc, r#rval: MutableHandleValue) -> Fallible<()>;
16522 fn IndexedDB(&self, ) -> DomRoot<D::IDBFactory>;
16523 fn Performance(&self, ) -> DomRoot<D::Performance>;
16524 fn IsSecureContext(&self, ) -> bool;
16525 fn TrustedTypes(&self, r#_can_gc: CanGc) -> DomRoot<D::TrustedTypePolicyFactory>;
16526 fn Fetch(&self, r#input: GenericUnionTypes::RequestOrUSVString::<D>, r#init: RootedTraceableBox<crate::codegen::GenericBindings::RequestBinding::RequestInit<D>>, r#_comp: InRealm, r#_can_gc: CanGc) -> Rc<D::Promise>;
16527 fn Crypto(&self, ) -> DomRoot<D::Crypto>;
16528 fn SessionStorage(&self, ) -> DomRoot<D::Storage>;
16529 fn SupportedPropertyNames(&self, ) -> Vec<DOMString>;
16530 fn NamedGetter(&self, r#name: DOMString) -> Option<GenericUnionTypes::WindowProxyOrElementOrHTMLCollection::<D>>;
16531}
16532static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
16533
16534pub(crate) fn init_sMethods_specs<D: DomTypes>() {
16535 sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
16536 JSFunctionSpec {
16537 name: JSPropertySpec_Name { string_: c"close".as_ptr() },
16538 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { close_methodinfo.get() } as *const _ as *const JSJitInfo },
16539 nargs: 0,
16540 flags: (JSPROP_ENUMERATE) as u16,
16541 selfHostedName: ptr::null()
16542 },
16543 JSFunctionSpec {
16544 name: JSPropertySpec_Name { string_: c"stop".as_ptr() },
16545 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stop_methodinfo.get() } as *const _ as *const JSJitInfo },
16546 nargs: 0,
16547 flags: (JSPROP_ENUMERATE) as u16,
16548 selfHostedName: ptr::null()
16549 },
16550 JSFunctionSpec {
16551 name: JSPropertySpec_Name { string_: c"focus".as_ptr() },
16552 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { focus_methodinfo.get() } as *const _ as *const JSJitInfo },
16553 nargs: 0,
16554 flags: (JSPROP_ENUMERATE) as u16,
16555 selfHostedName: ptr::null()
16556 },
16557 JSFunctionSpec {
16558 name: JSPropertySpec_Name { string_: c"blur".as_ptr() },
16559 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blur_methodinfo.get() } as *const _ as *const JSJitInfo },
16560 nargs: 0,
16561 flags: (JSPROP_ENUMERATE) as u16,
16562 selfHostedName: ptr::null()
16563 },
16564 JSFunctionSpec {
16565 name: JSPropertySpec_Name { string_: c"open".as_ptr() },
16566 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { open_methodinfo.get() } as *const _ as *const JSJitInfo },
16567 nargs: 0,
16568 flags: (JSPROP_ENUMERATE) as u16,
16569 selfHostedName: ptr::null()
16570 },
16571 JSFunctionSpec {
16572 name: JSPropertySpec_Name { string_: c"alert".as_ptr() },
16573 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { alert_methodinfo.get() } as *const _ as *const JSJitInfo },
16574 nargs: 0,
16575 flags: (JSPROP_ENUMERATE) as u16,
16576 selfHostedName: ptr::null()
16577 },
16578 JSFunctionSpec {
16579 name: JSPropertySpec_Name { string_: c"confirm".as_ptr() },
16580 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { confirm_methodinfo.get() } as *const _ as *const JSJitInfo },
16581 nargs: 0,
16582 flags: (JSPROP_ENUMERATE) as u16,
16583 selfHostedName: ptr::null()
16584 },
16585 JSFunctionSpec {
16586 name: JSPropertySpec_Name { string_: c"prompt".as_ptr() },
16587 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { prompt_methodinfo.get() } as *const _ as *const JSJitInfo },
16588 nargs: 0,
16589 flags: (JSPROP_ENUMERATE) as u16,
16590 selfHostedName: ptr::null()
16591 },
16592 JSFunctionSpec {
16593 name: JSPropertySpec_Name { string_: c"requestAnimationFrame".as_ptr() },
16594 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { requestAnimationFrame_methodinfo.get() } as *const _ as *const JSJitInfo },
16595 nargs: 1,
16596 flags: (JSPROP_ENUMERATE) as u16,
16597 selfHostedName: ptr::null()
16598 },
16599 JSFunctionSpec {
16600 name: JSPropertySpec_Name { string_: c"cancelAnimationFrame".as_ptr() },
16601 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { cancelAnimationFrame_methodinfo.get() } as *const _ as *const JSJitInfo },
16602 nargs: 1,
16603 flags: (JSPROP_ENUMERATE) as u16,
16604 selfHostedName: ptr::null()
16605 },
16606 JSFunctionSpec {
16607 name: JSPropertySpec_Name { string_: c"postMessage".as_ptr() },
16608 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { postMessage_methodinfo.get() } as *const _ as *const JSJitInfo },
16609 nargs: 1,
16610 flags: (JSPROP_ENUMERATE) as u16,
16611 selfHostedName: ptr::null()
16612 },
16613 JSFunctionSpec {
16614 name: JSPropertySpec_Name { string_: c"captureEvents".as_ptr() },
16615 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { captureEvents_methodinfo.get() } as *const _ as *const JSJitInfo },
16616 nargs: 0,
16617 flags: (JSPROP_ENUMERATE) as u16,
16618 selfHostedName: ptr::null()
16619 },
16620 JSFunctionSpec {
16621 name: JSPropertySpec_Name { string_: c"releaseEvents".as_ptr() },
16622 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { releaseEvents_methodinfo.get() } as *const _ as *const JSJitInfo },
16623 nargs: 0,
16624 flags: (JSPROP_ENUMERATE) as u16,
16625 selfHostedName: ptr::null()
16626 },
16627 JSFunctionSpec {
16628 name: JSPropertySpec_Name { string_: c"getComputedStyle".as_ptr() },
16629 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getComputedStyle_methodinfo.get() } as *const _ as *const JSJitInfo },
16630 nargs: 1,
16631 flags: (JSPROP_ENUMERATE) as u16,
16632 selfHostedName: ptr::null()
16633 },
16634 JSFunctionSpec {
16635 name: JSPropertySpec_Name { string_: c"matchMedia".as_ptr() },
16636 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { matchMedia_methodinfo.get() } as *const _ as *const JSJitInfo },
16637 nargs: 1,
16638 flags: (JSPROP_ENUMERATE) as u16,
16639 selfHostedName: ptr::null()
16640 },
16641 JSFunctionSpec {
16642 name: JSPropertySpec_Name { string_: c"moveTo".as_ptr() },
16643 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { moveTo_methodinfo.get() } as *const _ as *const JSJitInfo },
16644 nargs: 2,
16645 flags: (JSPROP_ENUMERATE) as u16,
16646 selfHostedName: ptr::null()
16647 },
16648 JSFunctionSpec {
16649 name: JSPropertySpec_Name { string_: c"moveBy".as_ptr() },
16650 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { moveBy_methodinfo.get() } as *const _ as *const JSJitInfo },
16651 nargs: 2,
16652 flags: (JSPROP_ENUMERATE) as u16,
16653 selfHostedName: ptr::null()
16654 },
16655 JSFunctionSpec {
16656 name: JSPropertySpec_Name { string_: c"resizeTo".as_ptr() },
16657 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { resizeTo_methodinfo.get() } as *const _ as *const JSJitInfo },
16658 nargs: 2,
16659 flags: (JSPROP_ENUMERATE) as u16,
16660 selfHostedName: ptr::null()
16661 },
16662 JSFunctionSpec {
16663 name: JSPropertySpec_Name { string_: c"resizeBy".as_ptr() },
16664 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { resizeBy_methodinfo.get() } as *const _ as *const JSJitInfo },
16665 nargs: 2,
16666 flags: (JSPROP_ENUMERATE) as u16,
16667 selfHostedName: ptr::null()
16668 },
16669 JSFunctionSpec {
16670 name: JSPropertySpec_Name { string_: c"scroll".as_ptr() },
16671 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { scroll_methodinfo.get() } as *const _ as *const JSJitInfo },
16672 nargs: 0,
16673 flags: (JSPROP_ENUMERATE) as u16,
16674 selfHostedName: ptr::null()
16675 },
16676 JSFunctionSpec {
16677 name: JSPropertySpec_Name { string_: c"scrollTo".as_ptr() },
16678 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { scrollTo_methodinfo.get() } as *const _ as *const JSJitInfo },
16679 nargs: 0,
16680 flags: (JSPROP_ENUMERATE) as u16,
16681 selfHostedName: ptr::null()
16682 },
16683 JSFunctionSpec {
16684 name: JSPropertySpec_Name { string_: c"scrollBy".as_ptr() },
16685 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { scrollBy_methodinfo.get() } as *const _ as *const JSJitInfo },
16686 nargs: 0,
16687 flags: (JSPROP_ENUMERATE) as u16,
16688 selfHostedName: ptr::null()
16689 },
16690 JSFunctionSpec {
16691 name: JSPropertySpec_Name { string_: ptr::null() },
16692 call: JSNativeWrapper { op: None, info: ptr::null() },
16693 nargs: 0,
16694 flags: 0,
16695 selfHostedName: ptr::null()
16696 }]))[..]
16697,
16698&Box::leak(Box::new([
16699 JSFunctionSpec {
16700 name: JSPropertySpec_Name { string_: c"debug".as_ptr() },
16701 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { debug_methodinfo.get() } as *const _ as *const JSJitInfo },
16702 nargs: 1,
16703 flags: (JSPROP_ENUMERATE) as u16,
16704 selfHostedName: ptr::null()
16705 },
16706 JSFunctionSpec {
16707 name: JSPropertySpec_Name { string_: c"gc".as_ptr() },
16708 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { gc_methodinfo.get() } as *const _ as *const JSJitInfo },
16709 nargs: 0,
16710 flags: (JSPROP_ENUMERATE) as u16,
16711 selfHostedName: ptr::null()
16712 },
16713 JSFunctionSpec {
16714 name: JSPropertySpec_Name { string_: c"js_backtrace".as_ptr() },
16715 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { js_backtrace_methodinfo.get() } as *const _ as *const JSJitInfo },
16716 nargs: 0,
16717 flags: (JSPROP_ENUMERATE) as u16,
16718 selfHostedName: ptr::null()
16719 },
16720 JSFunctionSpec {
16721 name: JSPropertySpec_Name { string_: ptr::null() },
16722 call: JSNativeWrapper { op: None, info: ptr::null() },
16723 nargs: 0,
16724 flags: 0,
16725 selfHostedName: ptr::null()
16726 }]))[..]
16727,
16728&Box::leak(Box::new([
16729 JSFunctionSpec {
16730 name: JSPropertySpec_Name { string_: c"webdriverCallback".as_ptr() },
16731 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { webdriverCallback_methodinfo.get() } as *const _ as *const JSJitInfo },
16732 nargs: 0,
16733 flags: (JSPROP_ENUMERATE) as u16,
16734 selfHostedName: ptr::null()
16735 },
16736 JSFunctionSpec {
16737 name: JSPropertySpec_Name { string_: c"webdriverException".as_ptr() },
16738 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { webdriverException_methodinfo.get() } as *const _ as *const JSJitInfo },
16739 nargs: 0,
16740 flags: (JSPROP_ENUMERATE) as u16,
16741 selfHostedName: ptr::null()
16742 },
16743 JSFunctionSpec {
16744 name: JSPropertySpec_Name { string_: c"webdriverElement".as_ptr() },
16745 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { webdriverElement_methodinfo.get() } as *const _ as *const JSJitInfo },
16746 nargs: 1,
16747 flags: (JSPROP_ENUMERATE) as u16,
16748 selfHostedName: ptr::null()
16749 },
16750 JSFunctionSpec {
16751 name: JSPropertySpec_Name { string_: c"webdriverFrame".as_ptr() },
16752 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { webdriverFrame_methodinfo.get() } as *const _ as *const JSJitInfo },
16753 nargs: 1,
16754 flags: (JSPROP_ENUMERATE) as u16,
16755 selfHostedName: ptr::null()
16756 },
16757 JSFunctionSpec {
16758 name: JSPropertySpec_Name { string_: c"webdriverWindow".as_ptr() },
16759 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { webdriverWindow_methodinfo.get() } as *const _ as *const JSJitInfo },
16760 nargs: 1,
16761 flags: (JSPROP_ENUMERATE) as u16,
16762 selfHostedName: ptr::null()
16763 },
16764 JSFunctionSpec {
16765 name: JSPropertySpec_Name { string_: c"webdriverShadowRoot".as_ptr() },
16766 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { webdriverShadowRoot_methodinfo.get() } as *const _ as *const JSJitInfo },
16767 nargs: 1,
16768 flags: (JSPROP_ENUMERATE) as u16,
16769 selfHostedName: ptr::null()
16770 },
16771 JSFunctionSpec {
16772 name: JSPropertySpec_Name { string_: c"getSelection".as_ptr() },
16773 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getSelection_methodinfo.get() } as *const _ as *const JSJitInfo },
16774 nargs: 0,
16775 flags: (JSPROP_ENUMERATE) as u16,
16776 selfHostedName: ptr::null()
16777 },
16778 JSFunctionSpec {
16779 name: JSPropertySpec_Name { string_: ptr::null() },
16780 call: JSNativeWrapper { op: None, info: ptr::null() },
16781 nargs: 0,
16782 flags: 0,
16783 selfHostedName: ptr::null()
16784 }]))[..]
16785,
16786&Box::leak(Box::new([
16787 JSFunctionSpec {
16788 name: JSPropertySpec_Name { string_: c"fetchLater".as_ptr() },
16789 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { fetchLater_methodinfo.get() } as *const _ as *const JSJitInfo },
16790 nargs: 1,
16791 flags: (JSPROP_ENUMERATE) as u16,
16792 selfHostedName: ptr::null()
16793 },
16794 JSFunctionSpec {
16795 name: JSPropertySpec_Name { string_: ptr::null() },
16796 call: JSNativeWrapper { op: None, info: ptr::null() },
16797 nargs: 0,
16798 flags: 0,
16799 selfHostedName: ptr::null()
16800 }]))[..]
16801,
16802&Box::leak(Box::new([
16803 JSFunctionSpec {
16804 name: JSPropertySpec_Name { string_: c"reportError".as_ptr() },
16805 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { reportError_methodinfo.get() } as *const _ as *const JSJitInfo },
16806 nargs: 1,
16807 flags: (JSPROP_ENUMERATE) as u16,
16808 selfHostedName: ptr::null()
16809 },
16810 JSFunctionSpec {
16811 name: JSPropertySpec_Name { string_: c"btoa".as_ptr() },
16812 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { btoa_methodinfo.get() } as *const _ as *const JSJitInfo },
16813 nargs: 1,
16814 flags: (JSPROP_ENUMERATE) as u16,
16815 selfHostedName: ptr::null()
16816 },
16817 JSFunctionSpec {
16818 name: JSPropertySpec_Name { string_: c"atob".as_ptr() },
16819 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { atob_methodinfo.get() } as *const _ as *const JSJitInfo },
16820 nargs: 1,
16821 flags: (JSPROP_ENUMERATE) as u16,
16822 selfHostedName: ptr::null()
16823 },
16824 JSFunctionSpec {
16825 name: JSPropertySpec_Name { string_: c"setTimeout".as_ptr() },
16826 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setTimeout_methodinfo.get() } as *const _ as *const JSJitInfo },
16827 nargs: 1,
16828 flags: (JSPROP_ENUMERATE) as u16,
16829 selfHostedName: ptr::null()
16830 },
16831 JSFunctionSpec {
16832 name: JSPropertySpec_Name { string_: c"clearTimeout".as_ptr() },
16833 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearTimeout_methodinfo.get() } as *const _ as *const JSJitInfo },
16834 nargs: 0,
16835 flags: (JSPROP_ENUMERATE) as u16,
16836 selfHostedName: ptr::null()
16837 },
16838 JSFunctionSpec {
16839 name: JSPropertySpec_Name { string_: c"setInterval".as_ptr() },
16840 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setInterval_methodinfo.get() } as *const _ as *const JSJitInfo },
16841 nargs: 1,
16842 flags: (JSPROP_ENUMERATE) as u16,
16843 selfHostedName: ptr::null()
16844 },
16845 JSFunctionSpec {
16846 name: JSPropertySpec_Name { string_: c"clearInterval".as_ptr() },
16847 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearInterval_methodinfo.get() } as *const _ as *const JSJitInfo },
16848 nargs: 0,
16849 flags: (JSPROP_ENUMERATE) as u16,
16850 selfHostedName: ptr::null()
16851 },
16852 JSFunctionSpec {
16853 name: JSPropertySpec_Name { string_: c"queueMicrotask".as_ptr() },
16854 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { queueMicrotask_methodinfo.get() } as *const _ as *const JSJitInfo },
16855 nargs: 1,
16856 flags: (JSPROP_ENUMERATE) as u16,
16857 selfHostedName: ptr::null()
16858 },
16859 JSFunctionSpec {
16860 name: JSPropertySpec_Name { string_: c"createImageBitmap".as_ptr() },
16861 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { createImageBitmap_methodinfo.get() } as *const _ as *const JSJitInfo },
16862 nargs: 1,
16863 flags: (JSPROP_ENUMERATE) as u16,
16864 selfHostedName: ptr::null()
16865 },
16866 JSFunctionSpec {
16867 name: JSPropertySpec_Name { string_: c"structuredClone".as_ptr() },
16868 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { structuredClone_methodinfo.get() } as *const _ as *const JSJitInfo },
16869 nargs: 1,
16870 flags: (JSPROP_ENUMERATE) as u16,
16871 selfHostedName: ptr::null()
16872 },
16873 JSFunctionSpec {
16874 name: JSPropertySpec_Name { string_: c"fetch".as_ptr() },
16875 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { fetch_methodinfo.get() } as *const _ as *const JSJitInfo },
16876 nargs: 1,
16877 flags: (JSPROP_ENUMERATE) as u16,
16878 selfHostedName: ptr::null()
16879 },
16880 JSFunctionSpec {
16881 name: JSPropertySpec_Name { string_: ptr::null() },
16882 call: JSNativeWrapper { op: None, info: ptr::null() },
16883 nargs: 0,
16884 flags: 0,
16885 selfHostedName: ptr::null()
16886 }]))[..]
16887])));
16888}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
16889
16890pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
16891 sMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[0]),
16892 Guard::new(&[Condition::Pref("dom_servo_helpers_enabled"),Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[1]),
16893 Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[2]),
16894 Guard::new(&[Condition::SecureContext(),Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[3]),
16895 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[4])])));
16896}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
16897
16898pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
16899 sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
16900 JSPropertySpec {
16901 name: JSPropertySpec_Name { string_: c"self".as_ptr() },
16902 attributes_: (JSPROP_ENUMERATE),
16903 kind_: (JSPropertySpec_Kind::NativeAccessor),
16904 u: JSPropertySpec_AccessorsOrValue {
16905 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16906 getter: JSPropertySpec_Accessor {
16907 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { self_getterinfo.get() } },
16908 },
16909 setter: JSPropertySpec_Accessor {
16910 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { self_setterinfo.get() } },
16911 }
16912 }
16913 }
16914 }
16915,
16916 JSPropertySpec {
16917 name: JSPropertySpec_Name { string_: c"name".as_ptr() },
16918 attributes_: (JSPROP_ENUMERATE),
16919 kind_: (JSPropertySpec_Kind::NativeAccessor),
16920 u: JSPropertySpec_AccessorsOrValue {
16921 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16922 getter: JSPropertySpec_Accessor {
16923 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { name_getterinfo.get() } },
16924 },
16925 setter: JSPropertySpec_Accessor {
16926 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { name_setterinfo.get() } },
16927 }
16928 }
16929 }
16930 }
16931,
16932 JSPropertySpec {
16933 name: JSPropertySpec_Name { string_: c"history".as_ptr() },
16934 attributes_: (JSPROP_ENUMERATE),
16935 kind_: (JSPropertySpec_Kind::NativeAccessor),
16936 u: JSPropertySpec_AccessorsOrValue {
16937 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16938 getter: JSPropertySpec_Accessor {
16939 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { history_getterinfo.get() } },
16940 },
16941 setter: JSPropertySpec_Accessor {
16942 native: JSNativeWrapper { op: None, info: ptr::null() },
16943 }
16944 }
16945 }
16946 }
16947,
16948 JSPropertySpec {
16949 name: JSPropertySpec_Name { string_: c"customElements".as_ptr() },
16950 attributes_: (JSPROP_ENUMERATE),
16951 kind_: (JSPropertySpec_Kind::NativeAccessor),
16952 u: JSPropertySpec_AccessorsOrValue {
16953 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16954 getter: JSPropertySpec_Accessor {
16955 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { customElements_getterinfo.get() } },
16956 },
16957 setter: JSPropertySpec_Accessor {
16958 native: JSNativeWrapper { op: None, info: ptr::null() },
16959 }
16960 }
16961 }
16962 }
16963,
16964 JSPropertySpec {
16965 name: JSPropertySpec_Name { string_: c"status".as_ptr() },
16966 attributes_: (JSPROP_ENUMERATE),
16967 kind_: (JSPropertySpec_Kind::NativeAccessor),
16968 u: JSPropertySpec_AccessorsOrValue {
16969 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16970 getter: JSPropertySpec_Accessor {
16971 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { status_getterinfo.get() } },
16972 },
16973 setter: JSPropertySpec_Accessor {
16974 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { status_setterinfo.get() } },
16975 }
16976 }
16977 }
16978 }
16979,
16980 JSPropertySpec {
16981 name: JSPropertySpec_Name { string_: c"closed".as_ptr() },
16982 attributes_: (JSPROP_ENUMERATE),
16983 kind_: (JSPropertySpec_Kind::NativeAccessor),
16984 u: JSPropertySpec_AccessorsOrValue {
16985 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16986 getter: JSPropertySpec_Accessor {
16987 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { closed_getterinfo.get() } },
16988 },
16989 setter: JSPropertySpec_Accessor {
16990 native: JSNativeWrapper { op: None, info: ptr::null() },
16991 }
16992 }
16993 }
16994 }
16995,
16996 JSPropertySpec {
16997 name: JSPropertySpec_Name { string_: c"frames".as_ptr() },
16998 attributes_: (JSPROP_ENUMERATE),
16999 kind_: (JSPropertySpec_Kind::NativeAccessor),
17000 u: JSPropertySpec_AccessorsOrValue {
17001 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17002 getter: JSPropertySpec_Accessor {
17003 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { frames_getterinfo.get() } },
17004 },
17005 setter: JSPropertySpec_Accessor {
17006 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { frames_setterinfo.get() } },
17007 }
17008 }
17009 }
17010 }
17011,
17012 JSPropertySpec {
17013 name: JSPropertySpec_Name { string_: c"length".as_ptr() },
17014 attributes_: (JSPROP_ENUMERATE),
17015 kind_: (JSPropertySpec_Kind::NativeAccessor),
17016 u: JSPropertySpec_AccessorsOrValue {
17017 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17018 getter: JSPropertySpec_Accessor {
17019 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { length_getterinfo.get() } },
17020 },
17021 setter: JSPropertySpec_Accessor {
17022 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { length_setterinfo.get() } },
17023 }
17024 }
17025 }
17026 }
17027,
17028 JSPropertySpec {
17029 name: JSPropertySpec_Name { string_: c"opener".as_ptr() },
17030 attributes_: (JSPROP_ENUMERATE),
17031 kind_: (JSPropertySpec_Kind::NativeAccessor),
17032 u: JSPropertySpec_AccessorsOrValue {
17033 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17034 getter: JSPropertySpec_Accessor {
17035 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { opener_getterinfo.get() } },
17036 },
17037 setter: JSPropertySpec_Accessor {
17038 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { opener_setterinfo.get() } },
17039 }
17040 }
17041 }
17042 }
17043,
17044 JSPropertySpec {
17045 name: JSPropertySpec_Name { string_: c"parent".as_ptr() },
17046 attributes_: (JSPROP_ENUMERATE),
17047 kind_: (JSPropertySpec_Kind::NativeAccessor),
17048 u: JSPropertySpec_AccessorsOrValue {
17049 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17050 getter: JSPropertySpec_Accessor {
17051 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { parent_getterinfo.get() } },
17052 },
17053 setter: JSPropertySpec_Accessor {
17054 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { parent_setterinfo.get() } },
17055 }
17056 }
17057 }
17058 }
17059,
17060 JSPropertySpec {
17061 name: JSPropertySpec_Name { string_: c"frameElement".as_ptr() },
17062 attributes_: (JSPROP_ENUMERATE),
17063 kind_: (JSPropertySpec_Kind::NativeAccessor),
17064 u: JSPropertySpec_AccessorsOrValue {
17065 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17066 getter: JSPropertySpec_Accessor {
17067 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { frameElement_getterinfo.get() } },
17068 },
17069 setter: JSPropertySpec_Accessor {
17070 native: JSNativeWrapper { op: None, info: ptr::null() },
17071 }
17072 }
17073 }
17074 }
17075,
17076 JSPropertySpec {
17077 name: JSPropertySpec_Name { string_: c"navigator".as_ptr() },
17078 attributes_: (JSPROP_ENUMERATE),
17079 kind_: (JSPropertySpec_Kind::NativeAccessor),
17080 u: JSPropertySpec_AccessorsOrValue {
17081 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17082 getter: JSPropertySpec_Accessor {
17083 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { navigator_getterinfo.get() } },
17084 },
17085 setter: JSPropertySpec_Accessor {
17086 native: JSNativeWrapper { op: None, info: ptr::null() },
17087 }
17088 }
17089 }
17090 }
17091,
17092 JSPropertySpec {
17093 name: JSPropertySpec_Name { string_: c"screen".as_ptr() },
17094 attributes_: (JSPROP_ENUMERATE),
17095 kind_: (JSPropertySpec_Kind::NativeAccessor),
17096 u: JSPropertySpec_AccessorsOrValue {
17097 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17098 getter: JSPropertySpec_Accessor {
17099 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { screen_getterinfo.get() } },
17100 },
17101 setter: JSPropertySpec_Accessor {
17102 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { screen_setterinfo.get() } },
17103 }
17104 }
17105 }
17106 }
17107,
17108 JSPropertySpec {
17109 name: JSPropertySpec_Name { string_: c"innerWidth".as_ptr() },
17110 attributes_: (JSPROP_ENUMERATE),
17111 kind_: (JSPropertySpec_Kind::NativeAccessor),
17112 u: JSPropertySpec_AccessorsOrValue {
17113 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17114 getter: JSPropertySpec_Accessor {
17115 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { innerWidth_getterinfo.get() } },
17116 },
17117 setter: JSPropertySpec_Accessor {
17118 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { innerWidth_setterinfo.get() } },
17119 }
17120 }
17121 }
17122 }
17123,
17124 JSPropertySpec {
17125 name: JSPropertySpec_Name { string_: c"innerHeight".as_ptr() },
17126 attributes_: (JSPROP_ENUMERATE),
17127 kind_: (JSPropertySpec_Kind::NativeAccessor),
17128 u: JSPropertySpec_AccessorsOrValue {
17129 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17130 getter: JSPropertySpec_Accessor {
17131 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { innerHeight_getterinfo.get() } },
17132 },
17133 setter: JSPropertySpec_Accessor {
17134 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { innerHeight_setterinfo.get() } },
17135 }
17136 }
17137 }
17138 }
17139,
17140 JSPropertySpec {
17141 name: JSPropertySpec_Name { string_: c"scrollX".as_ptr() },
17142 attributes_: (JSPROP_ENUMERATE),
17143 kind_: (JSPropertySpec_Kind::NativeAccessor),
17144 u: JSPropertySpec_AccessorsOrValue {
17145 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17146 getter: JSPropertySpec_Accessor {
17147 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { scrollX_getterinfo.get() } },
17148 },
17149 setter: JSPropertySpec_Accessor {
17150 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { scrollX_setterinfo.get() } },
17151 }
17152 }
17153 }
17154 }
17155,
17156 JSPropertySpec {
17157 name: JSPropertySpec_Name { string_: c"pageXOffset".as_ptr() },
17158 attributes_: (JSPROP_ENUMERATE),
17159 kind_: (JSPropertySpec_Kind::NativeAccessor),
17160 u: JSPropertySpec_AccessorsOrValue {
17161 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17162 getter: JSPropertySpec_Accessor {
17163 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { pageXOffset_getterinfo.get() } },
17164 },
17165 setter: JSPropertySpec_Accessor {
17166 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { pageXOffset_setterinfo.get() } },
17167 }
17168 }
17169 }
17170 }
17171,
17172 JSPropertySpec {
17173 name: JSPropertySpec_Name { string_: c"scrollY".as_ptr() },
17174 attributes_: (JSPROP_ENUMERATE),
17175 kind_: (JSPropertySpec_Kind::NativeAccessor),
17176 u: JSPropertySpec_AccessorsOrValue {
17177 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17178 getter: JSPropertySpec_Accessor {
17179 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { scrollY_getterinfo.get() } },
17180 },
17181 setter: JSPropertySpec_Accessor {
17182 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { scrollY_setterinfo.get() } },
17183 }
17184 }
17185 }
17186 }
17187,
17188 JSPropertySpec {
17189 name: JSPropertySpec_Name { string_: c"pageYOffset".as_ptr() },
17190 attributes_: (JSPROP_ENUMERATE),
17191 kind_: (JSPropertySpec_Kind::NativeAccessor),
17192 u: JSPropertySpec_AccessorsOrValue {
17193 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17194 getter: JSPropertySpec_Accessor {
17195 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { pageYOffset_getterinfo.get() } },
17196 },
17197 setter: JSPropertySpec_Accessor {
17198 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { pageYOffset_setterinfo.get() } },
17199 }
17200 }
17201 }
17202 }
17203,
17204 JSPropertySpec {
17205 name: JSPropertySpec_Name { string_: c"screenX".as_ptr() },
17206 attributes_: (JSPROP_ENUMERATE),
17207 kind_: (JSPropertySpec_Kind::NativeAccessor),
17208 u: JSPropertySpec_AccessorsOrValue {
17209 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17210 getter: JSPropertySpec_Accessor {
17211 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { screenX_getterinfo.get() } },
17212 },
17213 setter: JSPropertySpec_Accessor {
17214 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { screenX_setterinfo.get() } },
17215 }
17216 }
17217 }
17218 }
17219,
17220 JSPropertySpec {
17221 name: JSPropertySpec_Name { string_: c"screenY".as_ptr() },
17222 attributes_: (JSPROP_ENUMERATE),
17223 kind_: (JSPropertySpec_Kind::NativeAccessor),
17224 u: JSPropertySpec_AccessorsOrValue {
17225 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17226 getter: JSPropertySpec_Accessor {
17227 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { screenY_getterinfo.get() } },
17228 },
17229 setter: JSPropertySpec_Accessor {
17230 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { screenY_setterinfo.get() } },
17231 }
17232 }
17233 }
17234 }
17235,
17236 JSPropertySpec {
17237 name: JSPropertySpec_Name { string_: c"outerWidth".as_ptr() },
17238 attributes_: (JSPROP_ENUMERATE),
17239 kind_: (JSPropertySpec_Kind::NativeAccessor),
17240 u: JSPropertySpec_AccessorsOrValue {
17241 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17242 getter: JSPropertySpec_Accessor {
17243 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { outerWidth_getterinfo.get() } },
17244 },
17245 setter: JSPropertySpec_Accessor {
17246 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { outerWidth_setterinfo.get() } },
17247 }
17248 }
17249 }
17250 }
17251,
17252 JSPropertySpec {
17253 name: JSPropertySpec_Name { string_: c"outerHeight".as_ptr() },
17254 attributes_: (JSPROP_ENUMERATE),
17255 kind_: (JSPropertySpec_Kind::NativeAccessor),
17256 u: JSPropertySpec_AccessorsOrValue {
17257 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17258 getter: JSPropertySpec_Accessor {
17259 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { outerHeight_getterinfo.get() } },
17260 },
17261 setter: JSPropertySpec_Accessor {
17262 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { outerHeight_setterinfo.get() } },
17263 }
17264 }
17265 }
17266 }
17267,
17268 JSPropertySpec {
17269 name: JSPropertySpec_Name { string_: c"devicePixelRatio".as_ptr() },
17270 attributes_: (JSPROP_ENUMERATE),
17271 kind_: (JSPropertySpec_Kind::NativeAccessor),
17272 u: JSPropertySpec_AccessorsOrValue {
17273 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17274 getter: JSPropertySpec_Accessor {
17275 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { devicePixelRatio_getterinfo.get() } },
17276 },
17277 setter: JSPropertySpec_Accessor {
17278 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { devicePixelRatio_setterinfo.get() } },
17279 }
17280 }
17281 }
17282 }
17283,
17284 JSPropertySpec::ZERO]))[..]
17285,
17286&Box::leak(Box::new([
17287 JSPropertySpec {
17288 name: JSPropertySpec_Name { string_: c"runningAnimationCount".as_ptr() },
17289 attributes_: (JSPROP_ENUMERATE),
17290 kind_: (JSPropertySpec_Kind::NativeAccessor),
17291 u: JSPropertySpec_AccessorsOrValue {
17292 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17293 getter: JSPropertySpec_Accessor {
17294 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { runningAnimationCount_getterinfo.get() } },
17295 },
17296 setter: JSPropertySpec_Accessor {
17297 native: JSNativeWrapper { op: None, info: ptr::null() },
17298 }
17299 }
17300 }
17301 }
17302,
17303 JSPropertySpec::ZERO]))[..]
17304,
17305&Box::leak(Box::new([
17306 JSPropertySpec {
17307 name: JSPropertySpec_Name { string_: c"event".as_ptr() },
17308 attributes_: (JSPROP_ENUMERATE),
17309 kind_: (JSPropertySpec_Kind::NativeAccessor),
17310 u: JSPropertySpec_AccessorsOrValue {
17311 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17312 getter: JSPropertySpec_Accessor {
17313 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { event_getterinfo.get() } },
17314 },
17315 setter: JSPropertySpec_Accessor {
17316 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { event_setterinfo.get() } },
17317 }
17318 }
17319 }
17320 }
17321,
17322 JSPropertySpec::ZERO]))[..]
17323,
17324&Box::leak(Box::new([
17325 JSPropertySpec {
17326 name: JSPropertySpec_Name { string_: c"cookieStore".as_ptr() },
17327 attributes_: (JSPROP_ENUMERATE),
17328 kind_: (JSPropertySpec_Kind::NativeAccessor),
17329 u: JSPropertySpec_AccessorsOrValue {
17330 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17331 getter: JSPropertySpec_Accessor {
17332 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { cookieStore_getterinfo.get() } },
17333 },
17334 setter: JSPropertySpec_Accessor {
17335 native: JSNativeWrapper { op: None, info: ptr::null() },
17336 }
17337 }
17338 }
17339 }
17340,
17341 JSPropertySpec::ZERO]))[..]
17342,
17343&Box::leak(Box::new([
17344 JSPropertySpec {
17345 name: JSPropertySpec_Name { string_: c"testRunner".as_ptr() },
17346 attributes_: (JSPROP_ENUMERATE),
17347 kind_: (JSPropertySpec_Kind::NativeAccessor),
17348 u: JSPropertySpec_AccessorsOrValue {
17349 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17350 getter: JSPropertySpec_Accessor {
17351 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { testRunner_getterinfo.get() } },
17352 },
17353 setter: JSPropertySpec_Accessor {
17354 native: JSNativeWrapper { op: None, info: ptr::null() },
17355 }
17356 }
17357 }
17358 }
17359,
17360 JSPropertySpec::ZERO]))[..]
17361,
17362&Box::leak(Box::new([
17363 JSPropertySpec {
17364 name: JSPropertySpec_Name { string_: c"onabort".as_ptr() },
17365 attributes_: (JSPROP_ENUMERATE),
17366 kind_: (JSPropertySpec_Kind::NativeAccessor),
17367 u: JSPropertySpec_AccessorsOrValue {
17368 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17369 getter: JSPropertySpec_Accessor {
17370 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onabort_getterinfo.get() } },
17371 },
17372 setter: JSPropertySpec_Accessor {
17373 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onabort_setterinfo.get() } },
17374 }
17375 }
17376 }
17377 }
17378,
17379 JSPropertySpec {
17380 name: JSPropertySpec_Name { string_: c"onauxclick".as_ptr() },
17381 attributes_: (JSPROP_ENUMERATE),
17382 kind_: (JSPropertySpec_Kind::NativeAccessor),
17383 u: JSPropertySpec_AccessorsOrValue {
17384 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17385 getter: JSPropertySpec_Accessor {
17386 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onauxclick_getterinfo.get() } },
17387 },
17388 setter: JSPropertySpec_Accessor {
17389 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onauxclick_setterinfo.get() } },
17390 }
17391 }
17392 }
17393 }
17394,
17395 JSPropertySpec {
17396 name: JSPropertySpec_Name { string_: c"onbeforeinput".as_ptr() },
17397 attributes_: (JSPROP_ENUMERATE),
17398 kind_: (JSPropertySpec_Kind::NativeAccessor),
17399 u: JSPropertySpec_AccessorsOrValue {
17400 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17401 getter: JSPropertySpec_Accessor {
17402 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onbeforeinput_getterinfo.get() } },
17403 },
17404 setter: JSPropertySpec_Accessor {
17405 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onbeforeinput_setterinfo.get() } },
17406 }
17407 }
17408 }
17409 }
17410,
17411 JSPropertySpec {
17412 name: JSPropertySpec_Name { string_: c"onbeforematch".as_ptr() },
17413 attributes_: (JSPROP_ENUMERATE),
17414 kind_: (JSPropertySpec_Kind::NativeAccessor),
17415 u: JSPropertySpec_AccessorsOrValue {
17416 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17417 getter: JSPropertySpec_Accessor {
17418 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onbeforematch_getterinfo.get() } },
17419 },
17420 setter: JSPropertySpec_Accessor {
17421 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onbeforematch_setterinfo.get() } },
17422 }
17423 }
17424 }
17425 }
17426,
17427 JSPropertySpec {
17428 name: JSPropertySpec_Name { string_: c"onbeforetoggle".as_ptr() },
17429 attributes_: (JSPROP_ENUMERATE),
17430 kind_: (JSPropertySpec_Kind::NativeAccessor),
17431 u: JSPropertySpec_AccessorsOrValue {
17432 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17433 getter: JSPropertySpec_Accessor {
17434 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onbeforetoggle_getterinfo.get() } },
17435 },
17436 setter: JSPropertySpec_Accessor {
17437 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onbeforetoggle_setterinfo.get() } },
17438 }
17439 }
17440 }
17441 }
17442,
17443 JSPropertySpec {
17444 name: JSPropertySpec_Name { string_: c"onblur".as_ptr() },
17445 attributes_: (JSPROP_ENUMERATE),
17446 kind_: (JSPropertySpec_Kind::NativeAccessor),
17447 u: JSPropertySpec_AccessorsOrValue {
17448 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17449 getter: JSPropertySpec_Accessor {
17450 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onblur_getterinfo.get() } },
17451 },
17452 setter: JSPropertySpec_Accessor {
17453 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onblur_setterinfo.get() } },
17454 }
17455 }
17456 }
17457 }
17458,
17459 JSPropertySpec {
17460 name: JSPropertySpec_Name { string_: c"oncancel".as_ptr() },
17461 attributes_: (JSPROP_ENUMERATE),
17462 kind_: (JSPropertySpec_Kind::NativeAccessor),
17463 u: JSPropertySpec_AccessorsOrValue {
17464 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17465 getter: JSPropertySpec_Accessor {
17466 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncancel_getterinfo.get() } },
17467 },
17468 setter: JSPropertySpec_Accessor {
17469 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncancel_setterinfo.get() } },
17470 }
17471 }
17472 }
17473 }
17474,
17475 JSPropertySpec {
17476 name: JSPropertySpec_Name { string_: c"oncanplay".as_ptr() },
17477 attributes_: (JSPROP_ENUMERATE),
17478 kind_: (JSPropertySpec_Kind::NativeAccessor),
17479 u: JSPropertySpec_AccessorsOrValue {
17480 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17481 getter: JSPropertySpec_Accessor {
17482 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncanplay_getterinfo.get() } },
17483 },
17484 setter: JSPropertySpec_Accessor {
17485 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncanplay_setterinfo.get() } },
17486 }
17487 }
17488 }
17489 }
17490,
17491 JSPropertySpec {
17492 name: JSPropertySpec_Name { string_: c"oncanplaythrough".as_ptr() },
17493 attributes_: (JSPROP_ENUMERATE),
17494 kind_: (JSPropertySpec_Kind::NativeAccessor),
17495 u: JSPropertySpec_AccessorsOrValue {
17496 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17497 getter: JSPropertySpec_Accessor {
17498 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncanplaythrough_getterinfo.get() } },
17499 },
17500 setter: JSPropertySpec_Accessor {
17501 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncanplaythrough_setterinfo.get() } },
17502 }
17503 }
17504 }
17505 }
17506,
17507 JSPropertySpec {
17508 name: JSPropertySpec_Name { string_: c"onchange".as_ptr() },
17509 attributes_: (JSPROP_ENUMERATE),
17510 kind_: (JSPropertySpec_Kind::NativeAccessor),
17511 u: JSPropertySpec_AccessorsOrValue {
17512 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17513 getter: JSPropertySpec_Accessor {
17514 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onchange_getterinfo.get() } },
17515 },
17516 setter: JSPropertySpec_Accessor {
17517 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onchange_setterinfo.get() } },
17518 }
17519 }
17520 }
17521 }
17522,
17523 JSPropertySpec {
17524 name: JSPropertySpec_Name { string_: c"onclick".as_ptr() },
17525 attributes_: (JSPROP_ENUMERATE),
17526 kind_: (JSPropertySpec_Kind::NativeAccessor),
17527 u: JSPropertySpec_AccessorsOrValue {
17528 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17529 getter: JSPropertySpec_Accessor {
17530 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onclick_getterinfo.get() } },
17531 },
17532 setter: JSPropertySpec_Accessor {
17533 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onclick_setterinfo.get() } },
17534 }
17535 }
17536 }
17537 }
17538,
17539 JSPropertySpec {
17540 name: JSPropertySpec_Name { string_: c"onclose".as_ptr() },
17541 attributes_: (JSPROP_ENUMERATE),
17542 kind_: (JSPropertySpec_Kind::NativeAccessor),
17543 u: JSPropertySpec_AccessorsOrValue {
17544 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17545 getter: JSPropertySpec_Accessor {
17546 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onclose_getterinfo.get() } },
17547 },
17548 setter: JSPropertySpec_Accessor {
17549 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onclose_setterinfo.get() } },
17550 }
17551 }
17552 }
17553 }
17554,
17555 JSPropertySpec {
17556 name: JSPropertySpec_Name { string_: c"oncommand".as_ptr() },
17557 attributes_: (JSPROP_ENUMERATE),
17558 kind_: (JSPropertySpec_Kind::NativeAccessor),
17559 u: JSPropertySpec_AccessorsOrValue {
17560 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17561 getter: JSPropertySpec_Accessor {
17562 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncommand_getterinfo.get() } },
17563 },
17564 setter: JSPropertySpec_Accessor {
17565 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncommand_setterinfo.get() } },
17566 }
17567 }
17568 }
17569 }
17570,
17571 JSPropertySpec {
17572 name: JSPropertySpec_Name { string_: c"oncontextlost".as_ptr() },
17573 attributes_: (JSPROP_ENUMERATE),
17574 kind_: (JSPropertySpec_Kind::NativeAccessor),
17575 u: JSPropertySpec_AccessorsOrValue {
17576 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17577 getter: JSPropertySpec_Accessor {
17578 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncontextlost_getterinfo.get() } },
17579 },
17580 setter: JSPropertySpec_Accessor {
17581 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncontextlost_setterinfo.get() } },
17582 }
17583 }
17584 }
17585 }
17586,
17587 JSPropertySpec {
17588 name: JSPropertySpec_Name { string_: c"oncontextmenu".as_ptr() },
17589 attributes_: (JSPROP_ENUMERATE),
17590 kind_: (JSPropertySpec_Kind::NativeAccessor),
17591 u: JSPropertySpec_AccessorsOrValue {
17592 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17593 getter: JSPropertySpec_Accessor {
17594 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncontextmenu_getterinfo.get() } },
17595 },
17596 setter: JSPropertySpec_Accessor {
17597 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncontextmenu_setterinfo.get() } },
17598 }
17599 }
17600 }
17601 }
17602,
17603 JSPropertySpec {
17604 name: JSPropertySpec_Name { string_: c"oncontextrestored".as_ptr() },
17605 attributes_: (JSPROP_ENUMERATE),
17606 kind_: (JSPropertySpec_Kind::NativeAccessor),
17607 u: JSPropertySpec_AccessorsOrValue {
17608 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17609 getter: JSPropertySpec_Accessor {
17610 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncontextrestored_getterinfo.get() } },
17611 },
17612 setter: JSPropertySpec_Accessor {
17613 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncontextrestored_setterinfo.get() } },
17614 }
17615 }
17616 }
17617 }
17618,
17619 JSPropertySpec {
17620 name: JSPropertySpec_Name { string_: c"oncopy".as_ptr() },
17621 attributes_: (JSPROP_ENUMERATE),
17622 kind_: (JSPropertySpec_Kind::NativeAccessor),
17623 u: JSPropertySpec_AccessorsOrValue {
17624 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17625 getter: JSPropertySpec_Accessor {
17626 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncopy_getterinfo.get() } },
17627 },
17628 setter: JSPropertySpec_Accessor {
17629 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncopy_setterinfo.get() } },
17630 }
17631 }
17632 }
17633 }
17634,
17635 JSPropertySpec {
17636 name: JSPropertySpec_Name { string_: c"oncuechange".as_ptr() },
17637 attributes_: (JSPROP_ENUMERATE),
17638 kind_: (JSPropertySpec_Kind::NativeAccessor),
17639 u: JSPropertySpec_AccessorsOrValue {
17640 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17641 getter: JSPropertySpec_Accessor {
17642 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncuechange_getterinfo.get() } },
17643 },
17644 setter: JSPropertySpec_Accessor {
17645 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncuechange_setterinfo.get() } },
17646 }
17647 }
17648 }
17649 }
17650,
17651 JSPropertySpec {
17652 name: JSPropertySpec_Name { string_: c"oncut".as_ptr() },
17653 attributes_: (JSPROP_ENUMERATE),
17654 kind_: (JSPropertySpec_Kind::NativeAccessor),
17655 u: JSPropertySpec_AccessorsOrValue {
17656 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17657 getter: JSPropertySpec_Accessor {
17658 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncut_getterinfo.get() } },
17659 },
17660 setter: JSPropertySpec_Accessor {
17661 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncut_setterinfo.get() } },
17662 }
17663 }
17664 }
17665 }
17666,
17667 JSPropertySpec {
17668 name: JSPropertySpec_Name { string_: c"ondblclick".as_ptr() },
17669 attributes_: (JSPROP_ENUMERATE),
17670 kind_: (JSPropertySpec_Kind::NativeAccessor),
17671 u: JSPropertySpec_AccessorsOrValue {
17672 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17673 getter: JSPropertySpec_Accessor {
17674 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondblclick_getterinfo.get() } },
17675 },
17676 setter: JSPropertySpec_Accessor {
17677 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondblclick_setterinfo.get() } },
17678 }
17679 }
17680 }
17681 }
17682,
17683 JSPropertySpec {
17684 name: JSPropertySpec_Name { string_: c"ondrag".as_ptr() },
17685 attributes_: (JSPROP_ENUMERATE),
17686 kind_: (JSPropertySpec_Kind::NativeAccessor),
17687 u: JSPropertySpec_AccessorsOrValue {
17688 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17689 getter: JSPropertySpec_Accessor {
17690 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondrag_getterinfo.get() } },
17691 },
17692 setter: JSPropertySpec_Accessor {
17693 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondrag_setterinfo.get() } },
17694 }
17695 }
17696 }
17697 }
17698,
17699 JSPropertySpec {
17700 name: JSPropertySpec_Name { string_: c"ondragend".as_ptr() },
17701 attributes_: (JSPROP_ENUMERATE),
17702 kind_: (JSPropertySpec_Kind::NativeAccessor),
17703 u: JSPropertySpec_AccessorsOrValue {
17704 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17705 getter: JSPropertySpec_Accessor {
17706 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragend_getterinfo.get() } },
17707 },
17708 setter: JSPropertySpec_Accessor {
17709 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragend_setterinfo.get() } },
17710 }
17711 }
17712 }
17713 }
17714,
17715 JSPropertySpec {
17716 name: JSPropertySpec_Name { string_: c"ondragenter".as_ptr() },
17717 attributes_: (JSPROP_ENUMERATE),
17718 kind_: (JSPropertySpec_Kind::NativeAccessor),
17719 u: JSPropertySpec_AccessorsOrValue {
17720 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17721 getter: JSPropertySpec_Accessor {
17722 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragenter_getterinfo.get() } },
17723 },
17724 setter: JSPropertySpec_Accessor {
17725 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragenter_setterinfo.get() } },
17726 }
17727 }
17728 }
17729 }
17730,
17731 JSPropertySpec {
17732 name: JSPropertySpec_Name { string_: c"ondragleave".as_ptr() },
17733 attributes_: (JSPROP_ENUMERATE),
17734 kind_: (JSPropertySpec_Kind::NativeAccessor),
17735 u: JSPropertySpec_AccessorsOrValue {
17736 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17737 getter: JSPropertySpec_Accessor {
17738 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragleave_getterinfo.get() } },
17739 },
17740 setter: JSPropertySpec_Accessor {
17741 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragleave_setterinfo.get() } },
17742 }
17743 }
17744 }
17745 }
17746,
17747 JSPropertySpec {
17748 name: JSPropertySpec_Name { string_: c"ondragover".as_ptr() },
17749 attributes_: (JSPROP_ENUMERATE),
17750 kind_: (JSPropertySpec_Kind::NativeAccessor),
17751 u: JSPropertySpec_AccessorsOrValue {
17752 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17753 getter: JSPropertySpec_Accessor {
17754 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragover_getterinfo.get() } },
17755 },
17756 setter: JSPropertySpec_Accessor {
17757 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragover_setterinfo.get() } },
17758 }
17759 }
17760 }
17761 }
17762,
17763 JSPropertySpec {
17764 name: JSPropertySpec_Name { string_: c"ondragstart".as_ptr() },
17765 attributes_: (JSPROP_ENUMERATE),
17766 kind_: (JSPropertySpec_Kind::NativeAccessor),
17767 u: JSPropertySpec_AccessorsOrValue {
17768 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17769 getter: JSPropertySpec_Accessor {
17770 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragstart_getterinfo.get() } },
17771 },
17772 setter: JSPropertySpec_Accessor {
17773 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragstart_setterinfo.get() } },
17774 }
17775 }
17776 }
17777 }
17778,
17779 JSPropertySpec {
17780 name: JSPropertySpec_Name { string_: c"ondrop".as_ptr() },
17781 attributes_: (JSPROP_ENUMERATE),
17782 kind_: (JSPropertySpec_Kind::NativeAccessor),
17783 u: JSPropertySpec_AccessorsOrValue {
17784 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17785 getter: JSPropertySpec_Accessor {
17786 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondrop_getterinfo.get() } },
17787 },
17788 setter: JSPropertySpec_Accessor {
17789 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondrop_setterinfo.get() } },
17790 }
17791 }
17792 }
17793 }
17794,
17795 JSPropertySpec {
17796 name: JSPropertySpec_Name { string_: c"ondurationchange".as_ptr() },
17797 attributes_: (JSPROP_ENUMERATE),
17798 kind_: (JSPropertySpec_Kind::NativeAccessor),
17799 u: JSPropertySpec_AccessorsOrValue {
17800 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17801 getter: JSPropertySpec_Accessor {
17802 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondurationchange_getterinfo.get() } },
17803 },
17804 setter: JSPropertySpec_Accessor {
17805 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondurationchange_setterinfo.get() } },
17806 }
17807 }
17808 }
17809 }
17810,
17811 JSPropertySpec {
17812 name: JSPropertySpec_Name { string_: c"onemptied".as_ptr() },
17813 attributes_: (JSPROP_ENUMERATE),
17814 kind_: (JSPropertySpec_Kind::NativeAccessor),
17815 u: JSPropertySpec_AccessorsOrValue {
17816 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17817 getter: JSPropertySpec_Accessor {
17818 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onemptied_getterinfo.get() } },
17819 },
17820 setter: JSPropertySpec_Accessor {
17821 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onemptied_setterinfo.get() } },
17822 }
17823 }
17824 }
17825 }
17826,
17827 JSPropertySpec {
17828 name: JSPropertySpec_Name { string_: c"onended".as_ptr() },
17829 attributes_: (JSPROP_ENUMERATE),
17830 kind_: (JSPropertySpec_Kind::NativeAccessor),
17831 u: JSPropertySpec_AccessorsOrValue {
17832 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17833 getter: JSPropertySpec_Accessor {
17834 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onended_getterinfo.get() } },
17835 },
17836 setter: JSPropertySpec_Accessor {
17837 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onended_setterinfo.get() } },
17838 }
17839 }
17840 }
17841 }
17842,
17843 JSPropertySpec {
17844 name: JSPropertySpec_Name { string_: c"onerror".as_ptr() },
17845 attributes_: (JSPROP_ENUMERATE),
17846 kind_: (JSPropertySpec_Kind::NativeAccessor),
17847 u: JSPropertySpec_AccessorsOrValue {
17848 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17849 getter: JSPropertySpec_Accessor {
17850 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onerror_getterinfo.get() } },
17851 },
17852 setter: JSPropertySpec_Accessor {
17853 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onerror_setterinfo.get() } },
17854 }
17855 }
17856 }
17857 }
17858,
17859 JSPropertySpec {
17860 name: JSPropertySpec_Name { string_: c"onfocus".as_ptr() },
17861 attributes_: (JSPROP_ENUMERATE),
17862 kind_: (JSPropertySpec_Kind::NativeAccessor),
17863 u: JSPropertySpec_AccessorsOrValue {
17864 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17865 getter: JSPropertySpec_Accessor {
17866 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onfocus_getterinfo.get() } },
17867 },
17868 setter: JSPropertySpec_Accessor {
17869 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onfocus_setterinfo.get() } },
17870 }
17871 }
17872 }
17873 }
17874,
17875 JSPropertySpec {
17876 name: JSPropertySpec_Name { string_: c"onformdata".as_ptr() },
17877 attributes_: (JSPROP_ENUMERATE),
17878 kind_: (JSPropertySpec_Kind::NativeAccessor),
17879 u: JSPropertySpec_AccessorsOrValue {
17880 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17881 getter: JSPropertySpec_Accessor {
17882 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onformdata_getterinfo.get() } },
17883 },
17884 setter: JSPropertySpec_Accessor {
17885 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onformdata_setterinfo.get() } },
17886 }
17887 }
17888 }
17889 }
17890,
17891 JSPropertySpec {
17892 name: JSPropertySpec_Name { string_: c"oninput".as_ptr() },
17893 attributes_: (JSPROP_ENUMERATE),
17894 kind_: (JSPropertySpec_Kind::NativeAccessor),
17895 u: JSPropertySpec_AccessorsOrValue {
17896 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17897 getter: JSPropertySpec_Accessor {
17898 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oninput_getterinfo.get() } },
17899 },
17900 setter: JSPropertySpec_Accessor {
17901 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oninput_setterinfo.get() } },
17902 }
17903 }
17904 }
17905 }
17906,
17907 JSPropertySpec {
17908 name: JSPropertySpec_Name { string_: c"oninvalid".as_ptr() },
17909 attributes_: (JSPROP_ENUMERATE),
17910 kind_: (JSPropertySpec_Kind::NativeAccessor),
17911 u: JSPropertySpec_AccessorsOrValue {
17912 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17913 getter: JSPropertySpec_Accessor {
17914 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oninvalid_getterinfo.get() } },
17915 },
17916 setter: JSPropertySpec_Accessor {
17917 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oninvalid_setterinfo.get() } },
17918 }
17919 }
17920 }
17921 }
17922,
17923 JSPropertySpec {
17924 name: JSPropertySpec_Name { string_: c"onkeydown".as_ptr() },
17925 attributes_: (JSPROP_ENUMERATE),
17926 kind_: (JSPropertySpec_Kind::NativeAccessor),
17927 u: JSPropertySpec_AccessorsOrValue {
17928 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17929 getter: JSPropertySpec_Accessor {
17930 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onkeydown_getterinfo.get() } },
17931 },
17932 setter: JSPropertySpec_Accessor {
17933 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onkeydown_setterinfo.get() } },
17934 }
17935 }
17936 }
17937 }
17938,
17939 JSPropertySpec {
17940 name: JSPropertySpec_Name { string_: c"onkeypress".as_ptr() },
17941 attributes_: (JSPROP_ENUMERATE),
17942 kind_: (JSPropertySpec_Kind::NativeAccessor),
17943 u: JSPropertySpec_AccessorsOrValue {
17944 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17945 getter: JSPropertySpec_Accessor {
17946 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onkeypress_getterinfo.get() } },
17947 },
17948 setter: JSPropertySpec_Accessor {
17949 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onkeypress_setterinfo.get() } },
17950 }
17951 }
17952 }
17953 }
17954,
17955 JSPropertySpec {
17956 name: JSPropertySpec_Name { string_: c"onkeyup".as_ptr() },
17957 attributes_: (JSPROP_ENUMERATE),
17958 kind_: (JSPropertySpec_Kind::NativeAccessor),
17959 u: JSPropertySpec_AccessorsOrValue {
17960 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17961 getter: JSPropertySpec_Accessor {
17962 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onkeyup_getterinfo.get() } },
17963 },
17964 setter: JSPropertySpec_Accessor {
17965 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onkeyup_setterinfo.get() } },
17966 }
17967 }
17968 }
17969 }
17970,
17971 JSPropertySpec {
17972 name: JSPropertySpec_Name { string_: c"onload".as_ptr() },
17973 attributes_: (JSPROP_ENUMERATE),
17974 kind_: (JSPropertySpec_Kind::NativeAccessor),
17975 u: JSPropertySpec_AccessorsOrValue {
17976 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17977 getter: JSPropertySpec_Accessor {
17978 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onload_getterinfo.get() } },
17979 },
17980 setter: JSPropertySpec_Accessor {
17981 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onload_setterinfo.get() } },
17982 }
17983 }
17984 }
17985 }
17986,
17987 JSPropertySpec {
17988 name: JSPropertySpec_Name { string_: c"onloadeddata".as_ptr() },
17989 attributes_: (JSPROP_ENUMERATE),
17990 kind_: (JSPropertySpec_Kind::NativeAccessor),
17991 u: JSPropertySpec_AccessorsOrValue {
17992 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
17993 getter: JSPropertySpec_Accessor {
17994 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onloadeddata_getterinfo.get() } },
17995 },
17996 setter: JSPropertySpec_Accessor {
17997 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onloadeddata_setterinfo.get() } },
17998 }
17999 }
18000 }
18001 }
18002,
18003 JSPropertySpec {
18004 name: JSPropertySpec_Name { string_: c"onloadedmetadata".as_ptr() },
18005 attributes_: (JSPROP_ENUMERATE),
18006 kind_: (JSPropertySpec_Kind::NativeAccessor),
18007 u: JSPropertySpec_AccessorsOrValue {
18008 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18009 getter: JSPropertySpec_Accessor {
18010 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onloadedmetadata_getterinfo.get() } },
18011 },
18012 setter: JSPropertySpec_Accessor {
18013 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onloadedmetadata_setterinfo.get() } },
18014 }
18015 }
18016 }
18017 }
18018,
18019 JSPropertySpec {
18020 name: JSPropertySpec_Name { string_: c"onloadstart".as_ptr() },
18021 attributes_: (JSPROP_ENUMERATE),
18022 kind_: (JSPropertySpec_Kind::NativeAccessor),
18023 u: JSPropertySpec_AccessorsOrValue {
18024 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18025 getter: JSPropertySpec_Accessor {
18026 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onloadstart_getterinfo.get() } },
18027 },
18028 setter: JSPropertySpec_Accessor {
18029 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onloadstart_setterinfo.get() } },
18030 }
18031 }
18032 }
18033 }
18034,
18035 JSPropertySpec {
18036 name: JSPropertySpec_Name { string_: c"onmousedown".as_ptr() },
18037 attributes_: (JSPROP_ENUMERATE),
18038 kind_: (JSPropertySpec_Kind::NativeAccessor),
18039 u: JSPropertySpec_AccessorsOrValue {
18040 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18041 getter: JSPropertySpec_Accessor {
18042 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmousedown_getterinfo.get() } },
18043 },
18044 setter: JSPropertySpec_Accessor {
18045 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmousedown_setterinfo.get() } },
18046 }
18047 }
18048 }
18049 }
18050,
18051 JSPropertySpec {
18052 name: JSPropertySpec_Name { string_: c"onmouseenter".as_ptr() },
18053 attributes_: (JSPROP_ENUMERATE),
18054 kind_: (JSPropertySpec_Kind::NativeAccessor),
18055 u: JSPropertySpec_AccessorsOrValue {
18056 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18057 getter: JSPropertySpec_Accessor {
18058 native: JSNativeWrapper { op: Some(generic_lenient_getter::<false>), info: unsafe { onmouseenter_getterinfo.get() } },
18059 },
18060 setter: JSPropertySpec_Accessor {
18061 native: JSNativeWrapper { op: Some(generic_lenient_setter), info: unsafe { onmouseenter_setterinfo.get() } },
18062 }
18063 }
18064 }
18065 }
18066,
18067 JSPropertySpec {
18068 name: JSPropertySpec_Name { string_: c"onmouseleave".as_ptr() },
18069 attributes_: (JSPROP_ENUMERATE),
18070 kind_: (JSPropertySpec_Kind::NativeAccessor),
18071 u: JSPropertySpec_AccessorsOrValue {
18072 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18073 getter: JSPropertySpec_Accessor {
18074 native: JSNativeWrapper { op: Some(generic_lenient_getter::<false>), info: unsafe { onmouseleave_getterinfo.get() } },
18075 },
18076 setter: JSPropertySpec_Accessor {
18077 native: JSNativeWrapper { op: Some(generic_lenient_setter), info: unsafe { onmouseleave_setterinfo.get() } },
18078 }
18079 }
18080 }
18081 }
18082,
18083 JSPropertySpec {
18084 name: JSPropertySpec_Name { string_: c"onmousemove".as_ptr() },
18085 attributes_: (JSPROP_ENUMERATE),
18086 kind_: (JSPropertySpec_Kind::NativeAccessor),
18087 u: JSPropertySpec_AccessorsOrValue {
18088 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18089 getter: JSPropertySpec_Accessor {
18090 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmousemove_getterinfo.get() } },
18091 },
18092 setter: JSPropertySpec_Accessor {
18093 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmousemove_setterinfo.get() } },
18094 }
18095 }
18096 }
18097 }
18098,
18099 JSPropertySpec {
18100 name: JSPropertySpec_Name { string_: c"onmouseout".as_ptr() },
18101 attributes_: (JSPROP_ENUMERATE),
18102 kind_: (JSPropertySpec_Kind::NativeAccessor),
18103 u: JSPropertySpec_AccessorsOrValue {
18104 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18105 getter: JSPropertySpec_Accessor {
18106 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmouseout_getterinfo.get() } },
18107 },
18108 setter: JSPropertySpec_Accessor {
18109 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmouseout_setterinfo.get() } },
18110 }
18111 }
18112 }
18113 }
18114,
18115 JSPropertySpec {
18116 name: JSPropertySpec_Name { string_: c"onmouseover".as_ptr() },
18117 attributes_: (JSPROP_ENUMERATE),
18118 kind_: (JSPropertySpec_Kind::NativeAccessor),
18119 u: JSPropertySpec_AccessorsOrValue {
18120 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18121 getter: JSPropertySpec_Accessor {
18122 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmouseover_getterinfo.get() } },
18123 },
18124 setter: JSPropertySpec_Accessor {
18125 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmouseover_setterinfo.get() } },
18126 }
18127 }
18128 }
18129 }
18130,
18131 JSPropertySpec {
18132 name: JSPropertySpec_Name { string_: c"onmouseup".as_ptr() },
18133 attributes_: (JSPROP_ENUMERATE),
18134 kind_: (JSPropertySpec_Kind::NativeAccessor),
18135 u: JSPropertySpec_AccessorsOrValue {
18136 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18137 getter: JSPropertySpec_Accessor {
18138 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmouseup_getterinfo.get() } },
18139 },
18140 setter: JSPropertySpec_Accessor {
18141 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmouseup_setterinfo.get() } },
18142 }
18143 }
18144 }
18145 }
18146,
18147 JSPropertySpec {
18148 name: JSPropertySpec_Name { string_: c"onpaste".as_ptr() },
18149 attributes_: (JSPROP_ENUMERATE),
18150 kind_: (JSPropertySpec_Kind::NativeAccessor),
18151 u: JSPropertySpec_AccessorsOrValue {
18152 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18153 getter: JSPropertySpec_Accessor {
18154 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpaste_getterinfo.get() } },
18155 },
18156 setter: JSPropertySpec_Accessor {
18157 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpaste_setterinfo.get() } },
18158 }
18159 }
18160 }
18161 }
18162,
18163 JSPropertySpec {
18164 name: JSPropertySpec_Name { string_: c"onpause".as_ptr() },
18165 attributes_: (JSPROP_ENUMERATE),
18166 kind_: (JSPropertySpec_Kind::NativeAccessor),
18167 u: JSPropertySpec_AccessorsOrValue {
18168 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18169 getter: JSPropertySpec_Accessor {
18170 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpause_getterinfo.get() } },
18171 },
18172 setter: JSPropertySpec_Accessor {
18173 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpause_setterinfo.get() } },
18174 }
18175 }
18176 }
18177 }
18178,
18179 JSPropertySpec {
18180 name: JSPropertySpec_Name { string_: c"onplay".as_ptr() },
18181 attributes_: (JSPROP_ENUMERATE),
18182 kind_: (JSPropertySpec_Kind::NativeAccessor),
18183 u: JSPropertySpec_AccessorsOrValue {
18184 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18185 getter: JSPropertySpec_Accessor {
18186 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onplay_getterinfo.get() } },
18187 },
18188 setter: JSPropertySpec_Accessor {
18189 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onplay_setterinfo.get() } },
18190 }
18191 }
18192 }
18193 }
18194,
18195 JSPropertySpec {
18196 name: JSPropertySpec_Name { string_: c"onplaying".as_ptr() },
18197 attributes_: (JSPROP_ENUMERATE),
18198 kind_: (JSPropertySpec_Kind::NativeAccessor),
18199 u: JSPropertySpec_AccessorsOrValue {
18200 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18201 getter: JSPropertySpec_Accessor {
18202 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onplaying_getterinfo.get() } },
18203 },
18204 setter: JSPropertySpec_Accessor {
18205 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onplaying_setterinfo.get() } },
18206 }
18207 }
18208 }
18209 }
18210,
18211 JSPropertySpec {
18212 name: JSPropertySpec_Name { string_: c"onprogress".as_ptr() },
18213 attributes_: (JSPROP_ENUMERATE),
18214 kind_: (JSPropertySpec_Kind::NativeAccessor),
18215 u: JSPropertySpec_AccessorsOrValue {
18216 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18217 getter: JSPropertySpec_Accessor {
18218 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onprogress_getterinfo.get() } },
18219 },
18220 setter: JSPropertySpec_Accessor {
18221 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onprogress_setterinfo.get() } },
18222 }
18223 }
18224 }
18225 }
18226,
18227 JSPropertySpec {
18228 name: JSPropertySpec_Name { string_: c"onratechange".as_ptr() },
18229 attributes_: (JSPROP_ENUMERATE),
18230 kind_: (JSPropertySpec_Kind::NativeAccessor),
18231 u: JSPropertySpec_AccessorsOrValue {
18232 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18233 getter: JSPropertySpec_Accessor {
18234 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onratechange_getterinfo.get() } },
18235 },
18236 setter: JSPropertySpec_Accessor {
18237 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onratechange_setterinfo.get() } },
18238 }
18239 }
18240 }
18241 }
18242,
18243 JSPropertySpec {
18244 name: JSPropertySpec_Name { string_: c"onreset".as_ptr() },
18245 attributes_: (JSPROP_ENUMERATE),
18246 kind_: (JSPropertySpec_Kind::NativeAccessor),
18247 u: JSPropertySpec_AccessorsOrValue {
18248 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18249 getter: JSPropertySpec_Accessor {
18250 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onreset_getterinfo.get() } },
18251 },
18252 setter: JSPropertySpec_Accessor {
18253 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onreset_setterinfo.get() } },
18254 }
18255 }
18256 }
18257 }
18258,
18259 JSPropertySpec {
18260 name: JSPropertySpec_Name { string_: c"onresize".as_ptr() },
18261 attributes_: (JSPROP_ENUMERATE),
18262 kind_: (JSPropertySpec_Kind::NativeAccessor),
18263 u: JSPropertySpec_AccessorsOrValue {
18264 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18265 getter: JSPropertySpec_Accessor {
18266 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onresize_getterinfo.get() } },
18267 },
18268 setter: JSPropertySpec_Accessor {
18269 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onresize_setterinfo.get() } },
18270 }
18271 }
18272 }
18273 }
18274,
18275 JSPropertySpec {
18276 name: JSPropertySpec_Name { string_: c"onscroll".as_ptr() },
18277 attributes_: (JSPROP_ENUMERATE),
18278 kind_: (JSPropertySpec_Kind::NativeAccessor),
18279 u: JSPropertySpec_AccessorsOrValue {
18280 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18281 getter: JSPropertySpec_Accessor {
18282 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onscroll_getterinfo.get() } },
18283 },
18284 setter: JSPropertySpec_Accessor {
18285 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onscroll_setterinfo.get() } },
18286 }
18287 }
18288 }
18289 }
18290,
18291 JSPropertySpec {
18292 name: JSPropertySpec_Name { string_: c"onscrollend".as_ptr() },
18293 attributes_: (JSPROP_ENUMERATE),
18294 kind_: (JSPropertySpec_Kind::NativeAccessor),
18295 u: JSPropertySpec_AccessorsOrValue {
18296 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18297 getter: JSPropertySpec_Accessor {
18298 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onscrollend_getterinfo.get() } },
18299 },
18300 setter: JSPropertySpec_Accessor {
18301 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onscrollend_setterinfo.get() } },
18302 }
18303 }
18304 }
18305 }
18306,
18307 JSPropertySpec {
18308 name: JSPropertySpec_Name { string_: c"onsecuritypolicyviolation".as_ptr() },
18309 attributes_: (JSPROP_ENUMERATE),
18310 kind_: (JSPropertySpec_Kind::NativeAccessor),
18311 u: JSPropertySpec_AccessorsOrValue {
18312 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18313 getter: JSPropertySpec_Accessor {
18314 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onsecuritypolicyviolation_getterinfo.get() } },
18315 },
18316 setter: JSPropertySpec_Accessor {
18317 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onsecuritypolicyviolation_setterinfo.get() } },
18318 }
18319 }
18320 }
18321 }
18322,
18323 JSPropertySpec {
18324 name: JSPropertySpec_Name { string_: c"onseeked".as_ptr() },
18325 attributes_: (JSPROP_ENUMERATE),
18326 kind_: (JSPropertySpec_Kind::NativeAccessor),
18327 u: JSPropertySpec_AccessorsOrValue {
18328 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18329 getter: JSPropertySpec_Accessor {
18330 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onseeked_getterinfo.get() } },
18331 },
18332 setter: JSPropertySpec_Accessor {
18333 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onseeked_setterinfo.get() } },
18334 }
18335 }
18336 }
18337 }
18338,
18339 JSPropertySpec {
18340 name: JSPropertySpec_Name { string_: c"onseeking".as_ptr() },
18341 attributes_: (JSPROP_ENUMERATE),
18342 kind_: (JSPropertySpec_Kind::NativeAccessor),
18343 u: JSPropertySpec_AccessorsOrValue {
18344 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18345 getter: JSPropertySpec_Accessor {
18346 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onseeking_getterinfo.get() } },
18347 },
18348 setter: JSPropertySpec_Accessor {
18349 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onseeking_setterinfo.get() } },
18350 }
18351 }
18352 }
18353 }
18354,
18355 JSPropertySpec {
18356 name: JSPropertySpec_Name { string_: c"onselect".as_ptr() },
18357 attributes_: (JSPROP_ENUMERATE),
18358 kind_: (JSPropertySpec_Kind::NativeAccessor),
18359 u: JSPropertySpec_AccessorsOrValue {
18360 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18361 getter: JSPropertySpec_Accessor {
18362 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onselect_getterinfo.get() } },
18363 },
18364 setter: JSPropertySpec_Accessor {
18365 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onselect_setterinfo.get() } },
18366 }
18367 }
18368 }
18369 }
18370,
18371 JSPropertySpec {
18372 name: JSPropertySpec_Name { string_: c"onslotchange".as_ptr() },
18373 attributes_: (JSPROP_ENUMERATE),
18374 kind_: (JSPropertySpec_Kind::NativeAccessor),
18375 u: JSPropertySpec_AccessorsOrValue {
18376 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18377 getter: JSPropertySpec_Accessor {
18378 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onslotchange_getterinfo.get() } },
18379 },
18380 setter: JSPropertySpec_Accessor {
18381 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onslotchange_setterinfo.get() } },
18382 }
18383 }
18384 }
18385 }
18386,
18387 JSPropertySpec {
18388 name: JSPropertySpec_Name { string_: c"onstalled".as_ptr() },
18389 attributes_: (JSPROP_ENUMERATE),
18390 kind_: (JSPropertySpec_Kind::NativeAccessor),
18391 u: JSPropertySpec_AccessorsOrValue {
18392 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18393 getter: JSPropertySpec_Accessor {
18394 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onstalled_getterinfo.get() } },
18395 },
18396 setter: JSPropertySpec_Accessor {
18397 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onstalled_setterinfo.get() } },
18398 }
18399 }
18400 }
18401 }
18402,
18403 JSPropertySpec {
18404 name: JSPropertySpec_Name { string_: c"onsubmit".as_ptr() },
18405 attributes_: (JSPROP_ENUMERATE),
18406 kind_: (JSPropertySpec_Kind::NativeAccessor),
18407 u: JSPropertySpec_AccessorsOrValue {
18408 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18409 getter: JSPropertySpec_Accessor {
18410 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onsubmit_getterinfo.get() } },
18411 },
18412 setter: JSPropertySpec_Accessor {
18413 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onsubmit_setterinfo.get() } },
18414 }
18415 }
18416 }
18417 }
18418,
18419 JSPropertySpec {
18420 name: JSPropertySpec_Name { string_: c"onsuspend".as_ptr() },
18421 attributes_: (JSPROP_ENUMERATE),
18422 kind_: (JSPropertySpec_Kind::NativeAccessor),
18423 u: JSPropertySpec_AccessorsOrValue {
18424 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18425 getter: JSPropertySpec_Accessor {
18426 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onsuspend_getterinfo.get() } },
18427 },
18428 setter: JSPropertySpec_Accessor {
18429 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onsuspend_setterinfo.get() } },
18430 }
18431 }
18432 }
18433 }
18434,
18435 JSPropertySpec {
18436 name: JSPropertySpec_Name { string_: c"ontimeupdate".as_ptr() },
18437 attributes_: (JSPROP_ENUMERATE),
18438 kind_: (JSPropertySpec_Kind::NativeAccessor),
18439 u: JSPropertySpec_AccessorsOrValue {
18440 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18441 getter: JSPropertySpec_Accessor {
18442 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontimeupdate_getterinfo.get() } },
18443 },
18444 setter: JSPropertySpec_Accessor {
18445 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontimeupdate_setterinfo.get() } },
18446 }
18447 }
18448 }
18449 }
18450,
18451 JSPropertySpec {
18452 name: JSPropertySpec_Name { string_: c"ontoggle".as_ptr() },
18453 attributes_: (JSPROP_ENUMERATE),
18454 kind_: (JSPropertySpec_Kind::NativeAccessor),
18455 u: JSPropertySpec_AccessorsOrValue {
18456 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18457 getter: JSPropertySpec_Accessor {
18458 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontoggle_getterinfo.get() } },
18459 },
18460 setter: JSPropertySpec_Accessor {
18461 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontoggle_setterinfo.get() } },
18462 }
18463 }
18464 }
18465 }
18466,
18467 JSPropertySpec {
18468 name: JSPropertySpec_Name { string_: c"onvolumechange".as_ptr() },
18469 attributes_: (JSPROP_ENUMERATE),
18470 kind_: (JSPropertySpec_Kind::NativeAccessor),
18471 u: JSPropertySpec_AccessorsOrValue {
18472 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18473 getter: JSPropertySpec_Accessor {
18474 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onvolumechange_getterinfo.get() } },
18475 },
18476 setter: JSPropertySpec_Accessor {
18477 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onvolumechange_setterinfo.get() } },
18478 }
18479 }
18480 }
18481 }
18482,
18483 JSPropertySpec {
18484 name: JSPropertySpec_Name { string_: c"onwaiting".as_ptr() },
18485 attributes_: (JSPROP_ENUMERATE),
18486 kind_: (JSPropertySpec_Kind::NativeAccessor),
18487 u: JSPropertySpec_AccessorsOrValue {
18488 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18489 getter: JSPropertySpec_Accessor {
18490 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwaiting_getterinfo.get() } },
18491 },
18492 setter: JSPropertySpec_Accessor {
18493 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwaiting_setterinfo.get() } },
18494 }
18495 }
18496 }
18497 }
18498,
18499 JSPropertySpec {
18500 name: JSPropertySpec_Name { string_: c"onwebkitanimationend".as_ptr() },
18501 attributes_: (JSPROP_ENUMERATE),
18502 kind_: (JSPropertySpec_Kind::NativeAccessor),
18503 u: JSPropertySpec_AccessorsOrValue {
18504 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18505 getter: JSPropertySpec_Accessor {
18506 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwebkitanimationend_getterinfo.get() } },
18507 },
18508 setter: JSPropertySpec_Accessor {
18509 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwebkitanimationend_setterinfo.get() } },
18510 }
18511 }
18512 }
18513 }
18514,
18515 JSPropertySpec {
18516 name: JSPropertySpec_Name { string_: c"onwebkitanimationiteration".as_ptr() },
18517 attributes_: (JSPROP_ENUMERATE),
18518 kind_: (JSPropertySpec_Kind::NativeAccessor),
18519 u: JSPropertySpec_AccessorsOrValue {
18520 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18521 getter: JSPropertySpec_Accessor {
18522 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwebkitanimationiteration_getterinfo.get() } },
18523 },
18524 setter: JSPropertySpec_Accessor {
18525 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwebkitanimationiteration_setterinfo.get() } },
18526 }
18527 }
18528 }
18529 }
18530,
18531 JSPropertySpec {
18532 name: JSPropertySpec_Name { string_: c"onwebkitanimationstart".as_ptr() },
18533 attributes_: (JSPROP_ENUMERATE),
18534 kind_: (JSPropertySpec_Kind::NativeAccessor),
18535 u: JSPropertySpec_AccessorsOrValue {
18536 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18537 getter: JSPropertySpec_Accessor {
18538 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwebkitanimationstart_getterinfo.get() } },
18539 },
18540 setter: JSPropertySpec_Accessor {
18541 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwebkitanimationstart_setterinfo.get() } },
18542 }
18543 }
18544 }
18545 }
18546,
18547 JSPropertySpec {
18548 name: JSPropertySpec_Name { string_: c"onwebkittransitionend".as_ptr() },
18549 attributes_: (JSPROP_ENUMERATE),
18550 kind_: (JSPropertySpec_Kind::NativeAccessor),
18551 u: JSPropertySpec_AccessorsOrValue {
18552 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18553 getter: JSPropertySpec_Accessor {
18554 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwebkittransitionend_getterinfo.get() } },
18555 },
18556 setter: JSPropertySpec_Accessor {
18557 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwebkittransitionend_setterinfo.get() } },
18558 }
18559 }
18560 }
18561 }
18562,
18563 JSPropertySpec {
18564 name: JSPropertySpec_Name { string_: c"onwheel".as_ptr() },
18565 attributes_: (JSPROP_ENUMERATE),
18566 kind_: (JSPropertySpec_Kind::NativeAccessor),
18567 u: JSPropertySpec_AccessorsOrValue {
18568 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18569 getter: JSPropertySpec_Accessor {
18570 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwheel_getterinfo.get() } },
18571 },
18572 setter: JSPropertySpec_Accessor {
18573 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwheel_setterinfo.get() } },
18574 }
18575 }
18576 }
18577 }
18578,
18579 JSPropertySpec {
18580 name: JSPropertySpec_Name { string_: c"onanimationstart".as_ptr() },
18581 attributes_: (JSPROP_ENUMERATE),
18582 kind_: (JSPropertySpec_Kind::NativeAccessor),
18583 u: JSPropertySpec_AccessorsOrValue {
18584 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18585 getter: JSPropertySpec_Accessor {
18586 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onanimationstart_getterinfo.get() } },
18587 },
18588 setter: JSPropertySpec_Accessor {
18589 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onanimationstart_setterinfo.get() } },
18590 }
18591 }
18592 }
18593 }
18594,
18595 JSPropertySpec {
18596 name: JSPropertySpec_Name { string_: c"onanimationiteration".as_ptr() },
18597 attributes_: (JSPROP_ENUMERATE),
18598 kind_: (JSPropertySpec_Kind::NativeAccessor),
18599 u: JSPropertySpec_AccessorsOrValue {
18600 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18601 getter: JSPropertySpec_Accessor {
18602 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onanimationiteration_getterinfo.get() } },
18603 },
18604 setter: JSPropertySpec_Accessor {
18605 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onanimationiteration_setterinfo.get() } },
18606 }
18607 }
18608 }
18609 }
18610,
18611 JSPropertySpec {
18612 name: JSPropertySpec_Name { string_: c"onanimationend".as_ptr() },
18613 attributes_: (JSPROP_ENUMERATE),
18614 kind_: (JSPropertySpec_Kind::NativeAccessor),
18615 u: JSPropertySpec_AccessorsOrValue {
18616 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18617 getter: JSPropertySpec_Accessor {
18618 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onanimationend_getterinfo.get() } },
18619 },
18620 setter: JSPropertySpec_Accessor {
18621 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onanimationend_setterinfo.get() } },
18622 }
18623 }
18624 }
18625 }
18626,
18627 JSPropertySpec {
18628 name: JSPropertySpec_Name { string_: c"onanimationcancel".as_ptr() },
18629 attributes_: (JSPROP_ENUMERATE),
18630 kind_: (JSPropertySpec_Kind::NativeAccessor),
18631 u: JSPropertySpec_AccessorsOrValue {
18632 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18633 getter: JSPropertySpec_Accessor {
18634 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onanimationcancel_getterinfo.get() } },
18635 },
18636 setter: JSPropertySpec_Accessor {
18637 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onanimationcancel_setterinfo.get() } },
18638 }
18639 }
18640 }
18641 }
18642,
18643 JSPropertySpec {
18644 name: JSPropertySpec_Name { string_: c"ontransitionrun".as_ptr() },
18645 attributes_: (JSPROP_ENUMERATE),
18646 kind_: (JSPropertySpec_Kind::NativeAccessor),
18647 u: JSPropertySpec_AccessorsOrValue {
18648 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18649 getter: JSPropertySpec_Accessor {
18650 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontransitionrun_getterinfo.get() } },
18651 },
18652 setter: JSPropertySpec_Accessor {
18653 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontransitionrun_setterinfo.get() } },
18654 }
18655 }
18656 }
18657 }
18658,
18659 JSPropertySpec {
18660 name: JSPropertySpec_Name { string_: c"ontransitionend".as_ptr() },
18661 attributes_: (JSPROP_ENUMERATE),
18662 kind_: (JSPropertySpec_Kind::NativeAccessor),
18663 u: JSPropertySpec_AccessorsOrValue {
18664 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18665 getter: JSPropertySpec_Accessor {
18666 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontransitionend_getterinfo.get() } },
18667 },
18668 setter: JSPropertySpec_Accessor {
18669 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontransitionend_setterinfo.get() } },
18670 }
18671 }
18672 }
18673 }
18674,
18675 JSPropertySpec {
18676 name: JSPropertySpec_Name { string_: c"ontransitioncancel".as_ptr() },
18677 attributes_: (JSPROP_ENUMERATE),
18678 kind_: (JSPropertySpec_Kind::NativeAccessor),
18679 u: JSPropertySpec_AccessorsOrValue {
18680 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18681 getter: JSPropertySpec_Accessor {
18682 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontransitioncancel_getterinfo.get() } },
18683 },
18684 setter: JSPropertySpec_Accessor {
18685 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontransitioncancel_setterinfo.get() } },
18686 }
18687 }
18688 }
18689 }
18690,
18691 JSPropertySpec {
18692 name: JSPropertySpec_Name { string_: c"onselectstart".as_ptr() },
18693 attributes_: (JSPROP_ENUMERATE),
18694 kind_: (JSPropertySpec_Kind::NativeAccessor),
18695 u: JSPropertySpec_AccessorsOrValue {
18696 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18697 getter: JSPropertySpec_Accessor {
18698 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onselectstart_getterinfo.get() } },
18699 },
18700 setter: JSPropertySpec_Accessor {
18701 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onselectstart_setterinfo.get() } },
18702 }
18703 }
18704 }
18705 }
18706,
18707 JSPropertySpec {
18708 name: JSPropertySpec_Name { string_: c"onselectionchange".as_ptr() },
18709 attributes_: (JSPROP_ENUMERATE),
18710 kind_: (JSPropertySpec_Kind::NativeAccessor),
18711 u: JSPropertySpec_AccessorsOrValue {
18712 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18713 getter: JSPropertySpec_Accessor {
18714 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onselectionchange_getterinfo.get() } },
18715 },
18716 setter: JSPropertySpec_Accessor {
18717 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onselectionchange_setterinfo.get() } },
18718 }
18719 }
18720 }
18721 }
18722,
18723 JSPropertySpec {
18724 name: JSPropertySpec_Name { string_: c"onafterprint".as_ptr() },
18725 attributes_: (JSPROP_ENUMERATE),
18726 kind_: (JSPropertySpec_Kind::NativeAccessor),
18727 u: JSPropertySpec_AccessorsOrValue {
18728 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18729 getter: JSPropertySpec_Accessor {
18730 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onafterprint_getterinfo.get() } },
18731 },
18732 setter: JSPropertySpec_Accessor {
18733 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onafterprint_setterinfo.get() } },
18734 }
18735 }
18736 }
18737 }
18738,
18739 JSPropertySpec {
18740 name: JSPropertySpec_Name { string_: c"onbeforeprint".as_ptr() },
18741 attributes_: (JSPROP_ENUMERATE),
18742 kind_: (JSPropertySpec_Kind::NativeAccessor),
18743 u: JSPropertySpec_AccessorsOrValue {
18744 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18745 getter: JSPropertySpec_Accessor {
18746 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onbeforeprint_getterinfo.get() } },
18747 },
18748 setter: JSPropertySpec_Accessor {
18749 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onbeforeprint_setterinfo.get() } },
18750 }
18751 }
18752 }
18753 }
18754,
18755 JSPropertySpec {
18756 name: JSPropertySpec_Name { string_: c"onbeforeunload".as_ptr() },
18757 attributes_: (JSPROP_ENUMERATE),
18758 kind_: (JSPropertySpec_Kind::NativeAccessor),
18759 u: JSPropertySpec_AccessorsOrValue {
18760 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18761 getter: JSPropertySpec_Accessor {
18762 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onbeforeunload_getterinfo.get() } },
18763 },
18764 setter: JSPropertySpec_Accessor {
18765 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onbeforeunload_setterinfo.get() } },
18766 }
18767 }
18768 }
18769 }
18770,
18771 JSPropertySpec {
18772 name: JSPropertySpec_Name { string_: c"onhashchange".as_ptr() },
18773 attributes_: (JSPROP_ENUMERATE),
18774 kind_: (JSPropertySpec_Kind::NativeAccessor),
18775 u: JSPropertySpec_AccessorsOrValue {
18776 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18777 getter: JSPropertySpec_Accessor {
18778 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onhashchange_getterinfo.get() } },
18779 },
18780 setter: JSPropertySpec_Accessor {
18781 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onhashchange_setterinfo.get() } },
18782 }
18783 }
18784 }
18785 }
18786,
18787 JSPropertySpec {
18788 name: JSPropertySpec_Name { string_: c"onlanguagechange".as_ptr() },
18789 attributes_: (JSPROP_ENUMERATE),
18790 kind_: (JSPropertySpec_Kind::NativeAccessor),
18791 u: JSPropertySpec_AccessorsOrValue {
18792 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18793 getter: JSPropertySpec_Accessor {
18794 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onlanguagechange_getterinfo.get() } },
18795 },
18796 setter: JSPropertySpec_Accessor {
18797 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onlanguagechange_setterinfo.get() } },
18798 }
18799 }
18800 }
18801 }
18802,
18803 JSPropertySpec {
18804 name: JSPropertySpec_Name { string_: c"onmessage".as_ptr() },
18805 attributes_: (JSPROP_ENUMERATE),
18806 kind_: (JSPropertySpec_Kind::NativeAccessor),
18807 u: JSPropertySpec_AccessorsOrValue {
18808 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18809 getter: JSPropertySpec_Accessor {
18810 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmessage_getterinfo.get() } },
18811 },
18812 setter: JSPropertySpec_Accessor {
18813 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmessage_setterinfo.get() } },
18814 }
18815 }
18816 }
18817 }
18818,
18819 JSPropertySpec {
18820 name: JSPropertySpec_Name { string_: c"onmessageerror".as_ptr() },
18821 attributes_: (JSPROP_ENUMERATE),
18822 kind_: (JSPropertySpec_Kind::NativeAccessor),
18823 u: JSPropertySpec_AccessorsOrValue {
18824 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18825 getter: JSPropertySpec_Accessor {
18826 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmessageerror_getterinfo.get() } },
18827 },
18828 setter: JSPropertySpec_Accessor {
18829 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmessageerror_setterinfo.get() } },
18830 }
18831 }
18832 }
18833 }
18834,
18835 JSPropertySpec {
18836 name: JSPropertySpec_Name { string_: c"onoffline".as_ptr() },
18837 attributes_: (JSPROP_ENUMERATE),
18838 kind_: (JSPropertySpec_Kind::NativeAccessor),
18839 u: JSPropertySpec_AccessorsOrValue {
18840 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18841 getter: JSPropertySpec_Accessor {
18842 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onoffline_getterinfo.get() } },
18843 },
18844 setter: JSPropertySpec_Accessor {
18845 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onoffline_setterinfo.get() } },
18846 }
18847 }
18848 }
18849 }
18850,
18851 JSPropertySpec {
18852 name: JSPropertySpec_Name { string_: c"ononline".as_ptr() },
18853 attributes_: (JSPROP_ENUMERATE),
18854 kind_: (JSPropertySpec_Kind::NativeAccessor),
18855 u: JSPropertySpec_AccessorsOrValue {
18856 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18857 getter: JSPropertySpec_Accessor {
18858 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ononline_getterinfo.get() } },
18859 },
18860 setter: JSPropertySpec_Accessor {
18861 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ononline_setterinfo.get() } },
18862 }
18863 }
18864 }
18865 }
18866,
18867 JSPropertySpec {
18868 name: JSPropertySpec_Name { string_: c"onpagehide".as_ptr() },
18869 attributes_: (JSPROP_ENUMERATE),
18870 kind_: (JSPropertySpec_Kind::NativeAccessor),
18871 u: JSPropertySpec_AccessorsOrValue {
18872 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18873 getter: JSPropertySpec_Accessor {
18874 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpagehide_getterinfo.get() } },
18875 },
18876 setter: JSPropertySpec_Accessor {
18877 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpagehide_setterinfo.get() } },
18878 }
18879 }
18880 }
18881 }
18882,
18883 JSPropertySpec {
18884 name: JSPropertySpec_Name { string_: c"onpagereveal".as_ptr() },
18885 attributes_: (JSPROP_ENUMERATE),
18886 kind_: (JSPropertySpec_Kind::NativeAccessor),
18887 u: JSPropertySpec_AccessorsOrValue {
18888 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18889 getter: JSPropertySpec_Accessor {
18890 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpagereveal_getterinfo.get() } },
18891 },
18892 setter: JSPropertySpec_Accessor {
18893 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpagereveal_setterinfo.get() } },
18894 }
18895 }
18896 }
18897 }
18898,
18899 JSPropertySpec {
18900 name: JSPropertySpec_Name { string_: c"onpageshow".as_ptr() },
18901 attributes_: (JSPROP_ENUMERATE),
18902 kind_: (JSPropertySpec_Kind::NativeAccessor),
18903 u: JSPropertySpec_AccessorsOrValue {
18904 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18905 getter: JSPropertySpec_Accessor {
18906 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpageshow_getterinfo.get() } },
18907 },
18908 setter: JSPropertySpec_Accessor {
18909 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpageshow_setterinfo.get() } },
18910 }
18911 }
18912 }
18913 }
18914,
18915 JSPropertySpec {
18916 name: JSPropertySpec_Name { string_: c"onpageswap".as_ptr() },
18917 attributes_: (JSPROP_ENUMERATE),
18918 kind_: (JSPropertySpec_Kind::NativeAccessor),
18919 u: JSPropertySpec_AccessorsOrValue {
18920 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18921 getter: JSPropertySpec_Accessor {
18922 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpageswap_getterinfo.get() } },
18923 },
18924 setter: JSPropertySpec_Accessor {
18925 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpageswap_setterinfo.get() } },
18926 }
18927 }
18928 }
18929 }
18930,
18931 JSPropertySpec {
18932 name: JSPropertySpec_Name { string_: c"onpopstate".as_ptr() },
18933 attributes_: (JSPROP_ENUMERATE),
18934 kind_: (JSPropertySpec_Kind::NativeAccessor),
18935 u: JSPropertySpec_AccessorsOrValue {
18936 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18937 getter: JSPropertySpec_Accessor {
18938 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpopstate_getterinfo.get() } },
18939 },
18940 setter: JSPropertySpec_Accessor {
18941 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpopstate_setterinfo.get() } },
18942 }
18943 }
18944 }
18945 }
18946,
18947 JSPropertySpec {
18948 name: JSPropertySpec_Name { string_: c"onrejectionhandled".as_ptr() },
18949 attributes_: (JSPROP_ENUMERATE),
18950 kind_: (JSPropertySpec_Kind::NativeAccessor),
18951 u: JSPropertySpec_AccessorsOrValue {
18952 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18953 getter: JSPropertySpec_Accessor {
18954 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onrejectionhandled_getterinfo.get() } },
18955 },
18956 setter: JSPropertySpec_Accessor {
18957 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onrejectionhandled_setterinfo.get() } },
18958 }
18959 }
18960 }
18961 }
18962,
18963 JSPropertySpec {
18964 name: JSPropertySpec_Name { string_: c"onstorage".as_ptr() },
18965 attributes_: (JSPROP_ENUMERATE),
18966 kind_: (JSPropertySpec_Kind::NativeAccessor),
18967 u: JSPropertySpec_AccessorsOrValue {
18968 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18969 getter: JSPropertySpec_Accessor {
18970 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onstorage_getterinfo.get() } },
18971 },
18972 setter: JSPropertySpec_Accessor {
18973 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onstorage_setterinfo.get() } },
18974 }
18975 }
18976 }
18977 }
18978,
18979 JSPropertySpec {
18980 name: JSPropertySpec_Name { string_: c"onunhandledrejection".as_ptr() },
18981 attributes_: (JSPROP_ENUMERATE),
18982 kind_: (JSPropertySpec_Kind::NativeAccessor),
18983 u: JSPropertySpec_AccessorsOrValue {
18984 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
18985 getter: JSPropertySpec_Accessor {
18986 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onunhandledrejection_getterinfo.get() } },
18987 },
18988 setter: JSPropertySpec_Accessor {
18989 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onunhandledrejection_setterinfo.get() } },
18990 }
18991 }
18992 }
18993 }
18994,
18995 JSPropertySpec {
18996 name: JSPropertySpec_Name { string_: c"onunload".as_ptr() },
18997 attributes_: (JSPROP_ENUMERATE),
18998 kind_: (JSPropertySpec_Kind::NativeAccessor),
18999 u: JSPropertySpec_AccessorsOrValue {
19000 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19001 getter: JSPropertySpec_Accessor {
19002 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onunload_getterinfo.get() } },
19003 },
19004 setter: JSPropertySpec_Accessor {
19005 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onunload_setterinfo.get() } },
19006 }
19007 }
19008 }
19009 }
19010,
19011 JSPropertySpec {
19012 name: JSPropertySpec_Name { string_: c"ongamepadconnected".as_ptr() },
19013 attributes_: (JSPROP_ENUMERATE),
19014 kind_: (JSPropertySpec_Kind::NativeAccessor),
19015 u: JSPropertySpec_AccessorsOrValue {
19016 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19017 getter: JSPropertySpec_Accessor {
19018 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ongamepadconnected_getterinfo.get() } },
19019 },
19020 setter: JSPropertySpec_Accessor {
19021 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ongamepadconnected_setterinfo.get() } },
19022 }
19023 }
19024 }
19025 }
19026,
19027 JSPropertySpec {
19028 name: JSPropertySpec_Name { string_: c"ongamepaddisconnected".as_ptr() },
19029 attributes_: (JSPROP_ENUMERATE),
19030 kind_: (JSPropertySpec_Kind::NativeAccessor),
19031 u: JSPropertySpec_AccessorsOrValue {
19032 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19033 getter: JSPropertySpec_Accessor {
19034 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ongamepaddisconnected_getterinfo.get() } },
19035 },
19036 setter: JSPropertySpec_Accessor {
19037 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ongamepaddisconnected_setterinfo.get() } },
19038 }
19039 }
19040 }
19041 }
19042,
19043 JSPropertySpec {
19044 name: JSPropertySpec_Name { string_: c"localStorage".as_ptr() },
19045 attributes_: (JSPROP_ENUMERATE),
19046 kind_: (JSPropertySpec_Kind::NativeAccessor),
19047 u: JSPropertySpec_AccessorsOrValue {
19048 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19049 getter: JSPropertySpec_Accessor {
19050 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { localStorage_getterinfo.get() } },
19051 },
19052 setter: JSPropertySpec_Accessor {
19053 native: JSNativeWrapper { op: None, info: ptr::null() },
19054 }
19055 }
19056 }
19057 }
19058,
19059 JSPropertySpec::ZERO]))[..]
19060,
19061&Box::leak(Box::new([
19062 JSPropertySpec {
19063 name: JSPropertySpec_Name { string_: c"origin".as_ptr() },
19064 attributes_: (JSPROP_ENUMERATE),
19065 kind_: (JSPropertySpec_Kind::NativeAccessor),
19066 u: JSPropertySpec_AccessorsOrValue {
19067 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19068 getter: JSPropertySpec_Accessor {
19069 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { origin_getterinfo.get() } },
19070 },
19071 setter: JSPropertySpec_Accessor {
19072 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { origin_setterinfo.get() } },
19073 }
19074 }
19075 }
19076 }
19077,
19078 JSPropertySpec::ZERO]))[..]
19079,
19080&Box::leak(Box::new([
19081 JSPropertySpec {
19082 name: JSPropertySpec_Name { string_: c"indexedDB".as_ptr() },
19083 attributes_: (JSPROP_ENUMERATE),
19084 kind_: (JSPropertySpec_Kind::NativeAccessor),
19085 u: JSPropertySpec_AccessorsOrValue {
19086 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19087 getter: JSPropertySpec_Accessor {
19088 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { indexedDB_getterinfo.get() } },
19089 },
19090 setter: JSPropertySpec_Accessor {
19091 native: JSNativeWrapper { op: None, info: ptr::null() },
19092 }
19093 }
19094 }
19095 }
19096,
19097 JSPropertySpec::ZERO]))[..]
19098,
19099&Box::leak(Box::new([
19100 JSPropertySpec {
19101 name: JSPropertySpec_Name { string_: c"performance".as_ptr() },
19102 attributes_: (JSPROP_ENUMERATE),
19103 kind_: (JSPropertySpec_Kind::NativeAccessor),
19104 u: JSPropertySpec_AccessorsOrValue {
19105 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19106 getter: JSPropertySpec_Accessor {
19107 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { performance_getterinfo.get() } },
19108 },
19109 setter: JSPropertySpec_Accessor {
19110 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { performance_setterinfo.get() } },
19111 }
19112 }
19113 }
19114 }
19115,
19116 JSPropertySpec {
19117 name: JSPropertySpec_Name { string_: c"isSecureContext".as_ptr() },
19118 attributes_: (JSPROP_ENUMERATE),
19119 kind_: (JSPropertySpec_Kind::NativeAccessor),
19120 u: JSPropertySpec_AccessorsOrValue {
19121 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19122 getter: JSPropertySpec_Accessor {
19123 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { isSecureContext_getterinfo.get() } },
19124 },
19125 setter: JSPropertySpec_Accessor {
19126 native: JSNativeWrapper { op: None, info: ptr::null() },
19127 }
19128 }
19129 }
19130 }
19131,
19132 JSPropertySpec {
19133 name: JSPropertySpec_Name { string_: c"trustedTypes".as_ptr() },
19134 attributes_: (JSPROP_ENUMERATE),
19135 kind_: (JSPropertySpec_Kind::NativeAccessor),
19136 u: JSPropertySpec_AccessorsOrValue {
19137 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19138 getter: JSPropertySpec_Accessor {
19139 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { trustedTypes_getterinfo.get() } },
19140 },
19141 setter: JSPropertySpec_Accessor {
19142 native: JSNativeWrapper { op: None, info: ptr::null() },
19143 }
19144 }
19145 }
19146 }
19147,
19148 JSPropertySpec {
19149 name: JSPropertySpec_Name { string_: c"crypto".as_ptr() },
19150 attributes_: (JSPROP_ENUMERATE),
19151 kind_: (JSPropertySpec_Kind::NativeAccessor),
19152 u: JSPropertySpec_AccessorsOrValue {
19153 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19154 getter: JSPropertySpec_Accessor {
19155 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { crypto_getterinfo.get() } },
19156 },
19157 setter: JSPropertySpec_Accessor {
19158 native: JSNativeWrapper { op: None, info: ptr::null() },
19159 }
19160 }
19161 }
19162 }
19163,
19164 JSPropertySpec::ZERO]))[..]
19165,
19166&Box::leak(Box::new([
19167 JSPropertySpec {
19168 name: JSPropertySpec_Name { string_: c"sessionStorage".as_ptr() },
19169 attributes_: (JSPROP_ENUMERATE),
19170 kind_: (JSPropertySpec_Kind::NativeAccessor),
19171 u: JSPropertySpec_AccessorsOrValue {
19172 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19173 getter: JSPropertySpec_Accessor {
19174 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { sessionStorage_getterinfo.get() } },
19175 },
19176 setter: JSPropertySpec_Accessor {
19177 native: JSNativeWrapper { op: None, info: ptr::null() },
19178 }
19179 }
19180 }
19181 }
19182,
19183 JSPropertySpec::ZERO]))[..]
19184,
19185&Box::leak(Box::new([
19186 JSPropertySpec {
19187 name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
19188 attributes_: (JSPROP_READONLY),
19189 kind_: (JSPropertySpec_Kind::Value),
19190 u: JSPropertySpec_AccessorsOrValue {
19191 value: JSPropertySpec_ValueWrapper {
19192 type_: JSPropertySpec_ValueWrapper_Type::String,
19193 __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
19194 string: c"Window".as_ptr(),
19195 }
19196 }
19197 }
19198 }
19199,
19200 JSPropertySpec::ZERO]))[..]
19201])));
19202}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
19203
19204pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
19205 sAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[0]),
19206 Guard::new(&[Condition::Pref("css_animations_testing_enabled"),Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[1]),
19207 Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[2]),
19208 Guard::new(&[Condition::SecureContext(),Condition::Pref("dom_cookiestore_enabled"),Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[3]),
19209 Guard::new(&[Condition::Pref("dom_bluetooth_testing_enabled"),Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[4]),
19210 Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[5]),
19211 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[6]),
19212 Guard::new(&[Condition::Pref("dom_indexeddb_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[7]),
19213 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[8]),
19214 Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[9]),
19215 Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[10])])));
19216}static sLegacyUnforgeableAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
19217
19218pub(crate) fn init_sLegacyUnforgeableAttributes_specs<D: DomTypes>() {
19219 sLegacyUnforgeableAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
19220 JSPropertySpec {
19221 name: JSPropertySpec_Name { string_: c"window".as_ptr() },
19222 attributes_: (JSPROP_ENUMERATE | JSPROP_PERMANENT),
19223 kind_: (JSPropertySpec_Kind::NativeAccessor),
19224 u: JSPropertySpec_AccessorsOrValue {
19225 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19226 getter: JSPropertySpec_Accessor {
19227 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { window_getterinfo.get() } },
19228 },
19229 setter: JSPropertySpec_Accessor {
19230 native: JSNativeWrapper { op: None, info: ptr::null() },
19231 }
19232 }
19233 }
19234 }
19235,
19236 JSPropertySpec {
19237 name: JSPropertySpec_Name { string_: c"document".as_ptr() },
19238 attributes_: (JSPROP_ENUMERATE | JSPROP_PERMANENT),
19239 kind_: (JSPropertySpec_Kind::NativeAccessor),
19240 u: JSPropertySpec_AccessorsOrValue {
19241 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19242 getter: JSPropertySpec_Accessor {
19243 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { document_getterinfo.get() } },
19244 },
19245 setter: JSPropertySpec_Accessor {
19246 native: JSNativeWrapper { op: None, info: ptr::null() },
19247 }
19248 }
19249 }
19250 }
19251,
19252 JSPropertySpec {
19253 name: JSPropertySpec_Name { string_: c"location".as_ptr() },
19254 attributes_: (JSPROP_ENUMERATE | JSPROP_PERMANENT),
19255 kind_: (JSPropertySpec_Kind::NativeAccessor),
19256 u: JSPropertySpec_AccessorsOrValue {
19257 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19258 getter: JSPropertySpec_Accessor {
19259 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { location_getterinfo.get() } },
19260 },
19261 setter: JSPropertySpec_Accessor {
19262 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { location_setterinfo.get() } },
19263 }
19264 }
19265 }
19266 }
19267,
19268 JSPropertySpec {
19269 name: JSPropertySpec_Name { string_: c"top".as_ptr() },
19270 attributes_: (JSPROP_ENUMERATE | JSPROP_PERMANENT),
19271 kind_: (JSPropertySpec_Kind::NativeAccessor),
19272 u: JSPropertySpec_AccessorsOrValue {
19273 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
19274 getter: JSPropertySpec_Accessor {
19275 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { top_getterinfo.get() } },
19276 },
19277 setter: JSPropertySpec_Accessor {
19278 native: JSNativeWrapper { op: None, info: ptr::null() },
19279 }
19280 }
19281 }
19282 }
19283,
19284 JSPropertySpec::ZERO]))[..]
19285])));
19286}static sLegacyUnforgeableAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
19287
19288pub(crate) fn init_sLegacyUnforgeableAttributes_prefs<D: DomTypes>() {
19289 sLegacyUnforgeableAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sLegacyUnforgeableAttributes_specs.get() })[0])])));
19290}
19291pub fn GetProtoObject<D: DomTypes>
19292(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
19293 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::Window), CreateInterfaceObjects::<D>, rval)
19295}
19296
19297
19298static PrototypeClass: JSClass = JSClass {
19299 name: c"WindowPrototype".as_ptr(),
19300 flags:
19301 (1 & JSCLASS_RESERVED_SLOTS_MASK ) << JSCLASS_RESERVED_SLOTS_SHIFT,
19303 cOps: ptr::null(),
19304 spec: ptr::null(),
19305 ext: ptr::null(),
19306 oOps: ptr::null(),
19307};
19308
19309
19310static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();
19311
19312pub(crate) fn init_interface_object<D: DomTypes>() {
19313 INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
19314 Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
19315 b"function Window() {\n [native code]\n}",
19316 PrototypeList::ID::Window,
19317 2,
19318 ));
19319}
19320
19321pub fn DefineDOMInterface<D: DomTypes>
19322(cx: SafeJSContext, global: HandleObject){
19323 define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::Window),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
19324}
19325
19326pub fn ConstructorEnabled<D: DomTypes>
19327(aCx: SafeJSContext, aObj: HandleObject) -> bool{
19328 is_exposed_in(aObj, Globals::WINDOW)
19329}
19330
19331unsafe fn CreateInterfaceObjects<D: DomTypes>
19332(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
19333
19334 rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
19335 EventTarget_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
19336 assert!(!prototype_proto.is_null());
19337
19338 rooted!(&in(cx) let mut prototype_proto_proto = prototype_proto.get());
19339 D::Window::create_named_properties_object(cx, prototype_proto_proto.handle(), prototype_proto.handle_mut());
19340 assert!(!prototype_proto.is_null());
19341
19342 rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
19343 create_interface_prototype_object::<D>(cx,
19344 global,
19345 prototype_proto.handle(),
19346 &PrototypeClass,
19347 &[],
19348 &[],
19349 &[],
19350 &[],
19351 prototype.handle_mut());
19352 assert!(!prototype.is_null());
19353 assert!((*cache)[PrototypeList::ID::Window as usize].is_null());
19354 (*cache)[PrototypeList::ID::Window as usize] = prototype.get();
19355 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::Window as isize),
19356 ptr::null_mut(),
19357 prototype.get());
19358
19359 rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
19360
19361 EventTarget_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());
19362
19363 assert!(!interface_proto.is_null());
19364
19365 rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
19366 create_noncallback_interface_object::<D>(cx,
19367 global,
19368 interface_proto.handle(),
19369 INTERFACE_OBJECT_CLASS.get(),
19370 &[],
19371 &[],
19372 &[],
19373 prototype.handle(),
19374 c"Window",
19375 0,
19376 &[],
19377 interface.handle_mut());
19378 assert!(!interface.is_null());
19379
19380 rooted!(&in(cx) let mut unforgeable_holder = ptr::null_mut::<JSObject>());
19381 unforgeable_holder.handle_mut().set(
19382 JS_NewObjectWithoutMetadata(cx.raw_cx(), ptr::null(), HandleObject::null()));
19383 assert!(!unforgeable_holder.is_null());
19384
19385 define_guarded_properties::<D>(cx, unforgeable_holder.handle(), unsafe { sLegacyUnforgeableAttributes.get() }, global);
19386 let val = ObjectValue(unforgeable_holder.get());
19387 JS_SetReservedSlot(prototype.get(), DOM_PROTO_UNFORGEABLE_HOLDER_SLOT, &val)
19388}
19389
19390
19391 pub(crate) fn init_statics<D: DomTypes>() {
19392 init_interface_object::<D>();
19393 init_domjs_class::<D>();
19394 crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_close_methodinfo::<D>();
19395crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_stop_methodinfo::<D>();
19396crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_focus_methodinfo::<D>();
19397crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_blur_methodinfo::<D>();
19398crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_open_methodinfo::<D>();
19399crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_alert_methodinfo::<D>();
19400crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_confirm_methodinfo::<D>();
19401crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_prompt_methodinfo::<D>();
19402crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_requestAnimationFrame_methodinfo::<D>();
19403crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_cancelAnimationFrame_methodinfo::<D>();
19404crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_postMessage_methodinfo::<D>();
19405crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_captureEvents_methodinfo::<D>();
19406crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_releaseEvents_methodinfo::<D>();
19407crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_getComputedStyle_methodinfo::<D>();
19408crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_matchMedia_methodinfo::<D>();
19409crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_moveTo_methodinfo::<D>();
19410crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_moveBy_methodinfo::<D>();
19411crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_resizeTo_methodinfo::<D>();
19412crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_resizeBy_methodinfo::<D>();
19413crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_scroll_methodinfo::<D>();
19414crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_scrollTo_methodinfo::<D>();
19415crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_scrollBy_methodinfo::<D>();
19416crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_debug_methodinfo::<D>();
19417crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_gc_methodinfo::<D>();
19418crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_js_backtrace_methodinfo::<D>();
19419crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_webdriverCallback_methodinfo::<D>();
19420crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_webdriverException_methodinfo::<D>();
19421crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_webdriverElement_methodinfo::<D>();
19422crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_webdriverFrame_methodinfo::<D>();
19423crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_webdriverWindow_methodinfo::<D>();
19424crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_webdriverShadowRoot_methodinfo::<D>();
19425crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_getSelection_methodinfo::<D>();
19426crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_fetchLater_methodinfo::<D>();
19427crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_reportError_methodinfo::<D>();
19428crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_btoa_methodinfo::<D>();
19429crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_atob_methodinfo::<D>();
19430crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_setTimeout_methodinfo::<D>();
19431crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_clearTimeout_methodinfo::<D>();
19432crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_setInterval_methodinfo::<D>();
19433crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_clearInterval_methodinfo::<D>();
19434crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_queueMicrotask_methodinfo::<D>();
19435crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_createImageBitmap_methodinfo::<D>();
19436crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_structuredClone_methodinfo::<D>();
19437crate::codegen::GenericBindings::WindowBinding::Window_Binding::init_fetch_methodinfo::<D>();
19438 init_window_getterinfo::<D>();
19439init_self_getterinfo::<D>();
19440init_document_getterinfo::<D>();
19441init_name_getterinfo::<D>();
19442init_location_getterinfo::<D>();
19443init_history_getterinfo::<D>();
19444init_customElements_getterinfo::<D>();
19445init_status_getterinfo::<D>();
19446init_closed_getterinfo::<D>();
19447init_frames_getterinfo::<D>();
19448init_length_getterinfo::<D>();
19449init_top_getterinfo::<D>();
19450init_opener_getterinfo::<D>();
19451init_parent_getterinfo::<D>();
19452init_frameElement_getterinfo::<D>();
19453init_navigator_getterinfo::<D>();
19454init_screen_getterinfo::<D>();
19455init_innerWidth_getterinfo::<D>();
19456init_innerHeight_getterinfo::<D>();
19457init_scrollX_getterinfo::<D>();
19458init_pageXOffset_getterinfo::<D>();
19459init_scrollY_getterinfo::<D>();
19460init_pageYOffset_getterinfo::<D>();
19461init_screenX_getterinfo::<D>();
19462init_screenY_getterinfo::<D>();
19463init_outerWidth_getterinfo::<D>();
19464init_outerHeight_getterinfo::<D>();
19465init_devicePixelRatio_getterinfo::<D>();
19466init_runningAnimationCount_getterinfo::<D>();
19467init_event_getterinfo::<D>();
19468init_cookieStore_getterinfo::<D>();
19469init_testRunner_getterinfo::<D>();
19470init_onabort_getterinfo::<D>();
19471init_onauxclick_getterinfo::<D>();
19472init_onbeforeinput_getterinfo::<D>();
19473init_onbeforematch_getterinfo::<D>();
19474init_onbeforetoggle_getterinfo::<D>();
19475init_onblur_getterinfo::<D>();
19476init_oncancel_getterinfo::<D>();
19477init_oncanplay_getterinfo::<D>();
19478init_oncanplaythrough_getterinfo::<D>();
19479init_onchange_getterinfo::<D>();
19480init_onclick_getterinfo::<D>();
19481init_onclose_getterinfo::<D>();
19482init_oncommand_getterinfo::<D>();
19483init_oncontextlost_getterinfo::<D>();
19484init_oncontextmenu_getterinfo::<D>();
19485init_oncontextrestored_getterinfo::<D>();
19486init_oncopy_getterinfo::<D>();
19487init_oncuechange_getterinfo::<D>();
19488init_oncut_getterinfo::<D>();
19489init_ondblclick_getterinfo::<D>();
19490init_ondrag_getterinfo::<D>();
19491init_ondragend_getterinfo::<D>();
19492init_ondragenter_getterinfo::<D>();
19493init_ondragleave_getterinfo::<D>();
19494init_ondragover_getterinfo::<D>();
19495init_ondragstart_getterinfo::<D>();
19496init_ondrop_getterinfo::<D>();
19497init_ondurationchange_getterinfo::<D>();
19498init_onemptied_getterinfo::<D>();
19499init_onended_getterinfo::<D>();
19500init_onerror_getterinfo::<D>();
19501init_onfocus_getterinfo::<D>();
19502init_onformdata_getterinfo::<D>();
19503init_oninput_getterinfo::<D>();
19504init_oninvalid_getterinfo::<D>();
19505init_onkeydown_getterinfo::<D>();
19506init_onkeypress_getterinfo::<D>();
19507init_onkeyup_getterinfo::<D>();
19508init_onload_getterinfo::<D>();
19509init_onloadeddata_getterinfo::<D>();
19510init_onloadedmetadata_getterinfo::<D>();
19511init_onloadstart_getterinfo::<D>();
19512init_onmousedown_getterinfo::<D>();
19513init_onmouseenter_getterinfo::<D>();
19514init_onmouseleave_getterinfo::<D>();
19515init_onmousemove_getterinfo::<D>();
19516init_onmouseout_getterinfo::<D>();
19517init_onmouseover_getterinfo::<D>();
19518init_onmouseup_getterinfo::<D>();
19519init_onpaste_getterinfo::<D>();
19520init_onpause_getterinfo::<D>();
19521init_onplay_getterinfo::<D>();
19522init_onplaying_getterinfo::<D>();
19523init_onprogress_getterinfo::<D>();
19524init_onratechange_getterinfo::<D>();
19525init_onreset_getterinfo::<D>();
19526init_onresize_getterinfo::<D>();
19527init_onscroll_getterinfo::<D>();
19528init_onscrollend_getterinfo::<D>();
19529init_onsecuritypolicyviolation_getterinfo::<D>();
19530init_onseeked_getterinfo::<D>();
19531init_onseeking_getterinfo::<D>();
19532init_onselect_getterinfo::<D>();
19533init_onslotchange_getterinfo::<D>();
19534init_onstalled_getterinfo::<D>();
19535init_onsubmit_getterinfo::<D>();
19536init_onsuspend_getterinfo::<D>();
19537init_ontimeupdate_getterinfo::<D>();
19538init_ontoggle_getterinfo::<D>();
19539init_onvolumechange_getterinfo::<D>();
19540init_onwaiting_getterinfo::<D>();
19541init_onwebkitanimationend_getterinfo::<D>();
19542init_onwebkitanimationiteration_getterinfo::<D>();
19543init_onwebkitanimationstart_getterinfo::<D>();
19544init_onwebkittransitionend_getterinfo::<D>();
19545init_onwheel_getterinfo::<D>();
19546init_onanimationstart_getterinfo::<D>();
19547init_onanimationiteration_getterinfo::<D>();
19548init_onanimationend_getterinfo::<D>();
19549init_onanimationcancel_getterinfo::<D>();
19550init_ontransitionrun_getterinfo::<D>();
19551init_ontransitionend_getterinfo::<D>();
19552init_ontransitioncancel_getterinfo::<D>();
19553init_onselectstart_getterinfo::<D>();
19554init_onselectionchange_getterinfo::<D>();
19555init_onafterprint_getterinfo::<D>();
19556init_onbeforeprint_getterinfo::<D>();
19557init_onbeforeunload_getterinfo::<D>();
19558init_onhashchange_getterinfo::<D>();
19559init_onlanguagechange_getterinfo::<D>();
19560init_onmessage_getterinfo::<D>();
19561init_onmessageerror_getterinfo::<D>();
19562init_onoffline_getterinfo::<D>();
19563init_ononline_getterinfo::<D>();
19564init_onpagehide_getterinfo::<D>();
19565init_onpagereveal_getterinfo::<D>();
19566init_onpageshow_getterinfo::<D>();
19567init_onpageswap_getterinfo::<D>();
19568init_onpopstate_getterinfo::<D>();
19569init_onrejectionhandled_getterinfo::<D>();
19570init_onstorage_getterinfo::<D>();
19571init_onunhandledrejection_getterinfo::<D>();
19572init_onunload_getterinfo::<D>();
19573init_ongamepadconnected_getterinfo::<D>();
19574init_ongamepaddisconnected_getterinfo::<D>();
19575init_localStorage_getterinfo::<D>();
19576init_origin_getterinfo::<D>();
19577init_indexedDB_getterinfo::<D>();
19578init_performance_getterinfo::<D>();
19579init_isSecureContext_getterinfo::<D>();
19580init_trustedTypes_getterinfo::<D>();
19581init_crypto_getterinfo::<D>();
19582init_sessionStorage_getterinfo::<D>();
19583 init_self_setterinfo::<D>();
19584init_name_setterinfo::<D>();
19585init_location_setterinfo::<D>();
19586init_status_setterinfo::<D>();
19587init_frames_setterinfo::<D>();
19588init_length_setterinfo::<D>();
19589init_opener_setterinfo::<D>();
19590init_parent_setterinfo::<D>();
19591init_screen_setterinfo::<D>();
19592init_innerWidth_setterinfo::<D>();
19593init_innerHeight_setterinfo::<D>();
19594init_scrollX_setterinfo::<D>();
19595init_pageXOffset_setterinfo::<D>();
19596init_scrollY_setterinfo::<D>();
19597init_pageYOffset_setterinfo::<D>();
19598init_screenX_setterinfo::<D>();
19599init_screenY_setterinfo::<D>();
19600init_outerWidth_setterinfo::<D>();
19601init_outerHeight_setterinfo::<D>();
19602init_devicePixelRatio_setterinfo::<D>();
19603init_event_setterinfo::<D>();
19604init_onabort_setterinfo::<D>();
19605init_onauxclick_setterinfo::<D>();
19606init_onbeforeinput_setterinfo::<D>();
19607init_onbeforematch_setterinfo::<D>();
19608init_onbeforetoggle_setterinfo::<D>();
19609init_onblur_setterinfo::<D>();
19610init_oncancel_setterinfo::<D>();
19611init_oncanplay_setterinfo::<D>();
19612init_oncanplaythrough_setterinfo::<D>();
19613init_onchange_setterinfo::<D>();
19614init_onclick_setterinfo::<D>();
19615init_onclose_setterinfo::<D>();
19616init_oncommand_setterinfo::<D>();
19617init_oncontextlost_setterinfo::<D>();
19618init_oncontextmenu_setterinfo::<D>();
19619init_oncontextrestored_setterinfo::<D>();
19620init_oncopy_setterinfo::<D>();
19621init_oncuechange_setterinfo::<D>();
19622init_oncut_setterinfo::<D>();
19623init_ondblclick_setterinfo::<D>();
19624init_ondrag_setterinfo::<D>();
19625init_ondragend_setterinfo::<D>();
19626init_ondragenter_setterinfo::<D>();
19627init_ondragleave_setterinfo::<D>();
19628init_ondragover_setterinfo::<D>();
19629init_ondragstart_setterinfo::<D>();
19630init_ondrop_setterinfo::<D>();
19631init_ondurationchange_setterinfo::<D>();
19632init_onemptied_setterinfo::<D>();
19633init_onended_setterinfo::<D>();
19634init_onerror_setterinfo::<D>();
19635init_onfocus_setterinfo::<D>();
19636init_onformdata_setterinfo::<D>();
19637init_oninput_setterinfo::<D>();
19638init_oninvalid_setterinfo::<D>();
19639init_onkeydown_setterinfo::<D>();
19640init_onkeypress_setterinfo::<D>();
19641init_onkeyup_setterinfo::<D>();
19642init_onload_setterinfo::<D>();
19643init_onloadeddata_setterinfo::<D>();
19644init_onloadedmetadata_setterinfo::<D>();
19645init_onloadstart_setterinfo::<D>();
19646init_onmousedown_setterinfo::<D>();
19647init_onmouseenter_setterinfo::<D>();
19648init_onmouseleave_setterinfo::<D>();
19649init_onmousemove_setterinfo::<D>();
19650init_onmouseout_setterinfo::<D>();
19651init_onmouseover_setterinfo::<D>();
19652init_onmouseup_setterinfo::<D>();
19653init_onpaste_setterinfo::<D>();
19654init_onpause_setterinfo::<D>();
19655init_onplay_setterinfo::<D>();
19656init_onplaying_setterinfo::<D>();
19657init_onprogress_setterinfo::<D>();
19658init_onratechange_setterinfo::<D>();
19659init_onreset_setterinfo::<D>();
19660init_onresize_setterinfo::<D>();
19661init_onscroll_setterinfo::<D>();
19662init_onscrollend_setterinfo::<D>();
19663init_onsecuritypolicyviolation_setterinfo::<D>();
19664init_onseeked_setterinfo::<D>();
19665init_onseeking_setterinfo::<D>();
19666init_onselect_setterinfo::<D>();
19667init_onslotchange_setterinfo::<D>();
19668init_onstalled_setterinfo::<D>();
19669init_onsubmit_setterinfo::<D>();
19670init_onsuspend_setterinfo::<D>();
19671init_ontimeupdate_setterinfo::<D>();
19672init_ontoggle_setterinfo::<D>();
19673init_onvolumechange_setterinfo::<D>();
19674init_onwaiting_setterinfo::<D>();
19675init_onwebkitanimationend_setterinfo::<D>();
19676init_onwebkitanimationiteration_setterinfo::<D>();
19677init_onwebkitanimationstart_setterinfo::<D>();
19678init_onwebkittransitionend_setterinfo::<D>();
19679init_onwheel_setterinfo::<D>();
19680init_onanimationstart_setterinfo::<D>();
19681init_onanimationiteration_setterinfo::<D>();
19682init_onanimationend_setterinfo::<D>();
19683init_onanimationcancel_setterinfo::<D>();
19684init_ontransitionrun_setterinfo::<D>();
19685init_ontransitionend_setterinfo::<D>();
19686init_ontransitioncancel_setterinfo::<D>();
19687init_onselectstart_setterinfo::<D>();
19688init_onselectionchange_setterinfo::<D>();
19689init_onafterprint_setterinfo::<D>();
19690init_onbeforeprint_setterinfo::<D>();
19691init_onbeforeunload_setterinfo::<D>();
19692init_onhashchange_setterinfo::<D>();
19693init_onlanguagechange_setterinfo::<D>();
19694init_onmessage_setterinfo::<D>();
19695init_onmessageerror_setterinfo::<D>();
19696init_onoffline_setterinfo::<D>();
19697init_ononline_setterinfo::<D>();
19698init_onpagehide_setterinfo::<D>();
19699init_onpagereveal_setterinfo::<D>();
19700init_onpageshow_setterinfo::<D>();
19701init_onpageswap_setterinfo::<D>();
19702init_onpopstate_setterinfo::<D>();
19703init_onrejectionhandled_setterinfo::<D>();
19704init_onstorage_setterinfo::<D>();
19705init_onunhandledrejection_setterinfo::<D>();
19706init_onunload_setterinfo::<D>();
19707init_ongamepadconnected_setterinfo::<D>();
19708init_ongamepaddisconnected_setterinfo::<D>();
19709init_origin_setterinfo::<D>();
19710init_performance_setterinfo::<D>();
19711
19712 init_sMethods_specs::<D>();
19713init_sMethods_prefs::<D>();
19714init_sAttributes_specs::<D>();
19715init_sAttributes_prefs::<D>();
19716init_sLegacyUnforgeableAttributes_specs::<D>();
19717init_sLegacyUnforgeableAttributes_prefs::<D>();
19718 }
19719 }