Cleanup WebKit prefixed names for classes in css directory.

Source/core/css/CSSParser.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 24 matching lines @@
 #include "core/css/CSSCanvasValue.h"
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSCursorImageValue.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSGradientValue.h"
 #include "core/css/CSSImageSetValue.h"
 #include "core/css/CSSImageValue.h"
 #include "core/css/CSSInheritedValue.h"
 #include "core/css/CSSInitialValue.h"
 #include "core/css/CSSLineBoxContainValue.h"
+#include "core/css/CSSMixFunctionValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSPropertySourceData.h"
 #include "core/css/CSSReflectValue.h"
+#include "core/css/CSSSVGDocumentValue.h"
 #include "core/css/CSSSelector.h"
+#include "core/css/CSSShaderValue.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/CSSTimingFunctionValue.h"
+#include "core/css/CSSTransformValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/CSSVariableValue.h"
 #include "core/css/Counter.h"
 #include "core/css/FontFeatureValue.h"
 #include "core/css/MediaList.h"
 #include "core/css/MediaQueryExp.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/ShadowValue.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StylePropertyShorthand.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/WebKitCSSArrayFunctionValue.h"
 #include "core/css/WebKitCSSFilterValue.h"
 #include "core/css/WebKitCSSKeyframeRule.h"
 #include "core/css/WebKitCSSKeyframesRule.h"
-#include "core/css/WebKitCSSMixFunctionValue.h"
-#include "core/css/WebKitCSSSVGDocumentValue.h"
-#include "core/css/WebKitCSSShaderValue.h"
-#include "core/css/WebKitCSSTransformValue.h"
 #include "core/dom/Document.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/page/Page.h"
 #include "core/page/PageConsole.h"
 #include "core/page/Settings.h"
 #include "core/platform/FloatConversion.h"
 #include "core/platform/HashTools.h"
 #include "core/platform/HistogramSupport.h"
 #include "core/rendering/RenderTheme.h"
@@ skipping 999 matching lines @@
     else if (isValidKeywordPropertyAndValue(propertyId, valueID, parserContext))
         value = cssValuePool().createIdentifierValue(valueID);
     else
         return false;
 
     declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
     return true;
 }
 
 template <typename CharacterType>
