Remove -webkit-mask-*.

sky/engine/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 609 matching lines @@
         }
         break;
     }
 
     case CSSPropertyBackgroundAttachment:
     case CSSPropertyBackgroundClip:
     case CSSPropertyWebkitBackgroundClip:
     case CSSPropertyWebkitBackgroundComposite:
     case CSSPropertyBackgroundImage:
     case CSSPropertyBackgroundOrigin:
-    case CSSPropertyMaskSourceType:
     case CSSPropertyWebkitBackgroundOrigin:
     case CSSPropertyBackgroundPosition:
     case CSSPropertyBackgroundPositionX:
     case CSSPropertyBackgroundPositionY:
     case CSSPropertyBackgroundSize:
     case CSSPropertyWebkitBackgroundSize:
     case CSSPropertyBackgroundRepeat:
-    case CSSPropertyWebkitMaskClip:
-    case CSSPropertyWebkitMaskComposite:
-    case CSSPropertyWebkitMaskImage:
-    case CSSPropertyWebkitMaskOrigin:
-    case CSSPropertyWebkitMaskPosition:
-    case CSSPropertyWebkitMaskPositionX:
-    case CSSPropertyWebkitMaskPositionY:
-    case CSSPropertyWebkitMaskSize:
-    case CSSPropertyWebkitMaskRepeat:
-    case CSSPropertyWebkitMaskRepeatX:
-    case CSSPropertyWebkitMaskRepeatY:
     {
         RefPtr<CSSValue> val1 = nullptr;
         RefPtr<CSSValue> val2 = nullptr;
         CSSPropertyID propId1, propId2;
         bool result = false;
         if (parseFillProperty(propId, propId1, propId2, val1, val2)) {
             if (propId == CSSPropertyBackgroundPosition ||
-                propId == CSSPropertyBackgroundRepeat ||
-                propId == CSSPropertyWebkitMaskPosition ||
-                propId == CSSPropertyWebkitMaskRepeat) {
+                propId == CSSPropertyBackgroundRepeat) {
                 ShorthandScope scope(this, propId);
                 addProperty(propId1, val1.release());
                 if (val2)
                     addProperty(propId2, val2.release());
             } else {
                 addProperty(propId1, val1.release());
                 if (val2)
                     addProperty(propId2, val2.release());
             }
             result = true;
         }
         m_implicitShorthand = false;
         return result;
     }
     case CSSPropertyObjectPosition:
         ASSERT(RuntimeEnabledFeatures::objectFitPositionEnabled());
         parsedValue = parseObjectPosition();
         break;
     case CSSPropertyListStyleImage:     // <uri> | none | inherit
     case CSSPropertyBorderImageSource:
-    case CSSPropertyWebkitMaskBoxImageSource:
         if (id == CSSValueNone) {
             parsedValue = cssValuePool().createIdentifierValue(CSSValueNone);
             m_valueList->next();
         } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
             parsedValue = createCSSImageValueWithReferrer(value->string, completeURL(value->string));
             m_valueList->next();
         } else if (isGeneratedImageValue(value)) {
             if (parseGeneratedImage(m_valueList, parsedValue))
                 m_valueList->next();
             else
@@ skipping 146 matching lines @@
         parsedValue = parseFontFaceSrc();
         break;
 
     case CSSPropertyUnicodeRange:
         parsedValue = parseFontFaceUnicodeRange();
         break;
 
     /* CSS3 properties */
 
     case CSSPropertyBorderImage:
-    case CSSPropertyWebkitMaskBoxImage:
         return parseBorderImageShorthand(propId);
     case CSSPropertyWebkitBorderImage: {
         if (RefPtr<CSSValue> result = parseBorderImage(propId)) {
             addProperty(propId, result);
             return true;
         }
         return false;
     }
 
-    case CSSPropertyBorderImageOutset:
-    case CSSPropertyWebkitMaskBoxImageOutset: {
+    case CSSPropertyBorderImageOutset: {
         RefPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageOutset(result)) {
             addProperty(propId, result);
             return true;
         }
         break;
     }
-    case CSSPropertyBorderImageRepeat:
-    case CSSPropertyWebkitMaskBoxImageRepeat: {
+    case CSSPropertyBorderImageRepeat: {
         RefPtr<CSSValue> result = nullptr;
         if (parseBorderImageRepeat(result)) {
             addProperty(propId, result);
             return true;
         }
         break;
     }
-    case CSSPropertyBorderImageSlice:
-    case CSSPropertyWebkitMaskBoxImageSlice: {
+    case CSSPropertyBorderImageSlice: {
         RefPtr<CSSBorderImageSliceValue> result = nullptr;
         if (parseBorderImageSlice(propId, result)) {
             addProperty(propId, result);
             return true;
         }
         break;
     }
-    case CSSPropertyBorderImageWidth:
-    case CSSPropertyWebkitMaskBoxImageWidth: {
+    case CSSPropertyBorderImageWidth: {
         RefPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageWidth(result)) {
             addProperty(propId, result);
             return true;
         }
         break;
     }
     case CSSPropertyBorderTopRightRadius:
     case CSSPropertyBorderTopLeftRadius:
     case CSSPropertyBorderBottomLeftRadius:
@@ skipping 219 matching lines @@
 
         /* shorthand properties */
     case CSSPropertyBackground: {
         // Position must come before color in this array because a plain old "0" is a legal color
         // in quirks mode but it's usually the X coordinate of a position.
         const CSSPropertyID properties[] = { CSSPropertyBackgroundImage, CSSPropertyBackgroundRepeat,
                                    CSSPropertyBackgroundAttachment, CSSPropertyBackgroundPosition, CSSPropertyBackgroundOrigin,
                                    CSSPropertyBackgroundClip, CSSPropertyBackgroundColor, CSSPropertyBackgroundSize };
         return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties));
     }
-    case CSSPropertyWebkitMask: {
-        const CSSPropertyID properties[] = { CSSPropertyWebkitMaskImage, CSSPropertyWebkitMaskRepeat,
-            CSSPropertyWebkitMaskPosition, CSSPropertyWebkitMaskOrigin, CSSPropertyWebkitMaskClip, CSSPropertyWebkitMaskSize };
-        return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties));
-    }
     case CSSPropertyBorder:
         // [ 'border-width' || 'border-style' || <color> ] | inherit
     {
         if (parseShorthand(propId, parsingShorthandForProperty(CSSPropertyBorder))) {
             // The CSS3 Borders and Backgrounds specification says that border also resets border-image. It's as
             // though a value of none was specified for the image.
             addExpandedPropertyForValue(CSSPropertyBorderImage, cssValuePool().createImplicitInitialValue());
             return true;
         }
         return false;
@@ skipping 182 matching lines @@
             // We hit the end.  Fill in all remaining values with the initial value.
             m_valueList->next();
             for (i = 0; i < numProperties; ++i) {
                 if (properties[i] == CSSPropertyBackgroundColor && parsedProperty[i])
                     // Color is not allowed except as the last item in a list for backgrounds.
                     // Reject the entire property.
                     return false;
 
                 if (!parsedProperty[i] && properties[i] != CSSPropertyBackgroundColor) {
                     addFillValue(values[i], cssValuePool().createImplicitInitialValue());
-                    if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
+                    if (properties[i] == CSSPropertyBackgroundPosition)
                         addFillValue(positionYValue, cssValuePool().createImplicitInitialValue());
-                    if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
+                    if (properties[i] == CSSPropertyBackgroundRepeat)
                         addFillValue(repeatYValue, cssValuePool().createImplicitInitialValue());
-                    if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) && !parsedProperty[i]) {
+                    if (properties[i] == CSSPropertyBackgroundOrigin && !parsedProperty[i]) {
                         // If background-origin wasn't present, then reset background-clip also.
                         addFillValue(clipValue, cssValuePool().createImplicitInitialValue());
                     }
                 }
                 parsedProperty[i] = false;
             }
             if (!m_valueList->current())
                 break;
         }
 
         bool sizeCSSPropertyExpected = false;
         if (isForwardSlashOperator(val) && foundPositionCSSProperty) {
             sizeCSSPropertyExpected = true;
             m_valueList->next();
         }
 
         foundPositionCSSProperty = false;
         bool found = false;
         for (i = 0; !found && i < numProperties; ++i) {
 
-            if (sizeCSSPropertyExpected && (properties[i] != CSSPropertyBackgroundSize && properties[i] != CSSPropertyWebkitMaskSize))
+            if (sizeCSSPropertyExpected && properties[i] != CSSPropertyBackgroundSize)
                 continue;
-            if (!sizeCSSPropertyExpected && (properties[i] == CSSPropertyBackgroundSize || properties[i] == CSSPropertyWebkitMaskSize))
+            if (!sizeCSSPropertyExpected && properties[i] == CSSPropertyBackgroundSize)
                 continue;
 
             if (!parsedProperty[i]) {
                 RefPtr<CSSValue> val1 = nullptr;
                 RefPtr<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)
+                    if (properties[i] == CSSPropertyBackgroundPosition)
                         addFillValue(positionYValue, val2.release());
-                    if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
+                    if (properties[i] == CSSPropertyBackgroundRepeat)
                         addFillValue(repeatYValue, val2.release());
-                    if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) {
+                    if (properties[i] == CSSPropertyBackgroundOrigin) {
                         // Reparse the value as a clip, and see if we succeed.
                         if (parseBackgroundClip(parserValue, val1))
                             addFillValue(clipValue, val1.release()); // The property parsed successfully.
                         else
                             addFillValue(clipValue, cssValuePool().createImplicitInitialValue()); // Some value was used for origin that is not supported by clip. Just reset clip instead.
                     }
-                    if (properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) {
+                    if (properties[i] == CSSPropertyBackgroundClip) {
                         // Update clipValue
                         addFillValue(clipValue, val1.release());
                         foundClip = true;
                     }
-                    if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
+                    if (properties[i] == CSSPropertyBackgroundPosition)
                         foundPositionCSSProperty = true;
                 }
             }
         }
 
         // if we didn't find at least one match, this is an
         // invalid shorthand and we have to ignore it
         if (!found) {
             m_implicitShorthand = false;
             return false;
         }
     }
 
     // Now add all of the properties we found.
     for (i = 0; i < numProperties; i++) {
         // Fill in any remaining properties with the initial value.
         if (!parsedProperty[i]) {
             addFillValue(values[i], cssValuePool().createImplicitInitialValue());
-            if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
+            if (properties[i] == CSSPropertyBackgroundPosition)
                 addFillValue(positionYValue, cssValuePool().createImplicitInitialValue());
-            if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
+            if (properties[i] == CSSPropertyBackgroundRepeat)
                 addFillValue(repeatYValue, cssValuePool().createImplicitInitialValue());
-            if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) {
+            if (properties[i] == CSSPropertyBackgroundOrigin) {
                 // If background-origin wasn't present, then reset background-clip also.
                 addFillValue(clipValue, cssValuePool().createImplicitInitialValue());
             }
         }
         if (properties[i] == CSSPropertyBackgroundPosition) {
             addProperty(CSSPropertyBackgroundPositionX, values[i].release());
             // it's OK to call positionYValue.release() since we only see CSSPropertyBackgroundPosition once
             addProperty(CSSPropertyBackgroundPositionY, positionYValue.release());
-        } else if (properties[i] == CSSPropertyWebkitMaskPosition) {
-            addProperty(CSSPropertyWebkitMaskPositionX, values[i].release());
-            // it's OK to call positionYValue.release() since we only see CSSPropertyWebkitMaskPosition once
-            addProperty(CSSPropertyWebkitMaskPositionY, positionYValue.release());
         } else if (properties[i] == CSSPropertyBackgroundRepeat) {
             addProperty(CSSPropertyBackgroundRepeatX, values[i].release());
             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
             addProperty(CSSPropertyBackgroundRepeatY, repeatYValue.release());
-        } else if (properties[i] == CSSPropertyWebkitMaskRepeat) {
-            addProperty(CSSPropertyWebkitMaskRepeatX, values[i].release());
-            // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
-            addProperty(CSSPropertyWebkitMaskRepeatY, repeatYValue.release());
-        } else if ((properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) && !foundClip)
+        } else if (properties[i] == CSSPropertyBackgroundClip && !foundClip)
             // Value is already set while updating origin
             continue;
         else
             addProperty(properties[i], values[i].release());
 
         // Add in clip values when we hit the corresponding origin property.
         if (properties[i] == CSSPropertyBackgroundOrigin && !foundClip)
             addProperty(CSSPropertyBackgroundClip, clipValue.release());
