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

Use non-IPC webrender API over explicit IPC channels.

Browse source
This commit is contained in:
Josh Matthews 2019-11-25 17:18:04 -05:00
parent a922c497fa
commit 564c16d754
77 changed files with 494 additions and 360 deletions
Download patch file Download diff file Expand all files Collapse all files

3
components/canvas/Cargo.toml
View file

@ -21,6 +21,7 @@ azure = {git = "https://github.com/servo/rust-azure", optional = true}
bitflags = "1.0"
byteorder = "1"
canvas_traits = {path = "../canvas_traits"}
crossbeam-channel = "0.3"
cssparser = "0.27.1"
embedder_traits = {path = "../embedder_traits"}
euclid = "0.20"
@ -35,7 +36,7 @@ pixels = {path = "../pixels"}
servo_config = {path = "../config"}
sparkle = "0.1.12"
webrender = {git = "https://github.com/servo/webrender"}
webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
webrender_api = {git = "https://github.com/servo/webrender"}
webrender_traits = {path = "../webrender_traits"}
webxr-api = {git = "https://github.com/servo/webxr", features = ["ipc"]}
# NOTE: the sm-angle feature only enables angle on windows, not other platforms!

87
components/canvas/canvas_paint_thread.rs
View file

@ -3,9 +3,12 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use crate::canvas_data::*;
use crate::ConstellationCanvasMsg;
use canvas_traits::canvas::*;
use crossbeam_channel::{select, unbounded, Sender};
use euclid::default::Size2D;
use ipc_channel::ipc::{self, IpcSender};
use ipc_channel::router::ROUTER;
use std::borrow::ToOwned;
use std::collections::HashMap;
use std::thread;
@ -30,53 +33,69 @@ impl<'a> CanvasPaintThread<'a> {
/// Creates a new `CanvasPaintThread` and returns an `IpcSender` to
/// communicate with it.
pub fn start() -> IpcSender<CanvasMsg> {
let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap();
pub fn start() -> (Sender<ConstellationCanvasMsg>, IpcSender<CanvasMsg>) {
let (ipc_sender, ipc_receiver) = ipc::channel::<CanvasMsg>().unwrap();
let msg_receiver = ROUTER.route_ipc_receiver_to_new_crossbeam_receiver(ipc_receiver);
let (create_sender, create_receiver) = unbounded();
thread::Builder::new()
.name("CanvasThread".to_owned())
.spawn(move || {
let mut canvas_paint_thread = CanvasPaintThread::new();
loop {
match receiver.recv() {
Ok(msg) => match msg {
CanvasMsg::Canvas2d(message, canvas_id) => {
canvas_paint_thread.process_canvas_2d_message(message, canvas_id);
},
CanvasMsg::Close(canvas_id) => {
canvas_paint_thread.canvases.remove(&canvas_id);
},
CanvasMsg::Create(creator, size, webrenderer_api_sender, antialias) => {
let canvas_id = canvas_paint_thread.create_canvas(
select! {
recv(msg_receiver) -> msg => {
match msg {
Ok(CanvasMsg::Canvas2d(message, canvas_id)) => {
canvas_paint_thread.process_canvas_2d_message(message, canvas_id);
},
Ok(CanvasMsg::Close(canvas_id)) => {
canvas_paint_thread.canvases.remove(&canvas_id);
},
Ok(CanvasMsg::Recreate(size, canvas_id)) => {
canvas_paint_thread.canvas(canvas_id).recreate(size);
},
Ok(CanvasMsg::FromScript(message, canvas_id)) => match message {
FromScriptMsg::SendPixels(chan) => {
canvas_paint_thread.canvas(canvas_id).send_pixels(chan);
},
},
Ok(CanvasMsg::FromLayout(message, canvas_id)) => match message {
FromLayoutMsg::SendData(chan) => {
canvas_paint_thread.canvas(canvas_id).send_data(chan);
},
},
Err(e) => {
warn!("Error on CanvasPaintThread receive ({})", e);
},
}
}
recv(create_receiver) -> msg => {
match msg {
Ok(ConstellationCanvasMsg::Create {
id_sender: creator,
size,
webrenderer_api_sender,
antialias,
);
creator.send(canvas_id).unwrap();
},
CanvasMsg::Recreate(size, canvas_id) => {
canvas_paint_thread.canvas(canvas_id).recreate(size);
},
CanvasMsg::FromScript(message, canvas_id) => match message {
FromScriptMsg::SendPixels(chan) => {
canvas_paint_thread.canvas(canvas_id).send_pixels(chan);
webrender_sender: webrenderer_api_sender,
antialias
}) => {
let canvas_id = canvas_paint_thread.create_canvas(
size,
webrenderer_api_sender,
antialias,
);
creator.send(canvas_id).unwrap();
},
},
CanvasMsg::FromLayout(message, canvas_id) => match message {
FromLayoutMsg::SendData(chan) => {
canvas_paint_thread.canvas(canvas_id).send_data(chan);
Ok(ConstellationCanvasMsg::Exit) => break,
Err(e) => {
warn!("Error on CanvasPaintThread receive ({})", e);
},
},
CanvasMsg::Exit => break,
},
Err(e) => {
warn!("Error on CanvasPaintThread receive ({})", e);
},
}
}
}
}
})
.expect("Thread spawning failed");
sender
(create_sender, ipc_sender)
}
pub fn create_canvas(

14
components/canvas/lib.rs
View file

@ -4,6 +4,10 @@
#![deny(unsafe_code)]
use canvas_traits::canvas::CanvasId;
use crossbeam_channel::Sender;
use euclid::default::Size2D;
#[macro_use]
extern crate bitflags;
#[macro_use]
@ -22,3 +26,13 @@ pub mod canvas_paint_thread;
mod webgl_limits;
mod webgl_mode;
pub mod webgl_thread;
pub enum ConstellationCanvasMsg {
Create {
id_sender: Sender<CanvasId>,
size: Size2D<u64>,
webrender_sender: webrender_api::RenderApiSender,
antialias: bool,
},
Exit,
}

4
components/canvas/webgl_mode/inprocess.rs
View file

@ -28,7 +28,7 @@ pub struct WebGLComm {
pub webgl_threads: WebGLThreads,
pub webxr_swap_chains: SwapChains<WebXRSwapChainId>,
pub image_handler: Box<dyn WebrenderExternalImageApi>,
pub output_handler: Option<Box<dyn webrender::OutputImageHandler>>,
pub output_handler: Option<Box<dyn webrender_api::OutputImageHandler>>,
}
impl WebGLComm {
@ -168,7 +168,7 @@ impl OutputHandler {
}
/// Bridge between the WR frame outputs and WebGL to implement DOMToTexture synchronization.
impl webrender::OutputImageHandler for OutputHandler {
impl webrender_api::OutputImageHandler for OutputHandler {
fn lock(
&mut self,
id: webrender_api::PipelineId,