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


/// `interface nsIMessageListener : nsISupports`
///

/// ```text
/// /**
///  * Message managers provide a way for chrome-privileged JS code to
///  * communicate with each other, even across process boundaries.
///  *
///  * Message managers are separated into "parent side" and "child side".
///  * These don't always correspond to process boundaries, but can.  For
///  * each child-side message manager, there is always exactly one
///  * corresponding parent-side message manager that it sends messages
///  * to.  However, for each parent-side message manager, there may be
///  * either one or many child-side managers it can message.
///  *
///  * Message managers that always have exactly one "other side" are of
///  * type nsIMessageSender.  Parent-side message managers that have many
///  * "other sides" are of type nsIMessageBroadcaster.
///  *
///  * Child-side message managers can send synchronous messages to their
///  * parent side, but not the other way around.
///  *
///  * There are two realms of message manager hierarchies.  One realm
///  * approximately corresponds to DOM elements, the other corresponds to
///  * process boundaries.
///  *
///  * Message managers corresponding to DOM elements
///  * ==============================================
///  *
///  * In this realm of message managers, there are
///  *  - "frame message managers" which correspond to frame elements
///  *  - "window message managers" which correspond to top-level chrome
///  *    windows
///  *  - "group message managers" which correspond to named message
///  *    managers with a specific window MM as the parent
///  *  - the "global message manager", on the parent side.  See below.
///  *
///  * The DOM-realm message managers can communicate in the ways shown by
///  * the following diagram.  The parent side and child side can
///  * correspond to process boundaries, but don't always.
///  *
///  *  Parent side                         Child side
///  * -------------                       ------------
///  *  global MMg
///  *   |
///  *   +-->window MMw1
///  *   |    |
///  *   |    +-->frame MMp1_1<------------>frame MMc1_1
///  *   |    |
///  *   |    +-->frame MMp1_2<------------>frame MMc1_2
///  *   |    |
///  *   |    +-->group MMgr1
///  *   |    |    |
///  *   |    |    +-->frame MMp2_1<------->frame MMc2_1
///  *   |    |    |
///  *   |    |    +-->frame MMp2_2<------->frame MMc2_2
///  *   |    |
///  *   |    +-->group MMgr2
///  *   |    |    ...
///  *   |    |
///  *   |    ...
///  *   |
///  *   +-->window MMw2
///  *   ...
///  *
///  * For example: a message sent from MMc1_1, from the child side, is
///  * sent only to MMp1_1 on the parent side.  However, note that all
///  * message managers in the hierarchy above MMp1_1, in this diagram
///  * MMw1 and MMg, will also notify their message listeners when the
///  * message arrives.
///  *
///  * A message sent from MMc2_1 will be sent to MMp2_1 and also notify
///  * all message managers in the hierarchy above that, including the
///  * group message manager MMgr1.
///
///  * For example: a message broadcast through the global MMg on the
///  * parent side would be broadcast to MMw1, which would transitively
///  * broadcast it to MMp1_1, MM1p_2.  The message would next be
///  * broadcast to MMgr1, which would broadcast it to MMp2_1 and MMp2_2.
///  * After that it would broadcast to MMgr2 and then to MMw2, and so
///  * on down the hierarchy.
///  *
///  *   ***** PERFORMANCE AND SECURITY WARNING *****
///  * Messages broadcast through the global MM and window or group MMs
///  * can result in messages being dispatched across many OS processes,
///  * and to many processes with different permissions.  Great care
///  * should be taken when broadcasting.
///  *
///  * Interfaces
///  * ----------
///  *
///  * The global MMg and window MMw's are message broadcasters implementing
///  * nsIMessageBroadcaster while the frame MMp's are simple message senders
///  * (nsIMessageSender). Their counterparts in the content processes are
///  * message senders implementing nsIContentFrameMessageManager.
///  *
///  *                    nsIMessageListenerManager
///  *                  /                           \
///  * nsIMessageSender                               nsIMessageBroadcaster
///  *       |
///  * nsISyncMessageSender (content process/in-process only)
///  *       |
///  * nsIContentFrameMessageManager (content process/in-process only)
///  *       |
///  * nsIInProcessContentFrameMessageManager (in-process only)
///  *
///  *
///  * Message managers in the chrome process can also be QI'ed to nsIFrameScriptLoader.
///  *
///  *
///  * Message managers corresponding to process boundaries
///  * ====================================================
///  *
///  * The second realm of message managers is the "process message
///  * managers".  With one exception, these always correspond to process
///  * boundaries.  The picture looks like
///  *
///  *  Parent process                      Child processes
///  * ----------------                    -----------------
///  *  global (GPPMM)
///  *   |
///  *   +-->parent in-process PIPMM<-->child in-process CIPPMM
///  *   |
///  *   +-->parent (PPMM1)<------------------>child (CPMM1)
///  *   |
///  *   +-->parent (PPMM2)<------------------>child (CPMM2)
///  *   ...
///  *
///  * Note, PIPMM and CIPPMM both run in the parent process.
///  *
///  * For example: the parent-process PPMM1 sends messages to the
///  * child-process CPMM1.
///  *
///  * For example: CPMM1 sends messages directly to PPMM1. The global GPPMM
///  * will also notify their message listeners when the message arrives.
///  *
///  * For example: messages sent through the global GPPMM will be
///  * dispatched to the listeners of the same-process, CIPPMM, CPMM1,
///  * CPMM2, etc.
///  *
///  *   ***** PERFORMANCE AND SECURITY WARNING *****
///  * Messages broadcast through the GPPMM can result in messages
///  * being dispatched across many OS processes, and to many processes
///  * with different permissions.  Great care should be taken when
///  * broadcasting.
///  *
///  * Requests sent to parent-process message listeners should usually
///  * have replies scoped to the requesting CPMM.  The following pattern
///  * is common
///  *
///  *  const ParentProcessListener = {
    ///  *    receiveMessage: function(aMessage) {
        ///  *      let childMM = aMessage.target.QueryInterface(Ci.nsIMessageSender);
        ///  *      switch (aMessage.name) {
            ///  *      case "Foo:Request":
            ///  *        // service request
            ///  *        childMM.sendAsyncMessage("Foo:Response", { data });
            ///  *      }
        ///  *    }
    ///  *  };
