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/CSSBorderImageSliceValue.h"
  31 #include "core/css/CSSCalculationValue.h"
  32 #include "core/css/CSSCanvasValue.h"
  33 #include "core/css/CSSContentDistributionValue.h"
  34 #include "core/css/CSSCrossfadeValue.h"
  35 #include "core/css/CSSCursorImageValue.h"
  36 #include "core/css/CSSFilterValue.h"
  37 #include "core/css/CSSFontFaceSrcValue.h"
  38 #include "core/css/CSSFontFeatureValue.h"
  39 #include "core/css/CSSFontValue.h"
  40 #include "core/css/CSSFunctionValue.h"
  41 #include "core/css/CSSGradientValue.h"
  42 #include "core/css/CSSGridLineNamesValue.h"
  43 #include "core/css/CSSGridTemplateAreasValue.h"
  44 #include "core/css/CSSImageSetValue.h"
  45 #include "core/css/CSSImageValue.h"
  46 #include "core/css/CSSInheritedValue.h"
  47 #include "core/css/CSSInitialValue.h"
  48 #include "core/css/CSSLineBoxContainValue.h"
  49 #include "core/css/CSSPrimitiveValue.h"
  50 #include "core/css/CSSReflectValue.h"
  51 #include "core/css/CSSSVGDocumentValue.h"
  52 #include "core/css/CSSShadowValue.h"
  53 #include "core/css/CSSTimingFunctionValue.h"
  54 #include "core/css/CSSTransformValue.h"
  55 #include "core/css/CSSUnicodeRangeValue.h"
  56 #include "core/css/CSSValueList.h"
  57
  58 namespace blink {
  59
  60 struct SameSizeAsCSSValue : public RefCountedWillBeGarbageCollectedFinalized<SameSizeAsCSSValue>
  61 // VC++ 2013 doesn't support EBCO (Empty Base Class Optimization), and having
  62 // multiple empty base classes makes the size of CSSValue bloat (Note that both
  63 // of GarbageCollectedFinalized and ScriptWrappableBase are empty classes).
  64 // See the following article for details.
  65 // http://social.msdn.microsoft.com/forums/vstudio/en-US/504c6598-6076-4acf-96b6-e6acb475d302/vc-multiple-inheritance-empty-base-classes-bloats-object-size
  66 //
  67 // FIXME: Remove this #if directive once VC++'s issue gets fixed.
  68 // Note that we're going to split CSSValue class into two classes; CSSOMValue
  69 // (assumed name) which derives ScriptWrappable and CSSValue (new one) which
  70 // doesn't derive ScriptWrappable or ScriptWrappableBase. Then, we can safely
  71 // remove this #if directive.
  72 #if ENABLE(OILPAN) && COMPILER(MSVC)
  73     , public ScriptWrappableBase
  74 #endif
  75 {
  76     uint32_t bitfields;
  77 };
  78
  79 COMPILE_ASSERT(sizeof(CSSValue) <= sizeof(SameSizeAsCSSValue), CSS_value_should_stay_small);
  80
  81 class TextCloneCSSValue : public CSSValue {
  82 public:
  83     static PassRefPtrWillBeRawPtr<TextCloneCSSValue> create(ClassType classType, const String& text)
  84     {
  85         return adoptRefWillBeNoop(new TextCloneCSSValue(classType, text));
  86     }
  87
  88     String cssText() const { return m_cssText; }
  89
  90     void traceAfterDispatch(Visitor* visitor) { CSSValue::traceAfterDispatch(visitor); }
  91
  92 private:
  93     TextCloneCSSValue(ClassType classType, const String& text)
  94         : CSSValue(classType, /*isCSSOMSafe*/ true)
  95         , m_cssText(text)
  96     {
  97         m_isTextClone = true;
  98     }
  99
 100     String m_cssText;
 101 };
 102
 103 DEFINE_CSS_VALUE_TYPE_CASTS(TextCloneCSSValue, isTextCloneCSSValue());
 104
 105 bool CSSValue::isImplicitInitialValue() const
 106 {
 107     return m_classType == InitialClass && toCSSInitialValue(this)->isImplicit();
 108 }
 109
 110 CSSValue::Type CSSValue::cssValueType() const
 111 {
 112     if (isInheritedValue())
 113         return CSS_INHERIT;
 114     if (isPrimitiveValue())
 115         return CSS_PRIMITIVE_VALUE;
 116     if (isValueList())
 117         return CSS_VALUE_LIST;
 118     if (isInitialValue())
 119         return CSS_INITIAL;
 120     return CSS_CUSTOM;
 121 }
 122
 123 bool CSSValue::hasFailedOrCanceledSubresources() const
 124 {
 125     // This should get called for internal instances only.
 126     ASSERT(!isCSSOMSafe());
 127
 128     if (isValueList())
 129         return toCSSValueList(this)->hasFailedOrCanceledSubresources();
 130     if (classType() == FontFaceSrcClass)
 131         return toCSSFontFaceSrcValue(this)->hasFailedOrCanceledSubresources();
 132     if (classType() == ImageClass)
 133         return toCSSImageValue(this)->hasFailedOrCanceledSubresources();
 134     if (classType() == CrossfadeClass)
 135         return toCSSCrossfadeValue(this)->hasFailedOrCanceledSubresources();
 136     if (classType() == ImageSetClass)
 137         return toCSSImageSetValue(this)->hasFailedOrCanceledSubresources();
 138
 139     return false;
 140 }
 141
 142 template<class ChildClassType>
 143 inline static bool compareCSSValues(const CSSValue& first, const CSSValue& second)
 144 {
 145     return static_cast<const ChildClassType&>(first).equals(static_cast<const ChildClassType&>(second));
 146 }
 147
 148 bool CSSValue::equals(const CSSValue& other) const
 149 {
 150     if (m_isTextClone) {
 151         ASSERT(isCSSOMSafe());
 152         return toTextCloneCSSValue(this)->cssText() == other.cssText();
 153     }
 154
 155     if (m_classType == other.m_classType) {
 156         switch (m_classType) {
 157         case BorderImageSliceClass:
 158             return compareCSSValues<CSSBorderImageSliceValue>(*this, other);
 159         case CanvasClass:
 160             return compareCSSValues<CSSCanvasValue>(*this, other);
 161         case CursorImageClass:
 162             return compareCSSValues<CSSCursorImageValue>(*this, other);
 163         case FontClass:
 164             return compareCSSValues<CSSFontValue>(*this, other);
 165         case FontFaceSrcClass:
 166             return compareCSSValues<CSSFontFaceSrcValue>(*this, other);
 167         case FontFeatureClass:
 168             return compareCSSValues<CSSFontFeatureValue>(*this, other);
 169         case FunctionClass:
 170             return compareCSSValues<CSSFunctionValue>(*this, other);
 171         case LinearGradientClass:
 172             return compareCSSValues<CSSLinearGradientValue>(*this, other);
 173         case RadialGradientClass:
 174             return compareCSSValues<CSSRadialGradientValue>(*this, other);
 175         case CrossfadeClass:
 176             return compareCSSValues<CSSCrossfadeValue>(*this, other);
 177         case ImageClass:
 178             return compareCSSValues<CSSImageValue>(*this, other);
 179         case InheritedClass:
 180             return compareCSSValues<CSSInheritedValue>(*this, other);
 181         case InitialClass:
 182             return compareCSSValues<CSSInitialValue>(*this, other);
 183         case GridLineNamesClass:
 184             return compareCSSValues<CSSGridLineNamesValue>(*this, other);
 185         case GridTemplateAreasClass:
 186             return compareCSSValues<CSSGridTemplateAreasValue>(*this, other);
 187         case PrimitiveClass:
 188             return compareCSSValues<CSSPrimitiveValue>(*this, other);
 189         case ReflectClass:
 190             return compareCSSValues<CSSReflectValue>(*this, other);
 191         case ShadowClass:
 192             return compareCSSValues<CSSShadowValue>(*this, other);
 193         case CubicBezierTimingFunctionClass:
 194             return compareCSSValues<CSSCubicBezierTimingFunctionValue>(*this, other);
 195         case StepsTimingFunctionClass:
 196             return compareCSSValues<CSSStepsTimingFunctionValue>(*this, other);
 197         case UnicodeRangeClass:
 198             return compareCSSValues<CSSUnicodeRangeValue>(*this, other);
 199         case ValueListClass:
 200             return compareCSSValues<CSSValueList>(*this, other);
 201         case CSSTransformClass:
 202             return compareCSSValues<CSSTransformValue>(*this, other);
 203         case LineBoxContainClass:
 204             return compareCSSValues<CSSLineBoxContainValue>(*this, other);
 205         case CalculationClass:
 206             return compareCSSValues<CSSCalcValue>(*this, other);
 207         case ImageSetClass:
 208             return compareCSSValues<CSSImageSetValue>(*this, other);
 209         case CSSFilterClass:
 210             return compareCSSValues<CSSFilterValue>(*this, other);
 211         case CSSSVGDocumentClass:
 212             return compareCSSValues<CSSSVGDocumentValue>(*this, other);
 213         case CSSContentDistributionClass:
 214             return compareCSSValues<CSSContentDistributionValue>(*this, other);
 215         default:
 216             ASSERT_NOT_REACHED();
 217             return false;
 218         }
 219     } else if (m_classType == ValueListClass && other.m_classType != ValueListClass)
 220         return toCSSValueList(this)->equals(other);
 221     else if (m_classType != ValueListClass && other.m_classType == ValueListClass)
 222         return static_cast<const CSSValueList&>(other).equals(*this);
 223     return false;
 224 }
 225
 226 String CSSValue::cssText() const
 227 {
 228     if (m_isTextClone) {
 229          ASSERT(isCSSOMSafe());
 230         return toTextCloneCSSValue(this)->cssText();
 231     }
 232     ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
 233
 234     switch (classType()) {
 235     case BorderImageSliceClass:
 236         return toCSSBorderImageSliceValue(this)->customCSSText();
 237     case CanvasClass:
 238         return toCSSCanvasValue(this)->customCSSText();
 239     case CursorImageClass:
 240         return toCSSCursorImageValue(this)->customCSSText();
 241     case FontClass:
 242         return toCSSFontValue(this)->customCSSText();
 243     case FontFaceSrcClass:
 244         return toCSSFontFaceSrcValue(this)->customCSSText();
 245     case FontFeatureClass:
 246         return toCSSFontFeatureValue(this)->customCSSText();
 247     case FunctionClass:
 248         return toCSSFunctionValue(this)->customCSSText();
 249     case LinearGradientClass:
 250         return toCSSLinearGradientValue(this)->customCSSText();
 251     case RadialGradientClass:
 252         return toCSSRadialGradientValue(this)->customCSSText();
 253     case CrossfadeClass:
 254         return toCSSCrossfadeValue(this)->customCSSText();
 255     case ImageClass:
 256         return toCSSImageValue(this)->customCSSText();
 257     case InheritedClass:
 258         return toCSSInheritedValue(this)->customCSSText();
 259     case InitialClass:
 260         return toCSSInitialValue(this)->customCSSText();
 261     case GridLineNamesClass:
 262         return toCSSGridLineNamesValue(this)->customCSSText();
 263     case GridTemplateAreasClass:
 264         return toCSSGridTemplateAreasValue(this)->customCSSText();
 265     case PrimitiveClass:
 266         return toCSSPrimitiveValue(this)->customCSSText();
 267     case ReflectClass:
 268         return toCSSReflectValue(this)->customCSSText();
 269     case ShadowClass:
 270         return toCSSShadowValue(this)->customCSSText();
 271     case CubicBezierTimingFunctionClass:
 272         return toCSSCubicBezierTimingFunctionValue(this)->customCSSText();
 273     case StepsTimingFunctionClass:
 274         return toCSSStepsTimingFunctionValue(this)->customCSSText();
 275     case UnicodeRangeClass:
 276         return toCSSUnicodeRangeValue(this)->customCSSText();
 277     case ValueListClass:
 278         return toCSSValueList(this)->customCSSText();
 279     case CSSTransformClass:
 280         return toCSSTransformValue(this)->customCSSText();
 281     case LineBoxContainClass:
 282         return toCSSLineBoxContainValue(this)->customCSSText();
 283     case CalculationClass:
 284         return toCSSCalcValue(this)->customCSSText();
 285     case ImageSetClass:
 286         return toCSSImageSetValue(this)->customCSSText();
 287     case CSSFilterClass:
 288         return toCSSFilterValue(this)->customCSSText();
 289     case CSSSVGDocumentClass:
 290         return toCSSSVGDocumentValue(this)->customCSSText();
 291     case CSSContentDistributionClass:
 292         return toCSSContentDistributionValue(this)->customCSSText();
 293     }
 294     ASSERT_NOT_REACHED();
 295     return String();
 296 }
 297
 298 void CSSValue::destroy()
 299 {
 300     if (m_isTextClone) {
 301         ASSERT(isCSSOMSafe());
 302         delete toTextCloneCSSValue(this);
 303         return;
 304     }
 305     ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
 306
 307     switch (classType()) {
 308     case BorderImageSliceClass:
 309         delete toCSSBorderImageSliceValue(this);
 310         return;
 311     case CanvasClass:
 312         delete toCSSCanvasValue(this);
 313         return;
 314     case CursorImageClass:
 315         delete toCSSCursorImageValue(this);
 316         return;
 317     case FontClass:
 318         delete toCSSFontValue(this);
 319         return;
 320     case FontFaceSrcClass:
 321         delete toCSSFontFaceSrcValue(this);
 322         return;
 323     case FontFeatureClass:
 324         delete toCSSFontFeatureValue(this);
 325         return;
 326     case FunctionClass:
 327         delete toCSSFunctionValue(this);
 328         return;
 329     case LinearGradientClass:
 330         delete toCSSLinearGradientValue(this);
 331         return;
 332     case RadialGradientClass:
 333         delete toCSSRadialGradientValue(this);
 334         return;
 335     case CrossfadeClass:
 336         delete toCSSCrossfadeValue(this);
 337         return;
 338     case ImageClass:
 339         delete toCSSImageValue(this);
 340         return;
 341     case InheritedClass:
 342         delete toCSSInheritedValue(this);
 343         return;
 344     case InitialClass:
 345         delete toCSSInitialValue(this);
 346         return;
 347     case GridLineNamesClass:
 348         delete toCSSGridLineNamesValue(this);
 349         return;
 350     case GridTemplateAreasClass:
 351         delete toCSSGridTemplateAreasValue(this);
 352         return;
 353     case PrimitiveClass:
 354         delete toCSSPrimitiveValue(this);
 355         return;
 356     case ReflectClass:
 357         delete toCSSReflectValue(this);
 358         return;
 359     case ShadowClass:
 360         delete toCSSShadowValue(this);
 361         return;
 362     case CubicBezierTimingFunctionClass:
 363         delete toCSSCubicBezierTimingFunctionValue(this);
 364         return;
 365     case StepsTimingFunctionClass:
 366         delete toCSSStepsTimingFunctionValue(this);
 367         return;
 368     case UnicodeRangeClass:
 369         delete toCSSUnicodeRangeValue(this);
 370         return;
 371     case ValueListClass:
 372         delete toCSSValueList(this);
 373         return;
 374     case CSSTransformClass:
 375         delete toCSSTransformValue(this);
 376         return;
 377     case LineBoxContainClass:
 378         delete toCSSLineBoxContainValue(this);
 379         return;
 380     case CalculationClass:
 381         delete toCSSCalcValue(this);
 382         return;
 383     case ImageSetClass:
 384         delete toCSSImageSetValue(this);
 385         return;
 386     case CSSFilterClass:
 387         delete toCSSFilterValue(this);
 388         return;
 389     case CSSSVGDocumentClass:
 390         delete toCSSSVGDocumentValue(this);
 391         return;
 392     case CSSContentDistributionClass:
 393         delete toCSSContentDistributionValue(this);
 394         return;
 395     }
 396     ASSERT_NOT_REACHED();
 397 }
 398
 399 void CSSValue::finalizeGarbageCollectedObject()
 400 {
 401     if (m_isTextClone) {
 402         ASSERT(isCSSOMSafe());
 403         toTextCloneCSSValue(this)->~TextCloneCSSValue();
 404         return;
 405     }
 406     ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
 407
 408     switch (classType()) {
 409     case BorderImageSliceClass:
 410         toCSSBorderImageSliceValue(this)->~CSSBorderImageSliceValue();
 411         return;
 412     case CanvasClass:
 413         toCSSCanvasValue(this)->~CSSCanvasValue();
 414         return;
 415     case CursorImageClass:
 416         toCSSCursorImageValue(this)->~CSSCursorImageValue();
 417         return;
 418     case FontClass:
 419         toCSSFontValue(this)->~CSSFontValue();
 420         return;
 421     case FontFaceSrcClass:
 422         toCSSFontFaceSrcValue(this)->~CSSFontFaceSrcValue();
 423         return;
 424     case FontFeatureClass:
 425         toCSSFontFeatureValue(this)->~CSSFontFeatureValue();
 426         return;
 427     case FunctionClass:
 428         toCSSFunctionValue(this)->~CSSFunctionValue();
 429         return;
 430     case LinearGradientClass:
 431         toCSSLinearGradientValue(this)->~CSSLinearGradientValue();
 432         return;
 433     case RadialGradientClass:
 434         toCSSRadialGradientValue(this)->~CSSRadialGradientValue();
 435         return;
 436     case CrossfadeClass:
 437         toCSSCrossfadeValue(this)->~CSSCrossfadeValue();
 438         return;
 439     case ImageClass:
 440         toCSSImageValue(this)->~CSSImageValue();
 441         return;
 442     case InheritedClass:
 443         toCSSInheritedValue(this)->~CSSInheritedValue();
 444         return;
 445     case InitialClass:
 446         toCSSInitialValue(this)->~CSSInitialValue();
 447         return;
 448     case GridLineNamesClass:
 449         toCSSGridLineNamesValue(this)->~CSSGridLineNamesValue();
 450         return;
 451     case GridTemplateAreasClass:
 452         toCSSGridTemplateAreasValue(this)->~CSSGridTemplateAreasValue();
 453         return;
 454     case PrimitiveClass:
 455         toCSSPrimitiveValue(this)->~CSSPrimitiveValue();
 456         return;
 457     case ReflectClass:
 458         toCSSReflectValue(this)->~CSSReflectValue();
 459         return;
 460     case ShadowClass:
 461         toCSSShadowValue(this)->~CSSShadowValue();
 462         return;
 463     case CubicBezierTimingFunctionClass:
 464         toCSSCubicBezierTimingFunctionValue(this)->~CSSCubicBezierTimingFunctionValue();
 465         return;
 466     case StepsTimingFunctionClass:
 467         toCSSStepsTimingFunctionValue(this)->~CSSStepsTimingFunctionValue();
 468         return;
 469     case UnicodeRangeClass:
 470         toCSSUnicodeRangeValue(this)->~CSSUnicodeRangeValue();
 471         return;
 472     case ValueListClass:
 473         toCSSValueList(this)->~CSSValueList();
 474         return;
 475     case CSSTransformClass:
 476         toCSSTransformValue(this)->~CSSTransformValue();
 477         return;
 478     case LineBoxContainClass:
 479         toCSSLineBoxContainValue(this)->~CSSLineBoxContainValue();
 480         return;
 481     case CalculationClass:
 482         toCSSCalcValue(this)->~CSSCalcValue();
 483         return;
 484     case ImageSetClass:
 485         toCSSImageSetValue(this)->~CSSImageSetValue();
 486         return;
 487     case CSSFilterClass:
 488         toCSSFilterValue(this)->~CSSFilterValue();
 489         return;
 490     case CSSSVGDocumentClass:
 491         toCSSSVGDocumentValue(this)->~CSSSVGDocumentValue();
 492         return;
 493     case CSSContentDistributionClass:
 494         toCSSContentDistributionValue(this)->~CSSContentDistributionValue();
 495         return;
 496     }
 497     ASSERT_NOT_REACHED();
 498 }
 499
 500 void CSSValue::trace(Visitor* visitor)
 501 {
 502     if (m_isTextClone) {
 503         ASSERT(isCSSOMSafe());
 504         toTextCloneCSSValue(this)->traceAfterDispatch(visitor);
 505         return;
 506     }
 507     ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
 508
 509     switch (classType()) {
 510     case BorderImageSliceClass:
 511         toCSSBorderImageSliceValue(this)->traceAfterDispatch(visitor);
 512         return;
 513     case CanvasClass:
 514         toCSSCanvasValue(this)->traceAfterDispatch(visitor);
 515         return;
 516     case CursorImageClass:
 517         toCSSCursorImageValue(this)->traceAfterDispatch(visitor);
 518         return;
 519     case FontClass:
 520         toCSSFontValue(this)->traceAfterDispatch(visitor);
 521         return;
 522     case FontFaceSrcClass:
 523         toCSSFontFaceSrcValue(this)->traceAfterDispatch(visitor);
 524         return;
 525     case FontFeatureClass:
 526         toCSSFontFeatureValue(this)->traceAfterDispatch(visitor);
 527         return;
 528     case FunctionClass:
 529         toCSSFunctionValue(this)->traceAfterDispatch(visitor);
 530         return;
 531     case LinearGradientClass:
 532         toCSSLinearGradientValue(this)->traceAfterDispatch(visitor);
 533         return;
 534     case RadialGradientClass:
 535         toCSSRadialGradientValue(this)->traceAfterDispatch(visitor);
 536         return;
 537     case CrossfadeClass:
 538         toCSSCrossfadeValue(this)->traceAfterDispatch(visitor);
 539         return;
 540     case ImageClass:
 541         toCSSImageValue(this)->traceAfterDispatch(visitor);
 542         return;
 543     case InheritedClass:
 544         toCSSInheritedValue(this)->traceAfterDispatch(visitor);
 545         return;
 546     case InitialClass:
 547         toCSSInitialValue(this)->traceAfterDispatch(visitor);
 548         return;
 549     case GridLineNamesClass:
 550         toCSSGridLineNamesValue(this)->traceAfterDispatch(visitor);
 551         return;
 552     case GridTemplateAreasClass:
 553         toCSSGridTemplateAreasValue(this)->traceAfterDispatch(visitor);
 554         return;
 555     case PrimitiveClass:
 556         toCSSPrimitiveValue(this)->traceAfterDispatch(visitor);
 557         return;
 558     case ReflectClass:
 559         toCSSReflectValue(this)->traceAfterDispatch(visitor);
 560         return;
 561     case ShadowClass:
 562         toCSSShadowValue(this)->traceAfterDispatch(visitor);
 563         return;
 564     case CubicBezierTimingFunctionClass:
 565         toCSSCubicBezierTimingFunctionValue(this)->traceAfterDispatch(visitor);
 566         return;
 567     case StepsTimingFunctionClass:
 568         toCSSStepsTimingFunctionValue(this)->traceAfterDispatch(visitor);
 569         return;
 570     case UnicodeRangeClass:
 571         toCSSUnicodeRangeValue(this)->traceAfterDispatch(visitor);
 572         return;
 573     case ValueListClass:
 574         toCSSValueList(this)->traceAfterDispatch(visitor);
 575         return;
 576     case CSSTransformClass:
 577         toCSSTransformValue(this)->traceAfterDispatch(visitor);
 578         return;
 579     case LineBoxContainClass:
 580         toCSSLineBoxContainValue(this)->traceAfterDispatch(visitor);
 581         return;
 582     case CalculationClass:
 583         toCSSCalcValue(this)->traceAfterDispatch(visitor);
 584         return;
 585     case ImageSetClass:
 586         toCSSImageSetValue(this)->traceAfterDispatch(visitor);
 587         return;
 588     case CSSFilterClass:
 589         toCSSFilterValue(this)->traceAfterDispatch(visitor);
 590         return;
 591     case CSSSVGDocumentClass:
 592         toCSSSVGDocumentValue(this)->traceAfterDispatch(visitor);
 593         return;
 594     case CSSContentDistributionClass:
 595         toCSSContentDistributionValue(this)->traceAfterDispatch(visitor);
 596         return;
 597     }
 598     ASSERT_NOT_REACHED();
 599 }
 600
 601 PassRefPtrWillBeRawPtr<CSSValue> CSSValue::cloneForCSSOM() const
 602 {
 603     switch (classType()) {
 604     case PrimitiveClass:
 605         return toCSSPrimitiveValue(this)->cloneForCSSOM();
 606     case ValueListClass:
 607         return toCSSValueList(this)->cloneForCSSOM();
 608     case ImageClass:
 609     case CursorImageClass:
 610         return toCSSImageValue(this)->cloneForCSSOM();
 611     case CSSFilterClass:
 612         return toCSSFilterValue(this)->cloneForCSSOM();
 613     case CSSTransformClass:
 614         return toCSSTransformValue(this)->cloneForCSSOM();
 615     case ImageSetClass:
 616         return toCSSImageSetValue(this)->cloneForCSSOM();
 617     default:
 618         ASSERT(!isSubtypeExposedToCSSOM());
 619         return TextCloneCSSValue::create(classType(), cssText());
 620     }
 621 }
 622
 623 }