Struct xpcom::interfaces::nsIExternalProtocolService

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

interface nsIExternalProtocolService : nsISupports

/**
 * The external protocol service is used for finding and launching
 * web handlers (a la registerProtocolHandler in the HTML5 draft) or
 * platform-specific applications for handling particular protocols.
 *
 * You can ask the external protocol service if it has an external
 * handler for a given protocol scheme. And you can ask it to load
 * the url using the default handler.
 */

Methods

impl nsIExternalProtocolService

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

Cast this nsIExternalProtocolService to one of its base interfaces.

impl nsIExternalProtocolService

pub unsafe fn ExternalProtocolHandlerExists(
    &self,
    aProtocolScheme: *const c_char,
    _retval: *mut bool
) -> nsresult

/**
   * Check whether a handler for a specific protocol exists.  Specifically,
   * this looks to see whether there are any known possible application handlers
   * in either the nsIHandlerService datastore or registered with the OS.
   *
   * @param aProtocolScheme The scheme from a url: http, ftp, mailto, etc.
   *
   * @return true if we have a handler and false otherwise.
   *
   * XXX shouldn't aProtocolScheme be an ACString like nsIURI::scheme?
   */

boolean externalProtocolHandlerExists (in string aProtocolScheme);

pub unsafe fn IsExposedProtocol(
    &self,
    aProtocolScheme: *const c_char,
    _retval: *mut bool
) -> nsresult

/**
   * Check whether a handler for a specific protocol is "exposed" as a visible
   * feature of the current application.
   *
   * An exposed protocol handler is one that can be used in all contexts.  A
   * non-exposed protocol handler is one that can only be used internally by the
   * application.  For example, a non-exposed protocol would not be loaded by the
   * application in response to a link click or a X-remote openURL command.
   * Instead, it would be deferred to the system's external protocol handler.
   * XXX shouldn't aProtocolScheme be an ACString like nsIURI::scheme?
   */

boolean isExposedProtocol (in string aProtocolScheme);

pub unsafe fn GetProtocolHandlerInfo(
    &self,
    aProtocolScheme: &nsACString,
    _retval: *mut *const nsIHandlerInfo
) -> nsresult

/**
   * Retrieve the handler for the given protocol.  If neither the application
   * nor the OS knows about a handler for the protocol, the object this method
   * returns will represent a default handler for unknown content.
   *
   * @param aProtocolScheme the scheme from a URL: http, ftp, mailto, etc.
   *
   * Note: aProtocolScheme should not include a trailing colon, which is part
   * of the URI syntax, not part of the scheme itself (i.e. pass "mailto" not
   * "mailto:").
   *
   * @return the handler, if any; otherwise a default handler
   */

nsIHandlerInfo getProtocolHandlerInfo (in ACString aProtocolScheme);

pub unsafe fn GetProtocolHandlerInfoFromOS(
    &self,
    aProtocolScheme: &nsACString,
    aFound: *mut bool,
    _retval: *mut *const nsIHandlerInfo
) -> nsresult

/**
   * Given a scheme, looks up the protocol info from the OS.  This should be
   * overridden by each OS's implementation.
   *
   * @param aScheme The protocol scheme we are looking for.
   * @param aFound  Was an OS default handler for this scheme found?
   * @return An nsIHanderInfo for the protocol.
   */

nsIHandlerInfo getProtocolHandlerInfoFromOS (in ACString aProtocolScheme, out boolean aFound);

pub unsafe fn SetProtocolHandlerDefaults(
    &self,
    aHandlerInfo: *const nsIHandlerInfo,
    aOSHandlerExists: bool
) -> nsresult

/**
   * Set some sane defaults for a protocol handler object.
   *
   * @param aHandlerInfo      nsIHandlerInfo object, as returned by
   *                          getProtocolHandlerInfoFromOS
   * @param aOSHandlerExists  was the object above created for an extant
   *                          OS default handler?  This is generally the
   *                          value of the aFound out param from
   *                          getProtocolHandlerInfoFromOS.
   */

void setProtocolHandlerDefaults (in nsIHandlerInfo aHandlerInfo, in boolean aOSHandlerExists);

pub unsafe fn LoadURI(
    &self,
    aURI: *const nsIURI,
    aWindowContext: *const nsIInterfaceRequestor
) -> nsresult

/**
   * Used to load a URI via an external application. Might prompt the user for
   * permission to load the external application.
   *
   * @param aURI
   *        The URI to load
   *
   * @param aWindowContext
   *        The window to parent the dialog against, and, if a web handler
   *        is chosen, it is loaded in this window as well.  This parameter
   *        may be ultimately passed nsIURILoader.openURI in the case of a
   *        web handler, and aWindowContext is null or not present, web
   *        handlers will fail.  We need to do better than that; bug 394483
   *        filed in order to track.
   *
   * @note  Embedders that do not expose the http protocol should not currently
   *        use web-based protocol handlers, as handoff won't work correctly
   *        (bug 394479).
   */

void loadURI (in nsIURI aURI, [optional] in nsIInterfaceRequestor aWindowContext);

pub unsafe fn GetApplicationDescription(
    &self,
    aScheme: &nsACString,
    _retval: &mut nsAString
) -> nsresult

/**
   * Gets a human-readable description for the application responsible for
   * handling a specific protocol.
   *
   * @param aScheme The scheme to look up. For example, "mms".
   *
   * @throw NS_ERROR_NOT_IMPLEMENTED
   *        If getting descriptions for protocol helpers is not supported
   * @throw NS_ERROR_NOT_AVAILABLE
   *        If no protocol helper exists for this scheme, or if it is not
   *        possible to get a description for it.
   */

AString getApplicationDescription (in AUTF8String aScheme);

Methods from Deref<Target = nsISupports>

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

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIExternalProtocolService

const IID: nsIID

IID: nsIID = nsID(1895381882, 16070, 19403, [176, 147, 146, 217, 152, 76, 159, 131])

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 nsIExternalProtocolService

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIExternalProtocolService

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.