///  */
/// ```
///

// 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 nsIMessageListener {
    vtable: *const nsIMessageListenerVTable,

    /// 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 nsIMessageListener.
unsafe impl XpCom for nsIMessageListener {
    const IID: nsIID = nsID(0x2b44eb57, 0xa9c6, 0x4773,
        [0x9a, 0x1e, 0xfe, 0x08, 0x18, 0x73, 0x9a, 0x4c]);
}

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

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

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

    /* void receiveMessage (); */
    pub ReceiveMessage: unsafe extern "system" fn (this: *const nsIMessageListener) -> 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 nsIMessageListener {

    /// ```text
    /// /**
    ///    * This is for JS only.
    ///    * receiveMessage is called with one parameter, which has the following
    ///    * properties:
    ///    *   {
        ///    *     target:    %the target of the message. Either an element owning
        ///    *                 the message manager, or message manager itself if no
        ///    *                 element owns it%
        ///    *     name:      %message name%,
        ///    *     sync:      %true or false%.
        ///    *     data:      %structured clone of the sent message data%,
        ///    *     json:      %same as .data, deprecated%,
        ///    *     objects:   %named table of jsvals/objects, or null%
        ///    *     principal: %principal for the window app
        ///    *   }
    ///    *
    ///    * Each listener is invoked with its own copy of the message
    ///    * parameter.
    ///    *
    ///    * When the listener is called, 'this' value is the target of the message.
    ///    *
    ///    * If the message is synchronous, the possible return value is
    ///    * returned as JSON (will be changed to use structured clones).
    ///    * When there are multiple listeners to sync messages, each
    ///    * listener's return value is sent back as an array.  |undefined|
    ///    * return values show up as undefined values in the array.
    ///    */
    /// ```
    ///

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


}


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

    /// 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 nsIMessageListenerManager.
