Add API on stacking contexts to configure glyph raster mode.

webrender/examples/alpha_perf.rs

@@ -40,6 +40,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         for _ in 0 .. self.rect_count {

webrender/examples/animation.rs

@@ -56,6 +56,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             filters,
+            GlyphRasterSpace::Screen,
         );
 
         let complex_clip = ComplexClipRegion {

webrender/examples/basic.rs

@@ -198,6 +198,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         let image_mask_key = api.generate_image_key();

webrender/examples/blob.rs

@@ -256,6 +256,7 @@ impl Example for App {
             None,
             api::MixBlendMode::Normal,
             Vec::new(),
+            api::GlyphRasterSpace::Screen,
         );
 
         let info = api::LayoutPrimitiveInfo::new((30, 30).by(500, 500));

webrender/examples/document.rs

@@ -119,6 +119,7 @@ impl Example for App {
                 None,
                 MixBlendMode::Normal,
                 Vec::new(),
+                GlyphRasterSpace::Screen,
             );
             builder.push_rect(
                 &LayoutPrimitiveInfo::new(local_rect),

webrender/examples/frame_output.rs

@@ -107,6 +107,7 @@ impl App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         builder.push_rect(&info, ColorF::new(1.0, 1.0, 0.0, 1.0));
@@ -155,6 +156,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         builder.push_image(

webrender/examples/iframe.rs

@@ -45,6 +45,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         // green rect visible == success
@@ -71,6 +72,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
         // red rect under the iframe: if this is visible, things have gone wrong
         builder.push_rect(&info, ColorF::new(1.0, 0.0, 0.0, 1.0));

webrender/examples/image_resize.rs

@@ -47,6 +47,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         let image_size = LayoutSize::new(100.0, 100.0);

webrender/examples/multiwindow.rs

@@ -187,6 +187,7 @@ impl Window {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         let info = LayoutPrimitiveInfo::new(LayoutRect::new(

webrender/examples/scrolling.rs

@@ -40,6 +40,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         if true {
@@ -55,6 +56,7 @@ impl Example for App {
                 None,
                 MixBlendMode::Normal,
                 Vec::new(),
+                GlyphRasterSpace::Screen,
             );
             // set the scrolling clip
             let clip_id = builder.define_scroll_frame(

webrender/examples/texture_cache_stress.rs

@@ -99,6 +99,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         let x0 = 50.0;

webrender/examples/yuv.rs

@@ -94,6 +94,7 @@ impl Example for App {
             None,
             MixBlendMode::Normal,
             Vec::new(),
+            GlyphRasterSpace::Screen,
         );
 
         let yuv_chanel1 = api.generate_image_key();

webrender/src/display_list_flattener.rs

@@ -6,7 +6,7 @@
 use api::{AlphaType, BorderDetails, BorderDisplayItem, BuiltDisplayListIter, ClipAndScrollInfo};
 use api::{ClipId, ColorF, ComplexClipRegion, DeviceIntPoint, DeviceIntRect, DeviceIntSize};
 use api::{DevicePixelScale, DeviceUintRect, DisplayItemRef, Epoch, ExtendMode, ExternalScrollId};
-use api::{FilterOp, FontInstanceKey, FontRenderMode, GlyphInstance, GlyphOptions, GradientStop};
+use api::{FilterOp, FontInstanceKey, FontRenderMode, GlyphInstance, GlyphOptions, GlyphRasterSpace, GradientStop};
 use api::{IframeDisplayItem, ImageKey, ImageRendering, ItemRange, LayerPoint, LayerPrimitiveInfo};
 use api::{LayerRect, LayerSize, LayerVector2D, LayoutRect, LayoutSize, LayoutTransform};
 use api::{LayoutVector2D, LineOrientation, LineStyle, LocalClip, PipelineId, PropertyBinding};
@@ -334,6 +334,7 @@ impl<'a> DisplayListFlattener<'a> {
             true,
             root_scroll_node,
             None,
+            GlyphRasterSpace::Screen,
         );
 
         // For the root pipeline, there's no need to add a full screen rectangle
@@ -539,6 +540,7 @@ impl<'a> DisplayListFlattener<'a> {
             false,
             final_scroll_node,
             stacking_context.clip_node_id,
+            stacking_context.glyph_raster_space,
         );
 
         self.flatten_items(
@@ -974,6 +976,7 @@ impl<'a> DisplayListFlattener<'a> {
         is_pipeline_root: bool,
         positioning_node: ClipId,
         clipping_node: Option<ClipId>,
+        glyph_raster_space: GlyphRasterSpace,
     ) {
         let clip_chain_id = match clipping_node {
             Some(ref clipping_node) => self.id_to_index_mapper.get_clip_chain_index(clipping_node),
@@ -1237,6 +1240,7 @@ impl<'a> DisplayListFlattener<'a> {
             allow_subpixel_aa,
             transform_style,
             rendering_context_3d_pic_index,
+            glyph_raster_space,
         };
 
         self.sc_stack.push(sc);
@@ -2065,19 +2069,24 @@ impl<'a> DisplayListFlattener<'a> {
                 flags |= options.flags;
             }
 
+            let (allow_subpixel_aa, glyph_raster_space) = match self.sc_stack.last() {
+                Some(stacking_context) => {
+                    (stacking_context.allow_subpixel_aa, stacking_context.glyph_raster_space)
+                }
+                None => {
+                    (true, GlyphRasterSpace::Screen)
+                }
+            };
+
             // There are some conditions under which we can't use
             // subpixel text rendering, even if enabled.
-            if render_mode == FontRenderMode::Subpixel {
+            if !allow_subpixel_aa {
                 // text on a picture that has filters
                 // (e.g. opacity) can't use sub-pixel.
                 // TODO(gw): It's possible we can relax this in
                 //           the future, if we modify the way
                 //           we handle subpixel blending.
-                if let Some(stacking_context) = self.sc_stack.last() {
-                    if !stacking_context.allow_subpixel_aa {
-                        render_mode = FontRenderMode::Alpha;
-                    }
-                }
+                render_mode = render_mode.limit_by(FontRenderMode::Alpha);
             }
 
             let prim_font = FontInstance::new(
@@ -2098,6 +2107,7 @@ impl<'a> DisplayListFlattener<'a> {
                 glyph_keys: Vec::new(),
                 offset: run_offset,
                 shadow: false,
+                glyph_raster_space,
             }
         };
 
@@ -2337,6 +2347,10 @@ struct FlattenedStackingContext {
     /// on transparent stacking contexts.
     allow_subpixel_aa: bool,
 
+    /// The rasterization mode for any text runs that are part
+    /// of this stacking context.
+    glyph_raster_space: GlyphRasterSpace,
+
     /// CSS transform-style property.
     transform_style: TransformStyle,
 

webrender/src/prim_store.rs

@@ -5,7 +5,7 @@
 use api::{AlphaType, BorderRadius, BoxShadowClipMode, BuiltDisplayList, ClipMode, ColorF, ComplexClipRegion};
 use api::{DeviceIntRect, DeviceIntSize, DevicePixelScale, Epoch, ExtendMode, FontRenderMode};
 use api::{FilterOp, GlyphInstance, GlyphKey, GradientStop, ImageKey, ImageRendering, ItemRange, ItemTag};
-use api::{LayerPoint, LayerRect, LayerSize, LayerToWorldTransform, LayerVector2D};
+use api::{GlyphRasterSpace, LayerPoint, LayerRect, LayerSize, LayerToWorldTransform, LayerVector2D};
 use api::{PipelineId, PremultipliedColorF, Shadow, YuvColorSpace, YuvFormat};
 use border::{BorderCornerInstance, BorderEdgeKind};
 use box_shadow::BLUR_SAMPLE_SCALE;
@@ -634,6 +634,7 @@ pub struct TextRunPrimitiveCpu {
     pub glyph_keys: Vec<GlyphKey>,
     pub glyph_gpu_blocks: Vec<GpuBlockData>,
     pub shadow: bool,
+    pub glyph_raster_space: GlyphRasterSpace,
 }
 
 impl TextRunPrimitiveCpu {
@@ -645,7 +646,9 @@ impl TextRunPrimitiveCpu {
         let mut font = self.font.clone();
         font.size = font.size.scale_by(device_pixel_scale.0);
         if let Some(transform) = transform {
-            if transform.has_perspective_component() || !transform.has_2d_inverse() {
+            if transform.has_perspective_component() ||
+               !transform.has_2d_inverse() ||
+               self.glyph_raster_space != GlyphRasterSpace::Screen {
                 font.render_mode = font.render_mode.limit_by(FontRenderMode::Alpha);
             } else {
                 font.transform = FontTransform::from(&transform).quantize();
@@ -972,6 +975,7 @@ impl PrimitiveContainer {
                     glyph_keys: info.glyph_keys.clone(),
                     glyph_gpu_blocks: Vec::new(),
                     shadow: true,
+                    glyph_raster_space: info.glyph_raster_space,
                 })
             }
             PrimitiveContainer::Brush(ref brush) => {

webrender_api/src/display_item.rs

@@ -452,6 +452,7 @@ pub struct StackingContext {
     pub mix_blend_mode: MixBlendMode,
     pub reference_frame_id: Option<ClipId>,
     pub clip_node_id: Option<ClipId>,
+    pub glyph_raster_space: GlyphRasterSpace,
 } // IMPLICIT: filters: Vec<FilterOp>
 
 #[repr(u32)]
@@ -468,6 +469,23 @@ pub enum TransformStyle {
     Preserve3D = 1,
 }
 
+// TODO(gw): In the future, we may modify this to apply to all elements
+//           within a stacking context, rather than just the glyphs. If
+//           this change occurs, we'll update the naming of this.
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
+#[repr(C, u8)]
+pub enum GlyphRasterSpace {
+    // Rasterize glyphs in local-space, applying supplied scale to glyph sizes.
+    // Best performance, but lower quality.
+    Local(f32),
+
+    // Rasterize the glyphs in screen-space, including rotation / skew etc in
+    // the rasterized glyph. Best quality, but slower performance. Note that
+    // any stacking context with a perspective transform will be rasterized
+    // in local-space, even if this is set.
+    Screen,
+}
+
 #[repr(u32)]
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
 pub enum MixBlendMode {

webrender_api/src/display_list.rs

@@ -16,7 +16,7 @@ use time::precise_time_ns;
 use {AlphaType, BorderDetails, BorderDisplayItem, BorderRadius, BorderWidths, BoxShadowClipMode};
 use {BoxShadowDisplayItem, ClipAndScrollInfo, ClipChainId, ClipChainItem, ClipDisplayItem, ClipId};
 use {ColorF, ComplexClipRegion, DisplayItem, ExtendMode, ExternalScrollId, FilterOp};
-use {FontInstanceKey, GlyphInstance, GlyphOptions, Gradient, GradientDisplayItem, GradientStop};
+use {FontInstanceKey, GlyphInstance, GlyphOptions, GlyphRasterSpace, Gradient, GradientDisplayItem, GradientStop};
 use {IframeDisplayItem, ImageDisplayItem, ImageKey, ImageMask, ImageRendering, LayerPrimitiveInfo};
 use {LayoutPoint, LayoutPrimitiveInfo, LayoutRect, LayoutSize, LayoutTransform, LayoutVector2D};
 use {LineDisplayItem, LineOrientation, LineStyle, MixBlendMode, PipelineId, PropertyBinding};
@@ -1276,6 +1276,7 @@ impl DisplayListBuilder {
         perspective: Option<LayoutTransform>,
         mix_blend_mode: MixBlendMode,
         filters: Vec<FilterOp>,
+        glyph_raster_space: GlyphRasterSpace,
     ) {
         let reference_frame_id = if transform.is_some() || perspective.is_some() {
             Some(self.generate_clip_id())
@@ -1292,6 +1293,7 @@ impl DisplayListBuilder {
                 mix_blend_mode,
                 reference_frame_id,
                 clip_node_id,
+                glyph_raster_space,
             },
         });
 

wrench/reftests/text/raster-space.yaml

@@ -0,0 +1,19 @@
+root:
+  items:
+    - type: stacking-context
+      transform: scale(5.0) rotate(45)
+      transform-origin: 300 300
+      glyph-raster-space: local(1.0)
+      items:
+      - text: "Local"
+        origin: 20 50
+        size: 20
+        font: "FreeSans.ttf"
+    - type: stacking-context
+      transform: scale(5.0) rotate(45)
+      transform-origin: 0 400
+      items:
+      - text: "Screen"
+        origin: 20 50
+        size: 20
+        font: "FreeSans.ttf"

wrench/reftests/text/reftest.list

@@ -56,3 +56,4 @@ platform(linux) == two-shadows.yaml two-shadows.png
 == shadow-fast-clip.yaml shadow-fast-clip-ref.yaml
 == shadow-partial-glyph.yaml shadow-partial-glyph-ref.yaml
 fuzzy(1,68) platform(linux) == shadow-transforms.yaml shadow-transforms.png
+fuzzy(1,71) platform(linux) == raster-space.yaml raster-space.png

wrench/src/yaml_frame_reader.rs

@@ -1534,6 +1534,9 @@ impl YamlFrameReader {
         let scroll_policy = yaml["scroll-policy"]
             .as_scroll_policy()
             .unwrap_or(ScrollPolicy::Scrollable);
+        let glyph_raster_space = yaml["glyph-raster-space"]
+            .as_glyph_raster_space()
+            .unwrap_or(GlyphRasterSpace::Screen);
 
         if is_root {
             if let Some(size) = yaml["scroll-offset"].as_point() {
@@ -1555,6 +1558,7 @@ impl YamlFrameReader {
             perspective,
             mix_blend_mode,
             filters,
+            glyph_raster_space,
         );
 
         if !yaml["items"].is_badvalue() {

wrench/src/yaml_frame_writer.rs

@@ -191,6 +191,16 @@ fn write_stacking_context(
 
     enum_node(parent, "transform-style", sc.transform_style);
 
+    let glyph_raster_space = match sc.glyph_raster_space {
+        GlyphRasterSpace::Local(scale) => {
+            format!("local({})", scale)
+        }
+        GlyphRasterSpace::Screen => {
+            "screen".to_owned()
+        }
+    };
+    str_node(parent, "glyph-raster-space", &glyph_raster_space);
+
     if let Some(clip_node_id) = sc.clip_node_id {
         yaml_node(parent, "clip-node", Yaml::Integer(clip_id_mapper.map_id(&clip_node_id) as i64));
     }

wrench/src/yaml_helper.rs

@@ -31,6 +31,7 @@ pub trait YamlHelper {
     fn as_border_radius_component(&self) -> LayoutSize;
     fn as_border_radius(&self) -> Option<BorderRadius>;
     fn as_transform_style(&self) -> Option<TransformStyle>;
+    fn as_glyph_raster_space(&self) -> Option<GlyphRasterSpace>;
     fn as_clip_mode(&self) -> Option<ClipMode>;
     fn as_mix_blend_mode(&self) -> Option<MixBlendMode>;
     fn as_scroll_policy(&self) -> Option<ScrollPolicy>;
@@ -519,6 +520,22 @@ impl YamlHelper for Yaml {
         self.as_str().and_then(|x| StringEnum::from_str(x))
     }
 
+    fn as_glyph_raster_space(&self) -> Option<GlyphRasterSpace> {
+        self.as_str().and_then(|s| {
+            match parse_function(s) {
+                ("screen", _, _) => {
+                    Some(GlyphRasterSpace::Screen)
+                }
+                ("local", ref args, _) if args.len() == 1 => {
+                    Some(GlyphRasterSpace::Local(args[0].parse().unwrap()))
+                }
+                f => {
+                    panic!("error parsing glyph raster space {:?}", f);
+                }
+            }
+        })
+    }
+
     fn as_mix_blend_mode(&self) -> Option<MixBlendMode> {
         self.as_str().and_then(|x| StringEnum::from_str(x))
     }