border-foo WIP

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSContentDistributionValue.h"
@@ skipping 1278 matching lines @@
                     parsedLonghand[i] = true;
                     foundProperty = true;
                     longhands[i]->append(*value);
                     break;
                 }
             }
             if (!foundProperty)
                 return false;
         } while (!m_range.atEnd() && m_range.peek().type() != CommaToken);
 
-        // TODO(timloh): This will make invalid longhands, see crbug.com/386459
         for (size_t i = 0; i < longhandCount; ++i) {
             if (!parsedLonghand[i])
-                longhands[i]->append(*CSSInitialValue::createLegacyImplicit());
+                longhands[i]->append(*CSSPropertyMetadata::initialValue(shorthand.properties()[i]));
             parsedLonghand[i] = false;
         }
     } while (consumeCommaIncludingWhitespace(m_range));
 
     for (size_t i = 0; i < longhandCount; ++i) {
         if (!isValidAnimationPropertyList(shorthand.properties()[i], *longhands[i]))
             return false;
     }
 
     for (size_t i = 0; i < longhandCount; ++i)
@@ skipping 2610 matching lines @@
                 foundLonghand = true;
         }
         if (!foundLonghand)
             return false;
     } while (!m_range.atEnd());
 
     for (size_t i = 0; i < shorthand.length(); ++i) {
         if (longhands[i])
             addProperty(shorthandProperties[i], shorthand.id(), *longhands[i], important);
         else
-            addProperty(shorthandProperties[i], shorthand.id(), *CSSInitialValue::createLegacyImplicit(), important);
+            addProperty(shorthandProperties[i], shorthand.id(), *CSSPropertyMetadata::initialValue(shorthandProperties[i]), important);
     }
     return true;
 }
 
 bool CSSPropertyParser::consumeFlex(bool important)
 {
     static const double unsetValue = -1;
     double flexGrow = unsetValue;
     double flexShrink = unsetValue;
     CSSPrimitiveValue* flexBasis = nullptr;
@@ skipping 67 matching lines @@
             if (color)
                 continue;
         }
         break;
     }
 
     if (!width && !style && !color)
         return false;
 
     if (!width)
-        width = CSSInitialValue::createLegacyImplicit();
+        width = CSSPropertyMetadata::initialValue(CSSPropertyBorderWidth);
     if (!style)
-        style = CSSInitialValue::createLegacyImplicit();
+        style = CSSPropertyMetadata::initialValue(CSSPropertyBorderStyle);
     if (!color)
-        color = CSSInitialValue::createLegacyImplicit();
+        color = CSSPropertyMetadata::initialValue(CSSPropertyBorderColor);
 
     addExpandedPropertyForValue(CSSPropertyBorderWidth, *width, important);
     addExpandedPropertyForValue(CSSPropertyBorderStyle, *style, important);
     addExpandedPropertyForValue(CSSPropertyBorderColor, *color, important);
