Change Rect and Quad to be CSSValues

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 28 matching lines @@
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSImageSetValue.h"
 #include "core/css/CSSImageValue.h"
 #include "core/css/CSSLineBoxContainValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSProperty.h"
 #include "core/css/CSSPropertyMetadata.h"
+#include "core/css/CSSQuadValue.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSSVGDocumentValue.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/HashTools.h"
 #include "core/css/Pair.h"
-#include "core/css/Rect.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/style/GridCoordinate.h"
 #include "core/svg/SVGPathUtilities.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
 
@@ skipping 858 matching lines @@
     case CSSPropertyWebkitBorderImage: {
         if (RefPtrWillBeRawPtr<CSSValue> result = parseBorderImage(propId)) {
             addProperty(propId, result, important);
             return true;
         }
         return false;
     }
 
     case CSSPropertyBorderImageOutset:
     case CSSPropertyWebkitMaskBoxImageOutset: {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
+        RefPtrWillBeRawPtr<CSSQuadValue> result = nullptr;
         if (parseBorderImageOutset(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageRepeat:
     case CSSPropertyWebkitMaskBoxImageRepeat: {
         RefPtrWillBeRawPtr<CSSValue> result = nullptr;
         if (parseBorderImageRepeat(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageSlice:
     case CSSPropertyWebkitMaskBoxImageSlice: {
         RefPtrWillBeRawPtr<CSSBorderImageSliceValue> result = nullptr;
         if (parseBorderImageSlice(propId, result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageWidth:
     case CSSPropertyWebkitMaskBoxImageWidth: {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
+        RefPtrWillBeRawPtr<CSSQuadValue> result = nullptr;
         if (parseBorderImageWidth(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderTopRightRadius:
     case CSSPropertyBorderTopLeftRadius:
     case CSSPropertyBorderBottomLeftRadius:
     case CSSPropertyBorderBottomRightRadius: {
@@ skipping 3004 matching lines @@
             listStyleID = i->id;
         else
             return nullptr;
 
         listStyle = cssValuePool().createIdentifierValue(listStyleID);
     }
 
     return CSSCounterValue::create(identifier.release(), listStyle.release(), separator.release());
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseClipShape()
+PassRefPtrWillBeRawPtr<CSSQuadValue> CSSPropertyParser::parseClipShape()
 {
     CSSParserValue* value = m_valueList->current();
     CSSParserValueList* args = value->function->args.get();
 
     if (value->function->id != CSSValueRect || !args)
         return nullptr;
 
     // rect(t, r, b, l) || rect(t r b l)
     if (args->size() != 4 && args->size() != 7)
         return nullptr;
-    RefPtrWillBeRawPtr<Rect> rect = Rect::create();
     int i = 0;
     CSSParserValue* a = args->current();
+
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> top = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> right = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> bottom = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> left = nullptr;
     while (a) {
         if (a->id != CSSValueAuto && !validUnit(a, FLength | FUnitlessQuirk))
             return nullptr;
         RefPtrWillBeRawPtr<CSSPrimitiveValue> length = a->id == CSSValueAuto ?
             cssValuePool().createIdentifierValue(CSSValueAuto) :
             createPrimitiveNumericValue(a);
         if (i == 0)
-            rect->setTop(length);
+            top = length;
         else if (i == 1)
-            rect->setRight(length);
+            right = length;
         else if (i == 2)
-            rect->setBottom(length);
+            bottom = length;
         else
-            rect->setLeft(length);
+            left = length;
         a = args->next();
         if (a && args->size() == 7) {
             if (!consumeComma(args))
                 return nullptr;
             a = args->current();
         }
         i++;
     }
     m_valueList->next();
-    return cssValuePool().createValue(rect.release());
+    return CSSQuadValue::createRect(top, right, bottom, left);
 }
 
 static void completeBorderRadii(RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[4])
 {
     if (radii[3])
         return;
     if (!radii[2]) {
         if (!radii[1])
             radii[1] = radii[0];
         radii[2] = radii[0];
@@ skipping 1459 matching lines @@
         if (!m_borderWidth && !m_allowWidth) {
             m_allowForwardSlashOperator = true;
             m_allowWidth = true;
             m_requireOutset = false;
         } else {
             m_allowForwardSlashOperator = false;
             m_requireOutset = true;
             m_allowWidth = false;
         }
     }
-    void commitBorderWidth(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> width)
+    void commitBorderWidth(PassRefPtrWillBeRawPtr<CSSQuadValue> width)
     {
         m_borderWidth = width;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowForwardSlashOperator = true;
         m_allowImageSlice = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImage = !m_image;
         m_allowRepeat = !m_repeat;
     }
-    void commitBorderOutset(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> outset)
+    void commitBorderOutset(PassRefPtrWillBeRawPtr<CSSQuadValue> outset)
     {
         m_outset = outset;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowImageSlice = false;
         m_allowForwardSlashOperator = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImage = !m_image;
         m_allowRepeat = !m_repeat;
@@ skipping 22 matching lines @@
     bool m_allowImage;
     bool m_allowImageSlice;
     bool m_allowRepeat;
     bool m_allowForwardSlashOperator;
 
     bool m_allowWidth;
     bool m_requireOutset;
 
     RefPtrWillBeMember<CSSValue> m_image;
     RefPtrWillBeMember<CSSBorderImageSliceValue> m_imageSlice;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_borderWidth;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_outset;
+    RefPtrWillBeMember<CSSQuadValue> m_borderWidth;
+    RefPtrWillBeMember<CSSQuadValue> m_outset;
 
     RefPtrWillBeMember<CSSValue> m_repeat;
 };
 
 bool CSSPropertyParser::buildBorderImageParseContext(CSSPropertyID propId, BorderImageParseContext& context)
 {
     CSSPropertyParser::ShorthandScope scope(this, propId);
     while (CSSParserValue* val = m_valueList->current()) {
         context.setCanAdvance(false);
 
@@ skipping 25 matching lines @@
                 context.commitImageSlice(imageSlice.release());
         }
 
         if (!context.canAdvance() && context.allowRepeat()) {
             RefPtrWillBeRawPtr<CSSValue> repeat = nullptr;
             if (parseBorderImageRepeat(repeat))
                 context.commitRepeat(repeat.release());
         }
 
         if (!context.canAdvance() && context.allowWidth()) {
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> borderWidth = nullptr;
+            RefPtrWillBeRawPtr<CSSQuadValue> borderWidth = nullptr;
             if (parseBorderImageWidth(borderWidth))
                 context.commitBorderWidth(borderWidth.release());
         }
 
         if (!context.canAdvance() && context.requireOutset()) {
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> borderOutset = nullptr;
+            RefPtrWillBeRawPtr<CSSQuadValue> borderOutset = nullptr;
             if (parseBorderImageOutset(borderOutset))
                 context.commitBorderOutset(borderOutset.release());
         }
 
         if (!context.canAdvance())
             return false;
 
         m_valueList->next();
     }
 
@@ skipping 124 matching lines @@
             m_bottom = m_top;
             m_left = m_top;
         }
         if (!m_bottom) {
             m_bottom = m_top;
             m_left = m_right;
         }
         if (!m_left)
             m_left = m_right;
 
-        // Now build a rect value to hold all four of our primitive values.
-        RefPtrWillBeRawPtr<Quad> quad = Quad::create();
-        quad->setTop(m_top);
-        quad->setRight(m_right);
-        quad->setBottom(m_bottom);
-        quad->setLeft(m_left);
-
-        // Make our new border image value now.
-        return CSSBorderImageSliceValue::create(cssValuePool().createValue(quad.release()), m_fill);
+        return CSSBorderImageSliceValue::create(CSSQuadValue::createQuad(m_top, m_right, m_bottom, m_left), m_fill);
     }
 
 private:
     bool m_allowNumber;
     bool m_allowFill;
     bool m_allowFinalCommit;
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_top;
     RefPtrWillBeMember<CSSPrimitiveValue> m_right;
     RefPtrWillBeMember<CSSPrimitiveValue> m_bottom;
@@ skipping 61 matching lines @@
             ASSERT(!m_left);
             m_left = val;
         }
 
         m_allowNumber = !m_left;
         m_allowFinalCommit = true;
     }
 
     void setTop(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val) { m_top = val; }
 
-    PassRefPtrWillBeRawPtr<CSSPrimitiveValue> commitBorderImageQuad()
+    PassRefPtrWillBeRawPtr<CSSQuadValue> commitBorderImageQuad()
     {
         // We need to clone and repeat values for any omissions.
         ASSERT(m_top);
         if (!m_right) {
             m_right = m_top;
             m_bottom = m_top;
             m_left = m_top;
         }
         if (!m_bottom) {
             m_bottom = m_top;
             m_left = m_right;
         }
         if (!m_left)
             m_left = m_right;
 
-        // Now build a quad value to hold all four of our primitive values.
-        RefPtrWillBeRawPtr<Quad> quad = Quad::create();
-        quad->setTop(m_top);
-        quad->setRight(m_right);
-        quad->setBottom(m_bottom);
-        quad->setLeft(m_left);
-
-        // Make our new value now.
-        return cssValuePool().createValue(quad.release());
+        return CSSQuadValue::createQuad(m_top, m_right, m_bottom, m_left);
     }
 
 private:
     bool m_allowNumber;
     bool m_allowFinalCommit;
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_top;
     RefPtrWillBeMember<CSSPrimitiveValue> m_right;
     RefPtrWillBeMember<CSSPrimitiveValue> m_bottom;
     RefPtrWillBeMember<CSSPrimitiveValue> m_left;
 };
 
-bool CSSPropertyParser::parseBorderImageQuad(Units validUnits, RefPtrWillBeRawPtr<CSSPrimitiveValue>& result)
+bool CSSPropertyParser::parseBorderImageQuad(Units validUnits, RefPtrWillBeRawPtr<CSSQuadValue>& result)
 {
     BorderImageQuadParseContext context;
     for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->next()) {
         if (context.allowNumber() && (validUnit(val, validUnits, HTMLStandardMode) || val->id == CSSValueAuto)) {
             if (val->id == CSSValueAuto)
                 context.commitNumber(cssValuePool().createIdentifierValue(val->id));
             else
                 context.commitNumber(createPrimitiveNumericValue(val));
         } else if (!inShorthand()) {
             // If we're not parsing a shorthand then we are invalid.
             return false;
         } else {
             if (context.allowFinalCommit())
                 m_valueList->previous(); // The shorthand loop will advance back to this point.
             break;
         }
     }
 
     if (context.allowFinalCommit()) {
         // Need to fully commit as a single value.
         result = context.commitBorderImageQuad();
         return true;
     }
     return false;
 }
 
-bool CSSPropertyParser::parseBorderImageWidth(RefPtrWillBeRawPtr<CSSPrimitiveValue>& result)
+bool CSSPropertyParser::parseBorderImageWidth(RefPtrWillBeRawPtr<CSSQuadValue>& result)
 {
     return parseBorderImageQuad(FLength | FNumber | FNonNeg | FPercent, result);
 }
 
-bool CSSPropertyParser::parseBorderImageOutset(RefPtrWillBeRawPtr<CSSPrimitiveValue>& result)
+bool CSSPropertyParser::parseBorderImageOutset(RefPtrWillBeRawPtr<CSSQuadValue>& result)
 {
     return parseBorderImageQuad(FLength | FNumber | FNonNeg, result);
 }
 
 bool CSSPropertyParser::parseBorderRadius(CSSPropertyID unresolvedProperty, bool important)
 {
     unsigned num = m_valueList->size();
     if (num > 9)
         return false;
 
@@ skipping 2181 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink