Changeset 183748 in webkit


Ignore:
Timestamp:
May 4, 2015 10:25:21 AM (9 years ago)
Author:
jfernandez@igalia.com
Message:

[CSS Box Alignment] Upgrade justify-content parsing to CSS3 Box Alignment spec.
https://bugs.webkit.org/show_bug.cgi?id=144442

Reviewed by David Hyatt.

Upgrade the justify-content property to the last CSS3 Box
Alignment specification. It defines a different enumeration for
Positional and Distribution alignment, which requires changes in
the FlexibleBox implementation.

Source/WebCore:

A new parsing function has been implemented to replace the basic
keyword IDs validation. Because of the complexity of the new
values, a new CSSPrimitiveValue derived class has been defined
which simplifies considerably the parsing logic.

We will follow the same approach than for Self Alignment, defining
a single class to hold all the related alignment data. This makes
possible to use a StyleBuilderConverter function instead of custom
builder functions for these properties.

Test: css3/parse-justify-content.html

  • CMakeLists.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • css/CSSComputedStyleDeclaration.cpp:

(WebCore::resolveContentAlignmentAuto):
(WebCore::valueForContentPositionAndDistributionWithOverflowAlignment):
(WebCore::ComputedStyleExtractor::propertyValue):
(WebCore::valueForItemPositionWithOverflowAlignment): Deleted.

  • css/CSSContentDistributionValue.cpp: Added.

(WebCore::CSSContentDistributionValue::CSSContentDistributionValue):
(WebCore::CSSContentDistributionValue::~CSSContentDistributionValue):
(WebCore::CSSContentDistributionValue::customCSSText):
(WebCore::CSSContentDistributionValue::equals):

  • css/CSSContentDistributionValue.h: Added.

(WebCore::CSSContentDistributionValue::create):
(WebCore::CSSContentDistributionValue::distribution):
(WebCore::CSSContentDistributionValue::position):
(WebCore::CSSContentDistributionValue::overflow):

  • css/CSSParser.cpp:

(WebCore::isValidKeywordPropertyAndValue):
(WebCore::isKeywordPropertyID):
(WebCore::CSSParser::parseValue):
(WebCore::isContentDistributionKeyword):
(WebCore::isContentPositionKeyword):
(WebCore::isAlignmentOverflowKeyword):
(WebCore::CSSParser::parseContentDistributionOverflowPosition):
(WebCore::CSSParser::parseItemPositionOverflowPosition):
(WebCore::CSSParser::parseLegacyPosition): Deleted.

  • css/CSSParser.h:
  • css/CSSPrimitiveValueMappings.h:

(WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
(WebCore::CSSPrimitiveValue::operator ContentPosition):
(WebCore::CSSPrimitiveValue::operator ContentDistributionType):
(WebCore::CSSPrimitiveValue::operator EFlexDirection): Deleted.

  • css/CSSPropertyNames.in:
  • css/CSSValue.cpp:

(WebCore::CSSValue::equals):
(WebCore::CSSValue::cssText):
(WebCore::CSSValue::destroy):

  • css/CSSValue.h:

(WebCore::CSSValue::isContentDistributionValue):
(WebCore::CSSValue::isWebKitCSSFilterValue): Deleted.

  • css/CSSValueKeywords.in:
  • css/StyleBuilderConverter.h:

(WebCore::StyleBuilderConverter::convertContentAlignmentData):
(WebCore::StyleBuilderConverter::convertSelfOrDefaultAlignmentData): Deleted.

  • rendering/RenderFlexibleBox.cpp:

(WebCore::initialJustifyContentOffset):
(WebCore::justifyContentSpaceBetweenChildren):
(WebCore::RenderFlexibleBox::layoutAndPlaceChildren):
(WebCore::RenderFlexibleBox::layoutColumnReverse):

  • rendering/RenderFullScreen.cpp:

(WebCore::createFullScreenStyle):

  • rendering/mathml/RenderMathMLScripts.cpp:

(WebCore::RenderMathMLScripts::fixAnonymousStyleForSubSupPair):
(WebCore::RenderMathMLScripts::fixAnonymousStyles):

  • rendering/style/RenderStyle.h:
  • rendering/style/RenderStyleConstants.h:
  • rendering/style/StyleContentAlignmentData.h: Added.

(WebCore::StyleContentAlignmentData::StyleContentAlignmentData):
(WebCore::StyleContentAlignmentData::setPosition):
(WebCore::StyleContentAlignmentData::setDistribution):
(WebCore::StyleContentAlignmentData::setOverflow):
(WebCore::StyleContentAlignmentData::position):
(WebCore::StyleContentAlignmentData::distribution):
(WebCore::StyleContentAlignmentData::overflow):
(WebCore::StyleContentAlignmentData::operator==):
(WebCore::StyleContentAlignmentData::operator!=):

  • rendering/style/StyleRareNonInheritedData.cpp:

(WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
(WebCore::StyleRareNonInheritedData::operator==):

  • rendering/style/StyleRareNonInheritedData.h:

LayoutTests:

Some minor changes in some Flexbox related test cases for adapting
them to the new parsing logic. New layout tests, not Flexbox
specific, to verify the parsing of the new values.

  • css3/flexbox/css-properties.html:
  • css3/parse-justify-content-expected.txt: Added.
  • css3/parse-justify-content.html: Added.
Location:
trunk
Files:
5 added
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r183739 r183748  
     12015-05-04  Javier Fernandez  <jfernandez@igalia.com>
     2
     3        [CSS Box Alignment] Upgrade justify-content parsing to CSS3 Box Alignment spec.
     4        https://bugs.webkit.org/show_bug.cgi?id=144442
     5
     6        Reviewed by David Hyatt.
     7
     8        Upgrade the justify-content property to the last CSS3 Box
     9        Alignment specification. It defines a different enumeration for
     10        Positional and Distribution alignment, which requires changes in
     11        the FlexibleBox implementation.
     12
     13        Some minor changes in some Flexbox related test cases for adapting
     14        them to the new parsing logic. New layout tests, not Flexbox
     15        specific, to verify the parsing of the new values.
     16
     17        * css3/flexbox/css-properties.html:
     18        * css3/parse-justify-content-expected.txt: Added.
     19        * css3/parse-justify-content.html: Added.
     20
    1212015-05-04  Manuel Rego Casasnovas  <rego@igalia.com>
    222
  • trunk/LayoutTests/css3/flexbox/css-properties.html

    r182147 r183748  
    5252
    5353
     54flexbox.style.display = '-webkit-flex';
     55
    5456shouldBeEqualToString('flexbox.style.webkitJustifyContent', '');
    5557// The initial value is 'flex-start'.
     
    7880shouldBeEqualToString('flexbox.style.webkitJustifyContent', '');
    7981shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitJustifyContent', 'flex-start');
    80 
    81 flexbox.style.display = '-webkit-flex';
    8282
    8383shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');
  • trunk/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt

    r182613 r183748  
    152152flex-direction: row;
    153153flex-wrap: nowrap;
    154 justify-content: flex-start;
     154justify-content: start;
    155155justify-self: start;
    156156justify-items: start;
  • trunk/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt

    r182613 r183748  
    151151flex-direction: row
    152152flex-wrap: nowrap
    153 justify-content: flex-start
     153justify-content: auto
    154154justify-self: auto
    155155justify-items: auto
  • trunk/LayoutTests/svg/css/getComputedStyle-basic-expected.txt

    r182613 r183748  
    301301rect: style.getPropertyValue(flex-wrap) : nowrap
    302302rect: style.getPropertyCSSValue(flex-wrap) : [object CSSPrimitiveValue]
    303 rect: style.getPropertyValue(justify-content) : flex-start
    304 rect: style.getPropertyCSSValue(justify-content) : [object CSSPrimitiveValue]
     303rect: style.getPropertyValue(justify-content) : start
     304rect: style.getPropertyCSSValue(justify-content) : [object CSSValueList]
    305305rect: style.getPropertyValue(justify-self) : start
    306306rect: style.getPropertyCSSValue(justify-self) : [object CSSValueList]
     
    819819g: style.getPropertyValue(flex-wrap) : nowrap
    820820g: style.getPropertyCSSValue(flex-wrap) : [object CSSPrimitiveValue]
    821 g: style.getPropertyValue(justify-content) : flex-start
    822 g: style.getPropertyCSSValue(justify-content) : [object CSSPrimitiveValue]
     821g: style.getPropertyValue(justify-content) : start
     822g: style.getPropertyCSSValue(justify-content) : [object CSSValueList]
    823823g: style.getPropertyValue(justify-self) : start
    824824g: style.getPropertyCSSValue(justify-self) : [object CSSValueList]
  • trunk/Source/WebCore/CMakeLists.txt

    r183618 r183748  
    12421242    css/CSSCharsetRule.cpp
    12431243    css/CSSComputedStyleDeclaration.cpp
     1244    css/CSSContentDistributionValue.cpp
    12441245    css/CSSCrossfadeValue.cpp
    12451246    css/CSSCursorImageValue.cpp
  • trunk/Source/WebCore/ChangeLog

    r183747 r183748  
     12015-05-04  Javier Fernandez  <jfernandez@igalia.com>
     2
     3        [CSS Box Alignment] Upgrade justify-content parsing to CSS3 Box Alignment spec.
     4        https://bugs.webkit.org/show_bug.cgi?id=144442
     5
     6        Reviewed by David Hyatt.
     7
     8        Upgrade the justify-content property to the last CSS3 Box
     9        Alignment specification. It defines a different enumeration for
     10        Positional and Distribution alignment, which requires changes in
     11        the FlexibleBox implementation.
     12
     13        A new parsing function has been implemented to replace the basic
     14        keyword IDs validation. Because of the complexity of the new
     15        values, a new CSSPrimitiveValue derived class has been defined
     16        which simplifies considerably the parsing logic.
     17
     18        We will follow the same approach than for Self Alignment, defining
     19        a single class to hold all the related alignment data. This makes
     20        possible to use a StyleBuilderConverter function instead of custom
     21        builder functions for these properties.
     22
     23        Test: css3/parse-justify-content.html
     24
     25        * CMakeLists.txt:
     26        * WebCore.xcodeproj/project.pbxproj:
     27        * css/CSSComputedStyleDeclaration.cpp:
     28        (WebCore::resolveContentAlignmentAuto):
     29        (WebCore::valueForContentPositionAndDistributionWithOverflowAlignment):
     30        (WebCore::ComputedStyleExtractor::propertyValue):
     31        (WebCore::valueForItemPositionWithOverflowAlignment): Deleted.
     32        * css/CSSContentDistributionValue.cpp: Added.
     33        (WebCore::CSSContentDistributionValue::CSSContentDistributionValue):
     34        (WebCore::CSSContentDistributionValue::~CSSContentDistributionValue):
     35        (WebCore::CSSContentDistributionValue::customCSSText):
     36        (WebCore::CSSContentDistributionValue::equals):
     37        * css/CSSContentDistributionValue.h: Added.
     38        (WebCore::CSSContentDistributionValue::create):
     39        (WebCore::CSSContentDistributionValue::distribution):
     40        (WebCore::CSSContentDistributionValue::position):
     41        (WebCore::CSSContentDistributionValue::overflow):
     42        * css/CSSParser.cpp:
     43        (WebCore::isValidKeywordPropertyAndValue):
     44        (WebCore::isKeywordPropertyID):
     45        (WebCore::CSSParser::parseValue):
     46        (WebCore::isContentDistributionKeyword):
     47        (WebCore::isContentPositionKeyword):
     48        (WebCore::isAlignmentOverflowKeyword):
     49        (WebCore::CSSParser::parseContentDistributionOverflowPosition):
     50        (WebCore::CSSParser::parseItemPositionOverflowPosition):
     51        (WebCore::CSSParser::parseLegacyPosition): Deleted.
     52        * css/CSSParser.h:
     53        * css/CSSPrimitiveValueMappings.h:
     54        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
     55        (WebCore::CSSPrimitiveValue::operator ContentPosition):
     56        (WebCore::CSSPrimitiveValue::operator ContentDistributionType):
     57        (WebCore::CSSPrimitiveValue::operator EFlexDirection): Deleted.
     58        * css/CSSPropertyNames.in:
     59        * css/CSSValue.cpp:
     60        (WebCore::CSSValue::equals):
     61        (WebCore::CSSValue::cssText):
     62        (WebCore::CSSValue::destroy):
     63        * css/CSSValue.h:
     64        (WebCore::CSSValue::isContentDistributionValue):
     65        (WebCore::CSSValue::isWebKitCSSFilterValue): Deleted.
     66        * css/CSSValueKeywords.in:
     67        * css/StyleBuilderConverter.h:
     68        (WebCore::StyleBuilderConverter::convertContentAlignmentData):
     69        (WebCore::StyleBuilderConverter::convertSelfOrDefaultAlignmentData): Deleted.
     70        * rendering/RenderFlexibleBox.cpp:
     71        (WebCore::initialJustifyContentOffset):
     72        (WebCore::justifyContentSpaceBetweenChildren):
     73        (WebCore::RenderFlexibleBox::layoutAndPlaceChildren):
     74        (WebCore::RenderFlexibleBox::layoutColumnReverse):
     75        * rendering/RenderFullScreen.cpp:
     76        (WebCore::createFullScreenStyle):
     77        * rendering/mathml/RenderMathMLScripts.cpp:
     78        (WebCore::RenderMathMLScripts::fixAnonymousStyleForSubSupPair):
     79        (WebCore::RenderMathMLScripts::fixAnonymousStyles):
     80        * rendering/style/RenderStyle.h:
     81        * rendering/style/RenderStyleConstants.h:
     82        * rendering/style/StyleContentAlignmentData.h: Added.
     83        (WebCore::StyleContentAlignmentData::StyleContentAlignmentData):
     84        (WebCore::StyleContentAlignmentData::setPosition):
     85        (WebCore::StyleContentAlignmentData::setDistribution):
     86        (WebCore::StyleContentAlignmentData::setOverflow):
     87        (WebCore::StyleContentAlignmentData::position):
     88        (WebCore::StyleContentAlignmentData::distribution):
     89        (WebCore::StyleContentAlignmentData::overflow):
     90        (WebCore::StyleContentAlignmentData::operator==):
     91        (WebCore::StyleContentAlignmentData::operator!=):
     92        * rendering/style/StyleRareNonInheritedData.cpp:
     93        (WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
     94        (WebCore::StyleRareNonInheritedData::operator==):
     95        * rendering/style/StyleRareNonInheritedData.h:
     96
    1972015-05-04  Per Arne Vollan  <peavo@outlook.com>
    298
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r183618 r183748  
    37903790                9BF9A8811648DD2F001C6B23 /* JSHTMLFormControlsCollection.h in Headers */ = {isa = PBXBuildFile; fileRef = 9BF9A87F1648DD2F001C6B23 /* JSHTMLFormControlsCollection.h */; };
    37913791                9D6380101AF173220031A15C /* StyleSelfAlignmentData.h in Headers */ = {isa = PBXBuildFile; fileRef = 9D63800F1AF16E160031A15C /* StyleSelfAlignmentData.h */; settings = {ATTRIBUTES = (Private, ); }; };
     3792                9DAC7C541AF2CAA100437C44 /* CSSContentDistributionValue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9DAC7C521AF2CAA100437C44 /* CSSContentDistributionValue.cpp */; };
     3793                9DAC7C551AF2CAA200437C44 /* CSSContentDistributionValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 9DAC7C531AF2CAA100437C44 /* CSSContentDistributionValue.h */; };
     3794                9DAC7C571AF2CB6400437C44 /* StyleContentAlignmentData.h in Headers */ = {isa = PBXBuildFile; fileRef = 9DAC7C561AF2CB6400437C44 /* StyleContentAlignmentData.h */; settings = {ATTRIBUTES = (Private, ); }; };
    37923795                9F72304F11184B4100AD0126 /* ScriptProfile.h in Headers */ = {isa = PBXBuildFile; fileRef = 9F72304C11184B4100AD0126 /* ScriptProfile.h */; settings = {ATTRIBUTES = (Private, ); }; };
    37933796                9FA37EE41172FC8000C4CD55 /* ScriptProfileNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 9FA37EE31172FC8000C4CD55 /* ScriptProfileNode.h */; settings = {ATTRIBUTES = (Private, ); }; };
     
    1107911082                9BF9A87F1648DD2F001C6B23 /* JSHTMLFormControlsCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSHTMLFormControlsCollection.h; sourceTree = "<group>"; };
    1108011083                9D63800F1AF16E160031A15C /* StyleSelfAlignmentData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StyleSelfAlignmentData.h; path = style/StyleSelfAlignmentData.h; sourceTree = "<group>"; };
     11084                9DAC7C521AF2CAA100437C44 /* CSSContentDistributionValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSContentDistributionValue.cpp; sourceTree = "<group>"; };
     11085                9DAC7C531AF2CAA100437C44 /* CSSContentDistributionValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSContentDistributionValue.h; sourceTree = "<group>"; };
     11086                9DAC7C561AF2CB6400437C44 /* StyleContentAlignmentData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StyleContentAlignmentData.h; path = style/StyleContentAlignmentData.h; sourceTree = "<group>"; };
    1108111087                9F72304C11184B4100AD0126 /* ScriptProfile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScriptProfile.h; sourceTree = "<group>"; };
    1108211088                9FA37EE31172FC8000C4CD55 /* ScriptProfileNode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScriptProfileNode.h; sourceTree = "<group>"; };
     
    2137721383                        isa = PBXGroup;
    2137821384                        children = (
     21385                                9DAC7C561AF2CB6400437C44 /* StyleContentAlignmentData.h */,
    2137921386                                9D63800F1AF16E160031A15C /* StyleSelfAlignmentData.h */,
    2138021387                                FBD6AF8215EF21A3008B7110 /* BasicShapes.cpp */,
     
    2233522342                                31BC742B1AAFF45C006B4340 /* CSSAnimationTriggerScrollValue.cpp */,
    2233622343                                31BC742C1AAFF45C006B4340 /* CSSAnimationTriggerScrollValue.h */,
     22344                                9DAC7C521AF2CAA100437C44 /* CSSContentDistributionValue.cpp */,
     22345                                9DAC7C531AF2CAA100437C44 /* CSSContentDistributionValue.h */,
    2233722346                                83520C7D1A71BFCC006BD2AA /* CSSFontFamily.h */,
    2233822347                                FBD6AF8415EF21D4008B7110 /* BasicShapeFunctions.cpp */,
     
    2399424003                                443818001A91B2F8006E04F2 /* CoreMediaSoftLink.h in Headers */,
    2399524004                                7C9DBFEE1A9C49B1000D6B25 /* JSHTMLAttachmentElement.h in Headers */,
    23996                                 9D6380101AF173220031A15C /* StyleSelfAlignmentData.h in Headers */,
    2399724005                                4449A4051A964B0000B64AD5 /* CoreMediaSPI.h in Headers */,
    2399824006                                1C6466251A12C38E0094603C /* CoreTextSPI.h in Headers */,
     
    2405924067                                A80E6CF90A1989CA007FB8C5 /* CSSCharsetRule.h in Headers */,
    2406024068                                BCEA4790097CAAC80094C9E4 /* CSSComputedStyleDeclaration.h in Headers */,
     24069                                9DAC7C551AF2CAA200437C44 /* CSSContentDistributionValue.h in Headers */,
    2406124070                                2D8FEBDD143E3EF70072502B /* CSSCrossfadeValue.h in Headers */,
    2406224071                                AA21ECCD0ABF0FC6002B834C /* CSSCursorImageValue.h in Headers */,
     
    2651726526                                BCEF444D0E674628001C1287 /* StyleCachedImage.h in Headers */,
    2651826527                                9393E605151A9A1800066F06 /* StyleCachedImageSet.h in Headers */,
     26528                                9DAC7C571AF2CB6400437C44 /* StyleContentAlignmentData.h in Headers */,
    2651926529                                BC5EB67F0E81D4A700B25965 /* StyleDashboardRegion.h in Headers */,
    2652026530                                A8C4A7FD09D563270003AC8D /* StyledElement.h in Headers */,
     
    2654326553                                E4946EAF156E64DD00D3297F /* StyleRuleImport.h in Headers */,
    2654426554                                F47A5E3E195B8C8A00483100 /* StyleScrollSnapPoints.h in Headers */,
     26555                                9D6380101AF173220031A15C /* StyleSelfAlignmentData.h in Headers */,
    2654526556                                A8EA800C0A19516E00A8EF5F /* StyleSheet.h in Headers */,
    2654626557                                E4F9EEF3156DA00700D23E7E /* StyleSheetContents.h in Headers */,
     
    2778827799                                E1EBBBD40AAC9B87001FE8E2 /* CSSCharsetRule.cpp in Sources */,
    2778927800                                BCEA478F097CAAC80094C9E4 /* CSSComputedStyleDeclaration.cpp in Sources */,
     27801                                9DAC7C541AF2CAA100437C44 /* CSSContentDistributionValue.cpp in Sources */,
    2779027802                                2D8FEBDC143E3EF70072502B /* CSSCrossfadeValue.cpp in Sources */,
    2779127803                                AA21ECCA0ABF0FBA002B834C /* CSSCursorImageValue.cpp in Sources */,
  • trunk/Source/WebCore/css/CSSAllInOne.cpp

    r183466 r183748  
    3333#include "CSSCharsetRule.cpp"
    3434#include "CSSComputedStyleDeclaration.cpp"
     35#include "CSSContentDistributionValue.cpp"
    3536#include "CSSCrossfadeValue.cpp"
    3637#include "CSSCursorImageValue.cpp"
  • trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp

    r183739 r183748  
    17181718        return position;
    17191719
    1720     bool isFlexOrGrid = element->style().isDisplayFlexibleOrGridBox();
    1721     return isFlexOrGrid ? ItemPositionStretch : ItemPositionStart;
     1720    return element->style().isDisplayFlexibleOrGridBox() ? ItemPositionStretch : ItemPositionStart;
    17221721}
    17231722
     
    17331732    overflow = parent->style().alignItemsOverflowAlignment();
    17341733    return resolveContainerAlignmentAuto(parent->style().alignItemsPosition(), parent);
     1734}
     1735
     1736static ContentPosition resolveContentAlignmentAuto(ContentPosition position, ContentDistributionType distribution, RenderObject* element)
     1737{
     1738    if (position != ContentPositionAuto || distribution != ContentDistributionDefault || !element)
     1739        return position;
     1740
     1741    return element->style().isDisplayFlexibleBox() ? ContentPositionFlexStart : ContentPositionStart;
    17351742}
    17361743
     
    18241831        result->append(cssValuePool().createValue(overflowAlignment));
    18251832    ASSERT(result->length() <= 2);
     1833    return result.release();
     1834}
     1835
     1836static PassRefPtr<CSSValueList> valueForContentPositionAndDistributionWithOverflowAlignment(ContentPosition position, ContentDistributionType distribution, OverflowAlignment overflowAlignment)
     1837{
     1838    RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
     1839    if (distribution != ContentDistributionDefault)
     1840        result->append(CSSPrimitiveValue::create(distribution));
     1841    if (distribution == ContentDistributionDefault || position != ContentPositionAuto)
     1842        result->append(CSSPrimitiveValue::create(position));
     1843    if ((position >= ContentPositionCenter || distribution != ContentDistributionDefault) && overflowAlignment != OverflowAlignmentDefault)
     1844        result->append(CSSPrimitiveValue::create(overflowAlignment));
     1845    ASSERT(result->length() > 0);
     1846    ASSERT(result->length() <= 3);
    18261847    return result.release();
    18271848}
     
    22112232            return cssValuePool().createValue(style->flexWrap());
    22122233        case CSSPropertyJustifyContent:
    2213             return cssValuePool().createValue(style->justifyContent());
     2234            return valueForContentPositionAndDistributionWithOverflowAlignment(resolveContentAlignmentAuto(style->justifyContentPosition(), style->justifyContentDistribution(), renderer), style->justifyContentDistribution(), style->justifyContentOverflowAlignment());
    22142235        case CSSPropertyJustifyItems:
    22152236            return valueForItemPositionWithOverflowAlignment(resolveContainerAlignmentAuto(style->justifyItemsPosition(), renderer), style->justifyItemsOverflowAlignment(), style->justifyItemsPositionType());
  • trunk/Source/WebCore/css/CSSParser.cpp

    r183610 r183748  
    3434#include "CSSBorderImage.h"
    3535#include "CSSCanvasValue.h"
     36#include "CSSContentDistributionValue.h"
    3637#include "CSSCrossfadeValue.h"
    3738#include "CSSCursorImageValue.h"
     
    892893        if (valueID == CSSValueNowrap || valueID == CSSValueWrap || valueID == CSSValueWrapReverse)
    893894             return true;
    894         break;
    895     case CSSPropertyJustifyContent:
    896         // FIXME: Per CSS alignment, this property should accept an optional <overflow-position>. We should share this parsing code with 'justify-self'.
    897         if (valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround)
    898             return true;
    899895        break;
    900896    case CSSPropertyWebkitFontKerning:
     
    11291125    case CSSPropertyFlexDirection:
    11301126    case CSSPropertyFlexWrap:
    1131     case CSSPropertyJustifyContent:
    11321127    case CSSPropertyWebkitFontKerning:
    11331128    case CSSPropertyWebkitFontSmoothing:
     
    27142709        return false;
    27152710    }
     2711    case CSSPropertyJustifyContent:
     2712        parsedValue = parseContentDistributionOverflowPosition();
     2713        break;
    27162714    case CSSPropertyJustifySelf:
    27172715        return parseItemPositionOverflowPosition(propId, important);
     
    31203118    case CSSPropertyFlexDirection:
    31213119    case CSSPropertyFlexWrap:
    3122     case CSSPropertyJustifyContent:
    31233120    case CSSPropertyWebkitFontKerning:
    31243121    case CSSPropertyWebkitFontSmoothing:
     
    32333230}
    32343231
     3232static bool isContentDistributionKeyword(CSSValueID id)
     3233{
     3234    return id == CSSValueSpaceBetween || id == CSSValueSpaceAround
     3235        || id == CSSValueSpaceEvenly || id == CSSValueStretch;
     3236}
     3237
     3238static bool isContentPositionKeyword(CSSValueID id)
     3239{
     3240    return id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter
     3241        || id == CSSValueFlexStart || id == CSSValueFlexEnd
     3242        || id == CSSValueLeft || id == CSSValueRight;
     3243}
     3244
    32353245static inline bool isBaselinePositionKeyword(CSSValueID id)
    32363246{
    32373247    return id == CSSValueBaseline || id == CSSValueLastBaseline;
     3248}
     3249
     3250static bool isAlignmentOverflowKeyword(CSSValueID id)
     3251{
     3252    return id == CSSValueTrue || id == CSSValueSafe;
    32383253}
    32393254
     
    32693284}
    32703285
     3286PassRefPtr<CSSValue> CSSParser::parseContentDistributionOverflowPosition()
     3287{
     3288    // auto | <baseline-position> | <content-distribution> || [ <overflow-position>? && <content-position> ]
     3289    // <baseline-position> = baseline | last-baseline;
     3290    // <content-distribution> = space-between | space-around | space-evenly | stretch;
     3291    // <content-position> = center | start | end | flex-start | flex-end | left | right;
     3292    // <overflow-position> = true | safe
     3293
     3294    CSSParserValue* value = m_valueList->current();
     3295    if (!value)
     3296        return nullptr;
     3297
     3298    // auto | <baseline-position>
     3299    if (value->id == CSSValueAuto || isBaselinePositionKeyword(value->id)) {
     3300        m_valueList->next();
     3301        return CSSContentDistributionValue::create(CSSValueInvalid, value->id, CSSValueInvalid);
     3302    }
     3303
     3304    CSSValueID distribution = CSSValueInvalid;
     3305    CSSValueID position = CSSValueInvalid;
     3306    CSSValueID overflow = CSSValueInvalid;
     3307    while (value) {
     3308        if (isContentDistributionKeyword(value->id)) {
     3309            if (distribution != CSSValueInvalid)
     3310                return nullptr;
     3311            distribution = value->id;
     3312        } else if (isContentPositionKeyword(value->id)) {
     3313            if (position != CSSValueInvalid)
     3314                return nullptr;
     3315            position = value->id;
     3316        } else if (isAlignmentOverflowKeyword(value->id)) {
     3317            if (overflow != CSSValueInvalid)
     3318                return nullptr;
     3319            overflow = value->id;
     3320        } else
     3321            return nullptr;
     3322        value = m_valueList->next();
     3323    }
     3324
     3325    // The grammar states that we should have at least <content-distribution> or
     3326    // <content-position> ( <content-distribution> || <content-position> ).
     3327    if (position == CSSValueInvalid && distribution == CSSValueInvalid)
     3328        return nullptr;
     3329
     3330    // The grammar states that <overflow-position> must be associated to <content-position>.
     3331    if (overflow != CSSValueInvalid && position == CSSValueInvalid)
     3332        return nullptr;
     3333
     3334    return CSSContentDistributionValue::create(distribution, position, overflow);
     3335}
     3336
    32713337bool CSSParser::parseItemPositionOverflowPosition(CSSPropertyID propId, bool important)
    32723338{
     
    32983364            overflowAlignmentKeyword = cssValuePool().createIdentifierValue(value->id);
    32993365        }
    3300     } else if (value->id != CSSValueTrue && value->id != CSSValueSafe)
    3301         return false;
    3302     else {
     3366    } else if (isAlignmentOverflowKeyword(value->id)) {
    33033367        overflowAlignmentKeyword = cssValuePool().createIdentifierValue(value->id);
    33043368        value = m_valueList->next();
     
    33073371        else
    33083372            return false;
    3309     }
     3373    } else
     3374        return false;
    33103375
    33113376    if (m_valueList->next())
  • trunk/Source/WebCore/css/CSSParser.h

    r183610 r183748  
    232232    bool parseLegacyPosition(CSSPropertyID, bool important);
    233233    bool parseItemPositionOverflowPosition(CSSPropertyID, bool important);
     234    PassRefPtr<CSSValue> parseContentDistributionOverflowPosition();
    234235
    235236#if ENABLE(CSS_SHAPES)
  • trunk/Source/WebCore/css/CSSPrimitiveValueMappings.h

    r183442 r183748  
    14371437    ASSERT_NOT_REACHED();
    14381438    return SHOW;
    1439 }
    1440 
    1441 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifyContent e)
    1442     : CSSValue(PrimitiveClass)
    1443 {
    1444     m_primitiveUnitType = CSS_VALUE_ID;
    1445     switch (e) {
    1446     case JustifyFlexStart:
    1447         m_value.valueID = CSSValueFlexStart;
    1448         break;
    1449     case JustifyFlexEnd:
    1450         m_value.valueID = CSSValueFlexEnd;
    1451         break;
    1452     case JustifyCenter:
    1453         m_value.valueID = CSSValueCenter;
    1454         break;
    1455     case JustifySpaceBetween:
    1456         m_value.valueID = CSSValueSpaceBetween;
    1457         break;
    1458     case JustifySpaceAround:
    1459         m_value.valueID = CSSValueSpaceAround;
    1460         break;
    1461     }
    1462 }
    1463 
    1464 template<> inline CSSPrimitiveValue::operator EJustifyContent() const
    1465 {
    1466     ASSERT(isValueID());
    1467 
    1468     switch (m_value.valueID) {
    1469     case CSSValueFlexStart:
    1470         return JustifyFlexStart;
    1471     case CSSValueFlexEnd:
    1472         return JustifyFlexEnd;
    1473     case CSSValueCenter:
    1474         return JustifyCenter;
    1475     case CSSValueSpaceBetween:
    1476         return JustifySpaceBetween;
    1477     case CSSValueSpaceAround:
    1478         return JustifySpaceAround;
    1479     default:
    1480         break;
    1481     }
    1482 
    1483     ASSERT_NOT_REACHED();
    1484     return JustifyFlexStart;
    14851439}
    14861440
     
    51875141}
    51885142
     5143template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPosition)
     5144    : CSSValue(PrimitiveClass)
     5145{
     5146    m_primitiveUnitType = CSS_VALUE_ID;
     5147    switch (contentPosition) {
     5148    case ContentPositionAuto:
     5149        m_value.valueID = CSSValueAuto;
     5150        break;
     5151    case ContentPositionBaseline:
     5152        m_value.valueID = CSSValueBaseline;
     5153        break;
     5154    case ContentPositionLastBaseline:
     5155        m_value.valueID = CSSValueLastBaseline;
     5156        break;
     5157    case ContentPositionCenter:
     5158        m_value.valueID = CSSValueCenter;
     5159        break;
     5160    case ContentPositionStart:
     5161        m_value.valueID = CSSValueStart;
     5162        break;
     5163    case ContentPositionEnd:
     5164        m_value.valueID = CSSValueEnd;
     5165        break;
     5166    case ContentPositionFlexStart:
     5167        m_value.valueID = CSSValueFlexStart;
     5168        break;
     5169    case ContentPositionFlexEnd:
     5170        m_value.valueID = CSSValueFlexEnd;
     5171        break;
     5172    case ContentPositionLeft:
     5173        m_value.valueID = CSSValueLeft;
     5174        break;
     5175    case ContentPositionRight:
     5176        m_value.valueID = CSSValueRight;
     5177        break;
     5178    }
     5179}
     5180
     5181template<> inline CSSPrimitiveValue::operator ContentPosition() const
     5182{
     5183    switch (m_value.valueID) {
     5184    case CSSValueAuto:
     5185        return ContentPositionAuto;
     5186    case CSSValueBaseline:
     5187        return ContentPositionBaseline;
     5188    case CSSValueLastBaseline:
     5189        return ContentPositionLastBaseline;
     5190    case CSSValueCenter:
     5191        return ContentPositionCenter;
     5192    case CSSValueStart:
     5193        return ContentPositionStart;
     5194    case CSSValueEnd:
     5195        return ContentPositionEnd;
     5196    case CSSValueFlexStart:
     5197        return ContentPositionFlexStart;
     5198    case CSSValueFlexEnd:
     5199        return ContentPositionFlexEnd;
     5200    case CSSValueLeft:
     5201        return ContentPositionLeft;
     5202    case CSSValueRight:
     5203        return ContentPositionRight;
     5204    default:
     5205        break;
     5206    }
     5207    ASSERT_NOT_REACHED();
     5208    return ContentPositionAuto;
     5209}
     5210
     5211template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentDistributionType contentDistribution)
     5212    : CSSValue(PrimitiveClass)
     5213{
     5214    m_primitiveUnitType = CSS_VALUE_ID;
     5215    switch (contentDistribution) {
     5216    case ContentDistributionDefault:
     5217        m_value.valueID = CSSValueDefault;
     5218        break;
     5219    case ContentDistributionSpaceBetween:
     5220        m_value.valueID = CSSValueSpaceBetween;
     5221        break;
     5222    case ContentDistributionSpaceAround:
     5223        m_value.valueID = CSSValueSpaceAround;
     5224        break;
     5225    case ContentDistributionSpaceEvenly:
     5226        m_value.valueID = CSSValueSpaceEvenly;
     5227        break;
     5228    case ContentDistributionStretch:
     5229        m_value.valueID = CSSValueStretch;
     5230        break;
     5231    }
     5232}
     5233
     5234template<> inline CSSPrimitiveValue::operator ContentDistributionType() const
     5235{
     5236    switch (m_value.valueID) {
     5237    case CSSValueSpaceBetween:
     5238        return ContentDistributionSpaceBetween;
     5239    case CSSValueSpaceAround:
     5240        return ContentDistributionSpaceAround;
     5241    case CSSValueSpaceEvenly:
     5242        return ContentDistributionSpaceEvenly;
     5243    case CSSValueStretch:
     5244        return ContentDistributionStretch;
     5245    default:
     5246        break;
     5247    }
     5248    ASSERT_NOT_REACHED();
     5249    return ContentDistributionStretch;
     5250}
    51895251
    51905252#if ENABLE(CSS_SCROLL_SNAP)
  • trunk/Source/WebCore/css/CSSPropertyNames.in

    r183591 r183748  
    474474flex-wrap
    475475-webkit-flex-wrap = flex-wrap
    476 justify-content
     476justify-content [Initial=initialContentAlignment, Converter=ContentAlignmentData]
    477477-webkit-justify-content = justify-content
    478478#if defined(ENABLE_FILTERS_LEVEL_2) && ENABLE_FILTERS_LEVEL_2
  • trunk/Source/WebCore/css/CSSValue.cpp

    r181602 r183748  
    3434#include "CSSCalculationValue.h"
    3535#include "CSSCanvasValue.h"
     36#include "CSSContentDistributionValue.h"
    3637#include "CSSCrossfadeValue.h"
    3738#include "CSSCursorImageValue.h"
     
    232233            return compareCSSValues<CSSAnimationTriggerScrollValue>(*this, other);
    233234#endif
     235        case CSSContentDistributionClass:
     236            return compareCSSValues<CSSContentDistributionValue>(*this, other);
    234237        default:
    235238            ASSERT_NOT_REACHED();
     
    324327    case WebKitCSSResourceClass:
    325328        return downcast<WebKitCSSResourceValue>(*this).customCSSText();
     329    case CSSContentDistributionClass:
     330        return downcast<CSSContentDistributionValue>(*this).customCSSText();
    326331    }
    327332    ASSERT_NOT_REACHED();
     
    443448    case WebKitCSSResourceClass:
    444449        delete downcast<WebKitCSSResourceValue>(this);
     450        return;
     451    case CSSContentDistributionClass:
     452        delete downcast<CSSContentDistributionValue>(this);
    445453        return;
    446454    }
  • trunk/Source/WebCore/css/CSSValue.h

    r181602 r183748  
    9797    bool isFilterImageValue() const { return m_classType == FilterImageClass; }
    9898    bool isWebKitCSSFilterValue() const { return m_classType == WebKitCSSFilterClass; }
     99    bool isContentDistributionValue() const { return m_classType == CSSContentDistributionClass; }
    99100#if ENABLE(CSS_GRID_LAYOUT)
    100101    bool isGridTemplateAreasValue() const { return m_classType == GridTemplateAreasClass; }
     
    173174        AnimationTriggerScrollClass,
    174175#endif
     176
     177        CSSContentDistributionClass,
    175178
    176179        // List class types must appear after ValueListClass.
  • trunk/Source/WebCore/css/CSSValueKeywords.in

    r183610 r183748  
    546546space-between
    547547space-around
     548space-evenly
    548549// stretch
    549550
     
    557558
    558559// CSS_PROP_JUSTIFY_CONTENT
     560// start
     561// end
    559562// flex-start
    560563// flex-end
     
    562565// space-between
    563566// space-around
     567// space-evenly
     568// stretch
    564569
    565570// CSS_PROP_JUSTIFY_ITEMS / CSS_PROP_JUSTIFY_SELF
  • trunk/Source/WebCore/css/StyleBuilderConverter.h

    r183591 r183748  
    3030#include "BasicShapeFunctions.h"
    3131#include "CSSCalculationValue.h"
     32#include "CSSContentDistributionValue.h"
    3233#include "CSSFontFeatureValue.h"
    3334#include "CSSFunctionValue.h"
     
    123124    static Color convertSVGColor(StyleResolver&, CSSValue&);
    124125    static StyleSelfAlignmentData convertSelfOrDefaultAlignmentData(StyleResolver&, CSSValue&);
     126    static StyleContentAlignmentData convertContentAlignmentData(StyleResolver&, CSSValue&);
    125127    static EGlyphOrientation convertGlyphOrientation(StyleResolver&, CSSValue&);
    126128    static EGlyphOrientation convertGlyphOrientationOrAuto(StyleResolver&, CSSValue&);
     
    11891191}
    11901192
     1193inline StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentData(StyleResolver&, CSSValue& value)
     1194{
     1195    StyleContentAlignmentData alignmentData = RenderStyle::initialContentAlignment();
     1196    auto& contentValue = downcast<CSSContentDistributionValue>(value);
     1197    if (contentValue.distribution()->getValueID() != CSSValueInvalid)
     1198        alignmentData.setDistribution(contentValue.distribution().get());
     1199    if (contentValue.position()->getValueID() != CSSValueInvalid)
     1200        alignmentData.setPosition(contentValue.position().get());
     1201    if (contentValue.overflow()->getValueID() != CSSValueInvalid)
     1202        alignmentData.setOverflow(contentValue.overflow().get());
     1203    return alignmentData;
     1204}
     1205
    11911206inline EGlyphOrientation StyleBuilderConverter::convertGlyphOrientation(StyleResolver&, CSSValue& value)
    11921207{
  • trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp

    r183591 r183748  
    959959}
    960960
    961 static LayoutUnit initialJustifyContentOffset(LayoutUnit availableFreeSpace, EJustifyContent justifyContent, unsigned numberOfChildren)
    962 {
    963     if (justifyContent == JustifyFlexEnd)
     961static LayoutUnit initialJustifyContentOffset(LayoutUnit availableFreeSpace, ContentPosition justifyContent, ContentDistributionType justifyContentDistribution, unsigned numberOfChildren)
     962{
     963    if (justifyContent == ContentPositionFlexEnd)
    964964        return availableFreeSpace;
    965     if (justifyContent == JustifyCenter)
     965    if (justifyContent == ContentPositionCenter)
    966966        return availableFreeSpace / 2;
    967     if (justifyContent == JustifySpaceAround) {
     967    if (justifyContentDistribution == ContentDistributionSpaceAround) {
    968968        if (availableFreeSpace > 0 && numberOfChildren)
    969969            return availableFreeSpace / (2 * numberOfChildren);
     
    974974}
    975975
    976 static LayoutUnit justifyContentSpaceBetweenChildren(LayoutUnit availableFreeSpace, EJustifyContent justifyContent, unsigned numberOfChildren)
     976static LayoutUnit justifyContentSpaceBetweenChildren(LayoutUnit availableFreeSpace, ContentDistributionType justifyContentDistribution, unsigned numberOfChildren)
    977977{
    978978    if (availableFreeSpace > 0 && numberOfChildren > 1) {
    979         if (justifyContent == JustifySpaceBetween)
     979        if (justifyContentDistribution == ContentDistributionSpaceBetween)
    980980            return availableFreeSpace / (numberOfChildren - 1);
    981         if (justifyContent == JustifySpaceAround)
     981        if (justifyContentDistribution == ContentDistributionSpaceAround)
    982982            return availableFreeSpace / numberOfChildren;
    983983    }
     
    10611061    LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
    10621062    LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
    1063     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, style().justifyContent(), numberOfChildrenForJustifyContent);
     1063    mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, style().justifyContentPosition(), style().justifyContentDistribution(), numberOfChildrenForJustifyContent);
    10641064    if (style().flexDirection() == FlowRowReverse)
    10651065        mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
     
    11181118        ++seenInFlowPositionedChildren;
    11191119        if (seenInFlowPositionedChildren < numberOfChildrenForJustifyContent)
    1120             mainAxisOffset += justifyContentSpaceBetweenChildren(availableFreeSpace, style().justifyContent(), numberOfChildrenForJustifyContent);
     1120            mainAxisOffset += justifyContentSpaceBetweenChildren(availableFreeSpace, style().justifyContentDistribution(), numberOfChildrenForJustifyContent);
    11211121    }
    11221122
     
    11441144    size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
    11451145    LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
    1146     mainAxisOffset -= initialJustifyContentOffset(availableFreeSpace, style().justifyContent(), numberOfChildrenForJustifyContent);
     1146    mainAxisOffset -= initialJustifyContentOffset(availableFreeSpace, style().justifyContentPosition(), style().justifyContentDistribution(), numberOfChildrenForJustifyContent);
    11471147    mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
    11481148
     
    11621162        ++seenInFlowPositionedChildren;
    11631163        if (seenInFlowPositionedChildren < numberOfChildrenForJustifyContent)
    1164             mainAxisOffset -= justifyContentSpaceBetweenChildren(availableFreeSpace, style().justifyContent(), numberOfChildrenForJustifyContent);
     1164            mainAxisOffset -= justifyContentSpaceBetweenChildren(availableFreeSpace, style().justifyContentDistribution(), numberOfChildrenForJustifyContent);
    11651165    }
    11661166}
  • trunk/Source/WebCore/rendering/RenderFullScreen.cpp

    r183591 r183748  
    9090
    9191    fullscreenStyle.get().setDisplay(FLEX);
    92     fullscreenStyle.get().setJustifyContent(JustifyCenter);
     92    fullscreenStyle.get().setJustifyContentPosition(ContentPositionCenter);
    9393    fullscreenStyle.get().setAlignItemsPosition(ItemPositionCenter);
    9494    fullscreenStyle.get().setFlexDirection(FlowColumn);
  • trunk/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp

    r183591 r183748  
    9696    // the flex container. Note that for valid <msub> and <msup> elements, the
    9797    // subSupPair should actually have only one script.
    98     scriptsStyle.setJustifyContent(m_kind == Sub ? JustifyFlexStart : m_kind == Super ? JustifyFlexEnd : JustifySpaceBetween);
     98    if (m_kind == Sub)
     99        scriptsStyle.setJustifyContentPosition(ContentPositionFlexStart);
     100    else if (m_kind == Super)
     101        scriptsStyle.setJustifyContentPosition(ContentPositionFlexEnd);
     102    else
     103        scriptsStyle.setJustifyContentDistribution(ContentDistributionSpaceBetween);
    99104
    100105    // The MathML specification does not specify vertical alignment of scripts.
     
    134139            RenderStyle& scriptsStyle = subSupPair->style();
    135140            scriptsStyle.setFlexDirection(FlowRow);
    136             scriptsStyle.setJustifyContent(JustifyFlexStart);
     141            scriptsStyle.setJustifyContentPosition(ContentPositionFlexStart);
    137142            scriptsStyle.setAlignItemsPosition(ItemPositionCenter);
    138143            scriptsStyle.setOrder(0);
  • trunk/Source/WebCore/rendering/style/RenderStyle.h

    r183660 r183748  
    923923    bool isReverseFlexDirection() const { return flexDirection() == FlowRowReverse || flexDirection() == FlowColumnReverse; }
    924924    EFlexWrap flexWrap() const { return static_cast<EFlexWrap>(rareNonInheritedData->m_flexibleBox->m_flexWrap); }
    925     EJustifyContent justifyContent() const { return static_cast<EJustifyContent>(rareNonInheritedData->m_justifyContent); }
     925    const StyleContentAlignmentData& justifyContent() const { return rareNonInheritedData->m_justifyContent; }
     926    ContentPosition justifyContentPosition() const { return rareNonInheritedData->m_justifyContent.position(); }
     927    ContentDistributionType justifyContentDistribution() const { return rareNonInheritedData->m_justifyContent.distribution(); }
     928    OverflowAlignment justifyContentOverflowAlignment() const { return rareNonInheritedData->m_justifyContent.overflow(); }
    926929    const StyleSelfAlignmentData& justifyItems() const { return rareNonInheritedData->m_justifyItems; }
    927930    ItemPosition justifyItemsPosition() const { return rareNonInheritedData->m_justifyItems.position(); }
     
    15111514    void setFlexDirection(EFlexDirection direction) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexDirection, direction); }
    15121515    void setFlexWrap(EFlexWrap w) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexWrap, w); }
    1513     void setJustifyContent(EJustifyContent p) { SET_VAR(rareNonInheritedData, m_justifyContent, p); }
     1516    void setJustifyContent(const StyleContentAlignmentData& data) { SET_VAR(rareNonInheritedData, m_justifyContent, data); }
     1517    void setJustifyContentPosition(ContentPosition position) { rareNonInheritedData.access()->m_justifyContent.setPosition(position); }
     1518    void setJustifyContentOverflow(OverflowAlignment overflow) { rareNonInheritedData.access()->m_justifyContent.setOverflow(overflow); }
     1519    void setJustifyContentDistribution(ContentDistributionType distribution) { rareNonInheritedData.access()->m_justifyContent.setDistribution(distribution); }
    15141520    void setJustifyItems(const StyleSelfAlignmentData& data) { SET_VAR(rareNonInheritedData, m_justifyItems, data); }
    15151521    void setJustifyItemsPosition(ItemPosition position) { rareNonInheritedData.access()->m_justifyItems.setPosition(position); }
     
    18051811    bool isOriginalDisplayInlineType() const { return isDisplayInlineType(originalDisplay()); }
    18061812    bool isDisplayFlexibleOrGridBox() const { return isDisplayFlexibleOrGridBox(display()); }
     1813    bool isDisplayFlexibleBox() const { return isDisplayFlexibleBox(display()); }
    18071814    bool isDisplayRegionType() const
    18081815    {
     
    19291936    static EAlignContent initialAlignContent() { return AlignContentStretch; }
    19301937    static StyleSelfAlignmentData initialSelfAlignment() { return StyleSelfAlignmentData(ItemPositionAuto, OverflowAlignmentDefault); }
     1938    static StyleContentAlignmentData initialContentAlignment() { return StyleContentAlignmentData(ContentPositionAuto, ContentDistributionDefault, OverflowAlignmentDefault); }
    19311939    static EFlexDirection initialFlexDirection() { return FlowRow; }
    19321940    static EFlexWrap initialFlexWrap() { return FlexNoWrap; }
    1933     static EJustifyContent initialJustifyContent() { return JustifyFlexStart; }
    19341941    static int initialMarqueeLoopCount() { return -1; }
    19351942    static int initialMarqueeSpeed() { return 85; }
  • trunk/Source/WebCore/rendering/style/RenderStyleConstants.h

    r183494 r183748  
    249249enum EFlexDirection { FlowRow, FlowRowReverse, FlowColumn, FlowColumnReverse };
    250250enum EFlexWrap { FlexNoWrap, FlexWrap, FlexWrapReverse };
    251 enum EJustifyContent { JustifyFlexStart, JustifyFlexEnd, JustifyCenter, JustifySpaceBetween, JustifySpaceAround };
    252251enum ItemPosition {ItemPositionAuto, ItemPositionStretch, ItemPositionBaseline, ItemPositionLastBaseline, ItemPositionCenter, ItemPositionStart, ItemPositionEnd, ItemPositionSelfStart, ItemPositionSelfEnd, ItemPositionFlexStart, ItemPositionFlexEnd, ItemPositionLeft, ItemPositionRight};
    253252enum OverflowAlignment {OverflowAlignmentDefault, OverflowAlignmentTrue, OverflowAlignmentSafe};
    254253enum ItemPositionType {NonLegacyPosition, LegacyPosition};
     254enum ContentPosition {ContentPositionAuto, ContentPositionBaseline, ContentPositionLastBaseline, ContentPositionCenter, ContentPositionStart, ContentPositionEnd, ContentPositionFlexStart, ContentPositionFlexEnd, ContentPositionLeft, ContentPositionRight};
     255enum ContentDistributionType {ContentDistributionDefault, ContentDistributionSpaceBetween, ContentDistributionSpaceAround, ContentDistributionSpaceEvenly, ContentDistributionStretch};
    255256
    256257enum ETextSecurity {
  • trunk/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp

    r183591 r183748  
    7474    , m_alignItems(RenderStyle::initialSelfAlignment())
    7575    , m_alignSelf(RenderStyle::initialSelfAlignment())
     76    , m_justifyContent(RenderStyle::initialContentAlignment())
    7677    , m_justifyItems(RenderStyle::initialSelfAlignment())
    7778    , m_justifySelf(RenderStyle::initialSelfAlignment())
     
    8788    , m_backfaceVisibility(RenderStyle::initialBackfaceVisibility())
    8889    , m_alignContent(RenderStyle::initialAlignContent())
    89     , m_justifyContent(RenderStyle::initialJustifyContent())
    9090    , userDrag(RenderStyle::initialUserDrag())
    9191    , textOverflow(RenderStyle::initialTextOverflow())
     
    162162    , m_alignItems(o.m_alignItems)
    163163    , m_alignSelf(o.m_alignSelf)
     164    , m_justifyContent(o.m_justifyContent)
    164165    , m_justifyItems(o.m_justifyItems)
    165166    , m_justifySelf(o.m_justifySelf)
     
    175176    , m_backfaceVisibility(o.m_backfaceVisibility)
    176177    , m_alignContent(o.m_alignContent)
    177     , m_justifyContent(o.m_justifyContent)
    178178    , userDrag(o.userDrag)
    179179    , textOverflow(o.textOverflow)
     
    259259        && m_alignItems == o.m_alignItems
    260260        && m_alignSelf == o.m_alignSelf
     261        && m_justifyContent == o.m_justifyContent
    261262        && m_justifyItems == o.m_justifyItems
    262263        && m_justifySelf == o.m_justifySelf
     
    270271        && m_backfaceVisibility == o.m_backfaceVisibility
    271272        && m_alignContent == o.m_alignContent
    272         && m_justifyContent == o.m_justifyContent
    273273        && userDrag == o.userDrag
    274274        && textOverflow == o.textOverflow
  • trunk/Source/WebCore/rendering/style/StyleRareNonInheritedData.h

    r183591 r183748  
    3535#include "NinePieceImage.h"
    3636#include "ShapeValue.h"
     37#include "StyleContentAlignmentData.h"
    3738#include "StyleSelfAlignmentData.h"
    3839#include <memory>
     
    179180    StyleSelfAlignmentData m_alignItems;
    180181    StyleSelfAlignmentData m_alignSelf;
     182    StyleContentAlignmentData m_justifyContent;
    181183    StyleSelfAlignmentData m_justifyItems;
    182184    StyleSelfAlignmentData m_justifySelf;
     
    197199
    198200    unsigned m_alignContent : 3; // EAlignContent
    199     unsigned m_justifyContent : 3; // EJustifyContent
    200201
    201202    unsigned userDrag : 2; // EUserDrag
Note: See TracChangeset for help on using the changeset viewer.