Use nullptr_t for RefPtr, PassRefPtr and RawPtr.

Source/core/css/parser/BisonCSSParser-in.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 223 matching lines @@
     m_logErrors = logErrors && sheet->singleOwnerDocument() && !sheet->baseURL().isEmpty() && sheet->singleOwnerDocument()->frameHost();
     m_ignoreErrors = false;
     m_tokenizer.m_lineNumber = 0;
     m_startPosition = startPosition;
     m_source = &string;
     m_tokenizer.m_internal = false;
     setupParser("", string, "");
     cssyyparse(this);
     sheet->shrinkToFit();
     m_source = 0;
-    m_rule = 0;
+    m_rule = nullptr;
     m_lineEndings.clear();
     m_ignoreErrors = false;
     m_logErrors = false;
     m_tokenizer.m_internal = true;
 }
 
 PassRefPtr<StyleRuleBase> BisonCSSParser::parseRule(StyleSheetContents* sheet, const String& string)
 {
     setStyleSheet(sheet);
     m_allowNamespaceDeclarations = false;
@@ skipping 719 matching lines @@
     }
     return true;
 }
 
 template <typename CharType>
 static PassRefPtrWillBeRawPtr<CSSTransformValue> parseTranslateTransformValue(CharType*& pos, CharType* end)
 {
     static const int shortestValidTransformStringLength = 12;
 
     if (end - pos < shortestValidTransformStringLength)
-        return 0;
+        return nullptr;
 
     if ((pos[0] != 't' && pos[0] != 'T')
         || (pos[1] != 'r' && pos[1] != 'R')
         || (pos[2] != 'a' && pos[2] != 'A')
         || (pos[3] != 'n' && pos[3] != 'N')
         || (pos[4] != 's' && pos[4] != 'S')
         || (pos[5] != 'l' && pos[5] != 'L')
         || (pos[6] != 'a' && pos[6] != 'A')
         || (pos[7] != 't' && pos[7] != 'T')
         || (pos[8] != 'e' && pos[8] != 'E'))
-        return 0;
+        return nullptr;
 
     CSSTransformValue::TransformOperationType transformType;
     unsigned expectedArgumentCount = 1;
     unsigned argumentStart = 11;
     if ((pos[9] == 'x' || pos[9] == 'X') && pos[10] == '(') {
         transformType = CSSTransformValue::TranslateXTransformOperation;
     } else if ((pos[9] == 'y' || pos[9] == 'Y') && pos[10] == '(') {
         transformType = CSSTransformValue::TranslateYTransformOperation;
     } else if ((pos[9] == 'z' || pos[9] == 'Z') && pos[10] == '(') {
         transformType = CSSTransformValue::TranslateZTransformOperation;
     } else if (pos[9] == '(') {
         transformType = CSSTransformValue::TranslateTransformOperation;
         expectedArgumentCount = 2;
         argumentStart = 10;
     } else if (pos[9] == '3' && (pos[10] == 'd' || pos[10] == 'D') && pos[11] == '(') {
         transformType = CSSTransformValue::Translate3DTransformOperation;
         expectedArgumentCount = 3;
         argumentStart = 12;
     } else {
-        return 0;
+        return nullptr;
     }
     pos += argumentStart;
 
     RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(transformType);
     if (!parseTransformTranslateArguments(pos, end, expectedArgumentCount, transformValue.get()))
-        return 0;
+        return nullptr;
     return transformValue.release();
 }
 
 template <typename CharType>
 static PassRefPtrWillBeRawPtr<CSSValueList> parseTranslateTransformList(CharType*& pos, CharType* end)
 {
     RefPtrWillBeRawPtr<CSSValueList> transformList;
     while (pos < end) {
         while (pos < end && isCSSSpace(*pos))
             ++pos;
         RefPtrWillBeRawPtr<CSSTransformValue> transformValue = parseTranslateTransformValue(pos, end);
         if (!transformValue)
-            return 0;
+            return nullptr;
         if (!transformList)
             transformList = CSSValueList::createSpaceSeparated();
         transformList->append(transformValue.release());
         if (pos < end) {
             if (isCSSSpace(*pos))
-                return 0;
+                return nullptr;
         }
     }
     return transformList.release();
 }
 
 static bool parseTranslateTransform(MutableStylePropertySet* properties, CSSPropertyID propertyID, const String& string, bool important)
 {
     if (propertyID != CSSPropertyWebkitTransform)
         return false;
     if (string.isEmpty())
@@ skipping 12 matching lines @@
         if (!transformList)
             return false;
     }
     properties->addParsedProperty(CSSProperty(CSSPropertyWebkitTransform, transformList.release(), important));
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSValueList> BisonCSSParser::parseFontFaceValue(const AtomicString& string)
 {
     if (string.isEmpty())
-        return 0;
+        return nullptr;
     RefPtr<MutableStylePropertySet> dummyStyle = MutableStylePropertySet::create();
     if (!parseValue(dummyStyle.get(), CSSPropertyFontFamily, string, false, HTMLQuirksMode, 0))
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSValue> fontFamily = dummyStyle->getPropertyCSSValue(CSSPropertyFontFamily);
     if (!fontFamily->isValueList())
-        return 0;
+        return nullptr;
 
     return toCSSValueList(dummyStyle->getPropertyCSSValue(CSSPropertyFontFamily).get());
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> BisonCSSParser::parseAnimationTimingFunctionValue(const String& string)
 {
     if (string.isEmpty())
-        return 0;
+        return nullptr;
     RefPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
     if (!parseValue(style.get(), CSSPropertyAnimationTimingFunction, string, false, HTMLStandardMode, 0))
-        return 0;
+        return nullptr;
 
     return style->getPropertyCSSValue(CSSPropertyAnimationTimingFunction);
 }
 
 bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, const Document& document)
 {
     ASSERT(!string.isEmpty());
 
     CSSParserContext context(document, UseCounter::getFrom(&document));
 
@@ skipping 43 matching lines @@
     setupParser("@-internal-value ", string, "");
 
     m_id = propertyID;
     m_important = important;
 
     {
         StyleDeclarationScope scope(this, declaration);
         cssyyparse(this);
     }
 
-    m_rule = 0;
+    m_rule = nullptr;
     m_id = CSSPropertyInvalid;
 
     bool ok = false;
     if (m_hasFontFaceOnlyValues)
         deleteFontFaceOnlyValues();
     if (!m_parsedProperties.isEmpty()) {
         ok = true;
         declaration->addParsedProperties(m_parsedProperties);
         clearProperties();
     }
@@ skipping 24 matching lines @@
         return false;
 
     color = primitiveValue->getRGBA32Value();
     return true;
 }
 
 bool BisonCSSParser::parseColor(const String& string)
 {
     setupParser("@-internal-decls color:", string, "");
     cssyyparse(this);
-    m_rule = 0;
+    m_rule = nullptr;
 
     return !m_parsedProperties.isEmpty() && m_parsedProperties.first().id() == CSSPropertyColor;
 }
 
 // FIXME: This is copied from SVGCSSParser.cpp
 static bool isSystemColor(int id)
 {
     return (id >= CSSValueActiveborder && id <= CSSValueWindowtext) || id == CSSValueMenu;
 }
 
@@ skipping 31 matching lines @@
     context.setMode((element->isHTMLElement() && !document.inQuirksMode()) ? HTMLStandardMode : HTMLQuirksMode);
     return BisonCSSParser(context).parseDeclaration(string, document.elementSheet()->contents());
 }
 
 PassRefPtr<ImmutableStylePropertySet> BisonCSSParser::parseDeclaration(const String& string, StyleSheetContents* contextStyleSheet)
 {
     setStyleSheet(contextStyleSheet);
 
     setupParser("@-internal-decls ", string, "");
     cssyyparse(this);
-    m_rule = 0;
+    m_rule = nullptr;
 
     if (m_hasFontFaceOnlyValues)
         deleteFontFaceOnlyValues();
 
     RefPtr<ImmutableStylePropertySet> style = createStylePropertySet();
     clearProperties();
     return style.release();
 }
 
 
 bool BisonCSSParser::parseDeclaration(MutableStylePropertySet* declaration, const String& string, CSSParserObserver* observer, StyleSheetContents* contextStyleSheet)
 {
     setStyleSheet(contextStyleSheet);
 
     TemporaryChange<CSSParserObserver*> scopedObsever(m_observer, observer);
 
     setupParser("@-internal-decls ", string, "");
     if (m_observer) {
         m_observer->startRuleHeader(CSSRuleSourceData::STYLE_RULE, 0);
         m_observer->endRuleHeader(1);
         m_observer->startRuleBody(0);
     }
 
     {
         StyleDeclarationScope scope(this, declaration);
         cssyyparse(this);
     }
 
-    m_rule = 0;
+    m_rule = nullptr;
 
     bool ok = false;
     if (m_hasFontFaceOnlyValues)
         deleteFontFaceOnlyValues();
     if (!m_parsedProperties.isEmpty()) {
         ok = true;
         declaration->addParsedProperties(m_parsedProperties);
         clearProperties();
     }
 
@@ skipping 288 matching lines @@
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMAX)
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSPrimitiveValue::CSS_DPPX && value->unit <= CSSPrimitiveValue::CSS_DPCM)
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSParserValue::Q_EMS)
         return CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS);
     if (isCalculation(value))
         return CSSPrimitiveValue::create(m_parsedCalculation.release());
 