-        else if (properties[i] == CSSPropertyWebkitMaskOrigin && !foundClip)
-            addProperty(CSSPropertyWebkitMaskClip, clipValue.release());
     }
 
     m_implicitShorthand = false;
     return true;
 }
 
 static bool isValidTransitionPropertyList(CSSValueList* value)
 {
     if (value->length() < 2)
         return true;
@@ skipping 834 matching lines @@
     RefPtr<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;
     }
 
     for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->current()) {
         RefPtr<CSSValue> currValue = nullptr;
         RefPtr<CSSValue> currValue2 = nullptr;
 
         if (allowComma) {
             if (!isComma(val))
                 return false;
             m_valueList->next();
             allowComma = false;
         } else {
             allowComma = true;
             switch (propId) {
                 case CSSPropertyBackgroundColor:
                     currValue = parseBackgroundColor();
                     if (currValue)
                         m_valueList->next();
                     break;
                 case CSSPropertyBackgroundAttachment:
                     if (val->id == CSSValueFixed || val->id == CSSValueLocal) {
                         currValue = cssValuePool().createIdentifierValue(val->id);
                         m_valueList->next();
                     }
                     break;
                 case CSSPropertyBackgroundImage:
-                case CSSPropertyWebkitMaskImage:
                     if (parseFillImage(m_valueList, currValue))
                         m_valueList->next();
                     break;
                 case CSSPropertyWebkitBackgroundClip:
                 case CSSPropertyWebkitBackgroundOrigin:
-                case CSSPropertyWebkitMaskClip:
-                case CSSPropertyWebkitMaskOrigin:
                     // The first three values here are deprecated and do not apply to the version of the property that has
                     // the -webkit- prefix removed.
                     if (val->id == CSSValueBorder || val->id == CSSValuePadding || val->id == CSSValueContent ||
                         val->id == CSSValueBorderBox || val->id == CSSValuePaddingBox || val->id == CSSValueContentBox ||
-                        ((propId == CSSPropertyWebkitBackgroundClip || propId == CSSPropertyWebkitMaskClip) &&
+                        (propId == CSSPropertyWebkitBackgroundClip &&
                          (val->id == CSSValueText))) {
                         currValue = cssValuePool().createIdentifierValue(val->id);
                         m_valueList->next();
                     }
                     break;
                 case CSSPropertyBackgroundClip:
                     if (parseBackgroundClip(val, currValue))
                         m_valueList->next();
                     break;
                 case CSSPropertyBackgroundOrigin:
                     if (val->id == CSSValueBorderBox || val->id == CSSValuePaddingBox || val->id == CSSValueContentBox) {
                         currValue = cssValuePool().createIdentifierValue(val->id);
                         m_valueList->next();
                     }
                     break;
                 case CSSPropertyBackgroundPosition:
-                case CSSPropertyWebkitMaskPosition:
                     parseFillPosition(m_valueList, currValue, currValue2);
                     // parseFillPosition advances the m_valueList pointer.
                     break;
-                case CSSPropertyBackgroundPositionX:
-                case CSSPropertyWebkitMaskPositionX: {
+                case CSSPropertyBackgroundPositionX: {
                     currValue = parseFillPositionX(m_valueList);
                     if (currValue)
                         m_valueList->next();
                     break;
                 }
-                case CSSPropertyBackgroundPositionY:
-                case CSSPropertyWebkitMaskPositionY: {
+                case CSSPropertyBackgroundPositionY: {
                     currValue = parseFillPositionY(m_valueList);
                     if (currValue)
                         m_valueList->next();
                     break;
                 }
                 case CSSPropertyWebkitBackgroundComposite:
-                case CSSPropertyWebkitMaskComposite:
                     if (val->id >= CSSValueClear && val->id <= CSSValuePlusLighter) {
                         currValue = cssValuePool().createIdentifierValue(val->id);
                         m_valueList->next();
                     }
                     break;
                 case CSSPropertyBackgroundRepeat:
-                case CSSPropertyWebkitMaskRepeat:
                     parseFillRepeat(currValue, currValue2);
                     // parseFillRepeat advances the m_valueList pointer
                     break;
                 case CSSPropertyBackgroundSize:
-                case CSSPropertyWebkitBackgroundSize:
-                case CSSPropertyWebkitMaskSize: {
+                case CSSPropertyWebkitBackgroundSize: {
                     currValue = parseFillSize(propId, allowComma);
                     if (currValue)
                         m_valueList->next();
                     break;
                 }
-                case CSSPropertyMaskSourceType: {
-                    ASSERT(RuntimeEnabledFeatures::cssMaskSourceTypeEnabled());
-                    if (val->id == CSSValueAuto || val->id == CSSValueAlpha || val->id == CSSValueLuminance) {
-                        currValue = cssValuePool().createIdentifierValue(val->id);
-                        m_valueList->next();
-                    } else {
-                        currValue = nullptr;
-                    }
-                    break;
-                }
                 default:
                     break;
             }
             if (!currValue)
                 return false;
 
             if (value && !values) {
                 values = CSSValueList::createCommaSeparated();
                 values->append(value.release());
             }
@@ skipping 2035 matching lines @@
         m_allowRepeat = m_allowForwardSlashOperator = m_requireWidth = m_requireOutset = false;
         m_allowImageSlice = !m_imageSlice;
         m_allowImage = !m_image;
     }
 
     PassRefPtr<CSSValue> commitCSSValue()
     {
         return createBorderImageValue(m_image, m_imageSlice.get(), m_borderWidth.get(), m_outset.get(), m_repeat.get());
     }
 
-    void commitMaskBoxImage(CSSPropertyParser* parser)
-    {
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSource, parser, m_image);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSlice, parser, m_imageSlice.get());
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageWidth, parser, m_borderWidth.get());
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageOutset, parser, m_outset.get());
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageRepeat, parser, m_repeat.get());
-    }
-
     void commitBorderImage(CSSPropertyParser* parser)
     {
         commitBorderImageProperty(CSSPropertyBorderImageSource, parser, m_image);
         commitBorderImageProperty(CSSPropertyBorderImageSlice, parser, m_imageSlice.get());
         commitBorderImageProperty(CSSPropertyBorderImageWidth, parser, m_borderWidth.get());
         commitBorderImageProperty(CSSPropertyBorderImageOutset, parser, m_outset.get());
         commitBorderImageProperty(CSSPropertyBorderImageRepeat, parser, m_repeat);
     }
 
     void commitBorderImageProperty(CSSPropertyID propId, CSSPropertyParser* parser, PassRefPtr<CSSValue> value)