unsafe impl XpCom for nsIMessageListenerManager {
    const IID: nsIID = nsID(0xb949bfec, 0xbb7d, 0x47bc,
        [0xb3, 0x87, 0xac, 0x6a, 0x9b, 0x65, 0x50, 0x72]);
}

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

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

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

    /* void addMessageListener (in AString messageName, in nsIMessageListener listener, [optional] in boolean listenWhenClosed); */
    pub AddMessageListener: unsafe extern "system" fn (this: *const nsIMessageListenerManager, messageName: &::nsstring::nsAString, listener: *const nsIMessageListener, listenWhenClosed: bool) -> nsresult,

    /* void removeMessageListener (in AString messageName, in nsIMessageListener listener); */
    pub RemoveMessageListener: unsafe extern "system" fn (this: *const nsIMessageListenerManager, messageName: &::nsstring::nsAString, listener: *const nsIMessageListener) -> nsresult,

    /* void addWeakMessageListener (in AString messageName, in nsIMessageListener listener); */
    pub AddWeakMessageListener: unsafe extern "system" fn (this: *const nsIMessageListenerManager, messageName: &::nsstring::nsAString, listener: *const nsIMessageListener) -> nsresult,

    /* void removeWeakMessageListener (in AString messageName, in nsIMessageListener listener); */
    pub RemoveWeakMessageListener: unsafe extern "system" fn (this: *const nsIMessageListenerManager, messageName: &::nsstring::nsAString, listener: *const nsIMessageListener) -> nsresult,

    /* [notxpcom] boolean markForCC (); */
    pub MarkForCC: unsafe extern "system" fn (this: *const nsIMessageListenerManager) -> bool,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIMessageListenerManager {

    /// ```text
    /// /**
    ///    * Register |listener| to receive |messageName|.  All listener
    ///    * callbacks for a particular message are invoked when that message
    ///    * is received.
    ///    *
    ///    * The message manager holds a strong ref to |listener|.
    ///    *
    ///    * If the same listener registers twice for the same message, the
    ///    * second registration is ignored.
    ///    *
    ///    * Pass true for listenWhenClosed if you want to receive messages
    ///    * during the short period after a frame has been removed from the
    ///    * DOM and before its frame script has finished unloading. This
    ///    * parameter only has an effect for frame message managers in
    ///    * the main process. Default is false.
    ///    */
    /// ```
    ///

    /// `void addMessageListener (in AString messageName, in nsIMessageListener listener, [optional] in boolean listenWhenClosed);`
    #[inline]
    pub unsafe fn AddMessageListener(&self, messageName: &::nsstring::nsAString, listener: *const nsIMessageListener, listenWhenClosed: bool) -> nsresult {
        ((*self.vtable).AddMessageListener)(self, messageName, listener, listenWhenClosed)
    }


    /// ```text
    /// /**
    ///    * Undo an |addMessageListener| call -- that is, calling this causes us to no
    ///    * longer invoke |listener| when |messageName| is received.
    ///    *
    ///    * removeMessageListener does not remove a message listener added via
    ///    * addWeakMessageListener; use removeWeakMessageListener for that.
    ///    */
    /// ```
    ///

    /// `void removeMessageListener (in AString messageName, in nsIMessageListener listener);`
    #[inline]
    pub unsafe fn RemoveMessageListener(&self, messageName: &::nsstring::nsAString, listener: *const nsIMessageListener) -> nsresult {
        ((*self.vtable).RemoveMessageListener)(self, messageName, listener)
    }


    /// ```text
    /// /**
    ///    * This is just like addMessageListener, except the message manager holds a
    ///    * weak ref to |listener|.
    ///    *
    ///    * If you have two weak message listeners for the same message, they may be
    ///    * called in any order.
    ///    */
    /// ```
    ///

    /// `void addWeakMessageListener (in AString messageName, in nsIMessageListener listener);`
    #[inline]
    pub unsafe fn AddWeakMessageListener(&self, messageName: &::nsstring::nsAString, listener: *const nsIMessageListener) -> nsresult {
        ((*self.vtable).AddWeakMessageListener)(self, messageName, listener)
    }


    /// ```text
    /// /**
    ///    * This undoes an |addWeakMessageListener| call.
    ///    */
    /// ```
    ///

    /// `void removeWeakMessageListener (in AString messageName, in nsIMessageListener listener);`
    #[inline]
    pub unsafe fn RemoveWeakMessageListener(&self, messageName: &::nsstring::nsAString, listener: *const nsIMessageListener) -> nsresult {
        ((*self.vtable).RemoveWeakMessageListener)(self, messageName, listener)
    }



    /// `[notxpcom] boolean markForCC ();`
    #[inline]
    pub unsafe fn MarkForCC(&self, ) -> bool {
        ((*self.vtable).MarkForCC)(self, )
    }


}


/// `interface nsIMessageSender : nsIMessageListenerManager`
///

/// ```text
/// /**
///  * Message "senders" have a single "other side" to which messages are
///  * sent.  For example, a child-process message manager will send
///  * messages that are only delivered to its one parent-process message
///  * manager.
///  */
/// ```
///

// 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 nsIMessageSender {
    vtable: *const nsIMessageSenderVTable,

    /// 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 nsIMessageSender.
unsafe impl XpCom for nsIMessageSender {
    const IID: nsIID = nsID(0xbb5d79e4, 0xe73c, 0x45e7,
        [0x96, 0x51, 0x4d, 0x71, 0x8f, 0x4b, 0x99, 0x4c]);
}

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

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

impl nsIMessageSender {
    /// Cast this `nsIMessageSender` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIMessageSenderCoerce>(&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 nsIMessageSender {
    type Target = nsIMessageListenerManager;
    #[inline]
    fn deref(&self) -> &nsIMessageListenerManager {
        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: nsIMessageListenerManagerCoerce> nsIMessageSenderCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIMessageSender) -> &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 nsIMessageSender
// 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 nsIMessageSenderVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIMessageListenerManagerVTable,

    /* [implicit_jscontext,optional_argc] void sendAsyncMessage ([optional] in AString messageName, [optional] in jsval obj, [optional] in jsval objects, [optional] in nsIPrincipal principal, [optional] in jsval transfers); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub SendAsyncMessage: *const ::libc::c_void,

    /* readonly attribute nsIMessageSender processMessageManager; */
    pub GetProcessMessageManager: unsafe extern "system" fn (this: *const nsIMessageSender, aProcessMessageManager: *mut *const nsIMessageSender) -> nsresult,

