src/third_party/WebKit/Source/core/css/CSSValue.cpp

   1 /*
   2  * Copyright (C) 2011 Andreas Kling (kling@webkit.org)
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  *
  25  */
  26
  27 #include "config.h"
  28 #include "core/css/CSSValue.h"
  29
  30 #include "core/css/CSSArrayFunctionValue.h"
  31 #include "core/css/CSSAspectRatioValue.h"
  32 #include "core/css/CSSBorderImageSliceValue.h"
  33 #include "core/css/CSSCalculationValue.h"
  34 #include "core/css/CSSCanvasValue.h"
  35 #include "core/css/CSSCrossfadeValue.h"
  36 #include "core/css/CSSCursorImageValue.h"
  37 #include "core/css/CSSFilterValue.h"
  38 #include "core/css/CSSFontFaceSrcValue.h"
  39 #include "core/css/CSSFontFeatureValue.h"
  40 #include "core/css/CSSFontValue.h"
  41 #include "core/css/CSSFunctionValue.h"
  42 #include "core/css/CSSGradientValue.h"
  43 #include "core/css/CSSGridLineNamesValue.h"
  44 #include "core/css/CSSGridTemplateAreasValue.h"
  45 #include "core/css/CSSImageSetValue.h"
  46 #include "core/css/CSSImageValue.h"
  47 #include "core/css/CSSInheritedValue.h"
  48 #include "core/css/CSSInitialValue.h"
  49 #include "core/css/CSSLineBoxContainValue.h"
  50 #include "core/css/CSSPrimitiveValue.h"
  51 #include "core/css/CSSReflectValue.h"
  52 #include "core/css/CSSSVGDocumentValue.h"
  53 #include "core/css/CSSShadowValue.h"
  54 #include "core/css/CSSTimingFunctionValue.h"
  55 #include "core/css/CSSTransformValue.h"
  56 #include "core/css/CSSUnicodeRangeValue.h"
  57 #include "core/css/CSSValueList.h"
  58 #include "core/svg/SVGColor.h"
  59 #include "core/svg/SVGPaint.h"
  60
  61 namespace WebCore {
  62
  63 DEFINE_GC_INFO(CSSValue);
  64
  65 struct SameSizeAsCSSValue : public RefCountedWillBeRefCountedGarbageCollected<SameSizeAsCSSValue> {
  66     uint32_t bitfields;
  67 };
  68
  69 COMPILE_ASSERT(sizeof(CSSValue) <= sizeof(SameSizeAsCSSValue), CSS_value_should_stay_small);
  70
  71 class TextCloneCSSValue : public CSSValue {
  72 public:
  73     static PassRefPtr<TextCloneCSSValue> create(ClassType classType, const String& text) { return adoptRef(new TextCloneCSSValue(classType, text)); }
  74
  75     String cssText() const { return m_cssText; }
  76
  77     void traceAfterDispatch(Visitor* visitor) { CSSValue::traceAfterDispatch(visitor); }
  78
  79 private:
  80     TextCloneCSSValue(ClassType classType, const String& text)
  81         : CSSValue(classType, /*isCSSOMSafe*/ true)
  82         , m_cssText(text)
  83     {
  84         m_isTextClone = true;
  85     }
  86
  87     String m_cssText;
  88 };
  89
  90 DEFINE_CSS_VALUE_TYPE_CASTS(TextCloneCSSValue, isTextCloneCSSValue());
  91
  92 bool CSSValue::isImplicitInitialValue() const
  93 {
  94     return m_classType == InitialClass && toCSSInitialValue(this)->isImplicit();
  95 }
  96
  97 CSSValue::Type CSSValue::cssValueType() const
  98 {
  99     if (isInheritedValue())
 100         return CSS_INHERIT;
 101     if (isPrimitiveValue())
 102         return CSS_PRIMITIVE_VALUE;
 103     if (isValueList())
 104         return CSS_VALUE_LIST;
 105     if (isInitialValue())
 106         return CSS_INITIAL;
 107     return CSS_CUSTOM;
 108 }
 109
 110 bool CSSValue::hasFailedOrCanceledSubresources() const
 111 {
 112     // This should get called for internal instances only.
 113     ASSERT(!isCSSOMSafe());
 114
 115     if (isValueList())
 116         return toCSSValueList(this)->hasFailedOrCanceledSubresources();
 117     if (classType() == FontFaceSrcClass)
 118         return toCSSFontFaceSrcValue(this)->hasFailedOrCanceledSubresources();
 119     if (classType() == ImageClass)
 120         return toCSSImageValue(this)->hasFailedOrCanceledSubresources();
 121     if (classType() == CrossfadeClass)
 122         return toCSSCrossfadeValue(this)->hasFailedOrCanceledSubresources();
 123     if (classType() == ImageSetClass)
 124         return toCSSImageSetValue(this)->hasFailedOrCanceledSubresources();
 125
 126     return false;
 127 }
 128
 129 template<class ChildClassType>
 130 inline static bool compareCSSValues(const CSSValue& first, const CSSValue& second)
 131 {
 132     return static_cast<const ChildClassType&>(first).equals(static_cast<const ChildClassType&>(second));
 133 }
 134
 135 bool CSSValue::equals(const CSSValue& other) const
 136 {
 137     if (m_isTextClone) {
 138         ASSERT(isCSSOMSafe());
 139         return toTextCloneCSSValue(this)->cssText() == other.cssText();
 140     }
 141
 142     if (m_classType == other.m_classType) {
 143         switch (m_classType) {
 144         case AspectRatioClass:
 145             return compareCSSValues<CSSAspectRatioValue>(*this, other);
 146         case BorderImageSliceClass:
 147             return compareCSSValues<CSSBorderImageSliceValue>(*this, other);
 148         case CanvasClass:
 149             return compareCSSValues<CSSCanvasValue>(*this, other);
 150         case CursorImageClass:
 151             return compareCSSValues<CSSCursorImageValue>(*this, other);
 152         case FontClass:
 153             return compareCSSValues<CSSFontValue>(*this, other);
 154         case FontFaceSrcClass:
 155             return compareCSSValues<CSSFontFaceSrcValue>(*this, other);
 156         case FontFeatureClass:
 157             return compareCSSValues<CSSFontFeatureValue>(*this, other);
 158         case FunctionClass:
 159             return compareCSSValues<CSSFunctionValue>(*this, other);
 160         case LinearGradientClass:
 161             return compareCSSValues<CSSLinearGradientValue>(*this, other);
 162         case RadialGradientClass:
 163             return compareCSSValues<CSSRadialGradientValue>(*this, other);
 164         case CrossfadeClass:
 165             return compareCSSValues<CSSCrossfadeValue>(*this, other);
 166         case ImageClass:
 167             return compareCSSValues<CSSImageValue>(*this, other);
 168         case InheritedClass:
 169             return compareCSSValues<CSSInheritedValue>(*this, other);
 170         case InitialClass:
 171             return compareCSSValues<CSSInitialValue>(*this, other);
 172         case GridLineNamesClass:
 173             return compareCSSValues<CSSGridLineNamesValue>(*this, other);
 174         case GridTemplateAreasClass:
 175             return compareCSSValues<CSSGridTemplateAreasValue>(*this, other);
 176         case PrimitiveClass:
 177             return compareCSSValues<CSSPrimitiveValue>(*this, other);
 178         case ReflectClass:
 179             return compareCSSValues<CSSReflectValue>(*this, other);
 180         case ShadowClass:
 181             return compareCSSValues<CSSShadowValue>(*this, other);
 182         case CubicBezierTimingFunctionClass:
 183             return compareCSSValues<CSSCubicBezierTimingFunctionValue>(*this, other);
 184         case StepsTimingFunctionClass:
 185             return compareCSSValues<CSSStepsTimingFunctionValue>(*this, other);
 186         case UnicodeRangeClass:
 187             return compareCSSValues<CSSUnicodeRangeValue>(*this, other);
 188         case ValueListClass:
 189             return compareCSSValues<CSSValueList>(*this, other);
 190         case CSSTransformClass:
 191             return compareCSSValues<CSSTransformValue>(*this, other);
 192         case LineBoxContainClass:
 193             return compareCSSValues<CSSLineBoxContainValue>(*this, other);
 194         case CalculationClass:
 195             return compareCSSValues<CSSCalcValue>(*this, other);
 196         case ImageSetClass:
 197             return compareCSSValues<CSSImageSetValue>(*this, other);
 198         case CSSFilterClass:
 199             return compareCSSValues<CSSFilterValue>(*this, other);
 200         case CSSArrayFunctionValueClass:
 201             return compareCSSValues<CSSArrayFunctionValue>(*this, other);
 202         case SVGColorClass:
 203             return compareCSSValues<SVGColor>(*this, other);
 204         case SVGPaintClass:
 205             return compareCSSValues<SVGPaint>(*this, other);
 206         case CSSSVGDocumentClass:
 207             return compareCSSValues<CSSSVGDocumentValue>(*this, other);
 208         default:
 209             ASSERT_NOT_REACHED();
 210             return false;
 211         }
 212     } else if (m_classType == ValueListClass && other.m_classType != ValueListClass)
 213         return toCSSValueList(this)->equals(other);
 214     else if (m_classType != ValueListClass && other.m_classType == ValueListClass)
 215         return static_cast<const CSSValueList&>(other).equals(*this);
 216     return false;
 217 }
 218
 219 String CSSValue::cssText() const
 220 {
 221     if (m_isTextClone) {
 222          ASSERT(isCSSOMSafe());
 223         return toTextCloneCSSValue(this)->cssText();
 224     }
 225     ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
 226
 227     switch (classType()) {
 228     case AspectRatioClass:
 229         return toCSSAspectRatioValue(this)->customCSSText();
 230     case BorderImageSliceClass:
 231         return toCSSBorderImageSliceValue(this)->customCSSText();
 232     case CanvasClass:
 233         return toCSSCanvasValue(this)->customCSSText();
 234     case CursorImageClass:
 235         return toCSSCursorImageValue(this)->customCSSText();
 236     case FontClass:
 237         return toCSSFontValue(this)->customCSSText();
 238     case FontFaceSrcClass:
 239         return toCSSFontFaceSrcValue(this)->customCSSText();
 240     case FontFeatureClass:
 241         return toCSSFontFeatureValue(this)->customCSSText();
 242     case FunctionClass:
 243         return toCSSFunctionValue(this)->customCSSText();
 244     case LinearGradientClass:
 245         return toCSSLinearGradientValue(this)->customCSSText();
 246     case RadialGradientClass:
 247         return toCSSRadialGradientValue(this)->customCSSText();
 248     case CrossfadeClass:
 249         return toCSSCrossfadeValue(this)->customCSSText();
 250     case ImageClass:
 251         return toCSSImageValue(this)->customCSSText();
 252     case InheritedClass:
 253         return toCSSInheritedValue(this)->customCSSText();
 254     case InitialClass:
 255         return toCSSInitialValue(this)->customCSSText();
 256     case GridLineNamesClass:
 257         return toCSSGridLineNamesValue(this)->customCSSText();
 258     case GridTemplateAreasClass:
 259         return toCSSGridTemplateAreasValue(this)->customCSSText();
 260     case PrimitiveClass:
 261         return toCSSPrimitiveValue(this)->customCSSText();
 262     case ReflectClass:
 263         return toCSSReflectValue(this)->customCSSText();
 264     case ShadowClass:
 265         return toCSSShadowValue(this)->customCSSText();
 266     case CubicBezierTimingFunctionClass:
 267         return toCSSCubicBezierTimingFunctionValue(this)->customCSSText();
 268     case StepsTimingFunctionClass:
 269         return toCSSStepsTimingFunctionValue(this)->customCSSText();
 270     case UnicodeRangeClass:
 271         return toCSSUnicodeRangeValue(this)->customCSSText();
 272     case ValueListClass:
 273         return toCSSValueList(this)->customCSSText();
 274     case CSSTransformClass:
 275         return toCSSTransformValue(this)->customCSSText();
 276     case LineBoxContainClass:
 277         return toCSSLineBoxContainValue(this)->customCSSText();
 278     case CalculationClass:
 279         return toCSSCalcValue(this)->customCSSText();
 280     case ImageSetClass:
 281         return toCSSImageSetValue(this)->customCSSText();
 282     case CSSFilterClass:
 283         return toCSSFilterValue(this)->customCSSText();
 284     case CSSArrayFunctionValueClass:
 285         return toCSSArrayFunctionValue(this)->customCSSText();
 286     case SVGColorClass:
 287         return toSVGColor(this)->customCSSText();
 288     case SVGPaintClass:
 289         return toSVGPaint(this)->customCSSText();
 290     case CSSSVGDocumentClass:
 291         return toCSSSVGDocumentValue(this)->customCSSText();
 292     }
 293     ASSERT_NOT_REACHED();
 294     return String();
 295 }
 296
 297 void CSSValue::destroy()
 298 {
 299     if (m_isTextClone) {
 300         ASSERT(isCSSOMSafe());
 301         delete toTextCloneCSSValue(this);
 302         return;
 303     }
 304     ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
 305
 306     switch (classType()) {
 307     case AspectRatioClass:
 308         delete toCSSAspectRatioValue(this);
 309         return;
 310     case BorderImageSliceClass:
 311         delete toCSSBorderImageSliceValue(this);
 312         return;
 313     case CanvasClass:
 314         delete toCSSCanvasValue(this);
 315         return;
 316     case CursorImageClass:
 317         delete toCSSCursorImageValue(this);
 318         return;
 319     case FontClass:
 320         delete toCSSFontValue(this);
 321         return;
 322     case FontFaceSrcClass:
 323         delete toCSSFontFaceSrcValue(this);
 324         return;
 325     case FontFeatureClass:
 326         delete toCSSFontFeatureValue(this);
 327         return;
 328     case FunctionClass:
 329         delete toCSSFunctionValue(this);
 330         return;
 331     case LinearGradientClass:
 332         delete toCSSLinearGradientValue(this);
 333         return;
 334     case RadialGradientClass:
 335         delete toCSSRadialGradientValue(this);
 336         return;
 337     case CrossfadeClass:
 338         delete toCSSCrossfadeValue(this);
 339         return;
 340     case ImageClass:
 341         delete toCSSImageValue(this);
 342         return;
 343     case InheritedClass:
 344         delete toCSSInheritedValue(this);
 345         return;
 346     case InitialClass:
 347         delete toCSSInitialValue(this);
 348         return;
 349     case GridLineNamesClass:
 350         delete toCSSGridLineNamesValue(this);
 351         return;
 352     case GridTemplateAreasClass:
 353         delete toCSSGridTemplateAreasValue(this);
 354         return;
 355     case PrimitiveClass:
 356         delete toCSSPrimitiveValue(this);
 357         return;
 358     case ReflectClass:
 359         delete toCSSReflectValue(this);
 360         return;
 361     case ShadowClass:
 362         delete toCSSShadowValue(this);
 363         return;
 364     case CubicBezierTimingFunctionClass:
 365         delete toCSSCubicBezierTimingFunctionValue(this);
 366         return;
 367     case StepsTimingFunctionClass:
 368         delete toCSSStepsTimingFunctionValue(this);
 369         return;
 370     case UnicodeRangeClass:
 371         delete toCSSUnicodeRangeValue(this);
 372         return;
 373     case ValueListClass:
 374         delete toCSSValueList(this);
 375         return;
 376     case CSSTransformClass:
 377         delete toCSSTransformValue(this);
 378         return;
 379     case LineBoxContainClass:
 380         delete toCSSLineBoxContainValue(this);
 381         return;
 382     case CalculationClass:
 383         delete toCSSCalcValue(this);
 384         return;
 385     case ImageSetClass:
 386         delete toCSSImageSetValue(this);
 387         return;
 388     case CSSFilterClass:
 389         delete toCSSFilterValue(this);
 390         return;
 391     case CSSArrayFunctionValueClass:
 392         delete toCSSArrayFunctionValue(this);
 393         return;
 394     case SVGColorClass:
 395         delete toSVGColor(this);
 396         return;
 397     case SVGPaintClass:
 398         delete toSVGPaint(this);
 399         return;
 400     case CSSSVGDocumentClass:
 401         delete toCSSSVGDocumentValue(this);
 402         return;
 403     }
 404     ASSERT_NOT_REACHED();
 405 }
 406
 407 void CSSValue::finalize()
 408 {
 409     if (m_isTextClone) {
 410         ASSERT(isCSSOMSafe());
 411         static_cast<TextCloneCSSValue*>(this)->~TextCloneCSSValue();
 412         return;
 413     }
 414     ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
 415
 416     switch (classType()) {
 417     case AspectRatioClass:
 418         static_cast<CSSAspectRatioValue*>(this)->~CSSAspectRatioValue();
 419         return;
 420     case BorderImageSliceClass:
 421         static_cast<CSSBorderImageSliceValue*>(this)->~CSSBorderImageSliceValue();
 422         return;
 423     case CanvasClass:
 424         static_cast<CSSCanvasValue*>(this)->~CSSCanvasValue();
 425         return;
 426     case CursorImageClass:
 427         static_cast<CSSCursorImageValue*>(this)->~CSSCursorImageValue();
 428         return;
 429     case FontClass:
 430         static_cast<CSSFontValue*>(this)->~CSSFontValue();
 431         return;
 432     case FontFaceSrcClass:
 433         static_cast<CSSFontFaceSrcValue*>(this)->~CSSFontFaceSrcValue();
 434         return;
 435     case FontFeatureClass:
 436         static_cast<CSSFontFeatureValue*>(this)->~CSSFontFeatureValue();
 437         return;
 438     case FunctionClass:
 439         static_cast<CSSFunctionValue*>(this)->~CSSFunctionValue();
 440         return;
 441     case LinearGradientClass:
 442         static_cast<CSSLinearGradientValue*>(this)->~CSSLinearGradientValue();
 443         return;
 444     case RadialGradientClass:
 445         static_cast<CSSRadialGradientValue*>(this)->~CSSRadialGradientValue();
 446         return;
 447     case CrossfadeClass:
 448         static_cast<CSSCrossfadeValue*>(this)->~CSSCrossfadeValue();
 449         return;
 450     case ImageClass:
 451         static_cast<CSSImageValue*>(this)->~CSSImageValue();
 452         return;
 453     case InheritedClass:
 454         static_cast<CSSInheritedValue*>(this)->~CSSInheritedValue();
 455         return;
 456     case InitialClass:
 457         static_cast<CSSInitialValue*>(this)->~CSSInitialValue();
 458         return;
 459     case GridLineNamesClass:
 460         static_cast<CSSGridLineNamesValue*>(this)->~CSSGridLineNamesValue();
 461         return;
 462     case GridTemplateAreasClass:
 463         static_cast<CSSGridTemplateAreasValue*>(this)->~CSSGridTemplateAreasValue();
 464         return;
 465     case PrimitiveClass:
 466         static_cast<CSSPrimitiveValue*>(this)->~CSSPrimitiveValue();
 467         return;
 468     case ReflectClass:
 469         static_cast<CSSReflectValue*>(this)->~CSSReflectValue();
 470         return;
 471     case ShadowClass:
 472         static_cast<CSSShadowValue*>(this)->~CSSShadowValue();
 473         return;
 474     case CubicBezierTimingFunctionClass:
 475         static_cast<CSSCubicBezierTimingFunctionValue*>(this)->~CSSCubicBezierTimingFunctionValue();
 476         return;
 477     case StepsTimingFunctionClass:
 478         static_cast<CSSStepsTimingFunctionValue*>(this)->~CSSStepsTimingFunctionValue();
 479         return;
 480     case UnicodeRangeClass:
 481         static_cast<CSSUnicodeRangeValue*>(this)->~CSSUnicodeRangeValue();
 482         return;
 483     case ValueListClass:
 484         static_cast<CSSValueList*>(this)->~CSSValueList();
 485         return;
 486     case CSSTransformClass:
 487         static_cast<CSSTransformValue*>(this)->~CSSTransformValue();
 488         return;
 489     case LineBoxContainClass:
 490         static_cast<CSSLineBoxContainValue*>(this)->~CSSLineBoxContainValue();
 491         return;
 492     case CalculationClass:
 493         static_cast<CSSCalcValue*>(this)->~CSSCalcValue();
 494         return;
 495     case ImageSetClass:
 496         static_cast<CSSImageSetValue*>(this)->~CSSImageSetValue();
 497         return;
 498     case CSSFilterClass:
 499         static_cast<CSSFilterValue*>(this)->~CSSFilterValue();
 500         return;
 501     case CSSArrayFunctionValueClass:
 502         static_cast<CSSArrayFunctionValue*>(this)->~CSSArrayFunctionValue();
 503         return;
 504     case SVGColorClass:
 505         static_cast<SVGColor*>(this)->~SVGColor();
 506         return;
 507     case SVGPaintClass:
 508         static_cast<SVGPaint*>(this)->~SVGPaint();
 509         return;
 510     case CSSSVGDocumentClass:
 511         static_cast<CSSSVGDocumentValue*>(this)->~CSSSVGDocumentValue();
 512         return;
 513     }
 514     ASSERT_NOT_REACHED();
 515 }
 516
 517 void CSSValue::trace(Visitor* visitor)
 518 {
 519     if (m_isTextClone) {
 520         ASSERT(isCSSOMSafe());
 521         static_cast<TextCloneCSSValue*>(this)->traceAfterDispatch(visitor);
 522         return;
 523     }
 524     ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
 525
 526     switch (classType()) {
 527     case AspectRatioClass:
 528         static_cast<CSSAspectRatioValue*>(this)->traceAfterDispatch(visitor);
 529         return;
 530     case BorderImageSliceClass:
 531         static_cast<CSSBorderImageSliceValue*>(this)->traceAfterDispatch(visitor);
 532         return;
 533     case CanvasClass:
 534         static_cast<CSSCanvasValue*>(this)->traceAfterDispatch(visitor);
 535         return;
 536     case CursorImageClass:
 537         static_cast<CSSCursorImageValue*>(this)->traceAfterDispatch(visitor);
 538         return;
 539     case FontClass:
 540         static_cast<CSSFontValue*>(this)->traceAfterDispatch(visitor);
 541         return;
 542     case FontFaceSrcClass:
 543         static_cast<CSSFontFaceSrcValue*>(this)->traceAfterDispatch(visitor);
 544         return;
 545     case FontFeatureClass:
 546         static_cast<CSSFontFeatureValue*>(this)->traceAfterDispatch(visitor);
 547         return;
 548     case FunctionClass:
 549         static_cast<CSSFunctionValue*>(this)->traceAfterDispatch(visitor);
 550         return;
 551     case LinearGradientClass:
 552         static_cast<CSSLinearGradientValue*>(this)->traceAfterDispatch(visitor);
 553         return;
 554     case RadialGradientClass:
 555         static_cast<CSSRadialGradientValue*>(this)->traceAfterDispatch(visitor);
 556         return;
 557     case CrossfadeClass:
 558         static_cast<CSSCrossfadeValue*>(this)->traceAfterDispatch(visitor);
 559         return;
 560     case ImageClass:
 561         static_cast<CSSImageValue*>(this)->traceAfterDispatch(visitor);
 562         return;
 563     case InheritedClass:
 564         static_cast<CSSInheritedValue*>(this)->traceAfterDispatch(visitor);
 565         return;
 566     case InitialClass:
 567         static_cast<CSSInitialValue*>(this)->traceAfterDispatch(visitor);
 568         return;
 569     case GridLineNamesClass:
 570         static_cast<CSSGridLineNamesValue*>(this)->traceAfterDispatch(visitor);
 571         return;
 572     case GridTemplateAreasClass:
 573         static_cast<CSSGridTemplateAreasValue*>(this)->traceAfterDispatch(visitor);
 574         return;
 575     case PrimitiveClass:
 576         static_cast<CSSPrimitiveValue*>(this)->traceAfterDispatch(visitor);
 577         return;
 578     case ReflectClass:
 579         static_cast<CSSReflectValue*>(this)->traceAfterDispatch(visitor);
 580         return;
 581     case ShadowClass:
 582         static_cast<CSSShadowValue*>(this)->traceAfterDispatch(visitor);
 583         return;
 584     case CubicBezierTimingFunctionClass:
 585         static_cast<CSSCubicBezierTimingFunctionValue*>(this)->traceAfterDispatch(visitor);
 586         return;
 587     case StepsTimingFunctionClass:
 588         static_cast<CSSStepsTimingFunctionValue*>(this)->traceAfterDispatch(visitor);
 589         return;
 590     case UnicodeRangeClass:
 591         static_cast<CSSUnicodeRangeValue*>(this)->traceAfterDispatch(visitor);
 592         return;
 593     case ValueListClass:
 594         static_cast<CSSValueList*>(this)->traceAfterDispatch(visitor);
 595         return;
 596     case CSSTransformClass:
 597         static_cast<CSSTransformValue*>(this)->traceAfterDispatch(visitor);
 598         return;
 599     case LineBoxContainClass:
 600         static_cast<CSSLineBoxContainValue*>(this)->traceAfterDispatch(visitor);
 601         return;
 602     case CalculationClass:
 603         static_cast<CSSCalcValue*>(this)->traceAfterDispatch(visitor);
 604         return;
 605     case ImageSetClass:
 606         static_cast<CSSImageSetValue*>(this)->traceAfterDispatch(visitor);
 607         return;
 608     case CSSFilterClass:
 609         static_cast<CSSFilterValue*>(this)->traceAfterDispatch(visitor);
 610         return;
 611     case CSSArrayFunctionValueClass:
 612         static_cast<CSSArrayFunctionValue*>(this)->traceAfterDispatch(visitor);
 613         return;
 614     case SVGColorClass:
 615         static_cast<SVGColor*>(this)->traceAfterDispatch(visitor);
 616         return;
 617     case SVGPaintClass:
 618         static_cast<SVGPaint*>(this)->traceAfterDispatch(visitor);
 619         return;
 620     case CSSSVGDocumentClass:
 621         static_cast<CSSSVGDocumentValue*>(this)->traceAfterDispatch(visitor);
 622         return;
 623     }
 624     ASSERT_NOT_REACHED();
 625 }
 626
 627 PassRefPtr<CSSValue> CSSValue::cloneForCSSOM() const
 628 {
 629     switch (classType()) {
 630     case PrimitiveClass:
 631         return toCSSPrimitiveValue(this)->cloneForCSSOM();
 632     case ValueListClass:
 633         return toCSSValueList(this)->cloneForCSSOM();
 634     case ImageClass:
 635     case CursorImageClass:
 636         return toCSSImageValue(this)->cloneForCSSOM();
 637     case CSSFilterClass:
 638         return toCSSFilterValue(this)->cloneForCSSOM();
 639     case CSSArrayFunctionValueClass:
 640         return toCSSArrayFunctionValue(this)->cloneForCSSOM();
 641     case CSSTransformClass:
 642         return toCSSTransformValue(this)->cloneForCSSOM();
 643     case ImageSetClass:
 644         return toCSSImageSetValue(this)->cloneForCSSOM();
 645     case SVGColorClass:
 646         return toSVGColor(this)->cloneForCSSOM();
 647     case SVGPaintClass:
 648         return toSVGPaint(this)->cloneForCSSOM();
 649     default:
 650         ASSERT(!isSubtypeExposedToCSSOM());
 651         return TextCloneCSSValue::create(classType(), cssText());
 652     }
 653 }
 654
 655 }