1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */

#![allow(non_camel_case_types,non_upper_case_globals,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]

use crate::dom::bindings::import::base::*;

pub use self::WebGLObject_Binding::{GetProtoObject, GetConstructorObject, DefineDOMInterface};
pub mod WebGLObject_Binding {
use crate::dom;
use crate::dom::bindings::import::module::*;
use crate::dom::types::WebGLObject;

impl IDLInterface for WebGLObject {
    #[inline]
    fn derives(class: &'static DOMClass) -> bool {
        class.interface_chain[0] == PrototypeList::ID::WebGLObject
    }
}

impl PartialEq for WebGLObject {
    fn eq(&self, other: &WebGLObject) -> bool {
        self as *const WebGLObject == other
    }
}

const sAttributes_specs: &[&[JSPropertySpec]] = &[
&[
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: b"WebGLObject\0" as *const u8 as *const libc::c_char,
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]

];
const sAttributes: &[Guard<&[JSPropertySpec]>] = &[
    Guard::new(Condition::Satisfied, sAttributes_specs[0])
];

pub fn GetProtoObject(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject) {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
            get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WebGLObject), CreateInterfaceObjects, rval)

}

static PrototypeClass: JSClass = JSClass {
    name: b"WebGLObjectPrototype\0" as *const u8 as *const libc::c_char,
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS(0)
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: 0 as *const _,
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

static INTERFACE_OBJECT_CLASS: NonCallbackInterfaceObjectClass =
    NonCallbackInterfaceObjectClass::new(
        {
            // Intermediate `const` because as of nightly-2018-10-05,
            // rustc is conservative in promotion to `'static` of the return values of `const fn`s:
            // https://github.com/rust-lang/rust/issues/54846
            // https://github.com/rust-lang/rust/pull/53851
            const BEHAVIOR: InterfaceConstructorBehavior = InterfaceConstructorBehavior::throw();
            &BEHAVIOR
        },
        b"function WebGLObject() {\n    [native code]\n}",
        PrototypeList::ID::WebGLObject,
        0);

pub fn GetConstructorObject(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject) {
    /* Get the interface object for this class.  This will create the object as
       needed. */
            get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::WebGLObject), CreateInterfaceObjects, rval)

}

pub fn DefineDOMInterface(cx: SafeJSContext, global: HandleObject) {

            define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WebGLObject), CreateInterfaceObjects, ConstructorEnabled)

}

fn ConstructorEnabled(aCx: SafeJSContext, aObj: HandleObject) -> bool {
    is_exposed_in(aObj, InterfaceObjectMap::Globals::WINDOW)
}

unsafe fn CreateInterfaceObjects(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray) {
    rooted!(in(*cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(*cx));
    assert!(!prototype_proto.is_null());

    rooted!(in(*cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes,
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::WebGLObject as usize].is_null());
    (*cache)[PrototypeList::ID::WebGLObject as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::WebGLObject as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(in(*cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(*cx));
    assert!(!interface_proto.is_null());

    rooted!(in(*cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object(cx,
                                        global,
                                        interface_proto.handle(),
                                        &INTERFACE_OBJECT_CLASS,
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        b"WebGLObject\0",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
    assert!((*cache)[PrototypeList::Constructor::WebGLObject as usize].is_null());
    (*cache)[PrototypeList::Constructor::WebGLObject as usize] = interface.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::WebGLObject as isize),
                                  ptr::null_mut(),
                                  interface.get());

}
} // mod WebGLObject_Binding