    /* readonly attribute AString remoteType; */
    pub GetRemoteType: unsafe extern "system" fn (this: *const nsIMessageSender, aRemoteType: &mut ::nsstring::nsAString) -> 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 nsIMessageSender {

    /// ```text
    /// /**
    ///    * Send |messageName| and |obj| to the "other side" of this message
    ///    * manager.  This invokes listeners who registered for
    ///    * |messageName|.
    ///    *
    ///    * See nsIMessageListener::receiveMessage() for the format of the
    ///    * data delivered to listeners.
    ///    * @throws NS_ERROR_NOT_INITIALIZED if the sender is not initialized.  For
    ///    *         example, we will throw NS_ERROR_NOT_INITIALIZED if we try to send
    ///    *         a message to a cross-process frame but the other process has not
    ///    *         yet been set up.
    ///    * @throws NS_ERROR_FAILURE when the message receiver cannot be found.  For
    ///    *         example, we will throw NS_ERROR_FAILURE if we try to send a message
    ///    *         to a cross-process frame whose process has crashed.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext,optional_argc] void sendAsyncMessage ([optional] in AString messageName, [optional] in jsval obj, [optional] in jsval objects, [optional] in nsIPrincipal principal, [optional] in jsval transfers);`
    const _SendAsyncMessage: () = ();

    /// ```text
    /// /**
    ///   * For remote browsers there is always a corresponding process message
    ///   * manager. The intention of this attribute is to link leaf level frame
    ///   * message managers on the parent side with the corresponding process
    ///   * message managers (if there is one). For any other cases this property
    ///   * is null.
    ///   */
    /// ```
    ///

    /// `readonly attribute nsIMessageSender processMessageManager;`
    #[inline]
    pub unsafe fn GetProcessMessageManager(&self, aProcessMessageManager: *mut *const nsIMessageSender) -> nsresult {
        ((*self.vtable).GetProcessMessageManager)(self, aProcessMessageManager)
    }


    /// ```text
    /// /**
    ///   * For remote browsers, this contains the remoteType of the content child.
    ///   * Otherwise, it is empty.
    ///   */
    /// ```
    ///

    /// `readonly attribute AString remoteType;`
    #[inline]
    pub unsafe fn GetRemoteType(&self, aRemoteType: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetRemoteType)(self, aRemoteType)
    }


}


/// `interface nsIMessageBroadcaster : nsIMessageListenerManager`
///

/// ```text
/// /**
///  * Message "broadcasters" don't have a single "other side" that they
///  * send messages to, but rather a set of subordinate message managers.
///  * For example, broadcasting a message through a window message
///  * manager will broadcast the message to all frame message managers
///  * within its window.
///  */
/// ```
///

// 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 nsIMessageBroadcaster {
    vtable: *const nsIMessageBroadcasterVTable,

    /// 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 nsIMessageBroadcaster.
unsafe impl XpCom for nsIMessageBroadcaster {
    const IID: nsIID = nsID(0x4d7d62ad, 0x4725, 0x4f39,
        [0x86, 0xcf, 0x8f, 0xb2, 0x2b, 0xf9, 0xc1, 0xd8]);
}

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

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

impl nsIMessageBroadcaster {
    /// Cast this `nsIMessageBroadcaster` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIMessageBroadcasterCoerce>(&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 nsIMessageBroadcaster {
    type Target = nsIMessageListenerManager;
    #[inline]
    fn deref(&self) -> &nsIMessageListenerManager {
        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: nsIMessageListenerManagerCoerce> nsIMessageBroadcasterCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIMessageBroadcaster) -> &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 nsIMessageBroadcaster
// 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 nsIMessageBroadcasterVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIMessageListenerManagerVTable,

    /* [implicit_jscontext,optional_argc] void broadcastAsyncMessage ([optional] in AString messageName, [optional] in jsval obj, [optional] in jsval objects); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub BroadcastAsyncMessage: *const ::libc::c_void,

    /* readonly attribute unsigned long childCount; */
    pub GetChildCount: unsafe extern "system" fn (this: *const nsIMessageBroadcaster, aChildCount: *mut libc::uint32_t) -> nsresult,

    /* nsIMessageListenerManager getChildAt (in unsigned long aIndex); */
    pub GetChildAt: unsafe extern "system" fn (this: *const nsIMessageBroadcaster, aIndex: libc::uint32_t, _retval: *mut *const nsIMessageListenerManager) -> nsresult,

    /* void releaseCachedProcesses (); */
    pub ReleaseCachedProcesses: unsafe extern "system" fn (this: *const nsIMessageBroadcaster) -> 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 nsIMessageBroadcaster {

    /// ```text
    /// /**
    ///    * Like |sendAsyncMessage()|, but also broadcasts this message to
    ///    * all "child" message managers of this message manager.  See long
    ///    * comment above for details.
    ///    *
    ///    * WARNING: broadcasting messages can be very expensive and leak
    ///    * sensitive data.  Use with extreme caution.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext,optional_argc] void broadcastAsyncMessage ([optional] in AString messageName, [optional] in jsval obj, [optional] in jsval objects);`
    const _BroadcastAsyncMessage: () = ();

    /// ```text
    /// /**
    ///    * Number of subordinate message managers.
    ///    */
    /// ```
    ///

    /// `readonly attribute unsigned long childCount;`
    #[inline]
    pub unsafe fn GetChildCount(&self, aChildCount: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetChildCount)(self, aChildCount)
    }


    /// ```text
    /// /**
    ///    * Return a single subordinate message manager.
    ///    */
    /// ```
    ///

