tree a1643deb82acb8f8fdf5c6df25d9a4d223ee139d
parent ce0bf874e7ebc061fce1555dd646e253f51d065d
author Javier Fernandez <jfernandez@igalia.com> 1524218626 +0000
committer Commit Bot <commit-bot@chromium.org> 1524218626 +0000

[css-align] Simple syntax for the Alignment shorthands

Now that the issue [1] about the syntax ambiguity has been resolved we
don´t need to use the custom syntax anymore. The Alignment shorthands
use now the simple syntax, defined based on the longhands' syntax.

Since we allow all the values valid for each longhand, we'll update
in this CL the corresponding web platform tests. Additionally, this CL
updates also the shorthand serialization tests [2], which didn't
consider the new value 'legacy' for justify-items (and place-items) due
to the bug [3] Firefox still has pending to be fixed.


[1] https://github.com/w3c/csswg-drafts/issues/1001
[2] css/css-align/default-alignment/shorthand-serialization-001.html
[3] https://bugzilla.mozilla.org/show_bug.cgi?id=1363875

Bug: 832503, 829806
Change-Id: I53f803b384cc55b0b38292540262e54f803586da
Reviewed-on: https://chromium-review.googlesource.com/1013710
Commit-Queue: Javier Fernandez <jfernandez@igalia.com>
Reviewed-by: Rune Lillesveen <futhark@chromium.org>
Reviewed-by: Manuel Rego Casasnovas <rego@igalia.com>
Cr-Original-Commit-Position: refs/heads/master@{#552293}
Cr-Mirrored-From: https://chromium.googlesource.com/chromium/src
Cr-Mirrored-Commit: 3afa6045ecc3baf120c4436238807c063e5bf7a5