Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

net: Use RequestId to cancel fetches instead of creating an IPC channel (#34883)

Browse source 
Instead of creating an IPC channel for every fetch, allow cancelling
fetches based on the `RequestId` of the original request. This requires
that `RequestId`s be UUIDs so that they are unique between processes
that might communicating with the resource process.

In addition, the resource process loop now keeps a `HashMap` or `Weak`
handles to cancellers and cleans them up.

This allows for creating mutiple `FetchCanceller`s in `script` for a
single fetch request, allowing integration of the media and video
elements to integrate with the `Document` canceller list -- meaning
these fetches also get cancelled when the `Document` unloads.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
This commit is contained in:
Martin Robinson 2025-01-11 12:49:22 +01:00 • committed by GitHub
parent e2be55b873
commit 748954d610
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
23 changed files with 179 additions and 226 deletions
Download patch file Download diff file Expand all files Collapse all files

1
components/fonts/font_context.rs
View file

@ -661,7 +661,6 @@ impl RemoteWebFontDownloader {
&core_resource_thread_clone,
request,
None,
None,
Box::new(move |response_message| {
match downloader.handle_web_font_fetch_message(response_message) {
DownloaderResponseResult::InProcess => {},

32
components/net/fetch/methods.rs
View file

@ -3,7 +3,7 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use std::borrow::Cow;
use std::sync::atomic::Ordering;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::{io, mem, str};
@ -15,7 +15,7 @@ use devtools_traits::DevtoolsControlMsg;
use headers::{AccessControlExposeHeaders, ContentType, HeaderMapExt};
use http::header::{self, HeaderMap, HeaderName};
use http::{Method, StatusCode};
use ipc_channel::ipc::{self, IpcReceiver};
use ipc_channel::ipc;
use log::warn;
use mime::{self, Mime};
use net_traits::filemanager_thread::{FileTokenCheck, RelativePos};
@ -59,37 +59,23 @@ pub struct FetchContext {
pub devtools_chan: Option<Arc<Mutex<Sender<DevtoolsControlMsg>>>>,
pub filemanager: Arc<Mutex<FileManager>>,
pub file_token: FileTokenCheck,
pub cancellation_listener: Arc<Mutex<CancellationListener>>,
pub cancellation_listener: Arc<CancellationListener>,
pub timing: ServoArc<Mutex<ResourceFetchTiming>>,
pub protocols: Arc<ProtocolRegistry>,
}
#[derive(Default)]
pub struct CancellationListener {
cancel_chan: Option<IpcReceiver<()>>,
cancelled: bool,
cancelled: AtomicBool,
}
impl CancellationListener {
pub fn new(cancel_chan: Option<IpcReceiver<()>>) -> Self {
Self {
cancel_chan,
cancelled: false,
}
pub(crate) fn cancelled(&self) -> bool {
self.cancelled.load(Ordering::Relaxed)
}
pub fn cancelled(&mut self) -> bool {
if let Some(ref cancel_chan) = self.cancel_chan {
if self.cancelled {
true
} else if cancel_chan.try_recv().is_ok() {
self.cancelled = true;
true
} else {
false
}
} else {
false
}
pub(crate) fn cancel(&self) {
self.cancelled.store(true, Ordering::Relaxed)
}
}
pub type DoneChannel = Option<(TokioSender<Data>, TokioReceiver<Data>)>;

8
components/net/filemanager_thread.rs
View file

@ -128,7 +128,7 @@ impl FileManager {
pub fn fetch_file(
&self,
done_sender: &mut TokioSender<Data>,
cancellation_listener: Arc<Mutex<CancellationListener>>,
cancellation_listener: Arc<CancellationListener>,
id: Uuid,
file_token: &FileTokenCheck,
origin: FileOrigin,
@ -211,7 +211,7 @@ impl FileManager {
done_sender: &mut TokioSender<Data>,
mut reader: BufReader<File>,
res_body: ServoArc<Mutex<ResponseBody>>,
cancellation_listener: Arc<Mutex<CancellationListener>>,
cancellation_listener: Arc<CancellationListener>,
range: RelativePos,
) {
let done_sender = done_sender.clone();
@ -220,7 +220,7 @@ impl FileManager {
.map(|pool| {
pool.spawn(move || {
loop {
if cancellation_listener.lock().unwrap().cancelled() {
if cancellation_listener.cancelled() {
*res_body.lock().unwrap() = ResponseBody::Done(vec![]);
let _ = done_sender.send(Data::Cancelled);
return;
@ -282,7 +282,7 @@ impl FileManager {
fn fetch_blob_buf(
&self,
done_sender: &mut TokioSender<Data>,
cancellation_listener: Arc<Mutex<CancellationListener>>,
cancellation_listener: Arc<CancellationListener>,
id: &Uuid,
file_token: &FileTokenCheck,
origin_in: &FileOrigin,

4
components/net/http_loader.rs
View file

@ -1944,7 +1944,7 @@ async fn http_network_fetch(
let meta_status = meta.status;
let meta_headers = meta.headers;
let cancellation_listener = context.cancellation_listener.clone();
if cancellation_listener.lock().unwrap().cancelled() {
if cancellation_listener.cancelled() {
return Response::network_error(NetworkError::Internal("Fetch aborted".into()));
}
@ -1983,7 +1983,7 @@ async fn http_network_fetch(
warn!("Error streaming response body: {:?}", e);
})
.try_fold(res_body, move |res_body, chunk| {
if cancellation_listener.lock().unwrap().cancelled() {
if cancellation_listener.cancelled() {
*res_body.lock().unwrap() = ResponseBody::Done(vec![]);
let _ = done_sender.send(Data::Cancelled);
return future::ready(Err(()));

78
components/net/resource_thread.rs
View file

@ -10,7 +10,7 @@ use std::fs::File;
use std::io::prelude::*;
use std::io::{self, BufReader};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, RwLock};
use std::sync::{Arc, Mutex, RwLock, Weak};
use std::thread;
use std::time::Duration;
@ -24,7 +24,7 @@ use log::{debug, warn};
use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
use net_traits::blob_url_store::parse_blob_url;
use net_traits::filemanager_thread::FileTokenCheck;
use net_traits::request::{Destination, RequestBuilder};
use net_traits::request::{Destination, RequestBuilder, RequestId};
use net_traits::response::{Response, ResponseInit};
use net_traits::storage_thread::StorageThreadMsg;
use net_traits::{
@ -142,6 +142,7 @@ pub fn new_core_resource_thread(
config_dir,
ca_certificates,
ignore_certificate_errors,
cancellation_listeners: Default::default(),
};
mem_profiler_chan.run_with_memory_reporting(
@ -168,6 +169,7 @@ struct ResourceChannelManager {
config_dir: Option<PathBuf>,
ca_certificates: CACertificates,
ignore_certificate_errors: bool,
cancellation_listeners: HashMap<RequestId, Weak<CancellationListener>>,
}
fn create_http_states(
@ -300,6 +302,30 @@ impl ResourceChannelManager {
msg.send(vec![public_report, private_report]);
}
fn cancellation_listener(&self, request_id: RequestId) -> Option<Arc<CancellationListener>> {
self.cancellation_listeners
.get(&request_id)
.and_then(Weak::upgrade)
}
fn get_or_create_cancellation_listener(
&mut self,
request_id: RequestId,
) -> Arc<CancellationListener> {
if let Some(listener) = self.cancellation_listener(request_id) {
return listener;
}
// Clear away any cancellation listeners that are no longer valid.
self.cancellation_listeners
.retain(|_, listener| listener.strong_count() > 0);
let cancellation_listener = Arc::new(Default::default());
self.cancellation_listeners
.insert(request_id, Arc::downgrade(&cancellation_listener));
cancellation_listener
}
/// Returns false if the thread should exit.
fn process_msg(
&mut self,
@ -308,33 +334,45 @@ impl ResourceChannelManager {
protocols: Arc<ProtocolRegistry>,
) -> bool {
match msg {
CoreResourceMsg::Fetch(req_init, channels) => match channels {
FetchChannels::ResponseMsg(sender, cancel_chan) => self.resource_manager.fetch(
req_init,
None,
sender,
http_state,
cancel_chan,
protocols,
),
CoreResourceMsg::Fetch(request_builder, channels) => match channels {
FetchChannels::ResponseMsg(sender) => {
let cancellation_listener =
self.get_or_create_cancellation_listener(request_builder.id);
self.resource_manager.fetch(
request_builder,
None,
sender,
http_state,
cancellation_listener,
protocols,
);
},
FetchChannels::WebSocket {
event_sender,
action_receiver,
} => self.resource_manager.websocket_connect(
req_init,
request_builder,
event_sender,
action_receiver,
http_state,
),
FetchChannels::Prefetch => self.resource_manager.fetch(
req_init,
request_builder,
None,
DiscardFetch,
http_state,
None,
Arc::new(Default::default()),
protocols,
),
},
CoreResourceMsg::Cancel(request_ids) => {
for cancellation_listener in request_ids
.into_iter()
.filter_map(|request_id| self.cancellation_listener(request_id))
{
cancellation_listener.cancel();
}
},
CoreResourceMsg::DeleteCookies(request) => {
http_state
.cookie_jar
@ -343,13 +381,15 @@ impl ResourceChannelManager {
.clear_storage(&request);
return true;
},
CoreResourceMsg::FetchRedirect(req_init, res_init, sender, cancel_chan) => {
CoreResourceMsg::FetchRedirect(request_builder, res_init, sender) => {
let cancellation_listener =
self.get_or_create_cancellation_listener(request_builder.id);
self.resource_manager.fetch(
req_init,
request_builder,
Some(res_init),
sender,
http_state,
cancel_chan,
cancellation_listener,
protocols,
)
},
@ -698,7 +738,7 @@ impl CoreResourceManager {
res_init_: Option<ResponseInit>,
mut sender: Target,
http_state: &Arc<HttpState>,
cancel_chan: Option<IpcReceiver<()>>,
cancellation_listener: Arc<CancellationListener>,
protocols: Arc<ProtocolRegistry>,
) {
let http_state = http_state.clone();
@ -746,7 +786,7 @@ impl CoreResourceManager {
devtools_chan: dc.map(|dc| Arc::new(Mutex::new(dc))),
filemanager: Arc::new(Mutex::new(filemanager)),
file_token,
cancellation_listener: Arc::new(Mutex::new(CancellationListener::new(cancel_chan))),
cancellation_listener,
timing: ServoArc::new(Mutex::new(ResourceFetchTiming::new(request.timing_type()))),
protocols,
};

8
components/net/tests/fetch.rs
View file

@ -26,7 +26,7 @@ use hyper::body::{Bytes, Incoming};
use hyper::{Request as HyperRequest, Response as HyperResponse};
use mime::{self, Mime};
use net::fetch::cors_cache::CorsCache;
use net::fetch::methods::{self, CancellationListener, FetchContext};
use net::fetch::methods::{self, FetchContext};
use net::filemanager_thread::FileManager;
use net::hsts::HstsEntry;
use net::protocols::ProtocolRegistry;
@ -702,7 +702,7 @@ fn test_fetch_with_hsts() {
Weak::new(),
))),
file_token: FileTokenCheck::NotRequired,
cancellation_listener: Arc::new(Mutex::new(CancellationListener::new(None))),
cancellation_listener: Arc::new(Default::default()),
timing: ServoArc::new(Mutex::new(ResourceFetchTiming::new(
ResourceTimingType::Navigation,
))),
@ -759,7 +759,7 @@ fn test_load_adds_host_to_hsts_list_when_url_is_https() {
Weak::new(),
))),
file_token: FileTokenCheck::NotRequired,
cancellation_listener: Arc::new(Mutex::new(CancellationListener::new(None))),
cancellation_listener: Arc::new(Default::default()),
timing: ServoArc::new(Mutex::new(ResourceFetchTiming::new(
ResourceTimingType::Navigation,
))),
@ -818,7 +818,7 @@ fn test_fetch_self_signed() {
Weak::new(),
))),
file_token: FileTokenCheck::NotRequired,
cancellation_listener: Arc::new(Mutex::new(CancellationListener::new(None))),
cancellation_listener: Arc::new(Default::default()),
timing: ServoArc::new(Mutex::new(ResourceFetchTiming::new(
ResourceTimingType::Navigation,
))),

4
components/net/tests/main.rs
View file

@ -39,7 +39,7 @@ use hyper::{Request as HyperRequest, Response as HyperResponse};
use hyper_util::rt::tokio::TokioIo;
use net::connector::{create_http_client, create_tls_config};
use net::fetch::cors_cache::CorsCache;
use net::fetch::methods::{self, CancellationListener, FetchContext};
use net::fetch::methods::{self, FetchContext};
use net::filemanager_thread::FileManager;
use net::protocols::ProtocolRegistry;
use net::resource_thread::CoreResourceThreadPool;
@ -183,7 +183,7 @@ fn new_fetch_context(
pool_handle.unwrap_or_else(|| Weak::new()),
))),
file_token: FileTokenCheck::NotRequired,
cancellation_listener: Arc::new(Mutex::new(CancellationListener::new(None))),
cancellation_listener: Arc::new(Default::default()),
timing: ServoArc::new(Mutex::new(ResourceFetchTiming::new(
ResourceTimingType::Navigation,
))),

20
components/script/document_loader.rs
View file

@ -6,7 +6,6 @@
//!
//! <https://html.spec.whatwg.org/multipage/#the-end>
use ipc_channel::ipc;
use net_traits::request::RequestBuilder;
use net_traits::{fetch_async, BoxedFetchCallback, ResourceThreads};
use servo_url::ServoUrl;
@ -121,7 +120,7 @@ impl DocumentLoader {
callback: BoxedFetchCallback,
) {
self.add_blocking_load(load);
self.fetch_async_background(request, callback, None);
self.fetch_async_background(request, callback);
}
/// Initiate a new fetch that does not block the document load event.
@ -129,22 +128,9 @@ impl DocumentLoader {
&mut self,
request: RequestBuilder,
callback: BoxedFetchCallback,
cancel_override: Option<ipc::IpcReceiver<()>>,
) {
let canceller = cancel_override.unwrap_or_else(|| {
let mut canceller = FetchCanceller::new();
let cancel_receiver = canceller.initialize();
self.cancellers.push(canceller);
cancel_receiver
});
fetch_async(
&self.resource_threads.core_thread,
request,
None, /* response_init */
Some(canceller),
callback,
);
self.cancellers.push(FetchCanceller::new(request.id));
fetch_async(&self.resource_threads.core_thread, request, None, callback);
}
/// Mark an in-progress network request complete.

4
components/script/dom/document.rs
View file

@ -2150,7 +2150,6 @@ impl Document {
&self,
request: RequestBuilder,
listener: Listener,
cancel_override: Option<ipc::IpcReceiver<()>>,
) {
let callback = NetworkListener {
context: std::sync::Arc::new(Mutex::new(listener)),
@ -2161,8 +2160,7 @@ impl Document {
.into(),
}
.into_callback();
self.loader_mut()
.fetch_async_background(request, callback, cancel_override);
self.loader_mut().fetch_async_background(request, callback);
}
// https://html.spec.whatwg.org/multipage/#the-end

6
components/script/dom/eventsource.rs
View file

@ -602,12 +602,12 @@ impl EventSourceMethods<crate::DomTypeHolder> for EventSource {
listener.notify_fetch(message.unwrap());
}),
);
let cancel_receiver = ev.canceller.borrow_mut().initialize();
*ev.canceller.borrow_mut() = FetchCanceller::new(request.id);
global
.core_resource_thread()
.send(CoreResourceMsg::Fetch(
request,
FetchChannels::ResponseMsg(action_sender, Some(cancel_receiver)),
FetchChannels::ResponseMsg(action_sender),
))
.unwrap();
// Step 13
@ -681,7 +681,7 @@ impl EventSourceTimeoutCallback {
.core_resource_thread()
.send(CoreResourceMsg::Fetch(
request,
FetchChannels::ResponseMsg(self.action_sender, None),
FetchChannels::ResponseMsg(self.action_sender),
))
.unwrap();
}

5
components/script/dom/globalscope.rs
View file

@ -3242,13 +3242,12 @@ impl GlobalScope {
request_builder: RequestBuilder,
context: Arc<Mutex<Listener>>,
task_source: SendableTaskSource,
cancellation_sender: Option<ipc::IpcReceiver<()>>,
) {
let network_listener = NetworkListener {
context,
task_source,
};
self.fetch_with_network_listener(request_builder, network_listener, cancellation_sender);
self.fetch_with_network_listener(request_builder, network_listener);
}
pub(crate) fn fetch_with_network_listener<
@ -3257,13 +3256,11 @@ impl GlobalScope {
&self,
request_builder: RequestBuilder,
network_listener: NetworkListener<Listener>,
cancellation_receiver: Option<ipc::IpcReceiver<()>>,
) {
fetch_async(
&self.core_resource_thread(),
request_builder,
None,
cancellation_receiver,
network_listener.into_callback(),
);
}

2
components/script/dom/htmlimageelement.rs
View file

@ -419,7 +419,7 @@ impl HTMLImageElement {
// This is a background load because the load blocker already fulfills the
// purpose of delaying the document's load event.
document.fetch_background(request, context, None);
document.fetch_background(request, context);
}
// Steps common to when an image has been loaded.

2
components/script/dom/htmllinkelement.rs
View file

@ -384,7 +384,7 @@ impl HTMLLinkElement {
resource_timing: ResourceFetchTiming::new(ResourceTimingType::Resource),
};
document.fetch_background(request, fetch_context, None);
document.fetch_background(request, fetch_context);
}
/// <https://html.spec.whatwg.org/multipage/#concept-link-obtain>

26
components/script/dom/htmlmediaelement.rs
View file

@ -898,15 +898,12 @@ impl HTMLMediaElement {
if let Some(ref mut current_fetch_context) = *current_fetch_context {
current_fetch_context.cancel(CancelReason::Overridden);
}
let (fetch_context, cancel_receiver) = HTMLMediaElementFetchContext::new();
*current_fetch_context = Some(fetch_context);
*current_fetch_context = Some(HTMLMediaElementFetchContext::new(request.id));
let listener =
HTMLMediaElementFetchListener::new(self, url.clone(), offset.unwrap_or(0), seek_lock);
// TODO: If this is supposed to to be a "fetch" as defined in the specification
// this should probably be integrated into the Document's list of cancellable fetches.
self.owner_document()
.fetch_background(request, listener, Some(cancel_receiver));
self.owner_document().fetch_background(request, listener);
}
// https://html.spec.whatwg.org/multipage/#concept-media-load-resource
@ -2598,17 +2595,12 @@ pub(crate) struct HTMLMediaElementFetchContext {
}
impl HTMLMediaElementFetchContext {
fn new() -> (HTMLMediaElementFetchContext, ipc::IpcReceiver<()>) {
let mut fetch_canceller = FetchCanceller::new();
let cancel_receiver = fetch_canceller.initialize();
(
HTMLMediaElementFetchContext {
cancel_reason: None,
is_seekable: false,
fetch_canceller,
},
cancel_receiver,
)
fn new(request_id: RequestId) -> HTMLMediaElementFetchContext {
HTMLMediaElementFetchContext {
cancel_reason: None,
is_seekable: false,
fetch_canceller: FetchCanceller::new(request_id),
}
}
fn is_seekable(&self) -> bool {

43
components/script/dom/htmlvideoelement.rs
View file

@ -54,8 +54,6 @@ pub(crate) struct HTMLVideoElement {
video_height: Cell<Option<u32>>,
/// Incremented whenever tasks associated with this element are cancelled.
generation_id: Cell<u32>,
/// Poster frame fetch request canceller.
poster_frame_canceller: DomRefCell<FetchCanceller>,
/// Load event blocker. Will block the load event while the poster frame
/// is being fetched.
load_blocker: DomRefCell<Option<LoadBlocker>>,
@ -78,7 +76,6 @@ impl HTMLVideoElement {
video_width: Cell::new(None),
video_height: Cell::new(None),
generation_id: Cell::new(0),
poster_frame_canceller: DomRefCell::new(Default::default()),
load_blocker: Default::default(),
last_frame: Default::default(),
sent_resize: Cell::new(None),
@ -162,7 +159,6 @@ impl HTMLVideoElement {
/// <https://html.spec.whatwg.org/multipage/#poster-frame>
fn fetch_poster_frame(&self, poster_url: &str, can_gc: CanGc) {
// Step 1.
let cancel_receiver = self.poster_frame_canceller.borrow_mut().initialize();
self.generation_id.set(self.generation_id.get() + 1);
// Step 2.
@ -199,20 +195,14 @@ impl HTMLVideoElement {
self.process_image_response(ImageResponse::Loaded(image, url), can_gc);
},
ImageCacheResult::ReadyForRequest(id) => {
self.do_fetch_poster_frame(poster_url, id, cancel_receiver, can_gc)
self.do_fetch_poster_frame(poster_url, id, can_gc);
},
_ => (),
}
}
/// <https://html.spec.whatwg.org/multipage/#poster-frame>
fn do_fetch_poster_frame(
&self,
poster_url: ServoUrl,
id: PendingImageId,
cancel_receiver: ipc::IpcReceiver<()>,
can_gc: CanGc,
) {
fn do_fetch_poster_frame(&self, poster_url: ServoUrl, id: PendingImageId, can_gc: CanGc) {
// Continuation of step 4.
let document = self.owner_document();
let request = RequestBuilder::new(poster_url.clone(), document.global().get_referrer())
@ -235,12 +225,8 @@ impl HTMLVideoElement {
LoadType::Image(poster_url.clone()),
));
let context = PosterFrameFetchContext::new(self, poster_url, id);
// TODO: If this is supposed to to be a "fetch" as defined in the specification
// this should probably be integrated into the Document's list of cancellable fetches.
self.owner_document()
.fetch_background(request, context, Some(cancel_receiver));
let context = PosterFrameFetchContext::new(self, poster_url, id, request.id);
self.owner_document().fetch_background(request, context);
}
}
@ -338,11 +324,16 @@ struct PosterFrameFetchContext {
resource_timing: ResourceFetchTiming,
/// Url for the resource
url: ServoUrl,
/// A [`FetchCanceller`] for this request.
fetch_canceller: FetchCanceller,
}
impl FetchResponseListener for PosterFrameFetchContext {
fn process_request_body(&mut self, _: RequestId) {}
fn process_request_eof(&mut self, _: RequestId) {}
fn process_request_eof(&mut self, _: RequestId) {
self.fetch_canceller.ignore()
}
fn process_response(
&mut self,
@ -365,11 +356,7 @@ impl FetchResponseListener for PosterFrameFetchContext {
if !status_is_ok {
self.cancelled = true;
self.elem
.root()
.poster_frame_canceller
.borrow_mut()
.cancel();
self.fetch_canceller.cancel();
}
}
@ -433,7 +420,12 @@ impl PreInvoke for PosterFrameFetchContext {
}
impl PosterFrameFetchContext {
fn new(elem: &HTMLVideoElement, url: ServoUrl, id: PendingImageId) -> PosterFrameFetchContext {
fn new(
elem: &HTMLVideoElement,
url: ServoUrl,
id: PendingImageId,
request_id: RequestId,
) -> PosterFrameFetchContext {
let window = elem.owner_window();
PosterFrameFetchContext {
image_cache: window.image_cache(),
@ -442,6 +434,7 @@ impl PosterFrameFetchContext {
cancelled: false,
resource_timing: ResourceFetchTiming::new(ResourceTimingType::Resource),
url,
fetch_canceller: FetchCanceller::new(request_id),
}
}
}

26
components/script/dom/xmlhttprequest.rs
View file

@ -18,7 +18,6 @@ use html5ever::serialize::SerializeOpts;
use http::header::{self, HeaderMap, HeaderName, HeaderValue};
use http::Method;
use hyper_serde::Serde;
use ipc_channel::ipc;
use js::jsapi::{Heap, JS_ClearPendingException};
use js::jsval::{JSVal, NullValue};
use js::rust::wrappers::JS_ParseJSON;
@ -291,16 +290,6 @@ impl XMLHttpRequest {
fn sync_in_window(&self) -> bool {
self.sync.get() && self.global().is::<Window>()
}
fn initiate_async_xhr(
context: Arc<Mutex<XHRContext>>,
task_source: SendableTaskSource,
global: &GlobalScope,
init: RequestBuilder,
cancellation_chan: ipc::IpcReceiver<()>,
) {
global.fetch(init, context, task_source, Some(cancellation_chan));
}
}
impl XMLHttpRequestMethods<crate::DomTypeHolder> for XMLHttpRequest {
@ -1548,7 +1537,7 @@ impl XMLHttpRequest {
self.response_status.set(Err(()));
}
fn fetch(&self, init: RequestBuilder, global: &GlobalScope) -> ErrorResult {
fn fetch(&self, request_builder: RequestBuilder, global: &GlobalScope) -> ErrorResult {
let xhr = Trusted::new(self);
let context = Arc::new(Mutex::new(XHRContext {
@ -1556,7 +1545,7 @@ impl XMLHttpRequest {
gen_id: self.generation_id.get(),
sync_status: DomRefCell::new(None),
resource_timing: ResourceFetchTiming::new(ResourceTimingType::Resource),
url: init.url.clone(),
url: request_builder.url.clone(),
}));
let (task_source, script_port) = if self.sync.get() {
@ -1577,15 +1566,8 @@ impl XMLHttpRequest {
)
};
let cancel_receiver = self.canceller.borrow_mut().initialize();
XMLHttpRequest::initiate_async_xhr(
context.clone(),
task_source,
global,
init,
cancel_receiver,
);
*self.canceller.borrow_mut() = FetchCanceller::new(request_builder.id);
global.fetch(request_builder, context.clone(), task_source);
if let Some(script_port) = script_port {
loop {

37
components/script/fetch.rs
View file

@ -12,9 +12,9 @@ use net_traits::request::{
RequestBuilder, RequestId, RequestMode, ServiceWorkersMode,
};
use net_traits::{
CoreResourceMsg, CoreResourceThread, FetchChannels, FetchMetadata, FetchResponseListener,
FetchResponseMsg, FilteredMetadata, Metadata, NetworkError, ResourceFetchTiming,
ResourceTimingType,
cancel_async_fetch, CoreResourceMsg, CoreResourceThread, FetchChannels, FetchMetadata,
FetchResponseListener, FetchResponseMsg, FilteredMetadata, Metadata, NetworkError,
ResourceFetchTiming, ResourceTimingType,
};
use servo_url::ServoUrl;
@ -52,44 +52,34 @@ struct FetchContext {
/// or let it cancel on Drop in that case.
#[derive(Default, JSTraceable, MallocSizeOf)]
pub(crate) struct FetchCanceller {
#[ignore_malloc_size_of = "channels are hard"]
#[no_trace]
cancel_chan: Option<ipc::IpcSender<()>>,
request_id: Option<RequestId>,
}
impl FetchCanceller {
/// Create an empty FetchCanceller
pub(crate) fn new() -> Self {
Default::default()
}
/// Obtain an IpcReceiver to send over to Fetch, and initialize
/// the internal sender
pub(crate) fn initialize(&mut self) -> ipc::IpcReceiver<()> {
// cancel previous fetch
self.cancel();
let (rx, tx) = ipc::channel().unwrap();
self.cancel_chan = Some(rx);
tx
pub(crate) fn new(request_id: RequestId) -> Self {
Self {
request_id: Some(request_id),
}
}
/// Cancel a fetch if it is ongoing
pub(crate) fn cancel(&mut self) {
if let Some(chan) = self.cancel_chan.take() {
if let Some(request_id) = self.request_id.take() {
// stop trying to make fetch happen
// it's not going to happen
// The receiver will be destroyed if the request has already completed;
// so we throw away the error. Cancellation is a courtesy call,
// No error handling here. Cancellation is a courtesy call,
// we don't actually care if the other side heard.
let _ = chan.send(());
cancel_async_fetch(vec![request_id]);
}
}
/// Use this if you don't want it to send a cancellation request
/// on drop (e.g. if the fetch completes)
pub(crate) fn ignore(&mut self) {
let _ = self.cancel_chan.take();
let _ = self.request_id.take();
}
}
@ -197,7 +187,6 @@ pub(crate) fn Fetch(
request_init,
fetch_context,
global.task_manager().networking_task_source().to_sendable(),
None,
);
// Step 13. Return p.
@ -344,7 +333,7 @@ pub(crate) fn load_whole_resource(
core_resource_thread
.send(CoreResourceMsg::Fetch(
request,
FetchChannels::ResponseMsg(action_sender, None),
FetchChannels::ResponseMsg(action_sender),
))
.unwrap();

2
components/script/layout_image.rs
View file

@ -112,5 +112,5 @@ pub(crate) fn fetch_image_for_layout(
.pipeline_id(Some(document.global().pipeline_id()));
// Layout image loads do not delay the document load event.
document.fetch_background(request, context, None);
document.fetch_background(request, context);
}

3
components/script/navigation.rs
View file

@ -13,7 +13,6 @@ use base::id::{BrowsingContextId, PipelineId, TopLevelBrowsingContextId};
use content_security_policy::Destination;
use crossbeam_channel::Sender;
use http::header;
use ipc_channel::ipc;
use net_traits::request::{CredentialsMode, RedirectMode, RequestBuilder, RequestMode};
use net_traits::response::ResponseInit;
use net_traits::{
@ -55,13 +54,11 @@ impl NavigationListener {
self,
core_resource_thread: &CoreResourceThread,
response_init: Option<ResponseInit>,
cancellation_receiver: Option<ipc::IpcReceiver<()>>,
) {
fetch_async(
core_resource_thread,
self.request_builder.clone(),
response_init,
cancellation_receiver,
self.into_callback(),
);
}

2
components/script/script_module.rs
View file

@ -1780,7 +1780,7 @@ fn fetch_single_module_script(
network_listener.into_callback(),
);
},
None => global.fetch_with_network_listener(request, network_listener, None),
None => global.fetch_with_network_listener(request, network_listener),
}
}

30
components/script/script_thread.rs
View file

@ -139,6 +139,7 @@ use crate::dom::window::Window;
use crate::dom::windowproxy::{CreatorBrowsingContextInfo, WindowProxy};
use crate::dom::worklet::WorkletThreadPool;
use crate::dom::workletglobalscope::WorkletGlobalScopeInit;
use crate::fetch::FetchCanceller;
use crate::messaging::{
CommonScriptMsg, MainThreadScriptMsg, MixedMessage, ScriptEventLoopSender,
ScriptThreadReceivers, ScriptThreadSenders,
@ -3426,17 +3427,10 @@ impl ScriptThread {
.borrow_mut()
.push((incomplete.pipeline_id, context));
let cancellation_receiver = incomplete.canceller.initialize();
NavigationListener::new(
incomplete.request_builder(),
self.senders.self_sender.clone(),
)
.initiate_fetch(
&self.resource_threads.core_thread,
None,
Some(cancellation_receiver),
);
let request_builder = incomplete.request_builder();
incomplete.canceller = FetchCanceller::new(request_builder.id);
NavigationListener::new(request_builder, self.senders.self_sender.clone())
.initiate_fetch(&self.resource_threads.core_thread, None);
self.incomplete_loads.borrow_mut().push(incomplete);
}
@ -3557,12 +3551,9 @@ impl ScriptThread {
.unwrap_or(200),
});
let cancellation_receiver = incomplete_load.canceller.initialize();
NavigationListener::new(request_builder, self.senders.self_sender.clone()).initiate_fetch(
&self.resource_threads.core_thread,
response_init,
Some(cancellation_receiver),
);
incomplete_load.canceller = FetchCanceller::new(request_builder.id);
NavigationListener::new(request_builder, self.senders.self_sender.clone())
.initiate_fetch(&self.resource_threads.core_thread, response_init);
}
/// Synchronously fetch `about:blank`. Stores the `InProgressLoad`
@ -3590,7 +3581,7 @@ impl ScriptThread {
self.incomplete_loads.borrow_mut().push(incomplete);
let dummy_request_id = RequestId::next();
let dummy_request_id = RequestId::default();
context.process_response(dummy_request_id, Ok(FetchMetadata::Unfiltered(meta)));
context.process_response_chunk(dummy_request_id, chunk);
context.process_response_eof(
@ -3614,7 +3605,8 @@ impl ScriptThread {
self.incomplete_loads.borrow_mut().push(incomplete);
let mut context = ParserContext::new(id, url);
let dummy_request_id = RequestId::next();
let dummy_request_id = RequestId::default();
context.process_response(dummy_request_id, Ok(FetchMetadata::Unfiltered(meta)));
context.process_response_chunk(dummy_request_id, chunk);
context.process_response_eof(

44
components/shared/net/lib.rs
View file

@ -464,10 +464,7 @@ pub enum WebSocketNetworkEvent {
#[derive(Debug, Deserialize, Serialize)]
/// IPC channels to communicate with the script thread about network or DOM events.
pub enum FetchChannels {
ResponseMsg(
IpcSender<FetchResponseMsg>,
/* cancel_chan */ Option<IpcReceiver<()>>,
),
ResponseMsg(IpcSender<FetchResponseMsg>),
WebSocket {
event_sender: IpcSender<WebSocketNetworkEvent>,
action_receiver: IpcReceiver<WebSocketDomAction>,
@ -480,13 +477,9 @@ pub enum FetchChannels {
#[derive(Debug, Deserialize, Serialize)]
pub enum CoreResourceMsg {
Fetch(RequestBuilder, FetchChannels),
Cancel(Vec<RequestId>),
/// Initiate a fetch in response to processing a redirection
FetchRedirect(
RequestBuilder,
ResponseInit,
IpcSender<FetchResponseMsg>,
/* cancel_chan */ Option<IpcReceiver<()>>,
),
FetchRedirect(RequestBuilder, ResponseInit, IpcSender<FetchResponseMsg>),
/// Store a cookie for a given originating URL
SetCookieForUrl(ServoUrl, Serde<Cookie<'static>>, CookieSource),
/// Store a set of cookies for a given originating URL
@ -522,10 +515,10 @@ pub enum CoreResourceMsg {
// FIXME: https://github.com/servo/servo/issues/34591
#[expect(clippy::large_enum_variant)]
enum ToFetchThreadMessage {
Cancel(Vec<RequestId>),
StartFetch(
/* request_builder */ RequestBuilder,
/* response_init */ Option<ResponseInit>,
/* cancel_chan */ Option<IpcReceiver<()>>,
/* callback */ BoxedFetchCallback,
),
FetchResponse(FetchResponseMsg),
@ -584,12 +577,7 @@ impl FetchThread {
fn run(&mut self) {
loop {
match self.receiver.recv().unwrap() {
ToFetchThreadMessage::StartFetch(
request_builder,
response_init,
canceller,
callback,
) => {
ToFetchThreadMessage::StartFetch(request_builder, response_init, callback) => {
self.active_fetches.insert(request_builder.id, callback);
// Only redirects have a `response_init` field.
@ -598,11 +586,10 @@ impl FetchThread {
request_builder,
response_init,
self.to_fetch_sender.clone(),
canceller,
),
None => CoreResourceMsg::Fetch(
request_builder,
FetchChannels::ResponseMsg(self.to_fetch_sender.clone(), canceller),
FetchChannels::ResponseMsg(self.to_fetch_sender.clone()),
),
};
@ -623,6 +610,14 @@ impl FetchThread {
self.active_fetches.remove(&request_id);
}
},
ToFetchThreadMessage::Cancel(request_ids) => {
// Errors are ignored here, because Servo sends many cancellation requests when shutting down.
// At this point the networking task might be shut down completely, so just ignore errors
// during this time.
let _ = self
.core_resource_thread
.send(CoreResourceMsg::Cancel(request_ids));
},
}
}
}
@ -635,7 +630,6 @@ pub fn fetch_async(
core_resource_thread: &CoreResourceThread,
request: RequestBuilder,
response_init: Option<ResponseInit>,
canceller: Option<IpcReceiver<()>>,
callback: BoxedFetchCallback,
) {
let _ = FETCH_THREAD
@ -643,11 +637,19 @@ pub fn fetch_async(
.send(ToFetchThreadMessage::StartFetch(
request,
response_init,
canceller,
callback,
));
}
/// Instruct the resource thread to cancel an existing request. Does nothing if the
/// request has already completed or has not been fetched yet.
pub fn cancel_async_fetch(request_ids: Vec<RequestId>) {
let _ = FETCH_THREAD
.get()
.expect("Tried to cancel request in process that hasn't started one.")
.send(ToFetchThreadMessage::Cancel(request_ids));
}
#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
pub struct ResourceCorsData {
/// CORS Preflight flag

18
components/shared/net/request.rs
View file

@ -2,7 +2,6 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use base::id::{PipelineId, TopLevelBrowsingContextId};
@ -14,6 +13,7 @@ use malloc_size_of_derive::MallocSizeOf;
use mime::Mime;
use serde::{Deserialize, Serialize};
use servo_url::{ImmutableOrigin, ServoUrl};
use uuid::Uuid;
use crate::policy_container::{PolicyContainer, RequestPolicyContainer};
use crate::response::HttpsState;
@ -21,12 +21,11 @@ use crate::{ReferrerPolicy, ResourceTimingType};
#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
/// An id to differeniate one network request from another.
pub struct RequestId(usize);
pub struct RequestId(Uuid);
impl RequestId {
pub fn next() -> Self {
static NEXT_REQUEST_ID: AtomicUsize = AtomicUsize::new(0);
Self(NEXT_REQUEST_ID.fetch_add(1, Ordering::Relaxed))
impl Default for RequestId {
fn default() -> Self {
Self(servo_rand::random_uuid())
}
}
@ -283,7 +282,7 @@ pub struct RequestBuilder {
impl RequestBuilder {
pub fn new(url: ServoUrl, referrer: Referrer) -> RequestBuilder {
RequestBuilder {
id: RequestId::next(),
id: RequestId::default(),
method: Method::GET,
url,
headers: HeaderMap::new(),
@ -471,8 +470,9 @@ impl RequestBuilder {
/// the Fetch spec.
#[derive(Clone, MallocSizeOf)]
pub struct Request {
/// The id of this request so that the task that triggered it can route
/// messages to the correct listeners.
/// The unique id of this request so that the task that triggered it can route
/// messages to the correct listeners. This is a UUID that is generated when a request
/// is being built.
pub id: RequestId,
/// <https://fetch.spec.whatwg.org/#concept-request-method>
#[ignore_malloc_size_of = "Defined in hyper"]