-static bool parseTransformArguments(WebKitCSSTransformValue* transformValue, CharacterType* characters, unsigned length, unsigned start, unsigned expectedCount)
+static bool parseTransformArguments(CSSTransformValue* transformValue, CharacterType* characters, unsigned length, unsigned start, unsigned expectedCount)
 {
     while (expectedCount) {
         size_t end = WTF::find(characters, length, expectedCount == 1 ? ')' : ',', start);
         if (end == notFound || (expectedCount == 1 && end != length - 1))
             return false;
         unsigned argumentLength = end - start;
         CSSPrimitiveValue::UnitTypes unit = CSSPrimitiveValue::CSS_NUMBER;
         double number;
         if (!parseSimpleLength(characters + start, argumentLength, unit, number))
             return false;
@@ skipping 12 matching lines @@
         return false;
     static const unsigned shortestValidTransformStringLength = 12;
     static const unsigned likelyMultipartTransformStringLengthCutoff = 32;
     if (string.length() < shortestValidTransformStringLength || string.length() > likelyMultipartTransformStringLengthCutoff)
         return false;
     if (!string.startsWith("translate", false))
         return false;
     UChar c9 = toASCIILower(string[9]);
     UChar c10 = toASCIILower(string[10]);
 
-    WebKitCSSTransformValue::TransformOperationType transformType;
+    CSSTransformValue::TransformOperationType transformType;
     unsigned expectedArgumentCount = 1;
     unsigned argumentStart = 11;
     if (c9 == 'x' && c10 == '(')
-        transformType = WebKitCSSTransformValue::TranslateXTransformOperation;
+        transformType = CSSTransformValue::TranslateXTransformOperation;
     else if (c9 == 'y' && c10 == '(')
-        transformType = WebKitCSSTransformValue::TranslateYTransformOperation;
+        transformType = CSSTransformValue::TranslateYTransformOperation;
     else if (c9 == 'z' && c10 == '(')
-        transformType = WebKitCSSTransformValue::TranslateZTransformOperation;
+        transformType = CSSTransformValue::TranslateZTransformOperation;
     else if (c9 == '(') {
-        transformType = WebKitCSSTransformValue::TranslateTransformOperation;
+        transformType = CSSTransformValue::TranslateTransformOperation;
         expectedArgumentCount = 2;
         argumentStart = 10;
     } else if (c9 == '3' && c10 == 'd' && string[11] == '(') {
-        transformType = WebKitCSSTransformValue::Translate3DTransformOperation;
+        transformType = CSSTransformValue::Translate3DTransformOperation;
         expectedArgumentCount = 3;
         argumentStart = 12;
     } else
         return false;
 
-    RefPtr<WebKitCSSTransformValue> transformValue = WebKitCSSTransformValue::create(transformType);
+    RefPtr<CSSTransformValue> transformValue = CSSTransformValue::create(transformType);
     bool success;
     if (string.is8Bit())
         success = parseTransformArguments(transformValue.get(), string.characters8(), string.length(), argumentStart, expectedArgumentCount);
     else
         success = parseTransformArguments(transformValue.get(), string.characters16(), string.length(), argumentStart, expectedArgumentCount);
     if (!success)
         return false;
     RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
     result->append(transformValue.release());
     properties->addParsedProperty(CSSProperty(CSSPropertyWebkitTransform, result.release(), important));
@@ skipping 6506 matching lines @@
         // Skip the comma and move on to the next argument.
         arg = functionArgs->next();
     }
 
     return imageSet.release();
 }
 
 class TransformOperationInfo {
 public:
     TransformOperationInfo(const CSSParserString& name)
-        : m_type(WebKitCSSTransformValue::UnknownTransformOperation)
+        : m_type(CSSTransformValue::UnknownTransformOperation)
         , m_argCount(1)
         , m_allowSingleArgument(false)
         , m_unit(CSSParser::FUnknown)
     {
         const UChar* characters;
         unsigned nameLength = name.length();
 
         const unsigned longestNameLength = 12;
         UChar characterBuffer[longestNameLength];
         if (name.is8Bit()) {
             unsigned length = std::min(longestNameLength, nameLength);
             const LChar* characters8 = name.characters8();
             for (unsigned i = 0; i < length; ++i)
                 characterBuffer[i] = characters8[i];
             characters = characterBuffer;
         } else
             characters = name.characters16();
 
         switch (nameLength) {
         case 5:
             // Valid name: skew(.
             if (((characters[0] == 's') || (characters[0] == 'S'))
                 & ((characters[1] == 'k') || (characters[1] == 'K'))
                 & ((characters[2] == 'e') || (characters[2] == 'E'))
                 & ((characters[3] == 'w') || (characters[3] == 'W'))
                 & (characters[4] == '(')) {
                 m_unit = CSSParser::FAngle;
-                m_type = WebKitCSSTransformValue::SkewTransformOperation;
+                m_type = CSSTransformValue::SkewTransformOperation;
                 m_allowSingleArgument = true;
                 m_argCount = 3;
             }
             break;
         case 6:
             // Valid names: skewx(, skewy(, scale(.
             if ((characters[1] == 'c') || (characters[1] == 'C')) {
                 if (((characters[0] == 's') || (characters[0] == 'S'))
                     & ((characters[2] == 'a') || (characters[2] == 'A'))
                     & ((characters[3] == 'l') || (characters[3] == 'L'))
                     & ((characters[4] == 'e') || (characters[4] == 'E'))
                     & (characters[5] == '(')) {
                     m_unit = CSSParser::FNumber;
-                    m_type = WebKitCSSTransformValue::ScaleTransformOperation;
+                    m_type = CSSTransformValue::ScaleTransformOperation;
                     m_allowSingleArgument = true;
                     m_argCount = 3;
                 }
             } else if (((characters[0] == 's') || (characters[0] == 'S'))
                        & ((characters[1] == 'k') || (characters[1] == 'K'))
                        & ((characters[2] == 'e') || (characters[2] == 'E'))
                        & ((characters[3] == 'w') || (characters[3] == 'W'))
                        & (characters[5] == '(')) {
                 if ((characters[4] == 'x') || (characters[4] == 'X')) {
                     m_unit = CSSParser::FAngle;
-                    m_type = WebKitCSSTransformValue::SkewXTransformOperation;
+                    m_type = CSSTransformValue::SkewXTransformOperation;
                 } else if ((characters[4] == 'y') || (characters[4] == 'Y')) {
                     m_unit = CSSParser::FAngle;
-                    m_type = WebKitCSSTransformValue::SkewYTransformOperation;
+                    m_type = CSSTransformValue::SkewYTransformOperation;
                 }
             }
             break;
         case 7:
             // Valid names: matrix(, rotate(, scalex(, scaley(, scalez(.
             if ((characters[0] == 'm') || (characters[0] == 'M')) {
                 if (((characters[1] == 'a') || (characters[1] == 'A'))
                     & ((characters[2] == 't') || (characters[2] == 'T'))
                     & ((characters[3] == 'r') || (characters[3] == 'R'))
                     & ((characters[4] == 'i') || (characters[4] == 'I'))
                     & ((characters[5] == 'x') || (characters[5] == 'X'))
                     & (characters[6] == '(')) {
                     m_unit = CSSParser::FNumber;
-                    m_type = WebKitCSSTransformValue::MatrixTransformOperation;
+                    m_type = CSSTransformValue::MatrixTransformOperation;
                     m_argCount = 11;
                 }
             } else if ((characters[0] == 'r') || (characters[0] == 'R')) {
                 if (((characters[1] == 'o') || (characters[1] == 'O'))
                     & ((characters[2] == 't') || (characters[2] == 'T'))
                     & ((characters[3] == 'a') || (characters[3] == 'A'))
                     & ((characters[4] == 't') || (characters[4] == 'T'))
                     & ((characters[5] == 'e') || (characters[5] == 'E'))
                     & (characters[6] == '(')) {
                     m_unit = CSSParser::FAngle;
-                    m_type = WebKitCSSTransformValue::RotateTransformOperation;
+                    m_type = CSSTransformValue::RotateTransformOperation;
                 }
             } else if (((characters[0] == 's') || (characters[0] == 'S'))
                        & ((characters[1] == 'c') || (characters[1] == 'C'))
                        & ((characters[2] == 'a') || (characters[2] == 'A'))
                        & ((characters[3] == 'l') || (characters[3] == 'L'))
                        & ((characters[4] == 'e') || (characters[4] == 'E'))
                        & (characters[6] == '(')) {
                 if ((characters[5] == 'x') || (characters[5] == 'X')) {
                     m_unit = CSSParser::FNumber;
-                    m_type = WebKitCSSTransformValue::ScaleXTransformOperation;
+                    m_type = CSSTransformValue::ScaleXTransformOperation;
                 } else if ((characters[5] == 'y') || (characters[5] == 'Y')) {
                     m_unit = CSSParser::FNumber;
-                    m_type = WebKitCSSTransformValue::ScaleYTransformOperation;
+                    m_type = CSSTransformValue::ScaleYTransformOperation;
                 } else if ((characters[5] == 'z') || (characters[5] == 'Z')) {
                     m_unit = CSSParser::FNumber;
-                    m_type = WebKitCSSTransformValue::ScaleZTransformOperation;
+                    m_type = CSSTransformValue::ScaleZTransformOperation;
                 }
             }
             break;
         case 8:
             // Valid names: rotatex(, rotatey(, rotatez(, scale3d(.
             if ((characters[0] == 's') || (characters[0] == 'S')) {
                 if (((characters[1] == 'c') || (characters[1] == 'C'))
                     & ((characters[2] == 'a') || (characters[2] == 'A'))
                     & ((characters[3] == 'l') || (characters[3] == 'L'))
                     & ((characters[4] == 'e') || (characters[4] == 'E'))
                     & (characters[5] == '3')
                     & ((characters[6] == 'd') || (characters[6] == 'D'))
                     & (characters[7] == '(')) {
                     m_unit = CSSParser::FNumber;
-                    m_type = WebKitCSSTransformValue::Scale3DTransformOperation;
+                    m_type = CSSTransformValue::Scale3DTransformOperation;
                     m_argCount = 5;
                 }
             } else if (((characters[0] == 'r') || (characters[0] == 'R'))
                        & ((characters[1] == 'o') || (characters[1] == 'O'))
                        & ((characters[2] == 't') || (characters[2] == 'T'))
                        & ((characters[3] == 'a') || (characters[3] == 'A'))
                        & ((characters[4] == 't') || (characters[4] == 'T'))
                        & ((characters[5] == 'e') || (characters[5] == 'E'))
                        & (characters[7] == '(')) {
                 if ((characters[6] == 'x') || (characters[6] == 'X')) {
                     m_unit = CSSParser::FAngle;
-                    m_type = WebKitCSSTransformValue::RotateXTransformOperation;
+                    m_type = CSSTransformValue::RotateXTransformOperation;
                 } else if ((characters[6] == 'y') || (characters[6] == 'Y')) {
                     m_unit = CSSParser::FAngle;
-                    m_type = WebKitCSSTransformValue::RotateYTransformOperation;
+                    m_type = CSSTransformValue::RotateYTransformOperation;
                 } else if ((characters[6] == 'z') || (characters[6] == 'Z')) {
                     m_unit = CSSParser::FAngle;
-                    m_type = WebKitCSSTransformValue::RotateZTransformOperation;
+                    m_type = CSSTransformValue::RotateZTransformOperation;
                 }
             }
             break;
         case 9:
             // Valid names: matrix3d(, rotate3d(.
             if ((characters[0] == 'm') || (characters[0] == 'M')) {
                 if (((characters[1] == 'a') || (characters[1] == 'A'))
                     & ((characters[2] == 't') || (characters[2] == 'T'))
                     & ((characters[3] == 'r') || (characters[3] == 'R'))
                     & ((characters[4] == 'i') || (characters[4] == 'I'))
                     & ((characters[5] == 'x') || (characters[5] == 'X'))
                     & (characters[6] == '3')
                     & ((characters[7] == 'd') || (characters[7] == 'D'))
                     & (characters[8] == '(')) {
                     m_unit = CSSParser::FNumber;
-                    m_type = WebKitCSSTransformValue::Matrix3DTransformOperation;
+                    m_type = CSSTransformValue::Matrix3DTransformOperation;
                     m_argCount = 31;
                 }
             } else if (((characters[0] == 'r') || (characters[0] == 'R'))
                        & ((characters[1] == 'o') || (characters[1] == 'O'))
                        & ((characters[2] == 't') || (characters[2] == 'T'))
                        & ((characters[3] == 'a') || (characters[3] == 'A'))
                        & ((characters[4] == 't') || (characters[4] == 'T'))
                        & ((characters[5] == 'e') || (characters[5] == 'E'))
                        & (characters[6] == '3')
                        & ((characters[7] == 'd') || (characters[7] == 'D'))
                        & (characters[8] == '(')) {
                 m_unit = CSSParser::FNumber;
-                m_type = WebKitCSSTransformValue::Rotate3DTransformOperation;
+                m_type = CSSTransformValue::Rotate3DTransformOperation;
                 m_argCount = 7;
             }
             break;
         case 10:
             // Valid name: translate(.
             if (((characters[0] == 't') || (characters[0] == 'T'))
                 & ((characters[1] == 'r') || (characters[1] == 'R'))
                 & ((characters[2] == 'a') || (characters[2] == 'A'))
                 & ((characters[3] == 'n') || (characters[3] == 'N'))
                 & ((characters[4] == 's') || (characters[4] == 'S'))
                 & ((characters[5] == 'l') || (characters[5] == 'L'))
                 & ((characters[6] == 'a') || (characters[6] == 'A'))
                 & ((characters[7] == 't') || (characters[7] == 'T'))
                 & ((characters[8] == 'e') || (characters[8] == 'E'))
                 & (characters[9] == '(')) {
                 m_unit = CSSParser::FLength | CSSParser::FPercent;
-                m_type = WebKitCSSTransformValue::TranslateTransformOperation;
+                m_type = CSSTransformValue::TranslateTransformOperation;
                 m_allowSingleArgument = true;
                 m_argCount = 3;
             }
             break;
         case 11:
             // Valid names: translatex(, translatey(, translatez(.
             if (((characters[0] == 't') || (characters[0] == 'T'))
                 & ((characters[1] == 'r') || (characters[1] == 'R'))
                 & ((characters[2] == 'a') || (characters[2] == 'A'))
                 & ((characters[3] == 'n') || (characters[3] == 'N'))
                 & ((characters[4] == 's') || (characters[4] == 'S'))
                 & ((characters[5] == 'l') || (characters[5] == 'L'))
                 & ((characters[6] == 'a') || (characters[6] == 'A'))
                 & ((characters[7] == 't') || (characters[7] == 'T'))
                 & ((characters[8] == 'e') || (characters[8] == 'E'))
                 & (characters[10] == '(')) {
                 if ((characters[9] == 'x') || (characters[9] == 'X')) {
                     m_unit = CSSParser::FLength | CSSParser::FPercent;
-                    m_type = WebKitCSSTransformValue::TranslateXTransformOperation;
+                    m_type = CSSTransformValue::TranslateXTransformOperation;
                 } else if ((characters[9] == 'y') || (characters[9] == 'Y')) {
                     m_unit = CSSParser::FLength | CSSParser::FPercent;
-                    m_type = WebKitCSSTransformValue::TranslateYTransformOperation;
+                    m_type = CSSTransformValue::TranslateYTransformOperation;
                 } else if ((characters[9] == 'z') || (characters[9] == 'Z')) {
                     m_unit = CSSParser::FLength | CSSParser::FPercent;
-                    m_type = WebKitCSSTransformValue::TranslateZTransformOperation;
+                    m_type = CSSTransformValue::TranslateZTransformOperation;
                 }
             }
             break;
         case 12:
             // Valid names: perspective(, translate3d(.
             if ((characters[0] == 'p') || (characters[0] == 'P')) {
                 if (((characters[1] == 'e') || (characters[1] == 'E'))
                     & ((characters[2] == 'r') || (characters[2] == 'R'))
                     & ((characters[3] == 's') || (characters[3] == 'S'))
                     & ((characters[4] == 'p') || (characters[4] == 'P'))
                     & ((characters[5] == 'e') || (characters[5] == 'E'))
                     & ((characters[6] == 'c') || (characters[6] == 'C'))
                     & ((characters[7] == 't') || (characters[7] == 'T'))
                     & ((characters[8] == 'i') || (characters[8] == 'I'))
                     & ((characters[9] == 'v') || (characters[9] == 'V'))
                     & ((characters[10] == 'e') || (characters[10] == 'E'))
                     & (characters[11] == '(')) {
                     m_unit = CSSParser::FNumber;
-                    m_type = WebKitCSSTransformValue::PerspectiveTransformOperation;
+                    m_type = CSSTransformValue::PerspectiveTransformOperation;
                 }
             } else if (((characters[0] == 't') || (characters[0] == 'T'))
                        & ((characters[1] == 'r') || (characters[1] == 'R'))
                        & ((characters[2] == 'a') || (characters[2] == 'A'))
                        & ((characters[3] == 'n') || (characters[3] == 'N'))
                        & ((characters[4] == 's') || (characters[4] == 'S'))
                        & ((characters[5] == 'l') || (characters[5] == 'L'))
                        & ((characters[6] == 'a') || (characters[6] == 'A'))
                        & ((characters[7] == 't') || (characters[7] == 'T'))
                        & ((characters[8] == 'e') || (characters[8] == 'E'))
                        & (characters[9] == '3')
                        & ((characters[10] == 'd') || (characters[10] == 'D'))
                        & (characters[11] == '(')) {
                 m_unit = CSSParser::FLength | CSSParser::FPercent;
-                m_type = WebKitCSSTransformValue::Translate3DTransformOperation;
+                m_type = CSSTransformValue::Translate3DTransformOperation;
                 m_argCount = 5;
             }
             break;
         } // end switch ()
     }
 
-    WebKitCSSTransformValue::TransformOperationType type() const { return m_type; }
+    CSSTransformValue::TransformOperationType type() const { return m_type; }
     unsigned argCount() const { return m_argCount; }
     CSSParser::Units unit() const { return m_unit; }
 
-    bool unknown() const { return m_type == WebKitCSSTransformValue::UnknownTransformOperation; }
+    bool unknown() const { return m_type == CSSTransformValue::UnknownTransformOperation; }
     bool hasCorrectArgCount(unsigned argCount) { return m_argCount == argCount || (m_allowSingleArgument && argCount == 1); }
 
 private:
-    WebKitCSSTransformValue::TransformOperationType m_type;
+    CSSTransformValue::TransformOperationType m_type;
     unsigned m_argCount;
     bool m_allowSingleArgument;
     CSSParser::Units m_unit;
 };
 
 PassRefPtr<CSSValueList> CSSParser::parseTransform()
 {
     if (!m_valueList)
         return 0;
 
@@ skipping 21 matching lines @@
 
     // See if the specified primitive is one we understand.
     TransformOperationInfo info(value->function->name);
     if (info.unknown())
         return 0;
 
     if (!info.hasCorrectArgCount(args->size()))
         return 0;
 
     // The transform is a list of functional primitives that specify transform operations.
-    // We collect a list of WebKitCSSTransformValues, where each value specifies a single operation.
+    // We collect a list of CSSTransformValues, where each value specifies a single operation.
 
-    // Create the new WebKitCSSTransformValue for this operation and add it to our list.
-    RefPtr<WebKitCSSTransformValue> transformValue = WebKitCSSTransformValue::create(info.type());
+    // Create the new CSSTransformValue for this operation and add it to our list.
+    RefPtr<CSSTransformValue> transformValue = CSSTransformValue::create(info.type());
 
     // Snag our values.
     CSSParserValue* a = args->current();
     unsigned argNumber = 0;
     while (a) {
         CSSParser::Units unit = info.unit();
 
-        if (info.type() == WebKitCSSTransformValue::Rotate3DTransformOperation && argNumber == 3) {
+        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, CSSStrictMode))
                 return 0;
-        } else if (info.type() == WebKitCSSTransformValue::Translate3DTransformOperation && argNumber == 2) {
+        } else if (info.type() == CSSTransformValue::Translate3DTransformOperation && argNumber == 2) {
             // 3rd param of translate3d() cannot be a percentage
             if (!validUnit(a, FLength, CSSStrictMode))
                 return 0;
-        } else if (info.type() == WebKitCSSTransformValue::TranslateZTransformOperation && !argNumber) {
+        } else if (info.type() == CSSTransformValue::TranslateZTransformOperation && !argNumber) {
             // 1st param of translateZ() cannot be a percentage
             if (!validUnit(a, FLength, CSSStrictMode))
                 return 0;
-        } else if (info.type() == WebKitCSSTransformValue::PerspectiveTransformOperation && !argNumber) {
+        } 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, CSSStrictMode))
                 return 0;
         } else if (!validUnit(a, unit, CSSStrictMode))
             return 0;
 
         // Add the value to the current transform operation.
         transformValue->append(createPrimitiveNumericValue(a));
 
         a = args->next();
