Auto merge of #3573 - moz-gfx:__wrlastsync, r=moz-gfx

Sync changes from mozilla-central

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/webrender/3573)
<!-- Reviewable:end -->

Author: bors-servo

examples/animation.rs

@@ -67,6 +67,7 @@ impl App {
             &LayoutPrimitiveInfo::new(LayoutRect::zero()),
             spatial_id,
             &filters,
+            &[],
         );
 
         let space_and_clip = SpaceAndClipInfo {

examples/scrolling.rs

@@ -56,7 +56,7 @@ impl Example for App {
                 vec![],
                 None,
                 ScrollSensitivity::ScriptAndInputEvents,
-                LayoutPoint::zero(),
+                LayoutVector2D::zero(),
             );
 
             // now put some content into it.
@@ -88,7 +88,7 @@ impl Example for App {
                 vec![],
                 None,
                 ScrollSensitivity::ScriptAndInputEvents,
-                LayoutPoint::zero(),
+                LayoutVector2D::zero(),
             );
 
             // give it a giant gray background just to distinguish it and to easily

webrender/res/brush_blend.glsl

@@ -4,6 +4,12 @@
 
 #define VECS_PER_SPECIFIC_BRUSH 3
 
+#define COMPONENT_TRANSFER_IDENTITY 0
+#define COMPONENT_TRANSFER_TABLE 1
+#define COMPONENT_TRANSFER_DISCRETE 2
+#define COMPONENT_TRANSFER_LINEAR 3
+#define COMPONENT_TRANSFER_GAMMA 4
+
 #include shared,prim_shared,brush
 
 // Interpolated UV coordinates to sample.
@@ -16,6 +22,8 @@ flat varying int vOp;
 flat varying mat3 vColorMat;
 flat varying vec3 vColorOffset;
 flat varying vec4 vUvClipBounds;
+flat varying int vTableAddress;
+flat varying int vFuncs[4];
 
 #ifdef WR_VERTEX_SHADER
 
@@ -55,9 +63,21 @@ void brush_vs(
     float amount = float(user_data.z) / 65536.0;
     float invAmount = 1.0 - amount;
 
-    vOp = user_data.y;
+    vOp = user_data.y & 0xffff;
     vAmount = amount;
 
+    // This assignment is only used for component transfer filters but this
+    // assignment has to be done here and not in the component transfer case
+    // below because it doesn't get executed on Windows because of a suspected
+    // miscompile of this shader on Windows. See
+    // https://github.com/servo/webrender/wiki/Driver-issues#bug-1505871---assignment-to-varying-flat-arrays-inside-switch-statement-of-vertex-shader-suspected-miscompile-on-windows
+    // default: just to satisfy angle_shader_validation.rs which needs one
+    // default: for every switch, even in comments.
+    vFuncs[0] = (user_data.y >> 28) & 0xf; // R
+    vFuncs[1] = (user_data.y >> 24) & 0xf; // G
+    vFuncs[2] = (user_data.y >> 20) & 0xf; // B
+    vFuncs[3] = (user_data.y >> 16) & 0xf; // A
+
     switch (vOp) {
         case 2: {
             // Grayscale
@@ -109,6 +129,11 @@ void brush_vs(
             vColorOffset = offset_data.rgb;
             break;
         }
+        case 13: {
+            // Component Transfer
+            vTableAddress = user_data.z;
+            break;
+        }
         default: break;
     }
 }
@@ -177,6 +202,58 @@ Fragment brush_fs() {
         case 12:
             color = LinearToSrgb(color);
             break;
+        case 13: // Component Transfer
+            int offset = 0;
+            vec4 texel;
+            int k;
+
+            // We push a different amount of data to the gpu cache depending
+            // on the function type.
+            // Identity => 0 blocks
+            // Table/Discrete => 64 blocks (256 values)
+            // Linear => 1 block (2 values)
+            // Gamma => 1 block (3 values)
+            // We loop through the color components and increment the offset
+            // (for the next color component) into the gpu cache based on how
+            // many blocks that function type put into the gpu cache.
+            // Table/Discrete use a 256 entry look up table.
+            // Linear/Gamma are a simple calculation.
+            vec4 colora = alpha != 0.0 ? Cs / alpha : Cs;
+            for (int i = 0; i < 4; i++) {
+                switch (vFuncs[i]) {
+                    case COMPONENT_TRANSFER_IDENTITY:
+                        break;
+                    case COMPONENT_TRANSFER_TABLE:
+                    case COMPONENT_TRANSFER_DISCRETE:
+                        // fetch value from lookup table
+                        k = int(floor(colora[i]*255.0));
+                        texel = fetch_from_gpu_cache_1(vTableAddress + offset + k/4);
+                        colora[i] = clamp(texel[k % 4], 0.0, 1.0);
+                        // offset plus 256/4 blocks
+                        offset = offset + 64;
+                        break;
+                    case COMPONENT_TRANSFER_LINEAR:
+                        // fetch the two values for use in the linear equation
+                        texel = fetch_from_gpu_cache_1(vTableAddress + offset);
+                        colora[i] = clamp(texel[0] * colora[i] + texel[1], 0.0, 1.0);
+                        // offset plus 1 block
+                        offset = offset + 1;
+                        break;
+                    case COMPONENT_TRANSFER_GAMMA:
+                        // fetch the three values for use in the gamma equation
+                        texel = fetch_from_gpu_cache_1(vTableAddress + offset);
+                        colora[i] = clamp(texel[0] * pow(colora[i], texel[1]) + texel[2], 0.0, 1.0);
+                        // offset plus 1 block
+                        offset = offset + 1;
+                        break;
+                    default:
+                        // shouldn't happen
+                        break;
+                }
+            }
+            color = colora.rgb;
+            alpha = colora.a;
+            break;
         default:
             color = vColorMat * color + vColorOffset;
     }

webrender/res/gpu_cache.glsl

@@ -33,6 +33,15 @@ vec4[2] fetch_from_gpu_cache_2(int address) {
     );
 }
 
+vec4 fetch_from_gpu_cache_1_direct(ivec2 address) {
+    return texelFetch(sGpuCache, address, 0);
+}
+
+vec4 fetch_from_gpu_cache_1(int address) {
+    ivec2 uv = get_gpu_cache_uv(address);
+    return texelFetch(sGpuCache, uv, 0);
+}
+
 #ifdef WR_VERTEX_SHADER
 
 vec4[8] fetch_from_gpu_cache_8(int address) {
@@ -85,15 +94,6 @@ vec4[4] fetch_from_gpu_cache_4(int address) {
     );
 }
 
-vec4 fetch_from_gpu_cache_1_direct(ivec2 address) {
-    return texelFetch(sGpuCache, address, 0);
-}
-
-vec4 fetch_from_gpu_cache_1(int address) {
-    ivec2 uv = get_gpu_cache_uv(address);
-    return texelFetch(sGpuCache, uv, 0);
-}
-
 //TODO: image resource is too specific for this module
 
 struct ImageResource {

webrender/src/batch.rs

@@ -1388,6 +1388,7 @@ impl AlphaBatchBuilder {
                                             FilterOp::ColorMatrix(..) => 10,
                                             FilterOp::SrgbToLinear => 11,
                                             FilterOp::LinearToSrgb => 12,
+                                            FilterOp::ComponentTransfer => unreachable!(),
                                         };
 
                                         let user_data = match filter {
@@ -1413,6 +1414,7 @@ impl AlphaBatchBuilder {
                                             FilterOp::ColorMatrix(_) => {
                                                 picture.extra_gpu_data_handle.as_int(gpu_cache)
                                             }
+                                            FilterOp::ComponentTransfer => unreachable!(),
                                         };
 
                                         let (uv_rect_address, textures) = surface
@@ -1452,6 +1454,60 @@ impl AlphaBatchBuilder {
                                     }
                                 }
                             }
+                            PictureCompositeMode::ComponentTransferFilter(handle) => {
+                                // This is basically the same as the general filter case above
+                                // except we store a little more data in the filter mode and
+                                // a gpu cache handle in the user data.
+                                let surface = ctx.surfaces[raster_config.surface_index.0]
+                                    .surface
+                                    .as_ref()
+                                    .expect("bug: surface must be allocated by now");
+
+
+                                let filter_data = &ctx.data_stores.filterdata[handle];
+                                let filter_mode : i32 = 13 |
+                                    ((filter_data.data.r_func.to_int() << 28 |
+                                      filter_data.data.g_func.to_int() << 24 |
+                                      filter_data.data.b_func.to_int() << 20 |
+                                      filter_data.data.a_func.to_int() << 16) as i32);
+
+                                let user_data = filter_data.gpu_cache_handle.as_int(gpu_cache);
+
+                                let (uv_rect_address, textures) = surface
+                                    .resolve(
+                                        render_tasks,
+                                        ctx.resource_cache,
+                                        gpu_cache,
+                                    );
+
+                                let key = BatchKey::new(
+                                    BatchKind::Brush(BrushBatchKind::Blend),
+                                    BlendMode::PremultipliedAlpha,
+                                    textures,
+                                );
+
+                                let prim_header_index = prim_headers.push(&prim_header, z_id, [
+                                    uv_rect_address.as_int(),
+                                    filter_mode,
+                                    user_data,
+                                ]);
+
+                                let instance = BrushInstance {
+                                    prim_header_index,
+                                    clip_task_address,
+                                    segment_index: INVALID_SEGMENT_INDEX,
+                                    edge_flags: EdgeAaSegmentMask::empty(),
+                                    brush_flags,
+                                    user_data: 0,
+                                };
+
+                                self.current_batch_list().push_single_instance(
+                                    key,
+                                    bounding_rect,
+                                    z_id,
+                                    PrimitiveInstanceData::from(instance),
+                                );
+                            }
                             PictureCompositeMode::Puppet { master: Some(source) } if ctx.is_picture_surface_visible(source) => return,
                             PictureCompositeMode::MixBlend { mode, backdrop } if ctx.is_picture_surface_visible(backdrop) => {
                                 let backdrop_picture = &ctx.prim_store.pictures[backdrop.0];

webrender/src/clip_scroll_tree.rs

@@ -433,6 +433,7 @@ impl ClipScrollTree {
         content_size: &LayoutSize,
         scroll_sensitivity: ScrollSensitivity,
         frame_kind: ScrollFrameKind,
+        external_scroll_offset: LayoutVector2D,
     ) -> SpatialNodeIndex {
         let node = SpatialNode::new_scroll_frame(
             pipeline_id,
@@ -442,6 +443,7 @@ impl ClipScrollTree {
             content_size,
             scroll_sensitivity,
             frame_kind,
+            external_scroll_offset,
         );
         self.add_spatial_node(node)
     }

webrender/src/device/gl.rs

@@ -2345,18 +2345,14 @@ impl Device {
         ibo_id: IBOId,
         owns_vertices_and_indices: bool,
     ) -> VAO {
-        debug_assert!(self.inside_frame);
-
         let instance_stride = descriptor.instance_stride() as usize;
         let vao_id = self.gl.gen_vertex_arrays(1)[0];
 
-        self.gl.bind_vertex_array(vao_id);
+        self.bind_vao_impl(vao_id);
 
         descriptor.bind(self.gl(), main_vbo_id, instance_vbo_id);
         ibo_id.bind(self.gl()); // force it to be a part of VAO
 
-        self.gl.bind_vertex_array(0);
-
         VAO {
             id: vao_id,
             ibo_id,
@@ -2374,7 +2370,7 @@ impl Device {
         debug_assert!(self.inside_frame);
 
         let vao_id = self.gl.gen_vertex_arrays(1)[0];
-        self.gl.bind_vertex_array(vao_id);
+        self.bind_vao_impl(vao_id);
 
         let mut attrib_index = 0;
         for stream in streams {
@@ -2388,8 +2384,6 @@ impl Device {
             attrib_index += stream.attributes.len();
         }
 
-        self.gl.bind_vertex_array(0);
-
         CustomVAO {
             id: vao_id,
         }