    /// `nsIMessageListenerManager getChildAt (in unsigned long aIndex);`
    #[inline]
    pub unsafe fn GetChildAt(&self, aIndex: libc::uint32_t, _retval: *mut *const nsIMessageListenerManager) -> nsresult {
        ((*self.vtable).GetChildAt)(self, aIndex, _retval)
    }


    /// ```text
    /// /**
    ///    * Some processes are kept alive after their last tab/window are closed for testing
    ///    * (see dom.ipc.keepProcessesAlive). This function releases those.
    ///    */
    /// ```
    ///

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


}


/// `interface nsISyncMessageSender : nsIMessageSender`
///


// 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 nsISyncMessageSender {
    vtable: *const nsISyncMessageSenderVTable,

    /// 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 nsISyncMessageSender.
unsafe impl XpCom for nsISyncMessageSender {
    const IID: nsIID = nsID(0x0e602c9e, 0x1977, 0x422a,
        [0xa8, 0xe4, 0xfe, 0x0d, 0x4a, 0x4f, 0x78, 0xd0]);
}

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

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

impl nsISyncMessageSender {
    /// Cast this `nsISyncMessageSender` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISyncMessageSenderCoerce>(&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 nsISyncMessageSender {
    type Target = nsIMessageSender;
    #[inline]
    fn deref(&self) -> &nsIMessageSender {
        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: nsIMessageSenderCoerce> nsISyncMessageSenderCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISyncMessageSender) -> &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 nsISyncMessageSender
// 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 nsISyncMessageSenderVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIMessageSenderVTable,

    /* [implicit_jscontext,optional_argc] jsval sendSyncMessage ([optional] in AString messageName, [optional] in jsval obj, [optional] in jsval objects, [optional] in nsIPrincipal principal); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub SendSyncMessage: *const ::libc::c_void,

    /* [implicit_jscontext,optional_argc] jsval sendRpcMessage ([optional] in AString messageName, [optional] in jsval obj, [optional] in jsval objects, [optional] in nsIPrincipal principal); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub SendRpcMessage: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsISyncMessageSender {

    /// ```text
    /// /**
    ///    * Like |sendAsyncMessage()|, except blocks the sender until all
    ///    * listeners of the message have been invoked.  Returns an array
    ///    * containing return values from each listener invoked.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext,optional_argc] jsval sendSyncMessage ([optional] in AString messageName, [optional] in jsval obj, [optional] in jsval objects, [optional] in nsIPrincipal principal);`
    const _SendSyncMessage: () = ();

    /// ```text
    /// /**
    ///    * Like |sendSyncMessage()|, except re-entrant. New RPC messages may be
    ///    * issued even if, earlier on the call stack, we are waiting for a reply
    ///    * to an earlier sendRpcMessage() call.
    ///    *
    ///    * Both sendSyncMessage and sendRpcMessage will block until a reply is
    ///    * received, but they may be temporarily interrupted to process an urgent
    ///    * incoming message (such as a CPOW request).
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext,optional_argc] jsval sendRpcMessage ([optional] in AString messageName, [optional] in jsval obj, [optional] in jsval objects, [optional] in nsIPrincipal principal);`
    const _SendRpcMessage: () = ();

}


/// `interface nsIMessageManagerGlobal : nsISyncMessageSender`
///


// 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 nsIMessageManagerGlobal {
    vtable: *const nsIMessageManagerGlobalVTable,

    /// 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 nsIMessageManagerGlobal.
unsafe impl XpCom for nsIMessageManagerGlobal {
    const IID: nsIID = nsID(0x13f3555f, 0x769e, 0x44ea,
        [0xb6, 0x07, 0x52, 0x39, 0x23, 0x0c, 0x31, 0x62]);
}

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

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

impl nsIMessageManagerGlobal {
    /// Cast this `nsIMessageManagerGlobal` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIMessageManagerGlobalCoerce>(&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 nsIMessageManagerGlobal {
    type Target = nsISyncMessageSender;
    #[inline]
    fn deref(&self) -> &nsISyncMessageSender {
        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: nsISyncMessageSenderCoerce> nsIMessageManagerGlobalCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIMessageManagerGlobal) -> &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 nsIMessageManagerGlobal
// 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 nsIMessageManagerGlobalVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISyncMessageSenderVTable,

    /* void dump (in DOMString aStr); */
    pub Dump: unsafe extern "system" fn (this: *const nsIMessageManagerGlobal, aStr: &::nsstring::nsAString) -> nsresult,

    /* void privateNoteIntentionalCrash (); */
    pub PrivateNoteIntentionalCrash: unsafe extern "system" fn (this: *const nsIMessageManagerGlobal) -> nsresult,