@@ skipping 83 matching lines @@
         parser.m_valueList->next();
     }
 
     return context.allowCommit();
 }
 
 bool CSSPropertyParser::parseBorderImageShorthand(CSSPropertyID propId)
 {
     BorderImageParseContext context;
     if (BorderImageParseContext::buildFromParser(*this, propId, context)) {
-        switch (propId) {
-        case CSSPropertyWebkitMaskBoxImage:
-            context.commitMaskBoxImage(this);
-            return true;
-        case CSSPropertyBorderImage:
-            context.commitBorderImage(this);
-            return true;
-        default:
-            ASSERT_NOT_REACHED();
-            return false;
-        }
+        ASSERT(propId == CSSPropertyBorderImage);
+        context.commitBorderImage(this);
+        return true;
     }
     return false;
 }
 
 PassRefPtr<CSSValue> CSSPropertyParser::parseBorderImage(CSSPropertyID propId)
 {
     BorderImageParseContext context;
     if (BorderImageParseContext::buildFromParser(*this, propId, context)) {
         return context.commitCSSValue();
     }
@@ skipping 132 matching lines @@
                 // We're going to successfully parse, but we don't want to consume this token.
                 m_valueList->previous();
             }
             break;
         }
     }
 
     if (context.allowFinalCommit()) {
         // FIXME: For backwards compatibility, -webkit-border-image, -webkit-mask-box-image and -webkit-box-reflect have to do a fill by default.
         // FIXME: What do we do with -webkit-box-reflect and -webkit-mask-box-image? Probably just have to leave them filling...
-        if (propId == CSSPropertyWebkitBorderImage || propId == CSSPropertyWebkitMaskBoxImage)
+        if (propId == CSSPropertyWebkitBorderImage)
             context.commitFill();
 
         // Need to fully commit as a single value.
         result = context.commitBorderImageSlice();
         return true;
     }
 
     return false;
 }
 
@@ skipping 1359 matching lines @@
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 bool CSSPropertyParser::isSystemColor(int id)
 {
     // FIXME(sky): remove
     return false;
 }
 
 } // namespace blink