-    addExpandedPropertyForValue(CSSPropertyBorderImage, *CSSInitialValue::createLegacyImplicit(), important);
-
+    addProperty(CSSPropertyBorderImageSource, CSSPropertyBorderImage, *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageSource), important);
+    addProperty(CSSPropertyBorderImageSlice, CSSPropertyBorderImage, *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageSlice), important);
+    addProperty(CSSPropertyBorderImageWidth, CSSPropertyBorderImage, *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageWidth), important);
+    addProperty(CSSPropertyBorderImageOutset, CSSPropertyBorderImage, *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageOutset), important);
+    addProperty(CSSPropertyBorderImageRepeat, CSSPropertyBorderImage, *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageRepeat), important);
     return m_range.atEnd();
 }
 
 bool CSSPropertyParser::consume4Values(const StylePropertyShorthand& shorthand, bool important)
 {
     ASSERT(shorthand.length() == 4);
     const CSSPropertyID* longhands = shorthand.properties();
     const CSSValue* top = parseSingleValue(longhands[0], shorthand.id());
     if (!top)
         return false;
@@ skipping 25 matching lines @@
 bool CSSPropertyParser::consumeBorderImage(CSSPropertyID property, bool important)
 {
     CSSValue* source = nullptr;
     CSSValue* slice = nullptr;
     CSSValue* width = nullptr;
     CSSValue* outset = nullptr;
     CSSValue* repeat = nullptr;
     if (consumeBorderImageComponents(property, m_range, m_context, source, slice, width, outset, repeat)) {
         switch (property) {
         case CSSPropertyWebkitMaskBoxImage:
-            addProperty(CSSPropertyWebkitMaskBoxImageSource, CSSPropertyWebkitMaskBoxImage, source ? *source : *CSSInitialValue::createLegacyImplicit(), important);
-            addProperty(CSSPropertyWebkitMaskBoxImageSlice, CSSPropertyWebkitMaskBoxImage, slice ? *slice : *CSSInitialValue::createLegacyImplicit(), important);
-            addProperty(CSSPropertyWebkitMaskBoxImageWidth, CSSPropertyWebkitMaskBoxImage, width ? *width : *CSSInitialValue::createLegacyImplicit(), important);
-            addProperty(CSSPropertyWebkitMaskBoxImageOutset, CSSPropertyWebkitMaskBoxImage, outset ? *outset : *CSSInitialValue::createLegacyImplicit(), important);
-            addProperty(CSSPropertyWebkitMaskBoxImageRepeat, CSSPropertyWebkitMaskBoxImage, repeat ? *repeat : *CSSInitialValue::createLegacyImplicit(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageSource, CSSPropertyWebkitMaskBoxImage, source ? *source : *CSSPropertyMetadata::initialValue(CSSPropertyWebkitMaskBoxImageSource), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageSlice, CSSPropertyWebkitMaskBoxImage, slice ? *slice : *CSSPropertyMetadata::initialValue(CSSPropertyWebkitMaskBoxImageSlice), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageWidth, CSSPropertyWebkitMaskBoxImage, width ? *width : *CSSPropertyMetadata::initialValue(CSSPropertyWebkitMaskBoxImageWidth), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageOutset, CSSPropertyWebkitMaskBoxImage, outset ? *outset : *CSSPropertyMetadata::initialValue(CSSPropertyWebkitMaskBoxImageOutset), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageRepeat, CSSPropertyWebkitMaskBoxImage, repeat ? *repeat : *CSSPropertyMetadata::initialValue(CSSPropertyWebkitMaskBoxImageRepeat), important);
             return true;
         case CSSPropertyBorderImage:
-            addProperty(CSSPropertyBorderImageSource, CSSPropertyBorderImage, source ? *source : *CSSInitialValue::createLegacyImplicit(), important);
-            addProperty(CSSPropertyBorderImageSlice, CSSPropertyBorderImage, slice ? *slice : *CSSInitialValue::createLegacyImplicit(), important);
-            addProperty(CSSPropertyBorderImageWidth, CSSPropertyBorderImage, width ? *width : *CSSInitialValue::createLegacyImplicit(), important);
-            addProperty(CSSPropertyBorderImageOutset, CSSPropertyBorderImage, outset ? *outset : *CSSInitialValue::createLegacyImplicit(), important);
-            addProperty(CSSPropertyBorderImageRepeat, CSSPropertyBorderImage, repeat ? *repeat : *CSSInitialValue::createLegacyImplicit(), important);
+            addProperty(CSSPropertyBorderImageSource, CSSPropertyBorderImage, source ? *source : *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageSource), important);
+            addProperty(CSSPropertyBorderImageSlice, CSSPropertyBorderImage, slice ? *slice : *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageSlice), important);
+            addProperty(CSSPropertyBorderImageWidth, CSSPropertyBorderImage, width ? *width : *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageWidth), important);
+            addProperty(CSSPropertyBorderImageOutset, CSSPropertyBorderImage, outset ? *outset : *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageOutset), important);
+            addProperty(CSSPropertyBorderImageRepeat, CSSPropertyBorderImage, repeat ? *repeat : *CSSPropertyMetadata::initialValue(CSSPropertyBorderImageRepeat), important);
             return true;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     }
     return false;
 }
 
 static inline CSSValueID mapFromPageBreakBetween(CSSValueID value)
@@ skipping 167 matching lines @@
                     if (valueY) {
                         parsedLonghand[i + 1] = true;
                         addBackgroundValue(longhands[i + 1], valueY);
                     }
                 }
             }
             if (!foundProperty)
                 return false;
         } while (!m_range.atEnd() && m_range.peek().type() != CommaToken);
 