    /* DOMString atob (in DOMString aAsciiString); */
    pub Atob: unsafe extern "system" fn (this: *const nsIMessageManagerGlobal, aAsciiString: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* DOMString btoa (in DOMString aBase64Data); */
    pub Btoa: unsafe extern "system" fn (this: *const nsIMessageManagerGlobal, aBase64Data: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> 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 nsIMessageManagerGlobal {

    /// ```text
    /// /**
    ///    * Print a string to stdout.
    ///    */
    /// ```
    ///

    /// `void dump (in DOMString aStr);`
    #[inline]
    pub unsafe fn Dump(&self, aStr: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).Dump)(self, aStr)
    }


    /// ```text
    /// /**
    ///    * If leak detection is enabled, print a note to the leak log that this
    ///    * process will intentionally crash.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Ascii base64 data to binary data and vice versa
    ///    */
    /// ```
    ///

    /// `DOMString atob (in DOMString aAsciiString);`
    #[inline]
    pub unsafe fn Atob(&self, aAsciiString: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).Atob)(self, aAsciiString, _retval)
    }



    /// `DOMString btoa (in DOMString aBase64Data);`
    #[inline]
    pub unsafe fn Btoa(&self, aBase64Data: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).Btoa)(self, aBase64Data, _retval)
    }


}


/// `interface nsIContentFrameMessageManager : nsIMessageManagerGlobal`
///


// 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 nsIContentFrameMessageManager {
    vtable: *const nsIContentFrameMessageManagerVTable,

    /// 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 nsIContentFrameMessageManager.
unsafe impl XpCom for nsIContentFrameMessageManager {
    const IID: nsIID = nsID(0x694e367c, 0xaa25, 0x4446,
        [0x84, 0x99, 0x2c, 0x52, 0x7c, 0x4b, 0xd8, 0x38]);
}

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

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

impl nsIContentFrameMessageManager {
    /// Cast this `nsIContentFrameMessageManager` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIContentFrameMessageManagerCoerce>(&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 nsIContentFrameMessageManager {
    type Target = nsIMessageManagerGlobal;
    #[inline]
    fn deref(&self) -> &nsIMessageManagerGlobal {
        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: nsIMessageManagerGlobalCoerce> nsIContentFrameMessageManagerCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIContentFrameMessageManager) -> &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 nsIContentFrameMessageManager
// 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 nsIContentFrameMessageManagerVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIMessageManagerGlobalVTable,

    /* readonly attribute mozIDOMWindowProxy content; */
    pub GetContent: unsafe extern "system" fn (this: *const nsIContentFrameMessageManager, aContent: *mut *const mozIDOMWindowProxy) -> nsresult,

    /* readonly attribute nsIDocShell docShell; */
    pub GetDocShell: unsafe extern "system" fn (this: *const nsIContentFrameMessageManager, aDocShell: *mut *const nsIDocShell) -> nsresult,

    /* readonly attribute nsIEventTarget tabEventTarget; */
    pub GetTabEventTarget: unsafe extern "system" fn (this: *const nsIContentFrameMessageManager, aTabEventTarget: *mut *const nsIEventTarget) -> 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 nsIContentFrameMessageManager {

    /// ```text
    /// /**
    ///    * The current top level window in the frame or null.
    ///    */
    /// ```
    ///

    /// `readonly attribute mozIDOMWindowProxy content;`
    #[inline]
    pub unsafe fn GetContent(&self, aContent: *mut *const mozIDOMWindowProxy) -> nsresult {
        ((*self.vtable).GetContent)(self, aContent)
    }


    /// ```text
    /// /**
    ///    * The top level docshell or null.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDocShell docShell;`
    #[inline]
    pub unsafe fn GetDocShell(&self, aDocShell: *mut *const nsIDocShell) -> nsresult {
        ((*self.vtable).GetDocShell)(self, aDocShell)
    }


    /// ```text
    /// /**
    ///    * Returns the SchedulerEventTarget corresponding to the TabGroup
    ///    * for this frame.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIEventTarget tabEventTarget;`
    #[inline]
    pub unsafe fn GetTabEventTarget(&self, aTabEventTarget: *mut *const nsIEventTarget) -> nsresult {
        ((*self.vtable).GetTabEventTarget)(self, aTabEventTarget)
    }


}


/// `interface nsIInProcessContentFrameMessageManager : nsIContentFrameMessageManager`
///


// 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 nsIInProcessContentFrameMessageManager {
    vtable: *const nsIInProcessContentFrameMessageManagerVTable,

    /// 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 nsIInProcessContentFrameMessageManager.
unsafe impl XpCom for nsIInProcessContentFrameMessageManager {
    const IID: nsIID = nsID(0xb39a3324, 0xb574, 0x4f85,
        [0x8c, 0xdb, 0x27, 0x4d, 0x04, 0xf8, 0x07, 0xef]);
}

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

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

impl nsIInProcessContentFrameMessageManager {
    /// Cast this `nsIInProcessContentFrameMessageManager` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIInProcessContentFrameMessageManagerCoerce>(&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 nsIInProcessContentFrameMessageManager {
    type Target = nsIContentFrameMessageManager;
    #[inline]
    fn deref(&self) -> &nsIContentFrameMessageManager {
        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: nsIContentFrameMessageManagerCoerce> nsIInProcessContentFrameMessageManagerCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIInProcessContentFrameMessageManager) -> &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 nsIInProcessContentFrameMessageManager
// 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 nsIInProcessContentFrameMessageManagerVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIContentFrameMessageManagerVTable,

    /* [notxpcom] nsIContent getOwnerContent (); */
    pub GetOwnerContent: unsafe extern "system" fn (this: *const nsIInProcessContentFrameMessageManager) -> *const nsIContent,

    /* [notxpcom] void cacheFrameLoader (in nsIFrameLoader aFrameLoader); */
    pub CacheFrameLoader: unsafe extern "system" fn (this: *const nsIInProcessContentFrameMessageManager, aFrameLoader: *const nsIFrameLoader) -> libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIInProcessContentFrameMessageManager {


    /// `[notxpcom] nsIContent getOwnerContent ();`
    #[inline]
    pub unsafe fn GetOwnerContent(&self, ) -> *const nsIContent {
        ((*self.vtable).GetOwnerContent)(self, )
    }



    /// `[notxpcom] void cacheFrameLoader (in nsIFrameLoader aFrameLoader);`
    #[inline]
    pub unsafe fn CacheFrameLoader(&self, aFrameLoader: *const nsIFrameLoader) -> libc::c_void {
        ((*self.vtable).CacheFrameLoader)(self, aFrameLoader)
    }


}


/// `interface nsIContentProcessMessageManager : nsIMessageManagerGlobal`
///


// 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 nsIContentProcessMessageManager {
    vtable: *const nsIContentProcessMessageManagerVTable,

    /// 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 nsIContentProcessMessageManager.
unsafe impl XpCom for nsIContentProcessMessageManager {
    const IID: nsIID = nsID(0x6d12e467, 0x2446, 0x46db,
        [0x99, 0x65, 0xe4, 0xe9, 0x3c, 0xb8, 0x7c, 0xa5]);
}

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

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

impl nsIContentProcessMessageManager {
    /// Cast this `nsIContentProcessMessageManager` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIContentProcessMessageManagerCoerce>(&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 nsIContentProcessMessageManager {
    type Target = nsIMessageManagerGlobal;
    #[inline]
    fn deref(&self) -> &nsIMessageManagerGlobal {
        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: nsIMessageManagerGlobalCoerce> nsIContentProcessMessageManagerCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIContentProcessMessageManager) -> &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 nsIContentProcessMessageManager
// 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 nsIContentProcessMessageManagerVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIMessageManagerGlobalVTable,

    /* [implicit_jscontext] readonly attribute jsval initialProcessData; */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetInitialProcessData: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIContentProcessMessageManager {

    /// ```text
    /// /**
    ///    * Read out a copy of the object that was initialized in the parent
    ///    * process via nsIProcessScriptLoader.initialProcessData.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext] readonly attribute jsval initialProcessData;`
    const _GetInitialProcessData: () = ();

}


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

    /// 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 nsIFrameScriptLoader.
unsafe impl XpCom for nsIFrameScriptLoader {
    const IID: nsIID = nsID(0xbf61446b, 0xba24, 0x4b1d,
        [0x88, 0xc7, 0x4f, 0x94, 0x72, 0x4b, 0x9c, 0xe1]);
}

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

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

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

    /* void loadFrameScript (in AString aURL, in boolean aAllowDelayedLoad, [optional] in boolean aRunInGlobalScope); */
    pub LoadFrameScript: unsafe extern "system" fn (this: *const nsIFrameScriptLoader, aURL: &::nsstring::nsAString, aAllowDelayedLoad: bool, aRunInGlobalScope: bool) -> nsresult,

    /* void removeDelayedFrameScript (in AString aURL); */
    pub RemoveDelayedFrameScript: unsafe extern "system" fn (this: *const nsIFrameScriptLoader, aURL: &::nsstring::nsAString) -> nsresult,

    /* [implicit_jscontext] jsval getDelayedFrameScripts (); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub GetDelayedFrameScripts: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIFrameScriptLoader {

    /// ```text
    /// /**
    ///    * Load a script in the (remote) frame. aURL must be the absolute URL.
    ///    * data: URLs are also supported. For example data:,dump("foo\n");
    ///    * If aAllowDelayedLoad is true, script will be loaded when the
    ///    * remote frame becomes available. Otherwise the script will be loaded
    ///    * only if the frame is already available.
    ///    */
    /// ```
    ///

    /// `void loadFrameScript (in AString aURL, in boolean aAllowDelayedLoad, [optional] in boolean aRunInGlobalScope);`
    #[inline]
    pub unsafe fn LoadFrameScript(&self, aURL: &::nsstring::nsAString, aAllowDelayedLoad: bool, aRunInGlobalScope: bool) -> nsresult {
        ((*self.vtable).LoadFrameScript)(self, aURL, aAllowDelayedLoad, aRunInGlobalScope)
    }


    /// ```text
    /// /**
    ///    * Removes aURL from the list of scripts which support delayed load.
    ///    */
    /// ```
    ///

    /// `void removeDelayedFrameScript (in AString aURL);`
    #[inline]
    pub unsafe fn RemoveDelayedFrameScript(&self, aURL: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).RemoveDelayedFrameScript)(self, aURL)
    }


