Backed out changeset 616bd23b9896 (bug 1391145) for frequently failing mochitests layout/style/test/test_animations.html and layout/style/test/test_animations_omta.html on Linux x64. r=backout

Backs out https://github.com/servo/servo/pull/18492

4 files changed, 20 insertions, 198 deletions

diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index 45a6bbebc21..0b5f2972c20 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -3084,17 +3084,8 @@ fn static_assert() {
                 ${transform_function_arm("MatrixWithPercents", "matrix3d", ["number"] * 12 + ["lop"] * 2
                                          + ["length"] + ["number"])}
                 ${transform_function_arm("Skew", "skew", ["angle"] * 2)}
-                ${transform_function_arm("TranslateX", "translatex", ["lop"])}
-                ${transform_function_arm("TranslateY", "translatey", ["lop"])}
-                ${transform_function_arm("TranslateZ", "translatez", ["length"])}
                 ${transform_function_arm("Translate", "translate3d", ["lop", "lop", "length"])}
-                ${transform_function_arm("ScaleX", "scalex", ["number"])}
-                ${transform_function_arm("ScaleY", "scaley", ["number"])}
-                ${transform_function_arm("ScaleZ", "scalez", ["number"])}
                 ${transform_function_arm("Scale", "scale3d", ["number"] * 3)}
-                ${transform_function_arm("RotateX", "rotatex", ["angle"])}
-                ${transform_function_arm("RotateY", "rotatey", ["angle"])}
-                ${transform_function_arm("RotateZ", "rotatez", ["angle"])}
                 ${transform_function_arm("Rotate", "rotate3d", ["number"] * 3 + ["angle"])}
                 ${transform_function_arm("Perspective", "perspective", ["length"])}
                 ${transform_function_arm("InterpolateMatrix", "interpolatematrix",
@@ -3213,18 +3204,8 @@ fn static_assert() {
             match transform_function {
                 ${computed_operation_arm("Matrix", "matrix3d", ["number"] * 16)}
                 ${computed_operation_arm("Skew", "skew", ["angle"] * 2)}
-
-                ${computed_operation_arm("TranslateX", "translatex", ["lop"])}
-                ${computed_operation_arm("TranslateY", "translatey", ["lop"])}
-                ${computed_operation_arm("TranslateZ", "translatez", ["length"])}
                 ${computed_operation_arm("Translate", "translate3d", ["lop", "lop", "length"])}
-                ${computed_operation_arm("ScaleX", "scalex", ["number"])}
-                ${computed_operation_arm("ScaleY", "scaley", ["number"])}
-                ${computed_operation_arm("ScaleZ", "scalez", ["number"])}
                 ${computed_operation_arm("Scale", "scale3d", ["number"] * 3)}
-                ${computed_operation_arm("RotateX", "rotatex", ["angle"])}
-                ${computed_operation_arm("RotateY", "rotatey", ["angle"])}
-                ${computed_operation_arm("RotateZ", "rotatez", ["angle"])}
                 ${computed_operation_arm("Rotate", "rotate3d", ["number"] * 3 + ["angle"])}
                 ${computed_operation_arm("Perspective", "perspective", ["length"])}
                 ${computed_operation_arm("InterpolateMatrix", "interpolatematrix",
diff --git a/components/style/properties/helpers/animated_properties.mako.rs b/components/style/properties/helpers/animated_properties.mako.rs
index a2f6d57e1e3..29ccd1d2560 100644
--- a/components/style/properties/helpers/animated_properties.mako.rs
+++ b/components/style/properties/helpers/animated_properties.mako.rs
@@ -1183,21 +1183,6 @@ impl ToAnimatedZero for TransformOperation {
                     sy.to_animated_zero()?,
                 ))
             },
-            TransformOperation::TranslateX(ref tx) => {
-                Ok(TransformOperation::TranslateX(
-                    tx.to_animated_zero()?
-                ))
-            },
-            TransformOperation::TranslateY(ref ty) => {
-                Ok(TransformOperation::TranslateY(
-                    ty.to_animated_zero()?
-                ))
-            },
-            TransformOperation::TranslateZ(ref tz) => {
-                Ok(TransformOperation::TranslateZ(
-                    tz.to_animated_zero()?
-                ))
-            },
             TransformOperation::Translate(ref tx, ref ty, ref tz) => {
                 Ok(TransformOperation::Translate(
                     tx.to_animated_zero()?,
@@ -1208,12 +1193,6 @@ impl ToAnimatedZero for TransformOperation {
             TransformOperation::Scale(..) => {
                 Ok(TransformOperation::Scale(1.0, 1.0, 1.0))
             },
-            TransformOperation::ScaleX(_) => Ok(TransformOperation::ScaleX(1.)),
-            TransformOperation::ScaleY(_) => Ok(TransformOperation::ScaleY(1.)),
-            TransformOperation::ScaleZ(_) => Ok(TransformOperation::ScaleZ(1.)),
-            TransformOperation::RotateX(_) => Ok(TransformOperation::RotateX(Angle::zero())),
-            TransformOperation::RotateY(_) => Ok(TransformOperation::RotateY(Angle::zero())),
-            TransformOperation::RotateZ(_) => Ok(TransformOperation::RotateZ(Angle::zero())),
             TransformOperation::Rotate(x, y, z, a) => {
                 let (x, y, z, _) = TransformList::get_normalized_vector_and_angle(x, y, z, a);
                 Ok(TransformOperation::Rotate(x, y, z, Angle::zero()))
@@ -1279,30 +1258,6 @@ impl Animate for TransformOperation {
                 ))
             },
             (
-                &TransformOperation::TranslateX(ref from),
-                &TransformOperation::TranslateX(ref to),
-            ) => {
-                Ok(TransformOperation::TranslateX(
-                    from.animate(to, procedure)?,
-                ))
-            },
-            (
-                &TransformOperation::TranslateY(ref from),
-                &TransformOperation::TranslateY(ref to),
-            ) => {
-                Ok(TransformOperation::TranslateY(
-                    from.animate(to, procedure)?,
-                ))
-            },
-            (
-                &TransformOperation::TranslateZ(ref from),
-                &TransformOperation::TranslateZ(ref to),
-            ) => {
-                Ok(TransformOperation::TranslateZ(
-                    from.animate(to, procedure)?,
-                ))
-            },
-            (
                 &TransformOperation::Scale(ref fx, ref fy, ref fz),
                 &TransformOperation::Scale(ref tx, ref ty, ref tz),
             ) => {
@@ -1313,48 +1268,6 @@ impl Animate for TransformOperation {
                 ))
             },
             (
-                &TransformOperation::ScaleX(ref from),
-                &TransformOperation::ScaleX(ref to),
-            ) => {
-                Ok(TransformOperation::ScaleX(
-                    animate_multiplicative_factor(*from, *to, procedure)?,
-                ))
-            },
-            (
-                &TransformOperation::ScaleY(ref from),
-                &TransformOperation::ScaleY(ref to),
-            ) => {
-                Ok(TransformOperation::ScaleY(
-                    animate_multiplicative_factor(*from, *to, procedure)?,
-                ))
-            },
-            (
-                &TransformOperation::ScaleZ(ref from),
-                &TransformOperation::ScaleZ(ref to),
-            ) => {
-                Ok(TransformOperation::ScaleZ(
-                    animate_multiplicative_factor(*from, *to, procedure)?,
-                ))
-            },
-            (
-                &TransformOperation::RotateX(ref from),
-                &TransformOperation::RotateX(ref to),
-            ) => {
-                Ok(TransformOperation::RotateX(from.animate(to, procedure)?))
-            },
-            (
-                &TransformOperation::RotateY(ref from),
-                &TransformOperation::RotateY(ref to),
-            ) => {
-                Ok(TransformOperation::RotateY(from.animate(to, procedure)?))
-            },
-            (
-                &TransformOperation::RotateZ(ref from),
-                &TransformOperation::RotateZ(ref to),
-            ) => {
-                Ok(TransformOperation::RotateZ(from.animate(to, procedure)?))
-            },
-            (
                 &TransformOperation::Rotate(fx, fy, fz, fa),
                 &TransformOperation::Rotate(tx, ty, tz, ta),
             ) => {
diff --git a/components/style/properties/longhand/box.mako.rs b/components/style/properties/longhand/box.mako.rs
index ef97818ab11..12f229b3af6 100644
--- a/components/style/properties/longhand/box.mako.rs
+++ b/components/style/properties/longhand/box.mako.rs
@@ -717,19 +717,10 @@ ${helpers.predefined_type(
             // For `-moz-transform` matrix and matrix3d.
             MatrixWithPercents(ComputedMatrixWithPercents),
             Skew(computed::Angle, computed::Angle),
-            TranslateX(LengthOrPercentage),
-            TranslateY(LengthOrPercentage),
-            TranslateZ(Length),
             Translate(computed::LengthOrPercentage,
                       computed::LengthOrPercentage,
                       computed::Length),
-            ScaleX(CSSFloat),
-            ScaleY(CSSFloat),
-            ScaleZ(CSSFloat),
             Scale(CSSFloat, CSSFloat, CSSFloat),
-            RotateX(computed::Angle),
-            RotateY(computed::Angle),
-            RotateZ(computed::Angle),
             Rotate(CSSFloat, CSSFloat, CSSFloat, computed::Angle),
             Perspective(computed::Length),
             // For mismatched transform lists.
@@ -1308,15 +1299,24 @@ ${helpers.predefined_type(
                     }
                     SpecifiedOperation::TranslateX(ref tx) => {
                         let tx = tx.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::TranslateX(tx));
+                        result.push(computed_value::ComputedOperation::Translate(
+                            tx,
+                            computed::length::LengthOrPercentage::zero(),
+                            computed::length::Length::new(0.)));
                     }
                     SpecifiedOperation::TranslateY(ref ty) => {
                         let ty = ty.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::TranslateY(ty));
+                        result.push(computed_value::ComputedOperation::Translate(
+                            computed::length::LengthOrPercentage::zero(),
+                            ty,
+                            computed::length::Length::new(0.)));
                     }
                     SpecifiedOperation::TranslateZ(ref tz) => {
                         let tz = tz.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::TranslateZ(tz));
+                        result.push(computed_value::ComputedOperation::Translate(
+                            computed::length::LengthOrPercentage::zero(),
+                            computed::length::LengthOrPercentage::zero(),
+                            tz));
                     }
                     SpecifiedOperation::Translate3D(ref tx, ref ty, ref tz) => {
                         let tx = tx.to_computed_value(context);
@@ -1335,15 +1335,15 @@ ${helpers.predefined_type(
                     }
                     SpecifiedOperation::ScaleX(sx) => {
                         let sx = sx.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::ScaleX(sx));
+                        result.push(computed_value::ComputedOperation::Scale(sx, 1.0, 1.0));
                     }
                     SpecifiedOperation::ScaleY(sy) => {
                         let sy = sy.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::ScaleY(sy));
+                        result.push(computed_value::ComputedOperation::Scale(1.0, sy, 1.0));
                     }
                     SpecifiedOperation::ScaleZ(sz) => {
                         let sz = sz.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::ScaleZ(sz));
+                        result.push(computed_value::ComputedOperation::Scale(1.0, 1.0, sz));
                     }
                     SpecifiedOperation::Scale3D(sx, sy, sz) => {
                         let sx = sx.to_computed_value(context);
@@ -1357,15 +1357,15 @@ ${helpers.predefined_type(
                     }
                     SpecifiedOperation::RotateX(theta) => {
                         let theta = theta.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::RotateX(theta));
+                        result.push(computed_value::ComputedOperation::Rotate(1.0, 0.0, 0.0, theta));
                     }
                     SpecifiedOperation::RotateY(theta) => {
                         let theta = theta.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::RotateY(theta));
+                        result.push(computed_value::ComputedOperation::Rotate(0.0, 1.0, 0.0, theta));
                     }
                     SpecifiedOperation::RotateZ(theta) => {
                         let theta = theta.to_computed_value(context);
-                        result.push(computed_value::ComputedOperation::RotateZ(theta));
+                        result.push(computed_value::ComputedOperation::Rotate(0.0, 0.0, 1.0, theta));
                     }
                     SpecifiedOperation::Rotate3D(ax, ay, az, theta) => {
                         let ax = ax.to_computed_value(context);
@@ -1460,54 +1460,20 @@ ${helpers.predefined_type(
                                 m44: Number::from_computed_value(&computed.m44),
                             });
                         }
-                        computed_value::ComputedOperation::TranslateX(ref tx) => {
-                            result.push(SpecifiedOperation::TranslateX(
-                                              ToComputedValue::from_computed_value(tx)));
-                        }
-                        computed_value::ComputedOperation::TranslateY(ref ty) => {
-                            result.push(SpecifiedOperation::TranslateY(
-                                              ToComputedValue::from_computed_value(ty)));
-                        }
-                        computed_value::ComputedOperation::TranslateZ(ref tz) => {
-                            result.push(SpecifiedOperation::TranslateZ(
-                                              ToComputedValue::from_computed_value(tz)));
-                        }
                         computed_value::ComputedOperation::Translate(ref tx, ref ty, ref tz) => {
+                            // XXXManishearth we lose information here; perhaps we should try to
+                            // recover the original function? Not sure if this can be observed.
                             result.push(SpecifiedOperation::Translate3D(
                                               ToComputedValue::from_computed_value(tx),
                                               ToComputedValue::from_computed_value(ty),
                                               ToComputedValue::from_computed_value(tz)));
                         }
-                        computed_value::ComputedOperation::ScaleX(ref sx) => {
-                            result.push(SpecifiedOperation::ScaleX(
-                                              ToComputedValue::from_computed_value(sx)));
-                        }
-                        computed_value::ComputedOperation::ScaleY(ref sy) => {
-                            result.push(SpecifiedOperation::ScaleY(
-                                              ToComputedValue::from_computed_value(sy)));
-                        }
-                        computed_value::ComputedOperation::ScaleZ(ref sz) => {
-                            result.push(SpecifiedOperation::ScaleZ(
-                                              ToComputedValue::from_computed_value(sz)));
-                        }
                         computed_value::ComputedOperation::Scale(ref sx, ref sy, ref sz) => {
                             result.push(SpecifiedOperation::Scale3D(
                                     Number::from_computed_value(sx),
                                     Number::from_computed_value(sy),
                                     Number::from_computed_value(sz)));
                         }
-                        computed_value::ComputedOperation::RotateX(ref rx) => {
-                            result.push(SpecifiedOperation::RotateX(
-                                              ToComputedValue::from_computed_value(rx)));
-                        }
-                        computed_value::ComputedOperation::RotateY(ref ry) => {
-                            result.push(SpecifiedOperation::RotateY(
-                                              ToComputedValue::from_computed_value(ry)));
-                        }
-                        computed_value::ComputedOperation::RotateZ(ref rz) => {
-                            result.push(SpecifiedOperation::RotateZ(
-                                              ToComputedValue::from_computed_value(rz)));
-                        }
                         computed_value::ComputedOperation::Rotate(ref ax, ref ay, ref az, ref theta) => {
                             result.push(SpecifiedOperation::Rotate3D(
                                     Number::from_computed_value(ax),
diff --git a/components/style/values/computed/transform.rs b/components/style/values/computed/transform.rs
index 90d9459e700..21c98c50d99 100644
--- a/components/style/values/computed/transform.rs
+++ b/components/style/values/computed/transform.rs
@@ -80,18 +80,6 @@ impl TransformList {
 
         for operation in list {
             let matrix = match *operation {
-                ComputedOperation::RotateX(theta) => {
-                    let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians());
-                    Transform3D::create_rotation(1., 0., 0., theta.into())
-                }
-                ComputedOperation::RotateY(theta) => {
-                    let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians());
-                    Transform3D::create_rotation(0., 1., 0., theta.into())
-                }
-                ComputedOperation::RotateZ(theta) => {
-                    let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians());
-                    Transform3D::create_rotation(0., 0., 1., theta.into())
-                }
                 ComputedOperation::Rotate(ax, ay, az, theta) => {
                     let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians());
                     let (ax, ay, az, theta) =
@@ -101,35 +89,9 @@ impl TransformList {
                 ComputedOperation::Perspective(d) => {
                     Self::create_perspective_matrix(d.px())
                 }
-                ComputedOperation::ScaleX(sx) => {
-                    Transform3D::create_scale(sx, 1., 1.)
-                }
-                ComputedOperation::ScaleY(sy) => {
-                    Transform3D::create_scale(1., sy, 1.)
-                }
-                ComputedOperation::ScaleZ(sz) => {
-                    Transform3D::create_scale(1., 1., sz)
-                }
                 ComputedOperation::Scale(sx, sy, sz) => {
                     Transform3D::create_scale(sx, sy, sz)
                 }
-                ComputedOperation::TranslateX(tx) => {
-                    let tx =  match reference_box {
-                        Some(relative_border_box) => tx.to_used_value(relative_border_box.size.width).to_f32_px(),
-                        None => extract_pixel_length(&tx),
-                    };
-                    Transform3D::create_translation(tx, 0., 0.)
-                }
-                ComputedOperation::TranslateY(ty) => {
-                    let ty =  match reference_box {
-                        Some(relative_border_box) => ty.to_used_value(relative_border_box.size.height).to_f32_px(),
-                        None => extract_pixel_length(&ty),
-                    };
-                    Transform3D::create_translation(0., ty, 0.)
-                }
-                ComputedOperation::TranslateZ(tz) => {
-                    Transform3D::create_translation(0., 0., tz.px())
-                }
                 ComputedOperation::Translate(tx, ty, tz) => {
                     let (tx, ty) = match reference_box {
                         Some(relative_border_box) => {