Do not zero-initialize RawPtr.

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 475 matching lines @@
     if (isKeywordPropertyID(propId)) {
         if (!isValidKeywordPropertyAndValue(propId, id, m_context))
             return false;
         if (m_valueList->next() && !inShorthand())
             return false;
         addProperty(propId, cssValuePool().createIdentifierValue(id), important);
         return true;
     }
 
     bool validPrimitive = false;
-    RefPtrWillBeRawPtr<CSSValue> parsedValue;
+    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
 
     switch (propId) {
     case CSSPropertySize:                 // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
         return parseSize(propId, important);
 
     case CSSPropertyQuotes:               // [<string> <string>]+ | none | inherit
         if (id)
             validPrimitive = true;
         else
             return parseQuotes(propId, important);
@@ skipping 20 matching lines @@
         break;
 
     /* Start of supported CSS properties with validation. This is needed for parseShorthand to work
      * correctly and allows optimization in WebCore::applyRule(..)
      */
     case CSSPropertyOverflow: {
         ShorthandScope scope(this, propId);
         if (num != 1 || !parseValue(CSSPropertyOverflowY, important))
             return false;
 
-        RefPtrWillBeRawPtr<CSSValue> overflowXValue;
+        RefPtrWillBeRawPtr<CSSValue> overflowXValue = nullptr;
 
         // FIXME: -webkit-paged-x or -webkit-paged-y only apply to overflow-y. If this value has been
         // set using the shorthand, then for now overflow-x will default to auto, but once we implement
         // pagination controls, it should default to hidden. If the overflow-y value is anything but
         // paged-x or paged-y, then overflow-x and overflow-y should have the same value.
         if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)
             overflowXValue = cssValuePool().createIdentifierValue(CSSValueAuto);
         else
             overflowXValue = m_parsedProperties.last().value();
         addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);
