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


/// `interface nsIDivertableChannel : nsISupports`
///

/// ```text
/// /**
///  * A channel implementing this interface allows diverting from an
///  * nsIStreamListener in the child process to one in the parent.
///  */
/// ```
///

// 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 nsIDivertableChannel {
    vtable: *const nsIDivertableChannelVTable,

    /// 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 nsIDivertableChannel.
unsafe impl XpCom for nsIDivertableChannel {
    const IID: nsIID = nsID(0x7a9bf52d, 0xf828, 0x4b31,
        [0xb8, 0xdf, 0xb4, 0x0f, 0xdd, 0x37, 0xd0, 0x07]);
}

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

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

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

    /* ChannelDiverterChild divertToParent (); */
    /// Unable to generate binding because `native type mozilla::net::ChannelDiverterChild is unsupported`
    pub DivertToParent: *const ::libc::c_void,

    /* void unknownDecoderInvolvedKeepData (); */
    pub UnknownDecoderInvolvedKeepData: unsafe extern "system" fn (this: *const nsIDivertableChannel) -> nsresult,

    /* void unknownDecoderInvolvedOnStartRequestCalled (); */
    pub UnknownDecoderInvolvedOnStartRequestCalled: unsafe extern "system" fn (this: *const nsIDivertableChannel) -> nsresult,

    /* readonly attribute bool divertingToParent; */
    pub GetDivertingToParent: unsafe extern "system" fn (this: *const nsIDivertableChannel, aDivertingToParent: *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 nsIDivertableChannel {

    /// ```text
    /// /**
    ///    * CHILD ONLY.
    ///    * Called by Necko client in child process during OnStartRequest to divert
    ///    * nsIStreamListener and nsIRequest callbacks to the parent process.
    ///    *
    ///    * The process should look like the following:
    ///    *
    ///    * 1) divertToParent is called in the child process.  It can only be called
///    *    during OnStartRequest().
///    *
///    * 2) The ChannelDiverterChild that is returned is an IPDL object. It should
///    *    be passed via some other IPDL method of the client's choosing to the
///    *    parent.  On the parent the ChannelDiverterParent's divertTo() function
///    *    should be called with an nsIStreamListener that will then receive the
///    *    OnStartRequest/OnDataAvailable/OnStopRequest for the channel.  The
///    *    ChannelDiverterParent can then be deleted (which will also destroy the
///    *    ChannelDiverterChild in the child).
///    *
///    *    After divertToParent() has been called, NO further function calls
///    *    should be made on the channel.  It is a dead object for all purposes.
///    *    The reference that the channel holds to the listener in the child is
///    *    released is once OnStartRequest completes, and no other
///    *    nsIStreamListener calls (OnDataAvailable, OnStopRequest) will be made
///    *    to it.
///    *
///    * @return ChannelDiverterChild IPDL actor to be passed to parent process by
///    *         client IPDL message, e.g. PClient.DivertUsing(PDiverterChild).
///    *
///    * @throws exception if the channel was canceled early. Throws status code of
///    *         canceled channel.
///    */
/// ```
///

/// `ChannelDiverterChild divertToParent ();`
const _DivertToParent: () = ();

/// ```text
/// /**
///    * nsUnknownDecoder delays calling OnStartRequest until it gets enough data
///    * to decide about the content type (until OnDataAvaiable is called). In a
///    * OnStartRequest DivertToParent can be called but some OnDataAvailables are
///    * already called and therefore can not be diverted to parent.
///    *
///    * nsUnknownDecoder will call UnknownDecoderInvolvedKeepData in its
///    * OnStartRequest function and when it calls OnStartRequest of the next
///    * listener it will call UnknownDecoderInvolvedOnStartRequestCalled. In this
///    * function Child process will decide to discarge data if it is not diverting
///    * to parent or keep them if it is diverting to parent.
///    */
/// ```
///

/// `void unknownDecoderInvolvedKeepData ();`
#[inline]
pub unsafe fn UnknownDecoderInvolvedKeepData(&self, ) -> nsresult {
((*self.vtable).UnknownDecoderInvolvedKeepData)(self, )
}



/// `void unknownDecoderInvolvedOnStartRequestCalled ();`
#[inline]
pub unsafe fn UnknownDecoderInvolvedOnStartRequestCalled(&self, ) -> nsresult {
((*self.vtable).UnknownDecoderInvolvedOnStartRequestCalled)(self, )
}



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


}