Remove CSS Grid Layout and grid media queries.

sky/engine/core/css/CSSComputedStyleDeclaration.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ skipping 17 matching lines @@
 #include "core/CSSPropertyNames.h"
 #include "core/StylePropertyShorthand.h"
 #include "core/animation/DocumentAnimations.h"
 #include "core/css/BasicShapeFunctions.h"
 #include "core/css/CSSAspectRatioValue.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSFilterValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFontValue.h"
 #include "core/css/CSSFunctionValue.h"
-#include "core/css/CSSGridLineNamesValue.h"
-#include "core/css/CSSGridTemplateAreasValue.h"
 #include "core/css/CSSLineBoxContainValue.h"
 #include "core/css/parser/BisonCSSParser.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSTransformValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/rendering/RenderBox.h"
-#include "core/rendering/RenderGrid.h"
 #include "core/rendering/style/ContentData.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "core/rendering/style/ShadowList.h"
 #include "core/rendering/style/ShapeValue.h"
 #include "platform/FontFamilyNames.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/FontFeatureSettings.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
@@ skipping 57 matching lines @@
     CSSPropertyFontKerning,
     CSSPropertyFontSize,
     CSSPropertyFontStretch,
     CSSPropertyFontStyle,
     CSSPropertyFontVariant,
     CSSPropertyFontVariantLigatures,
     CSSPropertyFontWeight,
     CSSPropertyHeight,
     CSSPropertyImageRendering,
     CSSPropertyIsolation,
-    CSSPropertyJustifyItems,
-    CSSPropertyJustifySelf,
     CSSPropertyLeft,
     CSSPropertyLetterSpacing,
     CSSPropertyLineHeight,
     CSSPropertyListStyleImage,
     CSSPropertyListStylePosition,
     CSSPropertyListStyleType,
     CSSPropertyMarginBottom,
     CSSPropertyMarginLeft,
     CSSPropertyMarginRight,
     CSSPropertyMarginTop,
@@ skipping 83 matching lines @@
     CSSPropertyAlignContent,
     CSSPropertyAlignItems,
     CSSPropertyAlignSelf,
     CSSPropertyFlexBasis,
     CSSPropertyFlexGrow,
     CSSPropertyFlexShrink,
     CSSPropertyFlexDirection,
     CSSPropertyFlexWrap,
     CSSPropertyJustifyContent,
     CSSPropertyWebkitFontSmoothing,
-    CSSPropertyGridAutoColumns,
-    CSSPropertyGridAutoFlow,
-    CSSPropertyGridAutoRows,
-    CSSPropertyGridColumnEnd,
-    CSSPropertyGridColumnStart,
-    CSSPropertyGridTemplateAreas,
-    CSSPropertyGridTemplateColumns,
-    CSSPropertyGridTemplateRows,
-    CSSPropertyGridRowEnd,
-    CSSPropertyGridRowStart,
     CSSPropertyWebkitHighlight,
     CSSPropertyWebkitHyphenateCharacter,
     CSSPropertyWebkitLineBoxContain,
     CSSPropertyWebkitLineBreak,
     CSSPropertyWebkitLineClamp,
     CSSPropertyWebkitLocale,
     CSSPropertyWebkitMarginBeforeCollapse,
     CSSPropertyWebkitMarginAfterCollapse,
     CSSPropertyWebkitMaskBoxImage,
     CSSPropertyWebkitMaskBoxImageOutset,
@@ skipping 479 matching lines @@
         default:
             filterValue = CSSFilterValue::create(CSSFilterValue::UnknownFilterOperation);
             break;
         }
         list->append(filterValue.release());
     }
 
     return list.release();
 }
 
