Struct xpcom::interfaces::nsILoadGroup

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

interface nsILoadGroup : nsIRequest

Methods

impl nsILoadGroup

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

Cast this nsILoadGroup to one of its base interfaces.

impl nsILoadGroup

pub unsafe fn GetGroupObserver(
    &self,
    aGroupObserver: *mut *const nsIRequestObserver
) -> nsresult

/**
 * A load group maintains a collection of nsIRequest objects.
 * This is used in lots of places where groups of requests need to be tracked.
 * For example, nsIDocument::mDocumentLoadGroup is used to track all requests
 * made for subdocuments in order to track page load progress and allow all
 * requests made on behalf of the document to be stopped, etc.
 */
/**
     * The group observer is notified when requests are added to and removed
     * from this load group.  The groupObserver is weak referenced.
     */

attribute nsIRequestObserver groupObserver;

pub unsafe fn SetGroupObserver(
    &self,
    aGroupObserver: *const nsIRequestObserver
) -> nsresult

/**
 * A load group maintains a collection of nsIRequest objects.
 * This is used in lots of places where groups of requests need to be tracked.
 * For example, nsIDocument::mDocumentLoadGroup is used to track all requests
 * made for subdocuments in order to track page load progress and allow all
 * requests made on behalf of the document to be stopped, etc.
 */
/**
     * The group observer is notified when requests are added to and removed
     * from this load group.  The groupObserver is weak referenced.
     */

attribute nsIRequestObserver groupObserver;

pub unsafe fn GetDefaultLoadRequest(
    &self,
    aDefaultLoadRequest: *mut *const nsIRequest
) -> nsresult

/**
     * Accesses the default load request for the group.  Each time a number
     * of requests are added to a group, the defaultLoadRequest may be set
     * to indicate that all of the requests are related to a base request.
     *
     * The load group inherits its load flags from the default load request.
     * If the default load request is NULL, then the group's load flags are
     * not changed.
     */

attribute nsIRequest defaultLoadRequest;

pub unsafe fn SetDefaultLoadRequest(
    &self,
    aDefaultLoadRequest: *const nsIRequest
) -> nsresult

/**
     * Accesses the default load request for the group.  Each time a number
     * of requests are added to a group, the defaultLoadRequest may be set
     * to indicate that all of the requests are related to a base request.
     *
     * The load group inherits its load flags from the default load request.
     * If the default load request is NULL, then the group's load flags are
     * not changed.
     */

attribute nsIRequest defaultLoadRequest;

pub unsafe fn AddRequest(
    &self,
    aRequest: *const nsIRequest,
    aContext: *const nsISupports
) -> nsresult

/**
     * Adds a new request to the group.  This will cause the default load
     * flags to be applied to the request.  If this is a foreground
     * request then the groupObserver's onStartRequest will be called.
     *
     * If the request is the default load request or if the default load
     * request is null, then the load group will inherit its load flags from
     * the request.
     */

void addRequest (in nsIRequest aRequest, in nsISupports aContext);

pub unsafe fn RemoveRequest(
    &self,
    aRequest: *const nsIRequest,
    aContext: *const nsISupports,
    aStatus: nsresult
) -> nsresult

/**
     * Removes a request from the group.  If this is a foreground request
     * then the groupObserver's onStopRequest will be called.
     *
     * By the time this call ends, aRequest will have been removed from the
     * loadgroup, even if this function throws an exception.
     */

void removeRequest (in nsIRequest aRequest, in nsISupports aContext, in nsresult aStatus);

pub unsafe fn GetRequests(
    &self,
    aRequests: *mut *const nsISimpleEnumerator
) -> nsresult

/**
     * Returns the requests contained directly in this group.
     * Enumerator element type: nsIRequest.
     */

readonly attribute nsISimpleEnumerator requests;

pub unsafe fn GetActiveCount(&self, aActiveCount: *mut uint32_t) -> nsresult

/**
     * Returns the count of "active" requests (ie. requests without the
     * LOAD_BACKGROUND bit set).
     */

readonly attribute unsigned long activeCount;

