diff options
Diffstat (limited to 'toolkit/components/bitsdownload/src/bits_interface')
13 files changed, 3619 insertions, 0 deletions
diff --git a/toolkit/components/bitsdownload/src/bits_interface/action.rs b/toolkit/components/bitsdownload/src/bits_interface/action.rs new file mode 100644 index 0000000000..1019e29827 --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/action.rs @@ -0,0 +1,118 @@ +/* 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/. */ + +//! `Action` is an enum describing what BITS action is being processed. This is +//! used mostly for logging and error reporting reasons. +//! The values of `Action` describe actions that could be in progress for +//! BitsService or BitsRequest. When specifying a type, `ServiceAction` or +//! `RequestAction`, can be used to restrict the action type to one of the two +//! categories. +//! A value of type `ServiceAction` or `RequestAction` can easily be converted +//! to an `Action` using the `into()` method. + +use std::convert::From; +use xpcom::interfaces::nsIBits; + +#[derive(Debug, PartialEq, Eq, Clone, Copy)] +pub enum Action { + StartDownload, + MonitorDownload, + Complete, + Cancel, + SetMonitorInterval, + SetPriority, + SetNoProgressTimeout, + Resume, + Suspend, +} + +impl Action { + pub fn description(&self) -> &'static str { + match self { + Action::StartDownload => "starting download", + Action::MonitorDownload => "monitoring download", + Action::Complete => "completing download", + Action::Cancel => "cancelling download", + Action::SetMonitorInterval => "changing monitor interval", + Action::SetPriority => "setting download priority", + Action::SetNoProgressTimeout => "setting no progress timeout", + Action::Resume => "resuming download", + Action::Suspend => "suspending download", + } + } + + pub fn as_error_code(&self) -> i32 { + match self { + Action::StartDownload => nsIBits::ERROR_ACTION_START_DOWNLOAD, + Action::MonitorDownload => nsIBits::ERROR_ACTION_MONITOR_DOWNLOAD, + Action::Complete => nsIBits::ERROR_ACTION_COMPLETE, + Action::Cancel => nsIBits::ERROR_ACTION_CANCEL, + Action::SetMonitorInterval => nsIBits::ERROR_ACTION_CHANGE_MONITOR_INTERVAL, + Action::SetPriority => nsIBits::ERROR_ACTION_SET_PRIORITY, + Action::SetNoProgressTimeout => nsIBits::ERROR_ACTION_SET_NO_PROGRESS_TIMEOUT, + Action::Resume => nsIBits::ERROR_ACTION_RESUME, + Action::Suspend => nsIBits::ERROR_ACTION_SUSPEND, + } + } +} + +#[derive(Debug, PartialEq, Clone, Copy)] +pub enum ServiceAction { + StartDownload, + MonitorDownload, +} + +impl From<ServiceAction> for Action { + fn from(action: ServiceAction) -> Action { + match action { + ServiceAction::StartDownload => Action::StartDownload, + ServiceAction::MonitorDownload => Action::MonitorDownload, + } + } +} + +impl ServiceAction { + pub fn as_error_code(&self) -> i32 { + Action::as_error_code(&(self.clone()).into()) + } + + pub fn description(&self) -> &'static str { + Action::description(&(self.clone()).into()) + } +} + +#[derive(Debug, PartialEq, Clone, Copy)] +pub enum RequestAction { + Complete, + Cancel, + SetMonitorInterval, + SetPriority, + SetNoProgressTimeout, + Resume, + Suspend, +} + +impl From<RequestAction> for Action { + fn from(action: RequestAction) -> Action { + match action { + RequestAction::Complete => Action::Complete, + RequestAction::Cancel => Action::Cancel, + RequestAction::SetMonitorInterval => Action::SetMonitorInterval, + RequestAction::SetPriority => Action::SetPriority, + RequestAction::SetNoProgressTimeout => Action::SetNoProgressTimeout, + RequestAction::Resume => Action::Resume, + RequestAction::Suspend => Action::Suspend, + } + } +} + +impl RequestAction { + pub fn as_error_code(&self) -> i32 { + Action::as_error_code(&(self.clone()).into()) + } + + pub fn description(&self) -> &'static str { + Action::description(&(self.clone()).into()) + } +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/dispatch_callback.rs b/toolkit/components/bitsdownload/src/bits_interface/dispatch_callback.rs new file mode 100644 index 0000000000..b42637a993 --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/dispatch_callback.rs @@ -0,0 +1,199 @@ +/* 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/. */ +use super::{ + error::{BitsTaskError, ErrorCode, ErrorType}, + BitsRequest, +}; +use log::{error, info, warn}; +use nserror::{nsresult, NS_ERROR_FAILURE, NS_OK}; +use xpcom::{ + interfaces::{nsIBitsCallback, nsIBitsNewRequestCallback}, + RefPtr, +}; + +#[derive(Debug, PartialEq, Clone, Copy)] +pub enum IsCallbackExpected { + CallbackExpected, + CallbackOptional, +} +pub use self::IsCallbackExpected::{CallbackExpected, CallbackOptional}; + +// This is meant to be called at the end of a nsIBits Task. It attempts to +// return the result via the callback given. If the callback is unavailable, a +// log message will be printed indicating the results and (possibly) warning +// than an expected callback was missing. +pub fn maybe_dispatch_request_via_callback( + result: Result<RefPtr<BitsRequest>, BitsTaskError>, + maybe_callback: Result<&nsIBitsNewRequestCallback, BitsTaskError>, + expected: IsCallbackExpected, +) -> Result<(), nsresult> { + if let Err(error) = maybe_callback.as_ref() { + if expected == CallbackExpected || error.error_type == ErrorType::CallbackOnWrongThread { + error!( + "Unexpected error when {} - No callback: {:?}", + error.error_action.description(), + error, + ); + } + } + match result { + Ok(request) => match (maybe_callback, expected) { + (Ok(callback), _) => unsafe { callback.Success(request.coerce()) }, + (Err(error), CallbackExpected) => { + error!( + "Success {} but there is no callback to return the result with", + error.error_action.description(), + ); + NS_ERROR_FAILURE + } + (Err(error), CallbackOptional) => { + info!("Success {}", error.error_action.description()); + NS_OK + } + }, + Err(error) => match (maybe_callback, expected) { + (Ok(callback), _) => match error.error_code { + ErrorCode::None => unsafe { + callback.Failure( + error.error_type.bits_code(), + error.error_action.as_error_code(), + error.error_stage.bits_code(), + ) + }, + ErrorCode::Hresult(error_code) => unsafe { + callback.FailureHresult( + error.error_type.bits_code(), + error.error_action.as_error_code(), + error.error_stage.bits_code(), + error_code, + ) + }, + ErrorCode::Nsresult(error_code) => unsafe { + callback.FailureNsresult( + error.error_type.bits_code(), + error.error_action.as_error_code(), + error.error_stage.bits_code(), + error_code, + ) + }, + ErrorCode::Message(message) => unsafe { + callback.FailureString( + error.error_type.bits_code(), + error.error_action.as_error_code(), + error.error_stage.bits_code(), + &*message, + ) + }, + }, + (Err(_), CallbackExpected) => { + error!("Error {}: {:?}", error.error_action.description(), error); + NS_ERROR_FAILURE + } + (Err(_), CallbackOptional) => { + warn!("Error {}: {:?}", error.error_action.description(), error); + NS_ERROR_FAILURE + } + }, + } + .to_result() +} + +// Intended to be used by an nsIBits XPCOM wrapper to return errors that occur +// before dispatching a task off-thread. No return value is returned because it +// will represent the return value of the callback function, which should not be +// propagated. +pub fn dispatch_pretask_interface_error( + error: BitsTaskError, + callback: &nsIBitsNewRequestCallback, +) { + let _ = maybe_dispatch_request_via_callback(Err(error), Ok(callback), CallbackExpected); +} + +// This is meant to be called at the end of a nsIBitsRequest Task. It attempts +// to return the result via the callback given. If the callback is unavailable, +// a log message will be printed indicating the results and (possibly) warning +// than an expected callback was missing. +pub fn maybe_dispatch_via_callback( + result: Result<(), BitsTaskError>, + maybe_callback: Result<&nsIBitsCallback, BitsTaskError>, + expected: IsCallbackExpected, +) -> Result<(), nsresult> { + if let Err(error) = maybe_callback.as_ref() { + if expected == CallbackExpected || error.error_type == ErrorType::CallbackOnWrongThread { + error!( + "Unexpected error when {} - No callback: {:?}", + error.error_action.description(), + error, + ); + } + } + match result { + Ok(()) => match (maybe_callback, expected) { + (Ok(callback), _) => unsafe { callback.Success() }, + (Err(error), CallbackExpected) => { + error!( + "Success {} but there is no callback to return the result with", + error.error_action.description(), + ); + NS_ERROR_FAILURE + } + (Err(error), CallbackOptional) => { + info!("Success {}", error.error_action.description()); + NS_OK + } + }, + Err(error) => match (maybe_callback, expected) { + (Ok(callback), _) => match error.error_code { + ErrorCode::None => unsafe { + callback.Failure( + error.error_type.bits_code(), + error.error_action.as_error_code(), + error.error_stage.bits_code(), + ) + }, + ErrorCode::Hresult(error_code) => unsafe { + callback.FailureHresult( + error.error_type.bits_code(), + error.error_action.as_error_code(), + error.error_stage.bits_code(), + error_code, + ) + }, + ErrorCode::Nsresult(error_code) => unsafe { + callback.FailureNsresult( + error.error_type.bits_code(), + error.error_action.as_error_code(), + error.error_stage.bits_code(), + error_code, + ) + }, + ErrorCode::Message(message) => unsafe { + callback.FailureString( + error.error_type.bits_code(), + error.error_action.as_error_code(), + error.error_stage.bits_code(), + &*message, + ) + }, + }, + (Err(_), CallbackExpected) => { + error!("Error {}: {:?}", error.error_action.description(), error); + NS_ERROR_FAILURE + } + (Err(_), CallbackOptional) => { + warn!("Error {}: {:?}", error.error_action.description(), error); + NS_ERROR_FAILURE + } + }, + } + .to_result() +} + +// Intended to be used by an nsIBitsRequest XPCOM wrapper to return errors that +// occur before dispatching a task off-thread. No return value is returned +// because it will represent the return value of the callback function, which +// should not be propagated. +pub fn dispatch_pretask_request_error(error: BitsTaskError, callback: &nsIBitsCallback) { + let _ = maybe_dispatch_via_callback(Err(error), Ok(callback), CallbackExpected); +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/error.rs b/toolkit/components/bitsdownload/src/bits_interface/error.rs new file mode 100644 index 0000000000..c046ae5e70 --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/error.rs @@ -0,0 +1,686 @@ +/* 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/. */ +use super::action::Action; +use bits_client::{ + bits_protocol::{ + CancelJobFailure, CompleteJobFailure, HResultMessage, MonitorJobFailure, ResumeJobFailure, + SetJobPriorityFailure, SetNoProgressTimeoutFailure, SetUpdateIntervalFailure, + StartJobFailure, SuspendJobFailure, + }, + PipeError, +}; +use comedy::error::HResult as ComedyError; +use nserror::{nsresult, NS_ERROR_FAILURE}; +use nsstring::nsCString; +use std::convert::From; +use xpcom::interfaces::nsIBits; + +#[derive(Debug, PartialEq, Clone, Copy)] +pub enum ErrorType { + NullArgument, + InvalidArgument, + NotInitialized, + NoUtf8Conversion, + InvalidGuid, + PipeNotConnected, + PipeTimeout, + PipeBadWriteCount, + PipeApiError, + FailedToCreateBitsJob, + FailedToAddFileToJob, + FailedToApplyBitsJobSettings, + FailedToResumeBitsJob, + OtherBitsError, + OtherBitsClientError, + BitsJobNotFound, + FailedToGetBitsJob, + FailedToSuspendBitsJob, + FailedToCompleteBitsJob, + PartiallyCompletedBitsJob, + FailedToCancelBitsJob, + MissingResultData, + MissingCallback, + CallbackOnWrongThread, + MissingBitsService, + BitsServiceOnWrongThread, + MissingBitsRequest, + BitsRequestOnWrongThread, + MissingObserver, + ObserverOnWrongThread, + MissingContext, + ContextOnWrongThread, + FailedToStartThread, + FailedToConstructTaskRunnable, + FailedToDispatchRunnable, + TransferAlreadyComplete, + OperationAlreadyInProgress, + MissingBitsClient, + FailedToGetJobStatus, + BitsStateError, + BitsStateTransientError, + BitsStateCancelled, + BitsStateUnexpected, + FailedToConnectToBcm, +} + +impl ErrorType { + pub fn bits_code(&self) -> i32 { + match self { + ErrorType::NullArgument => nsIBits::ERROR_TYPE_NULL_ARGUMENT, + ErrorType::InvalidArgument => nsIBits::ERROR_TYPE_INVALID_ARGUMENT, + ErrorType::NotInitialized => nsIBits::ERROR_TYPE_NOT_INITIALIZED, + ErrorType::NoUtf8Conversion => nsIBits::ERROR_TYPE_NO_UTF8_CONVERSION, + ErrorType::InvalidGuid => nsIBits::ERROR_TYPE_INVALID_GUID, + ErrorType::PipeNotConnected => nsIBits::ERROR_TYPE_PIPE_NOT_CONNECTED, + ErrorType::PipeTimeout => nsIBits::ERROR_TYPE_PIPE_TIMEOUT, + ErrorType::PipeBadWriteCount => nsIBits::ERROR_TYPE_PIPE_BAD_WRITE_COUNT, + ErrorType::PipeApiError => nsIBits::ERROR_TYPE_PIPE_API_ERROR, + ErrorType::FailedToCreateBitsJob => nsIBits::ERROR_TYPE_FAILED_TO_CREATE_BITS_JOB, + ErrorType::FailedToAddFileToJob => nsIBits::ERROR_TYPE_FAILED_TO_ADD_FILE_TO_JOB, + ErrorType::FailedToApplyBitsJobSettings => { + nsIBits::ERROR_TYPE_FAILED_TO_APPLY_BITS_JOB_SETTINGS + } + ErrorType::FailedToResumeBitsJob => nsIBits::ERROR_TYPE_FAILED_TO_RESUME_BITS_JOB, + ErrorType::OtherBitsError => nsIBits::ERROR_TYPE_OTHER_BITS_ERROR, + ErrorType::OtherBitsClientError => nsIBits::ERROR_TYPE_OTHER_BITS_CLIENT_ERROR, + ErrorType::BitsJobNotFound => nsIBits::ERROR_TYPE_BITS_JOB_NOT_FOUND, + ErrorType::FailedToGetBitsJob => nsIBits::ERROR_TYPE_FAILED_TO_GET_BITS_JOB, + ErrorType::FailedToSuspendBitsJob => nsIBits::ERROR_TYPE_FAILED_TO_SUSPEND_BITS_JOB, + ErrorType::FailedToCompleteBitsJob => nsIBits::ERROR_TYPE_FAILED_TO_COMPLETE_BITS_JOB, + ErrorType::PartiallyCompletedBitsJob => { + nsIBits::ERROR_TYPE_PARTIALLY_COMPLETED_BITS_JOB + } + ErrorType::FailedToCancelBitsJob => nsIBits::ERROR_TYPE_FAILED_TO_CANCEL_BITS_JOB, + ErrorType::MissingResultData => nsIBits::ERROR_TYPE_MISSING_RESULT_DATA, + ErrorType::MissingCallback => nsIBits::ERROR_TYPE_MISSING_CALLBACK, + ErrorType::CallbackOnWrongThread => nsIBits::ERROR_TYPE_CALLBACK_ON_WRONG_THREAD, + ErrorType::MissingBitsService => nsIBits::ERROR_TYPE_MISSING_BITS_SERVICE, + ErrorType::BitsServiceOnWrongThread => nsIBits::ERROR_TYPE_BITS_SERVICE_ON_WRONG_THREAD, + ErrorType::MissingBitsRequest => nsIBits::ERROR_TYPE_MISSING_BITS_REQUEST, + ErrorType::BitsRequestOnWrongThread => nsIBits::ERROR_TYPE_BITS_REQUEST_ON_WRONG_THREAD, + ErrorType::MissingObserver => nsIBits::ERROR_TYPE_MISSING_OBSERVER, + ErrorType::ObserverOnWrongThread => nsIBits::ERROR_TYPE_OBSERVER_ON_WRONG_THREAD, + ErrorType::MissingContext => nsIBits::ERROR_TYPE_MISSING_CONTEXT, + ErrorType::ContextOnWrongThread => nsIBits::ERROR_TYPE_CONTEXT_ON_WRONG_THREAD, + ErrorType::FailedToStartThread => nsIBits::ERROR_TYPE_FAILED_TO_START_THREAD, + ErrorType::FailedToConstructTaskRunnable => { + nsIBits::ERROR_TYPE_FAILED_TO_CONSTRUCT_TASK_RUNNABLE + } + ErrorType::FailedToDispatchRunnable => nsIBits::ERROR_TYPE_FAILED_TO_DISPATCH_RUNNABLE, + ErrorType::TransferAlreadyComplete => nsIBits::ERROR_TYPE_TRANSFER_ALREADY_COMPLETE, + ErrorType::OperationAlreadyInProgress => { + nsIBits::ERROR_TYPE_OPERATION_ALREADY_IN_PROGRESS + } + ErrorType::MissingBitsClient => nsIBits::ERROR_TYPE_MISSING_BITS_CLIENT, + ErrorType::FailedToGetJobStatus => nsIBits::ERROR_TYPE_FAILED_TO_GET_JOB_STATUS, + ErrorType::BitsStateError => nsIBits::ERROR_TYPE_BITS_STATE_ERROR, + ErrorType::BitsStateTransientError => nsIBits::ERROR_TYPE_BITS_STATE_TRANSIENT_ERROR, + ErrorType::BitsStateCancelled => nsIBits::ERROR_TYPE_BITS_STATE_CANCELLED, + ErrorType::BitsStateUnexpected => nsIBits::ERROR_TYPE_BITS_STATE_UNEXPECTED, + ErrorType::FailedToConnectToBcm => nsIBits::ERROR_TYPE_FAILED_TO_CONNECT_TO_BCM, + } + } +} + +impl From<&PipeError> for ErrorType { + fn from(error: &PipeError) -> Self { + match error { + PipeError::NotConnected => ErrorType::PipeNotConnected, + PipeError::Timeout => ErrorType::PipeTimeout, + PipeError::WriteCount(_, _) => ErrorType::PipeBadWriteCount, + PipeError::Api(_) => ErrorType::PipeApiError, + } + } +} + +#[derive(Debug, PartialEq, Clone, Copy)] +pub enum ErrorStage { + Pretask, + CommandThread, + AgentCommunication, + BitsClient, + MainThread, +} + +impl ErrorStage { + pub fn bits_code(&self) -> i32 { + let val = match self { + ErrorStage::Pretask => nsIBits::ERROR_STAGE_PRETASK, + ErrorStage::CommandThread => nsIBits::ERROR_STAGE_COMMAND_THREAD, + ErrorStage::AgentCommunication => nsIBits::ERROR_STAGE_AGENT_COMMUNICATION, + ErrorStage::BitsClient => nsIBits::ERROR_STAGE_BITS_CLIENT, + ErrorStage::MainThread => nsIBits::ERROR_STAGE_MAIN_THREAD, + }; + val as i32 + } +} + +#[derive(Debug, Clone)] +pub enum ErrorCode { + None, + Hresult(i32), + Nsresult(nsresult), + Message(nsCString), +} + +impl From<ComedyError> for ErrorCode { + fn from(error: ComedyError) -> Self { + ErrorCode::Hresult(error.code()) + } +} + +impl From<HResultMessage> for ErrorCode { + fn from(result: HResultMessage) -> Self { + ErrorCode::Hresult(result.hr) + } +} + +#[derive(Debug, Clone)] +pub struct BitsTaskError { + pub error_type: ErrorType, + pub error_action: Action, + pub error_stage: ErrorStage, + pub error_code: ErrorCode, +} + +impl BitsTaskError { + pub fn new( + error_type: ErrorType, + error_action: Action, + error_stage: ErrorStage, + ) -> BitsTaskError { + BitsTaskError { + error_type, + error_action, + error_stage, + error_code: ErrorCode::None, + } + } + + pub fn missing_result(error_action: Action) -> BitsTaskError { + BitsTaskError { + error_type: ErrorType::MissingResultData, + error_action, + error_stage: ErrorStage::MainThread, + error_code: ErrorCode::None, + } + } + + pub fn from_nsresult( + error_type: ErrorType, + error_action: Action, + error_stage: ErrorStage, + error_code: nsresult, + ) -> BitsTaskError { + BitsTaskError { + error_type, + error_action, + error_stage, + error_code: ErrorCode::Nsresult(error_code), + } + } + + pub fn from_hresult( + error_type: ErrorType, + error_action: Action, + error_stage: ErrorStage, + error_code: i32, + ) -> BitsTaskError { + BitsTaskError { + error_type, + error_action, + error_stage, + error_code: ErrorCode::Hresult(error_code), + } + } + + pub fn from_comedy( + error_type: ErrorType, + error_action: Action, + error_stage: ErrorStage, + comedy_error: ComedyError, + ) -> BitsTaskError { + BitsTaskError { + error_type, + error_action, + error_stage, + error_code: comedy_error.into(), + } + } + + pub fn from_pipe(error_action: Action, pipe_error: PipeError) -> BitsTaskError { + let error_type = (&pipe_error).into(); + match pipe_error { + PipeError::Api(comedy_error) => BitsTaskError { + error_type, + error_action, + error_stage: ErrorStage::AgentCommunication, + error_code: comedy_error.into(), + }, + _ => BitsTaskError { + error_type, + error_action, + error_stage: ErrorStage::AgentCommunication, + error_code: ErrorCode::None, + }, + } + } +} + +impl From<BitsTaskError> for nsresult { + fn from(error: BitsTaskError) -> Self { + if let ErrorCode::Nsresult(rv) = error.error_code { + rv + } else { + NS_ERROR_FAILURE + } + } +} + +impl From<StartJobFailure> for BitsTaskError { + fn from(error: StartJobFailure) -> Self { + let error_stage = ErrorStage::BitsClient; + let error_action = Action::StartDownload; + match error { + StartJobFailure::ArgumentValidation(message) => BitsTaskError { + error_type: ErrorType::InvalidArgument, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + StartJobFailure::Create(error_code) => BitsTaskError { + error_type: ErrorType::FailedToCreateBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + StartJobFailure::AddFile(error_code) => BitsTaskError { + error_type: ErrorType::FailedToAddFileToJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + StartJobFailure::ApplySettings(error_code) => BitsTaskError { + error_type: ErrorType::FailedToApplyBitsJobSettings, + error_action, + error_stage, + error_code: error_code.into(), + }, + StartJobFailure::Resume(error_code) => BitsTaskError { + error_type: ErrorType::FailedToResumeBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + StartJobFailure::ConnectBcm(error_code) => BitsTaskError { + error_type: ErrorType::FailedToConnectToBcm, + error_action, + error_stage, + error_code: error_code.into(), + }, + StartJobFailure::OtherBITS(error_code) => BitsTaskError { + error_type: ErrorType::OtherBitsError, + error_action, + error_stage, + error_code: error_code.into(), + }, + StartJobFailure::Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} + +impl From<MonitorJobFailure> for BitsTaskError { + fn from(error: MonitorJobFailure) -> Self { + let error_stage = ErrorStage::BitsClient; + let error_action = Action::MonitorDownload; + match error { + MonitorJobFailure::ArgumentValidation(message) => BitsTaskError { + error_type: ErrorType::InvalidArgument, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + MonitorJobFailure::NotFound => BitsTaskError { + error_type: ErrorType::BitsJobNotFound, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + MonitorJobFailure::GetJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToGetBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + MonitorJobFailure::ConnectBcm(error_code) => BitsTaskError { + error_type: ErrorType::FailedToConnectToBcm, + error_action, + error_stage, + error_code: error_code.into(), + }, + MonitorJobFailure::OtherBITS(error_code) => BitsTaskError { + error_type: ErrorType::OtherBitsError, + error_action, + error_stage, + error_code: error_code.into(), + }, + MonitorJobFailure::Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} + +impl From<SuspendJobFailure> for BitsTaskError { + fn from(error: SuspendJobFailure) -> Self { + let error_stage = ErrorStage::BitsClient; + let error_action = Action::Suspend; + match error { + SuspendJobFailure::NotFound => BitsTaskError { + error_type: ErrorType::BitsJobNotFound, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + SuspendJobFailure::GetJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToGetBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + SuspendJobFailure::SuspendJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToSuspendBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + SuspendJobFailure::ConnectBcm(error_code) => BitsTaskError { + error_type: ErrorType::FailedToConnectToBcm, + error_action, + error_stage, + error_code: error_code.into(), + }, + SuspendJobFailure::OtherBITS(error_code) => BitsTaskError { + error_type: ErrorType::OtherBitsError, + error_action, + error_stage, + error_code: error_code.into(), + }, + SuspendJobFailure::Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} + +impl From<ResumeJobFailure> for BitsTaskError { + fn from(error: ResumeJobFailure) -> Self { + let error_stage = ErrorStage::BitsClient; + let error_action = Action::Resume; + match error { + ResumeJobFailure::NotFound => BitsTaskError { + error_type: ErrorType::BitsJobNotFound, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + ResumeJobFailure::GetJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToGetBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + ResumeJobFailure::ResumeJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToResumeBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + ResumeJobFailure::ConnectBcm(error_code) => BitsTaskError { + error_type: ErrorType::FailedToConnectToBcm, + error_action, + error_stage, + error_code: error_code.into(), + }, + ResumeJobFailure::OtherBITS(error_code) => BitsTaskError { + error_type: ErrorType::OtherBitsError, + error_action, + error_stage, + error_code: error_code.into(), + }, + ResumeJobFailure::Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} + +impl From<SetJobPriorityFailure> for BitsTaskError { + fn from(error: SetJobPriorityFailure) -> Self { + let error_stage = ErrorStage::BitsClient; + let error_action = Action::SetPriority; + match error { + SetJobPriorityFailure::NotFound => BitsTaskError { + error_type: ErrorType::BitsJobNotFound, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + SetJobPriorityFailure::GetJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToGetBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + SetJobPriorityFailure::ApplySettings(error_code) => BitsTaskError { + error_type: ErrorType::FailedToApplyBitsJobSettings, + error_action, + error_stage, + error_code: error_code.into(), + }, + SetJobPriorityFailure::ConnectBcm(error_code) => BitsTaskError { + error_type: ErrorType::FailedToConnectToBcm, + error_action, + error_stage, + error_code: error_code.into(), + }, + SetJobPriorityFailure::OtherBITS(error_code) => BitsTaskError { + error_type: ErrorType::OtherBitsError, + error_action, + error_stage, + error_code: error_code.into(), + }, + SetJobPriorityFailure::Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} + +impl From<SetNoProgressTimeoutFailure> for BitsTaskError { + fn from(error: SetNoProgressTimeoutFailure) -> Self { + use self::SetNoProgressTimeoutFailure::*; + + let error_stage = ErrorStage::BitsClient; + let error_action = Action::SetNoProgressTimeout; + match error { + NotFound => BitsTaskError { + error_type: ErrorType::BitsJobNotFound, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + GetJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToGetBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + ApplySettings(error_code) => BitsTaskError { + error_type: ErrorType::FailedToApplyBitsJobSettings, + error_action, + error_stage, + error_code: error_code.into(), + }, + ConnectBcm(error_code) => BitsTaskError { + error_type: ErrorType::FailedToConnectToBcm, + error_action, + error_stage, + error_code: error_code.into(), + }, + OtherBITS(error_code) => BitsTaskError { + error_type: ErrorType::OtherBitsError, + error_action, + error_stage, + error_code: error_code.into(), + }, + Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} + +impl From<SetUpdateIntervalFailure> for BitsTaskError { + fn from(error: SetUpdateIntervalFailure) -> Self { + let error_stage = ErrorStage::BitsClient; + let error_action = Action::SetMonitorInterval; + match error { + SetUpdateIntervalFailure::ArgumentValidation(message) => BitsTaskError { + error_type: ErrorType::InvalidArgument, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + SetUpdateIntervalFailure::NotFound => BitsTaskError { + error_type: ErrorType::BitsJobNotFound, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + SetUpdateIntervalFailure::Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} + +impl From<CompleteJobFailure> for BitsTaskError { + fn from(error: CompleteJobFailure) -> Self { + let error_stage = ErrorStage::BitsClient; + let error_action = Action::Complete; + match error { + CompleteJobFailure::NotFound => BitsTaskError { + error_type: ErrorType::BitsJobNotFound, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + CompleteJobFailure::GetJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToGetBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + CompleteJobFailure::CompleteJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToCompleteBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + CompleteJobFailure::PartialComplete => BitsTaskError { + error_type: ErrorType::PartiallyCompletedBitsJob, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + CompleteJobFailure::ConnectBcm(error_code) => BitsTaskError { + error_type: ErrorType::FailedToConnectToBcm, + error_action, + error_stage, + error_code: error_code.into(), + }, + CompleteJobFailure::OtherBITS(error_code) => BitsTaskError { + error_type: ErrorType::OtherBitsError, + error_action, + error_stage, + error_code: error_code.into(), + }, + CompleteJobFailure::Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} + +impl From<CancelJobFailure> for BitsTaskError { + fn from(error: CancelJobFailure) -> Self { + let error_stage = ErrorStage::BitsClient; + let error_action = Action::Cancel; + match error { + CancelJobFailure::NotFound => BitsTaskError { + error_type: ErrorType::BitsJobNotFound, + error_action, + error_stage, + error_code: ErrorCode::None, + }, + CancelJobFailure::GetJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToGetBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + CancelJobFailure::CancelJob(error_code) => BitsTaskError { + error_type: ErrorType::FailedToCancelBitsJob, + error_action, + error_stage, + error_code: error_code.into(), + }, + CancelJobFailure::ConnectBcm(error_code) => BitsTaskError { + error_type: ErrorType::FailedToConnectToBcm, + error_action, + error_stage, + error_code: error_code.into(), + }, + CancelJobFailure::OtherBITS(error_code) => BitsTaskError { + error_type: ErrorType::OtherBitsError, + error_action, + error_stage, + error_code: error_code.into(), + }, + CancelJobFailure::Other(message) => BitsTaskError { + error_type: ErrorType::OtherBitsClientError, + error_action, + error_stage, + error_code: ErrorCode::Message(nsCString::from(message)), + }, + } + } +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/mod.rs b/toolkit/components/bitsdownload/src/bits_interface/mod.rs new file mode 100644 index 0000000000..93d2ddeadd --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/mod.rs @@ -0,0 +1,329 @@ +/* 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/. */ +mod action; +mod dispatch_callback; +mod error; +mod monitor; +mod request; +mod string; +mod task; +mod xpcom_methods; + +pub use self::error::BitsTaskError; +use self::{ + action::Action, + error::{ + ErrorStage::Pretask, + ErrorType::{ + FailedToConstructTaskRunnable, FailedToDispatchRunnable, FailedToStartThread, + InvalidArgument, NotInitialized, + }, + }, + request::BitsRequest, + string::Guid_from_nsCString, + task::{ClientInitData, MonitorDownloadTask, StartDownloadTask}, +}; +use nsIBits_method; // From xpcom_method.rs + +use bits_client::BitsProxyUsage; +use log::{info, warn}; +use moz_task::{create_thread, Task, TaskRunnable}; +use nserror::{nsresult, NS_ERROR_ALREADY_INITIALIZED, NS_OK}; +use nsstring::{nsACString, nsCString}; +use std::cell::Cell; +use xpcom::{ + interfaces::{ + nsIBits, nsIBitsNewRequestCallback, nsIRequestObserver, nsISupports, nsIThread, + nsProxyUsage, + }, + xpcom, xpcom_method, RefPtr, +}; + +#[no_mangle] +pub unsafe extern "C" fn new_bits_service(result: *mut *const nsIBits) { + let service: RefPtr<BitsService> = BitsService::new(); + RefPtr::new(service.coerce::<nsIBits>()).forget(&mut *result); +} + +#[xpcom(implement(nsIBits), nonatomic)] +pub struct BitsService { + // This command thread will be used to send commands (ex: Suspend, Resume) + // to a running job. It will be started up when the first job is created and + // shutdown when all jobs have been completed or cancelled. + command_thread: Cell<Option<RefPtr<nsIThread>>>, + client_init_data: Cell<Option<ClientInitData>>, + // This count will track the number of in-progress requests so that the + // service knows when the command_thread is no longer being used and can be + // shut down. + // `BitsRequest::new()` will increment this and it will be decremented + // either when cancel/complete is called, or when the request is dropped + // (if it didn't decrement it already). + // The count will also be incremented when an action to create a request + // starts and decremented when the action ends and returns the result via + // the callback. This prevents the command thread from being shut down while + // a job is being created. + request_count: Cell<u32>, +} + +/// This implements the nsIBits interface, documented in nsIBits.idl, to enable +/// BITS job management. Specifically, this interface can start a download or +/// connect to an existing download. Doing so will create a BitsRequest through +/// which the transfer can be further manipulated. +/// +/// This is a primarily asynchronous interface, which is accomplished via +/// callbacks of type nsIBitsNewRequestCallback. The callback is passed in as +/// an argument and is then passed off-thread via a Task. The Task interacts +/// with BITS and is dispatched back to the main thread with the BITS result. +/// Back on the main thread, it returns that result via the callback including, +/// if successful, a BitsRequest. +impl BitsService { + pub fn new() -> RefPtr<BitsService> { + BitsService::allocate(InitBitsService { + command_thread: Cell::new(None), + client_init_data: Cell::new(None), + request_count: Cell::new(0), + }) + } + + fn get_client_init(&self) -> Option<ClientInitData> { + let maybe_init_data = self.client_init_data.take(); + self.client_init_data.set(maybe_init_data.clone()); + maybe_init_data + } + + // Returns the handle to the command thread. If it has not been started yet, + // the thread will be started. + fn get_command_thread(&self) -> Result<RefPtr<nsIThread>, nsresult> { + let mut command_thread = self.command_thread.take(); + if command_thread.is_none() { + command_thread.replace(create_thread("BitsCommander")?); + } + self.command_thread.set(command_thread.clone()); + Ok(command_thread.unwrap()) + } + + // Asynchronously shuts down the command thread. The thread is not shutdown + // until the event queue is empty, so any tasks that were dispatched before + // this is called will still run. + // Leaves None in self.command_thread + fn shutdown_command_thread(&self) { + if let Some(command_thread) = self.command_thread.take() { + if let Err(rv) = unsafe { command_thread.AsyncShutdown() }.to_result() { + warn!("Failed to shut down command thread: {}", rv); + warn!("Releasing reference to thread that failed to shut down!"); + } + } + } + + fn dispatch_runnable_to_command_thread( + &self, + task: Box<dyn Task + Send + Sync>, + task_runnable_name: &'static str, + action: Action, + ) -> Result<(), BitsTaskError> { + let command_thread = self + .get_command_thread() + .map_err(|rv| BitsTaskError::from_nsresult(FailedToStartThread, action, Pretask, rv))?; + let runnable = TaskRunnable::new(task_runnable_name, task).map_err(|rv| { + BitsTaskError::from_nsresult(FailedToConstructTaskRunnable, action, Pretask, rv) + })?; + TaskRunnable::dispatch(runnable, &command_thread).map_err(|rv| { + BitsTaskError::from_nsresult(FailedToDispatchRunnable, action, Pretask, rv) + }) + } + + fn inc_request_count(&self) { + self.request_count.set(self.request_count.get() + 1); + } + + fn dec_request_count(&self) { + let mut count = self.request_count.get(); + if count == 0 { + warn!("Attempted to decrement request count, but it is 0"); + return; + } + count -= 1; + self.request_count.set(count); + + if count == 0 { + self.shutdown_command_thread(); + } + } + + xpcom_method!( + get_initialized => GetInitialized() -> bool + ); + fn get_initialized(&self) -> Result<bool, nsresult> { + Ok(self.get_client_init().is_some()) + } + + xpcom_method!( + init => Init( + job_name: *const nsACString, + save_path_prefix: *const nsACString, + monitor_timeout_ms: u32 + ) + ); + fn init( + &self, + job_name: &nsACString, + save_path_prefix: &nsACString, + monitor_timeout_ms: u32, + ) -> Result<(), nsresult> { + let previous_data = self.client_init_data.take(); + if previous_data.is_some() { + self.client_init_data.set(previous_data); + return Err(NS_ERROR_ALREADY_INITIALIZED); + } + + info!( + "BitsService initialized with job_name: {}, save_path_prefix: {}, timeout: {}", + job_name, save_path_prefix, monitor_timeout_ms, + ); + + self.client_init_data.set(Some(ClientInitData::new( + nsCString::from(job_name), + nsCString::from(save_path_prefix), + monitor_timeout_ms, + ))); + + Ok(()) + } + + nsIBits_method!( + [Action::StartDownload] + start_download => StartDownload( + download_url: *const nsACString, + save_rel_path: *const nsACString, + proxy: nsProxyUsage, + no_progress_timeout_secs: u32, + update_interval_ms: u32, + observer: *const nsIRequestObserver, + [optional] context: *const nsISupports, + ) + ); + fn start_download( + &self, + download_url: &nsACString, + save_rel_path: &nsACString, + proxy: nsProxyUsage, + no_progress_timeout_secs: u32, + update_interval_ms: u32, + observer: &nsIRequestObserver, + context: Option<&nsISupports>, + callback: &nsIBitsNewRequestCallback, + ) -> Result<(), BitsTaskError> { + let client_init_data = self + .get_client_init() + .ok_or_else(|| BitsTaskError::new(NotInitialized, Action::StartDownload, Pretask))?; + if update_interval_ms >= client_init_data.monitor_timeout_ms { + return Err(BitsTaskError::new( + InvalidArgument, + Action::StartDownload, + Pretask, + )); + } + let proxy = match proxy { + nsIBits::PROXY_NONE => BitsProxyUsage::NoProxy, + nsIBits::PROXY_PRECONFIG => BitsProxyUsage::Preconfig, + nsIBits::PROXY_AUTODETECT => BitsProxyUsage::AutoDetect, + _ => { + return Err(BitsTaskError::new( + InvalidArgument, + Action::StartDownload, + Pretask, + )); + } + }; + + let task: Box<StartDownloadTask> = Box::new(StartDownloadTask::new( + client_init_data, + nsCString::from(download_url), + nsCString::from(save_rel_path), + proxy, + no_progress_timeout_secs, + update_interval_ms, + RefPtr::new(self), + RefPtr::new(observer), + context.map(RefPtr::new), + RefPtr::new(callback), + )); + + let dispatch_result = self.dispatch_runnable_to_command_thread( + task, + "BitsService::start_download", + Action::StartDownload, + ); + + if dispatch_result.is_ok() { + // Increment the request count when we dispatch an action to start + // a job, decrement it when the action completes. See the + // declaration of InitBitsService::request_count for details. + self.inc_request_count(); + } + + dispatch_result + } + + nsIBits_method!( + [Action::MonitorDownload] + monitor_download => MonitorDownload( + id: *const nsACString, + update_interval_ms: u32, + observer: *const nsIRequestObserver, + [optional] context: *const nsISupports, + ) + ); + fn monitor_download( + &self, + id: &nsACString, + update_interval_ms: u32, + observer: &nsIRequestObserver, + context: Option<&nsISupports>, + callback: &nsIBitsNewRequestCallback, + ) -> Result<(), BitsTaskError> { + let client_init_data = self + .get_client_init() + .ok_or_else(|| BitsTaskError::new(NotInitialized, Action::MonitorDownload, Pretask))?; + if update_interval_ms >= client_init_data.monitor_timeout_ms { + return Err(BitsTaskError::new( + InvalidArgument, + Action::MonitorDownload, + Pretask, + )); + } + let guid = Guid_from_nsCString(&nsCString::from(id), Action::MonitorDownload, Pretask)?; + + let task: Box<MonitorDownloadTask> = Box::new(MonitorDownloadTask::new( + client_init_data, + guid, + update_interval_ms, + RefPtr::new(self), + RefPtr::new(observer), + context.map(RefPtr::new), + RefPtr::new(callback), + )); + + let dispatch_result = self.dispatch_runnable_to_command_thread( + task, + "BitsService::monitor_download", + Action::MonitorDownload, + ); + + if dispatch_result.is_ok() { + // Increment the request count when we dispatch an action to start + // a job, decrement it when the action completes. See the + // declaration of InitBitsService::request_count for details. + self.inc_request_count(); + } + + dispatch_result + } +} + +impl Drop for BitsService { + fn drop(&mut self) { + self.shutdown_command_thread(); + } +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/monitor.rs b/toolkit/components/bitsdownload/src/bits_interface/monitor.rs new file mode 100644 index 0000000000..4332efe04b --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/monitor.rs @@ -0,0 +1,247 @@ +/* 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/. */ +use bits_interface::{error::ErrorType, BitsRequest}; + +use bits_client::{ + bits_protocol::HResultMessage, BitsJobState, BitsMonitorClient, Guid, JobStatus, PipeError, +}; +use crossbeam_utils::atomic::AtomicCell; +use log::error; +use moz_task::{get_main_thread, is_main_thread}; +use nserror::{nsresult, NS_ERROR_ABORT, NS_ERROR_FAILURE, NS_OK}; +use nsstring::{nsACString, nsCString}; +use xpcom::{ + interfaces::{nsIEventTarget, nsIThread}, + xpcom, xpcom_method, RefPtr, ThreadBoundRefPtr, +}; + +/// This function takes the output of BitsMonitorClient::get_status() and uses +/// it to determine whether the the transfer has started. If the argument +/// contains an error, the transfer is considered started because we also +/// consider a transfer stopped on error. +/// This function is used to determine whether the OnStartRequest and OnProgress +/// observer functions should be called. +fn transfer_started(status: &Result<Result<JobStatus, HResultMessage>, PipeError>) -> bool { + match status.as_ref() { + Ok(Ok(job_status)) => match job_status.state { + BitsJobState::Queued | BitsJobState::Connecting => false, + _ => true, + }, + Ok(Err(_)) => true, + Err(_) => true, + } +} + +/// This function takes the output of BitsMonitorClient::get_status() and uses +/// it to determine whether the the transfer has stopped. If the argument +/// contains an error, the transfer is considered stopped. +/// A number of things will be done when a transfer is completed, such as +/// calling the observer's OnStopRequest method. +fn transfer_completed(status: &Result<Result<JobStatus, HResultMessage>, PipeError>) -> bool { + match status.as_ref() { + Ok(Ok(job_status)) => match job_status.state { + BitsJobState::Error + | BitsJobState::Transferred + | BitsJobState::Acknowledged + | BitsJobState::Cancelled => true, + _ => false, + }, + Ok(Err(_)) => true, + Err(_) => true, + } +} + +/// BitsRequest implements nsIRequest, which means that it must be able to +/// provide an nsresult status code. This function provides such a status code +/// based on the output of BitsMonitorClient::get_status(). +fn status_to_nsresult(status: &Result<Result<JobStatus, HResultMessage>, PipeError>) -> nsresult { + match status.as_ref() { + Ok(Ok(job_status)) => match job_status.state { + BitsJobState::Cancelled => NS_ERROR_ABORT, + BitsJobState::Transferred | BitsJobState::Acknowledged => NS_OK, + _ => NS_ERROR_FAILURE, + }, + Ok(Err(_)) => NS_ERROR_FAILURE, + Err(_) => NS_ERROR_FAILURE, + } +} + +/// This function takes the output of BitsMonitorClient::get_status() and uses +/// it to determine the result value of the request. This will take the form of +/// an Optional ErrorType value with a None value indicating success. +fn status_to_request_result( + status: &Result<Result<JobStatus, HResultMessage>, PipeError>, +) -> Option<ErrorType> { + match status.as_ref() { + Ok(Ok(job_status)) => match job_status.state { + BitsJobState::Transferred | BitsJobState::Acknowledged => None, + BitsJobState::Cancelled => Some(ErrorType::BitsStateCancelled), + BitsJobState::Error => Some(ErrorType::BitsStateError), + BitsJobState::TransientError => Some(ErrorType::BitsStateTransientError), + _ => Some(ErrorType::BitsStateUnexpected), + }, + Ok(Err(_)) => Some(ErrorType::FailedToGetJobStatus), + Err(pipe_error) => Some(pipe_error.into()), + } +} + +/// MonitorRunnable is an nsIRunnable meant to be dispatched off thread. It will +/// perform the following actions: +/// 1. Call BitsMonitorClient::get_status and store the result. +/// 2. Dispatch itself back to the main thread. +/// 3. Report the status to the observer. +/// 4. If the transfer has finished, free its data and return, otherwise: +/// 5. Dispatch itself back to its original thread and repeat from step 1. +#[xpcom(implement(nsIRunnable, nsINamed), atomic)] +pub struct MonitorRunnable { + request: AtomicCell<Option<ThreadBoundRefPtr<BitsRequest>>>, + id: Guid, + timeout: u32, + monitor_client: AtomicCell<Option<BitsMonitorClient>>, + // This cell contains an Option, possibly containing the return value of + // BitsMonitorClient::get_status. + status: AtomicCell<Option<Result<Result<JobStatus, HResultMessage>, PipeError>>>, + request_started: AtomicCell<bool>, + in_error_state: AtomicCell<bool>, +} + +impl MonitorRunnable { + pub fn new( + request: RefPtr<BitsRequest>, + id: Guid, + timeout: u32, + monitor_client: BitsMonitorClient, + ) -> RefPtr<MonitorRunnable> { + MonitorRunnable::allocate(InitMonitorRunnable { + request: AtomicCell::new(Some(ThreadBoundRefPtr::new(request))), + id, + timeout, + monitor_client: AtomicCell::new(Some(monitor_client)), + status: AtomicCell::new(None), + request_started: AtomicCell::new(false), + in_error_state: AtomicCell::new(false), + }) + } + + pub fn dispatch(&self, thread: RefPtr<nsIThread>) -> Result<(), nsresult> { + unsafe { thread.DispatchFromScript(self.coerce(), nsIEventTarget::DISPATCH_NORMAL) } + .to_result() + } + + fn free_mainthread_data(&self) { + if is_main_thread() { + // This is not safe to free unless on the main thread + self.request.swap(None); + } else { + error!("Attempting to free data on the main thread, but not on the main thread"); + } + } + + xpcom_method!(run => Run()); + + /// This method is essentially a error-handling wrapper around try_run. + /// This is done to make it easier to ensure that main-thread data is freed + /// on the main thread. + pub fn run(&self) -> Result<(), nsresult> { + if self.in_error_state.load() { + self.free_mainthread_data(); + return Err(NS_ERROR_FAILURE); + } + + self.try_run().or_else(|error_message| { + error!("{}", error_message); + + // Once an error has been encountered, we need to free all of our + // data, but it all needs to be freed on the main thread. + self.in_error_state.store(true); + if is_main_thread() { + self.free_mainthread_data(); + Err(NS_ERROR_FAILURE) + } else { + self.dispatch(get_main_thread()?) + } + }) + } + + /// This function performs all the primary functionality of MonitorRunnable. + /// See the documentation for InitMonitorRunnable/MonitorRunnable for + /// details. + pub fn try_run(&self) -> Result<(), String> { + if !is_main_thread() { + let mut monitor_client = self + .monitor_client + .swap(None) + .ok_or("Missing monitor client")?; + self.status + .store(Some(monitor_client.get_status(self.timeout))); + self.monitor_client.store(Some(monitor_client)); + + let main_thread = + get_main_thread().map_err(|rv| format!("Unable to get main thread: {}", rv))?; + + self.dispatch(main_thread) + .map_err(|rv| format!("Unable to dispatch to main thread: {}", rv)) + } else { + let status = self.status.swap(None).ok_or("Missing status object")?; + let tb_request = self.request.swap(None).ok_or("Missing request")?; + + // This block bounds the scope for request to ensure that it ends + // before re-storing tb_request. + let maybe_next_thread: Option<RefPtr<nsIThread>> = { + let request = tb_request + .get_ref() + .ok_or("BitsRequest is on the wrong thread")?; + + if !self.request_started.load() && transfer_started(&status) { + self.request_started.store(true); + request.on_start(); + } + + if self.request_started.load() { + if let Ok(Ok(job_status)) = status.as_ref() { + let transferred_bytes = job_status.progress.transferred_bytes as i64; + let total_bytes = match job_status.progress.total_bytes { + Some(total) => total as i64, + None => -1i64, + }; + request.on_progress(transferred_bytes, total_bytes); + } + } + + if transfer_completed(&status) { + request.on_stop(Some(( + status_to_nsresult(&status), + status_to_request_result(&status), + ))); + + // Transfer completed. No need to dispatch back to the monitor thread. + None + } else { + Some( + request + .get_monitor_thread() + .ok_or("Missing monitor thread")?, + ) + } + }; + + self.request.store(Some(tb_request)); + + match maybe_next_thread { + Some(next_thread) => self + .dispatch(next_thread) + .map_err(|rv| format!("Unable to dispatch to thread: {}", rv)), + None => { + self.free_mainthread_data(); + Ok(()) + } + } + } + } + + xpcom_method!(get_name => GetName() -> nsACString); + fn get_name(&self) -> Result<nsCString, nsresult> { + Ok(nsCString::from("BitsRequest::Monitor")) + } +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/request.rs b/toolkit/components/bitsdownload/src/bits_interface/request.rs new file mode 100644 index 0000000000..460e3b4950 --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/request.rs @@ -0,0 +1,763 @@ +/* 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/. */ + +use super::{ + action::{Action, ServiceAction}, + error::{ + ErrorStage::{MainThread, Pretask}, + ErrorType, + ErrorType::{ + BitsStateCancelled, FailedToDispatchRunnable, FailedToStartThread, InvalidArgument, + OperationAlreadyInProgress, TransferAlreadyComplete, + }, + }, + monitor::MonitorRunnable, + task::{ + CancelTask, ChangeMonitorIntervalTask, CompleteTask, Priority, ResumeTask, + SetNoProgressTimeoutTask, SetPriorityTask, SuspendTask, + }, + BitsService, BitsTaskError, +}; +use nsIBitsRequest_method; // From xpcom_method.rs + +use bits_client::{BitsMonitorClient, Guid}; +use log::{error, info, warn}; +use moz_task::create_thread; +use nserror::{nsresult, NS_ERROR_ABORT, NS_ERROR_NOT_IMPLEMENTED, NS_OK}; +use nsstring::{nsACString, nsCString}; +use std::{cell::Cell, fmt}; +use xpcom::{ + interfaces::{ + nsIBits, nsIBitsCallback, nsILoadGroup, nsIProgressEventSink, nsIRequestObserver, + nsISupports, nsIThread, nsLoadFlags, + }, + xpcom, xpcom_method, RefPtr, XpCom, +}; + +/// This structure exists to resolve a race condition. If cancel is called, we +/// don't want to immediately set the request state to cancelled, because the +/// cancel action could fail. But it's possible that on_stop() could be called +/// before the cancel action resolves, and the correct status should be sent to +/// OnStopRequest. +/// This is how this race condition will be resolved: +/// 1. cancel() is called, which sets the CancelAction to InProgress and +/// stores in it the status that should be set if it succeeds. +/// 2. cancel() dispatches the cancel task off thread. +/// At this point, things unfold in one of two ways, depending on the race +/// condition. Either: +/// 3. The cancel task returns to the main thread and calls +/// BitsRequest::finish_cancel_action. +/// 4. If the cancel action succeeded, the appropriate status codes are set +/// and the CancelAction is set to RequestEndPending. +/// If the cancel action failed, the CancelAction is set to NotInProgress. +/// 5. The MonitorRunnable detects that the transfer has ended and calls +/// BitsRequest::on_stop, passing different status codes. +/// 6. BitsRequest::on_stop checks the CancelAction and +/// If the cancel action succeeded and RequestEndPending is set, the +/// status codes that were set by BitsRequest::finish_cancel_action are +/// left untouched. +/// If the cancel action failed and NotInProgress is set, the status codes +/// passed to BitsRequest::on_stop are set. +/// 7. onStopRequest is called with the correct status code. +/// Or, if MonitorRunnable calls on_stop before the cancel task can finish: +/// 3. The MonitorRunnable detects that the transfer has ended and calls +/// BitsRequest::on_stop, passing status codes to it. +/// 4. BitsRequest::on_stop checks the CancelAction, sees it is set to +/// InProgress, and sets it to RequestEndedWhileInProgress, carrying over +/// the status code from InProgress. +/// 5. BitsRequest::on_stop sets the status to the value passed to it, which +/// will be overwritten if the cancel action succeeds, but kept if it +/// fails. +/// 6. BitsRequest::on_stop returns early, without calling OnStopRequest. +/// 7. The cancel task returns to the main thread and calls +/// BitsRequest::finish_cancel_action. +/// 8. If the cancel action succeeded, the status codes are set from the +/// value stored in RequestEndedWhileInProgress. +/// If the cancel action failed, the status codes are not changed. +/// 9. The CancelAction is set to NotInProgress. +/// 10. BitsRequest::finish_cancel_action calls BitsRequest::on_stop without +/// passing it any status codes. +/// 11. onStopRequest is called with the correct status code. +#[derive(Clone, Copy, PartialEq)] +enum CancelAction { + NotInProgress, + InProgress(Option<nsresult>), + RequestEndedWhileInProgress(Option<nsresult>), + RequestEndPending, +} + +#[xpcom(implement(nsIBitsRequest), nonatomic)] +pub struct BitsRequest { + bits_id: Guid, + bits_service: RefPtr<BitsService>, + // Stores the value to be returned by nsIRequest::IsPending. + download_pending: Cell<bool>, + // Stores the value to be returned by nsIRequest::GetStatus. + download_status_nsresult: Cell<nsresult>, + // Stores an ErrorType if the request has failed, or None to represent the + // success state. + download_status_error_type: Cell<Option<ErrorType>>, + // This option will be None only after OnStopRequest has been fired. + monitor_thread: Cell<Option<RefPtr<nsIThread>>>, + monitor_timeout_ms: u32, + observer: RefPtr<nsIRequestObserver>, + // started indicates whether or not OnStartRequest has been fired. + started: Cell<bool>, + // finished indicates whether or not we have called + // BitsService::dec_request_count() to (assuming that there are no other + // requests) shutdown the command thread. + finished: Cell<bool>, + cancel_action: Cell<CancelAction>, +} + +impl fmt::Debug for BitsRequest { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "BitsRequest {{ id: {} }}", self.bits_id) + } +} + +/// This implements the nsIBitsRequest interface, documented in nsIBits.idl, to +/// enable BITS job management. This interface deals only with BITS jobs that +/// already exist. Jobs can be created via BitsService, which will create a +/// BitsRequest for that job. +/// +/// This is a primarily asynchronous interface, which is accomplished via +/// callbacks of type nsIBitsCallback. The callback is passed in as an argument +/// and is then passed off-thread via a Task. The Task interacts with BITS and +/// is dispatched back to the main thread with the BITS result. Back on the main +/// thread, it returns that result via the callback. +impl BitsRequest { + pub fn new( + id: Guid, + bits_service: RefPtr<BitsService>, + monitor_timeout_ms: u32, + observer: RefPtr<nsIRequestObserver>, + context: Option<RefPtr<nsISupports>>, + monitor_client: BitsMonitorClient, + action: ServiceAction, + ) -> Result<RefPtr<BitsRequest>, BitsTaskError> { + let _ = context; + let action: Action = action.into(); + let monitor_thread = create_thread("BitsMonitor").map_err(|rv| { + BitsTaskError::from_nsresult(FailedToStartThread, action, MainThread, rv) + })?; + + // BitsRequest.drop() will call dec_request_count + bits_service.inc_request_count(); + let request: RefPtr<BitsRequest> = BitsRequest::allocate(InitBitsRequest { + bits_id: id.clone(), + bits_service, + download_pending: Cell::new(true), + download_status_nsresult: Cell::new(NS_OK), + download_status_error_type: Cell::new(None), + monitor_thread: Cell::new(Some(monitor_thread.clone())), + monitor_timeout_ms, + observer, + started: Cell::new(false), + finished: Cell::new(false), + cancel_action: Cell::new(CancelAction::NotInProgress), + }); + + let monitor_runnable = + MonitorRunnable::new(request.clone(), id, monitor_timeout_ms, monitor_client); + + if let Err(rv) = monitor_runnable.dispatch(monitor_thread.clone()) { + request.shutdown_monitor_thread(); + return Err(BitsTaskError::from_nsresult( + FailedToDispatchRunnable, + action, + MainThread, + rv, + )); + } + + Ok(request) + } + + pub fn get_monitor_thread(&self) -> Option<RefPtr<nsIThread>> { + let monitor_thread = self.monitor_thread.take(); + self.monitor_thread.set(monitor_thread.clone()); + monitor_thread + } + + fn has_monitor_thread(&self) -> bool { + let maybe_monitor_thread = self.monitor_thread.take(); + let transferred = maybe_monitor_thread.is_some(); + self.monitor_thread.set(maybe_monitor_thread); + transferred + } + + /// If this returns an true, it means that: + /// - The monitor thread and monitor runnable may have been shut down + /// - The BITS job is not in the TRANSFERRING state + /// - The download either completed, failed, or was cancelled + /// - The BITS job may or may not still need complete() or cancel() to be + /// called on it + fn request_has_transferred(&self) -> bool { + self.request_has_completed() || !self.has_monitor_thread() + } + + /// If this returns an error, it means that: + /// - complete() or cancel() has been called on the BITS job. + /// - BitsService::dec_request_count has already been called. + /// - The BitsClient object that this request was using may have been + /// dropped. + fn request_has_completed(&self) -> bool { + self.finished.get() + } + + fn shutdown_monitor_thread(&self) { + if let Some(monitor_thread) = self.monitor_thread.take() { + if let Err(rv) = unsafe { monitor_thread.AsyncShutdown() }.to_result() { + warn!("Failed to shut down monitor thread: {:?}", rv); + warn!("Releasing reference to thread that failed to shut down!"); + } + } + } + + /** + * To be called when the transfer starts. Fires observer.OnStartRequest exactly once. + */ + pub fn on_start(&self) { + if self.started.get() { + return; + } + self.started.set(true); + if let Err(rv) = unsafe { self.observer.OnStartRequest(self.coerce()) }.to_result() { + // This behavior is specified by nsIRequestObserver. + // See nsIRequestObserver.idl + info!( + "Cancelling download because OnStartRequest rejected with: {:?}", + rv + ); + if let Err(rv) = self.cancel(NS_ERROR_ABORT, None) { + warn!("Failed to cancel download: {:?}", rv); + } + } + } + + pub fn on_progress(&self, transferred_bytes: i64, total_bytes: i64) { + if let Some(progress_event_sink) = self.observer.query_interface::<nsIProgressEventSink>() { + unsafe { + progress_event_sink.OnProgress(self.coerce(), transferred_bytes, total_bytes); + } + } + } + + /// To be called when the transfer stops (fails or completes). Fires + /// observer.OnStopRequest exactly once, though the call may be delayed to + /// resolve a race condition. + /// + /// The status values, if passed, will be stored in download_status_nsresult + /// and download_status_error_type, unless they have been overridden by a + /// cancel action. + /// + /// See the documentation for CancelAction for details. + pub fn on_stop(&self, maybe_status: Option<(nsresult, Option<ErrorType>)>) { + if !self.has_monitor_thread() { + // If the request has already stopped, don't stop it again + return; + } + + match self.cancel_action.get() { + CancelAction::InProgress(saved_status) + | CancelAction::RequestEndedWhileInProgress(saved_status) => { + if let Some((status, result)) = maybe_status { + self.download_status_nsresult.set(status); + self.download_status_error_type.set(result); + } + + info!("Deferring OnStopRequest until Cancel Task completes"); + self.cancel_action + .set(CancelAction::RequestEndedWhileInProgress(saved_status)); + return; + } + CancelAction::NotInProgress => { + if let Some((status, result)) = maybe_status { + self.download_status_nsresult.set(status); + self.download_status_error_type.set(result); + } + } + CancelAction::RequestEndPending => { + // Don't set the status variables if the end of this request was + // the result of a cancel action. The cancel action already set + // those values and they should not be changed. + // See the CancelAction documentation for details. + } + } + + self.download_pending.set(false); + self.shutdown_monitor_thread(); + unsafe { + self.observer + .OnStopRequest(self.coerce(), self.download_status_nsresult.get()); + } + } + + /// To be called after a cancel or complete task has run successfully. If + /// this is the only BitsRequest running, this will shut down + /// BitsService's command thread, destroying the BitsClient. + pub fn on_finished(&self) { + if self.finished.get() { + return; + } + self.finished.set(true); + self.bits_service.dec_request_count(); + } + + // Return the same thing for GetBitsId() and GetName(). + xpcom_method!( + maybe_get_bits_id => GetBitsId() -> nsACString + ); + xpcom_method!( + maybe_get_bits_id => GetName() -> nsACString + ); + fn maybe_get_bits_id(&self) -> Result<nsCString, nsresult> { + Ok(self.get_bits_id()) + } + pub fn get_bits_id(&self) -> nsCString { + nsCString::from(self.bits_id.to_string()) + } + + xpcom_method!( + get_bits_transfer_error_nsIBitsRequest => GetTransferError() -> i32 + ); + #[allow(non_snake_case)] + fn get_bits_transfer_error_nsIBitsRequest(&self) -> Result<i32, nsresult> { + let error_type = match self.download_status_error_type.get() { + None => nsIBits::ERROR_TYPE_SUCCESS, + Some(error_type) => error_type.bits_code(), + }; + Ok(error_type) + } + + xpcom_method!( + is_pending => IsPending() -> bool + ); + fn is_pending(&self) -> Result<bool, nsresult> { + Ok(self.download_pending.get()) + } + + xpcom_method!( + get_status_nsIRequest => GetStatus() -> nsresult + ); + #[allow(non_snake_case)] + fn get_status_nsIRequest(&self) -> Result<nsresult, nsresult> { + Ok(self.get_status()) + } + pub fn get_status(&self) -> nsresult { + self.download_status_nsresult.get() + } + + nsIBitsRequest_method!( + [Action::SetMonitorInterval] + change_monitor_interval => ChangeMonitorInterval(update_interval_ms: u32) + ); + fn change_monitor_interval( + &self, + update_interval_ms: u32, + callback: &nsIBitsCallback, + ) -> Result<(), BitsTaskError> { + if update_interval_ms == 0 || update_interval_ms >= self.monitor_timeout_ms { + return Err(BitsTaskError::new( + InvalidArgument, + Action::SetMonitorInterval, + Pretask, + )); + } + if self.request_has_transferred() { + return Err(BitsTaskError::new( + TransferAlreadyComplete, + Action::SetMonitorInterval, + Pretask, + )); + } + + let task: Box<ChangeMonitorIntervalTask> = Box::new(ChangeMonitorIntervalTask::new( + RefPtr::new(self), + self.bits_id.clone(), + update_interval_ms, + RefPtr::new(callback), + )); + + self.bits_service.dispatch_runnable_to_command_thread( + task, + "BitsRequest::change_monitor_interval", + Action::SetMonitorInterval, + ) + } + + nsIBitsRequest_method!( + [Action::Cancel] + cancel_nsIBitsRequest => CancelAsync(status: nsresult) + ); + #[allow(non_snake_case)] + fn cancel_nsIBitsRequest( + &self, + status: nsresult, + callback: &nsIBitsCallback, + ) -> Result<(), BitsTaskError> { + self.cancel(status, Some(RefPtr::new(callback))) + } + xpcom_method!( + cancel_nsIRequest => Cancel(status: nsresult) + ); + #[allow(non_snake_case)] + fn cancel_nsIRequest(&self, status: nsresult) -> Result<(), BitsTaskError> { + self.cancel(status, None) + } + + fn cancel( + &self, + status: nsresult, + callback: Option<RefPtr<nsIBitsCallback>>, + ) -> Result<(), BitsTaskError> { + if status.clone().succeeded() { + return Err(BitsTaskError::new(InvalidArgument, Action::Cancel, Pretask)); + } + if self.request_has_completed() { + return Err(BitsTaskError::new( + TransferAlreadyComplete, + Action::Cancel, + Pretask, + )); + } + + // If the transfer is still in a success state, cancelling it should move it to the failure + // state that was passed. But if the transfer already failed, the only reason to call cancel + // is to remove the job from BITS. So in that case, we should keep the failure status that + // we already have. + let maybe_status: Option<nsresult> = if self.download_status_nsresult.get().failed() { + None + } else { + Some(status) + }; + + if self.cancel_action.get() != CancelAction::NotInProgress { + return Err(BitsTaskError::new( + OperationAlreadyInProgress, + Action::Cancel, + Pretask, + )); + } + self.cancel_action + .set(CancelAction::InProgress(maybe_status)); + + let task: Box<CancelTask> = Box::new(CancelTask::new( + RefPtr::new(self), + self.bits_id.clone(), + callback, + )); + + self.bits_service.dispatch_runnable_to_command_thread( + task, + "BitsRequest::cancel", + Action::Cancel, + ) + } + + /// This function must be called when a cancel action completes. + /// + /// See the documentation for CancelAction for details. + pub fn finish_cancel_action(&self, cancelled_successfully: bool) { + let (maybe_status, transfer_ended) = match self.cancel_action.get() { + CancelAction::InProgress(maybe_status) => (maybe_status, false), + CancelAction::RequestEndedWhileInProgress(maybe_status) => (maybe_status, true), + _ => { + error!("End of cancel action, but cancel action is not in progress!"); + return; + } + }; + info!( + "Finishing cancel action. cancel success = {}", + cancelled_successfully + ); + if cancelled_successfully { + // If no status was provided, it is because this cancel action removed the BITS job + // after the job had already failed. Keep the original error codes. + if let Some(status) = maybe_status { + self.download_status_nsresult.set(status); + self.download_status_error_type + .set(Some(BitsStateCancelled)); + } + } + + let next_stage = if cancelled_successfully && !transfer_ended { + // This signals on_stop not to allow the status codes set above to + // be overridden by the ones passed to it. + CancelAction::RequestEndPending + } else { + CancelAction::NotInProgress + }; + self.cancel_action.set(next_stage); + + if cancelled_successfully { + self.on_finished(); + } + + if transfer_ended { + info!("Running deferred OnStopRequest"); + self.on_stop(None); + } + } + + nsIBitsRequest_method!( + [Action::SetPriority] + set_priority_high => SetPriorityHigh() + ); + fn set_priority_high(&self, callback: &nsIBitsCallback) -> Result<(), BitsTaskError> { + self.set_priority(Priority::High, callback) + } + + nsIBitsRequest_method!( + [Action::SetPriority] + set_priority_low => SetPriorityLow() + ); + fn set_priority_low(&self, callback: &nsIBitsCallback) -> Result<(), BitsTaskError> { + self.set_priority(Priority::Low, callback) + } + + fn set_priority( + &self, + priority: Priority, + callback: &nsIBitsCallback, + ) -> Result<(), BitsTaskError> { + if self.request_has_transferred() { + return Err(BitsTaskError::new( + TransferAlreadyComplete, + Action::SetPriority, + Pretask, + )); + } + + let task: Box<SetPriorityTask> = Box::new(SetPriorityTask::new( + RefPtr::new(self), + self.bits_id.clone(), + priority, + RefPtr::new(callback), + )); + + self.bits_service.dispatch_runnable_to_command_thread( + task, + "BitsRequest::set_priority", + Action::SetPriority, + ) + } + + nsIBitsRequest_method!( + [Action::SetNoProgressTimeout] + set_no_progress_timeout => SetNoProgressTimeout(timeout_secs: u32) + ); + fn set_no_progress_timeout( + &self, + timeout_secs: u32, + callback: &nsIBitsCallback, + ) -> Result<(), BitsTaskError> { + if self.request_has_transferred() { + return Err(BitsTaskError::new( + TransferAlreadyComplete, + Action::SetNoProgressTimeout, + Pretask, + )); + } + + let task: Box<SetNoProgressTimeoutTask> = Box::new(SetNoProgressTimeoutTask::new( + RefPtr::new(self), + self.bits_id.clone(), + timeout_secs, + RefPtr::new(callback), + )); + + self.bits_service.dispatch_runnable_to_command_thread( + task, + "BitsRequest::set_no_progress_timeout", + Action::SetNoProgressTimeout, + ) + } + + nsIBitsRequest_method!( + [Action::Complete] + complete => Complete() + ); + fn complete(&self, callback: &nsIBitsCallback) -> Result<(), BitsTaskError> { + if self.request_has_completed() { + return Err(BitsTaskError::new( + TransferAlreadyComplete, + Action::Complete, + Pretask, + )); + } + + let task: Box<CompleteTask> = Box::new(CompleteTask::new( + RefPtr::new(self), + self.bits_id.clone(), + RefPtr::new(callback), + )); + + self.bits_service.dispatch_runnable_to_command_thread( + task, + "BitsRequest::complete", + Action::Complete, + ) + } + + nsIBitsRequest_method!( + [Action::Suspend] + suspend_nsIBitsRequest => SuspendAsync() + ); + #[allow(non_snake_case)] + fn suspend_nsIBitsRequest(&self, callback: &nsIBitsCallback) -> Result<(), BitsTaskError> { + self.suspend(Some(RefPtr::new(callback))) + } + xpcom_method!( + suspend_nsIRequest => Suspend() + ); + #[allow(non_snake_case)] + fn suspend_nsIRequest(&self) -> Result<(), BitsTaskError> { + self.suspend(None) + } + + fn suspend(&self, callback: Option<RefPtr<nsIBitsCallback>>) -> Result<(), BitsTaskError> { + if self.request_has_transferred() { + return Err(BitsTaskError::new( + TransferAlreadyComplete, + Action::Suspend, + Pretask, + )); + } + + let task: Box<SuspendTask> = Box::new(SuspendTask::new( + RefPtr::new(self), + self.bits_id.clone(), + callback, + )); + + self.bits_service.dispatch_runnable_to_command_thread( + task, + "BitsRequest::suspend", + Action::Suspend, + ) + } + + nsIBitsRequest_method!( + [Action::Resume] + resume_nsIBitsRequest => ResumeAsync() + ); + #[allow(non_snake_case)] + fn resume_nsIBitsRequest(&self, callback: &nsIBitsCallback) -> Result<(), BitsTaskError> { + self.resume(Some(RefPtr::new(callback))) + } + xpcom_method!( + resume_nsIRequest => Resume() + ); + #[allow(non_snake_case)] + fn resume_nsIRequest(&self) -> Result<(), BitsTaskError> { + self.resume(None) + } + + fn resume(&self, callback: Option<RefPtr<nsIBitsCallback>>) -> Result<(), BitsTaskError> { + if self.request_has_transferred() { + return Err(BitsTaskError::new( + TransferAlreadyComplete, + Action::Resume, + Pretask, + )); + } + + let task: Box<ResumeTask> = Box::new(ResumeTask::new( + RefPtr::new(self), + self.bits_id.clone(), + callback, + )); + + self.bits_service.dispatch_runnable_to_command_thread( + task, + "BitsRequest::resume", + Action::Resume, + ) + } + + xpcom_method!( + get_load_group => GetLoadGroup() -> *const nsILoadGroup + ); + + /** + * As stated in nsIBits.idl, nsIBits interfaces are not expected to + * implement the loadGroup or loadFlags attributes. This implementation + * provides only null implementations only for these methods. + */ + fn get_load_group(&self) -> Result<RefPtr<nsILoadGroup>, nsresult> { + Err(NS_ERROR_NOT_IMPLEMENTED) + } + + xpcom_method!( + set_load_group => SetLoadGroup(_load_group: *const nsILoadGroup) + ); + fn set_load_group(&self, _load_group: &nsILoadGroup) -> Result<(), nsresult> { + Err(NS_ERROR_NOT_IMPLEMENTED) + } + + xpcom_method!( + get_load_flags => GetLoadFlags() -> nsLoadFlags + ); + fn get_load_flags(&self) -> Result<nsLoadFlags, nsresult> { + Err(NS_ERROR_NOT_IMPLEMENTED) + } + + xpcom_method!( + set_load_flags => SetLoadFlags(_load_flags: nsLoadFlags) + ); + fn set_load_flags(&self, _load_flags: nsLoadFlags) -> Result<(), nsresult> { + Err(NS_ERROR_NOT_IMPLEMENTED) + } + + xpcom_method!( + get_trr_mode => GetTRRMode() -> u32 + ); + fn get_trr_mode(&self) -> Result<u32, nsresult> { + Err(NS_ERROR_NOT_IMPLEMENTED) + } + + xpcom_method!( + set_trr_mode => SetTRRMode(_trr_mode: u32) + ); + fn set_trr_mode(&self, _trr_mode: u32) -> Result<(), nsresult> { + Err(NS_ERROR_NOT_IMPLEMENTED) + } + + xpcom_method!( + get_canceled_reason => GetCanceledReason() -> nsACString + ); + fn get_canceled_reason(&self) -> Result<nsCString, nsresult> { + Err(NS_ERROR_NOT_IMPLEMENTED) + } + + xpcom_method!( + set_canceled_reason => SetCanceledReason(_reason: *const nsACString) + ); + fn set_canceled_reason(&self, _reason: *const nsACString) -> Result<(), nsresult> { + Err(NS_ERROR_NOT_IMPLEMENTED) + } + + xpcom_method!( + cancel_with_reason_nsIRequest => CancelWithReason(status: nsresult, _reason: *const nsACString) + ); + #[allow(non_snake_case)] + fn cancel_with_reason_nsIRequest( + &self, + status: nsresult, + _reason: *const nsACString, + ) -> Result<(), BitsTaskError> { + self.cancel(status, None) + } +} + +impl Drop for BitsRequest { + fn drop(&mut self) { + // Make sure that the monitor thread gets cleaned up. + self.shutdown_monitor_thread(); + // Make sure we tell BitsService that we are done with the command thread. + self.on_finished(); + } +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/string.rs b/toolkit/components/bitsdownload/src/bits_interface/string.rs new file mode 100644 index 0000000000..c3111b7cba --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/string.rs @@ -0,0 +1,80 @@ +/* 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/. */ +use super::{ + action::Action, + error::{BitsTaskError, ErrorStage, ErrorType}, +}; + +use bits_client::Guid; +use nsstring::nsCString; +use std::ffi::OsString; +use std::{str, str::FromStr}; + +/// This function is fallible, and the consumers would prefer a BitsTaskError +/// in the failure case. To facilitate that, this function takes some params +/// that give it the data necessary to construct the BitsTaskError if it fails. +/// If it succeeds, those values will be unused. +#[allow(non_snake_case)] +pub fn nsCString_to_String( + value: &nsCString, + error_action: Action, + error_stage: ErrorStage, +) -> Result<String, BitsTaskError> { + match String::from_utf8(value[..].to_vec()) { + Ok(s) => Ok(s), + Err(_) => Err(BitsTaskError::new( + ErrorType::NoUtf8Conversion, + error_action, + error_stage, + )), + } +} + +/// This function is fallible, and the consumers would prefer a BitsTaskError +/// in the failure case. To facilitate that, this function takes some params +/// that give it the data necessary to construct the BitsTaskError if it fails. +/// If it succeeds, those values will be unused. +#[allow(non_snake_case)] +pub fn nsCString_to_OsString( + value: &nsCString, + error_action: Action, + error_stage: ErrorStage, +) -> Result<OsString, BitsTaskError> { + Ok(OsString::from(nsCString_to_String( + value, + error_action, + error_stage, + )?)) +} + +/// This function is fallible, and the consumers would prefer a BitsTaskError +/// in the failure case. To facilitate that, this function takes some params +/// that give it the data necessary to construct the BitsTaskError if it fails. +/// If it succeeds, those values will be unused. +#[allow(non_snake_case)] +pub fn Guid_from_nsCString( + value: &nsCString, + error_action: Action, + error_stage: ErrorStage, +) -> Result<Guid, BitsTaskError> { + let vector = &value[..].to_vec(); + let string = match str::from_utf8(vector) { + Ok(s) => s, + Err(_) => { + return Err(BitsTaskError::new( + ErrorType::NoUtf8Conversion, + error_action, + error_stage, + )); + } + }; + Guid::from_str(string).map_err(|comedy_error| { + BitsTaskError::from_comedy( + ErrorType::InvalidGuid, + error_action, + error_stage, + comedy_error, + ) + }) +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/task/client.rs b/toolkit/components/bitsdownload/src/bits_interface/task/client.rs new file mode 100644 index 0000000000..edbf4d0698 --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/task/client.rs @@ -0,0 +1,102 @@ +/* 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/. */ +use super::{ + action::Action, + error::{BitsTaskError, ErrorStage::CommandThread, ErrorType::MissingBitsClient}, + string::nsCString_to_OsString, +}; + +use bits_client::BitsClient; +use nsstring::nsCString; +use std::cell::Cell; + +thread_local! { + // This is used to store the `BitsClient` on the Command thread. + // Keeping it here solves the problem of how to allow multiple runnables to + // be simultaneously queued on the Command thread while giving them all + // access to the same `BitsClient`. + static BITS_CLIENT: Cell<Option<BitsClient>> = Cell::new(None); +} + +/// This structure holds the data needed to initialize `BitsClient` and +/// `BitsMonitorClient`. +#[derive(Debug, Clone)] +pub struct ClientInitData { + pub job_name: nsCString, + pub save_path_prefix: nsCString, + pub monitor_timeout_ms: u32, +} + +impl ClientInitData { + pub fn new( + job_name: nsCString, + save_path_prefix: nsCString, + monitor_timeout_ms: u32, + ) -> ClientInitData { + ClientInitData { + job_name, + save_path_prefix, + monitor_timeout_ms, + } + } +} + +/// This function constructs a `BitsClient`, if one does not already exist. If +/// the `BitsClient` cannot be constructed, a `BitsTaskError` will be returned. +/// If the `BitsClient` could be obtained, then the function then calls the +/// closure passed to it, passing a mutable reference to the `BitsClient`. +/// This function will then return whatever the closure returned, which must be +/// a `Result<_, BitsTaskError>`. +pub fn with_maybe_new_bits_client<F, R>( + init_data: &ClientInitData, + action: Action, + closure: F, +) -> Result<R, BitsTaskError> +where + F: FnOnce(&mut BitsClient) -> Result<R, BitsTaskError>, +{ + _with_bits_client(Some(init_data), action, closure) +} + +/// This function assumes that a `BitsClient` has already been constructed. If +/// there is not one available, a `BitsTaskError` will be returned. Otherwise, +/// the function calls the closure passed to it, passing a mutable reference to +/// the `BitsClient`. This function will then return whatever the closure +/// returned, which must be a `Result<_, BitsTaskError>`. +pub fn with_bits_client<F, R>(action: Action, closure: F) -> Result<R, BitsTaskError> +where + F: FnOnce(&mut BitsClient) -> Result<R, BitsTaskError>, +{ + _with_bits_client(None, action, closure) +} + +fn _with_bits_client<F, R>( + maybe_init_data: Option<&ClientInitData>, + action: Action, + closure: F, +) -> Result<R, BitsTaskError> +where + F: FnOnce(&mut BitsClient) -> Result<R, BitsTaskError>, +{ + BITS_CLIENT.with(|cell| { + let maybe_client = cell.take(); + let mut client = match (maybe_client, maybe_init_data) { + (Some(r), _) => r, + (None, Some(init_data)) => { + // Immediately invoked function to allow for the ? operator + BitsClient::new( + nsCString_to_OsString(&init_data.job_name, action, CommandThread)?, + nsCString_to_OsString(&init_data.save_path_prefix, action, CommandThread)?, + ) + .map_err(|pipe_error| BitsTaskError::from_pipe(action, pipe_error))? + } + (None, None) => { + return Err(BitsTaskError::new(MissingBitsClient, action, CommandThread)); + } + }; + let result = closure(&mut client); + cell.set(Some(client)); + result + }) +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/task/from_threadbound.rs b/toolkit/components/bitsdownload/src/bits_interface/task/from_threadbound.rs new file mode 100644 index 0000000000..2cf2e9189a --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/task/from_threadbound.rs @@ -0,0 +1,125 @@ +/* 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/. */ +use super::{ + action::Action, + error::{BitsTaskError, ErrorStage, ErrorType}, +}; +use log::warn; +use xpcom::{RefCounted, ThreadBoundRefPtr}; + +#[derive(Debug, PartialEq, Clone, Copy)] +pub enum DataType { + Callback, + BitsService, + BitsRequest, + Observer, + Context, +} + +#[derive(Debug, PartialEq, Clone, Copy)] +enum GetThreadboundError { + Missing, + WrongThread, +} + +impl DataType { + fn error_type(&self, error: GetThreadboundError) -> ErrorType { + match self { + DataType::Callback => match error { + GetThreadboundError::Missing => ErrorType::MissingCallback, + GetThreadboundError::WrongThread => ErrorType::CallbackOnWrongThread, + }, + DataType::BitsService => match error { + GetThreadboundError::Missing => ErrorType::MissingBitsService, + GetThreadboundError::WrongThread => ErrorType::BitsServiceOnWrongThread, + }, + DataType::BitsRequest => match error { + GetThreadboundError::Missing => ErrorType::MissingBitsRequest, + GetThreadboundError::WrongThread => ErrorType::BitsRequestOnWrongThread, + }, + DataType::Observer => match error { + GetThreadboundError::Missing => ErrorType::MissingObserver, + GetThreadboundError::WrongThread => ErrorType::ObserverOnWrongThread, + }, + DataType::Context => match error { + GetThreadboundError::Missing => ErrorType::MissingContext, + GetThreadboundError::WrongThread => ErrorType::ContextOnWrongThread, + }, + } + } + + fn name(&self) -> &'static str { + match self { + DataType::Callback => "Callback", + DataType::BitsService => "BITS Service", + DataType::BitsRequest => "BITS Request", + DataType::Observer => "Observer", + DataType::Context => "Context", + } + } +} + +/// Given a reference to a threadbound option +/// (i.e. `&Option<ThreadBoundRefPtr<_>>`), this function will attempt to +/// retrieve a reference to the value stored within. If it is not available +/// (option is `None` or value is on the wrong thread), `None` is returned +/// instead. +pub fn get_from_threadbound_option<T>( + maybe_threadbound: &Option<ThreadBoundRefPtr<T>>, + data_type: DataType, + action: Action, +) -> Option<&T> +where + T: RefCounted + 'static, +{ + maybe_threadbound.as_ref().and_then(|threadbound| { + let maybe_reference = threadbound.get_ref(); + if maybe_reference.is_none() { + warn!( + "Unexpected error {}: {} is on the wrong thread", + action.description(), + data_type.name(), + ); + } + maybe_reference + }) +} + +/// Given a reference to a threadbound option +/// (i.e. `&Option<ThreadBoundRefPtr<_>>`), this function will attempt to +/// retrieve a reference to the value stored within. If it is not available +/// (option is `None` or value is on the wrong thread), a `BitsTaskError` is +/// returned instead. +pub fn expect_from_threadbound_option<T>( + maybe_threadbound: &Option<ThreadBoundRefPtr<T>>, + data_type: DataType, + action: Action, +) -> Result<&T, BitsTaskError> +where + T: RefCounted + 'static, +{ + match maybe_threadbound.as_ref() { + Some(threadbound) => { + match threadbound.get_ref() { + Some(reference) => Ok(reference), + None => Err(BitsTaskError::new( + data_type.error_type(GetThreadboundError::WrongThread), + action, + // Retrieving data from threadbounds all happens on the main thread. + // No data is ever bound to other threads so there would be no + // reason to retrieve it there. + ErrorStage::MainThread, + )), + } + } + None => Err(BitsTaskError::new( + data_type.error_type(GetThreadboundError::Missing), + action, + // Retrieving data from threadbounds all happens on the main thread. + // No data is ever bound to other threads so there would be no + // reason to retrieve it there. + ErrorStage::MainThread, + )), + } +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/task/mod.rs b/toolkit/components/bitsdownload/src/bits_interface/task/mod.rs new file mode 100644 index 0000000000..b6b96d887b --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/task/mod.rs @@ -0,0 +1,18 @@ +/* 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/. */ +mod from_threadbound; + +use super::{action, dispatch_callback, error, request::BitsRequest, string, BitsService}; + +mod client; +pub use self::client::ClientInitData; + +mod service_task; +pub use self::service_task::{MonitorDownloadTask, StartDownloadTask}; + +mod request_task; +pub use self::request_task::{ + CancelTask, ChangeMonitorIntervalTask, CompleteTask, Priority, ResumeTask, + SetNoProgressTimeoutTask, SetPriorityTask, SuspendTask, +}; diff --git a/toolkit/components/bitsdownload/src/bits_interface/task/request_task.rs b/toolkit/components/bitsdownload/src/bits_interface/task/request_task.rs new file mode 100644 index 0000000000..f0fd331ed0 --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/task/request_task.rs @@ -0,0 +1,425 @@ +/* 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/. */ +use super::{ + action::{Action, RequestAction}, + client::with_bits_client, + dispatch_callback::{ + maybe_dispatch_via_callback, CallbackExpected, CallbackOptional, IsCallbackExpected, + }, + error::BitsTaskError, + from_threadbound::{expect_from_threadbound_option, DataType}, + BitsRequest, +}; + +use bits_client::{BitsClient, Guid}; +use crossbeam_utils::atomic::AtomicCell; +use log::info; +use moz_task::Task; +use nserror::nsresult; +use xpcom::{interfaces::nsIBitsCallback, RefPtr, ThreadBoundRefPtr}; + +type RunFn<D> = fn(Guid, &D, &mut BitsClient) -> Result<(), BitsTaskError>; +type DoneFn = fn(&BitsRequest, bool) -> Result<(), BitsTaskError>; + +pub struct RequestTask<D> { + request: AtomicCell<Option<ThreadBoundRefPtr<BitsRequest>>>, + guid: Guid, + action: RequestAction, + task_data: D, + run_fn: RunFn<D>, + maybe_done_fn: Option<DoneFn>, + callback: AtomicCell<Option<ThreadBoundRefPtr<nsIBitsCallback>>>, + callback_presence: IsCallbackExpected, + result: AtomicCell<Option<Result<(), BitsTaskError>>>, +} + +impl<D> RequestTask<D> +where + D: Sync + Send, +{ + pub fn new( + request: RefPtr<BitsRequest>, + guid: Guid, + action: RequestAction, + task_data: D, + run_fn: RunFn<D>, + maybe_done_fn: Option<DoneFn>, + callback: Option<RefPtr<nsIBitsCallback>>, + callback_presence: IsCallbackExpected, + ) -> RequestTask<D> { + RequestTask { + request: AtomicCell::new(Some(ThreadBoundRefPtr::new(request))), + guid, + action, + task_data, + run_fn, + maybe_done_fn, + callback: AtomicCell::new(callback.map(ThreadBoundRefPtr::new)), + result: AtomicCell::new(None), + callback_presence, + } + } +} + +impl<D> Task for RequestTask<D> { + fn run(&self) { + let result = with_bits_client(self.action.into(), |client| { + (self.run_fn)(self.guid.clone(), &self.task_data, client) + }); + self.result.store(Some(result)); + } + + fn done(&self) -> Result<(), nsresult> { + // If TaskRunnable.run() calls Task.done() to return a result + // on the main thread before TaskRunnable.run() returns on the worker + // thread, then the Task will get dropped on the worker thread. + // + // But the callback is an nsXPCWrappedJS that isn't safe to release + // on the worker thread. So we move it out of the Task here to ensure + // it gets released on the main thread. + let maybe_tb_callback = self.callback.swap(None); + // It also isn't safe to drop the BitsRequest RefPtr off-thread, + // because BitsRequest refcounting is non-atomic + let maybe_tb_request = self.request.swap(None); + + let action: Action = self.action.into(); + let maybe_callback = + expect_from_threadbound_option(&maybe_tb_callback, DataType::Callback, action); + + // Immediately invoked function expression to allow for the ? operator + let result: Result<(), BitsTaskError> = (|| { + let request = + expect_from_threadbound_option(&maybe_tb_request, DataType::BitsRequest, action)?; + + let maybe_result = self.result.swap(None); + + let success = if let Some(result) = maybe_result.as_ref() { + result.is_ok() + } else { + false + }; + + if let Some(done_fn) = self.maybe_done_fn { + done_fn(request, success)?; + } + + maybe_result.ok_or_else(|| BitsTaskError::missing_result(action))? + })(); + info!("BITS Request Task completed: {:?}", result); + maybe_dispatch_via_callback(result, maybe_callback, self.callback_presence) + } +} + +pub struct CompleteTask(RequestTask<()>); + +impl Task for CompleteTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl CompleteTask { + pub fn new( + request: RefPtr<BitsRequest>, + id: Guid, + callback: RefPtr<nsIBitsCallback>, + ) -> CompleteTask { + CompleteTask(RequestTask::new( + request, + id, + RequestAction::Complete, + (), + CompleteTask::run_fn, + Some(CompleteTask::done_fn), + Some(callback), + CallbackExpected, + )) + } + + fn run_fn(id: Guid, _data: &(), client: &mut BitsClient) -> Result<(), BitsTaskError> { + client + .complete_job(id) + .map_err(|pipe_error| BitsTaskError::from_pipe(Action::Complete, pipe_error))??; + Ok(()) + } + + fn done_fn(request: &BitsRequest, success: bool) -> Result<(), BitsTaskError> { + if success { + request.on_finished(); + } + Ok(()) + } +} + +pub struct CancelTask(RequestTask<()>); + +impl Task for CancelTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl CancelTask { + pub fn new( + request: RefPtr<BitsRequest>, + id: Guid, + callback: Option<RefPtr<nsIBitsCallback>>, + ) -> CancelTask { + let callback_presence = if callback.is_some() { + CallbackExpected + } else { + CallbackOptional + }; + + CancelTask(RequestTask::new( + request, + id, + RequestAction::Cancel, + (), + CancelTask::run_fn, + Some(CancelTask::done_fn), + callback, + callback_presence, + )) + } + + fn run_fn(id: Guid, _data: &(), client: &mut BitsClient) -> Result<(), BitsTaskError> { + client + .cancel_job(id) + .map_err(|pipe_error| BitsTaskError::from_pipe(Action::Cancel, pipe_error))??; + Ok(()) + } + + fn done_fn(request: &BitsRequest, success: bool) -> Result<(), BitsTaskError> { + request.finish_cancel_action(success); + Ok(()) + } +} + +pub struct SuspendTask(RequestTask<()>); + +impl Task for SuspendTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl SuspendTask { + pub fn new( + request: RefPtr<BitsRequest>, + id: Guid, + callback: Option<RefPtr<nsIBitsCallback>>, + ) -> SuspendTask { + let callback_presence = if callback.is_some() { + CallbackExpected + } else { + CallbackOptional + }; + + SuspendTask(RequestTask::new( + request, + id, + RequestAction::Suspend, + (), + SuspendTask::run_fn, + None, + callback, + callback_presence, + )) + } + + fn run_fn(id: Guid, _data: &(), client: &mut BitsClient) -> Result<(), BitsTaskError> { + client + .suspend_job(id) + .map_err(|pipe_error| BitsTaskError::from_pipe(Action::Suspend, pipe_error))??; + Ok(()) + } +} + +pub struct ResumeTask(RequestTask<()>); + +impl Task for ResumeTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl ResumeTask { + pub fn new( + request: RefPtr<BitsRequest>, + id: Guid, + callback: Option<RefPtr<nsIBitsCallback>>, + ) -> ResumeTask { + let callback_presence = if callback.is_some() { + CallbackExpected + } else { + CallbackOptional + }; + + ResumeTask(RequestTask::new( + request, + id, + RequestAction::Resume, + (), + ResumeTask::run_fn, + None, + callback, + callback_presence, + )) + } + + fn run_fn(id: Guid, _data: &(), client: &mut BitsClient) -> Result<(), BitsTaskError> { + client + .resume_job(id) + .map_err(|pipe_error| BitsTaskError::from_pipe(Action::Resume, pipe_error))??; + Ok(()) + } +} + +pub struct ChangeMonitorIntervalTask(RequestTask<u32>); + +impl Task for ChangeMonitorIntervalTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl ChangeMonitorIntervalTask { + pub fn new( + request: RefPtr<BitsRequest>, + id: Guid, + update_interval_ms: u32, + callback: RefPtr<nsIBitsCallback>, + ) -> ChangeMonitorIntervalTask { + ChangeMonitorIntervalTask(RequestTask::new( + request, + id, + RequestAction::SetMonitorInterval, + update_interval_ms, + ChangeMonitorIntervalTask::run_fn, + None, + Some(callback), + CallbackExpected, + )) + } + + fn run_fn( + id: Guid, + update_interval_ms: &u32, + client: &mut BitsClient, + ) -> Result<(), BitsTaskError> { + client + .set_update_interval(id, *update_interval_ms) + .map_err(|pipe_error| { + BitsTaskError::from_pipe(Action::SetMonitorInterval, pipe_error) + })??; + Ok(()) + } +} + +#[derive(Debug, PartialEq, Clone, Copy)] +pub enum Priority { + High, + Low, +} + +pub struct SetPriorityTask(RequestTask<Priority>); + +impl Task for SetPriorityTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl SetPriorityTask { + pub fn new( + request: RefPtr<BitsRequest>, + id: Guid, + priority: Priority, + callback: RefPtr<nsIBitsCallback>, + ) -> SetPriorityTask { + SetPriorityTask(RequestTask::new( + request, + id, + RequestAction::SetPriority, + priority, + SetPriorityTask::run_fn, + None, + Some(callback), + CallbackExpected, + )) + } + + fn run_fn(id: Guid, priority: &Priority, client: &mut BitsClient) -> Result<(), BitsTaskError> { + client + .set_job_priority(id, *priority == Priority::High) + .map_err(|pipe_error| BitsTaskError::from_pipe(Action::SetPriority, pipe_error))??; + Ok(()) + } +} + +pub struct SetNoProgressTimeoutTask(RequestTask<u32>); + +impl Task for SetNoProgressTimeoutTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl SetNoProgressTimeoutTask { + pub fn new( + request: RefPtr<BitsRequest>, + id: Guid, + timeout_secs: u32, + callback: RefPtr<nsIBitsCallback>, + ) -> SetNoProgressTimeoutTask { + SetNoProgressTimeoutTask(RequestTask::new( + request, + id, + RequestAction::SetNoProgressTimeout, + timeout_secs, + SetNoProgressTimeoutTask::run_fn, + None, + Some(callback), + CallbackExpected, + )) + } + + fn run_fn(id: Guid, timeout_secs: &u32, client: &mut BitsClient) -> Result<(), BitsTaskError> { + client + .set_no_progress_timeout(id, *timeout_secs) + .map_err(|pipe_error| { + BitsTaskError::from_pipe(Action::SetNoProgressTimeout, pipe_error) + })??; + Ok(()) + } +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/task/service_task.rs b/toolkit/components/bitsdownload/src/bits_interface/task/service_task.rs new file mode 100644 index 0000000000..c66f127f7a --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/task/service_task.rs @@ -0,0 +1,332 @@ +/* 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/. */ +use super::{ + action::{ + Action, + Action::{MonitorDownload, StartDownload}, + ServiceAction, + }, + client::{with_maybe_new_bits_client, ClientInitData}, + dispatch_callback::{maybe_dispatch_request_via_callback, CallbackExpected}, + error::{BitsTaskError, ErrorStage::CommandThread}, + from_threadbound::{expect_from_threadbound_option, get_from_threadbound_option, DataType}, + string::nsCString_to_OsString, + BitsRequest, BitsService, +}; + +use bits_client::{BitsClient, BitsMonitorClient, BitsProxyUsage, Guid}; +use crossbeam_utils::atomic::AtomicCell; +use log::{info, warn}; +use moz_task::Task; +use nserror::nsresult; +use nsstring::nsCString; +use xpcom::{ + interfaces::{nsIBitsNewRequestCallback, nsIRequestObserver, nsISupports}, + RefPtr, ThreadBoundRefPtr, +}; + +// D is the Data Type that the RunFn function needs to make S. +// S is the Success Type that the RunFn returns on success and that the +// DoneFn needs to make the BitsRequest. +type RunFn<D, S> = fn(&D, &mut BitsClient) -> Result<S, BitsTaskError>; +type DoneFn<D, S> = fn( + &D, + S, + &ClientInitData, + &BitsService, + &nsIRequestObserver, + Option<&nsISupports>, +) -> Result<RefPtr<BitsRequest>, BitsTaskError>; + +pub struct ServiceTask<D, S> { + client_init_data: ClientInitData, + action: ServiceAction, + task_data: D, + run_fn: RunFn<D, S>, + done_fn: DoneFn<D, S>, + bits_service: AtomicCell<Option<ThreadBoundRefPtr<BitsService>>>, + observer: AtomicCell<Option<ThreadBoundRefPtr<nsIRequestObserver>>>, + context: AtomicCell<Option<ThreadBoundRefPtr<nsISupports>>>, + callback: AtomicCell<Option<ThreadBoundRefPtr<nsIBitsNewRequestCallback>>>, + result: AtomicCell<Option<Result<S, BitsTaskError>>>, +} + +impl<D, S> ServiceTask<D, S> +where + D: Sync + Send, + S: Sync + Send, +{ + pub fn new( + client_init_data: ClientInitData, + action: ServiceAction, + task_data: D, + run_fn: RunFn<D, S>, + done_fn: DoneFn<D, S>, + bits_service: RefPtr<BitsService>, + observer: RefPtr<nsIRequestObserver>, + context: Option<RefPtr<nsISupports>>, + callback: RefPtr<nsIBitsNewRequestCallback>, + ) -> ServiceTask<D, S> { + ServiceTask { + client_init_data, + action, + task_data, + run_fn, + done_fn, + bits_service: AtomicCell::new(Some(ThreadBoundRefPtr::new(bits_service))), + observer: AtomicCell::new(Some(ThreadBoundRefPtr::new(observer))), + context: AtomicCell::new(context.map(ThreadBoundRefPtr::new)), + callback: AtomicCell::new(Some(ThreadBoundRefPtr::new(callback))), + result: AtomicCell::new(None), + } + } +} + +impl<D, S> Task for ServiceTask<D, S> { + fn run(&self) { + let result = + with_maybe_new_bits_client(&self.client_init_data, self.action.into(), |client| { + (self.run_fn)(&self.task_data, client) + }); + self.result.store(Some(result)); + } + + fn done(&self) -> Result<(), nsresult> { + // If TaskRunnable.run() calls Task.done() to return a result + // on the main thread before TaskRunnable.run() returns on the worker + // thread, then the Task will get dropped on the worker thread. + // + // But the callback is an nsXPCWrappedJS that isn't safe to release + // on the worker thread. So we move it out of the Task here to ensure + // it gets released on the main thread. + let maybe_tb_callback = self.callback.swap(None); + // It also isn't safe to drop the BitsService RefPtr off-thread, + // because BitsService refcounting is non-atomic + let maybe_tb_service = self.bits_service.swap(None); + // The observer and context are also an nsXPCWrappedJS that aren't safe + // to release on the worker thread. + let maybe_tb_observer = self.observer.swap(None); + let maybe_tb_context = self.context.swap(None); + + let action: Action = self.action.into(); + let maybe_callback = + expect_from_threadbound_option(&maybe_tb_callback, DataType::Callback, action); + + // Immediately invoked function expression to allow for the ? operator + let result: Result<RefPtr<BitsRequest>, BitsTaskError> = (|| { + let bits_service = + expect_from_threadbound_option(&maybe_tb_service, DataType::BitsService, action)?; + let observer = + expect_from_threadbound_option(&maybe_tb_observer, DataType::Observer, action)?; + let maybe_context = + get_from_threadbound_option(&maybe_tb_context, DataType::Context, action); + let success = self + .result + .swap(None) + .ok_or_else(|| BitsTaskError::missing_result(action))??; + + (self.done_fn)( + &self.task_data, + success, + &self.client_init_data, + bits_service, + observer, + maybe_context, + ) + })(); + info!("BITS Interface Task completed: {:?}", result); + // We incremented the request count when we dispatched an action to + // start the job. Now we will decrement since the action completed. + // See the declaration of InitBitsService::request_count for details. + let bits_service_result = + expect_from_threadbound_option(&maybe_tb_service, DataType::BitsService, action); + match bits_service_result { + Ok(bits_service) => { + bits_service.dec_request_count(); + } + Err(error) => { + warn!( + concat!( + "Unable to decrement the request count when finishing ServiceTask. ", + "The command thread may not be shut down. Error: {:?}" + ), + error + ); + } + } + + maybe_dispatch_request_via_callback(result, maybe_callback, CallbackExpected) + } +} + +struct StartDownloadData { + download_url: nsCString, + save_rel_path: nsCString, + proxy: BitsProxyUsage, + no_progress_timeout_secs: u32, + update_interval_ms: u32, +} + +struct StartDownloadSuccess { + guid: Guid, + monitor_client: BitsMonitorClient, +} + +pub struct StartDownloadTask(ServiceTask<StartDownloadData, StartDownloadSuccess>); + +impl Task for StartDownloadTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl StartDownloadTask { + pub fn new( + client_init_data: ClientInitData, + download_url: nsCString, + save_rel_path: nsCString, + proxy: BitsProxyUsage, + no_progress_timeout_secs: u32, + update_interval_ms: u32, + bits_service: RefPtr<BitsService>, + observer: RefPtr<nsIRequestObserver>, + context: Option<RefPtr<nsISupports>>, + callback: RefPtr<nsIBitsNewRequestCallback>, + ) -> StartDownloadTask { + StartDownloadTask(ServiceTask::new( + client_init_data, + ServiceAction::StartDownload, + StartDownloadData { + download_url, + save_rel_path, + proxy, + no_progress_timeout_secs, + update_interval_ms, + }, + StartDownloadTask::run_fn, + StartDownloadTask::done_fn, + bits_service, + observer, + context, + callback, + )) + } + + fn run_fn( + data: &StartDownloadData, + client: &mut BitsClient, + ) -> Result<StartDownloadSuccess, BitsTaskError> { + let url = nsCString_to_OsString(&data.download_url, StartDownload, CommandThread)?; + let path = nsCString_to_OsString(&data.save_rel_path, StartDownload, CommandThread)?; + let (success, monitor_client) = client + .start_job( + url, + path, + data.proxy, + data.no_progress_timeout_secs, + data.update_interval_ms, + ) + .map_err(|pipe_error| BitsTaskError::from_pipe(StartDownload, pipe_error))??; + Ok(StartDownloadSuccess { + guid: success.guid, + monitor_client, + }) + } + + fn done_fn( + _data: &StartDownloadData, + success: StartDownloadSuccess, + client_init_data: &ClientInitData, + bits_service: &BitsService, + observer: &nsIRequestObserver, + maybe_context: Option<&nsISupports>, + ) -> Result<RefPtr<BitsRequest>, BitsTaskError> { + BitsRequest::new( + success.guid.clone(), + RefPtr::new(bits_service), + client_init_data.monitor_timeout_ms, + RefPtr::new(&observer), + maybe_context.map(RefPtr::new), + success.monitor_client, + ServiceAction::StartDownload, + ) + } +} + +struct MonitorDownloadData { + guid: Guid, + update_interval_ms: u32, +} + +pub struct MonitorDownloadTask(ServiceTask<MonitorDownloadData, BitsMonitorClient>); + +impl Task for MonitorDownloadTask { + fn run(&self) { + self.0.run(); + } + + fn done(&self) -> Result<(), nsresult> { + self.0.done() + } +} + +impl MonitorDownloadTask { + pub fn new( + client_init_data: ClientInitData, + guid: Guid, + update_interval_ms: u32, + bits_service: RefPtr<BitsService>, + observer: RefPtr<nsIRequestObserver>, + context: Option<RefPtr<nsISupports>>, + callback: RefPtr<nsIBitsNewRequestCallback>, + ) -> MonitorDownloadTask { + MonitorDownloadTask(ServiceTask::new( + client_init_data, + ServiceAction::MonitorDownload, + MonitorDownloadData { + guid, + update_interval_ms, + }, + MonitorDownloadTask::run_fn, + MonitorDownloadTask::done_fn, + bits_service, + observer, + context, + callback, + )) + } + + fn run_fn( + data: &MonitorDownloadData, + client: &mut BitsClient, + ) -> Result<BitsMonitorClient, BitsTaskError> { + let result = client + .monitor_job(data.guid.clone(), data.update_interval_ms) + .map_err(|pipe_error| BitsTaskError::from_pipe(MonitorDownload, pipe_error)); + Ok(result??) + } + + fn done_fn( + data: &MonitorDownloadData, + monitor_client: BitsMonitorClient, + client_init_data: &ClientInitData, + bits_service: &BitsService, + observer: &nsIRequestObserver, + maybe_context: Option<&nsISupports>, + ) -> Result<RefPtr<BitsRequest>, BitsTaskError> { + BitsRequest::new( + data.guid.clone(), + RefPtr::new(bits_service), + client_init_data.monitor_timeout_ms, + RefPtr::new(&observer), + maybe_context.map(RefPtr::new), + monitor_client, + ServiceAction::MonitorDownload, + ) + } +} diff --git a/toolkit/components/bitsdownload/src/bits_interface/xpcom_methods.rs b/toolkit/components/bitsdownload/src/bits_interface/xpcom_methods.rs new file mode 100644 index 0000000000..cb267b9634 --- /dev/null +++ b/toolkit/components/bitsdownload/src/bits_interface/xpcom_methods.rs @@ -0,0 +1,195 @@ +/* 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 macro is very similar to xpcom_macro, but works a bit differently: +/// +/// When possible, it returns errors via the callback rather than via the return +/// value. +/// +/// It implicitly adds the callback argument of type: nsIBitsNewRequestCallback +/// +/// It needs an action type, to be specified before the rust name, in square +/// brackets. +/// +/// The rustic implementation that the xpcom method calls is expected to return +/// the type: Result<_, BitsTaskError>. If this value is Ok, it will be ignored. +/// If the value is Err, it will be returned via the callback passed. +/// +/// Usage like this: +/// +/// ```ignore +/// nsIBits_method!( +/// [ActionType] +/// rust_method => XpcomMethod( +/// foo: *const nsACString, +/// bar: *const nsIBar, +/// baz: bool, +/// [optional] qux: *const nsIQux, +/// ) +/// ); +/// ``` +/// +/// Results in the macro generating a method like: +/// +/// ```ignore +/// unsafe fn XpcomMethod( +/// &self, +/// foo: *const nsACString, +/// bar: *const nsIBar, +/// baz: bool, +/// qux: *const nsIQux, +/// callback: *const nsIBitsNewRequestCallback, +/// ) -> nsresult { +/// let callback: &nsIBitsNewRequestCallback = match xpcom::Ensure::ensure(callback) { +/// Ok(val) => val, +/// Err(result) => return result, +/// }; +/// let foo = match xpcom::Ensure::ensure(foo) { +/// Ok(val) => val, +/// Err(_) => { +/// dispatch_pretask_interface_error(BitsTaskError::new(ErrorType::NullArgument, ActionType.into(), ErrorStage::Pretask), callback); +/// return NS_OK; +/// } +/// }; +/// let bar = match xpcom::Ensure::ensure(bar) { +/// Ok(val) => val, +/// Err(_) => { +/// dispatch_pretask_interface_error(BitsTaskError::new(ErrorType::NullArgument, ActionType.into(), ErrorStage::Pretask), callback); +/// return NS_OK; +/// } +/// }; +/// let baz = match xpcom::Ensure::ensure(baz) { +/// Ok(val) => val, +/// Err(_) => { +/// dispatch_pretask_interface_error(BitsTaskError::new(ErrorType::NullArgument, ActionType.into(), ErrorStage::Pretask), callback); +/// return NS_OK; +/// } +/// }; +/// let qux = match xpcom::Ensure::ensure(qux) { +/// Ok(val) => Some(val), +/// Err(_) => None, +/// }; +/// +/// if let Err(error) = self.rust_method(foo, bar, baz, qux, callback) { +/// dispatch_pretask_interface_error(error, callback); +/// } +/// +/// NS_OK +/// } +/// ``` +/// +/// Which expects a Rustic implementation method like: +/// +/// ```ignore +/// fn rust_method( +/// &self, +/// foo: &nsACString, +/// bar: &nsIBar, +/// baz: bool, +/// qux: Option<&nsIQux>, +/// callback: &nsIBitsNewRequestCallback, +/// ) -> Result<(), BitsTaskError> { +/// do_something() +/// } +/// ``` +#[macro_export] +macro_rules! nsIBits_method { + // The internal rule @ensure_param converts raw pointer arguments to + // references, calling dispatch_pretask_interface_error and returning if the + // argument is null. + // If, however, the type is optional, the reference will also be wrapped + // in an option and null pointers will be converted to None. + (@ensure_param [optional] $name:ident, $action:expr, $callback:ident) => { + let $name = match Ensure::ensure($name) { + Ok(val) => Some(val), + Err(_) => None, + }; + }; + (@ensure_param $name:ident, $action:expr, $callback:ident) => { + let $name = match Ensure::ensure($name) { + Ok(val) => val, + Err(_) => { + dispatch_pretask_interface_error(BitsTaskError::new(NullArgument, $action.into(), Pretask), $callback); + return NS_OK; + } + }; + }; + + ([$action:expr] $rust_name:ident => $xpcom_name:ident($($([$param_required:ident])* $param_name:ident: $param_type:ty $(,)*)*)) => { + #[allow(non_snake_case)] + unsafe fn $xpcom_name(&self, $($param_name: $param_type, )* callback: *const nsIBitsNewRequestCallback) -> nsresult { + use xpcom::Ensure; + use nserror::NS_OK; + // When no params are passed, the imports below will not be used, so silence the + // warning + #[allow(unused_imports)] + use bits_interface::{ + dispatch_callback::dispatch_pretask_interface_error, + error::{BitsTaskError, ErrorStage::Pretask, ErrorType::NullArgument}, + }; + + let callback: &nsIBitsNewRequestCallback = match Ensure::ensure(callback) { + Ok(val) => val, + Err(result) => return result, + }; + $(nsIBits_method!(@ensure_param $([$param_required])* $param_name, $action, callback);)* + if let Err(error) = self.$rust_name($($param_name, )* callback) { + dispatch_pretask_interface_error(error, callback); + } + NS_OK + } + }; +} + +/* + * Same as above, but expects a nsIBitsCallback as its callback. + */ +#[macro_export] +macro_rules! nsIBitsRequest_method { + // The internal rule @ensure_param converts raw pointer arguments to + // references, calling dispatch_pretask_interface_error and returning if the + // argument is null. + // If, however, the type is optional, the reference will also be wrapped + // in an option and null pointers will be converted to None. + (@ensure_param [optional] $name:ident, $action:expr, $callback:ident) => { + let $name = match Ensure::ensure($name) { + Ok(val) => Some(val), + Err(_) => None, + }; + }; + (@ensure_param $name:ident, $action:expr, $callback:ident) => { + let $name = match Ensure::ensure($name) { + Ok(val) => val, + Err(_) => { + dispatch_pretask_request_error(BitsTaskError::new(NullArgument, $action.into(), Pretask), $callback); + return NS_OK; + } + }; + }; + + ([$action:expr] $rust_name:ident => $xpcom_name:ident($($([$param_required:ident])* $param_name:ident: $param_type:ty $(,)*)*)) => { + #[allow(non_snake_case)] + unsafe fn $xpcom_name(&self, $($param_name: $param_type, )* callback: *const nsIBitsCallback) -> nsresult { + use xpcom::Ensure; + use nserror::NS_OK; + // When no params are passed, the imports below will not be used, so silence the + // warning + #[allow(unused_imports)] + use bits_interface::{ + dispatch_callback::dispatch_pretask_request_error, + error::{BitsTaskError, ErrorStage::Pretask, ErrorType::NullArgument}, + }; + + let callback: &nsIBitsCallback = match Ensure::ensure(callback) { + Ok(val) => val, + Err(result) => return result, + }; + $(nsIBitsRequest_method!(@ensure_param $([$param_required])* $param_name, $action, callback);)* + if let Err(error) = self.$rust_name($($param_name, )* callback) { + dispatch_pretask_request_error(error, callback); + } + NS_OK + } + }; +} |