Allow subpixel with specified background color in offscreen targets.

When a subpixel text run has a specified background color, we can
safely draw it into an off-screen surface.

Fix a bug in the renderer where the shader color mode was being
set before the shader was bound.

Add support in wrench for specifying the background color of
a text run.

Add a reftest that checks offscreen surface + bg color subpixel
text is the same as subpixel text on a normal background.

Fixes #2670.

webrender/src/glyph_rasterizer.rs

@@ -224,6 +224,10 @@ impl FontInstance {
         platform_options: Option<FontInstancePlatformOptions>,
         variations: Vec<FontVariation>,
     ) -> Self {
+        // If a background color is enabled, it only makes sense
+        // for it to be completely opaque.
+        debug_assert!(bg_color.a == 0 || bg_color.a == 255);
+
         FontInstance {
             font_key,
             size,

webrender/src/prim_store.rs

@@ -728,7 +728,7 @@ impl TextRunPrimitiveCpu {
         display_list: &BuiltDisplayList,
         frame_building_state: &mut FrameBuildingState,
     ) {
-        if !allow_subpixel_aa {
+        if !allow_subpixel_aa && self.font.bg_color.a == 0 {
             self.font.render_mode = self.font.render_mode.limit_by(FontRenderMode::Alpha);
         }
 

webrender/src/renderer.rs

@@ -2891,6 +2891,13 @@ impl Renderer {
             }
 
             for batch in &alpha_batch_container.alpha_batches {
+                self.shaders
+                    .get(&batch.key)
+                    .bind(
+                        &mut self.device, projection,
+                        &mut self.renderer_errors,
+                    );
+
                 if batch.key.blend_mode != prev_blend_mode {
                     match batch.key.blend_mode {
                         BlendMode::None => {
@@ -2924,13 +2931,6 @@ impl Renderer {
                     prev_blend_mode = batch.key.blend_mode;
                 }
 
-                self.shaders
-                    .get(&batch.key)
-                    .bind(
-                        &mut self.device, projection,
-                        &mut self.renderer_errors,
-                    );
-
                 // Handle special case readback for composites.
                 if let BatchKind::Brush(BrushBatchKind::MixBlend { task_id, source_id, backdrop_id }) = batch.key.kind {
                     // composites can't be grouped together because

wrench/reftests/text/bg-color-ref.yaml

@@ -0,0 +1,8 @@
+---
+root:
+  items:
+    - text: "A"
+      origin: 30 220
+      size: 200
+      color: black
+      font: "FreeSans.ttf"

wrench/reftests/text/bg-color.yaml

@@ -0,0 +1,15 @@
+# verify that drawing a text run on an off-screen surface with a
+# specified background color gives the same result as drawing a
+# subpixel text run directly on the background.
+---
+root:
+  items:
+    - type: stacking-context
+      transform-style: preserve-3d
+      items:
+      - text: "A"
+        origin: 30 220
+        size: 200
+        color: black
+        font: "FreeSans.ttf"
+        bg-color: white

wrench/reftests/text/reftest.list

@@ -58,3 +58,4 @@ platform(linux) == two-shadows.yaml two-shadows.png
 fuzzy(1,68) platform(linux) == shadow-transforms.yaml shadow-transforms.png
 fuzzy(1,71) platform(linux) == raster-space.yaml raster-space.png
 != allow-subpixel.yaml allow-subpixel-ref.yaml
+== bg-color.yaml bg-color-ref.yaml

wrench/src/wrench.rs

@@ -467,6 +467,7 @@ impl Wrench {
         size: Au,
         flags: FontInstanceFlags,
         render_mode: Option<FontRenderMode>,
+        bg_color: Option<ColorU>,
     ) -> FontInstanceKey {
         let key = self.api.generate_font_instance_key();
         let mut update = ResourceUpdates::new();
@@ -475,6 +476,9 @@ impl Wrench {
         if let Some(render_mode) = render_mode {
             options.render_mode = render_mode;
         }
+        if let Some(bg_color) = bg_color {
+            options.bg_color = bg_color;
+        }
         update.add_font_instance(key, font_key, size, Some(options), None, Vec::new());
         self.api.update_resources(update);
         key

wrench/src/yaml_frame_reader.rs

@@ -198,7 +198,7 @@ pub struct YamlFrameReader {
     image_map: HashMap<(PathBuf, Option<i64>), (ImageKey, LayoutSize)>,
 
     fonts: HashMap<FontDescriptor, FontKey>,
-    font_instances: HashMap<(FontKey, Au, FontInstanceFlags), FontInstanceKey>,
+    font_instances: HashMap<(FontKey, Au, FontInstanceFlags, Option<ColorU>), FontInstanceKey>,
     font_render_mode: Option<FontRenderMode>,
     allow_mipmaps: bool,
 
@@ -544,19 +544,21 @@ impl YamlFrameReader {
         &mut self,
         font_key: FontKey,
         size: Au,
+        bg_color: Option<ColorU>,
         flags: FontInstanceFlags,
         wrench: &mut Wrench,
     ) -> FontInstanceKey {
         let font_render_mode = self.font_render_mode;
 
         *self.font_instances
-            .entry((font_key, size, flags))
+            .entry((font_key, size, flags, bg_color))
             .or_insert_with(|| {
                 wrench.add_font_instance(
                     font_key,
                     size,
                     flags,
                     font_render_mode,
+                    bg_color,
                 )
             })
     }
@@ -1117,6 +1119,8 @@ impl YamlFrameReader {
     ) {
         let size = item["size"].as_pt_to_au().unwrap_or(Au::from_f32_px(16.0));
         let color = item["color"].as_colorf().unwrap_or(*BLACK_COLOR);
+        let bg_color = item["bg-color"].as_colorf().map(|c| c.into());
+
         let mut flags = FontInstanceFlags::empty();
         if item["synthetic-italics"].as_bool().unwrap_or(false) {
             flags |= FontInstanceFlags::SYNTHETIC_ITALICS;
@@ -1146,6 +1150,7 @@ impl YamlFrameReader {
         let font_key = self.get_or_create_font(desc, wrench);
         let font_instance_key = self.get_or_create_font_instance(font_key,
                                                                  size,
+                                                                 bg_color,
                                                                  flags,
                                                                  wrench);