pub unsafe fn GetNotificationCallbacks(
    &self,
    aNotificationCallbacks: *mut *const nsIInterfaceRequestor
) -> nsresult

/**
     * Notification callbacks for the load group.
     */

attribute nsIInterfaceRequestor notificationCallbacks;

pub unsafe fn SetNotificationCallbacks(
    &self,
    aNotificationCallbacks: *const nsIInterfaceRequestor
) -> nsresult

/**
     * Notification callbacks for the load group.
     */

attribute nsIInterfaceRequestor notificationCallbacks;

pub unsafe fn GetRequestContextID(
    &self,
    aRequestContextID: *mut uint64_t
) -> nsresult

/**
     * Context for managing things like js/css connection blocking,
     * and per-tab connection grouping.
     */

readonly attribute unsigned long long requestContextID;

pub unsafe fn GetDefaultLoadFlags(
    &self,
    aDefaultLoadFlags: *mut nsLoadFlags
) -> nsresult

/**
     * The set of load flags that will be added to all new requests added to
     * this group. Any existing requests in the load group are not modified,
     * so it is expected these flags will be added before requests are added
     * to the group - typically via nsIDocShell::defaultLoadFlags on a new
     * docShell.
     * Note that these flags are *not* added to the default request for the
     * load group; it is expected the default request will already have these
     * flags (again, courtesy of setting nsIDocShell::defaultLoadFlags before
     * the docShell has created the default request.)
     */

attribute nsLoadFlags defaultLoadFlags;

pub unsafe fn SetDefaultLoadFlags(
    &self,
    aDefaultLoadFlags: nsLoadFlags
) -> nsresult

/**
     * The set of load flags that will be added to all new requests added to
     * this group. Any existing requests in the load group are not modified,
     * so it is expected these flags will be added before requests are added
     * to the group - typically via nsIDocShell::defaultLoadFlags on a new
     * docShell.
     * Note that these flags are *not* added to the default request for the
     * load group; it is expected the default request will already have these
     * flags (again, courtesy of setting nsIDocShell::defaultLoadFlags before
     * the docShell has created the default request.)
     */

attribute nsLoadFlags defaultLoadFlags;

pub unsafe fn GetUserAgentOverrideCache(
    &self,
    aUserAgentOverrideCache: &mut nsACString
) -> nsresult

/**
     * The cached user agent override created by UserAgentOverrides.jsm. Used
     * for all sub-resource requests in the loadgroup.
     */

attribute ACString userAgentOverrideCache;

pub unsafe fn SetUserAgentOverrideCache(
    &self,
    aUserAgentOverrideCache: &nsACString
) -> nsresult

/**
     * The cached user agent override created by UserAgentOverrides.jsm. Used
     * for all sub-resource requests in the loadgroup.
     */

attribute ACString userAgentOverrideCache;

Methods from Deref<Target = nsIRequest>

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

Cast this nsIRequest to one of its base interfaces.

pub const LOAD_REQUESTMASK: i64

pub const LOAD_NORMAL: i64

pub const LOAD_BACKGROUND: i64

pub const LOAD_HTML_OBJECT_DATA: i64

pub const LOAD_DOCUMENT_NEEDS_COOKIE: i64

pub const INHIBIT_CACHING: i64

pub const INHIBIT_PERSISTENT_CACHING: i64

pub const LOAD_BYPASS_CACHE: i64

pub const LOAD_FROM_CACHE: i64

pub const VALIDATE_ALWAYS: i64

pub const VALIDATE_NEVER: i64

pub const VALIDATE_ONCE_PER_SESSION: i64

pub const LOAD_ANONYMOUS: i64

pub const LOAD_FRESH_CONNECTION: i64

pub unsafe fn GetName(&self, aName: &mut nsACString) -> nsresult

/**
     * The name of the request.  Often this is the URI of the request.
     */

readonly attribute AUTF8String name;

pub unsafe fn IsPending(&self, _retval: *mut bool) -> nsresult

