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


/// `interface nsIXMLHttpRequestEventTarget : nsIDOMEventTarget`
///


// 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 nsIXMLHttpRequestEventTarget {
    vtable: *const nsIXMLHttpRequestEventTargetVTable,

    /// 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 nsIXMLHttpRequestEventTarget.
unsafe impl XpCom for nsIXMLHttpRequestEventTarget {
    const IID: nsIID = nsID(0x88e7d2a0, 0x2e5b, 0x4f65,
        [0x96, 0x24, 0xa6, 0x1e, 0x60, 0x7a, 0x99, 0x48]);
}

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

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

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

}


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


}


/// `interface nsIXMLHttpRequestUpload : nsIXMLHttpRequestEventTarget`
///


// 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 nsIXMLHttpRequestUpload {
    vtable: *const nsIXMLHttpRequestUploadVTable,

    /// 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 nsIXMLHttpRequestUpload.
unsafe impl XpCom for nsIXMLHttpRequestUpload {
    const IID: nsIID = nsID(0xd74c4dc4, 0xbc8c, 0x4f5d,
        [0xb7, 0xf1, 0x12, 0x1a, 0x48, 0x75, 0x0a, 0xbe]);
}

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

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

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

}


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


}


/// `interface nsIXMLHttpRequest : nsISupports`
///

/// ```text
/// /**
///  * Mozilla's XMLHttpRequest is modelled after Microsoft's IXMLHttpRequest
///  * object. The goal has been to make Mozilla's version match Microsoft's
///  * version as closely as possible, but there are bound to be some differences.
///  *
///  * In general, Microsoft's documentation for IXMLHttpRequest can be used.
///  * Mozilla's interface definitions provide some additional documentation. The
///  * web page to look at is http://www.mozilla.org/xmlextras/
///  *
///  * Mozilla's XMLHttpRequest object can be created in JavaScript like this:
///  *   new XMLHttpRequest()
///  * compare to Internet Explorer:
///  *   new ActiveXObject("Msxml2.XMLHTTP")
///  *
///  * From native code, the way to set up onload and onerror handlers is a bit
///  * different. Here is a comment from Johnny Stenback <jst@netscape.com>:
///  *
///  *   The mozilla implementation of nsIXMLHttpRequest implements the interface
///  *   nsIDOMEventTarget and that's how you're supported to add event listeners.
///  *   Try something like this:
///  *
///  *   nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(myxmlhttpreq));
///  *
///  *   target->AddEventListener(NS_LITERAL_STRING("load"), mylistener,
    ///  *                            PR_FALSE)
///  *
///  *   where mylistener is your event listener object that implements the
///  *   interface nsIDOMEventListener.
///  *
///  * Conclusion: Do not use event listeners on XMLHttpRequest from C++, unless
///  * you're aware of all the security implications.  And then think twice about
///  * it.
///  */
/// ```
///

// 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 nsIXMLHttpRequest {
    vtable: *const nsIXMLHttpRequestVTable,

    /// 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 nsIXMLHttpRequest.