@@ skipping 74 matching lines @@
         break;
 
     case CSSPropertyCursor: {
         // Grammar defined by CSS3 UI and modified by CSS4 images:
         // [ [<image> [<x> <y>]?,]*
         // [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize |
         // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | ew-resize |
         // ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | text | wait | help |
         // vertical-text | cell | context-menu | alias | copy | no-drop | not-allowed | -webkit-zoom-in
         // -webkit-zoom-out | all-scroll | -webkit-grab | -webkit-grabbing ] ] | inherit
-        RefPtrWillBeRawPtr<CSSValueList> list;
+        RefPtrWillBeRawPtr<CSSValueList> list = nullptr;
         while (value) {
             RefPtrWillBeRawPtr<CSSValue> image = nullptr;
             if (value->unit == CSSPrimitiveValue::CSS_URI) {
                 String uri = value->string;
                 if (!uri.isNull())
                     image = CSSImageValue::create(uri, completeURL(uri));
             } else if (value->unit == CSSParserValue::Function && equalIgnoringCase(value->function->name, "-webkit-image-set(")) {
                 image = parseImageSet(m_valueList.get());
                 if (!image)
                     break;
@@ skipping 72 matching lines @@
     case CSSPropertyWebkitMaskImage:
     case CSSPropertyWebkitMaskOrigin:
     case CSSPropertyWebkitMaskPosition:
     case CSSPropertyWebkitMaskPositionX:
     case CSSPropertyWebkitMaskPositionY:
     case CSSPropertyWebkitMaskSize:
     case CSSPropertyWebkitMaskRepeat:
     case CSSPropertyWebkitMaskRepeatX:
     case CSSPropertyWebkitMaskRepeatY:
     {
-        RefPtrWillBeRawPtr<CSSValue> val1;
-        RefPtrWillBeRawPtr<CSSValue> val2;
+        RefPtrWillBeRawPtr<CSSValue> val1 = nullptr;
+        RefPtrWillBeRawPtr<CSSValue> val2 = nullptr;
         CSSPropertyID propId1, propId2;
         bool result = false;
         if (parseFillProperty(propId, propId1, propId2, val1, val2)) {
             OwnPtr<ShorthandScope> shorthandScope;
             if (propId == CSSPropertyBackgroundPosition ||
                 propId == CSSPropertyBackgroundRepeat ||
                 propId == CSSPropertyWebkitMaskPosition ||
                 propId == CSSPropertyWebkitMaskRepeat) {
                 shorthandScope = adoptPtr(new ShorthandScope(this, propId));
             }
@@ skipping 205 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;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageOutset(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageRepeat:
     case CSSPropertyWebkitMaskBoxImageRepeat: {
-        RefPtrWillBeRawPtr<CSSValue> result;
+        RefPtrWillBeRawPtr<CSSValue> result = nullptr;
         if (parseBorderImageRepeat(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageSlice:
     case CSSPropertyWebkitMaskBoxImageSlice: {
-        RefPtrWillBeRawPtr<CSSBorderImageSliceValue> result;
+        RefPtrWillBeRawPtr<CSSBorderImageSliceValue> result = nullptr;
         if (parseBorderImageSlice(propId, result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageWidth:
     case CSSPropertyWebkitMaskBoxImageWidth: {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> result;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageWidth(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderTopRightRadius:
     case CSSPropertyBorderTopLeftRadius:
     case CSSPropertyBorderBottomLeftRadius:
     case CSSPropertyBorderBottomRightRadius: {
         if (num != 1 && num != 2)
             return false;
         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
         if (!validPrimitive)
             return false;
         RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(value);
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = nullptr;
         if (num == 2) {
             value = m_valueList->next();
             validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
             if (!validPrimitive)
                 return false;
             parsedValue2 = createPrimitiveNumericValue(value);
         } else
             parsedValue2 = parsedValue1;
 
         addProperty(propId, createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release()), important);
@@ skipping 106 matching lines @@
                 addProperty(propId, transformValue.release(), important);
                 return true;
             }
             return false;
         }
         break;
     case CSSPropertyWebkitTransformOrigin:
     case CSSPropertyWebkitTransformOriginX:
     case CSSPropertyWebkitTransformOriginY:
     case CSSPropertyWebkitTransformOriginZ: {
-        RefPtrWillBeRawPtr<CSSValue> val1;
-        RefPtrWillBeRawPtr<CSSValue> val2;
-        RefPtrWillBeRawPtr<CSSValue> val3;
+        RefPtrWillBeRawPtr<CSSValue> val1 = nullptr;
+        RefPtrWillBeRawPtr<CSSValue> val2 = nullptr;
+        RefPtrWillBeRawPtr<CSSValue> val3 = nullptr;
         CSSPropertyID propId1, propId2, propId3;
         if (parseTransformOrigin(propId, propId1, propId2, propId3, val1, val2, val3)) {
             addProperty(propId1, val1.release(), important);
             if (val2)
                 addProperty(propId2, val2.release(), important);
             if (val3)
                 addProperty(propId3, val3.release(), important);
             return true;
         }
         return false;
     }
     case CSSPropertyWebkitPerspective:
         if (id == CSSValueNone)
             validPrimitive = true;
         else {
             // Accepting valueless numbers is a quirk of the -webkit prefixed version of the property.
             if (validUnit(value, FNumber | FLength | FNonNeg)) {
                 RefPtrWillBeRawPtr<CSSValue> val = createPrimitiveNumericValue(value);
                 if (val) {
                     addProperty(propId, val.release(), important);
                     return true;
                 }
                 return false;
             }
         }
         break;
     case CSSPropertyWebkitPerspectiveOrigin:
     case CSSPropertyWebkitPerspectiveOriginX:
     case CSSPropertyWebkitPerspectiveOriginY: {
-        RefPtrWillBeRawPtr<CSSValue> val1;
-        RefPtrWillBeRawPtr<CSSValue> val2;
+        RefPtrWillBeRawPtr<CSSValue> val1 = nullptr;
+        RefPtrWillBeRawPtr<CSSValue> val2 = nullptr;
         CSSPropertyID propId1, propId2;
         if (parsePerspectiveOrigin(propId, propId1, propId2, val1, val2)) {
             addProperty(propId1, val1.release(), important);
             if (val2)
                 addProperty(propId2, val2.release(), important);
             return true;
         }
         return false;
     }
     case CSSPropertyAnimationDelay:
@@ skipping 15 matching lines @@
     case CSSPropertyWebkitAnimationIterationCount:
     case CSSPropertyWebkitAnimationTimingFunction:
     case CSSPropertyTransitionDelay:
     case CSSPropertyTransitionDuration:
     case CSSPropertyTransitionTimingFunction:
     case CSSPropertyTransitionProperty:
     case CSSPropertyWebkitTransitionDelay:
     case CSSPropertyWebkitTransitionDuration:
     case CSSPropertyWebkitTransitionTimingFunction:
     case CSSPropertyWebkitTransitionProperty: {
-        RefPtrWillBeRawPtr<CSSValue> val;
+        RefPtrWillBeRawPtr<CSSValue> val = nullptr;
         AnimationParseContext context;
         if (parseAnimationProperty(propId, val, context)) {
             addPropertyWithPrefixingVariant(propId, val.release(), important);
             return true;
         }
         return false;
     }
 
     case CSSPropertyJustifySelf:
         if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
@@ skipping 459 matching lines @@
 bool CSSPropertyParser::parseFillShorthand(CSSPropertyID propId, const CSSPropertyID* properties, int numProperties, bool important)
 {
     ASSERT(numProperties <= cMaxFillProperties);
     if (numProperties > cMaxFillProperties)
         return false;
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[cMaxFillProperties] = { false };
     RefPtrWillBeRawPtr<CSSValue> values[cMaxFillProperties];
-    RefPtrWillBeRawPtr<CSSValue> clipValue;
-    RefPtrWillBeRawPtr<CSSValue> positionYValue;
-    RefPtrWillBeRawPtr<CSSValue> repeatYValue;
+#if ENABLE(OILPAN)
+    // Zero initialize the array of raw pointers.
+    memset(&values, 0, sizeof(values));
+#endif
+    RefPtrWillBeRawPtr<CSSValue> clipValue = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> positionYValue = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> repeatYValue = nullptr;
     bool foundClip = false;
     int i;
     bool foundPositionCSSProperty = false;
 
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
             // We hit the end.  Fill in all remaining values with the initial value.
             m_valueList->next();
             for (i = 0; i < numProperties; ++i) {
@@ skipping 28 matching lines @@
         foundPositionCSSProperty = false;
         bool found = false;
         for (i = 0; !found && i < numProperties; ++i) {
 
             if (sizeCSSPropertyExpected && (properties[i] != CSSPropertyBackgroundSize && properties[i] != CSSPropertyWebkitMaskSize))
                 continue;
             if (!sizeCSSPropertyExpected && (properties[i] == CSSPropertyBackgroundSize || properties[i] == CSSPropertyWebkitMaskSize))
                 continue;
 
             if (!parsedProperty[i]) {
-                RefPtrWillBeRawPtr<CSSValue> val1;
-                RefPtrWillBeRawPtr<CSSValue> val2;
+                RefPtrWillBeRawPtr<CSSValue> val1 = nullptr;
+                RefPtrWillBeRawPtr<CSSValue> val2 = nullptr;
                 CSSPropertyID propId1, propId2;
                 CSSParserValue* parserValue = m_valueList->current();
                 // parseFillProperty() may modify m_implicitShorthand, so we MUST reset it
                 // before EACH return below.
                 if (parseFillProperty(properties[i], propId1, propId2, val1, val2)) {
                     parsedProperty[i] = found = true;
                     addFillValue(values[i], val1.release());
                     if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
                         addFillValue(positionYValue, val2.release());
                     if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
@@ skipping 99 matching lines @@
     // length as the list with animation name in last position, even though they are
     // in a different order.
     ASSERT(numProperties == animationProperties.length());
     ASSERT(numProperties == shorthandForProperty(propId).length());
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[numProperties] = { false };
     AnimationParseContext context;
     RefPtrWillBeRawPtr<CSSValue> values[numProperties];
+#if ENABLE(OILPAN)
+    // Zero initialize the array of raw pointers.
+    memset(&values, 0, sizeof(values));
+#endif
 
     unsigned i;
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
             // We hit the end.  Fill in all remaining values with the initial value.
             m_valueList->next();
             for (i = 0; i < numProperties; ++i) {
                 if (!parsedProperty[i])
                     addAnimationValue(values[i], cssValuePool().createImplicitInitialValue());
                 parsedProperty[i] = false;
             }
             if (!m_valueList->current())
                 break;
             context.commitFirstAnimation();
         }
 
         bool found = false;
         for (i = 0; i < numProperties; ++i) {
             if (!parsedProperty[i]) {
-                RefPtrWillBeRawPtr<CSSValue> val;
+                RefPtrWillBeRawPtr<CSSValue> val = nullptr;
                 if (parseAnimationProperty(animationProperties.properties()[i], val, context)) {
                     parsedProperty[i] = found = true;
                     addAnimationValue(values[i], val.release());
                     break;
                 }
             }
         }
 
         // if we didn't find at least one match, this is an
         // invalid shorthand and we have to ignore it
@@ skipping 19 matching lines @@
 {
     const unsigned numProperties = 4;
     const StylePropertyShorthand& shorthand = shorthandForProperty(propId);
     ASSERT(numProperties == shorthand.length());
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[numProperties] = { false };
     AnimationParseContext context;
     RefPtrWillBeRawPtr<CSSValue> values[numProperties];
+#if ENABLE(OILPAN)
+    // Zero initialize the array of raw pointers.
+    memset(&values, 0, sizeof(values));
+#endif
 
     unsigned i;
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
             // We hit the end. Fill in all remaining values with the initial value.
             m_valueList->next();
             for (i = 0; i < numProperties; ++i) {
                 if (!parsedProperty[i])
                     addAnimationValue(values[i], cssValuePool().createImplicitInitialValue());
                 parsedProperty[i] = false;
             }
             if (!m_valueList->current())
                 break;
             context.commitFirstAnimation();
         }
 
         bool found = false;
         for (i = 0; !found && i < numProperties; ++i) {
             if (!parsedProperty[i]) {
-                RefPtrWillBeRawPtr<CSSValue> val;
+                RefPtrWillBeRawPtr<CSSValue> val = nullptr;
                 if (parseAnimationProperty(shorthand.properties()[i], val, context)) {
                     parsedProperty[i] = found = true;
                     addAnimationValue(values[i], val.release());
                 }
 
                 // There are more values to process but 'none' or 'all' were already defined as the animation property, the declaration becomes invalid.
                 if (!context.animationPropertyKeywordAllowed() && context.hasCommittedFirstAnimation())
                     return false;
             }
         }
@@ skipping 38 matching lines @@
         || (!value->id && validUnit(value, FPositiveInteger, HTMLQuirksMode))) {
         RefPtrWillBeRawPtr<CSSValue> parsedValue = parseValidPrimitive(value->id, value);
         m_valueList->next();
         return parsedValue;
     }
     return nullptr;
 }
 
 bool CSSPropertyParser::parseColumnsShorthand(bool important)
 {
-    RefPtrWillBeRawPtr<CSSValue> columnWidth;
-    RefPtrWillBeRawPtr<CSSValue> columnCount;
+    RefPtrWillBeRawPtr<CSSValue> columnWidth = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> columnCount = nullptr;
     bool hasPendingExplicitAuto = false;
 
     for (unsigned propertiesParsed = 0; CSSParserValue* value = m_valueList->current(); propertiesParsed++) {
         if (propertiesParsed >= 2)
             return false; // Too many values for this shorthand. Invalid declaration.
         if (!propertiesParsed && value->id == CSSValueAuto) {
             // 'auto' is a valid value for any of the two longhands, and at this point we
             // don't know which one(s) it is meant for. We need to see if there are other
             // values first.
             m_valueList->next();
@@ skipping 237 matching lines @@
         return None;
     }
 }
 
 // [ <string> <string> ]+ | inherit | none
 // inherit and none are handled in parseValue.
 bool CSSPropertyParser::parseQuotes(CSSPropertyID propId, bool important)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
     while (CSSParserValue* val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue;
+        RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
         if (val->unit == CSSPrimitiveValue::CSS_STRING)
             parsedValue = CSSPrimitiveValue::create(val->string, CSSPrimitiveValue::CSS_STRING);
         else
             break;
         values->append(parsedValue.release());
         m_valueList->next();
     }
     if (values->length()) {
         addProperty(propId, values.release(), important);
         m_valueList->next();
         return true;
     }
     return false;
 }
 
 // [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
 // in CSS 2.1 this got somewhat reduced:
 // [ <string> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
 bool CSSPropertyParser::parseContent(CSSPropertyID propId, bool important)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
 
     while (CSSParserValue* val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue;
+        RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
         if (val->unit == CSSPrimitiveValue::CSS_URI) {
             // url
             parsedValue = CSSImageValue::create(val->string, completeURL(val->string));
         } else if (val->unit == CSSParserValue::Function) {
             // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z]) | -webkit-gradient(...)
             CSSParserValueList* args = val->function->args.get();
             if (!args)
                 return false;
             if (equalIgnoringCase(val->function->name, "attr(")) {
                 parsedValue = parseAttr(args);
@@ skipping 295 matching lines @@
             return;
 
         secondPositionKeyword = CSSValueTop;
         if (ident1 == CSSValueTop || ident1 == CSSValueBottom) {
             secondPositionKeyword = CSSValueLeft;
             swapNeeded = true;
         }
         value1 = createPrimitiveValuePair(parsedValue1, parsedValue2);
         value2 = createPrimitiveValuePair(cssValuePool().createIdentifierValue(secondPositionKeyword), cssValuePool().createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE));
     } else {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> firstPositionValue;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> secondPositionValue;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> firstPositionValue = nullptr;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> secondPositionValue = nullptr;
 
         if (isFillPositionKeyword(ident2)) {
             // To match CSS grammar, we should only accept: [ center | left | right | bottom | top ] [ left | right | top | bottom ] [ <percentage> | <length> ].
             ASSERT(ident2 != CSSValueCenter);
 
             if (isFillPositionKeyword(ident3))
                 return;
 
             secondPositionValue = value3;
             secondPositionKeyword = ident2;
@@ skipping 180 matching lines @@
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillSize(CSSPropertyID propId, bool& allowComma)
 {
     allowComma = true;
     CSSParserValue* value = m_valueList->current();
 
     if (value->id == CSSValueContain || value->id == CSSValueCover)
         return cssValuePool().createIdentifierValue(value->id);
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = nullptr;
 
     if (value->id == CSSValueAuto)
         parsedValue1 = cssValuePool().createIdentifierValue(CSSValueAuto);
     else {
         if (!validUnit(value, FLength | FPercent))
             return nullptr;
         parsedValue1 = createPrimitiveNumericValue(value);
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = nullptr;
     if ((value = m_valueList->next())) {
         if (value->unit == CSSParserValue::Operator && value->iValue == ',')
             allowComma = false;
         else if (value->id != CSSValueAuto) {
             if (!validUnit(value, FLength | FPercent)) {
                 if (!inShorthand())
                     return nullptr;
                 // We need to rewind the value list, so that when it is advanced we'll end up back at this value.
                 m_valueList->previous();
             } else
                 parsedValue2 = createPrimitiveNumericValue(value);
         }
     } else if (!parsedValue2 && propId == CSSPropertyWebkitBackgroundSize) {
         // For backwards compatibility we set the second value to the first if it is omitted.
         // We only need to do this for -webkit-background-size. It should be safe to let masks match
         // the real property.
         parsedValue2 = parsedValue1;
     }
 
     if (!parsedValue2)
         return parsedValue1;
     return createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release());
 }
 
 bool CSSPropertyParser::parseFillProperty(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2,
     RefPtrWillBeRawPtr<CSSValue>& retValue1, RefPtrWillBeRawPtr<CSSValue>& retValue2)
 {
-    RefPtrWillBeRawPtr<CSSValueList> values;
-    RefPtrWillBeRawPtr<CSSValueList> values2;
+    RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
+    RefPtrWillBeRawPtr<CSSValueList> values2 = nullptr;
     CSSParserValue* val;
-    RefPtrWillBeRawPtr<CSSValue> value;
-    RefPtrWillBeRawPtr<CSSValue> value2;
+    RefPtrWillBeRawPtr<CSSValue> value = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> value2 = nullptr;
 
     bool allowComma = false;
 
     retValue1 = retValue2 = nullptr;
     propId1 = propId;
     propId2 = propId;
     if (propId == CSSPropertyBackgroundPosition) {
         propId1 = CSSPropertyBackgroundPositionX;
         propId2 = CSSPropertyBackgroundPositionY;
     } else if (propId == CSSPropertyWebkitMaskPosition) {
         propId1 = CSSPropertyWebkitMaskPositionX;
         propId2 = CSSPropertyWebkitMaskPositionY;
     } else if (propId == CSSPropertyBackgroundRepeat) {
         propId1 = CSSPropertyBackgroundRepeatX;
         propId2 = CSSPropertyBackgroundRepeatY;
     } else if (propId == CSSPropertyWebkitMaskRepeat) {
         propId1 = CSSPropertyWebkitMaskRepeatX;
         propId2 = CSSPropertyWebkitMaskRepeatY;
     }
 
     while ((val = m_valueList->current())) {
-        RefPtrWillBeRawPtr<CSSValue> currValue;
-        RefPtrWillBeRawPtr<CSSValue> currValue2;
+        RefPtrWillBeRawPtr<CSSValue> currValue = nullptr;
+        RefPtrWillBeRawPtr<CSSValue> currValue2 = nullptr;
 
         if (allowComma) {
             if (!isComma(val))
                 return false;
             m_valueList->next();
             allowComma = false;
         } else {
             allowComma = true;
             switch (propId) {
                 case CSSPropertyBackgroundColor:
@@ skipping 339 matching lines @@
             return nullptr;
 
         return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
     }
 
     return nullptr;
 }
 
 bool CSSPropertyParser::parseAnimationProperty(CSSPropertyID propId, RefPtrWillBeRawPtr<CSSValue>& result, AnimationParseContext& context)
 {
-    RefPtrWillBeRawPtr<CSSValueList> values;
+    RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
     CSSParserValue* val;
-    RefPtrWillBeRawPtr<CSSValue> value;
+    RefPtrWillBeRawPtr<CSSValue> value = nullptr;
     bool allowComma = false;
 
     result = nullptr;
 
     while ((val = m_valueList->current())) {
-        RefPtrWillBeRawPtr<CSSValue> currValue;
+        RefPtrWillBeRawPtr<CSSValue> currValue = nullptr;
         if (allowComma) {
             if (!isComma(val))
                 return false;
             m_valueList->next();
             allowComma = false;
         }
         else {
             switch (propId) {
                 case CSSPropertyAnimationDelay:
                 case CSSPropertyWebkitAnimationDelay:
@@ skipping 130 matching lines @@
     if (value->id == CSSValueAuto) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueAuto);
     }
 
     if (value->id != CSSValueSpan && value->unit == CSSPrimitiveValue::CSS_IDENT) {
         m_valueList->next();
         return cssValuePool().createValue(value->string, CSSPrimitiveValue::CSS_STRING);
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> numericValue;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> gridLineName;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> numericValue = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> gridLineName = nullptr;
     bool hasSeenSpanKeyword = false;
 
     if (parseIntegerOrStringFromGridPosition(numericValue, gridLineName)) {
         value = m_valueList->current();
         if (value && value->id == CSSValueSpan) {
             hasSeenSpanKeyword = true;
             m_valueList->next();
         }
     } else if (value->id == CSSValueSpan) {
         hasSeenSpanKeyword = true;
@@ skipping 36 matching lines @@
 bool CSSPropertyParser::parseGridItemPositionShorthand(CSSPropertyID shorthandId, bool important)
 {
     ShorthandScope scope(this, shorthandId);
     const StylePropertyShorthand& shorthand = shorthandForProperty(shorthandId);
     ASSERT(shorthand.length() == 2);
 
     RefPtrWillBeRawPtr<CSSValue> startValue = parseGridPosition();
     if (!startValue)
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> endValue;
+    RefPtrWillBeRawPtr<CSSValue> endValue = nullptr;
     if (m_valueList->current()) {
         if (!isForwardSlashOperator(m_valueList->current()))
             return false;
 
         if (!m_valueList->next())
             return false;
 
         endValue = parseGridPosition();
         if (!endValue || m_valueList->current())
             return false;
@@ skipping 11 matching lines @@
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     ShorthandScope scope(this, CSSPropertyGridArea);
     const StylePropertyShorthand& shorthand = gridAreaShorthand();
     ASSERT_UNUSED(shorthand, shorthand.length() == 4);
 
     RefPtrWillBeRawPtr<CSSValue> rowStartValue = parseGridPosition();
     if (!rowStartValue)
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> columnStartValue;
+    RefPtrWillBeRawPtr<CSSValue> columnStartValue = nullptr;
     if (!parseSingleGridAreaLonghand(columnStartValue))
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> rowEndValue;
+    RefPtrWillBeRawPtr<CSSValue> rowEndValue = nullptr;
     if (!parseSingleGridAreaLonghand(rowEndValue))
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> columnEndValue;
+    RefPtrWillBeRawPtr<CSSValue> columnEndValue = nullptr;
     if (!parseSingleGridAreaLonghand(columnEndValue))
         return false;
 
     if (!columnStartValue)
         columnStartValue = gridMissingGridPositionValue(rowStartValue.get());
 
     if (!rowEndValue)
         rowEndValue = gridMissingGridPositionValue(rowStartValue.get());
 
     if (!columnEndValue)
@@ skipping 263 matching lines @@
     if (counters && numArgs != 3 && numArgs != 5)
         return nullptr;
     if (!counters && numArgs != 1 && numArgs != 3)
         return nullptr;
 
     CSSParserValue* i = args->current();
     if (i->unit != CSSPrimitiveValue::CSS_IDENT)
         return nullptr;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> identifier = createPrimitiveStringValue(i);
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> separator;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> separator = nullptr;
     if (!counters)
         separator = cssValuePool().createValue(String(), CSSPrimitiveValue::CSS_STRING);
     else {
         i = args->next();
         if (i->unit != CSSParserValue::Operator || i->iValue != ',')
             return nullptr;
 
         i = args->next();
         if (i->unit != CSSPrimitiveValue::CSS_STRING)
             return nullptr;
 
         separator = createPrimitiveStringValue(i);
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle = nullptr;
     i = args->next();
     if (!i) // Make the list style default decimal
         listStyle = cssValuePool().createIdentifierValue(CSSValueDecimal);
     else {
         if (i->unit != CSSParserValue::Operator || i->iValue != ',')
             return nullptr;
 
         i = args->next();
         if (i->unit != CSSPrimitiveValue::CSS_IDENT)
             return nullptr;
@@ skipping 85 matching lines @@
         radiusArguments.addValue(*argument);
         argument = args->next();
     }
 
     unsigned num = radiusArguments.size();
     if (!num || num > 9)
         return nullptr;
 
     // FIXME: Refactor completeBorderRadii and the array
     RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[2][4];
+#if ENABLE(OILPAN)
+    // Zero initialize the array of raw pointers.
+    memset(&radii, 0, sizeof(radii));
+#endif
 
     unsigned indexAfterSlash = 0;
     for (unsigned i = 0; i < num; ++i) {
         CSSParserValue* value = radiusArguments.valueAt(i);
         if (value->unit == CSSParserValue::Operator) {
             if (value->iValue != '/')
                 return nullptr;
 
             if (!i || indexAfterSlash || i + 1 == num)
                 return nullptr;
@@ skipping 172 matching lines @@
         if (!args->currentIndex() && argument->id != CSSValueAt) {
             if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
                 shape->setRadius(radius);
                 continue;
             }
 
             return nullptr;
         }
 
         if (argument->id == CSSValueAt && args->next()) {
-            RefPtrWillBeRawPtr<CSSValue> centerX;
-            RefPtrWillBeRawPtr<CSSValue> centerY;
+            RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
+            RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
             parseFillPosition(args, centerX, centerY);
             if (centerX && centerY && !args->current()) {
                 ASSERT(centerX->isPrimitiveValue());
                 ASSERT(centerY->isPrimitiveValue());
                 shape->setCenterX(toCSSPrimitiveValue(centerX.get()));
                 shape->setCenterY(toCSSPrimitiveValue(centerY.get()));
             } else {
                 return nullptr;
             }
         } else {
@@ skipping 30 matching lines @@
                 else
                     shape->setRadiusY(radius);
                 continue;
             }
 
             return nullptr;
         }
 
         if (argument->id != CSSValueAt || !args->next()) // expecting ellipse(.. at <position>)
             return nullptr;
-        RefPtrWillBeRawPtr<CSSValue> centerX;
-        RefPtrWillBeRawPtr<CSSValue> centerY;
+        RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
+        RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
         parseFillPosition(args, centerX, centerY);
         if (!centerX || !centerY || args->current())
             return nullptr;
 
         ASSERT(centerX->isPrimitiveValue());
         ASSERT(centerY->isPrimitiveValue());
         shape->setCenterX(toCSSPrimitiveValue(centerX.get()));
         shape->setCenterY(toCSSPrimitiveValue(centerY.get()));
     }
 
@@ skipping 66 matching lines @@
     return false;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSPropertyID propId)
 {
     if (!RuntimeEnabledFeatures::cssShapesEnabled())
         return nullptr;
 
     CSSParserValue* value = m_valueList->current();
     CSSValueID valueId = value->id;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> boxValue;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue;
 
     if (valueId == CSSValueNone
         || (valueId == CSSValueOutsideShape && propId == CSSPropertyShapeInside)) {
         RefPtrWillBeRawPtr<CSSPrimitiveValue> keywordValue = parseValidPrimitive(valueId, value);
         m_valueList->next();
         return keywordValue.release();
     }
 
-    RefPtrWillBeRawPtr<CSSValue> imageValue;
+    RefPtrWillBeRawPtr<CSSValue> imageValue = nullptr;
     if (valueId != CSSValueNone && parseFillImage(m_valueList.get(), imageValue)) {
         m_valueList->next();
         return imageValue.release();
     }
 
     return parseBasicShapeAndOrBox();
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBasicShapeAndOrBox()
 {
@@ skipping 33 matching lines @@
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseBasicShape()
 {
     CSSParserValue* value = m_valueList->current();
     ASSERT(value->unit == CSSParserValue::Function);
     CSSParserValueList* args = value->function->args.get();
 
     if (!args)
         return nullptr;
 
-    RefPtrWillBeRawPtr<CSSBasicShape> shape;
+    RefPtrWillBeRawPtr<CSSBasicShape> shape = nullptr;
     if (equalIgnoringCase(value->function->name, "circle("))
         shape = parseBasicShapeCircle(args);
     else if (equalIgnoringCase(value->function->name, "ellipse("))
         shape = parseBasicShapeEllipse(args);
     else if (equalIgnoringCase(value->function->name, "polygon("))
         shape = parseBasicShapePolygon(args);
     else if (equalIgnoringCase(value->function->name, "inset("))
         shape = parseBasicShapeInset(args);
 
     if (!shape)
@@ skipping 212 matching lines @@
         validPrimitive = true;
     else
         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
     if (validPrimitive && (!m_valueList->next() || inShorthand()))
         addProperty(CSSPropertyFontSize, parseValidPrimitive(id, value), important);
     return validPrimitive;
 }
 
 bool CSSPropertyParser::parseFontVariant(bool important)
 {
-    RefPtrWillBeRawPtr<CSSValueList> values;
+    RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
     if (m_valueList->size() > 1)
         values = CSSValueList::createCommaSeparated();
     CSSParserValue* val;
     bool expectComma = false;
     while ((val = m_valueList->current())) {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = nullptr;
         if (!expectComma) {
             expectComma = true;
             if (val->id == CSSValueNormal || val->id == CSSValueSmallCaps)
                 parsedValue = cssValuePool().createIdentifierValue(val->id);
             else if (val->id == CSSValueAll && !values) {
                 // 'all' is only allowed in @font-face and with no other values. Make a value list to
                 // indicate that we are in the @font-face case.
                 values = CSSValueList::createCommaSeparated();
                 parsedValue = cssValuePool().createIdentifierValue(val->id);
             }
@@ skipping 804 matching lines @@
         else {
             allowBlur = false;
             allowSpread = false;
             allowColor = false;
         }
     }
 
     CSSPropertyID property;
     CSSPropertyParser* m_parser;
 
-    RefPtrWillBeRawPtr<CSSValueList> values;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> x;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> y;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> blur;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> spread;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> style;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> color;
+    RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> x = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> y = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> blur = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> spread = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> style = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> color = nullptr;

[haraken, 2014/03/24 13:52:54]

These could be RefPtrWillBeMembers, since the object is stack-allocated.

[Mads Ager (chromium), 2014/03/24 14:27:30]

Absolutely!

 
     bool allowX;
     bool allowY;
     bool allowBlur;
     bool allowSpread;
     bool allowColor;
     bool allowStyle; // inset or not.
     bool allowBreak;
 };
 
@@ skipping 22 matching lines @@
 
             // A length is allowed here.  Construct the value and add it.
             context.commitLength(val);
         } else if (val->id == CSSValueInset) {
             if (!context.allowStyle)
                 return nullptr;
 
             context.commitStyle(val);
         } else {
             // The only other type of value that's ok is a color value.
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedColor;
+            RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedColor = nullptr;
             bool isColor = ((val->id >= CSSValueAqua && val->id <= CSSValueWindowtext) || val->id == CSSValueMenu
                             || (val->id >= CSSValueWebkitFocusRingColor && val->id <= CSSValueWebkitText && inQuirksMode())
                             || val->id == CSSValueCurrentcolor);
             if (isColor) {
                 if (!context.allowColor)
                     return nullptr;
                 parsedColor = cssValuePool().createIdentifierValue(val->id);
             }
 
             if (!parsedColor)
@@ skipping 18 matching lines @@
 
     return nullptr;
 }
 
 bool CSSPropertyParser::parseReflect(CSSPropertyID propId, bool important)
 {
     // box-reflect: <direction> <offset> <mask>
 
     // Direction comes first.
     CSSParserValue* val = m_valueList->current();
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> direction;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> direction = nullptr;
     switch (val->id) {
     case CSSValueAbove:
     case CSSValueBelow:
     case CSSValueLeft:
     case CSSValueRight:
         direction = cssValuePool().createIdentifierValue(val->id);
         break;
     default:
         return false;
     }
 
     // The offset comes next.
     val = m_valueList->next();
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> offset;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> offset = nullptr;
     if (!val)
         offset = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PX);
     else {
         if (!validUnit(val, FLength | FPercent))
             return false;
         offset = createPrimitiveNumericValue(val);
     }
 
     // Now for the mask.
-    RefPtrWillBeRawPtr<CSSValue> mask;
+    RefPtrWillBeRawPtr<CSSValue> mask = nullptr;
     val = m_valueList->next();
     if (val) {
         mask = parseBorderImage(propId);
         if (!mask)
             return false;
     }
 
     RefPtrWillBeRawPtr<CSSReflectValue> reflectValue = CSSReflectValue::create(direction.release(), offset.release(), mask.release());
     addProperty(propId, reflectValue.release(), important);
     m_valueList->next();
     return true;
 }
 
 bool CSSPropertyParser::parseFlex(CSSParserValueList* args, bool important)
 {
     if (!args || !args->size() || args->size() > 3)
         return false;
     static const double unsetValue = -1;
     double flexGrow = unsetValue;
     double flexShrink = unsetValue;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> flexBasis;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> flexBasis = nullptr;
 
     while (CSSParserValue* arg = args->current()) {
         if (validUnit(arg, FNumber | FNonNeg)) {
             if (flexGrow == unsetValue)
                 flexGrow = arg->fValue;
             else if (flexShrink == unsetValue)
                 flexShrink = arg->fValue;
             else if (!arg->fValue) {
                 // flex only allows a basis of 0 (sans units) if flex-grow and flex-shrink values have already been set.
                 flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PX);
@@ skipping 18 matching lines @@
         flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PX);
 
     addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(clampToFloat(flexGrow), CSSPrimitiveValue::CSS_NUMBER), important);
     addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(clampToFloat(flexShrink), CSSPrimitiveValue::CSS_NUMBER), important);
     addProperty(CSSPropertyFlexBasis, flexBasis, important);
     return true;
 }
 
 bool CSSPropertyParser::parseObjectPosition(bool important)
 {
-    RefPtrWillBeRawPtr<CSSValue> xValue;
-    RefPtrWillBeRawPtr<CSSValue> yValue;
+    RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
     parseFillPosition(m_valueList.get(), xValue, yValue);
     if (!xValue || !yValue)
         return false;
     addProperty(
         CSSPropertyObjectPosition,
         createPrimitiveValuePair(toCSSPrimitiveValue(xValue.get()), toCSSPrimitiveValue(yValue.get()), Pair::KeepIdenticalValues),
         important);
     return true;
 }
 
@@ skipping 118 matching lines @@
 
     bool m_allowCommit;
     bool m_allowImage;
     bool m_allowImageSlice;
     bool m_allowRepeat;
     bool m_allowForwardSlashOperator;
 
     bool m_requireWidth;
     bool m_requireOutset;
 
-    RefPtrWillBeRawPtr<CSSValue> m_image;
-    RefPtrWillBeRawPtr<CSSBorderImageSliceValue> m_imageSlice;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_borderSlice;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_outset;
+    RefPtrWillBeRawPtr<CSSValue> m_image = nullptr;
+    RefPtrWillBeRawPtr<CSSBorderImageSliceValue> m_imageSlice = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_borderSlice = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_outset = nullptr;
 
-    RefPtrWillBeRawPtr<CSSValue> m_repeat;
+    RefPtrWillBeRawPtr<CSSValue> m_repeat = nullptr;

[haraken, 2014/03/24 13:52:54]

Ditto.

[Mads Ager (chromium), 2014/03/24 14:27:30]

Yes, good catch. This is stack allocated as well.

 };
 
 bool BorderImageParseContext::buildFromParser(CSSPropertyParser& parser, CSSPropertyID propId, BorderImageParseContext& context)
 {
     CSSPropertyParser::ShorthandScope scope(&parser, propId);
     while (CSSParserValue* val = parser.m_valueList->current()) {
         context.setCanAdvance(false);
 
         if (!context.canAdvance() && context.allowForwardSlashOperator() && isForwardSlashOperator(val))
             context.commitForwardSlashOperator();
 
         if (!context.canAdvance() && context.allowImage()) {
             if (val->unit == CSSPrimitiveValue::CSS_URI) {
                 context.commitImage(CSSImageValue::create(val->string, parser.m_context.completeURL(val->string)));
             } else if (isGeneratedImageValue(val)) {
-                RefPtrWillBeRawPtr<CSSValue> value;
+                RefPtrWillBeRawPtr<CSSValue> value = nullptr;
                 if (parser.parseGeneratedImage(parser.m_valueList.get(), value))
                     context.commitImage(value.release());
                 else
                     return false;
             } else if (val->unit == CSSParserValue::Function && equalIgnoringCase(val->function->name, "-webkit-image-set(")) {
                 RefPtrWillBeRawPtr<CSSValue> value = parser.parseImageSet(parser.m_valueList.get());
                 if (value)
                     context.commitImage(value.release());
                 else
                     return false;
             } else if (val->id == CSSValueNone)
                 context.commitImage(cssValuePool().createIdentifierValue(CSSValueNone));
         }
 
         if (!context.canAdvance() && context.allowImageSlice()) {
-            RefPtrWillBeRawPtr<CSSBorderImageSliceValue> imageSlice;
+            RefPtrWillBeRawPtr<CSSBorderImageSliceValue> imageSlice = nullptr;
             if (parser.parseBorderImageSlice(propId, imageSlice))
                 context.commitImageSlice(imageSlice.release());
         }
 
         if (!context.canAdvance() && context.allowRepeat()) {
-            RefPtrWillBeRawPtr<CSSValue> repeat;
+            RefPtrWillBeRawPtr<CSSValue> repeat = nullptr;
             if (parser.parseBorderImageRepeat(repeat))
                 context.commitRepeat(repeat.release());
         }
 
         if (!context.canAdvance() && context.requireWidth()) {
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> borderSlice;
+            RefPtrWillBeRawPtr<CSSPrimitiveValue> borderSlice = nullptr;
             if (parser.parseBorderImageWidth(borderSlice))
                 context.commitBorderWidth(borderSlice.release());
         }
 
         if (!context.canAdvance() && context.requireOutset()) {
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> borderOutset;
+            RefPtrWillBeRawPtr<CSSPrimitiveValue> borderOutset = nullptr;
             if (parser.parseBorderImageOutset(borderOutset))
                 context.commitBorderOutset(borderOutset.release());
         }
 
         if (!context.canAdvance())
             return false;
 
         parser.m_valueList->next();
     }
 
@@ skipping 28 matching lines @@
     return nullptr;
 }
 
 static bool isBorderImageRepeatKeyword(int id)
 {
     return id == CSSValueStretch || id == CSSValueRepeat || id == CSSValueSpace || id == CSSValueRound;
 }
 
 bool CSSPropertyParser::parseBorderImageRepeat(RefPtrWillBeRawPtr<CSSValue>& result)
 {
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> firstValue;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> secondValue;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> firstValue = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> secondValue = nullptr;
     CSSParserValue* val = m_valueList->current();
     if (!val)
         return false;
     if (isBorderImageRepeatKeyword(val->id))
         firstValue = cssValuePool().createIdentifierValue(val->id);
     else
         return false;
 
     val = m_valueList->next();
     if (val) {
@@ skipping 78 matching lines @@
         return CSSBorderImageSliceValue::create(cssValuePool().createValue(quad.release()), m_fill);
     }
 
 private:
     CSSPropertyParser* m_parser;
 
     bool m_allowNumber;
     bool m_allowFill;
     bool m_allowFinalCommit;
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_top;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_right;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_bottom;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_left;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_top = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_right = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_bottom = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_left = nullptr;

[haraken, 2014/03/24 13:52:54]

Ditto.

[Mads Ager (chromium), 2014/03/24 14:27:30]

Yes.

 
     bool m_fill;
 };
 
 bool CSSPropertyParser::parseBorderImageSlice(CSSPropertyID propId, RefPtrWillBeRawPtr<CSSBorderImageSliceValue>& result)
 {
     BorderImageSliceParseContext context(this);
     CSSParserValue* val;
     while ((val = m_valueList->current())) {
         // FIXME calc() http://webkit.org/b/16662 : calc is parsed but values are not created yet.
@@ skipping 36 matching lines @@
     , m_allowNumber(true)
     , m_allowFinalCommit(false)
     { }
 
     bool allowNumber() const { return m_allowNumber; }
     bool allowFinalCommit() const { return m_allowFinalCommit; }
     CSSPrimitiveValue* top() const { return m_top.get(); }
 
     void commitNumber(CSSParserValue* v)
     {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> val;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> val = nullptr;
         if (v->id == CSSValueAuto)
             val = cssValuePool().createIdentifierValue(v->id);
         else
             val = m_parser->createPrimitiveNumericValue(v);
 
         if (!m_top)
             m_top = val;
         else if (!m_right)
             m_right = val;
         else if (!m_bottom)
@@ skipping 36 matching lines @@
         // Make our new value now.
         return cssValuePool().createValue(quad.release());
     }
 
 private:
     CSSPropertyParser* m_parser;
 
     bool m_allowNumber;
     bool m_allowFinalCommit;
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_top;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_right;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_bottom;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_left;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_top = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_right = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_bottom = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> m_left = nullptr;

[haraken, 2014/03/24 13:52:54]

Ditto.

[Mads Ager (chromium), 2014/03/24 14:27:30]

And yes. :)

 };
 
 bool CSSPropertyParser::parseBorderImageQuad(Units validUnits, RefPtrWillBeRawPtr<CSSPrimitiveValue>& result)
 {
     BorderImageQuadParseContext context(this);
     CSSParserValue* val;
     while ((val = m_valueList->current())) {
         if (context.allowNumber() && (validUnit(val, validUnits, HTMLStandardMode) || val->id == CSSValueAuto)) {
             context.commitNumber(val);
         } else if (!inShorthand()) {
@@ skipping 26 matching lines @@
 }
 
 bool CSSPropertyParser::parseBorderRadius(CSSPropertyID propId, bool important)
 {
     unsigned num = m_valueList->size();
     if (num > 9)
         return false;
 
     ShorthandScope scope(this, propId);
     RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[2][4];
+#if ENABLE(OILPAN)
+    // Zero initialize the array of raw pointers.
+    memset(&radii, 0, sizeof(radii));
+#endif
 
     unsigned indexAfterSlash = 0;
     for (unsigned i = 0; i < num; ++i) {
         CSSParserValue* value = m_valueList->valueAt(i);
         if (value->unit == CSSParserValue::Operator) {
             if (value->iValue != '/')
                 return false;
 
             if (!i || indexAfterSlash || i + 1 == num || num > i + 5)
                 return false;
@@ skipping 65 matching lines @@
     addProperty(CSSPropertyWebkitAspectRatio, CSSAspectRatioValue::create(narrowPrecisionToFloat(lvalue->fValue), narrowPrecisionToFloat(rvalue->fValue)), important);
 
     return true;
 }
 
 bool CSSPropertyParser::parseCounter(CSSPropertyID propId, int defaultValue, bool important)
 {
     enum { ID, VAL } state = ID;
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> counterName;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> counterName = nullptr;
 
     while (true) {
         CSSParserValue* val = m_valueList->current();
         switch (state) {
             case ID:
                 if (val && val->unit == CSSPrimitiveValue::CSS_IDENT) {
                     counterName = createPrimitiveStringValue(val);
                     state = VAL;
                     m_valueList->next();
                     continue;
@@ skipping 19 matching lines @@
         addProperty(propId, list.release(), important);
         return true;
     }
 
     return false;
 }
 
 // This should go away once we drop support for -webkit-gradient
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parseDeprecatedGradientPoint(CSSParserValue* a, bool horizontal)
 {
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> result;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
     if (a->unit == CSSPrimitiveValue::CSS_IDENT) {
         if ((equalIgnoringCase(a, "left") && horizontal)
             || (equalIgnoringCase(a, "top") && !horizontal))
             result = cssValuePool().createValue(0., CSSPrimitiveValue::CSS_PERCENTAGE);
         else if ((equalIgnoringCase(a, "right") && horizontal)
                  || (equalIgnoringCase(a, "bottom") && !horizontal))
             result = cssValuePool().createValue(100., CSSPrimitiveValue::CSS_PERCENTAGE);
         else if (equalIgnoringCase(a, "center"))
             result = cssValuePool().createValue(50., CSSPrimitiveValue::CSS_PERCENTAGE);
     } else if (a->unit == CSSPrimitiveValue::CSS_NUMBER || a->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
@@ skipping 77 matching lines @@
     CSSParserValue* a = args->current();
     if (!a || a->unit != CSSPrimitiveValue::CSS_IDENT)
         return false;
     if (equalIgnoringCase(a, "linear"))
         gradientType = CSSDeprecatedLinearGradient;
     else if (equalIgnoringCase(a, "radial"))
         gradientType = CSSDeprecatedRadialGradient;
     else
         return false;
 
-    RefPtrWillBeRawPtr<CSSGradientValue> result;
+    RefPtrWillBeRawPtr<CSSGradientValue> result = nullptr;
     switch (gradientType) {
     case CSSDeprecatedLinearGradient:
         result = CSSLinearGradientValue::create(NonRepeating, gradientType);
         break;
     case CSSDeprecatedRadialGradient:
         result = CSSRadialGradientValue::create(NonRepeating, gradientType);
         break;
     default:
         // The rest of the gradient types shouldn't appear here.
         ASSERT_NOT_REACHED();
@@ skipping 144 matching lines @@
 
     bool expectComma = false;
     // Look for angle.
     if (validUnit(a, FAngle, HTMLStandardMode)) {
         result->setAngle(createPrimitiveNumericValue(a));
 
         args->next();
         expectComma = true;
     } else {
         // Look one or two optional keywords that indicate a side or corner.
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> startX, startY;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> startX = nullptr;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> startY = nullptr;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> location;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> location = nullptr;
         bool isHorizontal = false;
         if ((location = valueFromSideKeyword(a, isHorizontal))) {
             if (isHorizontal)
                 startX = location;
             else
                 startY = location;
 
             if ((a = args->next())) {
                 if ((location = valueFromSideKeyword(a, isHorizontal))) {
                     if (isHorizontal) {
@@ skipping 39 matching lines @@
     if (!args || !args->size())
         return false;
 
     CSSParserValue* a = args->current();
     if (!a)
         return false;
 
     bool expectComma = false;
 
     // Optional background-position
-    RefPtrWillBeRawPtr<CSSValue> centerX;
-    RefPtrWillBeRawPtr<CSSValue> centerY;
+    RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
     // parse2ValuesFillPosition advances the args next pointer.
     parse2ValuesFillPosition(args, centerX, centerY);
     a = args->current();
     if (!a)
         return false;
 
     if (centerX || centerY) {
         // Comma
         if (!isComma(a))
             return false;
 
         a = args->next();
         if (!a)
             return false;
     }
 
     result->setFirstX(toCSSPrimitiveValue(centerX.get()));
     result->setSecondX(toCSSPrimitiveValue(centerX.get()));
     // CSS3 radial gradients always share the same start and end point.
     result->setFirstY(toCSSPrimitiveValue(centerY.get()));
     result->setSecondY(toCSSPrimitiveValue(centerY.get()));
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeValue;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeValue = nullptr;
 
     // Optional shape and/or size in any order.
     for (int i = 0; i < 2; ++i) {
         if (a->unit != CSSPrimitiveValue::CSS_IDENT)
             break;
 
         bool foundValue = false;
         switch (a->id) {
         case CSSValueCircle:
         case CSSValueEllipse:
@@ skipping 19 matching lines @@
                 return false;
 
             expectComma = true;
         }
     }
 
     result->setShape(shapeValue);
     result->setSizingBehavior(sizeValue);
 
     // Or, two lengths or percentages
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalSize;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalSize;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalSize = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalSize = nullptr;
 
     if (!shapeValue && !sizeValue) {
         if (validUnit(a, FLength | FPercent)) {
             horizontalSize = createPrimitiveNumericValue(a);
             a = args->next();
             if (!a)
                 return false;
 
             expectComma = true;
         }
@@ skipping 40 matching lines @@
         result->setAngle(createPrimitiveNumericValue(a));
 
         args->next();
         expectComma = true;
     } else if (a->unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(a, "to")) {
         // to [ [left | right] || [top | bottom] ]
         a = args->next();
         if (!a)
             return false;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> endX, endY;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> location;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> endX = nullptr;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> endY = nullptr;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> location = nullptr;
         bool isHorizontal = false;
 
         location = valueFromSideKeyword(a, isHorizontal);
         if (!location)
             return false;
 
         if (isHorizontal)
             endX = location;
         else
             endY = location;
@@ skipping 39 matching lines @@
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || !args->size())
         return false;
 
     CSSParserValue* a = args->current();
     if (!a)
         return false;
 
     bool expectComma = false;
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeValue;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalSize;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalSize;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeValue = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalSize = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalSize = nullptr;
 
     // First part of grammar, the size/shape clause:
     // [ circle || <length> ] |
     // [ ellipse || [ <length> | <percentage> ]{2} ] |
     // [ [ circle | ellipse] || <size-keyword> ]
     for (int i = 0; i < 3; ++i) {
         if (a->unit == CSSPrimitiveValue::CSS_IDENT) {
             bool badIdent = false;
             switch (a->id) {
             case CSSValueCircle:
@@ skipping 54 matching lines @@
     if (!verticalSize && horizontalSize && horizontalSize->isPercentage())
         return false;
 
     result->setShape(shapeValue);
     result->setSizingBehavior(sizeValue);
     result->setEndHorizontalSize(horizontalSize);
     result->setEndVerticalSize(verticalSize);
 
     // Second part of grammar, the center-position clause:
     // at <position>
-    RefPtrWillBeRawPtr<CSSValue> centerX;
-    RefPtrWillBeRawPtr<CSSValue> centerY;
+    RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
     if (a->unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(a, "at")) {
         a = args->next();
         if (!a)
             return false;
 
         parseFillPosition(args, centerX, centerY);
         if (!(centerX && centerY))
             return false;
 
         a = args->current();
@@ skipping 116 matching lines @@
     return false;
 }
 
 bool CSSPropertyParser::parseCrossfade(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& crossfade)
 {
     // Walk the arguments.
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || args->size() != 5)
         return false;
     CSSParserValue* a = args->current();
-    RefPtrWillBeRawPtr<CSSValue> fromImageValue;
-    RefPtrWillBeRawPtr<CSSValue> toImageValue;
+    RefPtrWillBeRawPtr<CSSValue> fromImageValue = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> toImageValue = nullptr;
 
     // The first argument is the "from" image. It is a fill image.
     if (!a || !parseFillImage(args, fromImageValue))
         return false;
     a = args->next();
 
     // Skip a comma
     if (!isComma(a))
         return false;
     a = args->next();
 
     // The second argument is the "to" image. It is a fill image.
     if (!a || !parseFillImage(args, toImageValue))
         return false;
     a = args->next();
 
     // Skip a comma
     if (!isComma(a))
         return false;
     a = args->next();
 
     // The third argument is the crossfade value. It is a percentage or a fractional number.
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> percentage;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> percentage = nullptr;
     if (!a)
         return false;
 
     if (a->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
         percentage = cssValuePool().createValue(clampTo<double>(a->fValue / 100, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
     else if (a->unit == CSSPrimitiveValue::CSS_NUMBER)
         percentage = cssValuePool().createValue(clampTo<double>(a->fValue, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
     else
         return false;
 
@@ skipping 496 matching lines @@
         return true;
     default:
         return false;
     }
 }
 
 bool CSSPropertyParser::parseTextEmphasisStyle(bool important)
 {
     unsigned valueListSize = m_valueList->size();
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> fill;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> shape;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> fill = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> shape = nullptr;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->unit == CSSPrimitiveValue::CSS_STRING) {
             if (fill || shape || (valueListSize != 1 && !inShorthand()))
                 return false;
             addProperty(CSSPropertyWebkitTextEmphasisStyle, createPrimitiveStringValue(value), important);
             m_valueList->next();
             return true;
         }
 
@@ skipping 293 matching lines @@
         if (id == CSSValueZoom || id == CSSValueFixed)
             validPrimitive = true;
         break;
     case CSSPropertyOrientation: // auto | portrait | landscape
         if (id == CSSValueAuto || id == CSSValuePortrait || id == CSSValueLandscape)
             validPrimitive = true;
     default:
         break;
     }
 
-    RefPtrWillBeRawPtr<CSSValue> parsedValue;
+    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
 
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {
             addProperty(propId, parsedValue.release(), important);
             return true;
         }
@@ skipping 110 matching lines @@
 
 bool CSSPropertyParser::parseSVGValue(CSSPropertyID propId, bool important)
 {
     CSSParserValue* value = m_valueList->current();
     if (!value)
         return false;
 
     CSSValueID id = value->id;
 
     bool validPrimitive = false;
-    RefPtrWillBeRawPtr<CSSValue> parsedValue;
+    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
 
     switch (propId) {
     /* The comment to the right defines all valid value of these
      * properties as defined in SVG 1.1, Appendix N. Property index */
     case CSSPropertyAlignmentBaseline:
     // auto | baseline | before-edge | text-before-edge | middle |
     // central | after-edge | text-after-edge | ideographic | alphabetic |
     // hanging | mathematical | inherit
         if (id == CSSValueAuto || id == CSSValueBaseline || id == CSSValueMiddle
             || (id >= CSSValueBeforeEdge && id <= CSSValueMathematical))
@@ skipping 351 matching lines @@
         parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueFill));
     if (!seenStroke)
         parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueStroke));
     if (!seenMarkers)
         parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueMarkers));
 
     return parsedValues.release();
 }
 
 } // namespace WebCore