mirror of
https://github.com/servo/servo.git
synced 2025-06-09 00:53:26 +00:00
75eb94afca
I moved away from the `Window` struct all the logic to handle task sources, into a new struct called `TaskManager`. In a happy world, I'd be able to just have there two functions, of the types: ```rust fn task_source<T: TaskSource>(&self, name: TaskSourceName) -> Box<T> fn task_source_with_canceller<T: TaskSource>(&self, name: TaskSourceName) -> (Box<T>, TaskSourceCanceller) ``` And not so much duplicated code. However, because TaskSource can't be a trait object (because it has generic type parameters), that's not possible. Instead, I decided to reduce duplicated logic through macros. For reasons[1], I have to pass both the name of the function with canceller and the name of the function without, as I'm not able to concatenate them in the macro itself. I could probably use `concat_idents` to create both types already defined and reduce the amount of arguments by one, but that macro is nightly only. At the same time, not being able to declare macros inside `impl` forces me to pass `self` as an argument. All this makes this solution more verbose than it would be ideally. It does reduce duplication, but it doesn't reduce the size of the file. [1](https://github.com/rust-lang/rust/issues/29599)
89 lines
3 KiB
Rust
89 lines
3 KiB
Rust
/* 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/. */
|
|
|
|
//! Infrastructure to initiate network requests for images needed by the layout
|
|
//! thread. The script thread needs to be responsible for them because there's
|
|
//! no guarantee that the responsible nodes will still exist in the future if the
|
|
//! layout thread holds on to them during asynchronous operations.
|
|
|
|
use crate::dom::bindings::reflector::DomObject;
|
|
use crate::dom::node::{document_from_node, Node};
|
|
use crate::network_listener::{NetworkListener, PreInvoke};
|
|
use ipc_channel::ipc;
|
|
use ipc_channel::router::ROUTER;
|
|
use net_traits::image_cache::{ImageCache, PendingImageId};
|
|
use net_traits::request::{Destination, RequestInit as FetchRequestInit};
|
|
use net_traits::{FetchMetadata, FetchResponseListener, FetchResponseMsg, NetworkError};
|
|
use servo_url::ServoUrl;
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
struct LayoutImageContext {
|
|
id: PendingImageId,
|
|
cache: Arc<dyn ImageCache>,
|
|
}
|
|
|
|
impl FetchResponseListener for LayoutImageContext {
|
|
fn process_request_body(&mut self) {}
|
|
fn process_request_eof(&mut self) {}
|
|
fn process_response(&mut self, metadata: Result<FetchMetadata, NetworkError>) {
|
|
self.cache
|
|
.notify_pending_response(self.id, FetchResponseMsg::ProcessResponse(metadata));
|
|
}
|
|
|
|
fn process_response_chunk(&mut self, payload: Vec<u8>) {
|
|
self.cache
|
|
.notify_pending_response(self.id, FetchResponseMsg::ProcessResponseChunk(payload));
|
|
}
|
|
|
|
fn process_response_eof(&mut self, response: Result<(), NetworkError>) {
|
|
self.cache
|
|
.notify_pending_response(self.id, FetchResponseMsg::ProcessResponseEOF(response));
|
|
}
|
|
}
|
|
|
|
impl PreInvoke for LayoutImageContext {}
|
|
|
|
pub fn fetch_image_for_layout(
|
|
url: ServoUrl,
|
|
node: &Node,
|
|
id: PendingImageId,
|
|
cache: Arc<dyn ImageCache>,
|
|
) {
|
|
let context = Arc::new(Mutex::new(LayoutImageContext {
|
|
id: id,
|
|
cache: cache,
|
|
}));
|
|
|
|
let document = document_from_node(node);
|
|
|
|
let (action_sender, action_receiver) = ipc::channel().unwrap();
|
|
let (task_source, canceller) = document
|
|
.window()
|
|
.task_manager()
|
|
.networking_task_source_with_canceller();
|
|
let listener = NetworkListener {
|
|
context,
|
|
task_source,
|
|
canceller: Some(canceller),
|
|
};
|
|
ROUTER.add_route(
|
|
action_receiver.to_opaque(),
|
|
Box::new(move |message| {
|
|
listener.notify_fetch(message.to().unwrap());
|
|
}),
|
|
);
|
|
|
|
let request = FetchRequestInit {
|
|
url: url,
|
|
origin: document.origin().immutable().clone(),
|
|
destination: Destination::Image,
|
|
pipeline_id: Some(document.global().pipeline_id()),
|
|
..FetchRequestInit::default()
|
|
};
|
|
|
|
// Layout image loads do not delay the document load event.
|
|
document
|
|
.loader_mut()
|
|
.fetch_async_background(request, action_sender);
|
|
}
|