Cleanup WebKit prefixed names for classes in css directory.

Source/core/css/CSSValue.cpp

 /*
  * Copyright (C) 2011 Andreas Kling (kling@webkit.org)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 23 matching lines @@
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSCursorImageValue.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSFunctionValue.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/CSSReflectValue.h"
+#include "core/css/CSSSVGDocumentValue.h"
+#include "core/css/CSSShaderValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
+#include "core/css/CSSTransformValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSVariableValue.h"
 #include "core/css/FontFeatureValue.h"
 #include "core/css/FontValue.h"
 #include "core/css/ShadowValue.h"
 #include "core/css/WebKitCSSArrayFunctionValue.h"
 #include "core/css/WebKitCSSFilterValue.h"
-#include "core/css/WebKitCSSMixFunctionValue.h"
-#include "core/css/WebKitCSSSVGDocumentValue.h"
-#include "core/css/WebKitCSSShaderValue.h"
-#include "core/css/WebKitCSSTransformValue.h"
 #include "core/dom/WebCoreMemoryInstrumentation.h"
 #include "core/svg/SVGColor.h"
 #include "core/svg/SVGPaint.h"
 
 namespace WebCore {
 
 struct SameSizeAsCSSValue : public RefCounted<SameSizeAsCSSValue> {
     uint32_t bitfields;
 };
 
@@ skipping 149 matching lines @@
         return;
     case LineBoxContainClass:
         static_cast<const CSSLineBoxContainValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     case CalculationClass:
         static_cast<const CSSCalcValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     case WebKitCSSArrayFunctionValueClass:
         static_cast<const WebKitCSSArrayFunctionValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
-    case WebKitCSSMixFunctionValueClass:
-        static_cast<const WebKitCSSMixFunctionValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
+    case CSSMixFunctionValueClass:
+        static_cast<const CSSMixFunctionValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
-    case WebKitCSSShaderClass:
-        static_cast<const WebKitCSSShaderValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
+    case CSSShaderClass:
+        static_cast<const CSSShaderValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     case VariableClass:
         static_cast<const CSSVariableValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     case SVGColorClass:
         static_cast<const SVGColor*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     case SVGPaintClass:
         static_cast<const SVGPaint*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
-    case WebKitCSSSVGDocumentClass:
-        static_cast<const WebKitCSSSVGDocumentValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
+    case CSSSVGDocumentClass:
+        static_cast<const CSSSVGDocumentValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     case ValueListClass:
         toCSSValueList(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     case ImageSetClass:
         static_cast<const CSSImageSetValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     case WebKitCSSFilterClass:
         static_cast<const WebKitCSSFilterValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
-    case WebKitCSSTransformClass:
-        static_cast<const WebKitCSSTransformValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
+    case CSSTransformClass:
+        static_cast<const CSSTransformValue*>(this)->reportDescendantMemoryUsage(memoryObjectInfo);
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
 template<class ChildClassType>
 inline static bool compareCSSValues(const CSSValue& first, const CSSValue& second)
 {
     return static_cast<const ChildClassType&>(first).equals(static_cast<const ChildClassType&>(second));
 }
@@ skipping 44 matching lines @@
         case LinearTimingFunctionClass:
             return compareCSSValues<CSSLinearTimingFunctionValue>(*this, other);
         case CubicBezierTimingFunctionClass:
             return compareCSSValues<CSSCubicBezierTimingFunctionValue>(*this, other);
         case StepsTimingFunctionClass:
             return compareCSSValues<CSSStepsTimingFunctionValue>(*this, other);
         case UnicodeRangeClass:
             return compareCSSValues<CSSUnicodeRangeValue>(*this, other);
         case ValueListClass:
             return compareCSSValues<CSSValueList>(*this, other);
-        case WebKitCSSTransformClass:
-            return compareCSSValues<WebKitCSSTransformValue>(*this, other);
+        case CSSTransformClass:
+            return compareCSSValues<CSSTransformValue>(*this, other);
         case LineBoxContainClass:
             return compareCSSValues<CSSLineBoxContainValue>(*this, other);
         case CalculationClass:
             return compareCSSValues<CSSCalcValue>(*this, other);
         case ImageSetClass:
             return compareCSSValues<CSSImageSetValue>(*this, other);
         case WebKitCSSFilterClass:
             return compareCSSValues<WebKitCSSFilterValue>(*this, other);
         case WebKitCSSArrayFunctionValueClass:
             return compareCSSValues<WebKitCSSArrayFunctionValue>(*this, other);
-        case WebKitCSSMixFunctionValueClass:
-            return compareCSSValues<WebKitCSSMixFunctionValue>(*this, other);
-        case WebKitCSSShaderClass:
-            return compareCSSValues<WebKitCSSShaderValue>(*this, other);
+        case CSSMixFunctionValueClass:
+            return compareCSSValues<CSSMixFunctionValue>(*this, other);
+        case CSSShaderClass:
+            return compareCSSValues<CSSShaderValue>(*this, other);
         case VariableClass:
             return compareCSSValues<CSSVariableValue>(*this, other);
         case SVGColorClass:
             return compareCSSValues<SVGColor>(*this, other);
         case SVGPaintClass:
             return compareCSSValues<SVGPaint>(*this, other);
-        case WebKitCSSSVGDocumentClass:
-            return compareCSSValues<WebKitCSSSVGDocumentValue>(*this, other);
+        case CSSSVGDocumentClass:
+            return compareCSSValues<CSSSVGDocumentValue>(*this, other);
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     } else if (m_classType == ValueListClass && other.m_classType != ValueListClass)
         return toCSSValueList(this)->equals(other);
     else if (m_classType != ValueListClass && other.m_classType == ValueListClass)
         return static_cast<const CSSValueList&>(other).equals(*this);
     return false;
 }
@@ skipping 44 matching lines @@
     case LinearTimingFunctionClass:
         return static_cast<const CSSLinearTimingFunctionValue*>(this)->customCssText();
     case CubicBezierTimingFunctionClass:
         return static_cast<const CSSCubicBezierTimingFunctionValue*>(this)->customCssText();
     case StepsTimingFunctionClass:
         return static_cast<const CSSStepsTimingFunctionValue*>(this)->customCssText();
     case UnicodeRangeClass:
         return static_cast<const CSSUnicodeRangeValue*>(this)->customCssText();
     case ValueListClass:
         return toCSSValueList(this)->customCssText();
-    case WebKitCSSTransformClass:
-        return static_cast<const WebKitCSSTransformValue*>(this)->customCssText();
+    case CSSTransformClass:
+        return static_cast<const CSSTransformValue*>(this)->customCssText();
     case LineBoxContainClass:
         return static_cast<const CSSLineBoxContainValue*>(this)->customCssText();
     case CalculationClass:
         return static_cast<const CSSCalcValue*>(this)->customCssText();
     case ImageSetClass:
         return static_cast<const CSSImageSetValue*>(this)->customCssText();
     case WebKitCSSFilterClass:
         return static_cast<const WebKitCSSFilterValue*>(this)->customCssText();
     case WebKitCSSArrayFunctionValueClass:
         return static_cast<const WebKitCSSArrayFunctionValue*>(this)->customCssText();
-    case WebKitCSSMixFunctionValueClass:
-        return static_cast<const WebKitCSSMixFunctionValue*>(this)->customCssText();
-    case WebKitCSSShaderClass:
-        return static_cast<const WebKitCSSShaderValue*>(this)->customCssText();
+    case CSSMixFunctionValueClass:
+        return static_cast<const CSSMixFunctionValue*>(this)->customCssText();
+    case CSSShaderClass:
+        return static_cast<const CSSShaderValue*>(this)->customCssText();
     case VariableClass:
         return static_cast<const CSSVariableValue*>(this)->value();
     case SVGColorClass:
         return static_cast<const SVGColor*>(this)->customCssText();
     case SVGPaintClass:
         return static_cast<const SVGPaint*>(this)->customCssText();
-    case WebKitCSSSVGDocumentClass:
-        return static_cast<const WebKitCSSSVGDocumentValue*>(this)->customCssText();
+    case CSSSVGDocumentClass:
+        return static_cast<const CSSSVGDocumentValue*>(this)->customCssText();
     }
     ASSERT_NOT_REACHED();
     return String();
 }
 
 String CSSValue::serializeResolvingVariables(const HashMap<AtomicString, String>& variables) const
 {
     switch (classType()) {
     case PrimitiveClass:
         return toCSSPrimitiveValue(this)->customSerializeResolvingVariables(variables);
     case ReflectClass:
         return static_cast<const CSSReflectValue*>(this)->customSerializeResolvingVariables(variables);
     case ValueListClass:
         return toCSSValueList(this)->customSerializeResolvingVariables(variables);
-    case WebKitCSSTransformClass:
-        return static_cast<const WebKitCSSTransformValue*>(this)->customSerializeResolvingVariables(variables);
+    case CSSTransformClass:
+        return static_cast<const CSSTransformValue*>(this)->customSerializeResolvingVariables(variables);
     default:
         return cssText();
     }
 }
 
 void CSSValue::destroy()
 {
     if (m_isTextClone) {
         ASSERT(isCSSOMSafe());
         delete static_cast<TextCloneCSSValue*>(this);
@@ skipping 61 matching lines @@
         return;
     case StepsTimingFunctionClass:
         delete static_cast<CSSStepsTimingFunctionValue*>(this);
         return;
     case UnicodeRangeClass:
         delete static_cast<CSSUnicodeRangeValue*>(this);
         return;
     case ValueListClass:
         delete toCSSValueList(this);
         return;
-    case WebKitCSSTransformClass:
-        delete static_cast<WebKitCSSTransformValue*>(this);
+    case CSSTransformClass:
+        delete static_cast<CSSTransformValue*>(this);
         return;
     case LineBoxContainClass:
         delete static_cast<CSSLineBoxContainValue*>(this);
         return;
     case CalculationClass:
         delete static_cast<CSSCalcValue*>(this);
         return;
     case ImageSetClass:
         delete static_cast<CSSImageSetValue*>(this);
         return;
     case WebKitCSSFilterClass:
         delete static_cast<WebKitCSSFilterValue*>(this);
         return;
     case WebKitCSSArrayFunctionValueClass:
         delete static_cast<WebKitCSSArrayFunctionValue*>(this);
         return;
-    case WebKitCSSMixFunctionValueClass:
-        delete static_cast<WebKitCSSMixFunctionValue*>(this);
+    case CSSMixFunctionValueClass:
+        delete static_cast<CSSMixFunctionValue*>(this);
         return;
-    case WebKitCSSShaderClass:
-        delete static_cast<WebKitCSSShaderValue*>(this);
+    case CSSShaderClass:
+        delete static_cast<CSSShaderValue*>(this);
         return;
     case VariableClass:
         delete static_cast<CSSVariableValue*>(this);
         return;
     case SVGColorClass:
         delete static_cast<SVGColor*>(this);
         return;
     case SVGPaintClass:
         delete static_cast<SVGPaint*>(this);
         return;
-    case WebKitCSSSVGDocumentClass:
-        delete static_cast<WebKitCSSSVGDocumentValue*>(this);
+    case CSSSVGDocumentClass:
+        delete static_cast<CSSSVGDocumentValue*>(this);
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
 PassRefPtr<CSSValue> CSSValue::cloneForCSSOM() const
 {
     switch (classType()) {
     case PrimitiveClass:
         return toCSSPrimitiveValue(this)->cloneForCSSOM();
     case ValueListClass:
         return toCSSValueList(this)->cloneForCSSOM();
     case ImageClass:
     case CursorImageClass:
         return toCSSImageValue(this)->cloneForCSSOM();
     case WebKitCSSFilterClass:
         return static_cast<const WebKitCSSFilterValue*>(this)->cloneForCSSOM();
     case WebKitCSSArrayFunctionValueClass:
         return static_cast<const WebKitCSSArrayFunctionValue*>(this)->cloneForCSSOM();
-    case WebKitCSSMixFunctionValueClass:
-        return static_cast<const WebKitCSSMixFunctionValue*>(this)->cloneForCSSOM();
-    case WebKitCSSTransformClass:
-        return static_cast<const WebKitCSSTransformValue*>(this)->cloneForCSSOM();
+    case CSSMixFunctionValueClass:
+        return static_cast<const CSSMixFunctionValue*>(this)->cloneForCSSOM();
+    case CSSTransformClass:
+        return static_cast<const CSSTransformValue*>(this)->cloneForCSSOM();
     case ImageSetClass:
         return static_cast<const CSSImageSetValue*>(this)->cloneForCSSOM();
     case SVGColorClass:
         return static_cast<const SVGColor*>(this)->cloneForCSSOM();
     case SVGPaintClass:
         return static_cast<const SVGPaint*>(this)->cloneForCSSOM();
     default:
         ASSERT(!isSubtypeExposedToCSSOM());
         return TextCloneCSSValue::create(classType(), cssText());
     }
 }
 
 }