Oilpan: initialize stack allocated raw pointers following r362079.

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSCustomIdentValue.h"
@@ skipping 119 matching lines @@
     return false;
 }
 
 bool CSSPropertyParser::consumeCSSWideKeyword(CSSPropertyID unresolvedProperty, bool important)
 {
     CSSParserTokenRange rangeCopy = m_range;
     CSSValueID id = rangeCopy.consumeIncludingWhitespace().id();
     if (!rangeCopy.atEnd())
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> value;
+    RefPtrWillBeRawPtr<CSSValue> value = nullptr;
     if (id == CSSValueInitial)
         value = cssValuePool().createExplicitInitialValue();
     else if (id == CSSValueInherit)
         value = cssValuePool().createInheritedValue();
     else if (id == CSSValueUnset)
         value = cssValuePool().createUnsetValue();
     else
         return false;
 
     addExpandedPropertyForValue(resolveCSSPropertyID(unresolvedProperty), value.release(), important);
@@ skipping 507 matching lines @@
             return false;
         CSSValueID id = currentValue->getValueID();
 
         if (id == CSSValueCenter) {
             if (seenCenter)
                 return false;
             seenCenter = true;
             continue;
         }
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> offset;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> offset = nullptr;
         if (values[i + 1] && !values[i + 1]->isValueID()) {
             offset = values[++i];
         } else {
             offset = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Percentage);
         }
 
         RefPtrWillBeRawPtr<CSSValuePair> pair = CSSValuePair::create(currentValue, offset.release(), CSSValuePair::KeepIdenticalValues);
 
         if (id == CSSValueLeft || id == CSSValueRight) {
             if (resultX)
@@ skipping 44 matching lines @@
     values[0] = value1.get();
     values[1] = value2.get();
     values[2] = value3.get();
     values[3] = value4.get();
     values[4] = nullptr;
     return positionFromThreeOrFourValues(values, resultX, resultY);
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
 {
-    RefPtrWillBeRawPtr<CSSValue> resultX;
-    RefPtrWillBeRawPtr<CSSValue> resultY;
+    RefPtrWillBeRawPtr<CSSValue> resultX = nullptr;
+    RefPtrWillBeRawPtr<CSSValue> resultY = nullptr;
     if (consumePosition(range, cssParserMode, unitless, resultX, resultY))
         return CSSValuePair::create(resultX.release(), resultY.release(), CSSValuePair::KeepIdenticalValues);
     return nullptr;
 }
 
 static inline bool isCSSWideKeyword(const CSSValueID& id)
 {
     return id == CSSValueInitial || id == CSSValueInherit || id == CSSValueUnset || id == CSSValueDefault;
 }
 
@@ skipping 592 matching lines @@
         // 1 (will be dropped in the unprefixed property).
         if (spanValue->getIntValue() == 1)
             return spanValue.release();
     }
     return nullptr;
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> consumeZoom(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     const CSSParserToken& token = range.peek();
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> zoom;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> zoom = nullptr;
     if (token.type() == IdentToken) {
         zoom = consumeIdent<CSSValueNormal, CSSValueReset, CSSValueDocument>(range);
     } else {
         zoom = consumePercent(range, ValueRangeNonNegative);
         if (!zoom)
             zoom = consumeNumber(range, ValueRangeNonNegative);
     }
     if (zoom && context.useCounter()
         && !(token.id() == CSSValueNormal
             || (token.type() == NumberToken && zoom->getDoubleValue() == 1)
@@ skipping 365 matching lines @@
     return list.release();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> consumeTextDecorationLine(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueNone)
         return consumeIdent(range);
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> ident;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> ident = nullptr;
     while ((ident = consumeIdent<CSSValueBlink, CSSValueUnderline, CSSValueOverline, CSSValueLineThrough>(range))) {
         if (list->hasValue(ident.get()))
             return nullptr;
         list->append(ident.release());
     }
 
     if (!list->length())
         return nullptr;
     return list.release();
 }
@@ skipping 94 matching lines @@
 }
 
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeColumnRuleWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     return consumeLineWidth(range, cssParserMode);
 }
 
 static bool consumeTranslate3d(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtrWillBeRawPtr<CSSFunctionValue>& transformValue)
 {
     unsigned numberOfArguments = 2;
-    RefPtrWillBeRawPtr<CSSValue> parsedValue;
+    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
     do {
         parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
         if (!parsedValue)
             return false;
         transformValue->append(parsedValue);
         if (!consumeCommaIncludingWhitespace(args))
             return false;
     } while (--numberOfArguments);
     parsedValue = consumeLength(args, cssParserMode, ValueRangeAll);
     if (!parsedValue)
@@ skipping 1015 matching lines @@
         return consumeShorthandGreedily(flexFlowShorthand(), important);
     case CSSPropertyWebkitColumnRule:
         return consumeShorthandGreedily(webkitColumnRuleShorthand(), important);
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink