mirror of
https://github.com/servo/servo.git
synced 2025-08-03 04:30:10 +01:00
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
This commit is contained in:
Gecko Backout
moz-servo-sync
parent
4c04ece8c5
commit
1aa0b20e09
4 changed files with 20 additions and 198 deletions
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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()))
|
||||
|
|
@ -1278,30 +1257,6 @@ impl Animate for TransformOperation {
|
|||
fz.animate(tz, procedure)?,
|
||||
))
|
||||
},
|
||||
(
|
||||
&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),
|
||||
|
|
@ -1312,48 +1267,6 @@ impl Animate for TransformOperation {
|
|||
animate_multiplicative_factor(*fz, *tz, procedure)?,
|
||||
))
|
||||
},
|
||||
(
|
||||
&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),
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
|
|
|
|||
|
|
@ -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) => {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue