Changed Pair to be a CSSValue

Source/core/css/resolver/StyleBuilderConverter.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 18 matching lines @@
 
 #include "core/css/BasicShapeFunctions.h"
 #include "core/css/CSSContentDistributionValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSQuadValue.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSShadowValue.h"
-#include "core/css/Pair.h"
+#include "core/css/CSSValuePair.h"
 #include "core/svg/SVGElement.h"
 #include "core/svg/SVGURIReference.h"
 #include "platform/transforms/RotateTransformOperation.h"
 #include "platform/transforms/ScaleTransformOperation.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 278 matching lines @@
     if (angle > 45.0f && angle <= 135.0f)
         return GO_90DEG;
     if (angle > 135.0f && angle <= 225.0f)
         return GO_180DEG;
     return GO_270DEG;
 }
 
 StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignmentData(StyleResolverState&, CSSValue* value)
 {
     StyleSelfAlignmentData alignmentData = ComputedStyle::initialSelfAlignment();
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (Pair* pairValue = primitiveValue->getPairValue()) {
-        if (pairValue->first()->getValueID() == CSSValueLegacy) {
+    if (value->isValuePair()) {
+        const CSSValuePair* pair = toCSSValuePair(value);
+        if (toCSSPrimitiveValue(pair->first())->getValueID() == CSSValueLegacy) {
             alignmentData.setPositionType(LegacyPosition);
-            alignmentData.setPosition(*pairValue->second());
+            alignmentData.setPosition(*toCSSPrimitiveValue(pair->second()));
         } else {
-            alignmentData.setPosition(*pairValue->first());
-            alignmentData.setOverflow(*pairValue->second());
+            alignmentData.setPosition(*toCSSPrimitiveValue(pair->first()));
+            alignmentData.setOverflow(*toCSSPrimitiveValue(pair->second()));
         }
     } else {
-        alignmentData.setPosition(*primitiveValue);
+        ASSERT(value->isPrimitiveValue());

[Timothy Loh, 2015/08/28 05:51:46]

toCSSPrimitiveValue will do this assertion

[sashab, 2015/08/31 00:33:51]

Just wanted to make it explicit, but you're right. Done.

+        alignmentData.setPosition(*toCSSPrimitiveValue(value));
     }
     return alignmentData;
 }
 
 StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentData(StyleResolverState&, CSSValue* value)
 {
     StyleContentAlignmentData alignmentData = ComputedStyle::initialContentAlignment();
     CSSContentDistributionValue* contentValue = toCSSContentDistributionValue(value);
     if (contentValue->distribution()->getValueID() != CSSValueInvalid)
         alignmentData.setDistribution(*contentValue->distribution());
@@ skipping 268 matching lines @@
 float StyleBuilderConverter::convertNumberOrPercentage(StyleResolverState& state, CSSValue* value)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     ASSERT(primitiveValue->isNumber() || primitiveValue->isPercentage());
     if (primitiveValue->isNumber())
         return primitiveValue->getFloatValue();
     return primitiveValue->getFloatValue() / 100.0f;
 }
 
 template <CSSValueID cssValueFor0, CSSValueID cssValueFor100>
-static Length convertPositionLength(StyleResolverState& state, CSSPrimitiveValue* primitiveValue)
+static Length convertPositionLength(StyleResolverState& state, CSSValue* value)
 {
-    if (Pair* pair = primitiveValue->getPairValue()) {
+    if (value->isValuePair()) {
+        const CSSValuePair* pair = toCSSValuePair(value);
         Length length = StyleBuilderConverter::convertLength(state, pair->second());
-        if (pair->first()->getValueID() == cssValueFor0)
+        if (toCSSPrimitiveValue(pair->first())->getValueID() == cssValueFor0)
             return length;
-        ASSERT(pair->first()->getValueID() == cssValueFor100);
+        ASSERT(toCSSPrimitiveValue(pair->first())->getValueID() == cssValueFor100);
         return length.subtractFromOneHundredPercent();
     }
 
-    return StyleBuilderConverter::convertLength(state, primitiveValue);
+    ASSERT(value->isPrimitiveValue());

[Timothy Loh, 2015/08/28 05:51:46]

convertLength will do all the relevant assertions

[sashab, 2015/08/31 00:33:51]

Done.

+    return StyleBuilderConverter::convertLength(state, value);
 }
 
 LengthPoint StyleBuilderConverter::convertPosition(StyleResolverState& state, CSSValue* value)
 {
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    Pair* pair = primitiveValue->getPairValue();
+    const CSSValuePair* pair = toCSSValuePair(value);
     return LengthPoint(
         convertPositionLength<CSSValueLeft, CSSValueRight>(state, pair->first()),
         convertPositionLength<CSSValueTop, CSSValueBottom>(state, pair->second())
     );
 }
 
 static float convertPerspectiveLength(StyleResolverState& state, CSSPrimitiveValue* primitiveValue)
 {
     return std::max(primitiveValue->computeLength<float>(state.cssToLengthConversionData()), 0.0f);
 }
@@ skipping 81 matching lines @@
             quotes->addPair(std::make_pair(startQuote, endQuote));
         }
         return quotes.release();
     }
     // FIXME: We should assert we're a primitive value with valueID = CSSValueNone
     return QuotesData::create();
 }
 
 LengthSize StyleBuilderConverter::convertRadius(StyleResolverState& state, CSSValue* value)
 {
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    Pair* pair = primitiveValue->getPairValue();
-    Length radiusWidth = pair->first()->convertToLength(state.cssToLengthConversionData());
-    Length radiusHeight = pair->second()->convertToLength(state.cssToLengthConversionData());
+    const CSSValuePair* pair = toCSSValuePair(value);
+    Length radiusWidth = toCSSPrimitiveValue(pair->first())->convertToLength(state.cssToLengthConversionData());
+    Length radiusHeight = toCSSPrimitiveValue(pair->second())->convertToLength(state.cssToLengthConversionData());
     float width = radiusWidth.value();
     float height = radiusHeight.value();
     ASSERT(width >= 0 && height >= 0);
     if (width <= 0 || height <= 0)
         return LengthSize(Length(0, Fixed), Length(0, Fixed));
     return LengthSize(radiusWidth, radiusHeight);
 }
 
 PassRefPtr<ShadowList> StyleBuilderConverter::convertShadow(StyleResolverState& state, CSSValue* value)
 {
@@ skipping 188 matching lines @@
     return ScaleTransformOperation::create(sx, sy, sz, TransformOperation::Scale3D);
 }
 
 RespectImageOrientationEnum StyleBuilderConverter::convertImageOrientation(StyleResolverState& state, CSSValue* value)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     return primitiveValue->getValueID() == CSSValueFromImage ? RespectImageOrientation : DoNotRespectImageOrientation;
 }
 
 } // namespace blink