    /// ```text
    /// /**
    ///    * Returns all delayed scripts that will be loaded once a (remote)
    ///    * frame becomes available. The return value is a list of pairs
    ///    * [<URL>, <WasLoadedInGlobalScope>].
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext] jsval getDelayedFrameScripts ();`
    const _GetDelayedFrameScripts: () = ();

}


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

    /// 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 nsIProcessScriptLoader.
unsafe impl XpCom for nsIProcessScriptLoader {
    const IID: nsIID = nsID(0x7e1e1a20, 0xb24f, 0x11e4,
        [0xab, 0x27, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66]);
}

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

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

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

    /* void loadProcessScript (in AString aURL, in boolean aAllowDelayedLoad); */
    pub LoadProcessScript: unsafe extern "system" fn (this: *const nsIProcessScriptLoader, aURL: &::nsstring::nsAString, aAllowDelayedLoad: bool) -> nsresult,

    /* void removeDelayedProcessScript (in AString aURL); */
    pub RemoveDelayedProcessScript: unsafe extern "system" fn (this: *const nsIProcessScriptLoader, aURL: &::nsstring::nsAString) -> nsresult,

    /* [implicit_jscontext] jsval getDelayedProcessScripts (); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub GetDelayedProcessScripts: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIProcessScriptLoader {

    /// ```text
    /// /**
    ///    * Load a script in the (possibly remote) process. aURL must be the absolute URL.
    ///    * data: URLs are also supported. For example data:,dump("foo\n");
    ///    * If aAllowDelayedLoad is true, script will be loaded when the
    ///    * remote frame becomes available. Otherwise the script will be loaded
    ///    * only if the frame is already available.
    ///    */
    /// ```
    ///

    /// `void loadProcessScript (in AString aURL, in boolean aAllowDelayedLoad);`
    #[inline]
    pub unsafe fn LoadProcessScript(&self, aURL: &::nsstring::nsAString, aAllowDelayedLoad: bool) -> nsresult {
        ((*self.vtable).LoadProcessScript)(self, aURL, aAllowDelayedLoad)
    }


    /// ```text
    /// /**
    ///    * Removes aURL from the list of scripts which support delayed load.
    ///    */
    /// ```
    ///

    /// `void removeDelayedProcessScript (in AString aURL);`
    #[inline]
    pub unsafe fn RemoveDelayedProcessScript(&self, aURL: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).RemoveDelayedProcessScript)(self, aURL)
    }


    /// ```text
    /// /**
    ///    * Returns all delayed scripts that will be loaded once a (remote)
    ///    * frame becomes available. The return value is a list of URLs.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext] jsval getDelayedProcessScripts ();`
    const _GetDelayedProcessScripts: () = ();

}


/// `interface nsIGlobalProcessScriptLoader : nsIProcessScriptLoader`
///


// 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 nsIGlobalProcessScriptLoader {
    vtable: *const nsIGlobalProcessScriptLoaderVTable,

    /// 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 nsIGlobalProcessScriptLoader.
unsafe impl XpCom for nsIGlobalProcessScriptLoader {
    const IID: nsIID = nsID(0x5b390753, 0xabb3, 0x49b0,
        [0xae, 0x3b, 0xb8, 0x03, 0xda, 0xb5, 0x81, 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 nsIGlobalProcessScriptLoader {
    #[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 nsIGlobalProcessScriptLoader.
// 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 nsIGlobalProcessScriptLoaderCoerce {
    /// Cheaply cast a value of this type from a `nsIGlobalProcessScriptLoader`.
    fn coerce_from(v: &nsIGlobalProcessScriptLoader) -> &Self;
}

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

impl nsIGlobalProcessScriptLoader {
    /// Cast this `nsIGlobalProcessScriptLoader` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIGlobalProcessScriptLoaderCoerce>(&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 nsIGlobalProcessScriptLoader {
    type Target = nsIProcessScriptLoader;
    #[inline]
    fn deref(&self) -> &nsIProcessScriptLoader {
        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: nsIProcessScriptLoaderCoerce> nsIGlobalProcessScriptLoaderCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIGlobalProcessScriptLoader) -> &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 nsIGlobalProcessScriptLoader
// 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 nsIGlobalProcessScriptLoaderVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIProcessScriptLoaderVTable,

    /* [implicit_jscontext] readonly attribute jsval initialProcessData; */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetInitialProcessData: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIGlobalProcessScriptLoader {

    /// ```text
    /// /**
    ///    * Allows the parent process to set the initial process data for
    ///    * new, not-yet-created child processes. This attribute should only
    ///    * be used by the global parent process message manager. When a new
    ///    * process is created, it gets a copy of this data (via structured
        ///    * cloning). It can access the data via the initialProcessData
    ///    * attribute of its childprocessmessagemanager.
    ///    *
    ///    * This value will always be a JS object. Different users are
    ///    * expected to set properties on this object. The property name
    ///    * should be unique enough that other Gecko consumers won't
    ///    * accidentally choose it.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext] readonly attribute jsval initialProcessData;`
    const _GetInitialProcessData: () = ();

}