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


/// `interface nsIHttpUpgradeListener : nsISupports`
///

/// ```text
/// /**
///  * The callback interface for nsIHttpChannelInternal::HTTPUpgrade()
///  */
/// ```
///

// 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 nsIHttpUpgradeListener {
    vtable: *const nsIHttpUpgradeListenerVTable,

    /// 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 nsIHttpUpgradeListener.
unsafe impl XpCom for nsIHttpUpgradeListener {
    const IID: nsIID = nsID(0x5b515449, 0xab64, 0x4dba,
        [0xb3, 0xcd, 0xda, 0x8f, 0xc2, 0xf8, 0x30, 0x64]);
}

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

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

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

    /* [must_use] void onTransportAvailable (in nsISocketTransport aTransport, in nsIAsyncInputStream aSocketIn, in nsIAsyncOutputStream aSocketOut); */
    pub OnTransportAvailable: unsafe extern "system" fn (this: *const nsIHttpUpgradeListener, aTransport: *const nsISocketTransport, aSocketIn: *const nsIAsyncInputStream, aSocketOut: *const nsIAsyncOutputStream) -> 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 nsIHttpUpgradeListener {


    /// `[must_use] void onTransportAvailable (in nsISocketTransport aTransport, in nsIAsyncInputStream aSocketIn, in nsIAsyncOutputStream aSocketOut);`
    #[inline]
    pub unsafe fn OnTransportAvailable(&self, aTransport: *const nsISocketTransport, aSocketIn: *const nsIAsyncInputStream, aSocketOut: *const nsIAsyncOutputStream) -> nsresult {
        ((*self.vtable).OnTransportAvailable)(self, aTransport, aSocketIn, aSocketOut)
    }


}


/// `interface nsIHttpChannelInternal : nsISupports`
///

/// ```text
/// /**
///  * Dumping ground for http.  This interface will never be frozen.  If you are
///  * using any feature exposed by this interface, be aware that this interface
///  * will change and you will be broken.  You have been warned.
///  */
/// ```
///

// 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 nsIHttpChannelInternal {
    vtable: *const nsIHttpChannelInternalVTable,

    /// 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 nsIHttpChannelInternal.
