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


/// `interface nsIContentSignatureVerifier : nsISupports`
///

/// ```text
/// /**
///  * An interface for verifying content-signatures, inspired by
///  * https://tools.ietf.org/html/draft-thomson-http-content-signature-00
///  * described here https://github.com/franziskuskiefer/content-signature/tree/pki
///  *
///  * A new signature verifier instance should be created for each signature
///  * verification - you can create these instances with do_CreateInstance.
///  *
///  * There are two ways to use this functionality:
///  * The first allows a signature to be verified all at once by simply calling
///  * verifyContentSignature.
///  * The second allows for streaming; call createContext with the signature
///  * information (and initial data), call update with more data as it becomes
///  * available then, finally, call end to verify the signature.
///  */
/// ```
///

// 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 nsIContentSignatureVerifier {
    vtable: *const nsIContentSignatureVerifierVTable,

    /// 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 nsIContentSignatureVerifier.
unsafe impl XpCom for nsIContentSignatureVerifier {
    const IID: nsIID = nsID(0x45a5fe2f, 0xc350, 0x4b86,
        [0x96, 0x2d, 0x02, 0xd5, 0xaa, 0xaa, 0x95, 0x5a]);
}

// 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 nsIContentSignatureVerifier {
    #[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 nsIContentSignatureVerifier.
// 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 nsIContentSignatureVerifierCoerce {
    /// Cheaply cast a value of this type from a `nsIContentSignatureVerifier`.
    fn coerce_from(v: &nsIContentSignatureVerifier) -> &Self;
}

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

impl nsIContentSignatureVerifier {
    /// Cast this `nsIContentSignatureVerifier` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIContentSignatureVerifierCoerce>(&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 nsIContentSignatureVerifier {
    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> nsIContentSignatureVerifierCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIContentSignatureVerifier) -> &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 nsIContentSignatureVerifier
// 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 nsIContentSignatureVerifierVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* [must_use] boolean verifyContentSignature (in ACString aData, in ACString aContentSignatureHeader, in ACString aCertificateChain, in ACString aName); */
    pub VerifyContentSignature: unsafe extern "system" fn (this: *const nsIContentSignatureVerifier, aData: &::nsstring::nsACString, aContentSignatureHeader: &::nsstring::nsACString, aCertificateChain: &::nsstring::nsACString, aName: &::nsstring::nsACString, _retval: *mut bool) -> nsresult,

    /* [must_use] void createContext (in ACString aData, in ACString aContentSignatureHeader, in ACString aCertificateChain, in ACString aName); */
    pub CreateContext: unsafe extern "system" fn (this: *const nsIContentSignatureVerifier, aData: &::nsstring::nsACString, aContentSignatureHeader: &::nsstring::nsACString, aCertificateChain: &::nsstring::nsACString, aName: &::nsstring::nsACString) -> nsresult,

    /* [must_use] void createContextWithoutCertChain (in nsIContentSignatureReceiverCallback aCallback, in ACString aContentSignatureHeader, in ACString aName); */
    pub CreateContextWithoutCertChain: unsafe extern "system" fn (this: *const nsIContentSignatureVerifier, aCallback: *const nsIContentSignatureReceiverCallback, aContentSignatureHeader: &::nsstring::nsACString, aName: &::nsstring::nsACString) -> nsresult,

    /* [must_use] void update (in ACString aData); */
    pub Update: unsafe extern "system" fn (this: *const nsIContentSignatureVerifier, aData: &::nsstring::nsACString) -> nsresult,

    /* [must_use] boolean end (); */
    pub End: unsafe extern "system" fn (this: *const nsIContentSignatureVerifier, _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 nsIContentSignatureVerifier {

    /// ```text
    /// /**
    ///    * Verifies that the data matches the data that was used to generate the
    ///    * signature.
    ///    *
    ///    * @param aData                   The data to be tested.
    ///    * @param aContentSignatureHeader The content-signature header,
    ///    *                                url-safe base64 encoded.
    ///    * @param aCertificateChain       The certificate chain to use for verification.
    ///    *                                PEM encoded string.
    ///    * @param aName                   The (host)name for which the end entity must
    ///                                     be valid.
    ///    * @returns true if the signature matches the data and aCertificateChain is
    ///    *          valid within aContext, false if not.
    ///    */
    /// ```
    ///

    /// `[must_use] boolean verifyContentSignature (in ACString aData, in ACString aContentSignatureHeader, in ACString aCertificateChain, in ACString aName);`
    #[inline]
    pub unsafe fn VerifyContentSignature(&self, aData: &::nsstring::nsACString, aContentSignatureHeader: &::nsstring::nsACString, aCertificateChain: &::nsstring::nsACString, aName: &::nsstring::nsACString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).VerifyContentSignature)(self, aData, aContentSignatureHeader, aCertificateChain, aName, _retval)
    }


    /// ```text
    /// /**
    ///    * Creates a context to verify a content signature against data that is added
    ///    * later with update calls.
    ///    *
    ///    * @param aData                   The first chunk of data to be tested.
    ///    * @param aContentSignatureHeader The signature of the data, url-safe base64
    ///    *                                encoded.
    ///    * @param aCertificateChain       The certificate chain to use for
    ///    *                                verification. PEM encoded string.
    ///    * @param aName                   The (host)name for which the end entity must
    ///                                     be valid.
    ///    */
    /// ```
    ///

    /// `[must_use] void createContext (in ACString aData, in ACString aContentSignatureHeader, in ACString aCertificateChain, in ACString aName);`
    #[inline]
    pub unsafe fn CreateContext(&self, aData: &::nsstring::nsACString, aContentSignatureHeader: &::nsstring::nsACString, aCertificateChain: &::nsstring::nsACString, aName: &::nsstring::nsACString) -> nsresult {
        ((*self.vtable).CreateContext)(self, aData, aContentSignatureHeader, aCertificateChain, aName)
    }


    /// ```text
    /// /**
    ///    * Creates a context to verify a content signature against data that is added
    ///    * later with update calls.
    ///    * This does not require the caller to download the certificate chain. It's
    ///    * done internally.
    ///    * It requires the x5u parameter to be present in aContentSignatureHeader
    ///    *
    ///    * NOTE: Callers have to wait for aCallback to return before invoking anything
    ///    *       else. Otherwise the ContentSignatureVerifier will fail.
    ///    *
    ///    * @param aCallback               Callback that's invoked when the cert chain
    ///    *                                got fetched.
    ///    * @param aContentSignatureHeader The signature of the data, url-safe base64
    ///    *                                encoded, and the x5u value.
    ///    * @param aName                   The (host)name for which the end entity must
    ///                                     be valid.
    ///    */
    /// ```
    ///

    /// `[must_use] void createContextWithoutCertChain (in nsIContentSignatureReceiverCallback aCallback, in ACString aContentSignatureHeader, in ACString aName);`
    #[inline]
    pub unsafe fn CreateContextWithoutCertChain(&self, aCallback: *const nsIContentSignatureReceiverCallback, aContentSignatureHeader: &::nsstring::nsACString, aName: &::nsstring::nsACString) -> nsresult {
        ((*self.vtable).CreateContextWithoutCertChain)(self, aCallback, aContentSignatureHeader, aName)
    }


    /// ```text
    /// /**
    ///    * Adds data to the context that was used to generate the signature.
    ///    *
    ///    * @param aData        More data to be tested.
    ///    */
    /// ```
    ///

    /// `[must_use] void update (in ACString aData);`
    #[inline]
    pub unsafe fn Update(&self, aData: &::nsstring::nsACString) -> nsresult {
        ((*self.vtable).Update)(self, aData)
    }


    /// ```text
    /// /**
    ///    * Finalises the signature and returns the result of the signature
    ///    * verification.
    ///    *
    ///    * @returns true if the signature matches the data added with createContext
    ///    *          and update, false if not.
    ///    */
    /// ```
    ///

    /// `[must_use] boolean end ();`
    #[inline]
    pub unsafe fn End(&self, _retval: *mut bool) -> nsresult {
        ((*self.vtable).End)(self, _retval)
    }


}


/// `interface nsIContentSignatureReceiverCallback : 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 nsIContentSignatureReceiverCallback {
    vtable: *const nsIContentSignatureReceiverCallbackVTable,

    /// 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 nsIContentSignatureReceiverCallback.
unsafe impl XpCom for nsIContentSignatureReceiverCallback {
    const IID: nsIID = nsID(0x1eb90707, 0xdf59, 0x48b7,
        [0x9d, 0x42, 0xd8, 0xbf, 0x63, 0x0a, 0xe7, 0x44]);
}

// 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 nsIContentSignatureReceiverCallback {
    #[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 nsIContentSignatureReceiverCallback.
// 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 nsIContentSignatureReceiverCallbackCoerce {
    /// Cheaply cast a value of this type from a `nsIContentSignatureReceiverCallback`.
    fn coerce_from(v: &nsIContentSignatureReceiverCallback) -> &Self;
}

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

impl nsIContentSignatureReceiverCallback {
    /// Cast this `nsIContentSignatureReceiverCallback` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIContentSignatureReceiverCallbackCoerce>(&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 nsIContentSignatureReceiverCallback {
    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> nsIContentSignatureReceiverCallbackCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIContentSignatureReceiverCallback) -> &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 nsIContentSignatureReceiverCallback
// 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 nsIContentSignatureReceiverCallbackVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* void contextCreated (in boolean successful); */
    pub ContextCreated: unsafe extern "system" fn (this: *const nsIContentSignatureReceiverCallback, successful: 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 nsIContentSignatureReceiverCallback {

    /// ```text
    /// /**
    ///  * Callback for nsIContentSignatureVerifier.
    ///  * { 0x1eb90707, 0xdf59, 0x48b7, \
        ///  *   { 0x9d, 0x42, 0xd8, 0xbf, 0x63, 0x0a, 0xe7, 0x44 } }
    ///  */
    /// /**
    ///    * Notification callback that's called by nsIContentSignatureVerifier when
    ///    * the cert chain is downloaded.
    ///    * If download and initialisation were successful, successful is true,
    ///    * otherwise false. If successful is false, the verification must be aborted.
    ///    */
    /// ```
    ///

    /// `void contextCreated (in boolean successful);`
    #[inline]
    pub unsafe fn ContextCreated(&self, successful: bool) -> nsresult {
        ((*self.vtable).ContextCreated)(self, successful)
    }


}