@@ skipping 88 matching lines @@
 
         if (!isComma(nextParserValue))
             return 0;
 
         arrayArgsParserValueList->next();
     }
 
     return arrayFunction;
 }
 
-PassRefPtr<WebKitCSSMixFunctionValue> CSSParser::parseMixFunction(CSSParserValue* value)
+PassRefPtr<CSSMixFunctionValue> CSSParser::parseMixFunction(CSSParserValue* value)
 {
     ASSERT(value->unit == CSSParserValue::Function && value->function);
 
     if (!equalIgnoringCase(value->function->name, "mix("))
         return 0;
 
     CSSParserValueList* argsList = value->function->args.get();
     if (!argsList)
         return 0;
 
     unsigned numArgs = argsList->size();
     if (numArgs < 1 || numArgs > 3)
         return 0;
 
-    RefPtr<WebKitCSSMixFunctionValue> mixFunction = WebKitCSSMixFunctionValue::create();
+    RefPtr<CSSMixFunctionValue> mixFunction = CSSMixFunctionValue::create();
 
     bool hasBlendMode = false;
     bool hasAlphaCompositing = false;
     CSSParserValue* arg;
     while ((arg = argsList->current())) {
         RefPtr<CSSValue> value;
 
         unsigned argNumber = argsList->currentIndex();
         if (!argNumber) {
             if (arg->unit == CSSPrimitiveValue::CSS_URI) {
                 KURL shaderURL = completeURL(arg->string);
-                value = WebKitCSSShaderValue::create(shaderURL.string());
+                value = CSSShaderValue::create(shaderURL.string());
             }
         } else if (argNumber == 1 || argNumber == 2) {
             if (!hasBlendMode && isBlendMode(arg->id)) {
                 hasBlendMode = true;
                 value = cssValuePool().createIdentifierValue(arg->id);
             } else if (!hasAlphaCompositing && isCompositeOperator(arg->id)) {
                 hasAlphaCompositing = true;
                 value = cssValuePool().createIdentifierValue(arg->id);
             }
         }
@@ skipping 157 matching lines @@
     // 1. Parse the shader URLs: <vertex-shader>[wsp<fragment-shader>]
     RefPtr<CSSValueList> shadersList = CSSValueList::createSpaceSeparated();
     bool hadAtLeastOneCustomShader = false;
     CSSParserValue* arg;
     while ((arg = argsList->current())) {
         RefPtr<CSSValue> value;
         if (arg->id == CSSValueNone)
             value = cssValuePool().createIdentifierValue(CSSValueNone);
         else if (arg->unit == CSSPrimitiveValue::CSS_URI) {
             KURL shaderURL = completeURL(arg->string);
-            value = WebKitCSSShaderValue::create(shaderURL.string());
+            value = CSSShaderValue::create(shaderURL.string());
             hadAtLeastOneCustomShader = true;
         } else if (argsList->currentIndex() == 1 && arg->unit == CSSParserValue::Function) {
             if (!(value = parseMixFunction(arg)))
                 return 0;
             hadAtLeastOneCustomShader = true;
         }
 
         if (!value)
             break;
         shadersList->append(value.release());
@@ skipping 84 matching lines @@
         RefPtr<CSSValue> parsedTransformValue = parseTransformValue(value);
         if (!parsedTransformValue)
             return 0;
 
         list->append(parsedTransformValue.release());
     }
 
     return list.release();
 }
 
-PassRefPtr<WebKitCSSShaderValue> CSSParser::parseFilterRuleSrcUriAndFormat(CSSParserValueList* valueList)
+PassRefPtr<CSSShaderValue> CSSParser::parseFilterRuleSrcUriAndFormat(CSSParserValueList* valueList)
 {
     CSSParserValue* value = valueList->current();
     ASSERT(value && value->unit == CSSPrimitiveValue::CSS_URI);
-    RefPtr<WebKitCSSShaderValue> shaderValue = WebKitCSSShaderValue::create(completeURL(value->string));
+    RefPtr<CSSShaderValue> shaderValue = CSSShaderValue::create(completeURL(value->string));
 
     value = valueList->next();
     if (value && value->unit == CSSParserValue::Function && equalIgnoringCase(value->function->name, "format(")) {
         CSSParserValueList* args = value->function->args.get();
         if (!args || args->size() != 1)
             return 0;
 
         CSSParserValue* arg = args->current();
         if (arg->unit != CSSPrimitiveValue::CSS_STRING)
             return 0;
 
         shaderValue->setFormat(arg->string);
         valueList->next();
     }
 
     return shaderValue.release();
 }
 
 bool CSSParser::parseFilterRuleSrc()
 {
     RefPtr<CSSValueList> srcList = CSSValueList::createCommaSeparated();
 
     CSSParserValue* value = m_valueList->current();
     while (value) {
         if (value->unit != CSSPrimitiveValue::CSS_URI)
             return false;
 
-        RefPtr<WebKitCSSShaderValue> shaderValue = parseFilterRuleSrcUriAndFormat(m_valueList.get());
+        RefPtr<CSSShaderValue> shaderValue = parseFilterRuleSrcUriAndFormat(m_valueList.get());
         if (!shaderValue)
             return false;
         srcList->append(shaderValue.release());
 
         if (!acceptCommaOperator(m_valueList.get()))
             return false;
 
         value = m_valueList->current();
     }
 
@@ skipping 118 matching lines @@
     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;
 
         WebKitCSSFilterValue::FilterOperationType filterType = WebKitCSSFilterValue::UnknownFilterOperation;
 
         // See if the specified primitive is one we understand.
         if (value->unit == CSSPrimitiveValue::CSS_URI) {
             RefPtr<WebKitCSSFilterValue> referenceFilterValue = WebKitCSSFilterValue::create(WebKitCSSFilterValue::ReferenceFilterOperation);
             list->append(referenceFilterValue);
-            referenceFilterValue->append(WebKitCSSSVGDocumentValue::create(value->string));
+            referenceFilterValue->append(CSSSVGDocumentValue::create(value->string));
         } else {
             const CSSParserString name = value->function->name;
             unsigned maximumArgumentCount = 1;
 
             filterInfoForName(name, filterType, maximumArgumentCount);
 
             if (filterType == WebKitCSSFilterValue::UnknownFilterOperation)
                 return 0;
 
             if (filterType == WebKitCSSFilterValue::CustomFilterOperation) {
@@ skipping 3147 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");
 }
 
 }