unsafe impl XpCom for nsIHttpChannelInternal {
    const IID: nsIID = nsID(0x4e28263d, 0x1e03, 0x46f4,
        [0xaa, 0x5c, 0x95, 0x12, 0xf9, 0x19, 0x57, 0xf9]);
}

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

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

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

    /* [must_use] attribute nsIURI documentURI; */
    pub GetDocumentURI: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aDocumentURI: *mut *const nsIURI) -> nsresult,

    /* [must_use] attribute nsIURI documentURI; */
    pub SetDocumentURI: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aDocumentURI: *const nsIURI) -> nsresult,

    /* [must_use] void getRequestVersion (out unsigned long major, out unsigned long minor); */
    pub GetRequestVersion: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, major: *mut libc::uint32_t, minor: *mut libc::uint32_t) -> nsresult,

    /* [must_use] void getResponseVersion (out unsigned long major, out unsigned long minor); */
    pub GetResponseVersion: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, major: *mut libc::uint32_t, minor: *mut libc::uint32_t) -> nsresult,

    /* [must_use,noscript] void takeAllSecurityMessages (in securityMessagesArray aMessages); */
    /// Unable to generate binding because `native type nsCOMArray<nsISecurityConsoleMessage> is unsupported`
    pub TakeAllSecurityMessages: *const ::libc::c_void,

    /* [must_use] void setCookie (in string aCookieHeader); */
    pub SetCookie: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aCookieHeader: *const libc::c_char) -> nsresult,

    /* [must_use] void setupFallbackChannel (in string aFallbackKey); */
    pub SetupFallbackChannel: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aFallbackKey: *const libc::c_char) -> nsresult,

    /* [must_use] attribute unsigned long thirdPartyFlags; */
    pub GetThirdPartyFlags: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aThirdPartyFlags: *mut libc::uint32_t) -> nsresult,

    /* [must_use] attribute unsigned long thirdPartyFlags; */
    pub SetThirdPartyFlags: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aThirdPartyFlags: libc::uint32_t) -> nsresult,

    /* [must_use] attribute boolean forceAllowThirdPartyCookie; */
    pub GetForceAllowThirdPartyCookie: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aForceAllowThirdPartyCookie: *mut bool) -> nsresult,

    /* [must_use] attribute boolean forceAllowThirdPartyCookie; */
    pub SetForceAllowThirdPartyCookie: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aForceAllowThirdPartyCookie: bool) -> nsresult,

    /* [must_use] readonly attribute boolean canceled; */
    pub GetCanceled: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aCanceled: *mut bool) -> nsresult,

    /* [must_use] attribute boolean channelIsForDownload; */
    pub GetChannelIsForDownload: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aChannelIsForDownload: *mut bool) -> nsresult,

    /* [must_use] attribute boolean channelIsForDownload; */
    pub SetChannelIsForDownload: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aChannelIsForDownload: bool) -> nsresult,

    /* [must_use] readonly attribute AUTF8String localAddress; */
    pub GetLocalAddress: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aLocalAddress: &mut ::nsstring::nsACString) -> nsresult,

    /* [must_use] readonly attribute int32_t localPort; */
    pub GetLocalPort: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aLocalPort: *mut int32_t) -> nsresult,

    /* [must_use] readonly attribute AUTF8String remoteAddress; */
    pub GetRemoteAddress: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aRemoteAddress: &mut ::nsstring::nsACString) -> nsresult,

    /* [must_use] readonly attribute int32_t remotePort; */
    pub GetRemotePort: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aRemotePort: *mut int32_t) -> nsresult,

    /* [must_use,noscript] void setCacheKeysRedirectChain (in StringArray cacheKeys); */
    /// Unable to generate binding because `native type nsTArray<nsCString> is unsupported`
    pub SetCacheKeysRedirectChain: *const ::libc::c_void,

    /* [must_use] void HTTPUpgrade (in ACString aProtocolName, in nsIHttpUpgradeListener aListener); */
    pub HTTPUpgrade: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aProtocolName: &::nsstring::nsACString, aListener: *const nsIHttpUpgradeListener) -> nsresult,

    /* [must_use] attribute boolean allowSpdy; */
    pub GetAllowSpdy: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aAllowSpdy: *mut bool) -> nsresult,

    /* [must_use] attribute boolean allowSpdy; */
    pub SetAllowSpdy: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aAllowSpdy: bool) -> nsresult,

    /* [must_use] attribute boolean responseTimeoutEnabled; */
    pub GetResponseTimeoutEnabled: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aResponseTimeoutEnabled: *mut bool) -> nsresult,

    /* [must_use] attribute boolean responseTimeoutEnabled; */
    pub SetResponseTimeoutEnabled: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aResponseTimeoutEnabled: bool) -> nsresult,

    /* [must_use] attribute unsigned long initialRwin; */
    pub GetInitialRwin: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aInitialRwin: *mut libc::uint32_t) -> nsresult,

    /* [must_use] attribute unsigned long initialRwin; */
    pub SetInitialRwin: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aInitialRwin: libc::uint32_t) -> nsresult,

    /* [must_use] readonly attribute nsIURI apiRedirectToURI; */
    pub GetApiRedirectToURI: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aApiRedirectToURI: *mut *const nsIURI) -> nsresult,

    /* [must_use] attribute boolean allowAltSvc; */
    pub GetAllowAltSvc: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aAllowAltSvc: *mut bool) -> nsresult,

    /* [must_use] attribute boolean allowAltSvc; */
    pub SetAllowAltSvc: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aAllowAltSvc: bool) -> nsresult,

    /* [must_use] attribute boolean beConservative; */
    pub GetBeConservative: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aBeConservative: *mut bool) -> nsresult,

    /* [must_use] attribute boolean beConservative; */
    pub SetBeConservative: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aBeConservative: bool) -> nsresult,

    /* [must_use] attribute unsigned long tlsFlags; */
    pub GetTlsFlags: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aTlsFlags: *mut libc::uint32_t) -> nsresult,

    /* [must_use] attribute unsigned long tlsFlags; */
    pub SetTlsFlags: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aTlsFlags: libc::uint32_t) -> nsresult,

    /* [must_use] readonly attribute PRTime lastModifiedTime; */
    pub GetLastModifiedTime: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aLastModifiedTime: *mut PRTime) -> nsresult,

    /* [must_use] readonly attribute boolean responseSynthesized; */
    pub GetResponseSynthesized: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aResponseSynthesized: *mut bool) -> nsresult,

    /* [must_use] attribute boolean corsIncludeCredentials; */
    pub GetCorsIncludeCredentials: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aCorsIncludeCredentials: *mut bool) -> nsresult,

    /* [must_use] attribute boolean corsIncludeCredentials; */
    pub SetCorsIncludeCredentials: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aCorsIncludeCredentials: bool) -> nsresult,

    /* [must_use] attribute unsigned long corsMode; */
    pub GetCorsMode: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aCorsMode: *mut libc::uint32_t) -> nsresult,

    /* [must_use] attribute unsigned long corsMode; */
    pub SetCorsMode: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aCorsMode: libc::uint32_t) -> nsresult,

    /* [must_use] attribute unsigned long redirectMode; */
    pub GetRedirectMode: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aRedirectMode: *mut libc::uint32_t) -> nsresult,

    /* [must_use] attribute unsigned long redirectMode; */
    pub SetRedirectMode: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aRedirectMode: libc::uint32_t) -> nsresult,

    /* [must_use] attribute unsigned long fetchCacheMode; */
    pub GetFetchCacheMode: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aFetchCacheMode: *mut libc::uint32_t) -> nsresult,

    /* [must_use] attribute unsigned long fetchCacheMode; */
    pub SetFetchCacheMode: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aFetchCacheMode: libc::uint32_t) -> nsresult,

    /* [must_use] readonly attribute nsIURI topWindowURI; */
    pub GetTopWindowURI: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aTopWindowURI: *mut *const nsIURI) -> nsresult,

    /* [must_use] void setTopWindowURIIfUnknown (in nsIURI topWindowURI); */
    pub SetTopWindowURIIfUnknown: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, topWindowURI: *const nsIURI) -> nsresult,

    /* [must_use] attribute ACString networkInterfaceId; */
    pub GetNetworkInterfaceId: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aNetworkInterfaceId: &mut ::nsstring::nsACString) -> nsresult,

    /* [must_use] attribute ACString networkInterfaceId; */
    pub SetNetworkInterfaceId: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aNetworkInterfaceId: &::nsstring::nsACString) -> nsresult,

    /* [must_use] readonly attribute nsIURI proxyURI; */
    pub GetProxyURI: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aProxyURI: *mut *const nsIURI) -> nsresult,

    /* [noscript,nostdcall,notxpcom] void setCorsPreflightParameters (in StringArrayRef unsafeHeaders); */
    /// Unable to generate binding because `native type const nsTArray<nsCString> is unsupported`
    pub SetCorsPreflightParameters: *const ::libc::c_void,

    /* [infallible] attribute boolean blockAuthPrompt; */
    pub GetBlockAuthPrompt: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aBlockAuthPrompt: *mut bool) -> nsresult,

    /* [infallible] attribute boolean blockAuthPrompt; */
    pub SetBlockAuthPrompt: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aBlockAuthPrompt: bool) -> nsresult,

    /* [must_use] attribute AString integrityMetadata; */
    pub GetIntegrityMetadata: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aIntegrityMetadata: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] attribute AString integrityMetadata; */
    pub SetIntegrityMetadata: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aIntegrityMetadata: &::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute ACString connectionInfoHashKey; */
    pub GetConnectionInfoHashKey: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aConnectionInfoHashKey: &mut ::nsstring::nsACString) -> nsresult,

    /* [infallible,noscript] attribute unsigned long lastRedirectFlags; */
    pub GetLastRedirectFlags: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aLastRedirectFlags: *mut libc::uint32_t) -> nsresult,

    /* [infallible,noscript] attribute unsigned long lastRedirectFlags; */
    pub SetLastRedirectFlags: unsafe extern "system" fn (this: *const nsIHttpChannelInternal, aLastRedirectFlags: libc::uint32_t) -> 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 nsIHttpChannelInternal {
    /// ```text
    /// /**
    ///      * This flag is set to force relevant cookies to be sent with this load
    ///      * even if normally they wouldn't be.
    ///      */
    /// ```
    ///

    pub const THIRD_PARTY_FORCE_ALLOW: i64 = 1;


    pub const CORS_MODE_SAME_ORIGIN: i64 = 0;


    pub const CORS_MODE_NO_CORS: i64 = 1;


    pub const CORS_MODE_CORS: i64 = 2;


    pub const CORS_MODE_NAVIGATE: i64 = 3;


    pub const REDIRECT_MODE_FOLLOW: i64 = 0;


    pub const REDIRECT_MODE_ERROR: i64 = 1;


    pub const REDIRECT_MODE_MANUAL: i64 = 2;


    pub const FETCH_CACHE_MODE_DEFAULT: i64 = 0;


    pub const FETCH_CACHE_MODE_NO_STORE: i64 = 1;


    pub const FETCH_CACHE_MODE_RELOAD: i64 = 2;


    pub const FETCH_CACHE_MODE_NO_CACHE: i64 = 3;


    pub const FETCH_CACHE_MODE_FORCE_CACHE: i64 = 4;


    pub const FETCH_CACHE_MODE_ONLY_IF_CACHED: i64 = 5;

    /// ```text
    /// /**
    ///      * An http channel can own a reference to the document URI
    ///      */
    /// ```
    ///

    /// `[must_use] attribute nsIURI documentURI;`
    #[inline]
    pub unsafe fn GetDocumentURI(&self, aDocumentURI: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetDocumentURI)(self, aDocumentURI)
    }


    /// ```text
    /// /**
    ///      * An http channel can own a reference to the document URI
    ///      */
    /// ```
    ///

    /// `[must_use] attribute nsIURI documentURI;`
    #[inline]
    pub unsafe fn SetDocumentURI(&self, aDocumentURI: *const nsIURI) -> nsresult {
        ((*self.vtable).SetDocumentURI)(self, aDocumentURI)
    }


    /// ```text
    /// /**
    ///      * Get the major/minor version numbers for the request
    ///      */
    /// ```
    ///

    /// `[must_use] void getRequestVersion (out unsigned long major, out unsigned long minor);`
    #[inline]
    pub unsafe fn GetRequestVersion(&self, major: *mut libc::uint32_t, minor: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetRequestVersion)(self, major, minor)
    }


    /// ```text
    /// /**
    ///      * Get the major/minor version numbers for the response
    ///      */
    /// ```
    ///

    /// `[must_use] void getResponseVersion (out unsigned long major, out unsigned long minor);`
    #[inline]
    pub unsafe fn GetResponseVersion(&self, major: *mut libc::uint32_t, minor: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetResponseVersion)(self, major, minor)
    }



    /// `[must_use,noscript] void takeAllSecurityMessages (in securityMessagesArray aMessages);`
    const _TakeAllSecurityMessages: () = ();

    /// ```text
    /// /**
    ///      * Helper method to set a cookie with a consumer-provided
    ///      * cookie header, _but_ using the channel's other information
    ///      * (URI's, prompters, date headers etc).
    ///      *
    ///      * @param aCookieHeader
    ///      *        The cookie header to be parsed.
    ///      */
    /// ```
    ///

    /// `[must_use] void setCookie (in string aCookieHeader);`
    #[inline]
    pub unsafe fn SetCookie(&self, aCookieHeader: *const libc::c_char) -> nsresult {
        ((*self.vtable).SetCookie)(self, aCookieHeader)
    }


    /// ```text
    /// /**
    ///      * Setup this channel as an application cache fallback channel.
    ///      */
    /// ```
    ///

    /// `[must_use] void setupFallbackChannel (in string aFallbackKey);`
    #[inline]
    pub unsafe fn SetupFallbackChannel(&self, aFallbackKey: *const libc::c_char) -> nsresult {
        ((*self.vtable).SetupFallbackChannel)(self, aFallbackKey)
    }


    /// ```text
    /// /**
    ///      * When set, these flags modify the algorithm used to decide whether to
    ///      * send 3rd party cookies for a given channel.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * When set, these flags modify the algorithm used to decide whether to
    ///      * send 3rd party cookies for a given channel.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * This attribute was added before the "flags" above and is retained here
    ///      * for compatibility. When set to true, has the same effect as
    ///      * THIRD_PARTY_FORCE_ALLOW, described above.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * This attribute was added before the "flags" above and is retained here
    ///      * for compatibility. When set to true, has the same effect as
    ///      * THIRD_PARTY_FORCE_ALLOW, described above.
    ///      */
    /// ```
    ///

    /// `[must_use] attribute boolean forceAllowThirdPartyCookie;`
    #[inline]
    pub unsafe fn SetForceAllowThirdPartyCookie(&self, aForceAllowThirdPartyCookie: bool) -> nsresult {
        ((*self.vtable).SetForceAllowThirdPartyCookie)(self, aForceAllowThirdPartyCookie)
    }


    /// ```text
    /// /**
    ///      * True iff the channel has been canceled.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * External handlers may set this to true to notify the channel
    ///      * that it is open on behalf of a download.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * External handlers may set this to true to notify the channel
    ///      * that it is open on behalf of a download.
    ///      */
    /// ```
    ///

    /// `[must_use] attribute boolean channelIsForDownload;`
    #[inline]
    pub unsafe fn SetChannelIsForDownload(&self, aChannelIsForDownload: bool) -> nsresult {
        ((*self.vtable).SetChannelIsForDownload)(self, aChannelIsForDownload)
    }


    /// ```text
    /// /**
    ///      * The local IP address to which this channel is bound, in the
    ///      * format produced by PR_NetAddrToString. May be IPv4 or IPv6.
    ///      * Note: in the presence of NAT, this may not be the same as the
    ///      * address that the remote host thinks it's talking to.
    ///      *
    ///      * May throw NS_ERROR_NOT_AVAILABLE if accessed when the channel's
    ///      * endpoints are not yet determined, or in any case when
    ///      * nsIHttpActivityObserver.isActive is false. See bugs 534698 and 526207.
    ///      */
    /// ```
    ///

    /// `[must_use] readonly attribute AUTF8String localAddress;`
    #[inline]
    pub unsafe fn GetLocalAddress(&self, aLocalAddress: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetLocalAddress)(self, aLocalAddress)
    }


    /// ```text
    /// /**
    ///      * The local port number to which this channel is bound.
    ///      *
    ///      * May throw NS_ERROR_NOT_AVAILABLE if accessed when the channel's
    ///      * endpoints are not yet determined, or in any case when
    ///      * nsIHttpActivityObserver.isActive is false. See bugs 534698 and 526207.
    ///      */
    /// ```
    ///

    /// `[must_use] readonly attribute int32_t localPort;`
    #[inline]
    pub unsafe fn GetLocalPort(&self, aLocalPort: *mut int32_t) -> nsresult {
        ((*self.vtable).GetLocalPort)(self, aLocalPort)
    }


    /// ```text
    /// /**
    ///      * The IP address of the remote host that this channel is
    ///      * connected to, in the format produced by PR_NetAddrToString.
    ///      *
    ///      * May throw NS_ERROR_NOT_AVAILABLE if accessed when the channel's
    ///      * endpoints are not yet determined, or in any case when
    ///      * nsIHttpActivityObserver.isActive is false. See bugs 534698 and 526207.
    ///      */
    /// ```
    ///

    /// `[must_use] readonly attribute AUTF8String remoteAddress;`
    #[inline]
    pub unsafe fn GetRemoteAddress(&self, aRemoteAddress: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetRemoteAddress)(self, aRemoteAddress)
    }


    /// ```text
    /// /**
    ///      * The remote port number that this channel is connected to.
    ///      *
    ///      * May throw NS_ERROR_NOT_AVAILABLE if accessed when the channel's
    ///      * endpoints are not yet determined, or in any case when
    ///      * nsIHttpActivityObserver.isActive is false. See bugs 534698 and 526207.
    ///      */
    /// ```
    ///

    /// `[must_use] readonly attribute int32_t remotePort;`
    #[inline]
    pub unsafe fn GetRemotePort(&self, aRemotePort: *mut int32_t) -> nsresult {
        ((*self.vtable).GetRemotePort)(self, aRemotePort)
    }


    /// ```text
    /// /**
    ///      * Transfer chain of redirected cache-keys.
    ///      */
    /// ```
    ///

    /// `[must_use,noscript] void setCacheKeysRedirectChain (in StringArray cacheKeys);`
    const _SetCacheKeysRedirectChain: () = ();

    /// ```text
    /// /**
    ///      * HTTPUpgrade allows for the use of HTTP to bootstrap another protocol
    ///      * via the RFC 2616 Upgrade request header in conjunction with a 101 level
    ///      * response. The nsIHttpUpgradeListener will have its
    ///      * onTransportAvailable() method invoked if a matching 101 is processed.
    ///      * The arguments to onTransportAvailable provide the new protocol the low
    ///      * level tranport streams that are no longer used by HTTP.
    ///      *
    ///      * The onStartRequest and onStopRequest events are still delivered and the
    ///      * listener gets full control over the socket if and when onTransportAvailable
    ///      * is delievered.
    ///      *
    ///      * @param aProtocolName
    ///      *        The value of the HTTP Upgrade request header
    ///      * @param aListener
    ///      *        The callback object used to handle a successful upgrade
    ///      */
    /// ```
    ///

    /// `[must_use] void HTTPUpgrade (in ACString aProtocolName, in nsIHttpUpgradeListener aListener);`
    #[inline]
    pub unsafe fn HTTPUpgrade(&self, aProtocolName: &::nsstring::nsACString, aListener: *const nsIHttpUpgradeListener) -> nsresult {
        ((*self.vtable).HTTPUpgrade)(self, aProtocolName, aListener)
    }


    /// ```text
    /// /**
    ///      * Enable/Disable Spdy negotiation on per channel basis.
    ///      * The network.http.spdy.enabled preference is still a pre-requisite
    ///      * for starting spdy.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Enable/Disable Spdy negotiation on per channel basis.
    ///      * The network.http.spdy.enabled preference is still a pre-requisite
    ///      * for starting spdy.
    ///      */
    /// ```
    ///

    /// `[must_use] attribute boolean allowSpdy;`
    #[inline]
    pub unsafe fn SetAllowSpdy(&self, aAllowSpdy: bool) -> nsresult {
        ((*self.vtable).SetAllowSpdy)(self, aAllowSpdy)
    }


    /// ```text
    /// /**
    ///      * This attribute en/disables the timeout for the first byte of an HTTP
    ///      * response. Enabled by default.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * This attribute en/disables the timeout for the first byte of an HTTP
    ///      * response. Enabled by default.
    ///      */
    /// ```
    ///

    /// `[must_use] attribute boolean responseTimeoutEnabled;`
    #[inline]
    pub unsafe fn SetResponseTimeoutEnabled(&self, aResponseTimeoutEnabled: bool) -> nsresult {
        ((*self.vtable).SetResponseTimeoutEnabled)(self, aResponseTimeoutEnabled)
    }


    /// ```text
    /// /**
    ///      * If the underlying transport supports RWIN manipulation, this is the
    ///      * intiial window value for the channel. HTTP/2 implements this.
    ///      * 0 means no override from system default. Set before opening channel.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * If the underlying transport supports RWIN manipulation, this is the
    ///      * intiial window value for the channel. HTTP/2 implements this.
    ///      * 0 means no override from system default. Set before opening channel.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Get value of the URI passed to nsIHttpChannel.redirectTo() if any.
    ///      * May return null when redirectTo() has not been called.
    ///      */
    /// ```
    ///

    /// `[must_use] readonly attribute nsIURI apiRedirectToURI;`
    #[inline]
    pub unsafe fn GetApiRedirectToURI(&self, aApiRedirectToURI: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetApiRedirectToURI)(self, aApiRedirectToURI)
    }


    /// ```text
    /// /**
    ///      * Enable/Disable use of Alternate Services with this channel.
    ///      * The network.http.altsvc.enabled preference is still a pre-requisite.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Enable/Disable use of Alternate Services with this channel.
    ///      * The network.http.altsvc.enabled preference is still a pre-requisite.
    ///      */
    /// ```
    ///

    /// `[must_use] attribute boolean allowAltSvc;`
    #[inline]
    pub unsafe fn SetAllowAltSvc(&self, aAllowAltSvc: bool) -> nsresult {
        ((*self.vtable).SetAllowAltSvc)(self, aAllowAltSvc)
    }


    /// ```text
    /// /**
    ///      * If true, do not use newer protocol features that might have interop problems
    ///      * on the Internet. Intended only for use with critical infra like the updater.
    ///      * default is false.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * If true, do not use newer protocol features that might have interop problems
    ///      * on the Internet. Intended only for use with critical infra like the updater.
    ///      * default is false.
    ///      */
    /// ```
    ///

    /// `[must_use] attribute boolean beConservative;`
    #[inline]
    pub unsafe fn SetBeConservative(&self, aBeConservative: bool) -> nsresult {
        ((*self.vtable).SetBeConservative)(self, aBeConservative)
    }


    /// ```text
    /// /**
    ///      * An opaque flags for non-standard behavior of the TLS system.
    ///      * It is unlikely this will need to be set outside of telemetry studies
    ///      * relating to the TLS implementation.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * An opaque flags for non-standard behavior of the TLS system.
    ///      * It is unlikely this will need to be set outside of telemetry studies
    ///      * relating to the TLS implementation.
    ///      */
    /// ```
    ///

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



    /// `[must_use] readonly attribute PRTime lastModifiedTime;`
    #[inline]
    pub unsafe fn GetLastModifiedTime(&self, aLastModifiedTime: *mut PRTime) -> nsresult {
        ((*self.vtable).GetLastModifiedTime)(self, aLastModifiedTime)
    }



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


    /// ```text
    /// /**
    ///      * Set by nsCORSListenerProxy if credentials should be included in
    ///      * cross-origin requests. false indicates "same-origin", users should still
    ///      * check flag LOAD_ANONYMOUS!
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Set by nsCORSListenerProxy if credentials should be included in
    ///      * cross-origin requests. false indicates "same-origin", users should still
    ///      * check flag LOAD_ANONYMOUS!
    ///      */
    /// ```
    ///

    /// `[must_use] attribute boolean corsIncludeCredentials;`
    #[inline]
    pub unsafe fn SetCorsIncludeCredentials(&self, aCorsIncludeCredentials: bool) -> nsresult {
        ((*self.vtable).SetCorsIncludeCredentials)(self, aCorsIncludeCredentials)
    }


    /// ```text
    /// /**
    ///      * Set by nsCORSListenerProxy to indicate CORS load type. Defaults to CORS_MODE_NO_CORS.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Set by nsCORSListenerProxy to indicate CORS load type. Defaults to CORS_MODE_NO_CORS.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Set to indicate Request.redirect mode exposed during ServiceWorker
    ///      * interception. No policy enforcement is performed by the channel for this
    ///      * value.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Set to indicate Request.redirect mode exposed during ServiceWorker
    ///      * interception. No policy enforcement is performed by the channel for this
    ///      * value.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Set to indicate Request.cache mode, which simulates the fetch API
    ///      * semantics, and is also used for exposing this value to the Web page
    ///      * during service worker interception.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Set to indicate Request.cache mode, which simulates the fetch API
    ///      * semantics, and is also used for exposing this value to the Web page
    ///      * during service worker interception.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * The URI of the top-level window that's associated with this channel.
    ///      */
    /// ```
    ///

    /// `[must_use] readonly attribute nsIURI topWindowURI;`
    #[inline]
    pub unsafe fn GetTopWindowURI(&self, aTopWindowURI: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetTopWindowURI)(self, aTopWindowURI)
    }


    /// ```text
    /// /**
    ///      * Set top-level window URI to this channel only when the topWindowURI
    ///      * is null and there is no window associated to this channel.
    ///      * Note that the current usage of this method is only for xpcshell test.
    ///      */
    /// ```
    ///

    /// `[must_use] void setTopWindowURIIfUnknown (in nsIURI topWindowURI);`
    #[inline]
    pub unsafe fn SetTopWindowURIIfUnknown(&self, topWindowURI: *const nsIURI) -> nsresult {
        ((*self.vtable).SetTopWindowURIIfUnknown)(self, topWindowURI)
    }


    /// ```text
    /// /**
    ///      * The network interface id that's associated with this channel.
    ///      */
    /// ```
    ///

    /// `[must_use] attribute ACString networkInterfaceId;`
    #[inline]
    pub unsafe fn GetNetworkInterfaceId(&self, aNetworkInterfaceId: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetNetworkInterfaceId)(self, aNetworkInterfaceId)
    }


    /// ```text
    /// /**
    ///      * The network interface id that's associated with this channel.
    ///      */
    /// ```
    ///

    /// `[must_use] attribute ACString networkInterfaceId;`
    #[inline]
    pub unsafe fn SetNetworkInterfaceId(&self, aNetworkInterfaceId: &::nsstring::nsACString) -> nsresult {
        ((*self.vtable).SetNetworkInterfaceId)(self, aNetworkInterfaceId)
    }


    /// ```text
    /// /**
    ///      * Read the proxy URI, which, if non-null, will be used to resolve
    ///      * proxies for this channel.
    ///      */
    /// ```
    ///

    /// `[must_use] readonly attribute nsIURI proxyURI;`
    #[inline]
    pub unsafe fn GetProxyURI(&self, aProxyURI: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetProxyURI)(self, aProxyURI)
    }


    /// ```text
    /// /**
    ///      * Make cross-origin CORS loads happen with a CORS preflight, and specify
    ///      * the CORS preflight parameters.
    ///      */
    /// ```
    ///

    /// `[noscript,nostdcall,notxpcom] void setCorsPreflightParameters (in StringArrayRef unsafeHeaders);`
    const _SetCorsPreflightParameters: () = ();

    /// ```text
    /// /**
    ///      * When set to true, the channel will not pop any authentication prompts up
    ///      * to the user.  When provided or cached credentials lead to an
    ///      * authentication failure, that failure will be propagated to the channel
    ///      * listener.  Must be called before opening the channel, otherwise throws.
    ///      */
    /// ```
    ///

    /// `[infallible] attribute boolean blockAuthPrompt;`
    #[inline]
    pub unsafe fn GetBlockAuthPrompt(&self) -> bool {
        let mut result = <bool as ::std::default::Default>::default();
        let _rv = ((*self.vtable).GetBlockAuthPrompt)(self, &mut result);
        debug_assert!(::nserror::NsresultExt::succeeded(_rv));
        result
    }


    /// ```text
    /// /**
    ///      * When set to true, the channel will not pop any authentication prompts up
    ///      * to the user.  When provided or cached credentials lead to an
    ///      * authentication failure, that failure will be propagated to the channel
    ///      * listener.  Must be called before opening the channel, otherwise throws.
    ///      */
    /// ```
    ///

    /// `[infallible] attribute boolean blockAuthPrompt;`
    #[inline]
    pub unsafe fn SetBlockAuthPrompt(&self, aBlockAuthPrompt: bool) -> nsresult {
        ((*self.vtable).SetBlockAuthPrompt)(self, aBlockAuthPrompt)
    }


    /// ```text
    /// /**
    ///      * Set to indicate Request.integrity.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Set to indicate Request.integrity.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * The connection info's hash key. We use it to test connection separation.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * If this channel was created as the result of a redirect, then this
    ///      * value will reflect the redirect flags passed to the
    ///      * SetupReplacementChannel() method.
    ///      */
    /// ```
    ///

    /// `[infallible,noscript] attribute unsigned long lastRedirectFlags;`
    #[inline]
    pub unsafe fn GetLastRedirectFlags(&self) -> libc::uint32_t {
        let mut result = <libc::uint32_t as ::std::default::Default>::default();
        let _rv = ((*self.vtable).GetLastRedirectFlags)(self, &mut result);
        debug_assert!(::nserror::NsresultExt::succeeded(_rv));
        result
    }


    /// ```text
    /// /**
    ///      * If this channel was created as the result of a redirect, then this
    ///      * value will reflect the redirect flags passed to the
    ///      * SetupReplacementChannel() method.
    ///      */
    /// ```
    ///

    /// `[infallible,noscript] attribute unsigned long lastRedirectFlags;`
    #[inline]
    pub unsafe fn SetLastRedirectFlags(&self, aLastRedirectFlags: libc::uint32_t) -> nsresult {
        ((*self.vtable).SetLastRedirectFlags)(self, aLastRedirectFlags)
    }


}