Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 12:40:06 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #29710 - servo:rename_sender_receiver_in_constellation, r=mrobinson

Browse source 
Make names of Sender<> and Receiver<> variables more coherent

<!-- Please describe your changes on the following line: -->
Sometimes these variables are called port, sometimes ipc, sometimes they have the name of the thread on the other end and sometimes not.  This PR tries to standardize on an obvious name for all of them:

Common pattern to note in this PR:
- If it is a `IpcSender`, then naming is followed by `ipc_sender`, such as:  `bluetooth_ipc_sender`,  `canvas_ipc_sender` etc..
- If variable is `crossbeam_channel` sender/receiver then naming is followed by `sender`/`receiver` such as:  `devtools_sender`, `canvas_sender` etc...

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `___` with appropriate data: -->
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors
- [x] These changes fix [#29679](https://github.com/servo/servo/issues/29679)

<!-- Either: -->
- [ ] There are tests for these changes OR
- [x] These changes do not require tests

<!-- Also, please make sure that "Allow edits from maintainers" checkbox is checked, so that we can help you if you get stuck somewhere along the way.-->

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->
This commit is contained in:
bors-servo 2023-05-08 11:36:33 +02:00 • committed by GitHub
commit 61f872e7da
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 253 additions and 223 deletions
Download patch file Download diff file Expand all files Collapse all files

389
components/constellation/constellation.rs
View file

@ -282,7 +282,7 @@ pub struct Constellation<Message, LTF, STF, SWF> {
/// to facilitate installing pipeline namespaces in threads /// to facilitate installing pipeline namespaces in threads
/// via a per-process installer. /// via a per-process installer.
namespace_receiver: Receiver<Result<PipelineNamespaceRequest, IpcError>>, namespace_receiver: Receiver<Result<PipelineNamespaceRequest, IpcError>>,
namespace_sender: IpcSender<PipelineNamespaceRequest>, namespace_ipc_sender: IpcSender<PipelineNamespaceRequest>,
/// An IPC channel for script threads to send messages to the constellation. /// An IPC channel for script threads to send messages to the constellation.
/// This is the script threads' view of `script_receiver`. /// This is the script threads' view of `script_receiver`.
@ -358,11 +358,11 @@ pub struct Constellation<Message, LTF, STF, SWF> {
/// A channel for the constellation to send messages to the /// A channel for the constellation to send messages to the
/// devtools thread. /// devtools thread.
devtools_chan: Option<Sender<DevtoolsControlMsg>>, devtools_sender: Option<Sender<DevtoolsControlMsg>>,
/// An IPC channel for the constellation to send messages to the /// An IPC channel for the constellation to send messages to the
/// bluetooth thread. /// bluetooth thread.
bluetooth_thread: IpcSender<BluetoothRequest>, bluetooth_ipc_sender: IpcSender<BluetoothRequest>,
/// A map of origin to sender to a Service worker manager. /// A map of origin to sender to a Service worker manager.
sw_managers: HashMap<ImmutableOrigin, IpcSender<ServiceWorkerMsg>>, sw_managers: HashMap<ImmutableOrigin, IpcSender<ServiceWorkerMsg>>,
@ -370,7 +370,7 @@ pub struct Constellation<Message, LTF, STF, SWF> {
/// An IPC channel for Service Worker Manager threads to send /// An IPC channel for Service Worker Manager threads to send
/// messages to the constellation. This is the SW Manager thread's /// messages to the constellation. This is the SW Manager thread's
/// view of `swmanager_receiver`. /// view of `swmanager_receiver`.
swmanager_sender: IpcSender<SWManagerMsg>, swmanager_ipc_sender: IpcSender<SWManagerMsg>,
/// A channel for the constellation to receive messages from the /// A channel for the constellation to receive messages from the
/// Service Worker Manager thread. This is the constellation's view of /// Service Worker Manager thread. This is the constellation's view of
@ -386,7 +386,7 @@ pub struct Constellation<Message, LTF, STF, SWF> {
mem_profiler_chan: mem::ProfilerChan, mem_profiler_chan: mem::ProfilerChan,
/// A channel for a pipeline to schedule timer events. /// A channel for a pipeline to schedule timer events.
scheduler_chan: IpcSender<TimerSchedulerMsg>, scheduler_ipc_sender: IpcSender<TimerSchedulerMsg>,
/// The receiver to which the IPC requests from scheduler_chan will be forwarded. /// The receiver to which the IPC requests from scheduler_chan will be forwarded.
scheduler_receiver: Receiver<Result<TimerSchedulerMsg, IpcError>>, scheduler_receiver: Receiver<Result<TimerSchedulerMsg, IpcError>>,
@ -476,9 +476,9 @@ pub struct Constellation<Message, LTF, STF, SWF> {
webxr_registry: webxr_api::Registry, webxr_registry: webxr_api::Registry,
/// A channel through which messages can be sent to the canvas paint thread. /// A channel through which messages can be sent to the canvas paint thread.
canvas_chan: Sender<ConstellationCanvasMsg>, canvas_sender: Sender<ConstellationCanvasMsg>,
ipc_canvas_chan: IpcSender<CanvasMsg>, canvas_ipc_sender: IpcSender<CanvasMsg>,
/// Navigation requests from script awaiting approval from the embedder. /// Navigation requests from script awaiting approval from the embedder.
pending_approval_navigations: PendingApprovalNavigations, pending_approval_navigations: PendingApprovalNavigations,
@ -523,7 +523,7 @@ pub struct InitialConstellationState {
pub compositor_proxy: CompositorProxy, pub compositor_proxy: CompositorProxy,
/// A channel to the developer tools, if applicable. /// A channel to the developer tools, if applicable.
pub devtools_chan: Option<Sender<DevtoolsControlMsg>>, pub devtools_sender: Option<Sender<DevtoolsControlMsg>>,
/// A channel to the bluetooth thread. /// A channel to the bluetooth thread.
pub bluetooth_thread: IpcSender<BluetoothRequest>, pub bluetooth_thread: IpcSender<BluetoothRequest>,
@ -613,21 +613,19 @@ enum ExitPipelineMode {
/// The number of warnings to include in each crash report. /// The number of warnings to include in each crash report.
const WARNINGS_BUFFER_SIZE: usize = 32; const WARNINGS_BUFFER_SIZE: usize = 32;
/// Route an ipc receiver to an mpsc receiver, preserving any errors. /// Route an ipc receiver to an crossbeam receiver, preserving any errors.
/// This is the same as `route_ipc_receiver_to_new_mpsc_receiver`, fn route_ipc_receiver_to_new_crossbeam_receiver_preserving_errors<T>(
/// but does not panic on deserializtion errors.
fn route_ipc_receiver_to_new_mpsc_receiver_preserving_errors<T>(
ipc_receiver: IpcReceiver<T>, ipc_receiver: IpcReceiver<T>,
) -> Receiver<Result<T, IpcError>> ) -> Receiver<Result<T, IpcError>>
where where
T: for<'de> Deserialize<'de> + Serialize + Send + 'static, T: for<'de> Deserialize<'de> + Serialize + Send + 'static,
{ {
let (mpsc_sender, mpsc_receiver) = unbounded(); let (crossbeam_sender, crossbeam_receiver) = unbounded();
ROUTER.add_route( ROUTER.add_route(
ipc_receiver.to_opaque(), ipc_receiver.to_opaque(),
Box::new(move |message| drop(mpsc_sender.send(message.to::<T>()))), Box::new(move |message| drop(crossbeam_sender.send(message.to::<T>()))),
); );
mpsc_receiver crossbeam_receiver
} }
impl<Message, LTF, STF, SWF> Constellation<Message, LTF, STF, SWF> impl<Message, LTF, STF, SWF> Constellation<Message, LTF, STF, SWF>
@ -645,66 +643,80 @@ where
is_running_problem_test: bool, is_running_problem_test: bool,
hard_fail: bool, hard_fail: bool,
enable_canvas_antialiasing: bool, enable_canvas_antialiasing: bool,
canvas_chan: Sender<ConstellationCanvasMsg>, canvas_create_sender: Sender<ConstellationCanvasMsg>,
ipc_canvas_chan: IpcSender<CanvasMsg>, canvas_ipc_sender: IpcSender<CanvasMsg>,
) -> Sender<FromCompositorMsg> { ) -> Sender<FromCompositorMsg> {
let (compositor_sender, compositor_receiver) = unbounded(); let (compositor_sender, compositor_receiver) = unbounded();
// service worker manager to communicate with constellation // service worker manager to communicate with constellation
let (swmanager_sender, swmanager_receiver) = ipc::channel().expect("ipc channel failure"); let (swmanager_ipc_sender, swmanager_ipc_receiver) =
ipc::channel().expect("ipc channel failure");
thread::Builder::new() thread::Builder::new()
.name("Constellation".to_owned()) .name("Constellation".to_owned())
.spawn(move || { .spawn(move || {
let (ipc_script_sender, ipc_script_receiver) = let (script_ipc_sender, script_ipc_receiver) =
ipc::channel().expect("ipc channel failure"); ipc::channel().expect("ipc channel failure");
let script_receiver = let script_receiver =
route_ipc_receiver_to_new_mpsc_receiver_preserving_errors(ipc_script_receiver); route_ipc_receiver_to_new_crossbeam_receiver_preserving_errors(
script_ipc_receiver,
);
let (namespace_sender, ipc_namespace_receiver) = let (namespace_ipc_sender, namespace_ipc_receiver) =
ipc::channel().expect("ipc channel failure"); ipc::channel().expect("ipc channel failure");
let namespace_receiver = route_ipc_receiver_to_new_mpsc_receiver_preserving_errors( let namespace_receiver =
ipc_namespace_receiver, route_ipc_receiver_to_new_crossbeam_receiver_preserving_errors(
); namespace_ipc_receiver,
);
let (scheduler_chan, ipc_scheduler_receiver) = let (scheduler_ipc_sender, scheduler_ipc_receiver) =
ipc::channel().expect("ipc channel failure"); ipc::channel().expect("ipc channel failure");
let scheduler_receiver = route_ipc_receiver_to_new_mpsc_receiver_preserving_errors( let scheduler_receiver =
ipc_scheduler_receiver, route_ipc_receiver_to_new_crossbeam_receiver_preserving_errors(
); scheduler_ipc_receiver,
);
let (background_hang_monitor_sender, ipc_bhm_receiver) = let (background_hang_monitor_ipc_sender, background_hang_monitor_ipc_receiver) =
ipc::channel().expect("ipc channel failure"); ipc::channel().expect("ipc channel failure");
let background_hang_monitor_receiver = let background_hang_monitor_receiver =
route_ipc_receiver_to_new_mpsc_receiver_preserving_errors(ipc_bhm_receiver); route_ipc_receiver_to_new_crossbeam_receiver_preserving_errors(
background_hang_monitor_ipc_receiver,
);
// If we are in multiprocess mode, // If we are in multiprocess mode,
// a dedicated per-process hang monitor will be initialized later inside the content process. // a dedicated per-process hang monitor will be initialized later inside the content process.
// See run_content_process in servo/lib.rs // See run_content_process in servo/lib.rs
let (background_monitor_register, bhm_control_chans) = if opts::multiprocess() { let (background_monitor_register, background_hang_monitor_control_ipc_senders) =
(None, vec![]) if opts::multiprocess() {
} else { (None, vec![])
let (bhm_control_chan, bhm_control_port) = } else {
ipc::channel().expect("ipc channel failure"); let (
( background_hang_monitor_control_ipc_sender,
Some(HangMonitorRegister::init( background_hang_monitor_control_ipc_receiver,
background_hang_monitor_sender.clone(), ) = ipc::channel().expect("ipc channel failure");
bhm_control_port, (
opts::get().background_hang_monitor, Some(HangMonitorRegister::init(
)), background_hang_monitor_ipc_sender.clone(),
vec![bhm_control_chan], background_hang_monitor_control_ipc_receiver,
) opts::get().background_hang_monitor,
}; )),
vec![background_hang_monitor_control_ipc_sender],
)
};
let (ipc_layout_sender, ipc_layout_receiver) = let (layout_ipc_sender, layout_ipc_receiver) =
ipc::channel().expect("ipc channel failure"); ipc::channel().expect("ipc channel failure");
let layout_receiver = let layout_receiver =
route_ipc_receiver_to_new_mpsc_receiver_preserving_errors(ipc_layout_receiver); route_ipc_receiver_to_new_crossbeam_receiver_preserving_errors(
layout_ipc_receiver,
);
let (network_listener_sender, network_listener_receiver) = unbounded(); let (network_listener_sender, network_listener_receiver) = unbounded();
let swmanager_receiver = let swmanager_receiver =
route_ipc_receiver_to_new_mpsc_receiver_preserving_errors(swmanager_receiver); route_ipc_receiver_to_new_crossbeam_receiver_preserving_errors(
swmanager_ipc_receiver,
);
// Zero is reserved for the embedder. // Zero is reserved for the embedder.
PipelineNamespace::install(PipelineNamespaceId(1)); PipelineNamespace::install(PipelineNamespaceId(1));
@ -742,13 +754,13 @@ where
let mut constellation: Constellation<Message, LTF, STF, SWF> = Constellation { let mut constellation: Constellation<Message, LTF, STF, SWF> = Constellation {
namespace_receiver, namespace_receiver,
namespace_sender, namespace_ipc_sender,
script_sender: ipc_script_sender, script_sender: script_ipc_sender,
background_hang_monitor_sender, background_hang_monitor_sender: background_hang_monitor_ipc_sender,
background_hang_monitor_receiver, background_hang_monitor_receiver,
background_monitor_register, background_monitor_register,
background_monitor_control_senders: bhm_control_chans, background_monitor_control_senders: background_hang_monitor_control_ipc_senders,
layout_sender: ipc_layout_sender, layout_sender: layout_ipc_sender,
script_receiver: script_receiver, script_receiver: script_receiver,
compositor_receiver: compositor_receiver, compositor_receiver: compositor_receiver,
layout_receiver: layout_receiver, layout_receiver: layout_receiver,
@ -758,14 +770,14 @@ where
compositor_proxy: state.compositor_proxy, compositor_proxy: state.compositor_proxy,
active_browser_id: None, active_browser_id: None,
browsers: HashMap::new(), browsers: HashMap::new(),
devtools_chan: state.devtools_chan, devtools_sender: state.devtools_sender,
bluetooth_thread: state.bluetooth_thread, bluetooth_ipc_sender: state.bluetooth_thread,
public_resource_threads: state.public_resource_threads, public_resource_threads: state.public_resource_threads,
private_resource_threads: state.private_resource_threads, private_resource_threads: state.private_resource_threads,
font_cache_thread: state.font_cache_thread, font_cache_thread: state.font_cache_thread,
sw_managers: Default::default(), sw_managers: Default::default(),
swmanager_receiver: swmanager_receiver, swmanager_receiver: swmanager_receiver,
swmanager_sender, swmanager_ipc_sender,
browsing_context_group_set: Default::default(), browsing_context_group_set: Default::default(),
browsing_context_group_next_id: Default::default(), browsing_context_group_next_id: Default::default(),
message_ports: HashMap::new(), message_ports: HashMap::new(),
@ -784,7 +796,7 @@ where
phantom: PhantomData, phantom: PhantomData,
webdriver: WebDriverData::new(), webdriver: WebDriverData::new(),
timer_scheduler: TimerScheduler::new(), timer_scheduler: TimerScheduler::new(),
scheduler_chan, scheduler_ipc_sender,
scheduler_receiver, scheduler_receiver,
document_states: HashMap::new(), document_states: HashMap::new(),
webrender_document: state.webrender_document, webrender_document: state.webrender_document,
@ -806,8 +818,8 @@ where
}), }),
webgl_threads: state.webgl_threads, webgl_threads: state.webgl_threads,
webxr_registry: state.webxr_registry, webxr_registry: state.webxr_registry,
canvas_chan, canvas_sender: canvas_create_sender,
ipc_canvas_chan, canvas_ipc_sender,
pending_approval_navigations: HashMap::new(), pending_approval_navigations: HashMap::new(),
pressed_mouse_buttons: 0, pressed_mouse_buttons: 0,
is_running_problem_test, is_running_problem_test,
@ -1034,18 +1046,18 @@ where
sender: self.script_sender.clone(), sender: self.script_sender.clone(),
pipeline_id: pipeline_id, pipeline_id: pipeline_id,
}, },
namespace_request_sender: self.namespace_sender.clone(), namespace_request_sender: self.namespace_ipc_sender.clone(),
pipeline_namespace_id: self.next_pipeline_namespace_id(), pipeline_namespace_id: self.next_pipeline_namespace_id(),
background_monitor_register: self.background_monitor_register.clone(), background_monitor_register: self.background_monitor_register.clone(),
background_hang_monitor_to_constellation_chan: self background_hang_monitor_to_constellation_chan: self
.background_hang_monitor_sender .background_hang_monitor_sender
.clone(), .clone(),
layout_to_constellation_chan: self.layout_sender.clone(), layout_to_constellation_chan: self.layout_sender.clone(),
scheduler_chan: self.scheduler_chan.clone(), scheduler_chan: self.scheduler_ipc_sender.clone(),
compositor_proxy: self.compositor_proxy.clone(), compositor_proxy: self.compositor_proxy.clone(),
devtools_chan: self.devtools_chan.clone(), devtools_sender: self.devtools_sender.clone(),
bluetooth_thread: self.bluetooth_thread.clone(), bluetooth_thread: self.bluetooth_ipc_sender.clone(),
swmanager_thread: self.swmanager_sender.clone(), swmanager_thread: self.swmanager_ipc_sender.clone(),
font_cache_thread: self.font_cache_thread.clone(), font_cache_thread: self.font_cache_thread.clone(),
resource_threads, resource_threads,
time_profiler_chan: self.time_profiler_chan.clone(), time_profiler_chan: self.time_profiler_chan.clone(),
@ -1346,11 +1358,11 @@ where
FromCompositorMsg::Exit => { FromCompositorMsg::Exit => {
self.handle_exit(); self.handle_exit();
}, },
FromCompositorMsg::GetBrowsingContext(pipeline_id, resp_chan) => { FromCompositorMsg::GetBrowsingContext(pipeline_id, response_sender) => {
self.handle_get_browsing_context(pipeline_id, resp_chan); self.handle_get_browsing_context(pipeline_id, response_sender);
}, },
FromCompositorMsg::GetPipeline(browsing_context_id, resp_chan) => { FromCompositorMsg::GetPipeline(browsing_context_id, response_sender) => {
self.handle_get_pipeline(browsing_context_id, resp_chan); self.handle_get_pipeline(browsing_context_id, response_sender);
}, },
FromCompositorMsg::GetFocusTopLevelBrowsingContext(resp_chan) => { FromCompositorMsg::GetFocusTopLevelBrowsingContext(resp_chan) => {
// The focused browsing context's top-level browsing context is // The focused browsing context's top-level browsing context is
@ -1513,18 +1525,19 @@ where
}, },
FromCompositorMsg::SetCursor(cursor) => self.handle_set_cursor_msg(cursor), FromCompositorMsg::SetCursor(cursor) => self.handle_set_cursor_msg(cursor),
FromCompositorMsg::EnableProfiler(rate, max_duration) => { FromCompositorMsg::EnableProfiler(rate, max_duration) => {
for chan in &self.background_monitor_control_senders { for background_monitor_control_sender in &self.background_monitor_control_senders {
if let Err(e) = chan.send(BackgroundHangMonitorControlMsg::EnableSampler( if let Err(e) = background_monitor_control_sender.send(
rate, BackgroundHangMonitorControlMsg::EnableSampler(rate, max_duration),
max_duration, ) {
)) {
warn!("error communicating with sampling profiler: {}", e); warn!("error communicating with sampling profiler: {}", e);
} }
} }
}, },
FromCompositorMsg::DisableProfiler => { FromCompositorMsg::DisableProfiler => {
for chan in &self.background_monitor_control_senders { for background_monitor_control_sender in &self.background_monitor_control_senders {
if let Err(e) = chan.send(BackgroundHangMonitorControlMsg::DisableSampler) { if let Err(e) = background_monitor_control_sender
.send(BackgroundHangMonitorControlMsg::DisableSampler)
{
warn!("error communicating with sampling profiler: {}", e); warn!("error communicating with sampling profiler: {}", e);
} }
} }
@ -1586,11 +1599,11 @@ where
FromScriptMsg::EntanglePorts(port1, port2) => { FromScriptMsg::EntanglePorts(port1, port2) => {
self.handle_entangle_messageports(port1, port2); self.handle_entangle_messageports(port1, port2);
}, },
FromScriptMsg::NewBroadcastChannelRouter(router_id, ipc_sender, origin) => { FromScriptMsg::NewBroadcastChannelRouter(router_id, response_sender, origin) => {
self.handle_new_broadcast_channel_router( self.handle_new_broadcast_channel_router(
source_pipeline_id, source_pipeline_id,
router_id, router_id,
ipc_sender, response_sender,
origin, origin,
); );
}, },
@ -1636,11 +1649,11 @@ where
FromScriptMsg::ScriptLoadedURLInIFrame(load_info) => { FromScriptMsg::ScriptLoadedURLInIFrame(load_info) => {
self.handle_script_loaded_url_in_iframe_msg(load_info); self.handle_script_loaded_url_in_iframe_msg(load_info);
}, },
FromScriptMsg::ScriptNewIFrame(load_info, layout_sender) => { FromScriptMsg::ScriptNewIFrame(load_info, response_sender) => {
self.handle_script_new_iframe(load_info, layout_sender); self.handle_script_new_iframe(load_info, response_sender);
}, },
FromScriptMsg::ScriptNewAuxiliary(load_info, layout_sender) => { FromScriptMsg::ScriptNewAuxiliary(load_info, response_sender) => {
self.handle_script_new_auxiliary(load_info, layout_sender); self.handle_script_new_auxiliary(load_info, response_sender);
}, },
FromScriptMsg::ChangeRunningAnimationsState(animation_state) => { FromScriptMsg::ChangeRunningAnimationsState(animation_state) => {
self.handle_change_running_animations_state(source_pipeline_id, animation_state) self.handle_change_running_animations_state(source_pipeline_id, animation_state)
@ -1672,8 +1685,8 @@ where
self.handle_replace_history_state_msg(source_pipeline_id, history_state_id, url); self.handle_replace_history_state_msg(source_pipeline_id, history_state_id, url);
}, },
// Handle a joint session history length request. // Handle a joint session history length request.
FromScriptMsg::JointSessionHistoryLength(sender) => { FromScriptMsg::JointSessionHistoryLength(response_sender) => {
self.handle_joint_session_history_length(source_top_ctx_id, sender); self.handle_joint_session_history_length(source_top_ctx_id, response_sender);
}, },
// Notification that the new document is ready to become active // Notification that the new document is ready to become active
FromScriptMsg::ActivateDocument => { FromScriptMsg::ActivateDocument => {
@ -1709,29 +1722,29 @@ where
FromScriptMsg::VisibilityChangeComplete(is_visible) => { FromScriptMsg::VisibilityChangeComplete(is_visible) => {
self.handle_visibility_change_complete(source_pipeline_id, is_visible); self.handle_visibility_change_complete(source_pipeline_id, is_visible);
}, },
FromScriptMsg::RemoveIFrame(browsing_context_id, sender) => { FromScriptMsg::RemoveIFrame(browsing_context_id, response_sender) => {
let removed_pipeline_ids = self.handle_remove_iframe_msg(browsing_context_id); let removed_pipeline_ids = self.handle_remove_iframe_msg(browsing_context_id);
if let Err(e) = sender.send(removed_pipeline_ids) { if let Err(e) = response_sender.send(removed_pipeline_ids) {
warn!("Error replying to remove iframe ({})", e); warn!("Error replying to remove iframe ({})", e);
} }
}, },
FromScriptMsg::CreateCanvasPaintThread(size, sender) => { FromScriptMsg::CreateCanvasPaintThread(size, response_sender) => {
self.handle_create_canvas_paint_thread_msg(size, sender) self.handle_create_canvas_paint_thread_msg(size, response_sender)
}, },
FromScriptMsg::SetDocumentState(state) => { FromScriptMsg::SetDocumentState(state) => {
self.document_states.insert(source_pipeline_id, state); self.document_states.insert(source_pipeline_id, state);
}, },
FromScriptMsg::GetClientWindow(send) => { FromScriptMsg::GetClientWindow(response_sender) => {
self.compositor_proxy self.compositor_proxy
.send(ToCompositorMsg::GetClientWindow(send)); .send(ToCompositorMsg::GetClientWindow(response_sender));
}, },
FromScriptMsg::GetScreenSize(send) => { FromScriptMsg::GetScreenSize(response_sender) => {
self.compositor_proxy self.compositor_proxy
.send(ToCompositorMsg::GetScreenSize(send)); .send(ToCompositorMsg::GetScreenSize(response_sender));
}, },
FromScriptMsg::GetScreenAvailSize(send) => { FromScriptMsg::GetScreenAvailSize(response_sender) => {
self.compositor_proxy self.compositor_proxy
.send(ToCompositorMsg::GetScreenAvailSize(send)); .send(ToCompositorMsg::GetScreenAvailSize(response_sender));
}, },
FromScriptMsg::LogEntry(thread_name, entry) => { FromScriptMsg::LogEntry(thread_name, entry) => {
self.handle_log_entry(Some(source_top_ctx_id), thread_name, entry); self.handle_log_entry(Some(source_top_ctx_id), thread_name, entry);
@ -1739,39 +1752,43 @@ where
FromScriptMsg::TouchEventProcessed(result) => self FromScriptMsg::TouchEventProcessed(result) => self
.compositor_proxy .compositor_proxy
.send(ToCompositorMsg::TouchEventProcessed(result)), .send(ToCompositorMsg::TouchEventProcessed(result)),
FromScriptMsg::GetBrowsingContextInfo(pipeline_id, sender) => { FromScriptMsg::GetBrowsingContextInfo(pipeline_id, response_sender) => {
let result = self let result = self
.pipelines .pipelines
.get(&pipeline_id) .get(&pipeline_id)
.and_then(|pipeline| self.browsing_contexts.get(&pipeline.browsing_context_id)) .and_then(|pipeline| self.browsing_contexts.get(&pipeline.browsing_context_id))
.map(|ctx| (ctx.id, ctx.parent_pipeline_id)); .map(|ctx| (ctx.id, ctx.parent_pipeline_id));
if let Err(e) = sender.send(result) { if let Err(e) = response_sender.send(result) {
warn!( warn!(
"Sending reply to get browsing context info failed ({:?}).", "Sending reply to get browsing context info failed ({:?}).",
e e
); );
} }
}, },
FromScriptMsg::GetTopForBrowsingContext(browsing_context_id, sender) => { FromScriptMsg::GetTopForBrowsingContext(browsing_context_id, response_sender) => {
let result = self let result = self
.browsing_contexts .browsing_contexts
.get(&browsing_context_id) .get(&browsing_context_id)
.and_then(|bc| Some(bc.top_level_id)); .and_then(|bc| Some(bc.top_level_id));
if let Err(e) = sender.send(result) { if let Err(e) = response_sender.send(result) {
warn!( warn!(
"Sending reply to get top for browsing context info failed ({:?}).", "Sending reply to get top for browsing context info failed ({:?}).",
e e
); );
} }
}, },
FromScriptMsg::GetChildBrowsingContextId(browsing_context_id, index, sender) => { FromScriptMsg::GetChildBrowsingContextId(
browsing_context_id,
index,
response_sender,
) => {
let result = self let result = self
.browsing_contexts .browsing_contexts
.get(&browsing_context_id) .get(&browsing_context_id)
.and_then(|bc| self.pipelines.get(&bc.pipeline_id)) .and_then(|bc| self.pipelines.get(&bc.pipeline_id))
.and_then(|pipeline| pipeline.children.get(index)) .and_then(|pipeline| pipeline.children.get(index))
.map(|maybe_bcid| *maybe_bcid); .map(|maybe_bcid| *maybe_bcid);
if let Err(e) = sender.send(result) { if let Err(e) = response_sender.send(result) {
warn!( warn!(
"Sending reply to get child browsing context ID failed ({:?}).", "Sending reply to get child browsing context ID failed ({:?}).",
e e
@ -1823,15 +1840,16 @@ where
EmbedderMsg::MediaSessionEvent(event), EmbedderMsg::MediaSessionEvent(event),
)); ));
}, },
FromScriptMsg::RequestAdapter(sender, options, ids) => self.handle_wgpu_request( FromScriptMsg::RequestAdapter(response_sender, options, ids) => self
.handle_wgpu_request(
source_pipeline_id,
BrowsingContextId::from(source_top_ctx_id),
FromScriptMsg::RequestAdapter(response_sender, options, ids),
),
FromScriptMsg::GetWebGPUChan(response_sender) => self.handle_wgpu_request(
source_pipeline_id, source_pipeline_id,
BrowsingContextId::from(source_top_ctx_id), BrowsingContextId::from(source_top_ctx_id),
FromScriptMsg::RequestAdapter(sender, options, ids), FromScriptMsg::GetWebGPUChan(response_sender),
),
FromScriptMsg::GetWebGPUChan(sender) => self.handle_wgpu_request(
source_pipeline_id,
BrowsingContextId::from(source_top_ctx_id),
FromScriptMsg::GetWebGPUChan(sender),
), ),
FromScriptMsg::TitleChanged(pipeline, title) => { FromScriptMsg::TitleChanged(pipeline, title) => {
if let Some(pipeline) = self.pipelines.get_mut(&pipeline) { if let Some(pipeline) = self.pipelines.get_mut(&pipeline) {
@ -1889,8 +1907,8 @@ where
continue; continue;
} }
if let Some(sender) = self.broadcast_routers.get(&router) { if let Some(broadcast_ipc_sender) = self.broadcast_routers.get(&router) {
if sender.send(message.clone()).is_err() { if broadcast_ipc_sender.send(message.clone()).is_err() {
warn!("Failed to broadcast message to router: {:?}", router); warn!("Failed to broadcast message to router: {:?}", router);
} }
} else { } else {
@ -1987,7 +2005,7 @@ where
&mut self, &mut self,
pipeline_id: PipelineId, pipeline_id: PipelineId,
router_id: BroadcastChannelRouterId, router_id: BroadcastChannelRouterId,
ipc_sender: IpcSender<BroadcastMsg>, broadcast_ipc_sender: IpcSender<BroadcastMsg>,
origin: ImmutableOrigin, origin: ImmutableOrigin,
) { ) {
if self if self
@ -1998,7 +2016,7 @@ where
} }
if self if self
.broadcast_routers .broadcast_routers
.insert(router_id, ipc_sender) .insert(router_id, broadcast_ipc_sender)
.is_some() .is_some()
{ {
warn!("Multple attempt to add broadcast-channel router."); warn!("Multple attempt to add broadcast-channel router.");
@ -2059,9 +2077,9 @@ where
Entry::Occupied(o) => o.get().clone(), Entry::Occupied(o) => o.get().clone(),
}; };
match request { match request {
FromScriptMsg::RequestAdapter(sender, options, ids) => { FromScriptMsg::RequestAdapter(response_sender, options, ids) => {
let adapter_request = WebGPURequest::RequestAdapter { let adapter_request = WebGPURequest::RequestAdapter {
sender, sender: response_sender,
options, options,
ids, ids,
}; };
@ -2069,8 +2087,8 @@ where
return warn!("Failed to send request adapter message on WebGPU channel"); return warn!("Failed to send request adapter message on WebGPU channel");
} }
}, },
FromScriptMsg::GetWebGPUChan(sender) => { FromScriptMsg::GetWebGPUChan(response_sender) => {
if sender.send(webgpu_chan).is_err() { if response_sender.send(webgpu_chan).is_err() {
return warn!( return warn!(
"Failed to send WebGPU channel to Pipeline {:?}", "Failed to send WebGPU channel to Pipeline {:?}",
source_pipeline_id source_pipeline_id
@ -2127,8 +2145,8 @@ where
TransferState::EntangledRemoved => { TransferState::EntangledRemoved => {
// If the entangled port has been removed while this one was in-transfer, // If the entangled port has been removed while this one was in-transfer,
// remove it now. // remove it now.
if let Some(sender) = self.message_port_routers.get(&router_id) { if let Some(ipc_sender) = self.message_port_routers.get(&router_id) {
let _ = sender.send(MessagePortMsg::RemoveMessagePort(port_id)); let _ = ipc_sender.send(MessagePortMsg::RemoveMessagePort(port_id));
} else { } else {
warn!("No message-port sender for {:?}", router_id); warn!("No message-port sender for {:?}", router_id);
} }
@ -2207,8 +2225,8 @@ where
current_buffer.push_front(task); current_buffer.push_front(task);
} }
// Forward the buffered message-queue to complete the current transfer. // Forward the buffered message-queue to complete the current transfer.
if let Some(sender) = self.message_port_routers.get(&target_router_id) { if let Some(ipc_sender) = self.message_port_routers.get(&target_router_id) {
if sender if ipc_sender
.send(MessagePortMsg::CompletePendingTransfer( .send(MessagePortMsg::CompletePendingTransfer(
port_id, port_id,
current_buffer, current_buffer,
@ -2257,8 +2275,8 @@ where
TransferState::EntangledRemoved => { TransferState::EntangledRemoved => {
// If the entangled port has been removed while this one was in-transfer, // If the entangled port has been removed while this one was in-transfer,
// remove it now. // remove it now.
if let Some(sender) = self.message_port_routers.get(&router_id) { if let Some(ipc_sender) = self.message_port_routers.get(&router_id) {
let _ = sender.send(MessagePortMsg::RemoveMessagePort(port_id)); let _ = ipc_sender.send(MessagePortMsg::RemoveMessagePort(port_id));
} else { } else {
warn!("No message-port sender for {:?}", router_id); warn!("No message-port sender for {:?}", router_id);
} }
@ -2303,8 +2321,8 @@ where
if !response.is_empty() { if !response.is_empty() {
// Forward the buffered message-queue. // Forward the buffered message-queue.
if let Some(sender) = self.message_port_routers.get(&router_id) { if let Some(ipc_sender) = self.message_port_routers.get(&router_id) {
if sender if ipc_sender
.send(MessagePortMsg::CompleteTransfer(response)) .send(MessagePortMsg::CompleteTransfer(response))
.is_err() .is_err()
{ {
@ -2331,8 +2349,8 @@ where
// In both the managed and completion of a transfer case, we forward the message. // In both the managed and completion of a transfer case, we forward the message.
// Note that in both cases, if the port is transferred before the message is handled, // Note that in both cases, if the port is transferred before the message is handled,
// it will be sent back here and buffered while the transfer is ongoing. // it will be sent back here and buffered while the transfer is ongoing.
if let Some(sender) = self.message_port_routers.get(&router_id) { if let Some(ipc_sender) = self.message_port_routers.get(&router_id) {
let _ = sender.send(MessagePortMsg::NewTask(port_id, task)); let _ = ipc_sender.send(MessagePortMsg::NewTask(port_id, task));
} else { } else {
warn!("No message-port sender for {:?}", router_id); warn!("No message-port sender for {:?}", router_id);
} }
@ -2374,9 +2392,10 @@ where
fn handle_new_messageport_router( fn handle_new_messageport_router(
&mut self, &mut self,
router_id: MessagePortRouterId, router_id: MessagePortRouterId,
control_sender: IpcSender<MessagePortMsg>, message_port_ipc_sender: IpcSender<MessagePortMsg>,
) { ) {
self.message_port_routers.insert(router_id, control_sender); self.message_port_routers
.insert(router_id, message_port_ipc_sender);
} }
fn handle_remove_messageport_router(&mut self, router_id: MessagePortRouterId) { fn handle_remove_messageport_router(&mut self, router_id: MessagePortRouterId) {
@ -2491,7 +2510,7 @@ where
let (own_sender, receiver) = ipc::channel().expect("Failed to create IPC channel!"); let (own_sender, receiver) = ipc::channel().expect("Failed to create IPC channel!");
let sw_senders = SWManagerSenders { let sw_senders = SWManagerSenders {
swmanager_sender: self.swmanager_sender.clone(), swmanager_sender: self.swmanager_ipc_sender.clone(),
resource_sender: self.public_resource_threads.sender(), resource_sender: self.public_resource_threads.sender(),
own_sender: own_sender.clone(), own_sender: own_sender.clone(),
receiver, receiver,
@ -2555,13 +2574,13 @@ where
// even when currently hanging(on JS or sync XHR). // even when currently hanging(on JS or sync XHR).
// This must be done before starting the process of closing all pipelines. // This must be done before starting the process of closing all pipelines.
for chan in &self.background_monitor_control_senders { for chan in &self.background_monitor_control_senders {
let (exit_sender, exit_receiver) = let (exit_ipc_sender, exit_ipc_receiver) =
ipc::channel().expect("Failed to create IPC channel!"); ipc::channel().expect("Failed to create IPC channel!");
if let Err(e) = chan.send(BackgroundHangMonitorControlMsg::Exit(exit_sender)) { if let Err(e) = chan.send(BackgroundHangMonitorControlMsg::Exit(exit_ipc_sender)) {
warn!("error communicating with bhm: {}", e); warn!("error communicating with bhm: {}", e);
continue; continue;
} }
if exit_receiver.recv().is_err() { if exit_ipc_receiver.recv().is_err() {
warn!("Failed to receive exit confirmation from BHM."); warn!("Failed to receive exit confirmation from BHM.");
} }
} }
@ -2623,19 +2642,20 @@ where
// At this point, there are no active pipelines, // At this point, there are no active pipelines,
// so we can safely block on other threads, without worrying about deadlock. // so we can safely block on other threads, without worrying about deadlock.
// Channels to receive signals when threads are done exiting. // Channels to receive signals when threads are done exiting.
let (core_sender, core_receiver) = ipc::channel().expect("Failed to create IPC channel!"); let (core_ipc_sender, core_ipc_receiver) =
let (storage_sender, storage_receiver) = ipc::channel().expect("Failed to create IPC channel!");
let (storage_ipc_sender, storage_ipc_receiver) =
ipc::channel().expect("Failed to create IPC channel!"); ipc::channel().expect("Failed to create IPC channel!");
debug!("Exiting core resource threads."); debug!("Exiting core resource threads.");
if let Err(e) = self if let Err(e) = self
.public_resource_threads .public_resource_threads
.send(net_traits::CoreResourceMsg::Exit(core_sender)) .send(net_traits::CoreResourceMsg::Exit(core_ipc_sender))
{ {
warn!("Exit resource thread failed ({})", e); warn!("Exit resource thread failed ({})", e);
} }
if let Some(ref chan) = self.devtools_chan { if let Some(ref chan) = self.devtools_sender {
debug!("Exiting devtools."); debug!("Exiting devtools.");
let msg = DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::ServerExitMsg); let msg = DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::ServerExitMsg);
if let Err(e) = chan.send(msg) { if let Err(e) = chan.send(msg) {
@ -2646,13 +2666,13 @@ where
debug!("Exiting storage resource threads."); debug!("Exiting storage resource threads.");
if let Err(e) = self if let Err(e) = self
.public_resource_threads .public_resource_threads
.send(StorageThreadMsg::Exit(storage_sender)) .send(StorageThreadMsg::Exit(storage_ipc_sender))
{ {
warn!("Exit storage thread failed ({})", e); warn!("Exit storage thread failed ({})", e);
} }
debug!("Exiting bluetooth thread."); debug!("Exiting bluetooth thread.");
if let Err(e) = self.bluetooth_thread.send(BluetoothRequest::Exit) { if let Err(e) = self.bluetooth_ipc_sender.send(BluetoothRequest::Exit) {
warn!("Exit bluetooth thread failed ({})", e); warn!("Exit bluetooth thread failed ({})", e);
} }
@ -2664,7 +2684,7 @@ where
} }
debug!("Exiting Canvas Paint thread."); debug!("Exiting Canvas Paint thread.");
if let Err(e) = self.canvas_chan.send(ConstellationCanvasMsg::Exit) { if let Err(e) = self.canvas_sender.send(ConstellationCanvasMsg::Exit) {
warn!("Exit Canvas Paint thread failed ({})", e); warn!("Exit Canvas Paint thread failed ({})", e);
} }
@ -2710,10 +2730,10 @@ where
self.font_cache_thread.exit(); self.font_cache_thread.exit();
// Receive exit signals from threads. // Receive exit signals from threads.
if let Err(e) = core_receiver.recv() { if let Err(e) = core_ipc_receiver.recv() {
warn!("Exit resource thread failed ({:?})", e); warn!("Exit resource thread failed ({:?})", e);
} }
if let Err(e) = storage_receiver.recv() { if let Err(e) = storage_ipc_receiver.recv() {
warn!("Exit storage thread failed ({:?})", e); warn!("Exit storage thread failed ({:?})", e);
} }
@ -2821,9 +2841,9 @@ where
is_visible, is_visible,
); );
self.add_pending_change(SessionHistoryChange { self.add_pending_change(SessionHistoryChange {
top_level_browsing_context_id: top_level_browsing_context_id, top_level_browsing_context_id,
browsing_context_id: browsing_context_id, browsing_context_id,
new_pipeline_id: new_pipeline_id, new_pipeline_id,
replace: None, replace: None,
new_browsing_context_info: None, new_browsing_context_info: None,
window_size, window_size,
@ -2959,15 +2979,15 @@ where
is_visible, is_visible,
); );
self.add_pending_change(SessionHistoryChange { self.add_pending_change(SessionHistoryChange {
top_level_browsing_context_id: top_level_browsing_context_id, top_level_browsing_context_id,
browsing_context_id: browsing_context_id, browsing_context_id,
new_pipeline_id: pipeline_id, new_pipeline_id: pipeline_id,
replace: None, replace: None,
new_browsing_context_info: Some(NewBrowsingContextInfo { new_browsing_context_info: Some(NewBrowsingContextInfo {
parent_pipeline_id: None, parent_pipeline_id: None,
is_private: is_private, is_private,
inherited_secure_context: None, inherited_secure_context: None,
is_visible: is_visible, is_visible,
}), }),
window_size, window_size,
}); });
@ -3221,14 +3241,14 @@ where
assert!(!self.pipelines.contains_key(&new_pipeline_id)); assert!(!self.pipelines.contains_key(&new_pipeline_id));
self.pipelines.insert(new_pipeline_id, pipeline); self.pipelines.insert(new_pipeline_id, pipeline);
self.add_pending_change(SessionHistoryChange { self.add_pending_change(SessionHistoryChange {
top_level_browsing_context_id: top_level_browsing_context_id, top_level_browsing_context_id,
browsing_context_id: browsing_context_id, browsing_context_id,
new_pipeline_id: new_pipeline_id, new_pipeline_id,
replace: None, replace: None,
// Browsing context for iframe doesn't exist yet. // Browsing context for iframe doesn't exist yet.
new_browsing_context_info: Some(NewBrowsingContextInfo { new_browsing_context_info: Some(NewBrowsingContextInfo {
parent_pipeline_id: Some(parent_pipeline_id), parent_pipeline_id: Some(parent_pipeline_id),
is_private: is_private, is_private,
inherited_secure_context: is_parent_secure, inherited_secure_context: is_parent_secure,
is_visible: is_parent_visible, is_visible: is_parent_visible,
}), }),
@ -3313,7 +3333,7 @@ where
self.add_pending_change(SessionHistoryChange { self.add_pending_change(SessionHistoryChange {
top_level_browsing_context_id: new_top_level_browsing_context_id, top_level_browsing_context_id: new_top_level_browsing_context_id,
browsing_context_id: new_browsing_context_id, browsing_context_id: new_browsing_context_id,
new_pipeline_id: new_pipeline_id, new_pipeline_id,
replace: None, replace: None,
new_browsing_context_info: Some(NewBrowsingContextInfo { new_browsing_context_info: Some(NewBrowsingContextInfo {
// Auxiliary browsing contexts are always top-level. // Auxiliary browsing contexts are always top-level.
@ -3816,8 +3836,8 @@ where
); );
self.add_pending_change(SessionHistoryChange { self.add_pending_change(SessionHistoryChange {
top_level_browsing_context_id: top_level_id, top_level_browsing_context_id: top_level_id,
browsing_context_id: browsing_context_id, browsing_context_id,
new_pipeline_id: new_pipeline_id, new_pipeline_id,
replace: Some(NeedsToReload::Yes(pipeline_id, load_data)), replace: Some(NeedsToReload::Yes(pipeline_id, load_data)),
// Browsing context must exist at this point. // Browsing context must exist at this point.
new_browsing_context_info: None, new_browsing_context_info: None,
@ -3850,7 +3870,7 @@ where
old_pipeline.notify_visibility(false); old_pipeline.notify_visibility(false);
} }
if let Some(new_pipeline) = self.pipelines.get(&new_pipeline_id) { if let Some(new_pipeline) = self.pipelines.get(&new_pipeline_id) {
if let Some(ref chan) = self.devtools_chan { if let Some(ref chan) = self.devtools_sender {
let state = NavigationState::Start(new_pipeline.url.clone()); let state = NavigationState::Start(new_pipeline.url.clone());
let _ = chan.send(DevtoolsControlMsg::FromScript( let _ = chan.send(DevtoolsControlMsg::FromScript(
ScriptToDevtoolsControlMsg::Navigate(browsing_context_id, state), ScriptToDevtoolsControlMsg::Navigate(browsing_context_id, state),
@ -3926,14 +3946,14 @@ where
fn handle_joint_session_history_length( fn handle_joint_session_history_length(
&self, &self,
top_level_browsing_context_id: TopLevelBrowsingContextId, top_level_browsing_context_id: TopLevelBrowsingContextId,
sender: IpcSender<u32>, response_sender: IpcSender<u32>,
) { ) {
let length = self let length = self
.browsers .browsers
.get(&top_level_browsing_context_id) .get(&top_level_browsing_context_id)
.map(|browser| browser.session_history.history_length()) .map(|browser| browser.session_history.history_length())
.unwrap_or(1); .unwrap_or(1);
let _ = sender.send(length as u32); let _ = response_sender.send(length as u32);
} }
fn handle_push_history_state_msg( fn handle_push_history_state_msg(
@ -3968,7 +3988,7 @@ where
new_history_state_id: history_state_id, new_history_state_id: history_state_id,
new_url: url, new_url: url,
old_history_state_id: old_state_id, old_history_state_id: old_state_id,
old_url: old_url, old_url,
}; };
self.get_joint_session_history(top_level_browsing_context_id) self.get_joint_session_history(top_level_browsing_context_id)
.push_diff(diff); .push_diff(diff);
@ -4114,7 +4134,7 @@ where
let msg = ConstellationControlMsg::PostMessage { let msg = ConstellationControlMsg::PostMessage {
target: pipeline_id, target: pipeline_id,
source: source_pipeline, source: source_pipeline,
source_browsing_context: source_browsing_context, source_browsing_context,
target_origin: origin, target_origin: origin,
source_origin, source_origin,
data, data,
@ -4131,7 +4151,7 @@ where
fn handle_get_pipeline( fn handle_get_pipeline(
&mut self, &mut self,
browsing_context_id: BrowsingContextId, browsing_context_id: BrowsingContextId,
resp_chan: IpcSender<Option<PipelineId>>, response_sender: IpcSender<Option<PipelineId>>,
) { ) {
let current_pipeline_id = self let current_pipeline_id = self
.browsing_contexts .browsing_contexts
@ -4144,7 +4164,7 @@ where
.find(|x| x.browsing_context_id == browsing_context_id) .find(|x| x.browsing_context_id == browsing_context_id)
.map(|x| x.new_pipeline_id) .map(|x| x.new_pipeline_id)
.or(current_pipeline_id); .or(current_pipeline_id);
if let Err(e) = resp_chan.send(pipeline_id_loaded) { if let Err(e) = response_sender.send(pipeline_id_loaded) {
warn!("Failed get_pipeline response ({}).", e); warn!("Failed get_pipeline response ({}).", e);
} }
} }
@ -4152,13 +4172,13 @@ where
fn handle_get_browsing_context( fn handle_get_browsing_context(
&mut self, &mut self,
pipeline_id: PipelineId, pipeline_id: PipelineId,
resp_chan: IpcSender<Option<BrowsingContextId>>, response_sender: IpcSender<Option<BrowsingContextId>>,
) { ) {
let browsing_context_id = self let browsing_context_id = self
.pipelines .pipelines
.get(&pipeline_id) .get(&pipeline_id)
.map(|pipeline| pipeline.browsing_context_id); .map(|pipeline| pipeline.browsing_context_id);
if let Err(e) = resp_chan.send(browsing_context_id) { if let Err(e) = response_sender.send(browsing_context_id) {
warn!("Failed get_browsing_context response ({}).", e); warn!("Failed get_browsing_context response ({}).", e);
} }
} }
@ -4277,7 +4297,7 @@ where
) { ) {
let (canvas_id_sender, canvas_id_receiver) = unbounded(); let (canvas_id_sender, canvas_id_receiver) = unbounded();
if let Err(e) = self.canvas_chan.send(ConstellationCanvasMsg::Create { if let Err(e) = self.canvas_sender.send(ConstellationCanvasMsg::Create {
id_sender: canvas_id_sender, id_sender: canvas_id_sender,
size, size,
antialias: self.enable_canvas_antialiasing, antialias: self.enable_canvas_antialiasing,
@ -4288,7 +4308,7 @@ where
Ok(canvas_id) => canvas_id, Ok(canvas_id) => canvas_id,
Err(e) => return warn!("Create canvas paint thread id response failed ({})", e), Err(e) => return warn!("Create canvas paint thread id response failed ({})", e),
}; };
if let Err(e) = response_sender.send((self.ipc_canvas_chan.clone(), canvas_id)) { if let Err(e) = response_sender.send((self.canvas_ipc_sender.clone(), canvas_id)) {
warn!("Create canvas paint thread response failed ({})", e); warn!("Create canvas paint thread response failed ({})", e);
} }
} }
@ -4297,25 +4317,33 @@ where
// Find the script channel for the given parent pipeline, // Find the script channel for the given parent pipeline,
// and pass the event to that script thread. // and pass the event to that script thread.
match msg { match msg {
WebDriverCommandMsg::GetWindowSize(_, reply) => { WebDriverCommandMsg::GetWindowSize(_, response_sender) => {
let _ = reply.send(self.window_size); let _ = response_sender.send(self.window_size);
}, },
WebDriverCommandMsg::SetWindowSize(top_level_browsing_context_id, size, reply) => { WebDriverCommandMsg::SetWindowSize(
self.webdriver.resize_channel = Some(reply); top_level_browsing_context_id,
size,
response_sender,
) => {
self.webdriver.resize_channel = Some(response_sender);
self.embedder_proxy.send(( self.embedder_proxy.send((
Some(top_level_browsing_context_id), Some(top_level_browsing_context_id),
EmbedderMsg::ResizeTo(size), EmbedderMsg::ResizeTo(size),
)); ));
}, },
WebDriverCommandMsg::LoadUrl(top_level_browsing_context_id, load_data, reply) => { WebDriverCommandMsg::LoadUrl(
top_level_browsing_context_id,
load_data,
response_sender,
) => {
self.load_url_for_webdriver( self.load_url_for_webdriver(
top_level_browsing_context_id, top_level_browsing_context_id,
load_data, load_data,
reply, response_sender,
HistoryEntryReplacement::Disabled, HistoryEntryReplacement::Disabled,
); );
}, },
WebDriverCommandMsg::Refresh(top_level_browsing_context_id, reply) => { WebDriverCommandMsg::Refresh(top_level_browsing_context_id, response_sender) => {
let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id); let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id);
let pipeline_id = match self.browsing_contexts.get(&browsing_context_id) { let pipeline_id = match self.browsing_contexts.get(&browsing_context_id) {
Some(browsing_context) => browsing_context.pipeline_id, Some(browsing_context) => browsing_context.pipeline_id,
@ -4333,7 +4361,7 @@ where
self.load_url_for_webdriver( self.load_url_for_webdriver(
top_level_browsing_context_id, top_level_browsing_context_id,
load_data, load_data,
reply, response_sender,
HistoryEntryReplacement::Enabled, HistoryEntryReplacement::Enabled,
); );
}, },
@ -4422,9 +4450,9 @@ where
self.compositor_proxy self.compositor_proxy
.send(ToCompositorMsg::WebDriverMouseMoveEvent(x, y)); .send(ToCompositorMsg::WebDriverMouseMoveEvent(x, y));
}, },
WebDriverCommandMsg::TakeScreenshot(_, rect, reply) => { WebDriverCommandMsg::TakeScreenshot(_, rect, response_sender) => {
self.compositor_proxy self.compositor_proxy
.send(ToCompositorMsg::CreatePng(rect, reply)); .send(ToCompositorMsg::CreatePng(rect, response_sender));
}, },
} }
} }
@ -4578,7 +4606,7 @@ where
&mut self, &mut self,
top_level_browsing_context_id: TopLevelBrowsingContextId, top_level_browsing_context_id: TopLevelBrowsingContextId,
load_data: LoadData, load_data: LoadData,
reply: IpcSender<webdriver_msg::LoadStatus>, response_sender: IpcSender<webdriver_msg::LoadStatus>,
replace: HistoryEntryReplacement, replace: HistoryEntryReplacement,
) { ) {
let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id); let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id);
@ -4597,7 +4625,7 @@ where
load_data, load_data,
replace, replace,
) { ) {
self.webdriver.load_channel = Some((new_pipeline_id, reply)); self.webdriver.load_channel = Some((new_pipeline_id, response_sender));
} }
} }
@ -4890,8 +4918,8 @@ where
let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id); let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id);
self.resize_browsing_context(new_size, size_type, browsing_context_id); self.resize_browsing_context(new_size, size_type, browsing_context_id);
if let Some(resize_channel) = self.webdriver.resize_channel.take() { if let Some(response_sender) = self.webdriver.resize_channel.take() {
let _ = resize_channel.send(new_size); let _ = response_sender.send(new_size);
} }
self.window_size = new_size; self.window_size = new_size;
@ -4945,7 +4973,8 @@ where
} }
let (state_sender, state_receiver) = ipc::channel().expect("Failed to create IPC channel!"); let (state_sender, state_receiver) = ipc::channel().expect("Failed to create IPC channel!");
let (epoch_sender, epoch_receiver) = ipc::channel().expect("Failed to create IPC channel!"); let (epoch_ipc_sender, epoch_ipc_receiver) =
ipc::channel().expect("Failed to create IPC channel!");
// Step through the fully active browsing contexts, checking that the script // Step through the fully active browsing contexts, checking that the script
// thread is idle, and that the current epoch of the layout thread // thread is idle, and that the current epoch of the layout thread
@ -5011,11 +5040,11 @@ where
// epoch matches what the compositor has drawn. If they match // epoch matches what the compositor has drawn. If they match
// (and script is idle) then this pipeline won't change again // (and script is idle) then this pipeline won't change again
// and can be considered stable. // and can be considered stable.
let message = LayoutControlMsg::GetCurrentEpoch(epoch_sender.clone()); let message = LayoutControlMsg::GetCurrentEpoch(epoch_ipc_sender.clone());
if let Err(e) = pipeline.layout_chan.send(message) { if let Err(e) = pipeline.layout_chan.send(message) {
warn!("Failed to send GetCurrentEpoch ({}).", e); warn!("Failed to send GetCurrentEpoch ({}).", e);
} }
match epoch_receiver.recv() { match epoch_ipc_receiver.recv() {
Err(e) => warn!("Failed to receive current epoch ({:?}).", e), Err(e) => warn!("Failed to receive current epoch ({:?}).", e),
Ok(layout_thread_epoch) => { Ok(layout_thread_epoch) => {
if layout_thread_epoch != *compositor_epoch { if layout_thread_epoch != *compositor_epoch {

55
components/constellation/pipeline.rs
View file

@ -145,7 +145,7 @@ pub struct InitialPipelineState {
pub compositor_proxy: CompositorProxy, pub compositor_proxy: CompositorProxy,
/// A channel to the developer tools, if applicable. /// A channel to the developer tools, if applicable.
pub devtools_chan: Option<Sender<DevtoolsControlMsg>>, pub devtools_sender: Option<Sender<DevtoolsControlMsg>>,
/// A channel to the bluetooth thread. /// A channel to the bluetooth thread.
pub bluetooth_thread: IpcSender<BluetoothRequest>, pub bluetooth_thread: IpcSender<BluetoothRequest>,
@ -249,29 +249,30 @@ impl Pipeline {
let (script_chan, script_port) = ipc::channel().expect("Pipeline script chan"); let (script_chan, script_port) = ipc::channel().expect("Pipeline script chan");
// Route messages coming from content to devtools as appropriate. // Route messages coming from content to devtools as appropriate.
let script_to_devtools_chan = state.devtools_chan.as_ref().map(|devtools_chan| { let script_to_devtools_ipc_sender =
let (script_to_devtools_chan, script_to_devtools_port) = state.devtools_sender.as_ref().map(|devtools_sender| {
ipc::channel().expect("Pipeline script to devtools chan"); let (script_to_devtools_ipc_sender, script_to_devtools_ipc_receiver) =
let devtools_chan = (*devtools_chan).clone(); ipc::channel().expect("Pipeline script to devtools chan");
ROUTER.add_route( let devtools_sender = (*devtools_sender).clone();
script_to_devtools_port.to_opaque(), ROUTER.add_route(
Box::new( script_to_devtools_ipc_receiver.to_opaque(),
move |message| match message.to::<ScriptToDevtoolsControlMsg>() { Box::new(move |message| {
Err(e) => { match message.to::<ScriptToDevtoolsControlMsg>() {
error!("Cast to ScriptToDevtoolsControlMsg failed ({}).", e) Err(e) => {
}, error!("Cast to ScriptToDevtoolsControlMsg failed ({}).", e)
Ok(message) => { },
if let Err(e) = Ok(message) => {
devtools_chan.send(DevtoolsControlMsg::FromScript(message)) if let Err(e) = devtools_sender
{ .send(DevtoolsControlMsg::FromScript(message))
warn!("Sending to devtools failed ({:?})", e) {
} warn!("Sending to devtools failed ({:?})", e)
}, }
}, },
), }
); }),
script_to_devtools_chan );
}); script_to_devtools_ipc_sender
});
let mut unprivileged_pipeline_content = UnprivilegedPipelineContent { let mut unprivileged_pipeline_content = UnprivilegedPipelineContent {
id: state.id, id: state.id,
@ -286,7 +287,7 @@ impl Pipeline {
.clone(), .clone(),
bhm_control_port: None, bhm_control_port: None,
scheduler_chan: state.scheduler_chan, scheduler_chan: state.scheduler_chan,
devtools_chan: script_to_devtools_chan, devtools_ipc_sender: script_to_devtools_ipc_sender,
bluetooth_thread: state.bluetooth_thread, bluetooth_thread: state.bluetooth_thread,
swmanager_thread: state.swmanager_thread, swmanager_thread: state.swmanager_thread,
font_cache_thread: state.font_cache_thread, font_cache_thread: state.font_cache_thread,
@ -496,7 +497,7 @@ pub struct UnprivilegedPipelineContent {
bhm_control_port: Option<IpcReceiver<BackgroundHangMonitorControlMsg>>, bhm_control_port: Option<IpcReceiver<BackgroundHangMonitorControlMsg>>,
layout_to_constellation_chan: IpcSender<LayoutMsg>, layout_to_constellation_chan: IpcSender<LayoutMsg>,
scheduler_chan: IpcSender<TimerSchedulerMsg>, scheduler_chan: IpcSender<TimerSchedulerMsg>,
devtools_chan: Option<IpcSender<ScriptToDevtoolsControlMsg>>, devtools_ipc_sender: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
bluetooth_thread: IpcSender<BluetoothRequest>, bluetooth_thread: IpcSender<BluetoothRequest>,
swmanager_thread: IpcSender<SWManagerMsg>, swmanager_thread: IpcSender<SWManagerMsg>,
font_cache_thread: FontCacheThread, font_cache_thread: FontCacheThread,
@ -562,7 +563,7 @@ impl UnprivilegedPipelineContent {
image_cache: image_cache.clone(), image_cache: image_cache.clone(),
time_profiler_chan: self.time_profiler_chan.clone(), time_profiler_chan: self.time_profiler_chan.clone(),
mem_profiler_chan: self.mem_profiler_chan.clone(), mem_profiler_chan: self.mem_profiler_chan.clone(),
devtools_chan: self.devtools_chan, devtools_chan: self.devtools_ipc_sender,
window_size: self.window_size, window_size: self.window_size,
pipeline_namespace_id: self.pipeline_namespace_id, pipeline_namespace_id: self.pipeline_namespace_id,
content_process_shutdown_chan: content_process_shutdown_chan, content_process_shutdown_chan: content_process_shutdown_chan,

16
components/net/resource_thread.rs
View file

@ -55,7 +55,7 @@ use std::time::Duration;
/// Returns a tuple of (public, private) senders to the new threads. /// Returns a tuple of (public, private) senders to the new threads.
pub fn new_resource_threads( pub fn new_resource_threads(
user_agent: Cow<'static, str>, user_agent: Cow<'static, str>,
devtools_chan: Option<Sender<DevtoolsControlMsg>>, devtools_sender: Option<Sender<DevtoolsControlMsg>>,
time_profiler_chan: ProfilerChan, time_profiler_chan: ProfilerChan,
mem_profiler_chan: MemProfilerChan, mem_profiler_chan: MemProfilerChan,
embedder_proxy: EmbedderProxy, embedder_proxy: EmbedderProxy,
@ -64,7 +64,7 @@ pub fn new_resource_threads(
) -> (ResourceThreads, ResourceThreads) { ) -> (ResourceThreads, ResourceThreads) {
let (public_core, private_core) = new_core_resource_thread( let (public_core, private_core) = new_core_resource_thread(
user_agent, user_agent,
devtools_chan, devtools_sender,
time_profiler_chan, time_profiler_chan,
mem_profiler_chan, mem_profiler_chan,
embedder_proxy, embedder_proxy,
@ -81,7 +81,7 @@ pub fn new_resource_threads(
/// Create a CoreResourceThread /// Create a CoreResourceThread
pub fn new_core_resource_thread( pub fn new_core_resource_thread(
user_agent: Cow<'static, str>, user_agent: Cow<'static, str>,
devtools_chan: Option<Sender<DevtoolsControlMsg>>, devtools_sender: Option<Sender<DevtoolsControlMsg>>,
time_profiler_chan: ProfilerChan, time_profiler_chan: ProfilerChan,
mem_profiler_chan: MemProfilerChan, mem_profiler_chan: MemProfilerChan,
embedder_proxy: EmbedderProxy, embedder_proxy: EmbedderProxy,
@ -97,7 +97,7 @@ pub fn new_core_resource_thread(
.spawn(move || { .spawn(move || {
let resource_manager = CoreResourceManager::new( let resource_manager = CoreResourceManager::new(
user_agent, user_agent,
devtools_chan, devtools_sender,
time_profiler_chan, time_profiler_chan,
embedder_proxy, embedder_proxy,
certificate_path.clone(), certificate_path.clone(),
@ -451,7 +451,7 @@ pub struct AuthCache {
pub struct CoreResourceManager { pub struct CoreResourceManager {
user_agent: Cow<'static, str>, user_agent: Cow<'static, str>,
devtools_chan: Option<Sender<DevtoolsControlMsg>>, devtools_sender: Option<Sender<DevtoolsControlMsg>>,
sw_managers: HashMap<ImmutableOrigin, IpcSender<CustomResponseMediator>>, sw_managers: HashMap<ImmutableOrigin, IpcSender<CustomResponseMediator>>,
filemanager: FileManager, filemanager: FileManager,
thread_pool: Arc<CoreResourceThreadPool>, thread_pool: Arc<CoreResourceThreadPool>,
@ -586,7 +586,7 @@ impl CoreResourceThreadPool {
impl CoreResourceManager { impl CoreResourceManager {
pub fn new( pub fn new(
user_agent: Cow<'static, str>, user_agent: Cow<'static, str>,
devtools_channel: Option<Sender<DevtoolsControlMsg>>, devtools_sender: Option<Sender<DevtoolsControlMsg>>,
_profiler_chan: ProfilerChan, _profiler_chan: ProfilerChan,
embedder_proxy: EmbedderProxy, embedder_proxy: EmbedderProxy,
certificate_path: Option<String>, certificate_path: Option<String>,
@ -595,7 +595,7 @@ impl CoreResourceManager {
let pool_handle = Arc::new(pool); let pool_handle = Arc::new(pool);
CoreResourceManager { CoreResourceManager {
user_agent: user_agent, user_agent: user_agent,
devtools_chan: devtools_channel, devtools_sender,
sw_managers: Default::default(), sw_managers: Default::default(),
filemanager: FileManager::new(embedder_proxy, Arc::downgrade(&pool_handle)), filemanager: FileManager::new(embedder_proxy, Arc::downgrade(&pool_handle)),
thread_pool: pool_handle, thread_pool: pool_handle,
@ -636,7 +636,7 @@ impl CoreResourceManager {
) { ) {
let http_state = http_state.clone(); let http_state = http_state.clone();
let ua = self.user_agent.clone(); let ua = self.user_agent.clone();
let dc = self.devtools_chan.clone(); let dc = self.devtools_sender.clone();
let filemanager = self.filemanager.clone(); let filemanager = self.filemanager.clone();
let timing_type = match request_builder.destination { let timing_type = match request_builder.destination {

16
components/servo/lib.rs
View file

@ -359,7 +359,7 @@ where
); );
let mem_profiler_chan = profile_mem::Profiler::create(opts.mem_profiler_period); let mem_profiler_chan = profile_mem::Profiler::create(opts.mem_profiler_period);
let devtools_chan = if opts.devtools_server_enabled { let devtools_sender = if opts.devtools_server_enabled {
Some(devtools::start_server( Some(devtools::start_server(
opts.devtools_port, opts.devtools_port,
embedder_proxy.clone(), embedder_proxy.clone(),
@ -507,7 +507,7 @@ where
compositor_proxy.clone(), compositor_proxy.clone(),
time_profiler_chan.clone(), time_profiler_chan.clone(),
mem_profiler_chan.clone(), mem_profiler_chan.clone(),
devtools_chan, devtools_sender,
webrender_document, webrender_document,
webrender_api_sender, webrender_api_sender,
webxr_main_thread.registry(), webxr_main_thread.registry(),
@ -868,7 +868,7 @@ fn create_constellation(
compositor_proxy: CompositorProxy, compositor_proxy: CompositorProxy,
time_profiler_chan: time::ProfilerChan, time_profiler_chan: time::ProfilerChan,
mem_profiler_chan: mem::ProfilerChan, mem_profiler_chan: mem::ProfilerChan,
devtools_chan: Option<Sender<devtools_traits::DevtoolsControlMsg>>, devtools_sender: Option<Sender<devtools_traits::DevtoolsControlMsg>>,
webrender_document: webrender_api::DocumentId, webrender_document: webrender_api::DocumentId,
webrender_api_sender: webrender_api::RenderApiSender, webrender_api_sender: webrender_api::RenderApiSender,
webxr_registry: webxr_api::Registry, webxr_registry: webxr_api::Registry,
@ -888,7 +888,7 @@ fn create_constellation(
let (public_resource_threads, private_resource_threads) = new_resource_threads( let (public_resource_threads, private_resource_threads) = new_resource_threads(
user_agent.clone(), user_agent.clone(),
devtools_chan.clone(), devtools_sender.clone(),
time_profiler_chan.clone(), time_profiler_chan.clone(),
mem_profiler_chan.clone(), mem_profiler_chan.clone(),
embedder_proxy.clone(), embedder_proxy.clone(),
@ -901,7 +901,7 @@ fn create_constellation(
Box::new(FontCacheWR(compositor_proxy.clone())), Box::new(FontCacheWR(compositor_proxy.clone())),
); );
let (canvas_chan, ipc_canvas_chan) = CanvasPaintThread::start( let (canvas_create_sender, canvas_ipc_sender) = CanvasPaintThread::start(
Box::new(CanvasWebrenderApi(compositor_proxy.clone())), Box::new(CanvasWebrenderApi(compositor_proxy.clone())),
font_cache_thread.clone(), font_cache_thread.clone(),
); );
@ -909,7 +909,7 @@ fn create_constellation(
let initial_state = InitialConstellationState { let initial_state = InitialConstellationState {
compositor_proxy, compositor_proxy,
embedder_proxy, embedder_proxy,
devtools_chan, devtools_sender,
bluetooth_thread, bluetooth_thread,
font_cache_thread, font_cache_thread,
public_resource_threads, public_resource_threads,
@ -941,8 +941,8 @@ fn create_constellation(
opts.is_running_problem_test, opts.is_running_problem_test,
opts.hard_fail, opts.hard_fail,
!opts.debug.disable_canvas_antialiasing, !opts.debug.disable_canvas_antialiasing,
canvas_chan, canvas_create_sender,
ipc_canvas_chan, canvas_ipc_sender,
); );
constellation_chan constellation_chan