diff --git a/webrender/res/cs_clip_image.glsl b/webrender/res/cs_clip_image.glsl
index 4ea58b0fb1..188c5e2e03 100644
--- a/webrender/res/cs_clip_image.glsl
+++ b/webrender/res/cs_clip_image.glsl
@@ -48,8 +48,7 @@ void main(void) {
 
 #ifdef WR_FRAGMENT_SHADER
 void main(void) {
-    float alpha = 1.f;
-    vec2 local_pos = init_transform_fs(vPos, alpha);
+    float alpha = init_transform_fs(vPos.xy / vPos.z);
 
     bool repeat_mask = false; //TODO
     vec2 clamped_mask_uv = repeat_mask ? fract(vClipMaskUv.xy) :
diff --git a/webrender/res/cs_clip_rectangle.glsl b/webrender/res/cs_clip_rectangle.glsl
index 239a3bf6e7..d6518df517 100644
--- a/webrender/res/cs_clip_rectangle.glsl
+++ b/webrender/res/cs_clip_rectangle.glsl
@@ -93,8 +93,8 @@ void main(void) {
 
 #ifdef WR_FRAGMENT_SHADER
 void main(void) {
-    float alpha = 1.f;
-    vec2 local_pos = init_transform_fs(vPos, alpha);
+    vec2 local_pos = vPos.xy / vPos.z;
+    float alpha = init_transform_fs(local_pos);
 
     float aa_range = compute_aa_range(local_pos);
 
diff --git a/webrender/res/prim_shared.glsl b/webrender/res/prim_shared.glsl
index e58b7414cd..d041cb3fe7 100644
--- a/webrender/res/prim_shared.glsl
+++ b/webrender/res/prim_shared.glsl
@@ -617,11 +617,6 @@ VertexInfo write_vertex(RectWithSize instance_rect,
 
 #ifdef WR_FEATURE_TRANSFORM
 
-struct TransformVertexInfo {
-    vec3 local_pos;
-    vec2 screen_pos;
-};
-
 float cross2(vec2 v0, vec2 v1) {
     return v0.x * v1.y - v0.y * v1.x;
 }
@@ -641,101 +636,67 @@ vec2 intersect_lines(vec2 p0, vec2 p1, vec2 p2, vec2 p3) {
     return vec2(nx / d, ny / d);
 }
 
-TransformVertexInfo write_transform_vertex(RectWithSize instance_rect,
-                                           RectWithSize local_clip_rect,
-                                           vec4 clip_edge_mask,
-                                           float z,
-                                           Layer layer,
-                                           PictureTask task) {
-    RectWithEndpoint local_rect = to_rect_with_endpoint(instance_rect);
-    RectWithSize clip_rect;
-    clip_rect.p0 = clamp_rect(local_clip_rect.p0, layer.local_clip_rect);
-    clip_rect.size = clamp_rect(local_clip_rect.p0 + local_clip_rect.size, layer.local_clip_rect) - clip_rect.p0;
-
-    vec2 current_local_pos, prev_local_pos, next_local_pos;
+VertexInfo write_transform_vertex(RectWithSize instance_rect,
+                                  RectWithSize local_clip_rect,
+                                  vec4 clip_edge_mask,
+                                  float z,
+                                  Layer layer,
+                                  PictureTask task) {
+    // Calculate a clip rect from local clip + layer clip.
+    RectWithEndpoint clip_rect = to_rect_with_endpoint(local_clip_rect);
+    clip_rect.p0 = clamp_rect(clip_rect.p0, layer.local_clip_rect);
+    clip_rect.p1 = clamp_rect(clip_rect.p1, layer.local_clip_rect);
 
-    // Clamp to the two local clip rects.
-    local_rect.p0 = clamp_rect(local_rect.p0, clip_rect);
-    local_rect.p1 = clamp_rect(local_rect.p1, clip_rect);
-
-    // Select the current vertex and the previous/next vertices,
-    // based on the vertex ID that is known based on the instance rect.
-    switch (gl_VertexID) {
-        case 0:
-            current_local_pos = vec2(local_rect.p0.x, local_rect.p0.y);
-            next_local_pos = vec2(local_rect.p0.x, local_rect.p1.y);
-            prev_local_pos = vec2(local_rect.p1.x, local_rect.p0.y);
-            break;
-        case 1:
-            current_local_pos = vec2(local_rect.p1.x, local_rect.p0.y);
-            next_local_pos = vec2(local_rect.p0.x, local_rect.p0.y);
-            prev_local_pos = vec2(local_rect.p1.x, local_rect.p1.y);
-            break;
-        case 2:
-            current_local_pos = vec2(local_rect.p0.x, local_rect.p1.y);
-            prev_local_pos = vec2(local_rect.p0.x, local_rect.p0.y);
-            next_local_pos = vec2(local_rect.p1.x, local_rect.p1.y);
-            break;
-        case 3:
-            current_local_pos = vec2(local_rect.p1.x, local_rect.p1.y);
-            prev_local_pos = vec2(local_rect.p0.x, local_rect.p1.y);
-            next_local_pos = vec2(local_rect.p1.x, local_rect.p0.y);
-            break;
-    }
+    // Calculate a clip rect from local_rect + local clip + layer clip.
+    RectWithEndpoint local_rect = to_rect_with_endpoint(instance_rect);
+    local_rect.p0 = clamp(local_rect.p0, clip_rect.p0, clip_rect.p1);
+    local_rect.p1 = clamp(local_rect.p1, clip_rect.p0, clip_rect.p1);
+
+    // As this is a transform shader, extrude by 2 (local space) pixels
+    // in each direction. This gives enough space around the edge to
+    // apply distance anti-aliasing. Technically, it:
+    // (a) slightly over-estimates the number of required pixels in the simple case.
+    // (b) might not provide enough edge in edge case perspective projections.
+    // However, it's fast and simple. If / when we ever run into issues, we
+    // can do some math on the projection matrix to work out a variable
+    // amount to extrude.
+    float extrude_distance = 2.0;
+    instance_rect.p0 -= vec2(extrude_distance);
+    instance_rect.size += vec2(2.0 * extrude_distance);
 
-    // Transform them to world space
-    vec4 current_world_pos = layer.transform * vec4(current_local_pos, 0.0, 1.0);
-    vec4 prev_world_pos = layer.transform * vec4(prev_local_pos, 0.0, 1.0);
-    vec4 next_world_pos = layer.transform * vec4(next_local_pos, 0.0, 1.0);
-
-    // Convert to device space
-    vec2 current_device_pos = uDevicePixelRatio * current_world_pos.xy / current_world_pos.w;
-    vec2 prev_device_pos = uDevicePixelRatio * prev_world_pos.xy / prev_world_pos.w;
-    vec2 next_device_pos = uDevicePixelRatio * next_world_pos.xy / next_world_pos.w;
-
-    // Get the normals of each of the vectors between the current and next/prev vertices.
-    const float amount = 2.0;
-    vec2 dir_prev = normalize(current_device_pos - prev_device_pos);
-    vec2 dir_next = normalize(current_device_pos - next_device_pos);
-    vec2 norm_prev = vec2(-dir_prev.y,  dir_prev.x);
-    vec2 norm_next = vec2( dir_next.y, -dir_next.x);
-
-    // Push those lines out along the normal by a specific amount of device pixels.
-    vec2 adjusted_prev_p0 = current_device_pos + norm_prev * amount;
-    vec2 adjusted_prev_p1 = prev_device_pos + norm_prev * amount;
-    vec2 adjusted_next_p0 = current_device_pos + norm_next * amount;
-    vec2 adjusted_next_p1 = next_device_pos + norm_next * amount;
-
-    // Intersect those adjusted lines to find the actual vertex position.
-    vec2 device_pos = intersect_lines(adjusted_prev_p0,
-                                      adjusted_prev_p1,
-                                      adjusted_next_p0,
-                                      adjusted_next_p1);
-
-    vec4 layer_pos = get_layer_pos(device_pos / uDevicePixelRatio, layer);
+    // Select the corner of the local rect that we are processing.
+    vec2 local_pos = instance_rect.p0 + instance_rect.size * aPosition.xy;
 
-    // Apply offsets for the render task to get correct screen location.
-    vec2 final_pos = device_pos - //Note: `snap_rect` is not used
-                     task.content_origin +
-                     task.common_data.task_rect.p0;
+    // Transform the current vertex to the world cpace.
+    vec4 world_pos = layer.transform * vec4(local_pos, 0.0, 1.0);
 
+    // Convert the world positions to device pixel space.
+    vec2 device_pos = world_pos.xy / world_pos.w * uDevicePixelRatio;
 
-    gl_Position = uTransform * vec4(final_pos, z, 1.0);
+    // We want the world space coords to be perspective divided by W.
+    // We also want that to apply to any interpolators. However, we
+    // want a constant Z across the primitive, since we're using it
+    // for draw ordering - so scale by the W coord to ensure this.
+    vec4 final_pos = vec4(world_pos.xy + task.common_data.task_rect.p0 - task.content_origin,
+                          z * world_pos.w,
+                          world_pos.w);
+    gl_Position = uTransform * final_pos;
 
     vLocalBounds = mix(
-        vec4(clip_rect.p0, clip_rect.p0 + clip_rect.size),
+        vec4(clip_rect.p0, clip_rect.p1),
         vec4(local_rect.p0, local_rect.p1),
         clip_edge_mask
     );
 
-    return TransformVertexInfo(layer_pos.xyw, device_pos);
+    VertexInfo vi = VertexInfo(local_pos, device_pos);
+    return vi;
 }
 
-TransformVertexInfo write_transform_vertex_primitive(Primitive prim) {
+VertexInfo write_transform_vertex_primitive(Primitive prim) {
     return write_transform_vertex(
         prim.local_rect,
         prim.local_clip_rect,
-        vec4(0.0),
+        vec4(1.0),
         prim.z,
         prim.layer,
         prim.task
@@ -854,20 +815,19 @@ float signed_distance_rect(vec2 pos, vec2 p0, vec2 p1) {
     return length(max(vec2(0.0), d)) + min(0.0, max(d.x, d.y));
 }
 
-vec2 init_transform_fs(vec3 local_pos, out float fragment_alpha) {
-    fragment_alpha = 1.0;
-    vec2 pos = local_pos.xy / local_pos.z;
-
-    // Now get the actual signed distance.
-    float d = signed_distance_rect(pos, vLocalBounds.xy, vLocalBounds.zw);
+float init_transform_fs(vec2 local_pos) {
+    // Get signed distance from local rect bounds.
+    float d = signed_distance_rect(
+        local_pos,
+        vLocalBounds.xy,
+        vLocalBounds.zw
+    );
 
     // Find the appropriate distance to apply the AA smoothstep over.
-    float aa_range = compute_aa_range(pos.xy);
+    float aa_range = compute_aa_range(local_pos);
 
     // Only apply AA to fragments outside the signed distance field.
-    fragment_alpha = distance_aa(aa_range, d);
-
-    return pos;
+    return distance_aa(aa_range, d);
 }
 #endif //WR_FEATURE_TRANSFORM
 
diff --git a/webrender/res/ps_border_corner.glsl b/webrender/res/ps_border_corner.glsl
index a86f1b443f..fa095b1e7d 100644
--- a/webrender/res/ps_border_corner.glsl
+++ b/webrender/res/ps_border_corner.glsl
@@ -24,11 +24,7 @@ flat varying float vIsBorderRadiusLessThanBorderWidth;
 // Border style
 flat varying float vAlphaSelect;
 
-#ifdef WR_FEATURE_TRANSFORM
-varying vec3 vLocalPos;
-#else
 varying vec2 vLocalPos;
-#endif
 
 #ifdef WR_VERTEX_SHADER
 // Matches BorderCornerSide enum in border.rs
@@ -302,12 +298,12 @@ void main(void) {
     segment_rect.size = p1 - p0;
 
 #ifdef WR_FEATURE_TRANSFORM
-    TransformVertexInfo vi = write_transform_vertex(segment_rect,
-                                                    prim.local_clip_rect,
-                                                    vec4(1.0),
-                                                    prim.z,
-                                                    prim.layer,
-                                                    prim.task);
+    VertexInfo vi = write_transform_vertex(segment_rect,
+                                           prim.local_clip_rect,
+                                           vec4(1.0),
+                                           prim.z,
+                                           prim.layer,
+                                           prim.task);
 #else
     VertexInfo vi = write_vertex(segment_rect,
                                  prim.local_clip_rect,
@@ -326,15 +322,12 @@ void main(void) {
 void main(void) {
     float alpha = 1.0;
 #ifdef WR_FEATURE_TRANSFORM
-    alpha = 0.0;
-    vec2 local_pos = init_transform_fs(vLocalPos, alpha);
-#else
-    vec2 local_pos = vLocalPos;
+    alpha = init_transform_fs(vLocalPos);
 #endif
 
     alpha *= do_clip();
 
-    float aa_range = compute_aa_range(local_pos);
+    float aa_range = compute_aa_range(vLocalPos);
 
     float distance_for_color;
     float color_mix_factor;
@@ -343,8 +336,8 @@ void main(void) {
     // necessary for correctness when the border width is greater
     // than the border radius.
     if (vIsBorderRadiusLessThanBorderWidth == 0.0 ||
-        all(lessThan(local_pos * vClipSign, vClipCenter * vClipSign))) {
-        vec2 p = local_pos - vClipCenter;
+        all(lessThan(vLocalPos * vClipSign, vClipCenter * vClipSign))) {
+        vec2 p = vLocalPos - vClipCenter;
 
         // The coordinate system is snapped to pixel boundaries. To sample the distance,
         // however, we are interested in the center of the pixels which introduces an
@@ -382,8 +375,8 @@ void main(void) {
         // greater than border radius.
 
         // Get linear distances along horizontal and vertical edges.
-        vec2 d0 = vClipSign.xx * (local_pos.xx - vEdgeDistance.xz);
-        vec2 d1 = vClipSign.yy * (local_pos.yy - vEdgeDistance.yw);
+        vec2 d0 = vClipSign.xx * (vLocalPos.xx - vEdgeDistance.xz);
+        vec2 d1 = vClipSign.yy * (vLocalPos.yy - vEdgeDistance.yw);
         // Apply union to get the outer edge signed distance.
         float da = min(d0.x, d1.x);
         // Apply intersection to get the inner edge signed distance.
@@ -406,7 +399,7 @@ void main(void) {
 
     // Select color based on side of line. Get distance from the
     // reference line, and then apply AA along the edge.
-    float ld = distance_to_line(vColorEdgeLine.xy, vColorEdgeLine.zw, local_pos);
+    float ld = distance_to_line(vColorEdgeLine.xy, vColorEdgeLine.zw, vLocalPos);
     float m = distance_aa(aa_range, -ld);
     vec4 color = mix(color0, color1, m);
 
diff --git a/webrender/res/ps_border_edge.glsl b/webrender/res/ps_border_edge.glsl
index 7aa371caa9..c88612bdbd 100644
--- a/webrender/res/ps_border_edge.glsl
+++ b/webrender/res/ps_border_edge.glsl
@@ -12,11 +12,7 @@ flat varying float vAlphaSelect;
 flat varying vec4 vClipParams;
 flat varying float vClipSelect;
 
-#ifdef WR_FEATURE_TRANSFORM
-varying vec3 vLocalPos;
-#else
 varying vec2 vLocalPos;
-#endif
 
 #ifdef WR_VERTEX_SHADER
 void write_edge_distance(float p0,
@@ -220,12 +216,12 @@ void main(void) {
     write_color1(color, style, color_flip);
 
 #ifdef WR_FEATURE_TRANSFORM
-    TransformVertexInfo vi = write_transform_vertex(segment_rect,
-                                                    prim.local_clip_rect,
-                                                    vec4(1.0),
-                                                    prim.z,
-                                                    prim.layer,
-                                                    prim.task);
+    VertexInfo vi = write_transform_vertex(segment_rect,
+                                           prim.local_clip_rect,
+                                           vec4(1.0),
+                                           prim.z,
+                                           prim.layer,
+                                           prim.task);
 #else
     VertexInfo vi = write_vertex(segment_rect,
                                  prim.local_clip_rect,
@@ -244,16 +240,13 @@ void main(void) {
 void main(void) {
     float alpha = 1.0;
 #ifdef WR_FEATURE_TRANSFORM
-    alpha = 0.0;
-    vec2 local_pos = init_transform_fs(vLocalPos, alpha);
-#else
-    vec2 local_pos = vLocalPos;
+    alpha = init_transform_fs(vLocalPos);
 #endif
 
     alpha *= do_clip();
 
     // Find the appropriate distance to apply the step over.
-    float aa_range = compute_aa_range(local_pos);
+    float aa_range = compute_aa_range(vLocalPos);
 
     // Applies the math necessary to draw a style: double
     // border. In the case of a solid border, the vertex
@@ -261,7 +254,7 @@ void main(void) {
     // no effect.
 
     // Select the x/y coord, depending on which axis this edge is.
-    vec2 pos = mix(local_pos.xy, local_pos.yx, vAxisSelect);
+    vec2 pos = mix(vLocalPos.xy, vLocalPos.yx, vAxisSelect);
 
     // Get signed distance from each of the inner edges.
     float d0 = pos.x - vEdgeDistance.x;
diff --git a/webrender/res/ps_gradient.glsl b/webrender/res/ps_gradient.glsl
index 71a9915edf..e843c25e80 100644
--- a/webrender/res/ps_gradient.glsl
+++ b/webrender/res/ps_gradient.glsl
@@ -6,11 +6,7 @@
 
 varying vec4 vColor;
 
-#ifdef WR_FEATURE_TRANSFORM
-varying vec3 vLocalPos;
-#else
-varying vec2 vPos;
-#endif
+varying vec2 vLocalPos;
 
 #ifdef WR_VERTEX_SHADER
 void main(void) {
@@ -71,12 +67,12 @@ void main(void) {
     }
 
 #ifdef WR_FEATURE_TRANSFORM
-    TransformVertexInfo vi = write_transform_vertex(segment_rect,
-                                                    prim.local_clip_rect,
-                                                    vec4(1.0),
-                                                    prim.z,
-                                                    prim.layer,
-                                                    prim.task);
+    VertexInfo vi = write_transform_vertex(segment_rect,
+                                           prim.local_clip_rect,
+                                           vec4(1.0),
+                                           prim.z,
+                                           prim.layer,
+                                           prim.task);
     vLocalPos = vi.local_pos;
     vec2 f = (vi.local_pos.xy - prim.local_rect.p0) / prim.local_rect.size;
 #else
@@ -88,7 +84,7 @@ void main(void) {
                                  prim.local_rect);
 
     vec2 f = (vi.local_pos - segment_rect.p0) / segment_rect.size;
-    vPos = vi.local_pos;
+    vLocalPos = vi.local_pos;
 #endif
 
     write_clip(vi.screen_pos, prim.clip_area);
@@ -100,11 +96,9 @@ void main(void) {
 #ifdef WR_FRAGMENT_SHADER
 void main(void) {
 #ifdef WR_FEATURE_TRANSFORM
-    float alpha = 0.0;
-    vec2 local_pos = init_transform_fs(vLocalPos, alpha);
+    float alpha = init_transform_fs(vLocalPos);
 #else
     float alpha = 1.0;
-    vec2 local_pos = vPos;
 #endif
 
     alpha *= do_clip();
diff --git a/webrender/res/ps_image.glsl b/webrender/res/ps_image.glsl
index e2c5c742e2..cfff1c3162 100644
--- a/webrender/res/ps_image.glsl
+++ b/webrender/res/ps_image.glsl
@@ -14,11 +14,10 @@ flat varying vec4 vStRect;        // Rectangle of valid texture rect.
 flat varying float vLayer;
 
 #ifdef WR_FEATURE_TRANSFORM
-varying vec3 vLocalPos;
 flat varying vec4 vLocalRect;
-#else
-varying vec2 vLocalPos;
 #endif
+
+varying vec2 vLocalPos;
 flat varying vec2 vStretchSize;
 
 #ifdef WR_VERTEX_SHADER
@@ -28,7 +27,7 @@ void main(void) {
     ImageResource res = fetch_image_resource(prim.user_data0);
 
 #ifdef WR_FEATURE_TRANSFORM
-    TransformVertexInfo vi = write_transform_vertex_primitive(prim);
+    VertexInfo vi = write_transform_vertex_primitive(prim);
     vLocalPos = vi.local_pos;
     vLocalRect = vec4(prim.local_rect.p0, prim.local_rect.p0 + prim.local_rect.size);
 #else
@@ -81,13 +80,12 @@ void main(void) {
 #ifdef WR_FRAGMENT_SHADER
 void main(void) {
 #ifdef WR_FEATURE_TRANSFORM
-    float alpha = 0.0;
-    vec2 pos = init_transform_fs(vLocalPos, alpha);
+    float alpha = init_transform_fs(vLocalPos);
 
     // We clamp the texture coordinate calculation here to the local rectangle boundaries,
     // which makes the edge of the texture stretch instead of repeat.
-    vec2 upper_bound_mask = step(vLocalRect.zw, pos);
-    vec2 relative_pos_in_rect = clamp(pos, vLocalRect.xy, vLocalRect.zw) - vLocalRect.xy;
+    vec2 upper_bound_mask = step(vLocalRect.zw, vLocalPos);
+    vec2 relative_pos_in_rect = clamp(vLocalPos, vLocalRect.xy, vLocalRect.zw) - vLocalRect.xy;
 #else
     float alpha = 1.0;
     vec2 relative_pos_in_rect = vLocalPos;
diff --git a/webrender/res/ps_line.glsl b/webrender/res/ps_line.glsl
index fe6c3ffda0..d583d52785 100644
--- a/webrender/res/ps_line.glsl
+++ b/webrender/res/ps_line.glsl
@@ -10,11 +10,7 @@ flat varying float vAxisSelect;
 flat varying vec4 vParams;
 flat varying vec2 vLocalOrigin;
 
-#ifdef WR_FEATURE_TRANSFORM
-varying vec3 vLocalPos;
-#else
 varying vec2 vLocalPos;
-#endif
 
 #ifdef WR_VERTEX_SHADER
 #define LINE_ORIENTATION_VERTICAL       0
@@ -113,7 +109,7 @@ void main(void) {
     vColor = line.color;
 
     #ifdef WR_FEATURE_TRANSFORM
-        TransformVertexInfo vi = write_transform_vertex_primitive(prim);
+        VertexInfo vi = write_transform_vertex_primitive(prim);
     #else
         VertexInfo vi = write_vertex(prim.local_rect,
                                      prim.local_clip_rect,
@@ -167,14 +163,12 @@ float approx_distance(vec2 p, vec2 b0, vec2 b1, vec2 b2) {
 void main(void) {
     float alpha = 1.0;
 
-#ifdef WR_FEATURE_CACHE
     vec2 local_pos = vLocalPos;
+
+#ifdef WR_FEATURE_CACHE
 #else
     #ifdef WR_FEATURE_TRANSFORM
-        alpha = 0.0;
-        vec2 local_pos = init_transform_fs(vLocalPos, alpha);
-    #else
-        vec2 local_pos = vLocalPos;
+        alpha = init_transform_fs(vLocalPos);
     #endif
 
         alpha *= do_clip();
diff --git a/webrender/res/ps_rectangle.glsl b/webrender/res/ps_rectangle.glsl
index 7b4efb9ee0..02e6fd9c3f 100644
--- a/webrender/res/ps_rectangle.glsl
+++ b/webrender/res/ps_rectangle.glsl
@@ -7,7 +7,7 @@
 varying vec4 vColor;
 
 #ifdef WR_FEATURE_TRANSFORM
-varying vec3 vLocalPos;
+varying vec2 vLocalPos;
 #endif
 
 #ifdef WR_VERTEX_SHADER
@@ -16,12 +16,12 @@ void main(void) {
     Rectangle rect = fetch_rectangle(prim.specific_prim_address);
     vColor = rect.color;
 #ifdef WR_FEATURE_TRANSFORM
-    TransformVertexInfo vi = write_transform_vertex(prim.local_rect,
-                                                    prim.local_clip_rect,
-                                                    rect.edge_aa_segment_mask,
-                                                    prim.z,
-                                                    prim.layer,
-                                                    prim.task);
+    VertexInfo vi = write_transform_vertex(prim.local_rect,
+                                           prim.local_clip_rect,
+                                           rect.edge_aa_segment_mask,
+                                           prim.z,
+                                           prim.layer,
+                                           prim.task);
     vLocalPos = vi.local_pos;
 #else
     VertexInfo vi = write_vertex(prim.local_rect,
@@ -42,8 +42,7 @@ void main(void) {
 void main(void) {
     float alpha = 1.0;
 #ifdef WR_FEATURE_TRANSFORM
-    alpha = 0.0;
-    init_transform_fs(vLocalPos, alpha);
+    alpha = init_transform_fs(vLocalPos);
 #endif
 
 #ifdef WR_FEATURE_CLIP
diff --git a/webrender/res/ps_yuv_image.glsl b/webrender/res/ps_yuv_image.glsl
index a4bbed9720..a82ea142f6 100644
--- a/webrender/res/ps_yuv_image.glsl
+++ b/webrender/res/ps_yuv_image.glsl
@@ -18,12 +18,11 @@ flat varying vec2 vHalfTexelUv;    // Normalized length of the half of u and v t
 flat varying vec3 vLayers;
 
 #ifdef WR_FEATURE_TRANSFORM
-varying vec3 vLocalPos;
 flat varying vec4 vLocalRect;
-#else
-varying vec2 vLocalPos;
 #endif
 
+varying vec2 vLocalPos;
+
 #ifdef WR_VERTEX_SHADER
 struct YuvImage {
     vec2 size;
@@ -37,7 +36,7 @@ YuvImage fetch_yuv_image(int address) {
 void main(void) {
     Primitive prim = load_primitive();
 #ifdef WR_FEATURE_TRANSFORM
-    TransformVertexInfo vi = write_transform_vertex_primitive(prim);
+    VertexInfo vi = write_transform_vertex_primitive(prim);
     vLocalPos = vi.local_pos;
     vLocalRect = vec4(prim.local_rect.p0, prim.local_rect.p0 + prim.local_rect.size);
 #else
@@ -146,12 +145,11 @@ const mat3 YuvColorMatrix = mat3(
 
 void main(void) {
 #ifdef WR_FEATURE_TRANSFORM
-    float alpha = 0.0;
-    vec2 pos = init_transform_fs(vLocalPos, alpha);
+    float alpha = init_transform_fs(vLocalPos);
 
     // We clamp the texture coordinate calculation here to the local rectangle boundaries,
     // which makes the edge of the texture stretch instead of repeat.
-    vec2 relative_pos_in_rect = clamp(pos, vLocalRect.xy, vLocalRect.zw) - vLocalRect.xy;
+    vec2 relative_pos_in_rect = clamp(vLocalPos, vLocalRect.xy, vLocalRect.zw) - vLocalRect.xy;
 #else
     float alpha = 1.0;;
     vec2 relative_pos_in_rect = vLocalPos;
diff --git a/wrench/reftests/transforms/local-clip.png b/wrench/reftests/transforms/local-clip.png
index 55d7070dbb..9268dc160e 100644
Binary files a/wrench/reftests/transforms/local-clip.png and b/wrench/reftests/transforms/local-clip.png differ
diff --git a/wrench/reftests/transforms/perspective.png b/wrench/reftests/transforms/perspective.png
index a80bc495fb..65e0b29e74 100644
Binary files a/wrench/reftests/transforms/perspective.png and b/wrench/reftests/transforms/perspective.png differ
diff --git a/wrench/reftests/transforms/reftest.list b/wrench/reftests/transforms/reftest.list
index 4e120bc405..b0d3429f47 100644
--- a/wrench/reftests/transforms/reftest.list
+++ b/wrench/reftests/transforms/reftest.list
@@ -3,6 +3,6 @@
 == image-rotated-clip.yaml image-rotated-clip.png
 # Something leaks the state: the test passes if only run `reftest reftests/transform`
 # but fails when all the tests are run
-fuzzy(1,1) == rotated-image.yaml rotated-image.png
+fuzzy(1,2) == rotated-image.yaml rotated-image.png
 == singular.yaml singular-ref.yaml
 fuzzy(1,41) == perspective.yaml perspective.png
diff --git a/wrench/reftests/transforms/rotated-clip.png b/wrench/reftests/transforms/rotated-clip.png
index 9c68cac5f7..b3994d6916 100644
Binary files a/wrench/reftests/transforms/rotated-clip.png and b/wrench/reftests/transforms/rotated-clip.png differ
diff --git a/wrench/reftests/transforms/rotated-image.png b/wrench/reftests/transforms/rotated-image.png
index 51733c74f8..fc0958fd80 100644
Binary files a/wrench/reftests/transforms/rotated-image.png and b/wrench/reftests/transforms/rotated-image.png differ