Split out String, URI and CustomIdent from CSSPrimitiveValue

third_party/WebKit/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 19 matching lines @@
 #include "core/css/BasicShapeFunctions.h"
 #include "core/css/CSSBasicShapeValues.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/CSSStringValue.h"
+#include "core/css/CSSURIValue.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 38 matching lines @@
 }
 
 Color StyleBuilderConverter::convertColor(StyleResolverState& state, CSSValue* value, bool forVisitedLink)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     return state.document().textLinkColors().colorFromPrimitiveValue(primitiveValue, state.style()->color(), forVisitedLink);
 }
 
 AtomicString StyleBuilderConverter::convertFragmentIdentifier(StyleResolverState& state, CSSValue* value)
 {
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->isURI())
-        return SVGURIReference::fragmentIdentifierFromIRIString(primitiveValue->getStringValue(), state.element()->treeScope());
+    if (value->isURIValue())
+        return SVGURIReference::fragmentIdentifierFromIRIString(toCSSURIValue(value)->value(), state.element()->treeScope());
     return nullAtom;
 }
 
 LengthBox StyleBuilderConverter::convertClip(StyleResolverState& state, CSSValue* value)
 {
     RefPtrWillBeRawPtr<CSSQuadValue> rect = toCSSQuadValue(value);
 
     return LengthBox(convertLengthOrAuto(state, rect->top()),
         convertLengthOrAuto(state, rect->right()),
         convertLengthOrAuto(state, rect->bottom()),
@@ skipping 15 matching lines @@
         return FontDescription::FantasyFamily;
     case CSSValueMonospace:
         return FontDescription::MonospaceFamily;
     case CSSValueWebkitPictograph:
         return FontDescription::PictographFamily;
     default:
         return FontDescription::NoFamily;
     }
 }
 
