Struct IOCompositor 

pub struct IOCompositor {

    painters: Vec<Rc<RefCell<Painter>>>,
    pub(crate) compositor_proxy: CompositorProxy,
    pub(crate) event_loop_waker: Box<dyn EventLoopWaker>,
    shutdown_state: Rc<Cell<ShutdownState>>,
    compositor_receiver: RoutedReceiver<CompositorMsg>,
    pub(crate) embedder_to_constellation_sender: Sender<EmbedderToConstellationMessage>,
    webrender_external_image_id_manager: WebRenderExternalImageIdManager,
    pub(crate) painter_surfman_details_map: PainterSurfmanDetailsMap,
    pub(crate) busy_webgl_contexts_map: WebGLContextBusyMap,
    webgl_threads: WebGLThreads,
    pub(crate) swap_chains: SwapChains<WebGLContextId, Device>,
    time_profiler_chan: ProfilerChan,
    _mem_profiler_registration: ProfilerRegistration,
    webxr_main_thread: RefCell<MainThreadRegistry>,
    webgpu_image_map: OnceCell<WebGpuExternalImageMap>,
}

NB: Never block on the constellation, because sometimes the constellation blocks on us.

Fields

painters: Vec<Rc<RefCell<Painter>>>

All of the [Painters] for this IOCompositor. Each Painter handles painting to a single RenderingContext.

compositor_proxy: CompositorProxy

A CompositorProxy which can be used to allow other parts of Servo to communicate with this IOCompositor.

event_loop_waker: Box<dyn EventLoopWaker>

An EventLoopWaker used to wake up the main embedder event loop when the renderer needs to run.

shutdown_state: Rc<Cell<ShutdownState>>

Tracks whether we are in the process of shutting down, or have shut down and should close the compositor. This is shared with the Servo instance.

compositor_receiver: RoutedReceiver<CompositorMsg>

The port on which we receive messages.

embedder_to_constellation_sender: Sender<EmbedderToConstellationMessage>

The channel on which messages can be sent to the constellation.

webrender_external_image_id_manager: WebRenderExternalImageIdManager

The WebRenderExternalImageIdManager used to generate new ExternalImageIds.

painter_surfman_details_map: PainterSurfmanDetailsMap

A HashMap of PainterId to the Surfaman types (Device, Adapter) that are specific to a particular Painter.

busy_webgl_contexts_map: WebGLContextBusyMap

A HashMap of WebGLContextId to a usage count. This count indicates when WebRender is still rendering the context. This is used to ensure properly clean up of all Surfman Surfaces.

webgl_threads: WebGLThreads

The WebGLThreads for this renderer.

swap_chains: SwapChains<WebGLContextId, Device>

The shared SwapChains used by WebGLThreads for this renderer.

time_profiler_chan: ProfilerChan

The channel on which messages can be sent to the time profiler.

_mem_profiler_registration: ProfilerRegistration

A handle to the memory profiler which will automatically unregister when it’s dropped.

webxr_main_thread: RefCell<MainThreadRegistry>

Some XR devices want to run on the main thread.

webgpu_image_map: OnceCell<WebGpuExternalImageMap>

An map of external images shared between all WebGpuExternalImages.

Implementations

impl IOCompositor

pub fn new(state: InitialCompositorState) -> Rc<RefCell<Self>>

pub fn register_rendering_context( &mut self, rendering_context: Rc<dyn RenderingContext>, ) -> PainterId

pub(crate) fn painter<'a>(&'a self, painter_id: PainterId) -> Ref<'a, Painter>

pub(crate) fn painter_mut<'a>( &'a self, painter_id: PainterId, ) -> RefMut<'a, Painter>

pub fn painter_id(&self) -> PainterId

pub fn deinit(&mut self)

pub fn rendering_context_size( &self, painter_id: PainterId, ) -> Size2D<u32, DevicePixel>

pub fn webgl_threads(&self) -> WebGLThreads

pub fn webrender_external_image_id_manager( &self, ) -> WebRenderExternalImageIdManager

pub fn webxr_running(&self) -> bool

pub fn webxr_main_thread_registry(&self) -> Registry

pub fn webgpu_image_map(&self) -> WebGpuExternalImageMap

pub fn webviews_needing_repaint(&self) -> Vec<WebViewId>

pub fn finish_shutting_down(&self)

fn handle_browser_message(&self, msg: CompositorMsg)

fn collect_memory_report(&self, sender: ReportsChan)

fn handle_browser_message_while_shutting_down(&self, msg: CompositorMsg)

Handle messages sent to the compositor during the shutdown process. In general, the things the compositor can do in this state are limited. It’s very important to answer any synchronous messages though as other threads might be waiting on the results to finish their own shut down process. We try to do as little as possible during this time.

When that involves generating WebRender ids, our approach here is to simply generate them, but assume they will never be used, since once shutting down the compositor no longer does any WebRender frame generation.

pub fn add_webview( &self, webview: Box<dyn WebViewTrait>, viewport_details: ViewportDetails, )

pub fn show_webview(&self, webview_id: WebViewId) -> Result<(), UnknownWebView>

pub fn hide_webview(&self, webview_id: WebViewId) -> Result<(), UnknownWebView>

pub fn set_hidpi_scale_factor( &self, webview_id: WebViewId, new_scale_factor: Scale<f32, DeviceIndependentPixel, DevicePixel>, )

pub fn resize_rendering_context( &self, webview_id: WebViewId, new_size: PhysicalSize<u32>, )

pub fn set_page_zoom(&self, webview_id: WebViewId, new_zoom: f32)

pub fn page_zoom(&self, webview_id: WebViewId) -> f32

pub fn render(&self, webview_id: WebViewId)

Render the WebRender scene to the active RenderingContext.

pub fn receiver(&self) -> &RoutedReceiver<CompositorMsg>

Get the message receiver for this IOCompositor.

pub fn handle_messages(&self, messages: Vec<CompositorMsg>)

pub fn perform_updates(&self) -> bool

pub fn toggle_webrender_debug(&self, option: WebRenderDebugOption)

pub fn capture_webrender(&self, webview_id: WebViewId)

pub fn notify_input_event(&self, webview_id: WebViewId, event: InputEventAndId)

pub fn notify_scroll_event( &self, webview_id: WebViewId, scroll: Scroll, point: WebViewPoint, )

pub fn pinch_zoom( &self, webview_id: WebViewId, pinch_zoom_delta: f32, center: DevicePoint, )

pub fn device_pixels_per_page_pixel( &self, webview_id: WebViewId, ) -> Scale<f32, CSSPixel, DevicePixel>

pub(crate) fn shutdown_state(&self) -> ShutdownState

pub fn request_screenshot( &self, webview_id: WebViewId, rect: Option<WebViewRect>, callback: Box<dyn FnOnce(Result<RgbaImage, ScreenshotCaptureError>) + 'static>, )

pub fn notify_input_event_handled( &self, webview_id: WebViewId, input_event_id: InputEventId, result: InputEventResult, )