Struct xpcom::interfaces::nsIJARProtocolHandler

#[repr(C)]
pub struct nsIJARProtocolHandler { /* fields omitted */ }

interface nsIJARProtocolHandler : nsIProtocolHandler

Methods

impl nsIJARProtocolHandler

pub fn coerce<T: nsIJARProtocolHandlerCoerce>(&self) -> &T

Cast this nsIJARProtocolHandler to one of its base interfaces.

impl nsIJARProtocolHandler

pub unsafe fn GetJARCache(
    &self,
    aJARCache: *mut *const nsIZipReaderCache
) -> nsresult

/**
     * JARCache contains the collection of open jar files.
     */

readonly attribute nsIZipReaderCache JARCache;

Methods from Deref<Target = nsIProtocolHandler>

pub fn coerce<T: nsIProtocolHandlerCoerce>(&self) -> &T

Cast this nsIProtocolHandler to one of its base interfaces.

pub const URI_STD: i64

pub const URI_NORELATIVE: i64

pub const URI_NOAUTH: i64

pub const ALLOWS_PROXY: i64

pub const ALLOWS_PROXY_HTTP: i64

pub const URI_INHERITS_SECURITY_CONTEXT: i64

pub const URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT: i64

pub const URI_LOADABLE_BY_ANYONE: i64

pub const URI_DANGEROUS_TO_LOAD: i64

pub const URI_IS_UI_RESOURCE: i64

pub const URI_IS_LOCAL_FILE: i64

pub const URI_LOADABLE_BY_SUBSUMERS: i64

pub const URI_DOES_NOT_RETURN_DATA: i64

pub const URI_IS_LOCAL_RESOURCE: i64

pub const URI_OPENING_EXECUTES_SCRIPT: i64

pub const URI_NON_PERSISTABLE: i64

pub const URI_FORBIDS_COOKIE_ACCESS: i64

pub const URI_CROSS_ORIGIN_NEEDS_WEBAPPS_PERM: i64

pub const URI_SYNC_LOAD_IS_OK: i64

pub const URI_SAFE_TO_LOAD_IN_SECURE_CONTEXT: i64

pub const URI_FETCHABLE_BY_ANYONE: i64

pub const ORIGIN_IS_FULL_SPEC: i64

pub const URI_SCHEME_NOT_SELF_LINKABLE: i64

pub const URI_LOADABLE_BY_EXTENSIONS: i64

pub unsafe fn GetScheme(&self, aScheme: &mut nsACString) -> nsresult

/**
     * The scheme of this protocol (e.g., "file").
     */

readonly attribute ACString scheme;

pub unsafe fn GetDefaultPort(&self, aDefaultPort: *mut int32_t) -> nsresult

/**
     * The default port is the port that this protocol normally uses.
     * If a port does not make sense for the protocol (e.g., "about:")
     * then -1 will be returned.
     */

readonly attribute long defaultPort;

pub unsafe fn GetProtocolFlags(&self, aProtocolFlags: *mut uint32_t) -> nsresult

/**
     * Returns the protocol specific flags (see flag definitions below).
     */

readonly attribute unsigned long protocolFlags;

pub unsafe fn NewURI(
    &self,
    aSpec: &nsACString,
    aOriginCharset: *const c_char,
    aBaseURI: *const nsIURI,
    _retval: *mut *const nsIURI
) -> nsresult

/**
     * Makes a URI object that is suitable for loading by this protocol,
     * where the URI string is given as an UTF-8 string.  The caller may
     * provide the charset from which the URI string originated, so that
     * the URI string can be translated back to that charset (if necessary)
     * before communicating with, for example, the origin server of the URI
     * string.  (Many servers do not support UTF-8 IRIs at the present time,
     * so we must be careful about tracking the native charset of the origin
     * server.)
     *
     * @param aSpec          - the URI string in UTF-8 encoding. depending
     *                         on the protocol implementation, unicode character
     *                         sequences may or may not be %xx escaped.
     * @param aOriginCharset - the charset of the document from which this URI
     *                         string originated.  this corresponds to the
     *                         charset that should be used when communicating
     *                         this URI to an origin server, for example.  if
     *                         null, then UTF-8 encoding is assumed (i.e.,
     *                         no charset transformation from aSpec).
     * @param aBaseURI       - if null, aSpec must specify an absolute URI.
     *                         otherwise, aSpec may be resolved relative
     *                         to aBaseURI, depending on the protocol.
     *                         If the protocol has no concept of relative
     *                         URI aBaseURI will simply be ignored.
     */

nsIURI newURI (in AUTF8String aSpec, [optional] in string aOriginCharset, [optional] in nsIURI aBaseURI);

pub unsafe fn NewChannel2(
    &self,
    aURI: *const nsIURI,
    aLoadinfo: *const nsILoadInfo,
    _retval: *mut *const nsIChannel
) -> nsresult

/**
     * Constructs a new channel from the given URI for this protocol handler and
     * sets the loadInfo for the constructed channel.
     */

nsIChannel newChannel2 (in nsIURI aURI, in nsILoadInfo aLoadinfo);

pub unsafe fn NewChannel(
    &self,
    aURI: *const nsIURI,
    _retval: *mut *const nsIChannel
) -> nsresult

/**
     * Constructs a new channel from the given URI for this protocol handler.
     */

nsIChannel newChannel (in nsIURI aURI);

pub unsafe fn AllowPort(
    &self,
    port: int32_t,
    scheme: *const c_char,
    _retval: *mut bool
) -> nsresult

/**
     * Allows a protocol to override blacklisted ports.
     *
     * This method will be called when there is an attempt to connect to a port
     * that is blacklisted.  For example, for most protocols, port 25 (Simple Mail
     * Transfer) is banned.  When a URI containing this "known-to-do-bad-things"
     * port number is encountered, this function will be called to ask if the
     * protocol handler wants to override the ban.
     */

boolean allowPort (in long port, in string scheme);

Trait Implementations

impl XpCom for nsIJARProtocolHandler

const IID: nsIID

IID: nsIID = nsID(2462299180, 39108, 4563, [140, 217, 0, 96, 176, 252, 20, 163])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIJARProtocolHandler

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIJARProtocolHandler

type Target = nsIProtocolHandler

The resulting type after dereferencing.

fn deref(&self) -> &nsIProtocolHandler

Dereferences the value.