diff options
Diffstat (limited to 'toolkit/components/bitsdownload/Bits.sys.mjs')
| -rw-r--r-- | toolkit/components/bitsdownload/Bits.sys.mjs | 826 |
1 files changed, 826 insertions, 0 deletions
diff --git a/toolkit/components/bitsdownload/Bits.sys.mjs b/toolkit/components/bitsdownload/Bits.sys.mjs new file mode 100644 index 0000000000..3248d2effa --- /dev/null +++ b/toolkit/components/bitsdownload/Bits.sys.mjs @@ -0,0 +1,826 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/** + * This module is used to interact with the Windows BITS component (Background + * Intelligent Transfer Service). This functionality cannot be used unless on + * Windows. + * + * The reason for this file's existence is that the interfaces in nsIBits.idl + * are asynchronous, but are unable to use Promises because they are implemented + * in Rust, which does not yet support Promises. This file functions as a layer + * between the Rust and the JS that provides access to the functionality + * provided by nsIBits via Promises rather than callbacks. + */ + +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +// This conditional prevents errors if this file is imported from operating +// systems other than Windows. This is purely for convenient importing, because +// attempting to use anything in this file on platforms other than Windows will +// result in an error. +if (AppConstants.MOZ_BITS_DOWNLOAD) { + XPCOMUtils.defineLazyServiceGetter( + lazy, + "gBits", + "@mozilla.org/bits;1", + "nsIBits" + ); +} + +// This value exists to mitigate a very unlikely problem: If a BITS method +// catastrophically fails, it may never call its callback. This would result in +// methods in this file returning promises that never resolve. This could, in +// turn, lead to download code hanging altogether rather than being able to +// report errors and utilize fallback mechanisms. +// This problem is mitigated by giving these promises a timeout, the length of +// which will be determined by this value. +const kBitsMethodTimeoutMs = 10 * 60 * 1000; // 10 minutes + +/** + * This class will wrap the errors returned by the nsIBits interface to make + * them more uniform and more easily consumable. + * + * The values of stored by this error type are entirely numeric. This should + * make them easier to consume with JS and telemetry, but does make them fairly + * unreadable. nsIBits.idl will need to be referenced to look up what errors + * the values correspond to. + * + * The type of BitsError.code is dependent on the value of BitsError.codeType. + * It may be null, a number (corresponding to an nsresult or hresult value), + * a string, or an exception. + */ +export class BitsError extends Error { + // If codeType == "none", code may be unspecified. + constructor(type, action, stage, codeType, code) { + let message = + `${BitsError.name} {type: ${type}, action: ${action}, ` + + `stage: ${stage}`; + switch (codeType) { + case lazy.gBits.ERROR_CODE_TYPE_NONE: + code = null; + message += ", codeType: none}"; + break; + case lazy.gBits.ERROR_CODE_TYPE_NSRESULT: + message += `, codeType: nsresult, code: ${code}}`; + break; + case lazy.gBits.ERROR_CODE_TYPE_HRESULT: + message += `, codeType: hresult, code: ${code}}`; + break; + case lazy.gBits.ERROR_CODE_TYPE_STRING: + message += `, codeType: string, code: ${JSON.stringify(code)}}`; + break; + case lazy.gBits.ERROR_CODE_TYPE_EXCEPTION: + message += `, codeType: exception, code: ${code}}`; + break; + default: + message += ", codeType: invalid}"; + break; + } + super(message); + + this.type = type; + this.action = action; + this.stage = stage; + this.codeType = codeType; + this.code = code; + this.name = this.constructor.name; + this.succeeded = false; + } +} + +// These specializations exist to make them easier to construct since they may +// need to be constructed outside of this file. +export class BitsVerificationError extends BitsError { + constructor() { + super( + Ci.nsIBits.ERROR_TYPE_VERIFICATION_FAILURE, + Ci.nsIBits.ERROR_ACTION_NONE, + Ci.nsIBits.ERROR_STAGE_VERIFICATION, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } +} + +export class BitsUnknownError extends BitsError { + constructor() { + super( + Ci.nsIBits.ERROR_TYPE_UNKNOWN, + Ci.nsIBits.ERROR_ACTION_UNKNOWN, + Ci.nsIBits.ERROR_STAGE_UNKNOWN, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } +} + +/** + * Returns a timer object. If the timer expires, reject will be called with + * a BitsError error. The timer's cancel method should be called if the promise + * resolves or rejects without the timeout expiring. + */ +function makeTimeout(reject, errorAction) { + let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + timer.initWithCallback( + () => { + let error = new BitsError( + lazy.gBits.ERROR_TYPE_METHOD_TIMEOUT, + errorAction, + lazy.gBits.ERROR_STAGE_UNKNOWN, + lazy.gBits.ERROR_CODE_TYPE_NONE + ); + reject(error); + }, + kBitsMethodTimeoutMs, + Ci.nsITimer.TYPE_ONE_SHOT + ); + return timer; +} + +/** + * This function does all of the wrapping and error handling for an async + * BitsRequest method. This allows the implementations for those methods to + * simply call this function with a closure that executes appropriate + * nsIBitsRequest method. + * + * Specifically, this function takes an nsBitsErrorAction and a function. + * The nsBitsErrorAction will be used when constructing a BitsError, if the + * wrapper encounters an error. + * The function will be passed the callback function that should be passed to + * the nsIBitsRequest method. + */ +async function requestPromise(errorAction, actionFn) { + return new Promise((resolve, reject) => { + let timer = makeTimeout(reject, errorAction); + + let callback = { + QueryInterface: ChromeUtils.generateQI(["nsIBitsCallback"]), + success() { + timer.cancel(); + resolve(); + }, + failure(type, action, stage) { + timer.cancel(); + let error = new BitsError( + type, + action, + stage, + lazy.gBits.ERROR_CODE_TYPE_NONE + ); + reject(error); + }, + failureNsresult(type, action, stage, code) { + timer.cancel(); + let error = new BitsError( + type, + action, + stage, + lazy.gBits.ERROR_CODE_TYPE_NSRESULT, + code + ); + reject(error); + }, + failureHresult(type, action, stage, code) { + timer.cancel(); + let error = new BitsError( + type, + action, + stage, + lazy.gBits.ERROR_CODE_TYPE_HRESULT, + code + ); + reject(error); + }, + failureString(type, action, stage, message) { + timer.cancel(); + let error = new BitsError( + type, + action, + stage, + lazy.gBits.ERROR_CODE_TYPE_STRING, + message + ); + reject(error); + }, + }; + + try { + actionFn(callback); + } catch (e) { + let error = new BitsError( + lazy.gBits.ERROR_TYPE_METHOD_THREW, + errorAction, + lazy.gBits.ERROR_STAGE_PRETASK, + lazy.gBits.ERROR_CODE_TYPE_EXCEPTION, + e + ); + reject(error); + } + }); +} + +/** + * This class is a wrapper around nsIBitsRequest that converts functions taking + * callbacks to asynchronous functions. This class implements nsIRequest. + * + * Note that once the request has been shutdown, calling methods on it will + * cause an exception to be thrown. The request will be shutdown automatically + * when the BITS job is successfully completed or cancelled. If the request is + * no longer needed, but the transfer is still in progress, the shutdown method + * should be called manually to prevent memory leaks. + * Getter methods (except loadGroup and loadFlags) should continue to be + * accessible, even after shutdown. + */ +export class BitsRequest { + constructor(request) { + this._request = request; + this._request.QueryInterface(Ci.nsIBitsRequest); + } + + /** + * This function releases the Rust request that backs this wrapper. Calling + * any method on this request after calling release will result in a BitsError + * being thrown. + * + * This step is important, because otherwise a cycle exists that the cycle + * collector doesn't know about. To break this cycle, either the Rust request + * needs to let go of the observer, or the JS request wrapper needs to let go + * of the Rust request (which is what we do here). + * + * Once there is support for cycle collection of cycles that extend through + * Rust, this function may no longer be necessary. + */ + shutdown() { + if (this.hasShutdown) { + return; + } + // Cache some values before we shut down so they are still available + this._name = this._request.name; + this._status = this._request.status; + this._bitsId = this._request.bitsId; + this._transferError = this._request.transferError; + + this._request = null; + } + + /** + * Allows consumers to determine if this request has been shutdown. + */ + get hasShutdown() { + return !this._request; + } + + /** + * This is the nsIRequest implementation. Since this._request is an + * nsIRequest, these functions just call the corresponding method on it. + * + * Note that nsIBitsRequest does not yet properly implement load groups or + * load flags. This class will still forward those calls, but they will have + * not succeed. + */ + get name() { + if (!this._request) { + return this._name; + } + return this._request.name; + } + isPending() { + if (!this._request) { + return false; + } + return this._request.isPending(); + } + get status() { + if (!this._request) { + return this._status; + } + return this._request.status; + } + cancel(status) { + return this.cancelAsync(status); + } + suspend() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_SUSPEND, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + return this._request.suspend(); + } + resume() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_RESUME, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + return this._request.resume(); + } + get loadGroup() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_NONE, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + return this._request.loadGroup; + } + set loadGroup(group) { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_NONE, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + this._request.loadGroup = group; + } + get loadFlags() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_NONE, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + return this._request.loadFlags; + } + set loadFlags(flags) { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_NONE, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + this._request.loadFlags = flags; + } + + /** + * This function wraps nsIBitsRequest::bitsId. + */ + get bitsId() { + if (!this._request) { + return this._bitsId; + } + return this._request.bitsId; + } + + /** + * This function wraps nsIBitsRequest::transferError. + * + * Instead of simply returning the nsBitsErrorType value, however, it returns + * a BitsError object, or null. + */ + get transferError() { + let result; + if (this._request) { + result = this._request.transferError; + } else { + result = this._transferError; + } + if (result == Ci.nsIBits.ERROR_TYPE_SUCCESS) { + return null; + } + return new BitsError( + result, + Ci.nsIBits.ERROR_ACTION_NONE, + Ci.nsIBits.ERROR_STAGE_MONITOR, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + + /** + * This function wraps nsIBitsRequest::changeMonitorInterval. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with no data, or rejects with a BitsError. + */ + async changeMonitorInterval(monitorIntervalMs) { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_CHANGE_MONITOR_INTERVAL, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + let action = lazy.gBits.ERROR_ACTION_CHANGE_MONITOR_INTERVAL; + return requestPromise(action, callback => { + this._request.changeMonitorInterval(monitorIntervalMs, callback); + }); + } + + /** + * This function wraps nsIBitsRequest::cancelAsync. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with no data, or rejects with a BitsError. + * + * Adds a default status of NS_ERROR_ABORT if one is not provided. + */ + async cancelAsync(status) { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_CANCEL, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + if (status === undefined) { + status = Cr.NS_ERROR_ABORT; + } + let action = lazy.gBits.ERROR_ACTION_CANCEL; + return requestPromise(action, callback => { + this._request.cancelAsync(status, callback); + }).then(() => this.shutdown()); + } + + /** + * This function wraps nsIBitsRequest::setPriorityHigh. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with no data, or rejects with a BitsError. + */ + async setPriorityHigh() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_SET_PRIORITY, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + let action = lazy.gBits.ERROR_ACTION_SET_PRIORITY; + return requestPromise(action, callback => { + this._request.setPriorityHigh(callback); + }); + } + + /** + * This function wraps nsIBitsRequest::setPriorityLow. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with no data, or rejects with a BitsError. + */ + async setPriorityLow() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_SET_PRIORITY, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + let action = lazy.gBits.ERROR_ACTION_SET_PRIORITY; + return requestPromise(action, callback => { + this._request.setPriorityLow(callback); + }); + } + + /** + * This function wraps nsIBitsRequest::setNoProgressTimeout. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with no data, or rejects with a BitsError. + */ + async setNoProgressTimeout(timeoutSecs) { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_SET_NO_PROGRESS_TIMEOUT, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + let action = lazy.gBits.ERROR_ACTION_SET_NO_PROGRESS_TIMEOUT; + return requestPromise(action, callback => { + this._request.setNoProgressTimeout(timeoutSecs, callback); + }); + } + + /** + * This function wraps nsIBitsRequest::complete. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with no data, or rejects with a BitsError. + */ + async complete() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_COMPLETE, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + let action = lazy.gBits.ERROR_ACTION_COMPLETE; + return requestPromise(action, callback => { + this._request.complete(callback); + }).then(() => this.shutdown()); + } + + /** + * This function wraps nsIBitsRequest::suspendAsync. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with no data, or rejects with a BitsError. + */ + async suspendAsync() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_SUSPEND, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + let action = lazy.gBits.ERROR_ACTION_SUSPEND; + return requestPromise(action, callback => { + this._request.suspendAsync(callback); + }); + } + + /** + * This function wraps nsIBitsRequest::resumeAsync. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with no data, or rejects with a BitsError. + */ + async resumeAsync() { + if (!this._request) { + throw new BitsError( + Ci.nsIBits.ERROR_TYPE_USE_AFTER_REQUEST_SHUTDOWN, + Ci.nsIBits.ERROR_ACTION_RESUME, + Ci.nsIBits.ERROR_STAGE_PRETASK, + Ci.nsIBits.ERROR_CODE_TYPE_NONE + ); + } + let action = lazy.gBits.ERROR_ACTION_RESUME; + return requestPromise(action, callback => { + this._request.resumeAsync(callback); + }); + } +} + +BitsRequest.prototype.QueryInterface = ChromeUtils.generateQI(["nsIRequest"]); + +/** + * This function does all of the wrapping and error handling for an async + * Bits Service method. This allows the implementations for those methods to + * simply call this function with a closure that executes appropriate + * nsIBits method. + * + * Specifically, this function takes an nsBitsErrorAction, an observer and a + * function. + * The nsBitsErrorAction will be used when constructing a BitsError, if the + * wrapper encounters an error. + * The observer should be the one that the caller passed to the Bits Interface + * method. It will be wrapped so that its methods are passed a BitsRequest + * rather than an nsIBitsRequest. + * The function will be passed the callback function and the wrapped observer, + * both of which should be passed to the nsIBitsRequest method. + */ +async function servicePromise(errorAction, observer, actionFn) { + return new Promise((resolve, reject) => { + if (!observer) { + let error = new BitsError( + lazy.gBits.ERROR_TYPE_NULL_ARGUMENT, + errorAction, + lazy.gBits.ERROR_STAGE_PRETASK, + lazy.gBits.ERROR_CODE_TYPE_NONE + ); + reject(error); + return; + } + try { + observer.QueryInterface(Ci.nsIRequestObserver); + } catch (e) { + let error = new BitsError( + lazy.gBits.ERROR_TYPE_INVALID_ARGUMENT, + errorAction, + lazy.gBits.ERROR_STAGE_PRETASK, + lazy.gBits.ERROR_CODE_TYPE_EXCEPTION, + e + ); + reject(error); + return; + } + let isProgressEventSink = false; + try { + observer.QueryInterface(Ci.nsIProgressEventSink); + isProgressEventSink = true; + } catch (e) {} + + // Check if we are not late in creating new requests. + if ( + Services && + Services.startup && + Services.startup.isInOrBeyondShutdownPhase( + Ci.nsIAppStartup.SHUTDOWN_PHASE_APPSHUTDOWNCONFIRMED + ) + ) { + let error = new BitsError( + lazy.gBits.ERROR_TYPE_BROWSER_SHUTTING_DOWN, + errorAction, + lazy.gBits.ERROR_STAGE_PRETASK, + lazy.gBits.ERROR_CODE_TYPE_NONE + ); + reject(error); + return; + } + + // This will be set to the BitsRequest (wrapping the nsIBitsRequest), once + // it is available. This prevents a new wrapper from having to be made every + // time an observer function is called. + let wrappedRequest; + + let wrappedObserver = { + onStartRequest: function wrappedObserver_onStartRequest(request) { + if (!wrappedRequest) { + wrappedRequest = new BitsRequest(request); + } + observer.onStartRequest(wrappedRequest); + }, + onStopRequest: function wrappedObserver_onStopRequest(request, status) { + if (!wrappedRequest) { + wrappedRequest = new BitsRequest(request); + } + observer.onStopRequest(wrappedRequest, status); + }, + onProgress: function wrappedObserver_onProgress( + request, + progress, + progressMax + ) { + if (isProgressEventSink) { + if (!wrappedRequest) { + wrappedRequest = new BitsRequest(request); + } + observer.onProgress(wrappedRequest, progress, progressMax); + } + }, + onStatus: function wrappedObserver_onStatus(request, status, statusArg) { + if (isProgressEventSink) { + if (!wrappedRequest) { + wrappedRequest = new BitsRequest(request); + } + observer.onStatus(wrappedRequest, status, statusArg); + } + }, + QueryInterface: ChromeUtils.generateQI([ + "nsIRequestObserver", + "nsIProgressEventSink", + ]), + }; + + let timer = makeTimeout(reject, errorAction); + let callback = { + QueryInterface: ChromeUtils.generateQI(["nsIBitsNewRequestCallback"]), + success(request) { + timer.cancel(); + if (!wrappedRequest) { + wrappedRequest = new BitsRequest(request); + } + resolve(wrappedRequest); + }, + failure(type, action, stage) { + timer.cancel(); + let error = new BitsError( + type, + action, + stage, + lazy.gBits.ERROR_CODE_TYPE_NONE + ); + reject(error); + }, + failureNsresult(type, action, stage, code) { + timer.cancel(); + let error = new BitsError( + type, + action, + stage, + lazy.gBits.ERROR_CODE_TYPE_NSRESULT, + code + ); + reject(error); + }, + failureHresult(type, action, stage, code) { + timer.cancel(); + let error = new BitsError( + type, + action, + stage, + lazy.gBits.ERROR_CODE_TYPE_HRESULT, + code + ); + reject(error); + }, + failureString(type, action, stage, message) { + timer.cancel(); + let error = new BitsError( + type, + action, + stage, + lazy.gBits.ERROR_CODE_TYPE_STRING, + message + ); + reject(error); + }, + }; + + try { + actionFn(wrappedObserver, callback); + } catch (e) { + let error = new BitsError( + lazy.gBits.ERROR_TYPE_METHOD_THREW, + errorAction, + lazy.gBits.ERROR_STAGE_PRETASK, + lazy.gBits.ERROR_CODE_TYPE_EXCEPTION, + e + ); + reject(error); + } + }); +} + +export var Bits = { + /** + * This function wraps nsIBits::initialized. + */ + get initialized() { + return lazy.gBits.initialized; + }, + + /** + * This function wraps nsIBits::init. + */ + init(jobName, savePathPrefix, monitorTimeoutMs) { + return lazy.gBits.init(jobName, savePathPrefix, monitorTimeoutMs); + }, + + /** + * This function wraps nsIBits::startDownload. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with a BitsRequest (which is also an + * nsIRequest), or rejects with a BitsError. + */ + async startDownload( + downloadURL, + saveRelPath, + proxy, + noProgressTimeoutSecs, + monitorIntervalMs, + observer, + context + ) { + let action = lazy.gBits.ERROR_ACTION_START_DOWNLOAD; + return servicePromise(action, observer, (wrappedObserver, callback) => { + lazy.gBits.startDownload( + downloadURL, + saveRelPath, + proxy, + noProgressTimeoutSecs, + monitorIntervalMs, + wrappedObserver, + context, + callback + ); + }); + }, + + /** + * This function wraps nsIBits::monitorDownload. + * + * Instead of taking a callback, the function is asynchronous. + * This method either resolves with a BitsRequest (which is also an + * nsIRequest), or rejects with a BitsError. + */ + async monitorDownload(id, monitorIntervalMs, observer, context) { + let action = lazy.gBits.ERROR_ACTION_MONITOR_DOWNLOAD; + return servicePromise(action, observer, (wrappedObserver, callback) => { + lazy.gBits.monitorDownload( + id, + monitorIntervalMs, + wrappedObserver, + context, + callback + ); + }); + }, +}; |