Struct xpcom::interfaces::nsIOfflineCacheUpdateService

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

interface nsIOfflineCacheUpdateService : nsISupports

Methods

impl nsIOfflineCacheUpdateService

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

Cast this nsIOfflineCacheUpdateService to one of its base interfaces.

impl nsIOfflineCacheUpdateService

pub const ALLOW_NO_WARN: i64

ALLOW_NO_WARN: i64 = 3

/**
     * Constants for the offline-app permission.
     *
     * XXX: This isn't a great place for this, but it's really the only
     * private offline-app-related interface
     */
/**
     * Allow the domain to use offline APIs, and don't warn about excessive
     * usage.
     */

pub unsafe fn GetNumUpdates(&self, aNumUpdates: *mut uint32_t) -> nsresult

/**
     * Access to the list of cache updates that have been scheduled.
     */

readonly attribute unsigned long numUpdates;

pub unsafe fn GetUpdate(
    &self,
    index: uint32_t,
    _retval: *mut *const nsIOfflineCacheUpdate
) -> nsresult

nsIOfflineCacheUpdate getUpdate (in unsigned long index);

pub unsafe fn ScheduleUpdate(
    &self,
    aManifestURI: *const nsIURI,
    aDocumentURI: *const nsIURI,
    aLoadingPrincipal: *const nsIPrincipal,
    aWindow: *const mozIDOMWindow,
    _retval: *mut *const nsIOfflineCacheUpdate
) -> nsresult

/**
     * Schedule a cache update for a given offline manifest.  If an
     * existing update is scheduled or running, that update will be returned.
     * Otherwise a new update will be scheduled.
     */

nsIOfflineCacheUpdate scheduleUpdate (in nsIURI aManifestURI, in nsIURI aDocumentURI, in nsIPrincipal aLoadingPrincipal, in mozIDOMWindow aWindow);

pub unsafe fn ScheduleAppUpdate(
    &self,
    aManifestURI: *const nsIURI,
    aDocumentURI: *const nsIURI,
    aLoadingPrincipal: *const nsIPrincipal,
    aProfileDir: *const nsIFile,
    _retval: *mut *const nsIOfflineCacheUpdate
) -> nsresult

/**
     * Schedule a cache update for a given offline manifest using app cache
     * bound to the given appID+inIsolatedMozBrowser flag.  If an existing update
     * is scheduled or running, that update will be returned. Otherwise a new
     * update will be scheduled.
     */

nsIOfflineCacheUpdate scheduleAppUpdate (in nsIURI aManifestURI, in nsIURI aDocumentURI, in nsIPrincipal aLoadingPrincipal, in nsIFile aProfileDir);

pub unsafe fn ScheduleOnDocumentStop(
    &self,
    aManifestURI: *const nsIURI,
    aDocumentURI: *const nsIURI,
    aLoadingPrincipal: *const nsIPrincipal,
    aDocument: *const nsIDOMDocument
) -> nsresult

/**
     * Schedule a cache update for a manifest when the document finishes
     * loading.
     */

void scheduleOnDocumentStop (in nsIURI aManifestURI, in nsIURI aDocumentURI, in nsIPrincipal aLoadingPrincipal, in nsIDOMDocument aDocument);

pub unsafe fn CheckForUpdate(
    &self,
    aManifestURI: *const nsIURI,
    aLoadingPrincipal: *const nsIPrincipal,
    aObserver: *const nsIObserver
) -> nsresult

/**
     * Schedule a check to see if an update is available.
     *
     * This will not update or make any changes to the appcache.
     * It only notifies the observer to indicate whether the manifest has
     * changed on the server (or not): a changed manifest means that an
     * update is available.
     *
     * For arguments see nsIOfflineCacheUpdate.initForUpdateCheck() method
     * description.
     */

void checkForUpdate (in nsIURI aManifestURI, in nsIPrincipal aLoadingPrincipal, in nsIObserver aObserver);

pub unsafe fn OfflineAppAllowed(
    &self,
    aPrincipal: *const nsIPrincipal,
    aPrefBranch: *const nsIPrefBranch,
    _retval: *mut bool
) -> nsresult

/**
     * Checks whether a principal should have access to the offline
     * cache.
     * @param aPrincipal
     *        The principal to check.
     * @param aPrefBranch
     *        The pref branch to use to check the
     *        offline-apps.allow_by_default pref.  If not specified,
     *        the pref service will be used.
     */

boolean offlineAppAllowed (in nsIPrincipal aPrincipal, in nsIPrefBranch aPrefBranch);

pub unsafe fn OfflineAppAllowedForURI(
    &self,
    aURI: *const nsIURI,
    aPrefBranch: *const nsIPrefBranch,
    _retval: *mut bool
) -> nsresult

/**
     * Checks whether a document at the given URI should have access
     * to the offline cache.
     * @param aURI
     *        The URI to check
     * @param aPrefBranch
     *        The pref branch to use to check the
     *        offline-apps.allow_by_default pref.  If not specified,
     *        the pref service will be used.
     */

boolean offlineAppAllowedForURI (in nsIURI aURI, in nsIPrefBranch aPrefBranch);

pub unsafe fn AllowOfflineApp(
    &self,
    aPrincipal: *const nsIPrincipal
) -> nsresult

/**
     * Sets the "offline-app" permission for the principal.
     * In the single process model calls directly on permission manager.
     * In the multi process model dispatches to the parent process.
     */

void allowOfflineApp (in nsIPrincipal aPrincipal);

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 nsIOfflineCacheUpdateService

const IID: nsIID

IID: nsIID = nsID(1150754420, 14308, 16704, [134, 119, 164, 207, 33, 58, 63, 75])

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 nsIOfflineCacheUpdateService

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIOfflineCacheUpdateService

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.