From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../bitsdownload/src/bits_interface/task/client.rs | 102 +++++ .../src/bits_interface/task/from_threadbound.rs | 125 ++++++ .../bitsdownload/src/bits_interface/task/mod.rs | 18 + .../src/bits_interface/task/request_task.rs | 425 +++++++++++++++++++++ .../src/bits_interface/task/service_task.rs | 332 ++++++++++++++++ 5 files changed, 1002 insertions(+) create mode 100644 toolkit/components/bitsdownload/src/bits_interface/task/client.rs create mode 100644 toolkit/components/bitsdownload/src/bits_interface/task/from_threadbound.rs create mode 100644 toolkit/components/bitsdownload/src/bits_interface/task/mod.rs create mode 100644 toolkit/components/bitsdownload/src/bits_interface/task/request_task.rs create mode 100644 toolkit/components/bitsdownload/src/bits_interface/task/service_task.rs (limited to 'toolkit/components/bitsdownload/src/bits_interface/task') 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> = 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( + init_data: &ClientInitData, + action: Action, + closure: F, +) -> Result +where + F: FnOnce(&mut BitsClient) -> Result, +{ + _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(action: Action, closure: F) -> Result +where + F: FnOnce(&mut BitsClient) -> Result, +{ + _with_bits_client(None, action, closure) +} + +fn _with_bits_client( + maybe_init_data: Option<&ClientInitData>, + action: Action, + closure: F, +) -> Result +where + F: FnOnce(&mut BitsClient) -> Result, +{ + 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>`), 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( + maybe_threadbound: &Option>, + 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>`), 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( + maybe_threadbound: &Option>, + 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 = fn(Guid, &D, &mut BitsClient) -> Result<(), BitsTaskError>; +type DoneFn = fn(&BitsRequest, bool) -> Result<(), BitsTaskError>; + +pub struct RequestTask { + request: AtomicCell>>, + guid: Guid, + action: RequestAction, + task_data: D, + run_fn: RunFn, + maybe_done_fn: Option, + callback: AtomicCell>>, + callback_presence: IsCallbackExpected, + result: AtomicCell>>, +} + +impl RequestTask +where + D: Sync + Send, +{ + pub fn new( + request: RefPtr, + guid: Guid, + action: RequestAction, + task_data: D, + run_fn: RunFn, + maybe_done_fn: Option, + callback: Option>, + callback_presence: IsCallbackExpected, + ) -> RequestTask { + 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 Task for RequestTask { + 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, + id: Guid, + callback: RefPtr, + ) -> 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, + id: Guid, + callback: Option>, + ) -> 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, + id: Guid, + callback: Option>, + ) -> 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, + id: Guid, + callback: Option>, + ) -> 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); + +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, + id: Guid, + update_interval_ms: u32, + callback: RefPtr, + ) -> 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); + +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, + id: Guid, + priority: Priority, + callback: RefPtr, + ) -> 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); + +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, + id: Guid, + timeout_secs: u32, + callback: RefPtr, + ) -> 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 = fn(&D, &mut BitsClient) -> Result; +type DoneFn = fn( + &D, + S, + &ClientInitData, + &BitsService, + &nsIRequestObserver, + Option<&nsISupports>, +) -> Result, BitsTaskError>; + +pub struct ServiceTask { + client_init_data: ClientInitData, + action: ServiceAction, + task_data: D, + run_fn: RunFn, + done_fn: DoneFn, + bits_service: AtomicCell>>, + observer: AtomicCell>>, + context: AtomicCell>>, + callback: AtomicCell>>, + result: AtomicCell>>, +} + +impl ServiceTask +where + D: Sync + Send, + S: Sync + Send, +{ + pub fn new( + client_init_data: ClientInitData, + action: ServiceAction, + task_data: D, + run_fn: RunFn, + done_fn: DoneFn, + bits_service: RefPtr, + observer: RefPtr, + context: Option>, + callback: RefPtr, + ) -> ServiceTask { + 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 Task for ServiceTask { + 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, 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); + +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, + observer: RefPtr, + context: Option>, + callback: RefPtr, + ) -> 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 { + 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, 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); + +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, + observer: RefPtr, + context: Option>, + callback: RefPtr, + ) -> 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 { + 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, 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, + ) + } +} -- cgit v1.2.3