-static bool convertFontFamilyName(StyleResolverState& state, CSSPrimitiveValue* primitiveValue,
+static bool convertFontFamilyName(StyleResolverState& state, CSSValue& value,
     FontDescription::GenericFamilyType& genericFamily, AtomicString& familyName)
 {
-    if (primitiveValue->isCustomIdent()) {
+    if (value.isCustomIdentValue()) {
         genericFamily = FontDescription::NoFamily;
-        familyName = AtomicString(primitiveValue->getStringValue());
+        familyName = AtomicString(toCSSCustomIdentValue(value).value());
     } else if (state.document().settings()) {
-        genericFamily = convertGenericFamily(primitiveValue->getValueID());
+        genericFamily = convertGenericFamily(toCSSPrimitiveValue(value).getValueID());
         familyName = state.fontBuilder().genericFontFamilyName(genericFamily);
     }
 
     return !familyName.isEmpty();
 }
 
 FontDescription::FamilyDescription StyleBuilderConverter::convertFontFamily(StyleResolverState& state, CSSValue* value)
 {
     ASSERT(value->isValueList());
 
     FontDescription::FamilyDescription desc(FontDescription::NoFamily);
     FontFamily* currFamily = nullptr;
 
     for (auto& family : toCSSValueList(*value)) {
         FontDescription::GenericFamilyType genericFamily = FontDescription::NoFamily;
         AtomicString familyName;
 
-        if (!convertFontFamilyName(state, toCSSPrimitiveValue(family.get()), genericFamily, familyName))
+        if (!convertFontFamilyName(state, *family, genericFamily, familyName))
             continue;
 
         if (!currFamily) {
             currFamily = &desc.family;
         } else {
             RefPtr<SharedFontFamily> newFamily = SharedFontFamily::create();
             currFamily->appendFamily(newFamily);
             currFamily = newFamily.get();
         }
 
@@ skipping 239 matching lines @@
     }
 }
 
 GridPosition StyleBuilderConverter::convertGridPosition(StyleResolverState&, CSSValue* value)
 {
     // We accept the specification's grammar:
     // 'auto' | [ <integer> || <custom-ident> ] | [ span && [ <integer> || <custom-ident> ] ] | <custom-ident>
 
     GridPosition position;
 
-    if (value->isPrimitiveValue()) {
-        CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+    if (value->isCustomIdentValue()) {
         // We translate <custom-ident> to <string> during parsing as it
         // makes handling it more simple.
-        if (primitiveValue->isCustomIdent()) {
-            position.setNamedGridArea(primitiveValue->getStringValue());
-            return position;
-        }
-
-        ASSERT(primitiveValue->getValueID() == CSSValueAuto);
+        position.setNamedGridArea(toCSSCustomIdentValue(value)->value());
         return position;
     }
 
+    if (value->isPrimitiveValue()) {
+        ASSERT(toCSSPrimitiveValue(value)->getValueID() == CSSValueAuto);
+        return position;
+    }
+
     CSSValueList* values = toCSSValueList(value);
     ASSERT(values->length());
 
     bool isSpanPosition = false;
     // The specification makes the <integer> optional, in which case it default to '1'.
     int gridLineNumber = 1;
     String gridLineName;
 
     auto it = values->begin();
-    CSSPrimitiveValue* currentValue = toCSSPrimitiveValue(it->get());
-    if (currentValue->getValueID() == CSSValueSpan) {
+    CSSValue* currentValue = it->get();
+    if (currentValue->isPrimitiveValue() && toCSSPrimitiveValue(currentValue)->getValueID() == CSSValueSpan) {
         isSpanPosition = true;
         ++it;
-        currentValue = it != values->end() ? toCSSPrimitiveValue(it->get()) : nullptr;
+        currentValue = it != values->end() ? it->get() : nullptr;
     }
 
-    if (currentValue && currentValue->isNumber()) {
-        gridLineNumber = currentValue->getIntValue();
+    if (currentValue && currentValue->isPrimitiveValue() && toCSSPrimitiveValue(currentValue)->isNumber()) {
+        gridLineNumber = toCSSPrimitiveValue(currentValue)->getIntValue();
         ++it;
-        currentValue = it != values->end() ? toCSSPrimitiveValue(it->get()) : nullptr;
+        currentValue = it != values->end() ? it->get() : nullptr;
     }
 
-    if (currentValue && currentValue->isCustomIdent()) {
-        gridLineName = currentValue->getStringValue();
+    if (currentValue && currentValue->isCustomIdentValue()) {
+        gridLineName = toCSSCustomIdentValue(currentValue)->value();
         ++it;
     }
 
     ASSERT(it == values->end());
     if (isSpanPosition)
         position.setSpanPosition(gridLineNumber, gridLineName);
     else
         position.setExplicitPosition(gridLineNumber, gridLineName);
 
     return position;
@@ skipping 15 matching lines @@
 {
     if (value->isPrimitiveValue()) {
         ASSERT(toCSSPrimitiveValue(value)->getValueID() == CSSValueNone);
         return;
     }
 
     size_t currentNamedGridLine = 0;
     for (auto& currValue : *toCSSValueList(value)) {
         if (currValue->isGridLineNamesValue()) {
             for (auto& namedGridLineValue : toCSSGridLineNamesValue(*currValue)) {
-                ASSERT(toCSSPrimitiveValue(namedGridLineValue.get())->isCustomIdent());
-                String namedGridLine = toCSSPrimitiveValue(namedGridLineValue.get())->getStringValue();
+                String namedGridLine = toCSSCustomIdentValue(*namedGridLineValue).value();
                 NamedGridLinesMap::AddResult result = namedGridLines.add(namedGridLine, Vector<size_t>());
                 result.storedValue->value.append(currentNamedGridLine);
                 OrderedNamedGridLines::AddResult orderedInsertionResult = orderedNamedGridLines.add(currentNamedGridLine, Vector<String>());
                 orderedInsertionResult.storedValue->value.append(namedGridLine);
             }
             continue;
         }
 
         ++currentNamedGridLine;
         trackSizes.append(convertGridTrackSize(state, currValue.get()));
@@ skipping 238 matching lines @@
     length.setQuirk(toCSSPrimitiveValue(value)->isQuirkyEms());
     return length;
 }
 
 PassRefPtr<QuotesData> StyleBuilderConverter::convertQuotes(StyleResolverState&, CSSValue* value)
 {
     if (value->isValueList()) {
         CSSValueList* list = toCSSValueList(value);
         RefPtr<QuotesData> quotes = QuotesData::create();
         for (size_t i = 0; i < list->length(); i += 2) {
-            CSSValue* first = list->item(i);
-            CSSValue* second = list->item(i + 1);
-            ASSERT(toCSSPrimitiveValue(first)->isString());
-            ASSERT(toCSSPrimitiveValue(second)->isString());
-            String startQuote = toCSSPrimitiveValue(first)->getStringValue();
-            String endQuote = toCSSPrimitiveValue(second)->getStringValue();
+            String startQuote = toCSSStringValue(list->item(i))->value();
+            String endQuote = toCSSStringValue(list->item(i + 1))->value();
             quotes->addPair(std::make_pair(startQuote, endQuote));
         }
         return quotes.release();
     }
     ASSERT(value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNone);
     return QuotesData::create();
 }
 
 LengthSize StyleBuilderConverter::convertRadius(StyleResolverState& state, CSSValue* value)
 {
@@ skipping 201 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