Struct xpcom::interfaces::nsIIncrementalDownload

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

interface nsIIncrementalDownload : nsIRequest

/**
 * An incremental download object attempts to fetch a file piecemeal over time
 * in an effort to minimize network bandwidth usage.
 *
 * Canceling a background download does not cause the file on disk to be
 * deleted.
 */

Methods

impl nsIIncrementalDownload

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

Cast this nsIIncrementalDownload to one of its base interfaces.

impl nsIIncrementalDownload

pub unsafe fn Init(
    &self,
    uri: *const nsIURI,
    destination: *const nsIFile,
    chunkSize: int32_t,
    intervalInSeconds: int32_t
) -> nsresult

/**
   * Initialize the incremental download object.  If the destination file
   * already exists, then only the remaining portion of the file will be
   * fetched.
   *
   * NOTE: The downloader will create the destination file if it does not
   * already exist.  It will create the file with the permissions 0600 if
   * needed.  To affect the permissions of the file, consumers of this
   * interface may create an empty file at the specified destination prior to
   * starting the incremental download.
   *
   * NOTE: Since this class may create a temporary file at the specified
   * destination, it is advisable for the consumer of this interface to specify
   * a file name for the destination that would not tempt the user into
   * double-clicking it.  For example, it might be wise to append a file
   * extension like ".part" to the end of the destination to protect users from
   * accidentally running "blah.exe" before it is a complete file.
   *
   * @param uri
   *        The URI to fetch.
   * @param destination
   *        The location where the file is to be stored.
   * @param chunkSize
   *        The size of the chunks to fetch.  A non-positive value results in
   *        the default chunk size being used.
   * @param intervalInSeconds
   *        The amount of time to wait between fetching chunks.  Pass a
   *        negative to use the default interval, or 0 to fetch the remaining
   *        part of the file in one chunk.
   */

void init (in nsIURI uri, in nsIFile destination, in long chunkSize, in long intervalInSeconds);

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

/**
   * The URI being fetched.
   */

readonly attribute nsIURI URI;

pub unsafe fn GetFinalURI(&self, aFinalURI: *mut *const nsIURI) -> nsresult

/**
   * The URI being fetched after any redirects have been followed.  This
   * attribute is set just prior to calling OnStartRequest on the observer
   * passed to the start method.
   */

readonly attribute nsIURI finalURI;

pub unsafe fn GetDestination(
    &self,
    aDestination: *mut *const nsIFile
) -> nsresult

/**
   * The file where the download is being written.
   */

readonly attribute nsIFile destination;

pub unsafe fn GetTotalSize(&self, aTotalSize: *mut int64_t) -> nsresult

/**
   * The total number of bytes for the requested file.  This attribute is set
   * just prior to calling OnStartRequest on the observer passed to the start
   * method.
   *
   * This attribute has a value of -1 if the total size is unknown.
   */

readonly attribute long long totalSize;

pub unsafe fn GetCurrentSize(&self, aCurrentSize: *mut int64_t) -> nsresult

/**
   * The current number of bytes downloaded so far.  This attribute is set just
   * prior to calling OnStartRequest on the observer passed to the start
   * method.
   *
   * This attribute has a value of -1 if the current size is unknown.
   */

readonly attribute long long currentSize;

pub unsafe fn Start(
    &self,
    observer: *const nsIRequestObserver,
    ctxt: *const nsISupports
) -> nsresult

/**
   * Start the incremental download.
   *
   * @param observer
   *        An observer to be notified of various events.  OnStartRequest is
   *        called when finalURI and totalSize have been determined or when an
   *        error occurs.  OnStopRequest is called when the file is completely
   *        downloaded or when an error occurs.  If this object implements
   *        nsIProgressEventSink, then its OnProgress method will be called as
   *        data is written to the destination file.  If this object implements
   *        nsIInterfaceRequestor, then it will be assigned as the underlying
   *        channel's notification callbacks, which allows it to provide a
   *        nsIAuthPrompt implementation if needed by the channel, for example.
   * @param ctxt
   *        User defined object forwarded to the observer's methods.
   */

void start (in nsIRequestObserver observer, in nsISupports ctxt);

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 nsIIncrementalDownload

const IID: nsIID

IID: nsIID = nsID(1720156735, 22212, 17949, [147, 161, 127, 108, 183, 223, 191, 186])

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 nsIIncrementalDownload

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIIncrementalDownload

type Target = nsIRequest

The resulting type after dereferencing.

fn deref(&self) -> &nsIRequest

Dereferences the value.