-static PassRefPtr<CSSValue> specifiedValueForGridTrackBreadth(const GridLength& trackBreadth, const RenderStyle& style)
-{
-    if (!trackBreadth.isLength())
-        return cssValuePool().createValue(trackBreadth.flex(), CSSPrimitiveValue::CSS_FR);
-
-    const Length& trackBreadthLength = trackBreadth.length();
-    if (trackBreadthLength.isAuto())
-        return cssValuePool().createIdentifierValue(CSSValueAuto);
-    return zoomAdjustedPixelValueForLength(trackBreadthLength, style);
-}
-
-static PassRefPtr<CSSValue> specifiedValueForGridTrackSize(const GridTrackSize& trackSize, const RenderStyle& style)
-{
-    switch (trackSize.type()) {
-    case LengthTrackSizing:
-        return specifiedValueForGridTrackBreadth(trackSize.length(), style);
-    case MinMaxTrackSizing:
-        RefPtr<CSSValueList> minMaxTrackBreadths = CSSValueList::createCommaSeparated();
-        minMaxTrackBreadths->append(specifiedValueForGridTrackBreadth(trackSize.minTrackBreadth(), style));
-        minMaxTrackBreadths->append(specifiedValueForGridTrackBreadth(trackSize.maxTrackBreadth(), style));
-        return CSSFunctionValue::create("minmax(", minMaxTrackBreadths);
-    }
-    ASSERT_NOT_REACHED();
-    return nullptr;
-}
-
-static void addValuesForNamedGridLinesAtIndex(const OrderedNamedGridLines& orderedNamedGridLines, size_t i, CSSValueList& list)
-{
-    const Vector<String>& namedGridLines = orderedNamedGridLines.get(i);
-    if (namedGridLines.isEmpty())
-        return;
-
-    RefPtr<CSSGridLineNamesValue> lineNames = CSSGridLineNamesValue::create();
-    for (size_t j = 0; j < namedGridLines.size(); ++j)
-        lineNames->append(cssValuePool().createValue(namedGridLines[j], CSSPrimitiveValue::CSS_STRING));
-    list.append(lineNames.release());
-}
-
-static PassRefPtr<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction, RenderObject* renderer, const RenderStyle& style)
-{
-    const Vector<GridTrackSize>& trackSizes = direction == ForColumns ? style.gridTemplateColumns() : style.gridTemplateRows();
-    const OrderedNamedGridLines& orderedNamedGridLines = direction == ForColumns ? style.orderedNamedGridColumnLines() : style.orderedNamedGridRowLines();
-
-    // Handle the 'none' case here.
-    if (!trackSizes.size()) {
-        ASSERT(orderedNamedGridLines.isEmpty());
-        return cssValuePool().createIdentifierValue(CSSValueNone);
-    }
-
-    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-    if (renderer && renderer->isRenderGrid()) {
-        const Vector<LayoutUnit>& trackPositions = direction == ForColumns ? toRenderGrid(renderer)->columnPositions() : toRenderGrid(renderer)->rowPositions();
-        // There are at least #tracks + 1 grid lines (trackPositions). Apart from that, the grid container can generate implicit grid tracks,
-        // so we'll have more trackPositions than trackSizes as the latter only contain the explicit grid.
-        ASSERT(trackPositions.size() - 1 >= trackSizes.size());
-
-        for (size_t i = 0; i < trackSizes.size(); ++i) {
-            addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, i, *list);
-            list->append(zoomAdjustedPixelValue(trackPositions[i + 1] - trackPositions[i], style));
-        }
-    } else {
-        for (size_t i = 0; i < trackSizes.size(); ++i) {
-            addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, i, *list);
-            list->append(specifiedValueForGridTrackSize(trackSizes[i], style));
-        }
-    }
-    // Those are the trailing <string>* allowed in the syntax.
-    addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, trackSizes.size(), *list);
-    return list.release();
-}
-
-static PassRefPtr<CSSValue> valueForGridPosition(const GridPosition& position)
-{
-    if (position.isAuto())
-        return cssValuePool().createIdentifierValue(CSSValueAuto);
-
-    if (position.isNamedGridArea())
-        return cssValuePool().createValue(position.namedGridLine(), CSSPrimitiveValue::CSS_STRING);
-
-    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-    if (position.isSpan()) {
-        list->append(cssValuePool().createIdentifierValue(CSSValueSpan));
-        list->append(cssValuePool().createValue(position.spanPosition(), CSSPrimitiveValue::CSS_NUMBER));
-    } else
-        list->append(cssValuePool().createValue(position.integerPosition(), CSSPrimitiveValue::CSS_NUMBER));
-
-    if (!position.namedGridLine().isNull())
-        list->append(cssValuePool().createValue(position.namedGridLine(), CSSPrimitiveValue::CSS_STRING));
-    return list;
-}
-
 static PassRefPtr<CSSValue> createTransitionPropertyValue(const CSSTransitionData::TransitionProperty& property)
 {
     if (property.propertyType == CSSTransitionData::TransitionNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     if (property.propertyType == CSSTransitionData::TransitionAll)
         return cssValuePool().createIdentifierValue(CSSValueAll);
     if (property.propertyType == CSSTransitionData::TransitionUnknown)
         return cssValuePool().createValue(property.propertyString, CSSPrimitiveValue::CSS_STRING);
     ASSERT(property.propertyType == CSSTransitionData::TransitionSingleProperty);
     return cssValuePool().createValue(getPropertyNameString(property.propertyId), CSSPrimitiveValue::CSS_STRING);
@@ skipping 503 matching lines @@
 
 static bool isLayoutDependent(CSSPropertyID propertyID, PassRefPtr<RenderStyle> style, RenderObject* renderer)
 {
     // Some properties only depend on layout in certain conditions which
     // are specified in the main switch statement below. So we can avoid
     // forcing layout in those conditions. The conditions in this switch
     // statement must remain in sync with the conditions in the main switch.
     // FIXME: Some of these cases could be narrowed down or optimized better.
     switch (propertyID) {
     case CSSPropertyBottom:
-    case CSSPropertyGridTemplateColumns:
-    case CSSPropertyGridTemplateRows:
     case CSSPropertyHeight:
     case CSSPropertyLeft:
     case CSSPropertyRight:
     case CSSPropertyTop:
     case CSSPropertyPerspectiveOrigin:
     case CSSPropertyWebkitPerspectiveOrigin:
     case CSSPropertyTransform:
     case CSSPropertyWebkitTransform:
     case CSSPropertyTransformOrigin:
     case CSSPropertyWebkitTransformOrigin:
@@ skipping 28 matching lines @@
 PassRefPtr<RenderStyle> CSSComputedStyleDeclaration::computeRenderStyle(CSSPropertyID propertyID) const
 {
     return m_node->computedStyle(m_pseudoElementSpecifier);
 }
 
 static ItemPosition resolveAlignmentAuto(ItemPosition position, Node* element)
 {
     if (position != ItemPositionAuto)
         return position;
 
-    bool isFlexOrGrid = element && element->computedStyle()
-        && element->computedStyle()->isDisplayFlexibleOrGridBox();
+    bool isFlex = element && element->computedStyle()
+        && element->computedStyle()->isDisplayFlexibleBox();
 
-    return isFlexOrGrid ? ItemPositionStretch : ItemPositionStart;
+    return isFlex ? ItemPositionStretch : ItemPositionStart;
 }
 
 static PassRefPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
 {
     RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
     if (positionType == LegacyPosition)
         result->append(CSSPrimitiveValue::createIdentifier(CSSValueLegacy));
     result->append(CSSPrimitiveValue::create(itemPosition));
     if (itemPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
         result->append(CSSPrimitiveValue::create(overflowAlignment));
@@ skipping 274 matching lines @@
             if (!featureSettings || !featureSettings->size())
                 return cssValuePool().createIdentifierValue(CSSValueNormal);
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             for (unsigned i = 0; i < featureSettings->size(); ++i) {
                 const FontFeature& feature = featureSettings->at(i);
                 RefPtr<CSSFontFeatureValue> featureValue = CSSFontFeatureValue::create(feature.tag(), feature.value());
                 list->append(featureValue.release());
             }
             return list.release();
         }
-        case CSSPropertyGridAutoFlow: {
-            RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-            switch (style->gridAutoFlow()) {
-            case AutoFlowRow:
-            case AutoFlowRowDense:
-                list->append(cssValuePool().createIdentifierValue(CSSValueRow));
-                break;
-            case AutoFlowColumn:
-            case AutoFlowColumnDense:
-                list->append(cssValuePool().createIdentifierValue(CSSValueColumn));
-                break;
-            case AutoFlowStackRow:
-            case AutoFlowStackColumn:
-                list->append(cssValuePool().createIdentifierValue(CSSValueStack));
-                break;
-            default:
-                ASSERT_NOT_REACHED();
-            }
-
-            switch (style->gridAutoFlow()) {
-            case AutoFlowRowDense:
-            case AutoFlowColumnDense:
-                list->append(cssValuePool().createIdentifierValue(CSSValueDense));
-                break;
-            case AutoFlowStackRow:
-                list->append(cssValuePool().createIdentifierValue(CSSValueRow));
-                break;
-            case AutoFlowStackColumn:
-                list->append(cssValuePool().createIdentifierValue(CSSValueColumn));
-                break;
-            default:
-                // Do nothing.
-                break;
-            }
-
-            return list.release();
-        }
-        // Specs mention that getComputedStyle() should return the used value of the property instead of the computed
-        // one for grid-definition-{rows|columns} but not for the grid-auto-{rows|columns} as things like
-        // grid-auto-columns: 2fr; cannot be resolved to a value in pixels as the '2fr' means very different things
-        // depending on the size of the explicit grid or the number of implicit tracks added to the grid. See
-        // http://lists.w3.org/Archives/Public/www-style/2013Nov/0014.html
-        case CSSPropertyGridAutoColumns:
-            return specifiedValueForGridTrackSize(style->gridAutoColumns(), *style);
-        case CSSPropertyGridAutoRows:
-            return specifiedValueForGridTrackSize(style->gridAutoRows(), *style);
-
-        case CSSPropertyGridTemplateColumns:
-            return valueForGridTrackList(ForColumns, renderer, *style);
-        case CSSPropertyGridTemplateRows:
-            return valueForGridTrackList(ForRows, renderer, *style);
-
-        case CSSPropertyGridColumnStart:
-            return valueForGridPosition(style->gridColumnStart());
-        case CSSPropertyGridColumnEnd:
-            return valueForGridPosition(style->gridColumnEnd());
-        case CSSPropertyGridRowStart:
-            return valueForGridPosition(style->gridRowStart());
-        case CSSPropertyGridRowEnd:
-            return valueForGridPosition(style->gridRowEnd());
-        case CSSPropertyGridColumn:
-            return valuesForGridShorthand(gridColumnShorthand());
-        case CSSPropertyGridRow:
-            return valuesForGridShorthand(gridRowShorthand());
-        case CSSPropertyGridArea:
-            return valuesForGridShorthand(gridAreaShorthand());
-        case CSSPropertyGridTemplate:
-            return valuesForGridShorthand(gridTemplateShorthand());
-        case CSSPropertyGrid:
-            return valuesForGridShorthand(gridShorthand());
-        case CSSPropertyGridTemplateAreas:
-            if (!style->namedGridAreaRowCount()) {
-                ASSERT(!style->namedGridAreaColumnCount());
-                return cssValuePool().createIdentifierValue(CSSValueNone);
-            }
-
-            return CSSGridTemplateAreasValue::create(style->namedGridArea(), style->namedGridAreaRowCount(), style->namedGridAreaColumnCount());
 
         case CSSPropertyHeight:
             if (renderer) {
                 // According to http://www.w3.org/TR/CSS2/visudet.html#the-height-property,
                 // the "height" property does not apply for non-replaced inline elements.
                 if (!renderer->isReplaced() && renderer->isInline())
                     return cssValuePool().createIdentifierValue(CSSValueAuto);
                 return zoomAdjustedPixelValue(sizingBox(renderer).height(), *style);
             }
             return zoomAdjustedPixelValueForLength(style->height(), *style);
         case CSSPropertyWebkitHighlight:
             if (style->highlight() == nullAtom)
                 return cssValuePool().createIdentifierValue(CSSValueNone);
             return cssValuePool().createValue(style->highlight(), CSSPrimitiveValue::CSS_STRING);
         case CSSPropertyWebkitHyphenateCharacter:
             if (style->hyphenationString().isNull())
                 return cssValuePool().createIdentifierValue(CSSValueAuto);
             return cssValuePool().createValue(style->hyphenationString(), CSSPrimitiveValue::CSS_STRING);
         case CSSPropertyImageRendering:
             return CSSPrimitiveValue::create(style->imageRendering());
         case CSSPropertyIsolation:
             return cssValuePool().createValue(style->isolation());
-        case CSSPropertyJustifyItems:
-            return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style->justifyItems(), m_node.get()), style->justifyItemsOverflowAlignment(), style->justifyItemsPositionType());
-        case CSSPropertyJustifySelf:
-            return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style->justifySelf(), m_node->parentNode()), style->justifySelfOverflowAlignment(), NonLegacyPosition);
         case CSSPropertyLeft:
             return valueForPositionOffset(*style, CSSPropertyLeft, renderer);
         case CSSPropertyLetterSpacing:
             if (!style->letterSpacing())
                 return cssValuePool().createIdentifierValue(CSSValueNormal);
             return zoomAdjustedPixelValue(style->letterSpacing(), *style);
         case CSSPropertyWebkitLineClamp:
             if (style->lineClamp().isNone())
                 return cssValuePool().createIdentifierValue(CSSValueNone);
             return cssValuePool().createValue(style->lineClamp().value(), style->lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);
@@ skipping 809 matching lines @@
     if (showRight)
         list->append(rightValue.release());
     if (showBottom)
         list->append(bottomValue.release());
     if (showLeft)
         list->append(leftValue.release());
 
     return list.release();
 }
 
-PassRefPtr<CSSValueList> CSSComputedStyleDeclaration::valuesForGridShorthand(const StylePropertyShorthand& shorthand) const
-{
-    RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
-    for (size_t i = 0; i < shorthand.length(); ++i) {
-        RefPtr<CSSValue> value = getPropertyCSSValue(shorthand.properties()[i], DoNotUpdateLayout);
-        list->append(value.release());
-    }
-    return list.release();
-}
-
 PassRefPtr<MutableStylePropertySet> CSSComputedStyleDeclaration::copyPropertiesInSet(const Vector<CSSPropertyID>& properties) const
 {
     Vector<CSSProperty, 256> list;
     list.reserveInitialCapacity(properties.size());
     for (unsigned i = 0; i < properties.size(); ++i) {
         RefPtr<CSSValue> value = getPropertyCSSValue(properties[i]);
         if (value)
             list.append(CSSProperty(properties[i], value.release(), false));
     }
     return MutableStylePropertySet::create(list.data(), list.size());
@@ skipping 78 matching lines @@
     return list.release();
 }
 
 void CSSComputedStyleDeclaration::trace(Visitor* visitor)
 {
     visitor->trace(m_node);
     CSSStyleDeclaration::trace(visitor);
 }
 
 } // namespace blink