/* 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::XRCompositionLayer_Binding::{Wrap, GetProtoObject, GetConstructorObject, DefineDOMInterface};
pub mod XRCompositionLayer_Binding {
use crate::dom;
use crate::dom::bindings::codegen::Bindings::EventTargetBinding::EventTarget_Binding;
use crate::dom::bindings::codegen::Bindings::XRLayerBinding::XRLayer_Binding;
use crate::dom::bindings::import::module::*;
use crate::dom::types::EventTarget;
use crate::dom::types::XRCompositionLayer;
use crate::dom::types::XRLayer;

unsafe extern fn _finalize(_cx: *mut GCContext, obj: *mut JSObject) {
    wrap_panic(&mut || {

        let this = native_from_object_static::<XRCompositionLayer>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern fn _trace(trc: *mut JSTracer, obj: *mut JSObject) {
    wrap_panic(&mut || {

        let this = native_from_object_static::<XRCompositionLayer>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}

static CLASS_OPS: JSClassOps = JSClassOps {
    addProperty: None,
    delProperty: None,
    enumerate: None,
    newEnumerate: None,
    resolve: None,
    mayResolve: None,
    finalize: Some(_finalize),
    call: None,
    construct: None,
    trace: Some(_trace),
};

static Class: DOMJSClass = DOMJSClass {
    base: JSClass {
        name: b"XRCompositionLayer\0" as *const u8 as *const libc::c_char,
        flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
               (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
               /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
        cOps: &CLASS_OPS,
        spec: ptr::null(),
        ext: ptr::null(),
        oOps: ptr::null(),
    },
    dom_class: DOMClass {
    interface_chain: [ PrototypeList::ID::EventTarget, PrototypeList::ID::XRLayer, PrototypeList::ID::XRCompositionLayer, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 2,
    type_id: crate::dom::bindings::codegen::InheritTypes::TopTypeId { eventtarget: (crate::dom::bindings::codegen::InheritTypes::EventTargetTypeId::XRLayer(crate::dom::bindings::codegen::InheritTypes::XRLayerTypeId::XRCompositionLayer(crate::dom::bindings::codegen::InheritTypes::XRCompositionLayerTypeId::XRCompositionLayer))) },
    malloc_size_of: malloc_size_of_including_raw_self::<XRCompositionLayer> as unsafe fn(&mut _, _) -> _,
    global: InterfaceObjectMap::Globals::EMPTY,
}
};

impl XRCompositionLayer {
    fn __assert_parent_type(&self) {
        use crate::dom::bindings::inheritance::HasParent;
        // If this type assertion fails, make sure the first field of your
        // DOM struct is of the correct type -- it must be the parent class.
        let _: &XRLayer = self.as_parent();
    }
}

pub unsafe fn Wrap(cx: SafeJSContext, scope: &GlobalScope, given_proto: Option<HandleObject>, object: Box<XRCompositionLayer>) -> DomRoot<XRCompositionLayer> {
    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(*cx, scope.get());

    rooted!(in(*cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(in(*cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        *proto = *given;
        if get_context_realm(*cx) != get_object_realm(*given) {
            assert!(JS_WrapObject(*cx, proto.handle_mut()));
        }
    } else {
        *proto = *canonical_proto;
    }
    rooted!(in(*cx) let obj = JS_NewObjectWithGivenProto(
        *cx,
        &Class.base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

impl DomObjectWrap for dom::xrcompositionlayer::XRCompositionLayer {
    const WRAP: unsafe fn(
        SafeJSContext,
        &GlobalScope,
        Option<HandleObject>,
        Box<Self>,
    ) -> Root<Dom<Self>> = Wrap;
}

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

impl PartialEq for XRCompositionLayer {
    fn eq(&self, other: &XRCompositionLayer) -> bool {
        self as *const XRCompositionLayer == 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"XRCompositionLayer\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::XRCompositionLayer), CreateInterfaceObjects, rval)

}

static PrototypeClass: JSClass = JSClass {
    name: b"XRCompositionLayerPrototype\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 XRCompositionLayer() {\n    [native code]\n}",
        PrototypeList::ID::XRCompositionLayer,
        2);

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::XRCompositionLayer), CreateInterfaceObjects, rval)

}

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

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

}

fn ConstructorEnabled(aCx: SafeJSContext, aObj: HandleObject) -> bool {
    is_exposed_in(aObj, InterfaceObjectMap::Globals::WINDOW) &&
    pref!(dom.webxr.layers.enabled)
}

unsafe fn CreateInterfaceObjects(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray) {
    rooted!(in(*cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    XRLayer_Binding::GetProtoObject(cx, global, prototype_proto.handle_mut());
    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::XRCompositionLayer as usize].is_null());
    (*cache)[PrototypeList::ID::XRCompositionLayer as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::XRCompositionLayer as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(in(*cx) let mut interface_proto = ptr::null_mut::<JSObject>());

    XRLayer_Binding::GetConstructorObject(cx, global, interface_proto.handle_mut());
    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"XRCompositionLayer\0",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
    assert!((*cache)[PrototypeList::Constructor::XRCompositionLayer as usize].is_null());
    (*cache)[PrototypeList::Constructor::XRCompositionLayer as usize] = interface.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::XRCompositionLayer as isize),
                                  ptr::null_mut(),
                                  interface.get());

}
} // mod XRCompositionLayer_Binding