Don't use post multiplication on transforms with compatible pairs of operations

Don't use matrix decomposation on transform list interpolations with compatible pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms

This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and more closely match
Firefox's behaviour. Firefox falls back to post multiplication
whenever mismatched rotate functions are blended which does not match
spec text.
Filed Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1322189

BUG=619616
Committed: https://crrev.com/a5df6c6cf9b46d62121f92e5e4161058877c7051
Cr-Commit-Position: refs/heads/master@{#436845}

[alancutter (OOO until 2018), 2016-11-23 00:47:18]

Description was changed from

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms
This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation.

This patch updates our code to match the spec and Firefox's behaviour.

BUG=618157
==========

to

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms
This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and Firefox's behaviour.

BUG=618157
==========

[alancutter (OOO until 2018), 2016-11-23 00:47:18]

alancutter@chromium.org changed reviewers:
+ jbroman@chromium.org

[alancutter (OOO until 2018), 2016-11-23 00:48:20]

Description was changed from

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms
This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and Firefox's behaviour.

BUG=618157
==========

to

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms
This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and Firefox's behaviour.

BUG=619616
==========

[jbroman, 2016-11-23 16:52:57]

Does this cover all cases? It would be nice to also see test cases for the other
groups (e.g. rotation).

For instance, by inspection it looks like RotateTransformOperation doesn't
permit the rotation types to blend, but from the spec reference you linked, it
seems like they should (e.g. rotateX and rotateY share the rotate3D primitive).

[alancutter (OOO until 2018), 2016-12-06 00:46:24]

Description was changed from

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms
This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and Firefox's behaviour.

BUG=619616
==========

to

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms

This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and more closely match
Firefox's behaviour. Firefox falls back to post multiplication
whenever mismatched rotate functions are blended which does not match
spec text.

BUG=619616
==========

[alancutter (OOO until 2018), 2016-12-06 01:01:57]

Description was changed from

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms

This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and more closely match
Firefox's behaviour. Firefox falls back to post multiplication
whenever mismatched rotate functions are blended which does not match
spec text.

BUG=619616
==========

to

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms

This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and more closely match
Firefox's behaviour. Firefox falls back to post multiplication
whenever mismatched rotate functions are blended which does not match
spec text.
Filed Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1322189

BUG=619616
==========

[alancutter (OOO until 2018), 2016-12-06 01:02:50]

On 2016/11/23 at 16:52:57, jbroman wrote:
> Does this cover all cases? It would be nice to also see test cases for the
other groups (e.g. rotation).
> 
> For instance, by inspection it looks like RotateTransformOperation doesn't
permit the rotation types to blend, but from the spec reference you linked, it
seems like they should (e.g. rotateX and rotateY share the rotate3D primitive).

Thanks for catching that, rewrote the patch to align with the spec's idea of
primitive types.
Added a better test case.

[alancutter (OOO until 2018), 2016-12-06 01:09:51]

The CQ bit was checked by alancutter@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-12-06 01:10:16]

Dry run: CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[jbroman, 2016-12-06 15:18:29]

lgtm, thanks

[alancutter (OOO until 2018), 2016-12-06 22:54:25]

The CQ bit was checked by alancutter@chromium.org

[commit-bot: I haz the power, 2016-12-06 22:55:24]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-12-07 02:41:34]

CQ is committing da patch.

Bot data: {"patchset_id": 40001, "attempt_start_ts": 1481064865808390,
"parent_rev": "5270b9b7b213b43b979ff6a61fccebfc28386b65", "commit_rev":
"7a81fa605a7d50d5c49bf7286a85d23f3ca9c0b2"}

[commit-bot: I haz the power, 2016-12-07 02:42:06]

Committed patchset #3 (id:40001)

[commit-bot: I haz the power, 2016-12-07 02:45:46]

Description was changed from

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms

This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and more closely match
Firefox's behaviour. Firefox falls back to post multiplication
whenever mismatched rotate functions are blended which does not match
spec text.
Filed Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1322189

BUG=619616
==========

to

==========
Don't use matrix decomposation on transform list interpolations with compatible
pairs of operations

The existing code required transform lists to have identical pairs of
operation types in order to do pairwise interpolation instead of
matrix decomposition.

The transform spec states that each pair must have the same name or
be a derivation of the same primitive.
https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms

This permits pairs like scaleX and scaleY to be compatible while our
existing code would reject them and fall back to decomposition
interpolation. This difference in behaviour is usually only noticable
when one side of the interpolation is non-invertable.

This patch updates our code to match the spec and more closely match
Firefox's behaviour. Firefox falls back to post multiplication
whenever mismatched rotate functions are blended which does not match
spec text.
Filed Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1322189

BUG=619616

Committed: https://crrev.com/a5df6c6cf9b46d62121f92e5e4161058877c7051
Cr-Commit-Position: refs/heads/master@{#436845}
==========

[commit-bot: I haz the power, 2016-12-07 02:45:47]

Patchset 3 (id:??) landed as
https://crrev.com/a5df6c6cf9b46d62121f92e5e4161058877c7051
Cr-Commit-Position: refs/heads/master@{#436845}