unsafe impl XpCom for nsIXMLHttpRequest {
    const IID: nsIID = nsID(0x6f54214c, 0x7175, 0x498d,
        [0x9d, 0x2d, 0x04, 0x29, 0xe3, 0x8c, 0x28, 0x69]);
}

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

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

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

    /* readonly attribute nsIChannel channel; */
    pub GetChannel: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aChannel: *mut *const nsIChannel) -> nsresult,

    /* readonly attribute nsIDOMDocument responseXML; */
    pub GetResponseXML: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aResponseXML: *mut *const nsIDOMDocument) -> nsresult,

    /* readonly attribute AString responseText; */
    pub GetResponseText: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aResponseText: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString responseType; */
    pub GetResponseType: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aResponseType: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString responseType; */
    pub SetResponseType: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aResponseType: &::nsstring::nsAString) -> nsresult,

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

    /* readonly attribute unsigned long status; */
    pub GetStatus: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aStatus: *mut libc::uint32_t) -> nsresult,

    /* readonly attribute ACString statusText; */
    pub GetStatusText: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aStatusText: &mut ::nsstring::nsACString) -> nsresult,

    /* [binaryname(SlowAbort)] void abort (); */
    pub SlowAbort: unsafe extern "system" fn (this: *const nsIXMLHttpRequest) -> nsresult,

    /* ACString getAllResponseHeaders (); */
    pub GetAllResponseHeaders: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, _retval: &mut ::nsstring::nsACString) -> nsresult,

    /* ACString getResponseHeader (in ACString header); */
    pub GetResponseHeader: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, header: &::nsstring::nsACString, _retval: &mut ::nsstring::nsACString) -> nsresult,

    /* [optional_argc] void open (in ACString method, in AUTF8String url, [optional] in boolean async, [optional, Undefined (Empty)] in DOMString user, [optional, Undefined (Empty)] in DOMString password); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub Open: *const ::libc::c_void,

    /* void send ([optional] in nsIVariant body); */
    pub Send: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, body: *const nsIVariant) -> nsresult,

    /* void setRequestHeader (in ACString header, in ACString value); */
    pub SetRequestHeader: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, header: &::nsstring::nsACString, value: &::nsstring::nsACString) -> nsresult,

    /* attribute unsigned long timeout; */
    pub GetTimeout: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aTimeout: *mut libc::uint32_t) -> nsresult,

    /* attribute unsigned long timeout; */
    pub SetTimeout: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aTimeout: libc::uint32_t) -> nsresult,

    /* readonly attribute unsigned short readyState; */
    pub GetReadyState: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aReadyState: *mut libc::uint16_t) -> nsresult,

    /* [binaryname(SlowOverrideMimeType)] void overrideMimeType (in DOMString mimetype); */
    pub SlowOverrideMimeType: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, mimetype: &::nsstring::nsAString) -> nsresult,

    /* attribute boolean mozBackgroundRequest; */
    pub GetMozBackgroundRequest: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aMozBackgroundRequest: *mut bool) -> nsresult,

    /* attribute boolean mozBackgroundRequest; */
    pub SetMozBackgroundRequest: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aMozBackgroundRequest: bool) -> nsresult,

    /* attribute boolean withCredentials; */
    pub GetWithCredentials: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aWithCredentials: *mut bool) -> nsresult,

    /* attribute boolean withCredentials; */
    pub SetWithCredentials: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aWithCredentials: bool) -> nsresult,

    /* [noscript] void init (in nsIPrincipal principal, in nsIGlobalObject globalObject, in nsIURI baseURI, [optional] in nsILoadGroup loadGroup); */
    pub Init: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, principal: *const nsIPrincipal, globalObject: *const nsIGlobalObject, baseURI: *const nsIURI, loadGroup: *const nsILoadGroup) -> nsresult,

    /* readonly attribute nsIXMLHttpRequestUpload upload; */
    pub GetUpload: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aUpload: *mut *const nsIXMLHttpRequestUpload) -> nsresult,

    /* readonly attribute boolean mozAnon; */
    pub GetMozAnon: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aMozAnon: *mut bool) -> nsresult,

    /* readonly attribute boolean mozSystem; */
    pub GetMozSystem: unsafe extern "system" fn (this: *const nsIXMLHttpRequest, aMozSystem: *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 nsIXMLHttpRequest {
    /// ```text
    /// /**
    ///    * The state of the request.
    ///    *
    ///    * Possible values:
    ///    *   0 UNSENT   open() has not been called yet.
    ///    *   1 OPENED   send() has not been called yet.
    ///    *   2 HEADERS_RECEIVED
    ///    *              send() has been called, headers and status are available.
    ///    *   3 LOADING  Downloading, responseText holds the partial data.
    ///    *   4 DONE     Finished with all operations.
    ///    */
    /// ```
    ///

    pub const UNSENT: i64 = 0;


    pub const OPENED: i64 = 1;


    pub const HEADERS_RECEIVED: i64 = 2;


    pub const LOADING: i64 = 3;


    pub const DONE: i64 = 4;

    /// ```text
    /// /**
    ///    * The request uses a channel in order to perform the
    ///    * request.  This attribute represents the channel used
    ///    * for the request.  NULL if the channel has not yet been
    ///    * created.
    ///    *
    ///    * Mozilla only. Requires elevated privileges to access.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIChannel channel;`
    #[inline]
    pub unsafe fn GetChannel(&self, aChannel: *mut *const nsIChannel) -> nsresult {
        ((*self.vtable).GetChannel)(self, aChannel)
    }


    /// ```text
    /// /**
    ///    * The response to the request is parsed as if it were a
    ///    * text/xml stream. This attributes represents the response as
    ///    * a DOM Document object. NULL if the request is unsuccessful or
    ///    * has not yet been sent.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDOMDocument responseXML;`
    #[inline]
    pub unsafe fn GetResponseXML(&self, aResponseXML: *mut *const nsIDOMDocument) -> nsresult {
        ((*self.vtable).GetResponseXML)(self, aResponseXML)
    }


    /// ```text
    /// /**
    ///    * The response to the request as text.
    ///    * NULL if the request is unsuccessful or
    ///    * has not yet been sent.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Determine a response format which response attribute returns.
    ///    * empty string (initial value) or "text": as text.
    ///    * "arraybuffer": as a typed array ArrayBuffer.
    ///    * "blob": as a File API Blob.
    ///    * "document": as a DOM Document object.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Determine a response format which response attribute returns.
    ///    * empty string (initial value) or "text": as text.
    ///    * "arraybuffer": as a typed array ArrayBuffer.
    ///    * "blob": as a File API Blob.
    ///    * "document": as a DOM Document object.
    ///    */
    /// ```
    ///

    /// `attribute AString responseType;`
    #[inline]
    pub unsafe fn SetResponseType(&self, aResponseType: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetResponseType)(self, aResponseType)
    }


    /// ```text
    /// /**
    ///    * The response to the request as a specified format by responseType.
    ///    * NULL if the request is unsuccessful or
    ///    * has not yet been sent.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext] readonly attribute jsval response;`
    const _GetResponse: () = ();

    /// ```text
    /// /**
    ///    * The status of the response to the request for HTTP requests.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * The string representing the status of the response for
    ///    * HTTP requests.
    ///    */
    /// ```
    ///

    /// `readonly attribute ACString statusText;`
    #[inline]
    pub unsafe fn GetStatusText(&self, aStatusText: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetStatusText)(self, aStatusText)
    }


    /// ```text
    /// /**
    ///    * If the request has been sent already, this method will
    ///    * abort the request.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Returns all of the response headers as a string for HTTP
    ///    * requests.
    ///    *
    ///    * @returns A string containing all of the response headers.
    ///    *          The empty string if the response has not yet been received.
    ///    */
    /// ```
    ///

    /// `ACString getAllResponseHeaders ();`
    #[inline]
    pub unsafe fn GetAllResponseHeaders(&self, _retval: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetAllResponseHeaders)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Returns the text of the header with the specified name for
    ///    * HTTP requests.
    ///    *
    ///    * @param header The name of the header to retrieve
    ///    * @returns A string containing the text of the header specified.
    ///    *          NULL if the response has not yet been received or the
    ///    *          header does not exist in the response.
    ///    */
    /// ```
    ///

    /// `ACString getResponseHeader (in ACString header);`
    #[inline]
    pub unsafe fn GetResponseHeader(&self, header: &::nsstring::nsACString, _retval: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetResponseHeader)(self, header, _retval)
    }


    /// ```text
    /// /**
    ///    * Meant to be a script-only method for initializing a request.
    ///    *
    ///    * If there is an "active" request (that is, if open() has been called
        ///    * already), this is equivalent to calling abort() and then open().
    ///    *
    ///    * @param method The HTTP method - either "POST" or "GET". Ignored
    ///    *               if the URL is not a HTTP URL.
    ///    * @param url The URL to which to send the request.
    ///    * @param async (optional) Whether the request is synchronous or
    ///    *              asynchronous i.e. whether send returns only after
    ///    *              the response is received or if it returns immediately after
    ///    *              sending the request. In the latter case, notification
    ///    *              of completion is sent through the event listeners.
    ///    *              The default value is true.
    ///    * @param user (optional) A username for authentication if necessary.
    ///    *             The default value is the empty string
    ///    * @param password (optional) A password for authentication if necessary.
    ///    *                 The default value is the empty string
    ///    */
    /// ```
    ///

    /// `[optional_argc] void open (in ACString method, in AUTF8String url, [optional] in boolean async, [optional, Undefined (Empty)] in DOMString user, [optional, Undefined (Empty)] in DOMString password);`
    const _Open: () = ();

    /// ```text
    /// /**
    ///    * Sends the request. If the request is asynchronous, returns
    ///    * immediately after sending the request. If it is synchronous
    ///    * returns only after the response has been received.
    ///    *
    ///    * All event listeners must be set before calling send().
    ///    *
    ///    * After the initial response, all event listeners will be cleared.
    ///    * // XXXbz what does that mean, exactly?
    ///    *
    ///    * @param body Either an instance of nsIDOMDocument, nsIInputStream
    ///    *             or a string (nsISupportsString in the native calling
        ///    *             case). This is used to populate the body of the
    ///    *             HTTP request if the HTTP request method is "POST".
    ///    *             If the parameter is a nsIDOMDocument, it is serialized.
    ///    *             If the parameter is a nsIInputStream, then it must be
    ///    *             compatible with nsIUploadChannel.setUploadStream, and a
    ///    *             Content-Length header will be added to the HTTP request
    ///    *             with a value given by nsIInputStream.available.  Any
    ///    *             headers included at the top of the stream will be
    ///    *             treated as part of the message body.  The MIME type of
    ///    *             the stream should be specified by setting the Content-
    ///    *             Type header via the setRequestHeader method before
    ///    *             calling send.
    ///    */
    /// ```
    ///

    /// `void send ([optional] in nsIVariant body);`
    #[inline]
    pub unsafe fn Send(&self, body: *const nsIVariant) -> nsresult {
        ((*self.vtable).Send)(self, body)
    }


    /// ```text
    /// /**
    ///    * Sets a HTTP request header for HTTP requests. You must call open
    ///    * before setting the request headers.
    ///    *
    ///    * @param header The name of the header to set in the request.
    ///    * @param value The body of the header.
    ///    */
    /// ```
    ///

    /// `void setRequestHeader (in ACString header, in ACString value);`
    #[inline]
    pub unsafe fn SetRequestHeader(&self, header: &::nsstring::nsACString, value: &::nsstring::nsACString) -> nsresult {
        ((*self.vtable).SetRequestHeader)(self, header, value)
    }


    /// ```text
    /// /**
    ///    * The amount of milliseconds a request can take before being terminated.
    ///    * Initially zero. Zero means there is no timeout.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * The amount of milliseconds a request can take before being terminated.
    ///    * Initially zero. Zero means there is no timeout.
    ///    */
    /// ```
    ///

    /// `attribute unsigned long timeout;`
    #[inline]
    pub unsafe fn SetTimeout(&self, aTimeout: libc::uint32_t) -> nsresult {
        ((*self.vtable).SetTimeout)(self, aTimeout)
    }



    /// `readonly attribute unsigned short readyState;`
    #[inline]
    pub unsafe fn GetReadyState(&self, aReadyState: *mut libc::uint16_t) -> nsresult {
        ((*self.vtable).GetReadyState)(self, aReadyState)
    }


    /// ```text
    /// /**
    ///    * Override the mime type returned by the server (if any). This may
    ///    * be used, for example, to force a stream to be treated and parsed
    ///    * as text/xml, even if the server does not report it as such. This
    ///    * must be done before the <code>send</code> method is invoked.
    ///    *
    ///    * @param mimetype The type used to override that returned by the server
    ///    *                 (if any).
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Set to true if this is a background service request. This will
    ///    * prevent a load group being associated with the request, and
    ///    * suppress any security dialogs from being shown * to the user.
    ///    * In the cases where one of those dialogs would be shown, the request
    ///    * will simply fail instead.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Set to true if this is a background service request. This will
    ///    * prevent a load group being associated with the request, and
    ///    * suppress any security dialogs from being shown * to the user.
    ///    * In the cases where one of those dialogs would be shown, the request
    ///    * will simply fail instead.
    ///    */
    /// ```
    ///

    /// `attribute boolean mozBackgroundRequest;`
    #[inline]
    pub unsafe fn SetMozBackgroundRequest(&self, aMozBackgroundRequest: bool) -> nsresult {
        ((*self.vtable).SetMozBackgroundRequest)(self, aMozBackgroundRequest)
    }


    /// ```text
    /// /**
    ///    * When set to true attempts to make cross-site Access-Control requests
    ///    * with credentials such as cookies and authorization headers.
    ///    *
    ///    * Never affects same-site requests.
    ///    *
    ///    * Defaults to false.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * When set to true attempts to make cross-site Access-Control requests
    ///    * with credentials such as cookies and authorization headers.
    ///    *
    ///    * Never affects same-site requests.
    ///    *
    ///    * Defaults to false.
    ///    */
    /// ```
    ///

    /// `attribute boolean withCredentials;`
    #[inline]
    pub unsafe fn SetWithCredentials(&self, aWithCredentials: bool) -> nsresult {
        ((*self.vtable).SetWithCredentials)(self, aWithCredentials)
    }


    /// ```text
    /// /**
    ///    * Initialize the object for use from C++ code with the principal, script
    ///    * context, and owner window that should be used.
    ///    *
    ///    * @param principal The principal to use for the request. This must not be
    ///    *                  null.
    ///    * @param globalObject The associated global for the request. Can be the
    ///    *                     outer window, a sandbox, or a backstage pass.
    ///    *                     May be null, but then the request cannot create a
    ///    *                     document.
    ///    * @param baseURI The base URI to use when resolving relative URIs. May be
    ///    *                null.
    ///    * @param loadGroup An optional load group to use when performing the request.
    ///    *                  This will be used even if the global has a window with a
    ///    *                  load group.
    ///    */
    /// ```
    ///

    /// `[noscript] void init (in nsIPrincipal principal, in nsIGlobalObject globalObject, in nsIURI baseURI, [optional] in nsILoadGroup loadGroup);`
    #[inline]
    pub unsafe fn Init(&self, principal: *const nsIPrincipal, globalObject: *const nsIGlobalObject, baseURI: *const nsIURI, loadGroup: *const nsILoadGroup) -> nsresult {
        ((*self.vtable).Init)(self, principal, globalObject, baseURI, loadGroup)
    }


    /// ```text
    /// /**
    ///    * Upload process can be tracked by adding event listener to |upload|.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIXMLHttpRequestUpload upload;`
    #[inline]
    pub unsafe fn GetUpload(&self, aUpload: *mut *const nsIXMLHttpRequestUpload) -> nsresult {
        ((*self.vtable).GetUpload)(self, aUpload)
    }


    /// ```text
    /// /**
    ///    * If true, the request will be sent without cookie and authentication
    ///    * headers.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * If true, the same origin policy will not be enforced on the request.
    ///    */
    /// ```
    ///

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


}


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

    /// 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 nsIXHRSendable.
unsafe impl XpCom for nsIXHRSendable {
    const IID: nsIID = nsID(0x840d0d00, 0xe83e, 0x4a29,
        [0xb3, 0xc7, 0x67, 0xe9, 0x6e, 0x90, 0xa4, 0x99]);
}

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

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

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

    /* void getSendInfo (out nsIInputStream body, out uint64_t contentLength, out ACString contentTypeWithCharset, out ACString charset); */
    pub GetSendInfo: unsafe extern "system" fn (this: *const nsIXHRSendable, body: *mut *const nsIInputStream, contentLength: *mut uint64_t, contentTypeWithCharset: &mut ::nsstring::nsACString, charset: &mut ::nsstring::nsACString) -> 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 nsIXHRSendable {


    /// `void getSendInfo (out nsIInputStream body, out uint64_t contentLength, out ACString contentTypeWithCharset, out ACString charset);`
    #[inline]
    pub unsafe fn GetSendInfo(&self, body: *mut *const nsIInputStream, contentLength: *mut uint64_t, contentTypeWithCharset: &mut ::nsstring::nsACString, charset: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetSendInfo)(self, body, contentLength, contentTypeWithCharset, charset)
    }


}