CL for perf tryjob on win

Source/build/scripts/templates/StyleBuilderFunctions.cpp.tmpl

 {% from 'macros.tmpl' import license %}
 {#
     This file is for property handlers which use the templating engine to
     reduce (handwritten) code duplication.
 
     The `properties' dict can be used to access a property's parameters in
     jinja2 templates (i.e. setter, getter, initial, type_name)
 #}
 #include "config.h"
 #include "StyleBuilderFunctions.h"
 
 #include "CSSValueKeywords.h"
 #include "core/css/BasicShapeFunctions.h"
 #include "core/css/CSSContentDistributionValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/Pair.h"
 #include "core/css/resolver/StyleResolverState.h"
 
 {% macro declare_initial_function(property_id) %}
 void StyleBuilderFunctions::applyInitial{{property_id}}(StyleResolverState& state)
 {%- endmacro %}
 {% macro declare_inherit_function(property_id) %}
 void StyleBuilderFunctions::applyInherit{{property_id}}(StyleResolverState& state)
 {%- endmacro %}
 {% macro declare_value_function(property_id) %}
-void StyleBuilderFunctions::applyValue{{property_id}}(StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValue{{property_id}}(StyleResolverState& state, CSSValue value)
 {%- endmacro %}
 {% macro set_value(property) %}
 {% if property.svg %}
 state.style()->accessSVGStyle().{{property.setter}}
 {%- elif property.font %}
 state.fontBuilder().{{property.setter}}
 {%- else %}
 state.style()->{{property.setter}}
 {%- endif %}
 {% endmacro %}
 {% macro convert_and_set_value(property) %}
 {% if property.converter %}
 {{set_value(property)}}(StyleBuilderConverter::{{property.converter}}(state, value));
 {%- else %}
-{{set_value(property)}}(static_cast<{{property.type_name}}>(*toCSSPrimitiveValue(value)));
+{{set_value(property)}}(static_cast<{{property.type_name}}>(toCSSPrimitiveValue(value)));
 {%- endif %}
 {% endmacro %}
 
 namespace blink {
 
 {% for property_id, property in properties.items() if property.should_declare_functions %}
 {% set apply_type = property.apply_type %}
 {% if not property.custom_initial %}
 {{declare_initial_function(property_id)}}
 {
@@ skipping 44 matching lines @@
     if (!parentData)
         applyInitial{{property_id}}(state);
     else
         state.style()->access{{animation}}s().{{vector}} = parentData->{{vector}};
 }
 
 {{declare_value_function(property_id)}}
 {
     CSS{{animation}}Data& data = state.style()->access{{animation}}s();
     data.{{vector}}.clear();
-    for (auto& listValue : toCSSValueList(*value))
-        data.{{vector}}.append(CSSToStyleMap::mapAnimation{{attribute}}(listValue.get()));
+    for (auto& listValue : toCSSValueList(value))
+        data.{{vector}}.append(CSSToStyleMap::mapAnimation{{attribute}}(listValue));
 }
 {% endmacro %}
 {{apply_animation('CSSPropertyAnimationDelay', 'Delay', 'Animation')}}
 {{apply_animation('CSSPropertyAnimationDirection', 'Direction', 'Animation')}}
 {{apply_animation('CSSPropertyAnimationDuration', 'Duration', 'Animation')}}
 {{apply_animation('CSSPropertyAnimationFillMode', 'FillMode', 'Animation')}}
 {{apply_animation('CSSPropertyAnimationIterationCount', 'IterationCount', 'Animation')}}
 {{apply_animation('CSSPropertyAnimationName', 'Name', 'Animation')}}
 {{apply_animation('CSSPropertyAnimationPlayState', 'PlayState', 'Animation')}}
 {{apply_animation('CSSPropertyAnimationTimingFunction', 'TimingFunction', 'Animation')}}
@@ skipping 14 matching lines @@
 {{declare_inherit_function(property_id)}}
 {
     if (state.parentStyle()->{{auto_getter}}())
         state.style()->{{auto_setter}}();
     else
         {{set_value(property)}}(state.parentStyle()->{{property.getter}}());
 }
 
 {{declare_value_function(property_id)}}
 {
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getValueID() == {{auto_identity}})
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    if (primitiveValue.getValueID() == {{auto_identity}})
         state.style()->{{auto_setter}}();
     else
         {{convert_and_set_value(property)}}
 }
 {% endmacro %}
 {{apply_auto('CSSPropertyClip')}}
 {{apply_auto('CSSPropertyOrphans')}}
 {{apply_auto('CSSPropertyWebkitColumnCount')}}
 {{apply_auto('CSSPropertyWebkitColumnGap', auto_getter='hasNormalColumnGap', auto_setter='setHasNormalColumnGap', auto_identity='CSSValueNormal')}}
 {{apply_auto('CSSPropertyWebkitColumnWidth')}}
@@ skipping 175 matching lines @@
     for (Iterator it = parentMap->begin(); it != end; ++it) {
         CounterDirectives& directives = map.add(it->key, CounterDirectives()).storedValue->value;
         directives.inherit{{action}}(it->value);
     }
 }
 
 {{declare_value_function(property_id)}}
 {
     state.style()->clear{{action}}Directives();
 
-    if (!value->isValueList()) {
-        ASSERT(value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNone);
+    if (!value.isValueList()) {
+        ASSERT(value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
         return;
     }
 
     CounterDirectiveMap& map = state.style()->accessCounterDirectives();
 
-    CSSValueList* list = toCSSValueList(value);
+    CSSValueList& list = toCSSValueList(value);
 
-    int length = list ? list->length() : 0;
+    int length = list.length();
     for (int i = 0; i < length; ++i) {
-        CSSValue* currValue = list->item(i);
-        if (!currValue->isPrimitiveValue())
+        CSSValue currValue = list.item(i);
+        if (!currValue.isPrimitiveValue())
             continue;
 
-        Pair* pair = toCSSPrimitiveValue(currValue)->getPairValue();
+        Pair* pair = toCSSPrimitiveValue(currValue).getPairValue();
         if (!pair || !pair->first() || !pair->second())
             continue;
 
         AtomicString identifier(pair->first()->getStringValue());
         int value = pair->second()->getIntValue();
         CounterDirectives& directives = map.add(identifier, CounterDirectives()).storedValue->value;
         {% if action == 'Reset' %}
         directives.setResetValue(value);
         {% else %}
         directives.addIncrementValue(value);
@@ skipping 36 matching lines @@
         /* Reset any remaining layers to not have the property set. */
         currChild->clear{{fill_type}}();
         currChild = currChild->next();
     }
 }
 
 {{declare_value_function(property_id)}}
 {
     FillLayer* currChild = &state.style()->{{access_layers}}();
     FillLayer* prevChild = 0;
-    if (value->isValueList() && !value->isImageSetValue()) {
+    if (value.isValueList() && !value.isImageSetValue()) {
         /* Walk each value and put it into a layer, creating new layers as needed. */
-        CSSValueList* valueList = toCSSValueList(value);
-        for (unsigned int i = 0; i < valueList->length(); i++) {
+        CSSValueList& valueList = toCSSValueList(value);
+        for (unsigned int i = 0; i < valueList.length(); i++) {
             if (!currChild)
                 currChild = prevChild->ensureNext();
-            CSSToStyleMap::{{map_fill}}(state, currChild, valueList->item(i));
+            CSSToStyleMap::{{map_fill}}(state, currChild, valueList.item(i));
             prevChild = currChild;
             currChild = currChild->next();
         }
     } else {
         CSSToStyleMap::{{map_fill}}(state, currChild, value);
         currChild = currChild->next();
     }
     while (currChild) {
         /* Reset all remaining layers to not have the property set. */
         currChild->clear{{fill_type}}();
@@ skipping 75 matching lines @@
         svgParentStyle.{{paint_type|lower_first}}Type(),
         svgParentStyle.{{paint_type|lower_first}}Color(),
         svgParentStyle.{{paint_type|lower_first}}Uri(),
         state.applyPropertyToRegularStyle(),
         state.applyPropertyToVisitedLinkStyle());
 }
 
 {{declare_value_function(property_id)}}
 {
     String url;
-    if (value->isValueList()) {
-        CSSValueList* list = toCSSValueList(value);
-        ASSERT(list->length() > 1);
+    if (value.isValueList()) {
+        CSSValueList& list = toCSSValueList(value);
+        ASSERT(list.length() > 1);
 
-        if (!list->item(0)->isPrimitiveValue())
+        if (!list.item(0).isPrimitiveValue())
             return;
 
-        CSSPrimitiveValue* pValue = toCSSPrimitiveValue(list->item(0));
-        if (!pValue->isURI())
+        CSSPrimitiveValue& pValue = toCSSPrimitiveValue(list.item(0));
+        if (!pValue.isURI())
             return;
 
-        url = pValue->getStringValue();
-        value = list->item(1);
+        url = pValue.getStringValue();
+        value = list.item(1);
     }
-    if (value->isPrimitiveValue()) {
-        CSSPrimitiveValue* pValue = toCSSPrimitiveValue(value);
+    if (value.isPrimitiveValue()) {
+        CSSPrimitiveValue& pValue = toCSSPrimitiveValue(value);
         Color c;
         SVGPaintType ptype = SVG_PAINTTYPE_RGBCOLOR;
-        if (pValue->isRGBColor()) {
-            c = pValue->getRGBA32Value();
+        if (pValue.isRGBColor()) {
+            c = pValue.getRGBA32Value();
             ptype = url.isEmpty() ? SVG_PAINTTYPE_RGBCOLOR : SVG_PAINTTYPE_URI_RGBCOLOR;
-        } else if (pValue->getValueID() == CSSValueCurrentcolor) {
+        } else if (pValue.getValueID() == CSSValueCurrentcolor) {
             c = state.style()->color();
             ptype = url.isEmpty() ? SVG_PAINTTYPE_CURRENTCOLOR : SVG_PAINTTYPE_URI_CURRENTCOLOR;
-        } else if (pValue->getValueID() == CSSValueNone) {
+        } else if (pValue.getValueID() == CSSValueNone) {
             ptype = url.isEmpty() ? SVG_PAINTTYPE_NONE : SVG_PAINTTYPE_URI_NONE;
-        } else if (pValue->isURI()) {
+        } else if (pValue.isURI()) {
             ptype = SVG_PAINTTYPE_URI;
-            url = pValue->getStringValue();
+            url = pValue.getStringValue();
         } else {
             return;
         }
         {{set_value(property)}}(ptype, c, url,
             state.applyPropertyToRegularStyle(),
             state.applyPropertyToVisitedLinkStyle());
     }
 }
 {% endmacro %}
 {{apply_svg_paint('CSSPropertyFill', 'FillPaint')}}
 {{apply_svg_paint('CSSPropertyStroke', 'StrokePaint')}}
 } // namespace blink