-        // TODO(timloh): This will make invalid longhands, see crbug.com/386459
         for (size_t i = 0; i < longhandCount; ++i) {
             CSSPropertyID property = shorthand.properties()[i];
             if (property == CSSPropertyBackgroundColor && !m_range.atEnd()) {
                 if (parsedLonghand[i])
                     return false; // Colors are only allowed in the last layer.
                 continue;
             }
             if ((property == CSSPropertyBackgroundClip || property == CSSPropertyWebkitMaskClip) && !parsedLonghand[i] && originValue) {
                 addBackgroundValue(longhands[i], originValue);
                 continue;
             }
             if (!parsedLonghand[i])
-                addBackgroundValue(longhands[i], CSSInitialValue::createLegacyImplicit());
+                addBackgroundValue(longhands[i], CSSPropertyMetadata::initialValue(property));
         }
     } while (consumeCommaIncludingWhitespace(m_range));
     if (!m_range.atEnd())
         return false;
 
     for (size_t i = 0; i < longhandCount; ++i) {
         CSSPropertyID property = shorthand.properties()[i];
         if (property == CSSPropertyBackgroundSize && longhands[i] && m_context.useLegacyBackgroundSizeShorthandBehavior())
             continue;
         addProperty(property, shorthand.id(), *longhands[i], important, implicit);
@@ skipping 159 matching lines @@
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
     ASSERT(shorthandForProperty(CSSPropertyGrid).length() == 8);
 
     CSSParserTokenRange rangeCopy = m_range;
 
     // 1- <grid-template>
     if (consumeGridTemplateShorthand(CSSPropertyGrid, important)) {
         // It can only be specified the explicit or the implicit grid properties in a single grid declaration.
         // The sub-properties not specified are set to their initial value, as normal for shorthands.
-        addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
-        addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
-        addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
-        addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
-        addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
+        addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridAutoFlow), important);
+        addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridAutoColumns), important);
+        addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridAutoRows), important);
+        addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridColumnGap), important);
+        addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridRowGap), important);
         return true;
     }
 
     m_range = rangeCopy;
 
     // 2- <grid-auto-flow> [ <grid-auto-rows> [ / <grid-auto-columns> ]? ]
     CSSValueList* gridAutoFlow = consumeGridAutoFlow(m_range);
     if (!gridAutoFlow)
         return false;
 
     CSSValue* autoColumnsValue = nullptr;
     CSSValue* autoRowsValue = nullptr;
 
     if (!m_range.atEnd()) {
         autoRowsValue = consumeGridTrackList(m_range, m_context.mode(), GridAuto);
         if (!autoRowsValue)
             return false;
         if (consumeSlashIncludingWhitespace(m_range)) {
             autoColumnsValue = consumeGridTrackList(m_range, m_context.mode(), GridAuto);
             if (!autoColumnsValue)
                 return false;
         }
         if (!m_range.atEnd())
             return false;
     } else {
         // Other omitted values are set to their initial values.
-        autoColumnsValue = CSSInitialValue::createLegacyImplicit();
-        autoRowsValue = CSSInitialValue::createLegacyImplicit();
+        autoColumnsValue = CSSPropertyMetadata::initialValue(CSSPropertyGridAutoColumns);
+        autoRowsValue = CSSPropertyMetadata::initialValue(CSSPropertyGridAutoRows);
     }
 
     // if <grid-auto-columns> value is omitted, it is set to the value specified for grid-auto-rows.
     if (!autoColumnsValue)
         autoColumnsValue = autoRowsValue;
 
     // It can only be specified the explicit or the implicit grid properties in a single grid declaration.
     // The sub-properties not specified are set to their initial value, as normal for shorthands.
-    addProperty(CSSPropertyGridTemplateColumns, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
-    addProperty(CSSPropertyGridTemplateRows, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
-    addProperty(CSSPropertyGridTemplateAreas, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
+    addProperty(CSSPropertyGridTemplateColumns, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridTemplateColumns), important);
+    addProperty(CSSPropertyGridTemplateRows, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridTemplateRows), important);
+    addProperty(CSSPropertyGridTemplateAreas, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridTemplateAreas), important);
     addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, *gridAutoFlow, important);
     addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, *autoColumnsValue, important);
     addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, *autoRowsValue, important);
-    addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
-    addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, *CSSInitialValue::createLegacyImplicit(), important);
+    addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridColumnGap), important);
+    addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, *CSSPropertyMetadata::initialValue(CSSPropertyGridRowGap), important);
     return true;
 }
 
 bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, bool important)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
 
     switch (property) {
     case CSSPropertyWebkitMarginCollapse: {
         CSSValueID id = m_range.consumeIncludingWhitespace().id();
@@ skipping 171 matching lines @@
     case CSSPropertyGridTemplate:
         return consumeGridTemplateShorthand(CSSPropertyGridTemplate, important);
     case CSSPropertyGrid:
         return consumeGridShorthand(important);
     default:
         return false;
     }
 }
 
 } // namespace blink