/**
     * Indicates whether the request is pending. nsIRequest::isPending is
     * true when there is an outstanding asynchronous event that will make
     * the request no longer be pending.  Requests do not necessarily start
     * out pending; in some cases, requests have to be explicitly initiated
     * (e.g. nsIChannel implementations are only pending once asyncOpen
     * returns successfully).
     *
     * Requests can become pending multiple times during their lifetime.
     *
     * @return TRUE if the request has yet to reach completion.
     * @return FALSE if the request has reached completion (e.g., after
     *   OnStopRequest has fired).
     * @note Suspended requests are still considered pending.
     */

boolean isPending ();

pub unsafe fn GetStatus(&self, aStatus: *mut nsresult) -> nsresult

/**
     * The error status associated with the request.
     */

readonly attribute nsresult status;

pub unsafe fn Cancel(&self, aStatus: nsresult) -> nsresult

/**
     * Cancels the current request.  This will close any open input or
     * output streams and terminate any async requests.  Users should
     * normally pass NS_BINDING_ABORTED, although other errors may also
     * be passed.  The error passed in will become the value of the
     * status attribute.
     *
     * Implementations must not send any notifications (e.g. via
     * nsIRequestObserver) synchronously from this function. Similarly,
     * removal from the load group (if any) must also happen asynchronously.
     *
     * Requests that use nsIStreamListener must not call onDataAvailable
     * anymore after cancel has been called.
     *
     * @param aStatus the reason for canceling this request.
     *
     * NOTE: most nsIRequest implementations expect aStatus to be a
     * failure code; however, some implementations may allow aStatus to
     * be a success code such as NS_OK.  In general, aStatus should be
     * a failure code.
     */

void cancel (in nsresult aStatus);

pub unsafe fn Suspend(&self) -> nsresult

/**
     * Suspends the current request.  This may have the effect of closing
     * any underlying transport (in order to free up resources), although
     * any open streams remain logically opened and will continue delivering
     * data when the transport is resumed.
     *
     * Calling cancel() on a suspended request must not send any
     * notifications (such as onstopRequest) until the request is resumed.
     *
     * NOTE: some implementations are unable to immediately suspend, and
     * may continue to deliver events already posted to an event queue. In
     * general, callers should be capable of handling events even after
     * suspending a request.
     */

void suspend ();

pub unsafe fn Resume(&self) -> nsresult

/**
     * Resumes the current request.  This may have the effect of re-opening
     * any underlying transport and will resume the delivery of data to
     * any open streams.
     */

void resume ();

pub unsafe fn GetLoadGroup(
    &self,
    aLoadGroup: *mut *const nsILoadGroup
) -> nsresult

/**
     * The load group of this request.  While pending, the request is a
     * member of the load group.  It is the responsibility of the request
     * to implement this policy.
     */

attribute nsILoadGroup loadGroup;

pub unsafe fn SetLoadGroup(&self, aLoadGroup: *const nsILoadGroup) -> nsresult

/**
     * The load group of this request.  While pending, the request is a
     * member of the load group.  It is the responsibility of the request
     * to implement this policy.
     */

attribute nsILoadGroup loadGroup;

pub unsafe fn GetLoadFlags(&self, aLoadFlags: *mut nsLoadFlags) -> nsresult

/**
     * The load flags of this request.  Bits 0-15 are reserved.
     *
     * When added to a load group, this request's load flags are merged with
     * the load flags of the load group.
     */

attribute nsLoadFlags loadFlags;

pub unsafe fn SetLoadFlags(&self, aLoadFlags: nsLoadFlags) -> nsresult

/**
     * The load flags of this request.  Bits 0-15 are reserved.
     *
     * When added to a load group, this request's load flags are merged with
     * the load flags of the load group.
     */

attribute nsLoadFlags loadFlags;

Trait Implementations

impl XpCom for nsILoadGroup

const IID: nsIID

IID: nsIID = nsID(4039669541, 31285, 17980, [156, 235, 44, 7, 242, 52, 6, 204])

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 nsILoadGroup

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsILoadGroup

type Target = nsIRequest

The resulting type after dereferencing.

fn deref(&self) -> &nsIRequest

Dereferences the value.