-    return 0;
+    return nullptr;
 }
 
 void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> prpValue, bool important)
 {
     const StylePropertyShorthand& shorthand = shorthandForProperty(propId);
     unsigned shorthandLength = shorthand.length();
     if (!shorthandLength) {
         addProperty(propId, prpValue, important);
         return;
     }
@@ skipping 203 matching lines @@
     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;
         while (value) {
-            RefPtrWillBeRawPtr<CSSValue> image = 0;
+            RefPtrWillBeRawPtr<CSSValue> image = nullptr;
             if (value->unit == CSSPrimitiveValue::CSS_URI) {
                 String uri = value->string;
                 if (!uri.isNull())
                     image = CSSImageValue::create(completeURL(uri));
             } else if (value->unit == CSSParserValue::Function && equalIgnoringCase(value->function->name, "-webkit-image-set(")) {
                 image = parseImageSet(m_valueList.get());
                 if (!image)
                     break;
             } else
                 break;
@@ skipping 1308 matching lines @@
 {
     CSSParserValue* value = m_valueList->current();
     // Always parse lengths in strict mode here, since it would be ambiguous otherwise when used in
     // the 'columns' shorthand property.
     if (value->id == CSSValueAuto
         || (validUnit(value, FLength | FNonNeg, HTMLStandardMode) && value->fValue)) {
         RefPtrWillBeRawPtr<CSSValue> parsedValue = parseValidPrimitive(value->id, value);
         m_valueList->next();
         return parsedValue;
     }
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseColumnCount()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueAuto
         || (!value->id && validUnit(value, FPositiveInteger, HTMLQuirksMode))) {
         RefPtrWillBeRawPtr<CSSValue> parsedValue = parseValidPrimitive(value->id, value);
         m_valueList->next();
         return parsedValue;
     }
-    return 0;
+    return nullptr;
 }
 
 bool CSSPropertyParser::parseColumnsShorthand(bool important)
 {
     RefPtrWillBeRawPtr<CSSValue> columnWidth;
     RefPtrWillBeRawPtr<CSSValue> columnCount;
     bool hasPendingExplicitAuto = false;
 
     for (unsigned propertiesParsed = 0; CSSParserValue* value = m_valueList->current(); propertiesParsed++) {
         if (propertiesParsed >= 2)
@@ skipping 338 matching lines @@
         m_valueList->next();
         return true;
     }
 
     return false;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAttr(CSSParserValueList* args)
 {
     if (args->size() != 1)
-        return 0;
+        return nullptr;
 
     CSSParserValue* a = args->current();
 
     if (a->unit != CSSPrimitiveValue::CSS_IDENT)
-        return 0;
+        return nullptr;
 
     String attrName = a->string;
     // CSS allows identifiers with "-" at the start, like "-webkit-mask-image".
     // But HTML attribute names can't have those characters, and we should not
     // even parse them inside attr().
     if (attrName[0] == '-')
-        return 0;
+        return nullptr;
 
     if (m_context.isHTMLDocument())
         attrName = attrName.lower();
 
     return cssValuePool().createValue(attrName, CSSPrimitiveValue::CSS_ATTR);
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBackgroundColor()
 {
     CSSValueID id = m_valueList->current()->id;
@@ skipping 32 matching lines @@
     if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueCenter) {
         int percent = 0;
         if (id == CSSValueRight)
             percent = 100;
         else if (id == CSSValueCenter)
             percent = 50;
         return cssValuePool().createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
     }
     if (validUnit(valueList->current(), FPercent | FLength))
         return createPrimitiveNumericValue(valueList->current());
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillPositionY(CSSParserValueList* valueList)
 {
     int id = valueList->current()->id;
     if (id == CSSValueTop || id == CSSValueBottom || id == CSSValueCenter) {
         int percent = 0;
         if (id == CSSValueBottom)
             percent = 100;
         else if (id == CSSValueCenter)
             percent = 50;
         return cssValuePool().createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
     }
     if (validUnit(valueList->current(), FPercent | FLength))
         return createPrimitiveNumericValue(valueList->current());
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseFillPositionComponent(CSSParserValueList* valueList, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode parsingMode)
 {
     CSSValueID id = valueList->current()->id;
     if (id == CSSValueLeft || id == CSSValueTop || id == CSSValueRight || id == CSSValueBottom || id == CSSValueCenter) {
         int percent = 0;
         if (id == CSSValueLeft || id == CSSValueRight) {
             if (cumulativeFlags & XFillPosition)
-                return 0;
+                return nullptr;
             cumulativeFlags |= XFillPosition;
             individualFlag = XFillPosition;
             if (id == CSSValueRight)
                 percent = 100;
         }
         else if (id == CSSValueTop || id == CSSValueBottom) {
             if (cumulativeFlags & YFillPosition)
-                return 0;
+                return nullptr;
             cumulativeFlags |= YFillPosition;
             individualFlag = YFillPosition;
             if (id == CSSValueBottom)
                 percent = 100;
         } else if (id == CSSValueCenter) {
             // Center is ambiguous, so we're not sure which position we've found yet, an x or a y.
             percent = 50;
             cumulativeFlags |= AmbiguousFillPosition;
             individualFlag = AmbiguousFillPosition;
         }
 
         if (parsingMode == ResolveValuesAsKeyword)
             return cssValuePool().createIdentifierValue(id);
 
         return cssValuePool().createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
     }
     if (validUnit(valueList->current(), FPercent | FLength)) {
         if (!cumulativeFlags) {
             cumulativeFlags |= XFillPosition;
             individualFlag = XFillPosition;
         } else if (cumulativeFlags & (XFillPosition | AmbiguousFillPosition)) {
             cumulativeFlags |= YFillPosition;
             individualFlag = YFillPosition;
         } else {
             if (m_parsedCalculation)
                 m_parsedCalculation.release();
-            return 0;
+            return nullptr;
         }
         return createPrimitiveNumericValue(valueList->current());
     }
-    return 0;
+    return nullptr;
 }
 
 static bool isValueConflictingWithCurrentEdge(int value1, int value2)
 {
     if ((value1 == CSSValueLeft || value1 == CSSValueRight) && (value2 == CSSValueLeft || value2 == CSSValueRight))
         return true;
 
     if ((value1 == CSSValueTop || value1 == CSSValueBottom) && (value2 == CSSValueTop || value2 == CSSValueBottom))
         return true;
 
@@ skipping 269 matching lines @@
     if (id == CSSValueRepeatY) {
         m_implicitShorthand = true;
         value1 = cssValuePool().createIdentifierValue(CSSValueNoRepeat);
         value2 = cssValuePool().createIdentifierValue(CSSValueRepeat);
         m_valueList->next();
         return;
     }
     if (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace)
         value1 = cssValuePool().createIdentifierValue(id);
     else {
-        value1 = 0;
+        value1 = nullptr;
         return;
     }
 
     CSSParserValue* value = m_valueList->next();
 
     // Parse the second value if one is available
     if (value && !isComma(value)) {
         id = value->id;
         if (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace) {
             value2 = cssValuePool().createIdentifierValue(id);
@@ skipping 14 matching lines @@
 
     if (value->id == CSSValueContain || value->id == CSSValueCover)
         return cssValuePool().createIdentifierValue(value->id);
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1;
 
     if (value->id == CSSValueAuto)
         parsedValue1 = cssValuePool().createIdentifierValue(CSSValueAuto);
     else {
         if (!validUnit(value, FLength | FPercent))
-            return 0;
+            return nullptr;
         parsedValue1 = createPrimitiveNumericValue(value);
     }
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2;
     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 0;
+                    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;
     CSSParserValue* val;
     RefPtrWillBeRawPtr<CSSValue> value;
     RefPtrWillBeRawPtr<CSSValue> value2;
 
     bool allowComma = false;
 
-    retValue1 = retValue2 = 0;
+    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;
@@ skipping 104 matching lines @@
                     if (currValue)
                         m_valueList->next();
                     break;
                 }
                 case CSSPropertyMaskSourceType: {
                     if (RuntimeEnabledFeatures::cssMaskSourceTypeEnabled()) {
                         if (val->id == CSSValueAuto || val->id == CSSValueAlpha || val->id == CSSValueLuminance) {
                             currValue = cssValuePool().createIdentifierValue(val->id);
                             m_valueList->next();
                         } else {
-                            currValue = 0;
+                            currValue = nullptr;
                         }
                     }
                     break;
                 }
                 default:
                     break;
             }
             if (!currValue)
                 return false;
 
@@ skipping 37 matching lines @@
         return true;
     }
     return false;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationDelay()
 {
     CSSParserValue* value = m_valueList->current();
     if (validUnit(value, FTime))
         return createPrimitiveNumericValue(value);
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationDirection()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueNormal || value->id == CSSValueAlternate || value->id == CSSValueReverse || value->id == CSSValueAlternateReverse)
         return cssValuePool().createIdentifierValue(value->id);
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationDuration()
 {
     CSSParserValue* value = m_valueList->current();
     if (validUnit(value, FTime | FNonNeg))
         return createPrimitiveNumericValue(value);
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationFillMode()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueNone || value->id == CSSValueForwards || value->id == CSSValueBackwards || value->id == CSSValueBoth)
         return cssValuePool().createIdentifierValue(value->id);
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationIterationCount()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueInfinite)
         return cssValuePool().createIdentifierValue(value->id);
     if (validUnit(value, FNumber | FNonNeg))
         return createPrimitiveNumericValue(value);
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationName()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT) {
         if (value->id == CSSValueNone || (value->unit == CSSPrimitiveValue::CSS_STRING && equalIgnoringCase(value, "none"))) {
             return cssValuePool().createIdentifierValue(CSSValueNone);
         } else {
             return createPrimitiveStringValue(value);
         }
     }
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationPlayState()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueRunning || value->id == CSSValuePaused)
         return cssValuePool().createIdentifierValue(value->id);
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationProperty(AnimationParseContext& context)
 {
     CSSParserValue* value = m_valueList->current();
     if (value->unit != CSSPrimitiveValue::CSS_IDENT)
-        return 0;
+        return nullptr;
     CSSPropertyID result = cssPropertyID(value->string);
     if (result)
         return cssValuePool().createIdentifierValue(result);
     if (equalIgnoringCase(value, "all")) {
         context.sawAnimationPropertyKeyword();
         return cssValuePool().createIdentifierValue(CSSValueAll);
     }
     if (equalIgnoringCase(value, "none")) {
         context.commitAnimationPropertyKeyword();
         context.sawAnimationPropertyKeyword();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
-    return 0;
+    return nullptr;
 }
 
 bool CSSPropertyParser::parseTransformOriginShorthand(RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2, RefPtrWillBeRawPtr<CSSValue>& value3)
 {
     parse2ValuesFillPosition(m_valueList.get(), value1, value2);
 
     // now get z
     if (m_valueList->current()) {
         if (validUnit(m_valueList->current(), FLength)) {
             value3 = createPrimitiveNumericValue(m_valueList->current());
@@ skipping 24 matching lines @@
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationTimingFunction()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueEase || value->id == CSSValueLinear || value->id == CSSValueEaseIn || value->id == CSSValueEaseOut
         || value->id == CSSValueEaseInOut || value->id == CSSValueStepStart || value->id == CSSValueStepEnd)
         return cssValuePool().createIdentifierValue(value->id);
 
     // We must be a function.
     if (value->unit != CSSParserValue::Function)
-        return 0;
+        return nullptr;
 
     CSSParserValueList* args = value->function->args.get();
 
     if (equalIgnoringCase(value->function->name, "steps(")) {
         // For steps, 1 or 2 params must be specified (comma-separated)
         if (!args || (args->size() != 1 && args->size() != 3))
-            return 0;
+            return nullptr;
 
         // There are two values.
         int numSteps;
         bool stepAtStart = false;
 
         CSSParserValue* v = args->current();
         if (!validUnit(v, FInteger))
-            return 0;
+            return nullptr;
         numSteps = clampToInteger(v->fValue);
         if (numSteps < 1)
-            return 0;
+            return nullptr;
         v = args->next();
 
         if (v) {
             // There is a comma so we need to parse the second value
             if (!isComma(v))
-                return 0;
+                return nullptr;
             v = args->next();
             if (v->id != CSSValueStart && v->id != CSSValueEnd)
-                return 0;
+                return nullptr;
             stepAtStart = v->id == CSSValueStart;
         }
 
         return CSSStepsTimingFunctionValue::create(numSteps, stepAtStart);
     }
 
     if (equalIgnoringCase(value->function->name, "cubic-bezier(")) {
         // For cubic bezier, 4 values must be specified.
         if (!args || args->size() != 7)
-            return 0;
+            return nullptr;
 
         // There are two points specified. The x values must be between 0 and 1 but the y values can exceed this range.
         double x1, y1, x2, y2;
 
         if (!parseCubicBezierTimingFunctionValue(args, x1))
-            return 0;
+            return nullptr;
         if (x1 < 0 || x1 > 1)
-            return 0;
+            return nullptr;
         if (!parseCubicBezierTimingFunctionValue(args, y1))
-            return 0;
+            return nullptr;
         if (!parseCubicBezierTimingFunctionValue(args, x2))
-            return 0;
+            return nullptr;
         if (x2 < 0 || x2 > 1)
-            return 0;
+            return nullptr;
         if (!parseCubicBezierTimingFunctionValue(args, y2))
-            return 0;
+            return nullptr;
 
         return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
     }
 
-    return 0;
+    return nullptr;
 }
 
 bool CSSPropertyParser::parseAnimationProperty(CSSPropertyID propId, RefPtrWillBeRawPtr<CSSValue>& result, AnimationParseContext& context)
 {
     RefPtrWillBeRawPtr<CSSValueList> values;
     CSSParserValue* val;
     RefPtrWillBeRawPtr<CSSValue> value;
     bool allowComma = false;
 
-    result = 0;
+    result = nullptr;
 
     while ((val = m_valueList->current())) {
         RefPtrWillBeRawPtr<CSSValue> currValue;
         if (allowComma) {
             if (!isComma(val))
                 return false;
             m_valueList->next();
             allowComma = false;
         }
         else {
@@ skipping 152 matching lines @@
         }
     } else if (value->id == CSSValueSpan) {
         hasSeenSpanKeyword = true;
         if (m_valueList->next())
             parseIntegerOrStringFromGridPosition(numericValue, gridLineName);
     }
 
     // Check that we have consumed all the value list. For shorthands, the parser will pass
     // the whole value list (including the opposite position).
     if (m_valueList->current() && !isForwardSlashOperator(m_valueList->current()))
-        return 0;
+        return nullptr;
 
     // If we didn't parse anything, this is not a valid grid position.
     if (!hasSeenSpanKeyword && !gridLineName && !numericValue)
-        return 0;
+        return nullptr;
 
     // Negative numbers are not allowed for span (but are for <integer>).
     if (hasSeenSpanKeyword && numericValue && numericValue->getIntValue() < 0)
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
     if (hasSeenSpanKeyword)
         values->append(cssValuePool().createIdentifierValue(CSSValueSpan));
     if (numericValue)
         values->append(numericValue.release());
     if (gridLineName)
         values->append(gridLineName.release());
     ASSERT(values->length());
     return values.release();
@@ skipping 208 matching lines @@
     CSSParserValue* currentValue = inputList.current();
     inputList.next();
 
     if (currentValue->id == CSSValueAuto)
         return cssValuePool().createIdentifierValue(CSSValueAuto);
 
     if (currentValue->unit == CSSParserValue::Function && equalIgnoringCase(currentValue->function->name, "minmax(")) {
         // The spec defines the following grammar: minmax( <track-breadth> , <track-breadth> )
         CSSParserValueList* arguments = currentValue->function->args.get();
         if (!arguments || arguments->size() != 3 || !isComma(arguments->valueAt(1)))
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> minTrackBreadth = parseGridBreadth(arguments->valueAt(0));
         if (!minTrackBreadth)
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> maxTrackBreadth = parseGridBreadth(arguments->valueAt(2));
         if (!maxTrackBreadth)
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSValueList> parsedArguments = CSSValueList::createCommaSeparated();
         parsedArguments->append(minTrackBreadth);
         parsedArguments->append(maxTrackBreadth);
         return CSSFunctionValue::create("minmax(", parsedArguments);
     }
 
     return parseGridBreadth(currentValue);
 }
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseGridBreadth(CSSParserValue* currentValue)
 {
     if (currentValue->id == CSSValueMinContent || currentValue->id == CSSValueMaxContent)
         return cssValuePool().createIdentifierValue(currentValue->id);
 
     if (currentValue->unit == CSSPrimitiveValue::CSS_FR) {
         double flexValue = currentValue->fValue;
 
         // Fractional unit is a non-negative dimension.
         if (flexValue <= 0)
-            return 0;
+            return nullptr;
 
         return cssValuePool().createValue(flexValue, CSSPrimitiveValue::CSS_FR);
     }
 
     if (!validUnit(currentValue, FNonNeg | FLength | FPercent))
-        return 0;
+        return nullptr;
 
     return createPrimitiveNumericValue(currentValue);
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridTemplateAreas()
 {
     NamedGridAreaMap gridAreaMap;
     size_t rowCount = 0;
     size_t columnCount = 0;
 
     while (CSSParserValue* currentValue = m_valueList->current()) {
         if (currentValue->unit != CSSPrimitiveValue::CSS_STRING)
-            return 0;
+            return nullptr;
 
         String gridRowNames = currentValue->string;
         if (!gridRowNames.length())
-            return 0;
+            return nullptr;
 
         Vector<String> columnNames;
         gridRowNames.split(' ', columnNames);
 
         if (!columnCount) {
             columnCount = columnNames.size();
             ASSERT(columnCount);
         } else if (columnCount != columnNames.size()) {
             // The declaration is invalid is all the rows don't have the number of columns.
-            return 0;
+            return nullptr;
         }
 
         for (size_t currentCol = 0; currentCol < columnCount; ++currentCol) {
             const String& gridAreaName = columnNames[currentCol];
 
             // Unamed areas are always valid (we consider them to be 1x1).
             if (gridAreaName == ".")
                 continue;
 
             // We handle several grid areas with the same name at once to simplify the validation code.
             size_t lookAheadCol;
             for (lookAheadCol = currentCol; lookAheadCol < (columnCount - 1); ++lookAheadCol) {
                 if (columnNames[lookAheadCol + 1] != gridAreaName)
                     break;
             }
 
             NamedGridAreaMap::iterator gridAreaIt = gridAreaMap.find(gridAreaName);
             if (gridAreaIt == gridAreaMap.end()) {
                 gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount), GridSpan(currentCol, lookAheadCol)));
             } else {
                 GridCoordinate& gridCoordinate = gridAreaIt->value;
 
                 // The following checks test that the grid area is a single filled-in rectangle.
                 // 1. The new row is adjacent to the previously parsed row.
                 if (rowCount != gridCoordinate.rows.initialPositionIndex + 1)
-                    return 0;
+                    return nullptr;
 
                 // 2. The new area starts at the same position as the previously parsed area.
                 if (currentCol != gridCoordinate.columns.initialPositionIndex)
-                    return 0;
+                    return nullptr;
 
                 // 3. The new area ends at the same position as the previously parsed area.
                 if (lookAheadCol != gridCoordinate.columns.finalPositionIndex)
-                    return 0;
+                    return nullptr;
 
                 ++gridCoordinate.rows.finalPositionIndex;
             }
             currentCol = lookAheadCol;
         }
 
         ++rowCount;
         m_valueList->next();
     }
 
     if (!rowCount || !columnCount)
-        return 0;
+        return nullptr;
 
     return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseCounterContent(CSSParserValueList* args, bool counters)
 {
     unsigned numArgs = args->size();
     if (counters && numArgs != 3 && numArgs != 5)
-        return 0;
+        return nullptr;
     if (!counters && numArgs != 1 && numArgs != 3)
-        return 0;
+        return nullptr;
 
     CSSParserValue* i = args->current();
     if (i->unit != CSSPrimitiveValue::CSS_IDENT)
-        return 0;
+        return nullptr;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> identifier = createPrimitiveStringValue(i);
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> separator;
     if (!counters)
         separator = cssValuePool().createValue(String(), CSSPrimitiveValue::CSS_STRING);
     else {
         i = args->next();
         if (i->unit != CSSParserValue::Operator || i->iValue != ',')
-            return 0;
+            return nullptr;
 
         i = args->next();
         if (i->unit != CSSPrimitiveValue::CSS_STRING)
-            return 0;
+            return nullptr;
 
         separator = createPrimitiveStringValue(i);
     }
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle;
     i = args->next();
     if (!i) // Make the list style default decimal
         listStyle = cssValuePool().createIdentifierValue(CSSValueDecimal);
     else {
         if (i->unit != CSSParserValue::Operator || i->iValue != ',')
-            return 0;
+            return nullptr;
 
         i = args->next();
         if (i->unit != CSSPrimitiveValue::CSS_IDENT)
-            return 0;
+            return nullptr;
 
         CSSValueID listStyleID = CSSValueInvalid;
         if (i->id == CSSValueNone || (i->id >= CSSValueDisc && i->id <= CSSValueKatakanaIroha))
             listStyleID = i->id;
         else
-            return 0;
+            return nullptr;
 
         listStyle = cssValuePool().createIdentifierValue(listStyleID);
     }
 
     return cssValuePool().createValue(Counter::create(identifier.release(), listStyle.release(), separator.release()));
 }
 
 bool CSSPropertyParser::parseClipShape(CSSPropertyID propId, bool important)
 {
     CSSParserValue* value = m_valueList->current();
@@ skipping 55 matching lines @@
     radii[3] = radii[1];
 }
 
 // FIXME: This should be refactored with CSSParser::parseBorderRadius.
 // CSSParser::parseBorderRadius contains support for some legacy radius construction.
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseInsetRoundedCorners(PassRefPtrWillBeRawPtr<CSSBasicShapeInset> shape, CSSParserValueList* args)
 {
     CSSParserValue* argument = args->next();
 
     if (!argument)
-        return 0;
+        return nullptr;
 
     CSSParserValueList radiusArguments;
     while (argument) {
         radiusArguments.addValue(*argument);
         argument = args->next();
     }
 
     unsigned num = radiusArguments.size();
     if (!num || num > 9)
-        return 0;
+        return nullptr;
 
     // FIXME: Refactor completeBorderRadii and the array
     RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[2][4];
 
     unsigned indexAfterSlash = 0;
     for (unsigned i = 0; i < num; ++i) {
         CSSParserValue* value = radiusArguments.valueAt(i);
         if (value->unit == CSSParserValue::Operator) {
             if (value->iValue != '/')
-                return 0;
+                return nullptr;
 
             if (!i || indexAfterSlash || i + 1 == num)
-                return 0;
+                return nullptr;
 
             indexAfterSlash = i + 1;
             completeBorderRadii(radii[0]);
             continue;
         }
 
         if (i - indexAfterSlash >= 4)
-            return 0;
+            return nullptr;
 
         if (!validUnit(value, FLength | FPercent | FNonNeg))
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(value);
 
         if (!indexAfterSlash)
             radii[0][i] = radius;
         else
             radii[1][i - indexAfterSlash] = radius.release();
     }
 
     if (!indexAfterSlash) {
@@ skipping 22 matching lines @@
     bool hasRoundedInset = false;
 
     while (argument) {
         if (argument->unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(argument->string, "round")) {
             hasRoundedInset = true;
             break;
         }
 
         Units unitFlags = FLength | FPercent;
         if (!validUnit(argument, unitFlags) || widthArguments.size() > 4)
-            return 0;
+            return nullptr;
 
         widthArguments.append(createPrimitiveNumericValue(argument));
         argument = args->next();
     }
 
     switch (widthArguments.size()) {
     case 1: {
         shape->updateShapeSize1Value(widthArguments[0].get());
         break;
     }
     case 2: {
         shape->updateShapeSize2Values(widthArguments[0].get(), widthArguments[1].get());
         break;
         }
     case 3: {
         shape->updateShapeSize3Values(widthArguments[0].get(), widthArguments[1].get(), widthArguments[2].get());
         break;
     }
     case 4: {
         shape->updateShapeSize4Values(widthArguments[0].get(), widthArguments[1].get(), widthArguments[2].get(), widthArguments[3].get());
         break;
     }
     default:
-        return 0;
+        return nullptr;
     }
 
     if (hasRoundedInset)
         return parseInsetRoundedCorners(shape, args);
     return shape;
 }
 
 static bool isItemPositionKeyword(CSSValueID id)
 {
     return id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter
@@ skipping 10 matching lines @@
     CSSParserValue* value = m_valueList->current();
 
     if (value->id == CSSValueAuto || value->id == CSSValueBaseline || value->id == CSSValueStretch) {
         if (m_valueList->next())
             return false;
 
         addProperty(propId, cssValuePool().createIdentifierValue(value->id), important);
         return true;
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> position = 0;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> overflowAlignmentKeyword = 0;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> position = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> overflowAlignmentKeyword = nullptr;
     if (isItemPositionKeyword(value->id)) {
         position = cssValuePool().createIdentifierValue(value->id);
         value = m_valueList->next();
         if (value) {
             if (value->id == CSSValueTrue || value->id == CSSValueSafe)
                 overflowAlignmentKeyword = cssValuePool().createIdentifierValue(value->id);
             else
                 return false;
         }
     } else if (value->id == CSSValueTrue || value->id == CSSValueSafe) {
@@ skipping 20 matching lines @@
 
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeRectangle(CSSParserValueList* args)
 {
     ASSERT(args);
 
     // rect(x, y, width, height, [[rx], ry])
     if (args->size() != 7 && args->size() != 9 && args->size() != 11)
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSBasicShapeRectangle> shape = CSSBasicShapeRectangle::create();
 
     unsigned argumentNumber = 0;
     CSSParserValue* argument = args->current();
     while (argument) {
         Units unitFlags = FLength | FPercent;
         if (argumentNumber > 1) {
             // Arguments width, height, rx, and ry cannot be negative.
             unitFlags = unitFlags | FNonNeg;
         }
         if (!validUnit(argument, unitFlags))
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(argument);
         ASSERT(argumentNumber < 6);
         switch (argumentNumber) {
         case 0:
             shape->setX(length);
             break;
         case 1:
             shape->setY(length);
             break;
         case 2:
             shape->setWidth(length);
             break;
         case 3:
             shape->setHeight(length);
             break;
         case 4:
             shape->setRadiusX(length);
             break;
         case 5:
             shape->setRadiusY(length);
             break;
         }
         argument = args->next();
         if (argument) {
             if (!isComma(argument))
-                return 0;
+                return nullptr;
 
             argument = args->next();
         }
         argumentNumber++;
     }
 
     if (argumentNumber < 4)
-        return 0;
+        return nullptr;
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeInsetRectangle(CSSParserValueList* args)
 {
     ASSERT(args);
 
     // inset-rectangle(top, right, bottom, left, [[rx], ry])
     if (args->size() != 7 && args->size() != 9 && args->size() != 11)
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSBasicShapeInsetRectangle> shape = CSSBasicShapeInsetRectangle::create();
 
     unsigned argumentNumber = 0;
     CSSParserValue* argument = args->current();
     while (argument) {
         Units unitFlags = FLength | FPercent | FNonNeg;
         if (!validUnit(argument, unitFlags))
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(argument);
         ASSERT(argumentNumber < 6);
         switch (argumentNumber) {
         case 0:
             shape->setTop(length);
             break;
         case 1:
             shape->setRight(length);
             break;
         case 2:
             shape->setBottom(length);
             break;
         case 3:
             shape->setLeft(length);
             break;
         case 4:
             shape->setRadiusX(length);
             break;
         case 5:
             shape->setRadiusY(length);
             break;
         }
         argument = args->next();
         if (argument) {
             if (!isComma(argument))
-                return 0;
+                return nullptr;
 
             argument = args->next();
         }
         argumentNumber++;
     }
 
     if (argumentNumber < 4)
-        return 0;
+        return nullptr;
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseShapeRadius(CSSParserValue* value)
 {
     if (value->id == CSSValueClosestSide || value->id == CSSValueFarthestSide)
         return cssValuePool().createIdentifierValue(value->id);
 
     if (!validUnit(value, FLength | FPercent | FNonNeg))
-        return 0;
+        return nullptr;
 
     return createPrimitiveNumericValue(value);
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeCircle(CSSParserValueList* args)
 {
     ASSERT(args);
 
     // circle(radius)
     // circle(radius at <position>
     // circle(at <position>)
     // where position defines centerX and centerY using a CSS <position> data type.
     RefPtrWillBeRawPtr<CSSBasicShapeCircle> shape = CSSBasicShapeCircle::create();
 
     for (CSSParserValue* argument = args->current(); argument; argument = args->next()) {
         // The call to parseFillPosition below should consume all of the
         // arguments except the first two. Thus, and index greater than one
         // indicates an invalid production.
         if (args->currentIndex() > 1)
-            return 0;
+            return nullptr;
 
         if (!args->currentIndex() && argument->id != CSSValueAt) {
             if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
                 shape->setRadius(radius);
                 continue;
             }
 
-            return 0;
+            return nullptr;
         }
 
         if (argument->id == CSSValueAt) {
             RefPtrWillBeRawPtr<CSSValue> centerX;
             RefPtrWillBeRawPtr<CSSValue> centerY;
             args->next(); // set list to start of position center
             parseFillPosition(args, centerX, centerY);
             if (centerX && centerY) {
                 ASSERT(centerX->isPrimitiveValue());
                 ASSERT(centerY->isPrimitiveValue());
                 shape->setCenterX(toCSSPrimitiveValue(centerX.get()));
                 shape->setCenterY(toCSSPrimitiveValue(centerY.get()));
             } else {
-                return 0;
+                return nullptr;
             }
         } else {
-            return 0;
+            return nullptr;
         }
     }
 
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseDeprecatedBasicShapeCircle(CSSParserValueList* args)
 {
     ASSERT(args);
 
     // circle(centerX, centerY, radius)
     if (args->size() != 5)
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSDeprecatedBasicShapeCircle> shape = CSSDeprecatedBasicShapeCircle::create();
 
     unsigned argumentNumber = 0;
     CSSParserValue* argument = args->current();
     while (argument) {
         Units unitFlags = FLength | FPercent;
         if (argumentNumber == 2) {
             // Argument radius cannot be negative.
             unitFlags = unitFlags | FNonNeg;
         }
 
         if (!validUnit(argument, unitFlags))
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(argument);
         ASSERT(argumentNumber < 3);
         switch (argumentNumber) {
         case 0:
             shape->setCenterX(length);
             break;
         case 1:
             shape->setCenterY(length);
             break;
         case 2:
             shape->setRadius(length);
             break;
         }
 
         argument = args->next();
         if (argument) {
             if (!isComma(argument))
-                return 0;
+                return nullptr;
             argument = args->next();
         }
         argumentNumber++;
     }
 
     if (argumentNumber < 3)
-        return 0;
+        return nullptr;
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeEllipse(CSSParserValueList* args)
 {
     ASSERT(args);
 
     // ellipse(radiusX)
     // ellipse(radiusX at <position>
     // ellipse(radiusX radiusY)
     // ellipse(radiusX radiusY at <position>
     // ellipse(at <position>)
     // where position defines centerX and centerY using a CSS <position> data type.
     RefPtrWillBeRawPtr<CSSBasicShapeEllipse> shape = CSSBasicShapeEllipse::create();
 
     for (CSSParserValue* argument = args->current(); argument; argument = args->next()) {
         // The call to parseFillPosition below should consume all of the
         // arguments except the first three. Thus, an index greater than two
         // indicates an invalid production.
         if (args->currentIndex() > 2)
-            return 0;
+            return nullptr;
 
         if (args->currentIndex() < 2 && argument->id != CSSValueAt) {
             if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
                 if (!shape->radiusX())
                     shape->setRadiusX(radius);
                 else
                     shape->setRadiusY(radius);
                 continue;
             }
 
-            return 0;
+            return nullptr;
         }
 
         if (argument->id != CSSValueAt)
-            return 0;
+            return nullptr;
         RefPtrWillBeRawPtr<CSSValue> centerX;
         RefPtrWillBeRawPtr<CSSValue> centerY;
         args->next(); // set list to start of position center
         parseFillPosition(args, centerX, centerY);
         if (!centerX || !centerY)
-            return 0;
+            return nullptr;
 
         ASSERT(centerX->isPrimitiveValue());
         ASSERT(centerY->isPrimitiveValue());
         shape->setCenterX(toCSSPrimitiveValue(centerX.get()));
         shape->setCenterY(toCSSPrimitiveValue(centerY.get()));
     }
 
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseDeprecatedBasicShapeEllipse(CSSParserValueList* args)
 {
     ASSERT(args);
 
     // ellipse(centerX, centerY, radiusX, radiusY)
     if (args->size() != 7)
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSDeprecatedBasicShapeEllipse> shape = CSSDeprecatedBasicShapeEllipse::create();
     unsigned argumentNumber = 0;
     CSSParserValue* argument = args->current();
     while (argument) {
         Units unitFlags = FLength | FPercent;
         if (argumentNumber > 1) {
             // Arguments radiusX and radiusY cannot be negative.
             unitFlags = unitFlags | FNonNeg;
         }
         if (!validUnit(argument, unitFlags))
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(argument);
         ASSERT(argumentNumber < 4);
         switch (argumentNumber) {
         case 0:
             shape->setCenterX(length);
             break;
         case 1:
             shape->setCenterY(length);
             break;
         case 2:
             shape->setRadiusX(length);
             break;
         case 3:
             shape->setRadiusY(length);
             break;
         }
 
         argument = args->next();
         if (argument) {
             if (!isComma(argument))
-                return 0;
+                return nullptr;
             argument = args->next();
         }
         argumentNumber++;
     }
 
     if (argumentNumber < 4)
-        return 0;
+        return nullptr;
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(CSSParserValueList* args)
 {
     ASSERT(args);
 
     unsigned size = args->size();
     if (!size)
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::create();
 
     CSSParserValue* argument = args->current();
     if (argument->id == CSSValueEvenodd || argument->id == CSSValueNonzero) {
         shape->setWindRule(argument->id == CSSValueEvenodd ? RULE_EVENODD : RULE_NONZERO);
 
         if (!isComma(args->next()))
-            return 0;
+            return nullptr;
 
         argument = args->next();
         size -= 2;
     }
 
     // <length> <length>, ... <length> <length> -> each pair has 3 elements except the last one
     if (!size || (size % 3) - 2)
-        return 0;
+        return nullptr;
 
     CSSParserValue* argumentX = argument;
     while (argumentX) {
         if (!validUnit(argumentX, FLength | FPercent))
-            return 0;
+            return nullptr;
 
         CSSParserValue* argumentY = args->next();
         if (!argumentY || !validUnit(argumentY, FLength | FPercent))
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> xLength = createPrimitiveNumericValue(argumentX);
         RefPtrWillBeRawPtr<CSSPrimitiveValue> yLength = createPrimitiveNumericValue(argumentY);
 
         shape->appendPoint(xLength.release(), yLength.release());
 
         CSSParserValue* commaOrNull = args->next();
         if (!commaOrNull)
             argumentX = 0;
         else if (!isComma(commaOrNull))
-            return 0;
+            return nullptr;
         else
             argumentX = args->next();
     }
 
     return shape;
 }
 
 static bool isBoxValue(CSSValueID valueId)
 {
     switch (valueId) {
@@ skipping 19 matching lines @@
         if (isComma(value))
             return true;
     }
 
     return false;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSPropertyID propId)
 {
     if (!RuntimeEnabledFeatures::cssShapesEnabled())
-        return 0;
+        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;
     if (valueId != CSSValueNone && parseFillImage(m_valueList.get(), imageValue)) {
         m_valueList->next();
         return imageValue.release();
     }
 
     if (value->unit == CSSParserValue::Function) {
         shapeValue = parseBasicShape();
         if (!shapeValue)
-            return 0;
+            return nullptr;
     } else if (isBoxValue(valueId)) {
         boxValue = parseValidPrimitive(valueId, value);
         m_valueList->next();
     } else {
-        return 0;
+        return nullptr;
     }
 
     ASSERT(shapeValue || boxValue);
     value = m_valueList->current();
 
     if (value) {
         valueId = value->id;
         if (boxValue && value->unit == CSSParserValue::Function) {
             shapeValue = parseBasicShape();
             if (!shapeValue)
-                return 0;
+                return nullptr;
         } else if (shapeValue && isBoxValue(valueId)) {
             boxValue = parseValidPrimitive(valueId, value);
             m_valueList->next();
         } else {
-            return 0;
+            return nullptr;
         }
 
         ASSERT(shapeValue && boxValue);
         shapeValue->getShapeValue()->setLayoutBox(boxValue.release());
     }
 
     if (shapeValue)
         return shapeValue.release();
     return boxValue.release();
 }
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseBasicShape()
 {
     CSSParserValue* value = m_valueList->current();
     ASSERT(value->unit == CSSParserValue::Function);
     CSSParserValueList* args = value->function->args.get();
 
     if (!args)
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSBasicShape> shape;
     if (equalIgnoringCase(value->function->name, "rectangle("))
         shape = parseBasicShapeRectangle(args);
     else if (equalIgnoringCase(value->function->name, "circle("))
         if (isDeprecatedBasicShape(args))
             shape = parseDeprecatedBasicShapeCircle(args);
         else
             shape = parseBasicShapeCircle(args);
     else if (equalIgnoringCase(value->function->name, "ellipse("))
         if (isDeprecatedBasicShape(args))
             shape = parseDeprecatedBasicShapeEllipse(args);
         else
             shape = parseBasicShapeEllipse(args);
     else if (equalIgnoringCase(value->function->name, "polygon("))
         shape = parseBasicShapePolygon(args);
     else if (equalIgnoringCase(value->function->name, "inset-rectangle("))
         shape = parseBasicShapeInsetRectangle(args);
     else if (equalIgnoringCase(value->function->name, "inset("))
         shape = parseBasicShapeInset(args);
 
     if (!shape)
-        return 0;
+        return nullptr;
 
     m_valueList->next();
     return cssValuePool().createValue(shape.release());
 }
 
 // [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]? 'font-family'
 bool CSSPropertyParser::parseFont(bool important)
 {
     // Let's check if there is an inherit or initial somewhere in the shorthand.
     for (unsigned i = 0; i < m_valueList->size(); ++i) {
@@ skipping 164 matching lines @@
             inFamily = false;
         }
         else if (nextValIsFontName)
             value = nextValue;
         else
             break;
     }
     familyBuilder.commit();
 
     if (!list->length())
-        list = 0;
+        list = nullptr;
     return list.release();
 }
 
 bool CSSPropertyParser::parseLineHeight(bool important)
 {
     CSSParserValue* value = m_valueList->current();
     CSSValueID id = value->id;
     bool validPrimitive = false;
     // normal | <number> | <length> | <percentage> | inherit
     if (id == CSSValueNormal)
@@ skipping 681 matching lines @@
             return false;
         colorArray[3] = max(0.0, min(1.0, parsedDouble(v, ReleaseParsedCalcValue)));
     }
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseColor(CSSParserValue* value)
 {
     RGBA32 c = Color::transparent;
     if (!parseColorFromValue(value ? value : m_valueList->current(), c))
-        return 0;
+        return nullptr;
     return cssValuePool().createColorValue(c);
 }
 
 bool CSSPropertyParser::parseColorFromValue(CSSParserValue* value, RGBA32& c)
 {
     if (inQuirksMode() && value->unit == CSSPrimitiveValue::CSS_NUMBER
         && value->fValue >= 0. && value->fValue < 1000000.) {
         String str = String::format("%06d", static_cast<int>((value->fValue+.5)));
         // FIXME: This should be strict parsing for SVG as well.
         if (!fastParseColor(c, str, !inQuirksMode()))
@@ skipping 68 matching lines @@
         // Handle the ,, case gracefully by doing nothing.
         if (x || y || blur || spread || color || style) {
             if (!values)
                 values = CSSValueList::createCommaSeparated();
 
             // Construct the current shadow value and add it to the list.
             values->append(CSSShadowValue::create(x.release(), y.release(), blur.release(), spread.release(), style.release(), color.release()));
         }
 
         // Now reset for the next shadow value.
-        x = 0;
-        y = 0;
-        blur = 0;
-        spread = 0;
-        style = 0;
-        color = 0;
+        x = nullptr;
+        y = nullptr;
+        blur = nullptr;
+        spread = nullptr;
+        style = nullptr;
+        color = nullptr;
 
         allowX = true;
         allowColor = true;
         allowBreak = true;
         allowY = false;
         allowBlur = false;
         allowSpread = false;
         allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow;
     }
 
@@ skipping 72 matching lines @@
     bool allowBreak;
 };
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseShadow(CSSParserValueList* valueList, CSSPropertyID propId)
 {
     ShadowParseContext context(propId, this);
     CSSParserValue* val;
     while ((val = valueList->current())) {
         // Check for a comma break first.
         if (val->unit == CSSParserValue::Operator) {
-            if (val->iValue != ',' || !context.allowBreak)
+            if (val->iValue != ',' || !context.allowBreak) {
                 // Other operators aren't legal or we aren't done with the current shadow
                 // value.  Treat as invalid.
-                return 0;
+                return nullptr;
+            }
             // The value is good.  Commit it.
             context.commitValue();
         } else if (validUnit(val, FLength, HTMLStandardMode)) {
             // We required a length and didn't get one. Invalid.
             if (!context.allowLength())
-                return 0;
+                return nullptr;
 
             // Blur radius must be non-negative.
             if (context.allowBlur && !validUnit(val, FLength | FNonNeg, HTMLStandardMode))
-                return 0;
+                return nullptr;
 
             // A length is allowed here.  Construct the value and add it.
             context.commitLength(val);
         } else if (val->id == CSSValueInset) {
             if (!context.allowStyle)
-                return 0;
+                return nullptr;
 
             context.commitStyle(val);
         } else {
             // The only other type of value that's ok is a color value.
             RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedColor;
             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 0;
+                    return nullptr;
                 parsedColor = cssValuePool().createIdentifierValue(val->id);
             }
 
             if (!parsedColor)
                 // It's not built-in. Try to parse it as a color.
                 parsedColor = parseColor(val);
 
             if (!parsedColor || !context.allowColor)
-                return 0; // This value is not a color or length and is invalid or
+                return nullptr; // This value is not a color or length and is invalid or
                           // it is a color, but a color isn't allowed at this point.
 
             context.commitColor(parsedColor.release());
         }
 
         valueList->next();
     }
 
     if (context.allowBreak) {
         context.commitValue();
         if (context.values && context.values->length())
             return context.values.release();
     }
 
-    return 0;
+    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;
     switch (val->id) {
@@ skipping 306 matching lines @@
     }
     return false;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBorderImage(CSSPropertyID propId)
 {
     BorderImageParseContext context;
     if (BorderImageParseContext::buildFromParser(*this, propId, context)) {
         return context.commitCSSValue();
     }
-    return 0;
+    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;
@@ skipping 595 matching lines @@
         a = args->next();
     }
 
     gradient = result.release();
     return true;
 }
 
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueFromSideKeyword(CSSParserValue* a, bool& isHorizontal)
 {
     if (a->unit != CSSPrimitiveValue::CSS_IDENT)
-        return 0;
+        return nullptr;
 
     switch (a->id) {
         case CSSValueLeft:
         case CSSValueRight:
             isHorizontal = true;
             break;
         case CSSValueTop:
         case CSSValueBottom:
             isHorizontal = false;
             break;
         default:
-            return 0;
+            return nullptr;
     }
     return cssValuePool().createIdentifierValue(a->id);
 }
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parseGradientColorOrKeyword(CSSPropertyParser* p, CSSParserValue* value)
 {
     CSSValueID id = value->id;
     if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor)
         return cssValuePool().createIdentifierValue(id);
 
@@ skipping 545 matching lines @@
 
     canvas = CSSCanvasValue::create(value->string);
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseImageSet(CSSParserValueList* valueList)
 {
     CSSParserValue* function = valueList->current();
 
     if (function->unit != CSSParserValue::Function)
-        return 0;
+        return nullptr;
 
     CSSParserValueList* functionArgs = valueList->current()->function->args.get();
     if (!functionArgs || !functionArgs->size() || !functionArgs->current())
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
 
     CSSParserValue* arg = functionArgs->current();
     while (arg) {
         if (arg->unit != CSSPrimitiveValue::CSS_URI)
-            return 0;
+            return nullptr;
 
         RefPtrWillBeRawPtr<CSSImageValue> image = CSSImageValue::create(completeURL(arg->string));
         imageSet->append(image);
 
         arg = functionArgs->next();
         if (!arg || arg->unit != CSSPrimitiveValue::CSS_DIMENSION)
-            return 0;
+            return nullptr;
 
         double imageScaleFactor = 0;
         const String& string = arg->string;
         unsigned length = string.length();
         if (!length)
-            return 0;
+            return nullptr;
         if (string.is8Bit()) {
             const LChar* start = string.characters8();
             parseDouble(start, start + length, 'x', imageScaleFactor);
         } else {
             const UChar* start = string.characters16();
             parseDouble(start, start + length, 'x', imageScaleFactor);
         }
         if (imageScaleFactor <= 0)
-            return 0;
+            return nullptr;
         imageSet->append(cssValuePool().createValue(imageScaleFactor, CSSPrimitiveValue::CSS_NUMBER));
 
         // If there are no more arguments, we're done.
         arg = functionArgs->next();
         if (!arg)
             break;
 
         // If there are more arguments, they should be after a comma.
         if (!isComma(arg))
-            return 0;
+            return nullptr;
 
         // Skip the comma and move on to the next argument.
         arg = functionArgs->next();
     }
 
     return imageSet.release();
 }
 
 bool CSSPropertyParser::parseWillChange(bool important)
 {
@@ skipping 182 matching lines @@
 private:
     CSSTransformValue::TransformOperationType m_type;
     unsigned m_argCount;
     bool m_allowSingleArgument;
     CSSPropertyParser::Units m_unit;
 };
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseTransform()
 {
     if (!m_valueList)
-        return 0;
+        return nullptr;
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         RefPtrWillBeRawPtr<CSSValue> parsedTransformValue = parseTransformValue(value);
         if (!parsedTransformValue)
-            return 0;
+            return nullptr;
 
         list->append(parsedTransformValue.release());
     }
 
     return list.release();
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTransformValue(CSSParserValue *value)
 {
     if (value->unit != CSSParserValue::Function || !value->function)
-        return 0;
+        return nullptr;
 
     // Every primitive requires at least one argument.
     CSSParserValueList* args = value->function->args.get();
     if (!args)
-        return 0;
+        return nullptr;
 
     // See if the specified primitive is one we understand.
     TransformOperationInfo info(value->function->name);
     if (info.unknown())
-        return 0;
+        return nullptr;
 
     if (!info.hasCorrectArgCount(args->size()))
-        return 0;
+        return nullptr;
 
     // The transform is a list of functional primitives that specify transform operations.
     // We collect a list of CSSTransformValues, where each value specifies a single operation.
 
     // Create the new CSSTransformValue for this operation and add it to our list.
     RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(info.type());
 
     // Snag our values.
     CSSParserValue* a = args->current();
     unsigned argNumber = 0;
     while (a) {
         CSSPropertyParser::Units unit = info.unit();
 
         if (info.type() == CSSTransformValue::Rotate3DTransformOperation && argNumber == 3) {
             // 4th param of rotate3d() is an angle rather than a bare number, validate it as such
             if (!validUnit(a, FAngle, HTMLStandardMode))
-                return 0;
+                return nullptr;
         } else if (info.type() == CSSTransformValue::Translate3DTransformOperation && argNumber == 2) {
             // 3rd param of translate3d() cannot be a percentage
             if (!validUnit(a, FLength, HTMLStandardMode))
-                return 0;
+                return nullptr;
         } else if (info.type() == CSSTransformValue::TranslateZTransformOperation && !argNumber) {
             // 1st param of translateZ() cannot be a percentage
             if (!validUnit(a, FLength, HTMLStandardMode))
-                return 0;
+                return nullptr;
         } else if (info.type() == CSSTransformValue::PerspectiveTransformOperation && !argNumber) {
             // 1st param of perspective() must be a non-negative number (deprecated) or length.
             if (!validUnit(a, FNumber | FLength | FNonNeg, HTMLStandardMode))
-                return 0;
-        } else if (!validUnit(a, unit, HTMLStandardMode))
-            return 0;
+                return nullptr;
+        } else if (!validUnit(a, unit, HTMLStandardMode)) {
+            return nullptr;
+        }
 
         // Add the value to the current transform operation.
         transformValue->append(createPrimitiveNumericValue(a));
 
         a = args->next();
         if (!a)
             break;
         if (a->unit != CSSParserValue::Operator || a->iValue != ',')
-            return 0;
+            return nullptr;
         a = args->next();
 
         argNumber++;
     }
 
     return transformValue.release();
 }
 
 bool CSSPropertyParser::isBlendMode(CSSValueID valueID)
 {
@@ skipping 41 matching lines @@
 
     switch (filterType) {
     case CSSFilterValue::GrayscaleFilterOperation:
     case CSSFilterValue::SepiaFilterOperation:
     case CSSFilterValue::SaturateFilterOperation:
     case CSSFilterValue::InvertFilterOperation:
     case CSSFilterValue::OpacityFilterOperation:
     case CSSFilterValue::ContrastFilterOperation: {
         // One optional argument, 0-1 or 0%-100%, if missing use 100%.
         if (args->size() > 1)
-            return 0;
+            return nullptr;
 
         if (args->size()) {
             CSSParserValue* value = args->current();
             if (!validUnit(value, FNumber | FPercent | FNonNeg, HTMLStandardMode))
-                return 0;
+                return nullptr;
 
             double amount = value->fValue;
 
             // Saturate and Contrast allow values over 100%.
             if (filterType != CSSFilterValue::SaturateFilterOperation
                 && filterType != CSSFilterValue::ContrastFilterOperation) {
                 double maxAllowed = value->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 100.0 : 1.0;
                 if (amount > maxAllowed)
-                    return 0;
+                    return nullptr;
             }
 
             filterValue->append(cssValuePool().createValue(amount, static_cast<CSSPrimitiveValue::UnitTypes>(value->unit)));
         }
         break;
     }
     case CSSFilterValue::BrightnessFilterOperation: {
         // One optional argument, if missing use 100%.
         if (args->size() > 1)
-            return 0;
+            return nullptr;
 
         if (args->size()) {
             CSSParserValue* value = args->current();
             if (!validUnit(value, FNumber | FPercent, HTMLStandardMode))
-                return 0;
+                return nullptr;
 
             filterValue->append(cssValuePool().createValue(value->fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value->unit)));
         }
         break;
     }
     case CSSFilterValue::HueRotateFilterOperation: {
         // hue-rotate() takes one optional angle.
         if (args->size() > 1)
-            return 0;
+            return nullptr;
 
         if (args->size()) {
             CSSParserValue* argument = args->current();
             if (!validUnit(argument, FAngle, HTMLStandardMode))
-                return 0;
+                return nullptr;
 
             filterValue->append(createPrimitiveNumericValue(argument));
         }
         break;
     }
     case CSSFilterValue::BlurFilterOperation: {
         // Blur takes a single length. Zero parameters are allowed.
         if (args->size() > 1)
-            return 0;
+            return nullptr;
 
         if (args->size()) {
             CSSParserValue* argument = args->current();
             if (!validUnit(argument, FLength | FNonNeg, HTMLStandardMode))
-                return 0;
+                return nullptr;
 
             filterValue->append(createPrimitiveNumericValue(argument));
         }
         break;
     }
     case CSSFilterValue::DropShadowFilterOperation: {
         // drop-shadow() takes a single shadow.
         RefPtrWillBeRawPtr<CSSValueList> shadowValueList = parseShadow(args, CSSPropertyWebkitFilter);
         if (!shadowValueList || shadowValueList->length() != 1)
-            return 0;
+            return nullptr;
 
         filterValue->append((shadowValueList.release())->itemWithoutBoundsCheck(0));
         break;
     }
     default:
         ASSERT_NOT_REACHED();
     }
     return filterValue.release();
 }
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFilter()
 {
     if (!m_valueList)
-        return 0;
+        return nullptr;
 
     // The filter is a list of functional primitives that specify individual operations.
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->unit != CSSPrimitiveValue::CSS_URI && (value->unit != CSSParserValue::Function || !value->function))
-            return 0;
+            return nullptr;
 
         CSSFilterValue::FilterOperationType filterType = CSSFilterValue::UnknownFilterOperation;
 
         // See if the specified primitive is one we understand.
         if (value->unit == CSSPrimitiveValue::CSS_URI) {
             RefPtrWillBeRawPtr<CSSFilterValue> referenceFilterValue = CSSFilterValue::create(CSSFilterValue::ReferenceFilterOperation);
             list->append(referenceFilterValue);
             referenceFilterValue->append(CSSSVGDocumentValue::create(value->string));
         } else {
             const CSSParserString name = value->function->name;
             unsigned maximumArgumentCount = 1;
 
             filterInfoForName(name, filterType, maximumArgumentCount);
 
             if (filterType == CSSFilterValue::UnknownFilterOperation)
-                return 0;
+                return nullptr;
 
             CSSParserValueList* args = value->function->args.get();
             if (!args)
-                return 0;
+                return nullptr;
 
             RefPtrWillBeRawPtr<CSSFilterValue> filterValue = parseBuiltinFilterArguments(args, filterType);
             if (!filterValue)
-                return 0;
+                return nullptr;
 
             list->append(filterValue);
         }
     }
 
     return list.release();
 }
 
 bool CSSPropertyParser::parseTransformOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, CSSPropertyID& propId3, RefPtrWillBeRawPtr<CSSValue>& value, RefPtrWillBeRawPtr<CSSValue>& value2, RefPtrWillBeRawPtr<CSSValue>& value3)
 {
@@ skipping 252 matching lines @@
     if (m_valueList->size() == 1) {
         CSSParserValue* value = m_valueList->current();
         if (!value->id && validUnit(value, FLength | FPercent)) {
             list->append(createPrimitiveNumericValue(value));
             m_valueList->next();
             return list.release();
         }
     }
 
     if (!RuntimeEnabledFeatures::css3TextEnabled())
-        return 0;
+        return nullptr;
 
     // The case where text-indent has only <length>(or <percentage>) value
     // is handled above if statement even though css3TextEnabled() returns true.
 
     // [ [ <length> | <percentage> ] && each-line ] | inherit
     if (m_valueList->size() != 2)
-        return 0;
+        return nullptr;
 
     CSSParserValue* firstValue = m_valueList->current();
     CSSParserValue* secondValue = m_valueList->next();
     CSSParserValue* lengthOrPercentageValue = 0;
 
     // [ <length> | <percentage> ] each-line
     if (validUnit(firstValue, FLength | FPercent) && secondValue->id == CSSValueEachLine)
         lengthOrPercentageValue = firstValue;
     // each-line [ <length> | <percentage> ]
     else if (firstValue->id == CSSValueEachLine && validUnit(secondValue, FLength | FPercent))
         lengthOrPercentageValue = secondValue;
 
     if (lengthOrPercentageValue) {
         list->append(createPrimitiveNumericValue(lengthOrPercentageValue));
         list->append(cssValuePool().createIdentifierValue(CSSValueEachLine));
         m_valueList->next();
         return list.release();
     }
 
-    return 0;
+    return nullptr;
 }
 
 bool CSSPropertyParser::parseLineBoxContain(bool important)
 {
     LineBoxContain lineBoxContain = LineBoxContainNone;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->id == CSSValueBlock) {
             if (lineBoxContain & LineBoxContainBlock)
                 return false;
@@ skipping 1034 matching lines @@
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 }