//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsIScriptSecurityManager.idl
//


/// `interface nsIScriptSecurityManager : nsISupports`
///


// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsIScriptSecurityManager {
    vtable: *const nsIScriptSecurityManagerVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIScriptSecurityManager.
unsafe impl XpCom for nsIScriptSecurityManager {
    const IID: nsIID = nsID(0x51daad87, 0x3a0c, 0x44cc,
        [0xb6, 0x20, 0x73, 0x56, 0x80, 0x1c, 0x90, 0x22]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIScriptSecurityManager {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsIScriptSecurityManager.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIScriptSecurityManagerCoerce {
    /// Cheaply cast a value of this type from a `nsIScriptSecurityManager`.
    fn coerce_from(v: &nsIScriptSecurityManager) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIScriptSecurityManagerCoerce for nsIScriptSecurityManager {
    #[inline]
    fn coerce_from(v: &nsIScriptSecurityManager) -> &Self {
        v
    }
}

impl nsIScriptSecurityManager {
    /// Cast this `nsIScriptSecurityManager` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIScriptSecurityManagerCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIScriptSecurityManager {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIScriptSecurityManagerCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIScriptSecurityManager) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIScriptSecurityManager
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIScriptSecurityManagerVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* [noscript] void canCreateWrapper (in JSContextPtr aJSContext, in nsIIDRef aIID, in nsISupports aObj, in nsIClassInfo aClassInfo); */
    /// Unable to generate binding because `native type JSContext is unsupported`
    pub CanCreateWrapper: *const ::libc::c_void,

    /* [noscript] void canCreateInstance (in JSContextPtr aJSContext, in nsCIDRef aCID); */
    /// Unable to generate binding because `native type JSContext is unsupported`
    pub CanCreateInstance: *const ::libc::c_void,

    /* [noscript] void canGetService (in JSContextPtr aJSContext, in nsCIDRef aCID); */
    /// Unable to generate binding because `native type JSContext is unsupported`
    pub CanGetService: *const ::libc::c_void,

    /* [noscript] void checkLoadURIFromScript (in JSContextPtr cx, in nsIURI uri); */
    /// Unable to generate binding because `native type JSContext is unsupported`
    pub CheckLoadURIFromScript: *const ::libc::c_void,

    /* void checkLoadURIWithPrincipal (in nsIPrincipal aPrincipal, in nsIURI uri, in unsigned long flags); */
    pub CheckLoadURIWithPrincipal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aPrincipal: *const nsIPrincipal, uri: *const nsIURI, flags: libc::uint32_t) -> nsresult,

    /* void checkLoadURIStrWithPrincipal (in nsIPrincipal aPrincipal, in AUTF8String uri, in unsigned long flags); */
    pub CheckLoadURIStrWithPrincipal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aPrincipal: *const nsIPrincipal, uri: &::nsstring::nsACString, flags: libc::uint32_t) -> nsresult,

    /* bool inFileURIWhitelist (in nsIURI aUri); */
    pub InFileURIWhitelist: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aUri: *const nsIURI, _retval: *mut bool) -> nsresult,

    /* nsIPrincipal getSystemPrincipal (); */
    pub GetSystemPrincipal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, _retval: *mut *const nsIPrincipal) -> nsresult,

    /* nsIPrincipal getLoadContextCodebasePrincipal (in nsIURI uri, in nsILoadContext loadContext); */
    pub GetLoadContextCodebasePrincipal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, uri: *const nsIURI, loadContext: *const nsILoadContext, _retval: *mut *const nsIPrincipal) -> nsresult,

    /* nsIPrincipal getDocShellCodebasePrincipal (in nsIURI uri, in nsIDocShell docShell); */
    pub GetDocShellCodebasePrincipal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, uri: *const nsIURI, docShell: *const nsIDocShell, _retval: *mut *const nsIPrincipal) -> nsresult,

    /* [implicit_jscontext] nsIPrincipal createCodebasePrincipal (in nsIURI uri, in jsval originAttributes); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub CreateCodebasePrincipal: *const ::libc::c_void,

    /* nsIPrincipal createCodebasePrincipalFromOrigin (in ACString origin); */
    pub CreateCodebasePrincipalFromOrigin: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, origin: &::nsstring::nsACString, _retval: *mut *const nsIPrincipal) -> nsresult,

    /* [implicit_jscontext] nsIPrincipal createNullPrincipal (in jsval originAttributes); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub CreateNullPrincipal: *const ::libc::c_void,

    /* void checkSameOriginURI (in nsIURI aSourceURI, in nsIURI aTargetURI, in boolean reportError); */
    pub CheckSameOriginURI: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aSourceURI: *const nsIURI, aTargetURI: *const nsIURI, reportError: bool) -> nsresult,

    /* nsIPrincipal getChannelResultPrincipal (in nsIChannel aChannel); */
    pub GetChannelResultPrincipal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aChannel: *const nsIChannel, _retval: *mut *const nsIPrincipal) -> nsresult,

    /* [noscript,nostdcall] nsIPrincipal getChannelResultPrincipalIfNotSandboxed (in nsIChannel aChannel); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub GetChannelResultPrincipalIfNotSandboxed: *const ::libc::c_void,

    /* nsIPrincipal getChannelURIPrincipal (in nsIChannel aChannel); */
    pub GetChannelURIPrincipal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aChannel: *const nsIChannel, _retval: *mut *const nsIPrincipal) -> nsresult,

    /* boolean isSystemPrincipal (in nsIPrincipal aPrincipal); */
    pub IsSystemPrincipal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aPrincipal: *const nsIPrincipal, _retval: *mut bool) -> nsresult,

    /* nsIDomainPolicy activateDomainPolicy (); */
    pub ActivateDomainPolicy: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, _retval: *mut *const nsIDomainPolicy) -> nsresult,

    /* readonly attribute boolean domainPolicyActive; */
    pub GetDomainPolicyActive: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aDomainPolicyActive: *mut bool) -> nsresult,

    /* [noscript] nsIDomainPolicy activateDomainPolicyInternal (); */
    pub ActivateDomainPolicyInternal: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, _retval: *mut *const nsIDomainPolicy) -> nsresult,

    /* [noscript,notxpcom] void cloneDomainPolicy (in DomainPolicyClonePtr aClone); */
    /// Unable to generate binding because `native type mozilla::dom::DomainPolicyClone is unsupported`
    pub CloneDomainPolicy: *const ::libc::c_void,

    /* bool policyAllowsScript (in nsIURI aDomain); */
    pub PolicyAllowsScript: unsafe extern "system" fn (this: *const nsIScriptSecurityManager, aDomain: *const nsIURI, _retval: *mut bool) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIScriptSecurityManager {
    /// ```text
    /// /**
    ///      * Default CheckLoadURI permissions
    ///      */
    /// ```
    ///

    pub const STANDARD: i64 = 0;


    pub const LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT: i64 = 1;


    pub const ALLOW_CHROME: i64 = 2;


    pub const DISALLOW_INHERIT_PRINCIPAL: i64 = 4;


    pub const DISALLOW_SCRIPT_OR_DATA: i64 = 4;


    pub const DISALLOW_SCRIPT: i64 = 8;


    pub const DONT_REPORT_ERRORS: i64 = 16;


    pub const NO_APP_ID: i64 = 0;


    pub const UNKNOWN_APP_ID: i64 = 4294967295;


    pub const DEFAULT_USER_CONTEXT_ID: i64 = 0;

    /// ```text
    /// /**
    ///      * For each of these hooks returning NS_OK means 'let the action continue'.
    ///      * Returning an error code means 'veto the action'. XPConnect will return
    ///      * false to the js engine if the action is vetoed. The implementor of this
    ///      * interface is responsible for setting a JS exception into the JSContext
    ///      * if that is appropriate.
    ///      */
    /// ```
    ///

    /// `[noscript] void canCreateWrapper (in JSContextPtr aJSContext, in nsIIDRef aIID, in nsISupports aObj, in nsIClassInfo aClassInfo);`
    const _CanCreateWrapper: () = ();


    /// `[noscript] void canCreateInstance (in JSContextPtr aJSContext, in nsCIDRef aCID);`
    const _CanCreateInstance: () = ();


    /// `[noscript] void canGetService (in JSContextPtr aJSContext, in nsCIDRef aCID);`
    const _CanGetService: () = ();

    /// ```text
    /// /**
    ///      * Check that the script currently running in context "cx" can load "uri".
    ///      *
    ///      * Will return error code NS_ERROR_DOM_BAD_URI if the load request
    ///      * should be denied.
    ///      *
    ///      * @param cx the JSContext of the script causing the load
    ///      * @param uri the URI that is being loaded
    ///      */
    /// ```
    ///

    /// `[noscript] void checkLoadURIFromScript (in JSContextPtr cx, in nsIURI uri);`
    const _CheckLoadURIFromScript: () = ();

    /// ```text
    /// /**
    ///      * Check that content with principal aPrincipal can load "uri".
    ///      *
    ///      * Will return error code NS_ERROR_DOM_BAD_URI if the load request
    ///      * should be denied.
    ///      *
    ///      * @param aPrincipal the principal identifying the actor causing the load
    ///      * @param uri the URI that is being loaded
    ///      * @param flags the permission set, see above
    ///      */
    /// ```
    ///

    /// `void checkLoadURIWithPrincipal (in nsIPrincipal aPrincipal, in nsIURI uri, in unsigned long flags);`
    #[inline]
    pub unsafe fn CheckLoadURIWithPrincipal(&self, aPrincipal: *const nsIPrincipal, uri: *const nsIURI, flags: libc::uint32_t) -> nsresult {
        ((*self.vtable).CheckLoadURIWithPrincipal)(self, aPrincipal, uri, flags)
    }


    /// ```text
    /// /**
    ///      * Similar to checkLoadURIWithPrincipal but there are two differences:
    ///      *
    ///      * 1) The URI is a string, not a URI object.
///      * 2) This function assumes that the URI may still be subject to fixup (and
///      * hence will check whether fixed-up versions of the URI are allowed to
///      * load as well); if any of the versions of this URI is not allowed, this
///      * function will return error code NS_ERROR_DOM_BAD_URI.
///      */
/// ```
///

/// `void checkLoadURIStrWithPrincipal (in nsIPrincipal aPrincipal, in AUTF8String uri, in unsigned long flags);`
#[inline]
pub unsafe fn CheckLoadURIStrWithPrincipal(&self, aPrincipal: *const nsIPrincipal, uri: &::nsstring::nsACString, flags: libc::uint32_t) -> nsresult {
((*self.vtable).CheckLoadURIStrWithPrincipal)(self, aPrincipal, uri, flags)
}


/// ```text
/// /**
///      * Returns true if the URI is from a domain that is white-listed through
///      * prefs to be allowed to use file:// URIs.
///      * @param aUri the URI to be tested
///      */
/// ```
///

/// `bool inFileURIWhitelist (in nsIURI aUri);`
#[inline]
pub unsafe fn InFileURIWhitelist(&self, aUri: *const nsIURI, _retval: *mut bool) -> nsresult {
((*self.vtable).InFileURIWhitelist)(self, aUri, _retval)
}


/// ```text
/// /**
///      * Return the all-powerful system principal.
///      */
/// ```
///

/// `nsIPrincipal getSystemPrincipal ();`
#[inline]
pub unsafe fn GetSystemPrincipal(&self, _retval: *mut *const nsIPrincipal) -> nsresult {
((*self.vtable).GetSystemPrincipal)(self, _retval)
}


/// ```text
/// /**
///      * Returns a principal that has the OriginAttributes of the load context.
///      * @param loadContext to get the OriginAttributes from.
///      */
/// ```
///

/// `nsIPrincipal getLoadContextCodebasePrincipal (in nsIURI uri, in nsILoadContext loadContext);`
#[inline]
pub unsafe fn GetLoadContextCodebasePrincipal(&self, uri: *const nsIURI, loadContext: *const nsILoadContext, _retval: *mut *const nsIPrincipal) -> nsresult {
((*self.vtable).GetLoadContextCodebasePrincipal)(self, uri, loadContext, _retval)
}


/// ```text
/// /**
///      * Returns a principal that has the OriginAttributes of the docshell.
///      * @param docShell to get the OriginAttributes from.
///      */
/// ```
///

/// `nsIPrincipal getDocShellCodebasePrincipal (in nsIURI uri, in nsIDocShell docShell);`
#[inline]
pub unsafe fn GetDocShellCodebasePrincipal(&self, uri: *const nsIURI, docShell: *const nsIDocShell, _retval: *mut *const nsIPrincipal) -> nsresult {
((*self.vtable).GetDocShellCodebasePrincipal)(self, uri, docShell, _retval)
}


/// ```text
/// /**
///      * Returns a principal whose origin is composed of |uri| and |originAttributes|.
///      * See nsIPrincipal.idl for a description of origin attributes, and
///      * ChromeUtils.webidl for a list of origin attributes and their defaults.
///      */
/// ```
///

/// `[implicit_jscontext] nsIPrincipal createCodebasePrincipal (in nsIURI uri, in jsval originAttributes);`
const _CreateCodebasePrincipal: () = ();

/// ```text
/// /**
///      * Returns a principal whose origin is the one we pass in.
///      * See nsIPrincipal.idl for a description of origin attributes, and
///      * ChromeUtils.webidl for a list of origin attributes and their defaults.
///      */
/// ```
///

/// `nsIPrincipal createCodebasePrincipalFromOrigin (in ACString origin);`
#[inline]
pub unsafe fn CreateCodebasePrincipalFromOrigin(&self, origin: &::nsstring::nsACString, _retval: *mut *const nsIPrincipal) -> nsresult {
((*self.vtable).CreateCodebasePrincipalFromOrigin)(self, origin, _retval)
}


/// ```text
/// /**
///      * Returns a unique nonce principal with |originAttributes|.
///      * See nsIPrincipal.idl for a description of origin attributes, and
///      * ChromeUtils.webidl for a list of origin attributes and their defaults.
///      */
/// ```
///

/// `[implicit_jscontext] nsIPrincipal createNullPrincipal (in jsval originAttributes);`
const _CreateNullPrincipal: () = ();

/// ```text
/// /**
///      * Returns OK if aSourceURI and target have the same "origin"
///      * (scheme, host, and port).
///      * ReportError flag suppresses error reports for functions that
///      * don't need reporting.
///      */
/// ```
///

/// `void checkSameOriginURI (in nsIURI aSourceURI, in nsIURI aTargetURI, in boolean reportError);`
#[inline]
pub unsafe fn CheckSameOriginURI(&self, aSourceURI: *const nsIURI, aTargetURI: *const nsIURI, reportError: bool) -> nsresult {
((*self.vtable).CheckSameOriginURI)(self, aSourceURI, aTargetURI, reportError)
}


/// ```text
/// /**
///      * Get the principal for the given channel.  This will typically be the
///      * channel owner if there is one, and the codebase principal for the
///      * channel's URI otherwise.  aChannel must not be null.
///      */
/// ```
///

/// `nsIPrincipal getChannelResultPrincipal (in nsIChannel aChannel);`
#[inline]
pub unsafe fn GetChannelResultPrincipal(&self, aChannel: *const nsIChannel, _retval: *mut *const nsIPrincipal) -> nsresult {
((*self.vtable).GetChannelResultPrincipal)(self, aChannel, _retval)
}


/// ```text
/// /**
///      * Temporary API until bug 1220687 is fixed.
///      *
///      * Returns the same value as getChannelResultPrincipal, but ignoring
///      * sandboxing.  Specifically, if sandboxing would have prevented the
///      * channel's triggering principal from being returned by
///      * getChannelResultPrincipal, the triggering principal will be returned
///      * by this method.
///      *
///      * Note that this method only ignores sandboxing of the channel in
///      * question, it does not ignore sandboxing of any channels further up a
///      * document chain.  The triggering principal itself may still be the null
///      * principal due to sandboxing further up a document chain.  In that regard
///      * the ignoring of sandboxing is limited.
///      */
/// ```
///

/// `[noscript,nostdcall] nsIPrincipal getChannelResultPrincipalIfNotSandboxed (in nsIChannel aChannel);`
const _GetChannelResultPrincipalIfNotSandboxed: () = ();

/// ```text
/// /**
///      * Get the codebase principal for the channel's URI.
///      * aChannel must not be null.
///      */
/// ```
///

/// `nsIPrincipal getChannelURIPrincipal (in nsIChannel aChannel);`
#[inline]
pub unsafe fn GetChannelURIPrincipal(&self, aChannel: *const nsIChannel, _retval: *mut *const nsIPrincipal) -> nsresult {
((*self.vtable).GetChannelURIPrincipal)(self, aChannel, _retval)
}


/// ```text
/// /**
///      * Check whether a given principal is a system principal.  This allows us
///      * to avoid handing back the system principal to script while allowing
///      * script to check whether a given principal is system.
///      */
/// ```
///

/// `boolean isSystemPrincipal (in nsIPrincipal aPrincipal);`
#[inline]
pub unsafe fn IsSystemPrincipal(&self, aPrincipal: *const nsIPrincipal, _retval: *mut bool) -> nsresult {
((*self.vtable).IsSystemPrincipal)(self, aPrincipal, _retval)
}


/// ```text
/// /**
///      * Per-domain controls to enable and disable script. This system is designed
///      * to be used by at most one consumer, and enforces this with its semantics.
///      *
///      * Initially, domainPolicyActive is false. When activateDomainPolicy() is
///      * invoked, domainPolicyActive becomes true, and subsequent calls to
///      * activateDomainPolicy() will fail until deactivate() is invoked on the
///      * nsIDomainPolicy returned from activateDomainPolicy(). At this point,
///      * domainPolicyActive becomes false again, and a new consumer may acquire
///      * control of the system by invoking activateDomainPolicy().
///      */
/// ```
///

/// `nsIDomainPolicy activateDomainPolicy ();`
#[inline]
pub unsafe fn ActivateDomainPolicy(&self, _retval: *mut *const nsIDomainPolicy) -> nsresult {
((*self.vtable).ActivateDomainPolicy)(self, _retval)
}



/// `readonly attribute boolean domainPolicyActive;`
#[inline]
pub unsafe fn GetDomainPolicyActive(&self, aDomainPolicyActive: *mut bool) -> nsresult {
((*self.vtable).GetDomainPolicyActive)(self, aDomainPolicyActive)
}


/// ```text
/// /**
///      * Only the parent process can directly access domain policies, child
///      * processes only have a read-only mirror to the one in the parent.
///      * For child processes the mirror is updated via messages
///      * and ContentChild will hold the DomainPolicy by calling
///      * ActivateDomainPolicyInternal directly. New consumer to this
///      * function should not be addded.
///      */
/// ```
///

/// `[noscript] nsIDomainPolicy activateDomainPolicyInternal ();`
#[inline]
pub unsafe fn ActivateDomainPolicyInternal(&self, _retval: *mut *const nsIDomainPolicy) -> nsresult {
((*self.vtable).ActivateDomainPolicyInternal)(self, _retval)
}


/// ```text
/// /**
///      * This function is for internal use only. Every time a child process is spawned, we
///      * must clone any active domain policies in the parent to the new child.
///      */
/// ```
///

/// `[noscript,notxpcom] void cloneDomainPolicy (in DomainPolicyClonePtr aClone);`
const _CloneDomainPolicy: () = ();

/// ```text
/// /**
///      * Query mechanism for the above policy.
///      *
///      * If domainPolicyEnabled is false, this simply returns the current value
///      * of javascript.enabled. Otherwise, it returns the same value, but taking
///      * the various blacklist/whitelist exceptions into account.
///      */
/// ```
///

/// `bool policyAllowsScript (in nsIURI aDomain);`
#[inline]
pub unsafe fn PolicyAllowsScript(&self, aDomain: *const nsIURI, _retval: *mut bool) -> nsresult {
((*self.vtable).PolicyAllowsScript)(self, aDomain, _retval)
}


}