aboutsummaryrefslogtreecommitdiffstats
path: root/components/canvas_traits
diff options
context:
space:
mode:
Diffstat (limited to 'components/canvas_traits')
-rw-r--r--components/canvas_traits/Cargo.toml3
-rw-r--r--components/canvas_traits/canvas.rs409
-rw-r--r--components/canvas_traits/lib.rs426
-rw-r--r--components/canvas_traits/webgl.rs506
-rw-r--r--components/canvas_traits/webgl_channel/ipc.rs15
-rw-r--r--components/canvas_traits/webgl_channel/mod.rs87
-rw-r--r--components/canvas_traits/webgl_channel/mpsc.rs51
7 files changed, 418 insertions, 1079 deletions
diff --git a/components/canvas_traits/Cargo.toml b/components/canvas_traits/Cargo.toml
index 43cc74e60b1..afc23f4a2e0 100644
--- a/components/canvas_traits/Cargo.toml
+++ b/components/canvas_traits/Cargo.toml
@@ -15,8 +15,5 @@ euclid = "0.15"
heapsize = "0.4"
heapsize_derive = "0.1"
ipc-channel = "0.8"
-lazy_static = "0.2"
-offscreen_gl_context = { version = "0.11", features = ["serde"] }
serde = "1.0"
-servo_config = {path = "../config"}
webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
diff --git a/components/canvas_traits/canvas.rs b/components/canvas_traits/canvas.rs
deleted file mode 100644
index 92444d03799..00000000000
--- a/components/canvas_traits/canvas.rs
+++ /dev/null
@@ -1,409 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-use cssparser::RGBA;
-use euclid::{Transform2D, Point2D, Vector2D, Rect, Size2D};
-use ipc_channel::ipc::IpcSender;
-use std::default::Default;
-use std::str::FromStr;
-use webrender_api;
-
-#[derive(Clone, Deserialize, Serialize)]
-pub enum FillRule {
- Nonzero,
- Evenodd,
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub enum CanvasMsg {
- Canvas2d(Canvas2dMsg),
- FromLayout(FromLayoutMsg),
- FromScript(FromScriptMsg),
- Recreate(Size2D<i32>),
- Close,
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub struct CanvasImageData {
- pub image_key: webrender_api::ImageKey,
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub enum Canvas2dMsg {
- Arc(Point2D<f32>, f32, f32, f32, bool),
- ArcTo(Point2D<f32>, Point2D<f32>, f32),
- DrawImage(Vec<u8>, Size2D<f64>, Rect<f64>, Rect<f64>, bool),
- DrawImageSelf(Size2D<f64>, Rect<f64>, Rect<f64>, bool),
- DrawImageInOther(
- IpcSender<CanvasMsg>, Size2D<f64>, Rect<f64>, Rect<f64>, bool, IpcSender<()>),
- BeginPath,
- BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>),
- ClearRect(Rect<f32>),
- Clip,
- ClosePath,
- Fill,
- FillRect(Rect<f32>),
- GetImageData(Rect<i32>, Size2D<f64>, IpcSender<Vec<u8>>),
- IsPointInPath(f64, f64, FillRule, IpcSender<bool>),
- LineTo(Point2D<f32>),
- MoveTo(Point2D<f32>),
- PutImageData(Vec<u8>, Vector2D<f64>, Size2D<f64>, Rect<f64>),
- QuadraticCurveTo(Point2D<f32>, Point2D<f32>),
- Rect(Rect<f32>),
- RestoreContext,
- SaveContext,
- StrokeRect(Rect<f32>),
- Stroke,
- SetFillStyle(FillOrStrokeStyle),
- SetStrokeStyle(FillOrStrokeStyle),
- SetLineWidth(f32),
- SetLineCap(LineCapStyle),
- SetLineJoin(LineJoinStyle),
- SetMiterLimit(f32),
- SetGlobalAlpha(f32),
- SetGlobalComposition(CompositionOrBlending),
- SetTransform(Transform2D<f32>),
- SetShadowOffsetX(f64),
- SetShadowOffsetY(f64),
- SetShadowBlur(f64),
- SetShadowColor(RGBA),
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub enum FromLayoutMsg {
- SendData(IpcSender<CanvasImageData>),
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub enum FromScriptMsg {
- SendPixels(IpcSender<Option<Vec<u8>>>),
-}
-
-#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
-pub struct CanvasGradientStop {
- pub offset: f64,
- pub color: RGBA,
-}
-
-#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
-pub struct LinearGradientStyle {
- pub x0: f64,
- pub y0: f64,
- pub x1: f64,
- pub y1: f64,
- pub stops: Vec<CanvasGradientStop>
-}
-
-impl LinearGradientStyle {
- pub fn new(x0: f64, y0: f64, x1: f64, y1: f64, stops: Vec<CanvasGradientStop>)
- -> LinearGradientStyle {
- LinearGradientStyle {
- x0: x0,
- y0: y0,
- x1: x1,
- y1: y1,
- stops: stops,
- }
- }
-}
-
-#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
-pub struct RadialGradientStyle {
- pub x0: f64,
- pub y0: f64,
- pub r0: f64,
- pub x1: f64,
- pub y1: f64,
- pub r1: f64,
- pub stops: Vec<CanvasGradientStop>
-}
-
-impl RadialGradientStyle {
- pub fn new(x0: f64, y0: f64, r0: f64, x1: f64, y1: f64, r1: f64, stops: Vec<CanvasGradientStop>)
- -> RadialGradientStyle {
- RadialGradientStyle {
- x0: x0,
- y0: y0,
- r0: r0,
- x1: x1,
- y1: y1,
- r1: r1,
- stops: stops,
- }
- }
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub struct SurfaceStyle {
- pub surface_data: Vec<u8>,
- pub surface_size: Size2D<i32>,
- pub repeat_x: bool,
- pub repeat_y: bool,
-}
-
-impl SurfaceStyle {
- pub fn new(surface_data: Vec<u8>, surface_size: Size2D<i32>, repeat_x: bool, repeat_y: bool)
- -> SurfaceStyle {
- SurfaceStyle {
- surface_data: surface_data,
- surface_size: surface_size,
- repeat_x: repeat_x,
- repeat_y: repeat_y,
- }
- }
-}
-
-
-#[derive(Clone, Deserialize, Serialize)]
-pub enum FillOrStrokeStyle {
- Color(RGBA),
- LinearGradient(LinearGradientStyle),
- RadialGradient(RadialGradientStyle),
- Surface(SurfaceStyle),
-}
-
-#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
-pub enum LineCapStyle {
- Butt = 0,
- Round = 1,
- Square = 2,
-}
-
-impl FromStr for LineCapStyle {
- type Err = ();
-
- fn from_str(string: &str) -> Result<LineCapStyle, ()> {
- match string {
- "butt" => Ok(LineCapStyle::Butt),
- "round" => Ok(LineCapStyle::Round),
- "square" => Ok(LineCapStyle::Square),
- _ => Err(()),
- }
- }
-}
-
-#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
-pub enum LineJoinStyle {
- Round = 0,
- Bevel = 1,
- Miter = 2,
-}
-
-impl FromStr for LineJoinStyle {
- type Err = ();
-
- fn from_str(string: &str) -> Result<LineJoinStyle, ()> {
- match string {
- "round" => Ok(LineJoinStyle::Round),
- "bevel" => Ok(LineJoinStyle::Bevel),
- "miter" => Ok(LineJoinStyle::Miter),
- _ => Err(()),
- }
- }
-}
-
-#[derive(Copy, Clone, PartialEq, Deserialize, Serialize)]
-pub enum RepetitionStyle {
- Repeat,
- RepeatX,
- RepeatY,
- NoRepeat,
-}
-
-impl FromStr for RepetitionStyle {
- type Err = ();
-
- fn from_str(string: &str) -> Result<RepetitionStyle, ()> {
- match string {
- "repeat" => Ok(RepetitionStyle::Repeat),
- "repeat-x" => Ok(RepetitionStyle::RepeatX),
- "repeat-y" => Ok(RepetitionStyle::RepeatY),
- "no-repeat" => Ok(RepetitionStyle::NoRepeat),
- _ => Err(()),
- }
- }
-}
-
-#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
-pub enum CompositionStyle {
- SrcIn,
- SrcOut,
- SrcOver,
- SrcAtop,
- DestIn,
- DestOut,
- DestOver,
- DestAtop,
- Copy,
- Lighter,
- Xor,
-}
-
-impl FromStr for CompositionStyle {
- type Err = ();
-
- fn from_str(string: &str) -> Result<CompositionStyle, ()> {
- match string {
- "source-in" => Ok(CompositionStyle::SrcIn),
- "source-out" => Ok(CompositionStyle::SrcOut),
- "source-over" => Ok(CompositionStyle::SrcOver),
- "source-atop" => Ok(CompositionStyle::SrcAtop),
- "destination-in" => Ok(CompositionStyle::DestIn),
- "destination-out" => Ok(CompositionStyle::DestOut),
- "destination-over" => Ok(CompositionStyle::DestOver),
- "destination-atop" => Ok(CompositionStyle::DestAtop),
- "copy" => Ok(CompositionStyle::Copy),
- "lighter" => Ok(CompositionStyle::Lighter),
- "xor" => Ok(CompositionStyle::Xor),
- _ => Err(())
- }
- }
-}
-
-impl CompositionStyle {
- pub fn to_str(&self) -> &str {
- match *self {
- CompositionStyle::SrcIn => "source-in",
- CompositionStyle::SrcOut => "source-out",
- CompositionStyle::SrcOver => "source-over",
- CompositionStyle::SrcAtop => "source-atop",
- CompositionStyle::DestIn => "destination-in",
- CompositionStyle::DestOut => "destination-out",
- CompositionStyle::DestOver => "destination-over",
- CompositionStyle::DestAtop => "destination-atop",
- CompositionStyle::Copy => "copy",
- CompositionStyle::Lighter => "lighter",
- CompositionStyle::Xor => "xor",
- }
- }
-}
-
-#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
-pub enum BlendingStyle {
- Multiply,
- Screen,
- Overlay,
- Darken,
- Lighten,
- ColorDodge,
- ColorBurn,
- HardLight,
- SoftLight,
- Difference,
- Exclusion,
- Hue,
- Saturation,
- Color,
- Luminosity,
-}
-
-impl FromStr for BlendingStyle {
- type Err = ();
-
- fn from_str(string: &str) -> Result<BlendingStyle, ()> {
- match string {
- "multiply" => Ok(BlendingStyle::Multiply),
- "screen" => Ok(BlendingStyle::Screen),
- "overlay" => Ok(BlendingStyle::Overlay),
- "darken" => Ok(BlendingStyle::Darken),
- "lighten" => Ok(BlendingStyle::Lighten),
- "color-dodge" => Ok(BlendingStyle::ColorDodge),
- "color-burn" => Ok(BlendingStyle::ColorBurn),
- "hard-light" => Ok(BlendingStyle::HardLight),
- "soft-light" => Ok(BlendingStyle::SoftLight),
- "difference" => Ok(BlendingStyle::Difference),
- "exclusion" => Ok(BlendingStyle::Exclusion),
- "hue" => Ok(BlendingStyle::Hue),
- "saturation" => Ok(BlendingStyle::Saturation),
- "color" => Ok(BlendingStyle::Color),
- "luminosity" => Ok(BlendingStyle::Luminosity),
- _ => Err(())
- }
- }
-}
-
-impl BlendingStyle {
- pub fn to_str(&self) -> &str {
- match *self {
- BlendingStyle::Multiply => "multiply",
- BlendingStyle::Screen => "screen",
- BlendingStyle::Overlay => "overlay",
- BlendingStyle::Darken => "darken",
- BlendingStyle::Lighten => "lighten",
- BlendingStyle::ColorDodge => "color-dodge",
- BlendingStyle::ColorBurn => "color-burn",
- BlendingStyle::HardLight => "hard-light",
- BlendingStyle::SoftLight => "soft-light",
- BlendingStyle::Difference => "difference",
- BlendingStyle::Exclusion => "exclusion",
- BlendingStyle::Hue => "hue",
- BlendingStyle::Saturation => "saturation",
- BlendingStyle::Color => "color",
- BlendingStyle::Luminosity => "luminosity",
- }
- }
-}
-
-#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
-pub enum CompositionOrBlending {
- Composition(CompositionStyle),
- Blending(BlendingStyle),
-}
-
-impl Default for CompositionOrBlending {
- fn default() -> CompositionOrBlending {
- CompositionOrBlending::Composition(CompositionStyle::SrcOver)
- }
-}
-
-impl FromStr for CompositionOrBlending {
- type Err = ();
-
- fn from_str(string: &str) -> Result<CompositionOrBlending, ()> {
- if let Ok(op) = CompositionStyle::from_str(string) {
- return Ok(CompositionOrBlending::Composition(op));
- }
-
- if let Ok(op) = BlendingStyle::from_str(string) {
- return Ok(CompositionOrBlending::Blending(op));
- }
-
- Err(())
- }
-}
-
-// TODO(pcwalton): Speed up with SIMD, or better yet, find some way to not do this.
-pub fn byte_swap(data: &mut [u8]) {
- let length = data.len();
- // FIXME(rust #27741): Range::step_by is not stable yet as of this writing.
- let mut i = 0;
- while i < length {
- let r = data[i + 2];
- data[i + 2] = data[i + 0];
- data[i + 0] = r;
- i += 4;
- }
-}
-
-pub fn multiply_u8_pixel(a: u8, b: u8) -> u8 {
- return (a as u32 * b as u32 / 255) as u8;
-}
-
-pub fn byte_swap_and_premultiply(data: &mut [u8]) {
- let length = data.len();
-
- let mut i = 0;
- while i < length {
- let r = data[i + 2];
- let g = data[i + 1];
- let b = data[i + 0];
- let a = data[i + 3];
-
- data[i + 0] = multiply_u8_pixel(r, a);
- data[i + 1] = multiply_u8_pixel(g, a);
- data[i + 2] = multiply_u8_pixel(b, a);
-
- i += 4;
- }
-}
diff --git a/components/canvas_traits/lib.rs b/components/canvas_traits/lib.rs
index 7830d669e3e..1f6d9eda087 100644
--- a/components/canvas_traits/lib.rs
+++ b/components/canvas_traits/lib.rs
@@ -4,22 +4,432 @@
#![crate_name = "canvas_traits"]
#![crate_type = "rlib"]
-#![feature(nonzero)]
#![deny(unsafe_code)]
-extern crate core;
extern crate cssparser;
extern crate euclid;
extern crate heapsize;
#[macro_use] extern crate heapsize_derive;
extern crate ipc_channel;
-#[macro_use] extern crate lazy_static;
-extern crate offscreen_gl_context;
#[macro_use] extern crate serde;
-extern crate servo_config;
extern crate webrender_api;
-pub mod canvas;
-pub mod webgl;
-mod webgl_channel;
+use cssparser::RGBA;
+use euclid::{Transform2D, Point2D, Vector2D, Rect, Size2D};
+use ipc_channel::ipc::IpcSender;
+use std::default::Default;
+use std::str::FromStr;
+use webrender_api::{WebGLCommand, WebGLContextId, VRCompositorCommand};
+
+#[derive(Clone, Deserialize, Serialize)]
+pub enum FillRule {
+ Nonzero,
+ Evenodd,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub enum CanvasMsg {
+ Canvas2d(Canvas2dMsg),
+ Common(CanvasCommonMsg),
+ FromLayout(FromLayoutMsg),
+ FromScript(FromScriptMsg),
+ WebGL(WebGLCommand),
+ WebVR(VRCompositorCommand)
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub enum CanvasCommonMsg {
+ Close,
+ Recreate(Size2D<i32>),
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub enum CanvasData {
+ Image(CanvasImageData),
+ WebGL(WebGLContextId),
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub struct CanvasImageData {
+ pub image_key: webrender_api::ImageKey,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub enum FromLayoutMsg {
+ SendData(IpcSender<CanvasData>),
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub enum FromScriptMsg {
+ SendPixels(IpcSender<Option<Vec<u8>>>),
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub enum Canvas2dMsg {
+ Arc(Point2D<f32>, f32, f32, f32, bool),
+ ArcTo(Point2D<f32>, Point2D<f32>, f32),
+ DrawImage(Vec<u8>, Size2D<f64>, Rect<f64>, Rect<f64>, bool),
+ DrawImageSelf(Size2D<f64>, Rect<f64>, Rect<f64>, bool),
+ DrawImageInOther(
+ IpcSender<CanvasMsg>, Size2D<f64>, Rect<f64>, Rect<f64>, bool, IpcSender<()>),
+ BeginPath,
+ BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>),
+ ClearRect(Rect<f32>),
+ Clip,
+ ClosePath,
+ Fill,
+ FillRect(Rect<f32>),
+ GetImageData(Rect<i32>, Size2D<f64>, IpcSender<Vec<u8>>),
+ IsPointInPath(f64, f64, FillRule, IpcSender<bool>),
+ LineTo(Point2D<f32>),
+ MoveTo(Point2D<f32>),
+ PutImageData(Vec<u8>, Vector2D<f64>, Size2D<f64>, Rect<f64>),
+ QuadraticCurveTo(Point2D<f32>, Point2D<f32>),
+ Rect(Rect<f32>),
+ RestoreContext,
+ SaveContext,
+ StrokeRect(Rect<f32>),
+ Stroke,
+ SetFillStyle(FillOrStrokeStyle),
+ SetStrokeStyle(FillOrStrokeStyle),
+ SetLineWidth(f32),
+ SetLineCap(LineCapStyle),
+ SetLineJoin(LineJoinStyle),
+ SetMiterLimit(f32),
+ SetGlobalAlpha(f32),
+ SetGlobalComposition(CompositionOrBlending),
+ SetTransform(Transform2D<f32>),
+ SetShadowOffsetX(f64),
+ SetShadowOffsetY(f64),
+ SetShadowBlur(f64),
+ SetShadowColor(RGBA),
+}
+
+#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
+pub struct CanvasGradientStop {
+ pub offset: f64,
+ pub color: RGBA,
+}
+
+#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
+pub struct LinearGradientStyle {
+ pub x0: f64,
+ pub y0: f64,
+ pub x1: f64,
+ pub y1: f64,
+ pub stops: Vec<CanvasGradientStop>
+}
+
+impl LinearGradientStyle {
+ pub fn new(x0: f64, y0: f64, x1: f64, y1: f64, stops: Vec<CanvasGradientStop>)
+ -> LinearGradientStyle {
+ LinearGradientStyle {
+ x0: x0,
+ y0: y0,
+ x1: x1,
+ y1: y1,
+ stops: stops,
+ }
+ }
+}
+
+#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
+pub struct RadialGradientStyle {
+ pub x0: f64,
+ pub y0: f64,
+ pub r0: f64,
+ pub x1: f64,
+ pub y1: f64,
+ pub r1: f64,
+ pub stops: Vec<CanvasGradientStop>
+}
+
+impl RadialGradientStyle {
+ pub fn new(x0: f64, y0: f64, r0: f64, x1: f64, y1: f64, r1: f64, stops: Vec<CanvasGradientStop>)
+ -> RadialGradientStyle {
+ RadialGradientStyle {
+ x0: x0,
+ y0: y0,
+ r0: r0,
+ x1: x1,
+ y1: y1,
+ r1: r1,
+ stops: stops,
+ }
+ }
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub struct SurfaceStyle {
+ pub surface_data: Vec<u8>,
+ pub surface_size: Size2D<i32>,
+ pub repeat_x: bool,
+ pub repeat_y: bool,
+}
+
+impl SurfaceStyle {
+ pub fn new(surface_data: Vec<u8>, surface_size: Size2D<i32>, repeat_x: bool, repeat_y: bool)
+ -> SurfaceStyle {
+ SurfaceStyle {
+ surface_data: surface_data,
+ surface_size: surface_size,
+ repeat_x: repeat_x,
+ repeat_y: repeat_y,
+ }
+ }
+}
+
+
+#[derive(Clone, Deserialize, Serialize)]
+pub enum FillOrStrokeStyle {
+ Color(RGBA),
+ LinearGradient(LinearGradientStyle),
+ RadialGradient(RadialGradientStyle),
+ Surface(SurfaceStyle),
+}
+
+#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
+pub enum LineCapStyle {
+ Butt = 0,
+ Round = 1,
+ Square = 2,
+}
+
+impl FromStr for LineCapStyle {
+ type Err = ();
+
+ fn from_str(string: &str) -> Result<LineCapStyle, ()> {
+ match string {
+ "butt" => Ok(LineCapStyle::Butt),
+ "round" => Ok(LineCapStyle::Round),
+ "square" => Ok(LineCapStyle::Square),
+ _ => Err(()),
+ }
+ }
+}
+
+#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
+pub enum LineJoinStyle {
+ Round = 0,
+ Bevel = 1,
+ Miter = 2,
+}
+
+impl FromStr for LineJoinStyle {
+ type Err = ();
+
+ fn from_str(string: &str) -> Result<LineJoinStyle, ()> {
+ match string {
+ "round" => Ok(LineJoinStyle::Round),
+ "bevel" => Ok(LineJoinStyle::Bevel),
+ "miter" => Ok(LineJoinStyle::Miter),
+ _ => Err(()),
+ }
+ }
+}
+
+#[derive(Copy, Clone, PartialEq, Deserialize, Serialize)]
+pub enum RepetitionStyle {
+ Repeat,
+ RepeatX,
+ RepeatY,
+ NoRepeat,
+}
+
+impl FromStr for RepetitionStyle {
+ type Err = ();
+
+ fn from_str(string: &str) -> Result<RepetitionStyle, ()> {
+ match string {
+ "repeat" => Ok(RepetitionStyle::Repeat),
+ "repeat-x" => Ok(RepetitionStyle::RepeatX),
+ "repeat-y" => Ok(RepetitionStyle::RepeatY),
+ "no-repeat" => Ok(RepetitionStyle::NoRepeat),
+ _ => Err(()),
+ }
+ }
+}
+
+#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
+pub enum CompositionStyle {
+ SrcIn,
+ SrcOut,
+ SrcOver,
+ SrcAtop,
+ DestIn,
+ DestOut,
+ DestOver,
+ DestAtop,
+ Copy,
+ Lighter,
+ Xor,
+}
+
+impl FromStr for CompositionStyle {
+ type Err = ();
+
+ fn from_str(string: &str) -> Result<CompositionStyle, ()> {
+ match string {
+ "source-in" => Ok(CompositionStyle::SrcIn),
+ "source-out" => Ok(CompositionStyle::SrcOut),
+ "source-over" => Ok(CompositionStyle::SrcOver),
+ "source-atop" => Ok(CompositionStyle::SrcAtop),
+ "destination-in" => Ok(CompositionStyle::DestIn),
+ "destination-out" => Ok(CompositionStyle::DestOut),
+ "destination-over" => Ok(CompositionStyle::DestOver),
+ "destination-atop" => Ok(CompositionStyle::DestAtop),
+ "copy" => Ok(CompositionStyle::Copy),
+ "lighter" => Ok(CompositionStyle::Lighter),
+ "xor" => Ok(CompositionStyle::Xor),
+ _ => Err(())
+ }
+ }
+}
+
+impl CompositionStyle {
+ pub fn to_str(&self) -> &str {
+ match *self {
+ CompositionStyle::SrcIn => "source-in",
+ CompositionStyle::SrcOut => "source-out",
+ CompositionStyle::SrcOver => "source-over",
+ CompositionStyle::SrcAtop => "source-atop",
+ CompositionStyle::DestIn => "destination-in",
+ CompositionStyle::DestOut => "destination-out",
+ CompositionStyle::DestOver => "destination-over",
+ CompositionStyle::DestAtop => "destination-atop",
+ CompositionStyle::Copy => "copy",
+ CompositionStyle::Lighter => "lighter",
+ CompositionStyle::Xor => "xor",
+ }
+ }
+}
+
+#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
+pub enum BlendingStyle {
+ Multiply,
+ Screen,
+ Overlay,
+ Darken,
+ Lighten,
+ ColorDodge,
+ ColorBurn,
+ HardLight,
+ SoftLight,
+ Difference,
+ Exclusion,
+ Hue,
+ Saturation,
+ Color,
+ Luminosity,
+}
+
+impl FromStr for BlendingStyle {
+ type Err = ();
+
+ fn from_str(string: &str) -> Result<BlendingStyle, ()> {
+ match string {
+ "multiply" => Ok(BlendingStyle::Multiply),
+ "screen" => Ok(BlendingStyle::Screen),
+ "overlay" => Ok(BlendingStyle::Overlay),
+ "darken" => Ok(BlendingStyle::Darken),
+ "lighten" => Ok(BlendingStyle::Lighten),
+ "color-dodge" => Ok(BlendingStyle::ColorDodge),
+ "color-burn" => Ok(BlendingStyle::ColorBurn),
+ "hard-light" => Ok(BlendingStyle::HardLight),
+ "soft-light" => Ok(BlendingStyle::SoftLight),
+ "difference" => Ok(BlendingStyle::Difference),
+ "exclusion" => Ok(BlendingStyle::Exclusion),
+ "hue" => Ok(BlendingStyle::Hue),
+ "saturation" => Ok(BlendingStyle::Saturation),
+ "color" => Ok(BlendingStyle::Color),
+ "luminosity" => Ok(BlendingStyle::Luminosity),
+ _ => Err(())
+ }
+ }
+}
+
+impl BlendingStyle {
+ pub fn to_str(&self) -> &str {
+ match *self {
+ BlendingStyle::Multiply => "multiply",
+ BlendingStyle::Screen => "screen",
+ BlendingStyle::Overlay => "overlay",
+ BlendingStyle::Darken => "darken",
+ BlendingStyle::Lighten => "lighten",
+ BlendingStyle::ColorDodge => "color-dodge",
+ BlendingStyle::ColorBurn => "color-burn",
+ BlendingStyle::HardLight => "hard-light",
+ BlendingStyle::SoftLight => "soft-light",
+ BlendingStyle::Difference => "difference",
+ BlendingStyle::Exclusion => "exclusion",
+ BlendingStyle::Hue => "hue",
+ BlendingStyle::Saturation => "saturation",
+ BlendingStyle::Color => "color",
+ BlendingStyle::Luminosity => "luminosity",
+ }
+ }
+}
+
+#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
+pub enum CompositionOrBlending {
+ Composition(CompositionStyle),
+ Blending(BlendingStyle),
+}
+
+impl Default for CompositionOrBlending {
+ fn default() -> CompositionOrBlending {
+ CompositionOrBlending::Composition(CompositionStyle::SrcOver)
+ }
+}
+
+impl FromStr for CompositionOrBlending {
+ type Err = ();
+
+ fn from_str(string: &str) -> Result<CompositionOrBlending, ()> {
+ if let Ok(op) = CompositionStyle::from_str(string) {
+ return Ok(CompositionOrBlending::Composition(op));
+ }
+
+ if let Ok(op) = BlendingStyle::from_str(string) {
+ return Ok(CompositionOrBlending::Blending(op));
+ }
+
+ Err(())
+ }
+}
+
+// TODO(pcwalton): Speed up with SIMD, or better yet, find some way to not do this.
+pub fn byte_swap(data: &mut [u8]) {
+ let length = data.len();
+ // FIXME(rust #27741): Range::step_by is not stable yet as of this writing.
+ let mut i = 0;
+ while i < length {
+ let r = data[i + 2];
+ data[i + 2] = data[i + 0];
+ data[i + 0] = r;
+ i += 4;
+ }
+}
+
+pub fn multiply_u8_pixel(a: u8, b: u8) -> u8 {
+ return (a as u32 * b as u32 / 255) as u8;
+}
+
+pub fn byte_swap_and_premultiply(data: &mut [u8]) {
+ let length = data.len();
+
+ let mut i = 0;
+ while i < length {
+ let r = data[i + 2];
+ let g = data[i + 1];
+ let b = data[i + 0];
+ let a = data[i + 3];
+
+ data[i + 0] = multiply_u8_pixel(r, a);
+ data[i + 1] = multiply_u8_pixel(g, a);
+ data[i + 2] = multiply_u8_pixel(b, a);
+
+ i += 4;
+ }
+}
diff --git a/components/canvas_traits/webgl.rs b/components/canvas_traits/webgl.rs
deleted file mode 100644
index 1bd6eb0649b..00000000000
--- a/components/canvas_traits/webgl.rs
+++ /dev/null
@@ -1,506 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-use core::nonzero::NonZero;
-use euclid::Size2D;
-use offscreen_gl_context::{GLContextAttributes, GLLimits};
-use std::fmt;
-use webrender_api;
-
-/// Sender type used in WebGLCommands.
-pub use ::webgl_channel::WebGLSender;
-/// Receiver type used in WebGLCommands.
-pub use ::webgl_channel::WebGLReceiver;
-/// Result type for send()/recv() calls in in WebGLCommands.
-pub use ::webgl_channel::WebGLSendResult;
-/// Helper function that creates a WebGL channel (WebGLSender, WebGLReceiver) to be used in WebGLCommands.
-pub use ::webgl_channel::webgl_channel;
-/// Entry point type used in a Script Pipeline to get the WebGLChan to be used in that thread.
-pub use ::webgl_channel::WebGLPipeline;
-/// Entry point channel type used for sending WebGLMsg messages to the WebGL renderer.
-pub use ::webgl_channel::WebGLChan;
-
-/// WebGL Message API
-#[derive(Clone, Deserialize, Serialize)]
-pub enum WebGLMsg {
- /// Creates a new WebGLContext.
- CreateContext(Size2D<i32>, GLContextAttributes, WebGLSender<Result<(WebGLCreateContextResult), String>>),
- /// Resizes a WebGLContext.
- ResizeContext(WebGLContextId, Size2D<i32>, WebGLSender<Result<(), String>>),
- /// Drops a WebGLContext.
- RemoveContext(WebGLContextId),
- /// Runs a WebGLCommand in a specific WebGLContext.
- WebGLCommand(WebGLContextId, WebGLCommand),
- /// Runs a WebVRCommand in a specific WebGLContext.
- WebVRCommand(WebGLContextId, WebVRCommand),
- /// Locks a specific WebGLContext. Lock messages are used for a correct synchronization
- /// with WebRender external image API.
- /// WR locks a external texture when it wants to use the shared texture contents.
- /// The WR client should not change the shared texture content until the Unlock call.
- /// Currently OpenGL Sync Objects are used to implement the synchronization mechanism.
- Lock(WebGLContextId, WebGLSender<(u32, Size2D<i32>)>),
- /// Unlocks a specific WebGLContext. Unlock messages are used for a correct synchronization
- /// with WebRender external image API.
- /// The WR unlocks a context when it finished reading the shared texture contents.
- /// Unlock messages are always sent after a Lock message.
- Unlock(WebGLContextId),
- /// Creates or updates the image keys required for WebRender.
- UpdateWebRenderImage(WebGLContextId, WebGLSender<webrender_api::ImageKey>),
- /// Frees all resources and closes the thread.
- Exit,
-}
-
-/// Contains the WebGLCommand sender and information about a WebGLContext
-#[derive(Clone, Deserialize, Serialize)]
-pub struct WebGLCreateContextResult {
- /// Sender instance to send commands to the specific WebGLContext
- pub sender: WebGLMsgSender,
- /// Information about the internal GL Context.
- pub limits: GLLimits,
- /// How the WebGLContext is shared with WebRender.
- pub share_mode: WebGLContextShareMode,
-}
-
-#[derive(Clone, Copy, Deserialize, HeapSizeOf, Serialize)]
-pub enum WebGLContextShareMode {
- /// Fast: a shared texture_id is used in WebRender.
- SharedTexture,
- /// Slow: glReadPixels is used to send pixels to WebRender each frame.
- Readback,
-}
-
-/// Helper struct to send WebGLCommands to a specific WebGLContext.
-#[derive(Clone, Deserialize, HeapSizeOf, Serialize)]
-pub struct WebGLMsgSender {
- ctx_id: WebGLContextId,
- #[ignore_heap_size_of = "channels are hard"]
- sender: WebGLChan,
-}
-
-impl WebGLMsgSender {
- pub fn new(id: WebGLContextId, sender: WebGLChan) -> Self {
- WebGLMsgSender {
- ctx_id: id,
- sender: sender,
- }
- }
-
- /// Send a WebGLCommand message
- #[inline]
- pub fn send(&self, command: WebGLCommand) -> WebGLSendResult {
- self.sender.send(WebGLMsg::WebGLCommand(self.ctx_id, command))
- }
-
- /// Send a WebVRCommand message
- #[inline]
- pub fn send_vr(&self, command: WebVRCommand) -> WebGLSendResult {
- self.sender.send(WebGLMsg::WebVRCommand(self.ctx_id, command))
- }
-
- /// Send a resize message
- #[inline]
- pub fn send_resize(&self,
- size: Size2D<i32>,
- sender: WebGLSender<Result<(), String>>)
- -> WebGLSendResult {
- self.sender.send(WebGLMsg::ResizeContext(self.ctx_id, size, sender))
- }
-
- #[inline]
- pub fn send_remove(&self) -> WebGLSendResult {
- self.sender.send(WebGLMsg::RemoveContext(self.ctx_id))
- }
-
- #[inline]
- pub fn send_update_wr_image(&self, sender: WebGLSender<webrender_api::ImageKey>) -> WebGLSendResult {
- self.sender.send(WebGLMsg::UpdateWebRenderImage(self.ctx_id, sender))
- }
-}
-
-/// WebGL Commands for a specific WebGLContext
-#[derive(Clone, Deserialize, Serialize)]
-pub enum WebGLCommand {
- GetContextAttributes(WebGLSender<GLContextAttributes>),
- ActiveTexture(u32),
- BlendColor(f32, f32, f32, f32),
- BlendEquation(u32),
- BlendEquationSeparate(u32, u32),
- BlendFunc(u32, u32),
- BlendFuncSeparate(u32, u32, u32, u32),
- AttachShader(WebGLProgramId, WebGLShaderId),
- DetachShader(WebGLProgramId, WebGLShaderId),
- BindAttribLocation(WebGLProgramId, u32, String),
- BufferData(u32, Vec<u8>, u32),
- BufferSubData(u32, isize, Vec<u8>),
- Clear(u32),
- ClearColor(f32, f32, f32, f32),
- ClearDepth(f64),
- ClearStencil(i32),
- ColorMask(bool, bool, bool, bool),
- CullFace(u32),
- FrontFace(u32),
- DepthFunc(u32),
- DepthMask(bool),
- DepthRange(f64, f64),
- Enable(u32),
- Disable(u32),
- CompileShader(WebGLShaderId, String),
- CopyTexImage2D(u32, i32, u32, i32, i32, i32, i32, i32),
- CopyTexSubImage2D(u32, i32, i32, i32, i32, i32, i32, i32),
- CreateBuffer(WebGLSender<Option<WebGLBufferId>>),
- CreateFramebuffer(WebGLSender<Option<WebGLFramebufferId>>),
- CreateRenderbuffer(WebGLSender<Option<WebGLRenderbufferId>>),
- CreateTexture(WebGLSender<Option<WebGLTextureId>>),
- CreateProgram(WebGLSender<Option<WebGLProgramId>>),
- CreateShader(u32, WebGLSender<Option<WebGLShaderId>>),
- DeleteBuffer(WebGLBufferId),
- DeleteFramebuffer(WebGLFramebufferId),
- DeleteRenderbuffer(WebGLRenderbufferId),
- DeleteTexture(WebGLTextureId),
- DeleteProgram(WebGLProgramId),
- DeleteShader(WebGLShaderId),
- BindBuffer(u32, Option<WebGLBufferId>),
- BindFramebuffer(u32, WebGLFramebufferBindingRequest),
- BindRenderbuffer(u32, Option<WebGLRenderbufferId>),
- BindTexture(u32, Option<WebGLTextureId>),
- DisableVertexAttribArray(u32),
- DrawArrays(u32, i32, i32),
- DrawElements(u32, i32, u32, i64),
- EnableVertexAttribArray(u32),
- FramebufferRenderbuffer(u32, u32, u32, Option<WebGLRenderbufferId>),
- FramebufferTexture2D(u32, u32, u32, Option<WebGLTextureId>, i32),
- GetBufferParameter(u32, u32, WebGLSender<WebGLResult<WebGLParameter>>),
- GetExtensions(WebGLSender<String>),
- GetParameter(u32, WebGLSender<WebGLResult<WebGLParameter>>),
- GetProgramParameter(WebGLProgramId, u32, WebGLSender<WebGLResult<WebGLParameter>>),
- GetShaderParameter(WebGLShaderId, u32, WebGLSender<WebGLResult<WebGLParameter>>),
- GetShaderPrecisionFormat(u32, u32, WebGLSender<WebGLResult<(i32, i32, i32)>>),
- GetActiveAttrib(WebGLProgramId, u32, WebGLSender<WebGLResult<(i32, u32, String)>>),
- GetActiveUniform(WebGLProgramId, u32, WebGLSender<WebGLResult<(i32, u32, String)>>),
- GetAttribLocation(WebGLProgramId, String, WebGLSender<Option<i32>>),
- GetUniformLocation(WebGLProgramId, String, WebGLSender<Option<i32>>),
- GetVertexAttrib(u32, u32, WebGLSender<WebGLResult<WebGLParameter>>),
- GetVertexAttribOffset(u32, u32, WebGLSender<WebGLResult<isize>>),
- GetShaderInfoLog(WebGLShaderId, WebGLSender<String>),
- GetProgramInfoLog(WebGLProgramId, WebGLSender<String>),
- PolygonOffset(f32, f32),
- RenderbufferStorage(u32, u32, i32, i32),
- ReadPixels(i32, i32, i32, i32, u32, u32, WebGLSender<Vec<u8>>),
- SampleCoverage(f32, bool),
- Scissor(i32, i32, i32, i32),
- StencilFunc(u32, i32, u32),
- StencilFuncSeparate(u32, u32, i32, u32),
- StencilMask(u32),
- StencilMaskSeparate(u32, u32),
- StencilOp(u32, u32, u32),
- StencilOpSeparate(u32, u32, u32, u32),
- Hint(u32, u32),
- IsEnabled(u32, WebGLSender<bool>),
- LineWidth(f32),
- PixelStorei(u32, i32),
- LinkProgram(WebGLProgramId),
- Uniform1f(i32, f32),
- Uniform1fv(i32, Vec<f32>),
- Uniform1i(i32, i32),
- Uniform1iv(i32, Vec<i32>),
- Uniform2f(i32, f32, f32),
- Uniform2fv(i32, Vec<f32>),
- Uniform2i(i32, i32, i32),
- Uniform2iv(i32, Vec<i32>),
- Uniform3f(i32, f32, f32, f32),
- Uniform3fv(i32, Vec<f32>),
- Uniform3i(i32, i32, i32, i32),
- Uniform3iv(i32, Vec<i32>),
- Uniform4f(i32, f32, f32, f32, f32),
- Uniform4fv(i32, Vec<f32>),
- Uniform4i(i32, i32, i32, i32, i32),
- Uniform4iv(i32, Vec<i32>),
- UniformMatrix2fv(i32, bool, Vec<f32>),
- UniformMatrix3fv(i32, bool, Vec<f32>),
- UniformMatrix4fv(i32, bool, Vec<f32>),
- UseProgram(WebGLProgramId),
- ValidateProgram(WebGLProgramId),
- VertexAttrib(u32, f32, f32, f32, f32),
- VertexAttribPointer(u32, i32, u32, bool, i32, u32),
- VertexAttribPointer2f(u32, i32, bool, i32, u32),
- Viewport(i32, i32, i32, i32),
- TexImage2D(u32, i32, i32, i32, i32, u32, u32, Vec<u8>),
- TexParameteri(u32, u32, i32),
- TexParameterf(u32, u32, f32),
- TexSubImage2D(u32, i32, i32, i32, i32, i32, u32, u32, Vec<u8>),
- DrawingBufferWidth(WebGLSender<i32>),
- DrawingBufferHeight(WebGLSender<i32>),
- Finish(WebGLSender<()>),
- Flush,
- GenerateMipmap(u32),
- CreateVertexArray(WebGLSender<Option<WebGLVertexArrayId>>),
- DeleteVertexArray(WebGLVertexArrayId),
- BindVertexArray(Option<WebGLVertexArrayId>),
-}
-
-macro_rules! define_resource_id_struct {
- ($name:ident) => {
- #[derive(Clone, Copy, Eq, Hash, PartialEq)]
- pub struct $name(NonZero<u32>);
-
- impl $name {
- #[allow(unsafe_code)]
- #[inline]
- pub unsafe fn new(id: u32) -> Self {
- $name(NonZero::new_unchecked(id))
- }
-
- #[inline]
- pub fn get(self) -> u32 {
- self.0.get()
- }
- }
-
- };
-}
-
-macro_rules! define_resource_id {
- ($name:ident) => {
- define_resource_id_struct!($name);
-
- #[allow(unsafe_code)]
- impl<'de> ::serde::Deserialize<'de> for $name {
- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where D: ::serde::Deserializer<'de>
- {
- let id = try!(u32::deserialize(deserializer));
- if id == 0 {
- Err(::serde::de::Error::custom("expected a non-zero value"))
- } else {
- Ok(unsafe { $name::new(id) })
- }
- }
- }
-
- impl ::serde::Serialize for $name {
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where S: ::serde::Serializer
- {
- self.get().serialize(serializer)
- }
- }
-
- impl ::std::fmt::Debug for $name {
- fn fmt(&self, fmt: &mut ::std::fmt::Formatter)
- -> Result<(), ::std::fmt::Error> {
- fmt.debug_tuple(stringify!($name))
- .field(&self.get())
- .finish()
- }
- }
-
- impl ::std::fmt::Display for $name {
- fn fmt(&self, fmt: &mut ::std::fmt::Formatter)
- -> Result<(), ::std::fmt::Error> {
- write!(fmt, "{}", self.get())
- }
- }
-
- impl ::heapsize::HeapSizeOf for $name {
- fn heap_size_of_children(&self) -> usize { 0 }
- }
- }
-}
-
-define_resource_id!(WebGLBufferId);
-define_resource_id!(WebGLFramebufferId);
-define_resource_id!(WebGLRenderbufferId);
-define_resource_id!(WebGLTextureId);
-define_resource_id!(WebGLProgramId);
-define_resource_id!(WebGLShaderId);
-define_resource_id!(WebGLVertexArrayId);
-
-#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
-pub struct WebGLContextId(pub usize);
-
-impl ::heapsize::HeapSizeOf for WebGLContextId {
- fn heap_size_of_children(&self) -> usize { 0 }
-}
-
-#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
-pub enum WebGLError {
- InvalidEnum,
- InvalidFramebufferOperation,
- InvalidOperation,
- InvalidValue,
- OutOfMemory,
- ContextLost,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub enum WebGLFramebufferBindingRequest {
- Explicit(WebGLFramebufferId),
- Default,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub enum WebGLParameter {
- Int(i32),
- Bool(bool),
- String(String),
- Float(f32),
- FloatArray(Vec<f32>),
- Invalid,
-}
-
-pub type WebGLResult<T> = Result<T, WebGLError>;
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub enum WebGLShaderParameter {
- Int(i32),
- Bool(bool),
- Invalid,
-}
-
-pub type WebVRDeviceId = u32;
-
-// WebVR commands that must be called in the WebGL render thread.
-#[derive(Clone, Deserialize, Serialize)]
-pub enum WebVRCommand {
- /// Start presenting to a VR device.
- Create(WebVRDeviceId),
- /// Synchronize the pose information to be used in the frame.
- SyncPoses(WebVRDeviceId, f64, f64, WebGLSender<Result<Vec<u8>, ()>>),
- /// Submit the frame to a VR device using the specified texture coordinates.
- SubmitFrame(WebVRDeviceId, [f32; 4], [f32; 4]),
- /// Stop presenting to a VR device
- Release(WebVRDeviceId)
-}
-
-// Trait object that handles WebVR commands.
-// Receives the texture id and size associated to the WebGLContext.
-pub trait WebVRRenderHandler: Send {
- fn handle(&mut self, command: WebVRCommand, texture: Option<(u32, Size2D<i32>)>);
-}
-
-impl fmt::Debug for WebGLCommand {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- use self::WebGLCommand::*;
- let name = match *self {
- GetContextAttributes(..) => "GetContextAttributes",
- ActiveTexture(..) => "ActiveTexture",
- BlendColor(..) => "BlendColor",
- BlendEquation(..) => "BlendEquation",
- BlendEquationSeparate(..) => "BlendEquationSeparate",
- BlendFunc(..) => "BlendFunc",
- BlendFuncSeparate(..) => "BlendFuncSeparate",
- AttachShader(..) => "AttachShader",
- DetachShader(..) => "DetachShader",
- BindAttribLocation(..) => "BindAttribLocation",
- BufferData(..) => "BufferData",
- BufferSubData(..) => "BufferSubData",
- Clear(..) => "Clear",
- ClearColor(..) => "ClearColor",
- ClearDepth(..) => "ClearDepth",
- ClearStencil(..) => "ClearStencil",
- ColorMask(..) => "ColorMask",
- CopyTexImage2D(..) => "CopyTexImage2D",
- CopyTexSubImage2D(..) => "CopyTexSubImage2D",
- CullFace(..) => "CullFace",
- FrontFace(..) => "FrontFace",
- DepthFunc(..) => "DepthFunc",
- DepthMask(..) => "DepthMask",
- DepthRange(..) => "DepthRange",
- Enable(..) => "Enable",
- Disable(..) => "Disable",
- CompileShader(..) => "CompileShader",
- CreateBuffer(..) => "CreateBuffer",
- CreateFramebuffer(..) => "CreateFramebuffer",
- CreateRenderbuffer(..) => "CreateRenderbuffer",
- CreateTexture(..) => "CreateTexture",
- CreateProgram(..) => "CreateProgram",
- CreateShader(..) => "CreateShader",
- DeleteBuffer(..) => "DeleteBuffer",
- DeleteFramebuffer(..) => "DeleteFramebuffer",
- DeleteRenderbuffer(..) => "DeleteRenderBuffer",
- DeleteTexture(..) => "DeleteTexture",
- DeleteProgram(..) => "DeleteProgram",
- DeleteShader(..) => "DeleteShader",
- BindBuffer(..) => "BindBuffer",
- BindFramebuffer(..) => "BindFramebuffer",
- BindRenderbuffer(..) => "BindRenderbuffer",
- BindTexture(..) => "BindTexture",
- DisableVertexAttribArray(..) => "DisableVertexAttribArray",
- DrawArrays(..) => "DrawArrays",
- DrawElements(..) => "DrawElements",
- EnableVertexAttribArray(..) => "EnableVertexAttribArray",
- FramebufferRenderbuffer(..) => "FramebufferRenderbuffer",
- FramebufferTexture2D(..) => "FramebufferTexture2D",
- GetBufferParameter(..) => "GetBufferParameter",
- GetExtensions(..) => "GetExtensions",
- GetParameter(..) => "GetParameter",
- GetProgramParameter(..) => "GetProgramParameter",
- GetShaderParameter(..) => "GetShaderParameter",
- GetShaderPrecisionFormat(..) => "GetShaderPrecisionFormat",
- GetActiveAttrib(..) => "GetActiveAttrib",
- GetActiveUniform(..) => "GetActiveUniform",
- GetAttribLocation(..) => "GetAttribLocation",
- GetUniformLocation(..) => "GetUniformLocation",
- GetShaderInfoLog(..) => "GetShaderInfoLog",
- GetProgramInfoLog(..) => "GetProgramInfoLog",
- GetVertexAttrib(..) => "GetVertexAttrib",
- GetVertexAttribOffset(..) => "GetVertexAttribOffset",
- PolygonOffset(..) => "PolygonOffset",
- ReadPixels(..) => "ReadPixels",
- RenderbufferStorage(..) => "RenderbufferStorage",
- SampleCoverage(..) => "SampleCoverage",
- Scissor(..) => "Scissor",
- StencilFunc(..) => "StencilFunc",
- StencilFuncSeparate(..) => "StencilFuncSeparate",
- StencilMask(..) => "StencilMask",
- StencilMaskSeparate(..) => "StencilMaskSeparate",
- StencilOp(..) => "StencilOp",
- StencilOpSeparate(..) => "StencilOpSeparate",
- Hint(..) => "Hint",
- IsEnabled(..) => "IsEnabled",
- LineWidth(..) => "LineWidth",
- PixelStorei(..) => "PixelStorei",
- LinkProgram(..) => "LinkProgram",
- Uniform1f(..) => "Uniform1f",
- Uniform1fv(..) => "Uniform1fv",
- Uniform1i(..) => "Uniform1i",
- Uniform1iv(..) => "Uniform1iv",
- Uniform2f(..) => "Uniform2f",
- Uniform2fv(..) => "Uniform2fv",
- Uniform2i(..) => "Uniform2i",
- Uniform2iv(..) => "Uniform2iv",
- Uniform3f(..) => "Uniform3f",
- Uniform3fv(..) => "Uniform3fv",
- Uniform3i(..) => "Uniform3i",
- Uniform3iv(..) => "Uniform3iv",
- Uniform4f(..) => "Uniform4f",
- Uniform4fv(..) => "Uniform4fv",
- Uniform4i(..) => "Uniform4i",
- Uniform4iv(..) => "Uniform4iv",
- UniformMatrix2fv(..) => "UniformMatrix2fv",
- UniformMatrix3fv(..) => "UniformMatrix3fv",
- UniformMatrix4fv(..) => "UniformMatrix4fv",
- UseProgram(..) => "UseProgram",
- ValidateProgram(..) => "ValidateProgram",
- VertexAttrib(..) => "VertexAttrib",
- VertexAttribPointer2f(..) => "VertexAttribPointer2f",
- VertexAttribPointer(..) => "VertexAttribPointer",
- Viewport(..) => "Viewport",
- TexImage2D(..) => "TexImage2D",
- TexParameteri(..) => "TexParameteri",
- TexParameterf(..) => "TexParameterf",
- TexSubImage2D(..) => "TexSubImage2D",
- DrawingBufferWidth(..) => "DrawingBufferWidth",
- DrawingBufferHeight(..) => "DrawingBufferHeight",
- Finish(..) => "Finish",
- Flush => "Flush",
- GenerateMipmap(..) => "GenerateMipmap",
- CreateVertexArray(..) => "CreateVertexArray",
- DeleteVertexArray(..) => "DeleteVertexArray",
- BindVertexArray(..) => "BindVertexArray"
- };
-
- write!(f, "CanvasWebGLMsg::{}(..)", name)
- }
-}
diff --git a/components/canvas_traits/webgl_channel/ipc.rs b/components/canvas_traits/webgl_channel/ipc.rs
deleted file mode 100644
index ac3020bbc7a..00000000000
--- a/components/canvas_traits/webgl_channel/ipc.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-use ipc_channel;
-use serde::{Deserialize, Serialize};
-use std::io;
-
-pub type WebGLSender<T> = ipc_channel::ipc::IpcSender<T>;
-pub type WebGLReceiver<T> = ipc_channel::ipc::IpcReceiver<T>;
-
-pub fn webgl_channel<T: Serialize + for<'de> Deserialize<'de>>()
- -> Result<(WebGLSender<T>, WebGLReceiver<T>), io::Error> {
- ipc_channel::ipc::channel()
-}
diff --git a/components/canvas_traits/webgl_channel/mod.rs b/components/canvas_traits/webgl_channel/mod.rs
deleted file mode 100644
index 1ac4ce15cb1..00000000000
--- a/components/canvas_traits/webgl_channel/mod.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-//! Enum wrappers to be able to select different channel implementations at runtime.
-
-mod ipc;
-mod mpsc;
-
-use ::webgl::WebGLMsg;
-use serde::{Deserialize, Serialize};
-use servo_config::opts;
-
-lazy_static! {
- static ref IS_MULTIPROCESS: bool = {
- opts::multiprocess()
- };
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub enum WebGLSender<T: Serialize> {
- Ipc(ipc::WebGLSender<T>),
- Mpsc(mpsc::WebGLSender<T>),
-}
-
-impl<T: Serialize> WebGLSender<T> {
- #[inline]
- pub fn send(&self, msg: T) -> WebGLSendResult {
- match *self {
- WebGLSender::Ipc(ref sender) => {
- sender.send(msg).map_err(|_| ())
- },
- WebGLSender::Mpsc(ref sender) => {
- sender.send(msg).map_err(|_| ())
- }
- }
- }
-}
-
-pub type WebGLSendResult = Result<(), ()>;
-
-pub enum WebGLReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
- Ipc(ipc::WebGLReceiver<T>),
- Mpsc(mpsc::WebGLReceiver<T>),
-}
-
-impl<T> WebGLReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
- pub fn recv(&self) -> Result<T, ()> {
- match *self {
- WebGLReceiver::Ipc(ref receiver) => {
- receiver.recv().map_err(|_| ())
- },
- WebGLReceiver::Mpsc(ref receiver) => {
- receiver.recv().map_err(|_| ())
- }
- }
- }
-}
-
-pub fn webgl_channel<T>() -> Result<(WebGLSender<T>, WebGLReceiver<T>), ()>
- where T: for<'de> Deserialize<'de> + Serialize {
- if *IS_MULTIPROCESS {
- ipc::webgl_channel().map(|(tx, rx)| (WebGLSender::Ipc(tx), WebGLReceiver::Ipc(rx)))
- .map_err(|_| ())
- } else {
- mpsc::webgl_channel().map(|(tx, rx)| (WebGLSender::Mpsc(tx), WebGLReceiver::Mpsc(rx)))
- }
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub struct WebGLChan(pub WebGLSender<WebGLMsg>);
-
-impl WebGLChan {
- #[inline]
- pub fn send(&self, msg: WebGLMsg) -> WebGLSendResult {
- self.0.send(msg)
- }
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub struct WebGLPipeline(pub WebGLChan);
-
-impl WebGLPipeline {
- pub fn channel(&self) -> WebGLChan {
- self.0.clone()
- }
-}
diff --git a/components/canvas_traits/webgl_channel/mpsc.rs b/components/canvas_traits/webgl_channel/mpsc.rs
deleted file mode 100644
index b0fe29241f3..00000000000
--- a/components/canvas_traits/webgl_channel/mpsc.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-use serde::{Deserialize, Serialize};
-use serde::{Deserializer, Serializer};
-use std::sync::mpsc;
-
-#[macro_use]
-macro_rules! unreachable_serializable {
- ($name:ident) => {
- impl<T> Serialize for $name<T> {
- fn serialize<S: Serializer>(&self, _: S) -> Result<S::Ok, S::Error> {
- unreachable!();
- }
- }
-
- impl<'a, T> Deserialize<'a> for $name<T> {
- fn deserialize<D>(_: D) -> Result<$name<T>, D::Error>
- where D: Deserializer<'a> {
- unreachable!();
- }
- }
- };
-}
-
-#[derive(Clone)]
-pub struct WebGLSender<T>(mpsc::Sender<T>);
-pub struct WebGLReceiver<T>(mpsc::Receiver<T>);
-
-impl<T> WebGLSender<T> {
- #[inline]
- pub fn send(&self, data: T) -> Result<(), mpsc::SendError<T>> {
- self.0.send(data)
- }
-}
-
-impl<T> WebGLReceiver<T> {
- #[inline]
- pub fn recv(&self) -> Result<T, mpsc::RecvError> {
- self.0.recv()
- }
-}
-
-pub fn webgl_channel<T>() -> Result<(WebGLSender<T>, WebGLReceiver<T>), ()> {
- let (sender, receiver) = mpsc::channel();
- Ok((WebGLSender(sender), WebGLReceiver(receiver)))
-}
-
-unreachable_serializable!(WebGLReceiver);
-unreachable_serializable!(WebGLSender);
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-05 03:40:50 +0000