Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-09-04 20:18:21 +01:00
Code Issues Projects Releases Packages Wiki Activity

script: Migrate swmanager to GenericChannel (#39076)

Browse source 
Migrate `ServiceWorkerMsg` and `SWManagerMsg` to GenericChannel

Testing: Covered by service worker wpt tests
Part of #38912

Signed-off-by: Jonathan Schwender <schwenderjonathan@gmail.com>
This commit is contained in:
Jonathan Schwender 2025-09-01 21:23:16 +02:00 • committed by GitHub
parent 93aeac056b
commit ce8b05738c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 44 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

16
components/constellation/constellation.rs
View file

@ -359,17 +359,17 @@ pub struct Constellation<STF, SWF> {
bluetooth_ipc_sender: IpcSender<BluetoothRequest>,
/// A map of origin to sender to a Service worker manager.
sw_managers: HashMap<ImmutableOrigin, IpcSender<ServiceWorkerMsg>>,
sw_managers: HashMap<ImmutableOrigin, GenericSender<ServiceWorkerMsg>>,
/// An IPC channel for Service Worker Manager threads to send
/// messages to the constellation. This is the SW Manager thread's
/// view of `swmanager_receiver`.
swmanager_ipc_sender: IpcSender<SWManagerMsg>,
swmanager_ipc_sender: GenericSender<SWManagerMsg>,
/// A channel for the constellation to receive messages from the
/// Service Worker Manager thread. This is the constellation's view of
/// `swmanager_sender`.
swmanager_receiver: Receiver<Result<SWManagerMsg, IpcError>>,
swmanager_receiver: RoutedReceiver<SWManagerMsg>,
/// A channel for the constellation to send messages to the
/// time profiler thread.
@ -607,7 +607,7 @@ where
// service worker manager to communicate with constellation
let (swmanager_ipc_sender, swmanager_ipc_receiver) =
ipc::channel().expect("ipc channel failure");
generic_channel::channel().expect("ipc channel failure");
thread::Builder::new()
.name("Constellation".to_owned())
@ -653,10 +653,7 @@ where
)
};
let swmanager_receiver =
route_ipc_receiver_to_new_crossbeam_receiver_preserving_errors(
swmanager_ipc_receiver,
);
let swmanager_receiver = swmanager_ipc_receiver.route_preserving_errors();
// Zero is reserved for the embedder.
PipelineNamespace::install(PipelineNamespaceId(1));
@ -2447,7 +2444,8 @@ where
let sw_manager = match self.sw_managers.entry(origin.clone()) {
Entry::Occupied(entry) => entry.into_mut(),
Entry::Vacant(entry) => {
let (own_sender, receiver) = ipc::channel().expect("Failed to create IPC channel!");
let (own_sender, receiver) =
generic_channel::channel().expect("Failed to create IPC channel!");
let sw_senders = SWManagerSenders {
swmanager_sender: self.swmanager_ipc_sender.clone(),

4
components/constellation/pipeline.rs
View file

@ -155,7 +155,7 @@ pub struct InitialPipelineState {
pub bluetooth_thread: IpcSender<BluetoothRequest>,
/// A channel to the service worker manager thread
pub swmanager_thread: IpcSender<SWManagerMsg>,
pub swmanager_thread: GenericSender<SWManagerMsg>,
/// A proxy to the system font service, responsible for managing the list of system fonts.
pub system_font_service: Arc<SystemFontServiceProxy>,
@ -481,7 +481,7 @@ pub struct UnprivilegedPipelineContent {
devtools_ipc_sender: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
#[cfg(feature = "bluetooth")]
bluetooth_thread: IpcSender<BluetoothRequest>,
swmanager_thread: IpcSender<SWManagerMsg>,
swmanager_thread: GenericSender<SWManagerMsg>,
system_font_service: SystemFontServiceProxySender,
resource_threads: ResourceThreads,
time_profiler_chan: time::ProfilerChan,

11
components/script/dom/serviceworkerglobalscope.rs
View file

@ -7,6 +7,7 @@ use std::sync::atomic::AtomicBool;
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};
use base::generic_channel::GenericSender;
use base::id::PipelineId;
use constellation_traits::{
ScopeThings, ServiceWorkerMsg, WorkerGlobalScopeInit, WorkerScriptLoadOrigin,
@ -15,7 +16,7 @@ use crossbeam_channel::{Receiver, Sender, after, unbounded};
use devtools_traits::DevtoolScriptControlMsg;
use dom_struct::dom_struct;
use fonts::FontContext;
use ipc_channel::ipc::{IpcReceiver, IpcSender};
use ipc_channel::ipc::IpcReceiver;
use ipc_channel::router::ROUTER;
use js::jsapi::{JS_AddInterruptCallback, JSContext};
use js::jsval::UndefinedValue;
@ -161,7 +162,7 @@ pub(crate) struct ServiceWorkerGlobalScope {
#[ignore_malloc_size_of = "Defined in std"]
#[no_trace]
swmanager_sender: IpcSender<ServiceWorkerMsg>,
swmanager_sender: GenericSender<ServiceWorkerMsg>,
#[no_trace]
scope_url: ServoUrl,
@ -224,7 +225,7 @@ impl ServiceWorkerGlobalScope {
own_sender: Sender<ServiceWorkerScriptMsg>,
receiver: Receiver<ServiceWorkerScriptMsg>,
time_out_port: Receiver<Instant>,
swmanager_sender: IpcSender<ServiceWorkerMsg>,
swmanager_sender: GenericSender<ServiceWorkerMsg>,
scope_url: ServoUrl,
control_receiver: Receiver<ServiceWorkerControlMsg>,
closing: Arc<AtomicBool>,
@ -263,7 +264,7 @@ impl ServiceWorkerGlobalScope {
own_sender: Sender<ServiceWorkerScriptMsg>,
receiver: Receiver<ServiceWorkerScriptMsg>,
time_out_port: Receiver<Instant>,
swmanager_sender: IpcSender<ServiceWorkerMsg>,
swmanager_sender: GenericSender<ServiceWorkerMsg>,
scope_url: ServoUrl,
control_receiver: Receiver<ServiceWorkerControlMsg>,
closing: Arc<AtomicBool>,
@ -293,7 +294,7 @@ impl ServiceWorkerGlobalScope {
own_sender: Sender<ServiceWorkerScriptMsg>,
receiver: Receiver<ServiceWorkerScriptMsg>,
devtools_receiver: IpcReceiver<DevtoolScriptControlMsg>,
swmanager_sender: IpcSender<ServiceWorkerMsg>,
swmanager_sender: GenericSender<ServiceWorkerMsg>,
scope_url: ServoUrl,
control_receiver: Receiver<ServiceWorkerControlMsg>,
context_sender: Sender<ThreadSafeJSContext>,

27
components/script/serviceworker_manager.rs
View file

@ -12,14 +12,15 @@ use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread::{self, JoinHandle};
use base::generic_channel::{self, GenericSender, ReceiveError, RoutedReceiver};
use base::id::{PipelineNamespace, ServiceWorkerId, ServiceWorkerRegistrationId};
use constellation_traits::{
DOMMessage, Job, JobError, JobResult, JobResultValue, JobType, SWManagerMsg, SWManagerSenders,
ScopeThings, ServiceWorkerManagerFactory, ServiceWorkerMsg,
};
use crossbeam_channel::{Receiver, RecvError, Sender, select, unbounded};
use crossbeam_channel::{Receiver, Sender, select, unbounded};
use fonts::FontContext;
use ipc_channel::ipc::{self, IpcSender};
use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use net_traits::{CoreResourceMsg, CustomResponseMediator};
use servo_config::pref;
@ -217,11 +218,11 @@ pub struct ServiceWorkerManager {
registrations: HashMap<ServoUrl, ServiceWorkerRegistration>,
// Will be useful to implement posting a message to a client.
// See https://github.com/servo/servo/issues/24660
_constellation_sender: IpcSender<SWManagerMsg>,
_constellation_sender: GenericSender<SWManagerMsg>,
// own sender to send messages here
own_sender: IpcSender<ServiceWorkerMsg>,
own_sender: GenericSender<ServiceWorkerMsg>,
// receiver to receive messages from constellation
own_port: Receiver<ServiceWorkerMsg>,
own_port: RoutedReceiver<ServiceWorkerMsg>,
// to receive resource messages
resource_receiver: Receiver<CustomResponseMediator>,
/// A shared [`FontContext`] to use for all service workers spawned by this [`ServiceWorkerManager`].
@ -230,10 +231,10 @@ pub struct ServiceWorkerManager {
impl ServiceWorkerManager {
fn new(
own_sender: IpcSender<ServiceWorkerMsg>,
from_constellation_receiver: Receiver<ServiceWorkerMsg>,
own_sender: GenericSender<ServiceWorkerMsg>,
from_constellation_receiver: RoutedReceiver<ServiceWorkerMsg>,
resource_port: Receiver<CustomResponseMediator>,
constellation_sender: IpcSender<SWManagerMsg>,
constellation_sender: GenericSender<SWManagerMsg>,
font_context: Arc<FontContext>,
) -> ServiceWorkerManager {
// Install a pipeline-namespace in the current thread.
@ -289,10 +290,10 @@ impl ServiceWorkerManager {
true
}
fn receive_message(&mut self) -> Result<Message, RecvError> {
fn receive_message(&mut self) -> generic_channel::ReceiveResult<Message> {
select! {
recv(self.own_port) -> msg => msg.map(|m| Message::FromConstellation(Box::new(m))),
recv(self.resource_receiver) -> msg => msg.map(Message::FromResource),
recv(self.own_port) -> result_msg => generic_channel::to_receive_result::<ServiceWorkerMsg>(result_msg).map(|msg| Message::FromConstellation(Box::new(msg))),
recv(self.resource_receiver) -> msg => msg.map(Message::FromResource).map_err(|_e| ReceiveError::Disconnected),
}
}
@ -452,7 +453,7 @@ impl ServiceWorkerManager {
/// <https://w3c.github.io/ServiceWorker/#update-algorithm>
fn update_serviceworker(
own_sender: IpcSender<ServiceWorkerMsg>,
own_sender: GenericSender<ServiceWorkerMsg>,
scope_url: ServoUrl,
scope_things: ScopeThings,
font_context: Arc<FontContext>,
@ -510,7 +511,7 @@ impl ServiceWorkerManagerFactory for ServiceWorkerManager {
compositor_api,
} = sw_senders;
let from_constellation = ROUTER.route_ipc_receiver_to_new_crossbeam_receiver(receiver);
let from_constellation = receiver.route_preserving_errors();
let resource_port = ROUTER.route_ipc_receiver_to_new_crossbeam_receiver(resource_port);
let _ = resource_threads
.core_thread

10
components/shared/base/generic_channel.rs
View file

@ -252,6 +252,16 @@ impl From<crossbeam_channel::TryRecvError> for TryReceiveError {
pub type RoutedReceiver<T> = crossbeam_channel::Receiver<Result<T, ipc_channel::Error>>;
pub type ReceiveResult<T> = Result<T, ReceiveError>;
pub type TryReceiveResult<T> = Result<T, TryReceiveError>;
pub type RoutedReceiverReceiveResult<T> =
Result<Result<T, ipc_channel::Error>, crossbeam_channel::RecvError>;
pub fn to_receive_result<T>(receive_result: RoutedReceiverReceiveResult<T>) -> ReceiveResult<T> {
match receive_result {
Ok(Ok(msg)) => Ok(msg),
Err(_crossbeam_recv_err) => Err(ReceiveError::Disconnected),
Ok(Err(ipc_err)) => Err(ReceiveError::DeserializationFailed(ipc_err.to_string())),
}
}
pub struct GenericReceiver<T>(GenericReceiverVariants<T>)
where

10
components/shared/constellation/from_script_message.rs
View file

@ -8,7 +8,7 @@ use std::collections::HashMap;
use std::fmt;
use base::Epoch;
use base::generic_channel::{GenericCallback, GenericSender, SendResult};
use base::generic_channel::{GenericCallback, GenericReceiver, GenericSender, SendResult};
use base::id::{
BroadcastChannelRouterId, BrowsingContextId, HistoryStateId, MessagePortId,
MessagePortRouterId, PipelineId, ServiceWorkerId, ServiceWorkerRegistrationId, WebViewId,
@ -24,7 +24,7 @@ use embedder_traits::{
use euclid::default::Size2D as UntypedSize2D;
use fonts_traits::SystemFontServiceProxySender;
use http::{HeaderMap, Method};
use ipc_channel::ipc::{IpcReceiver, IpcSender};
use ipc_channel::ipc::IpcSender;
use malloc_size_of_derive::MallocSizeOf;
use net_traits::policy_container::PolicyContainer;
use net_traits::request::{Destination, InsecureRequestsPolicy, Referrer, RequestBody};
@ -206,7 +206,7 @@ pub struct DOMMessage {
#[derive(Deserialize, Serialize)]
pub struct SWManagerSenders {
/// Sender of messages to the constellation.
pub swmanager_sender: IpcSender<SWManagerMsg>,
pub swmanager_sender: GenericSender<SWManagerMsg>,
/// [`ResourceThreads`] for initating fetches or using i/o.
pub resource_threads: ResourceThreads,
/// [`CrossProcessCompositorApi`] for communicating with the compositor.
@ -214,9 +214,9 @@ pub struct SWManagerSenders {
/// The [`SystemFontServiceProxy`] used to communicate with the `SystemFontService`.
pub system_font_service_sender: SystemFontServiceProxySender,
/// Sender of messages to the manager.
pub own_sender: IpcSender<ServiceWorkerMsg>,
pub own_sender: GenericSender<ServiceWorkerMsg>,
/// Receiver of messages from the constellation.
pub receiver: IpcReceiver<ServiceWorkerMsg>,
pub receiver: GenericReceiver<ServiceWorkerMsg>,
}
/// Messages sent to Service Worker Manager thread