Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-17 19:35:33 +01:00
Code Issues Projects Releases Packages Wiki Activity

compositing: Use webrender_api::ExternalImageSource instead of WebRenderImageSource (#38703)

Browse source 
There is no reason to roll our own type.

Motivation: I need `ExternalImageSource::Invalid`.

Testing: Covered by existing WPT tests, but it's just refactor

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
sagudev 2025-08-15 21:39:07 +02:00 • committed by GitHub
parent 18e05d3aab
commit 85588fada0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 20 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

8
components/media/lib.rs
View file

@ -10,8 +10,8 @@ mod media_thread;
use std::sync::{Arc, Mutex};
use compositing_traits::{
WebrenderExternalImageApi, WebrenderExternalImageHandlers, WebrenderExternalImageRegistry,
WebrenderImageHandlerType, WebrenderImageSource,
ExternalImageSource, WebrenderExternalImageApi, WebrenderExternalImageHandlers,
WebrenderExternalImageRegistry, WebrenderImageHandlerType,
};
use euclid::default::Size2D;
use ipc_channel::ipc::{IpcReceiver, IpcSender, channel};
@ -214,7 +214,7 @@ impl GLPlayerExternalImages {
}
impl WebrenderExternalImageApi for GLPlayerExternalImages {
fn lock(&mut self, id: u64) -> (WebrenderImageSource, Size2D<i32>) {
fn lock(&mut self, id: u64) -> (ExternalImageSource, Size2D<i32>) {
// The GLPlayerMsgForward::Lock message inserts a fence in the
// GLPlayer command queue.
self.glplayer_channel
@ -228,7 +228,7 @@ impl WebrenderExternalImageApi for GLPlayerExternalImages {
// internal OpenGL subsystem.
//self.webrender_gl
// .wait_sync(gl_sync as gl::GLsync, 0, gl::TIMEOUT_IGNORED);
(WebrenderImageSource::TextureHandle(image_id), size)
(ExternalImageSource::NativeTexture(image_id), size)
}
fn unlock(&mut self, id: u64) {

20
components/shared/compositing/lib.rs
View file

@ -30,12 +30,13 @@ use euclid::default::Size2D as UntypedSize2D;
use ipc_channel::ipc::{self, IpcSharedMemory};
use profile_traits::mem::{OpaqueSender, ReportsChan};
use serde::{Deserialize, Serialize};
pub use webrender_api::ExternalImageSource;
use webrender_api::units::{LayoutVector2D, TexelRect};
use webrender_api::{
BuiltDisplayList, BuiltDisplayListDescriptor, ExternalImage, ExternalImageData,
ExternalImageHandler, ExternalImageId, ExternalImageSource, ExternalScrollId,
FontInstanceFlags, FontInstanceKey, FontKey, ImageData, ImageDescriptor, ImageKey,
NativeFontHandle, PipelineId as WebRenderPipelineId,
ExternalImageHandler, ExternalImageId, ExternalScrollId, FontInstanceFlags, FontInstanceKey,
FontKey, ImageData, ImageDescriptor, ImageKey, NativeFontHandle,
PipelineId as WebRenderPipelineId,
};
use crate::viewport_description::ViewportDescription;
@ -341,15 +342,10 @@ impl CrossProcessCompositorApi {
/// This trait is used to notify lock/unlock messages and get the
/// required info that WR needs.
pub trait WebrenderExternalImageApi {
fn lock(&mut self, id: u64) -> (WebrenderImageSource, UntypedSize2D<i32>);
fn lock(&mut self, id: u64) -> (ExternalImageSource, UntypedSize2D<i32>);
fn unlock(&mut self, id: u64);
}
pub enum WebrenderImageSource<'a> {
TextureHandle(u32),
Raw(&'a [u8]),
}
/// Type of Webrender External Image Handler.
pub enum WebrenderImageHandlerType {
WebGL,
@ -438,7 +434,7 @@ impl ExternalImageHandler for WebrenderExternalImageHandlers {
WebrenderImageHandlerType::WebGL => {
let (source, size) = self.webgl_handler.as_mut().unwrap().lock(key.0);
let texture_id = match source {
WebrenderImageSource::TextureHandle(b) => b,
ExternalImageSource::NativeTexture(b) => b,
_ => panic!("Wrong type"),
};
ExternalImage {
@ -449,7 +445,7 @@ impl ExternalImageHandler for WebrenderExternalImageHandlers {
WebrenderImageHandlerType::Media => {
let (source, size) = self.media_handler.as_mut().unwrap().lock(key.0);
let texture_id = match source {
WebrenderImageSource::TextureHandle(b) => b,
ExternalImageSource::NativeTexture(b) => b,
_ => panic!("Wrong type"),
};
ExternalImage {
@ -460,7 +456,7 @@ impl ExternalImageHandler for WebrenderExternalImageHandlers {
WebrenderImageHandlerType::WebGPU => {
let (source, size) = self.webgpu_handler.as_mut().unwrap().lock(key.0);
let buffer = match source {
WebrenderImageSource::Raw(b) => b,
ExternalImageSource::RawData(b) => b,
_ => panic!("Wrong type"),
};
ExternalImage {

8
components/webgl/webgl_mode/inprocess.rs
View file

@ -9,8 +9,8 @@ use std::sync::{Arc, Mutex};
use canvas_traits::webgl::{GlType, WebGLContextId, WebGLMsg, WebGLThreads, webgl_channel};
use compositing_traits::rendering_context::RenderingContext;
use compositing_traits::{
CrossProcessCompositorApi, WebrenderExternalImageApi, WebrenderExternalImageRegistry,
WebrenderImageSource,
CrossProcessCompositorApi, ExternalImageSource, WebrenderExternalImageApi,
WebrenderExternalImageRegistry,
};
use euclid::default::Size2D;
use fnv::FnvHashMap;
@ -134,10 +134,10 @@ impl WebGLExternalImages {
}
impl WebrenderExternalImageApi for WebGLExternalImages {
fn lock(&mut self, id: u64) -> (WebrenderImageSource, Size2D<i32>) {
fn lock(&mut self, id: u64) -> (ExternalImageSource, Size2D<i32>) {
let id = WebGLContextId(id);
let (texture_id, size) = self.lock_swap_chain(id).unwrap_or_default();
(WebrenderImageSource::TextureHandle(texture_id), size)
(ExternalImageSource::NativeTexture(texture_id), size)
}
fn unlock(&mut self, id: u64) {

8
components/webgpu/swapchain.rs
View file

@ -9,8 +9,8 @@ use std::sync::{Arc, Mutex};
use arrayvec::ArrayVec;
use compositing_traits::{
CrossProcessCompositorApi, SerializableImageData, WebrenderExternalImageApi,
WebrenderImageSource,
CrossProcessCompositorApi, ExternalImageSource, SerializableImageData,
WebrenderExternalImageApi,
};
use euclid::default::Size2D;
use ipc_channel::ipc::IpcSender;
@ -83,7 +83,7 @@ pub struct WGPUExternalImages {
}
impl WebrenderExternalImageApi for WGPUExternalImages {
fn lock(&mut self, id: u64) -> (WebrenderImageSource, Size2D<i32>) {
fn lock(&mut self, id: u64) -> (ExternalImageSource, Size2D<i32>) {
let id = WebGPUContextId(id);
let webgpu_contexts = self.images.lock().unwrap();
let context_data = webgpu_contexts.get(&id).unwrap();
@ -99,7 +99,7 @@ impl WebrenderExternalImageApi for WGPUExternalImages {
};
self.locked_ids.insert(id, data);
(
WebrenderImageSource::Raw(self.locked_ids.get(&id).unwrap().as_slice()),
ExternalImageSource::RawData(self.locked_ids.get(&id).unwrap().as_slice()),
size,
)
}