Clean up after getPropertyCSSValue

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 40 matching lines @@
 #include "core/css/CSSSVGDocumentValue.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSTransformValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
 #include "core/css/CSSValueList.h"
 
 namespace blink {
 
 struct SameSizeAsCSSValue : public RefCountedWillBeGarbageCollectedFinalized<SameSizeAsCSSValue>
-// VC++ 2013 doesn't support EBCO (Empty Base Class Optimization), and having
-// multiple empty base classes makes the size of CSSValue bloat (Note that both
-// of GarbageCollectedFinalized and ScriptWrappableBase are empty classes).
-// See the following article for details.
-// http://social.msdn.microsoft.com/forums/vstudio/en-US/504c6598-6076-4acf-96b6-e6acb475d302/vc-multiple-inheritance-empty-base-classes-bloats-object-size
-//
-// FIXME: Remove this #if directive once VC++'s issue gets fixed.
-// Note that we're going to split CSSValue class into two classes; CSSOMValue
-// (assumed name) which derives ScriptWrappable and CSSValue (new one) which
-// doesn't derive ScriptWrappable or ScriptWrappableBase. Then, we can safely
-// remove this #if directive.
-#if ENABLE(OILPAN) && COMPILER(MSVC)
-    , public ScriptWrappableBase
-#endif
 {
     uint32_t bitfields;
 };
 
 COMPILE_ASSERT(sizeof(CSSValue) <= sizeof(SameSizeAsCSSValue), CSS_value_should_stay_small);
 
-class TextCloneCSSValue : public CSSValue {
-public:
-    static PassRefPtrWillBeRawPtr<TextCloneCSSValue> create(ClassType classType, const String& text)
-    {
-        return adoptRefWillBeNoop(new TextCloneCSSValue(classType, text));
-    }
-
-    String cssText() const { return m_cssText; }
-
-    void traceAfterDispatch(Visitor* visitor) { CSSValue::traceAfterDispatch(visitor); }
-
-private:
-    TextCloneCSSValue(ClassType classType, const String& text)
-        : CSSValue(classType, /*isCSSOMSafe*/ true)
-        , m_cssText(text)
-    {
-        m_isTextClone = true;
-    }
-
-    String m_cssText;
-};
-
-DEFINE_CSS_VALUE_TYPE_CASTS(TextCloneCSSValue, isTextCloneCSSValue());
-
 bool CSSValue::isImplicitInitialValue() const
 {
     return m_classType == InitialClass && toCSSInitialValue(this)->isImplicit();
 }
 
 CSSValue::Type CSSValue::cssValueType() const
 {
     if (isInheritedValue())
         return CSS_INHERIT;
     if (isPrimitiveValue())
         return CSS_PRIMITIVE_VALUE;
     if (isValueList())
         return CSS_VALUE_LIST;
     if (isInitialValue())
         return CSS_INITIAL;
     return CSS_CUSTOM;
 }
 
 bool CSSValue::hasFailedOrCanceledSubresources() const
 {
-    // This should get called for internal instances only.
-    ASSERT(!isCSSOMSafe());
-
     if (isValueList())
         return toCSSValueList(this)->hasFailedOrCanceledSubresources();
     if (classType() == FontFaceSrcClass)
         return toCSSFontFaceSrcValue(this)->hasFailedOrCanceledSubresources();
     if (classType() == ImageClass)
         return toCSSImageValue(this)->hasFailedOrCanceledSubresources();
     if (classType() == CrossfadeClass)
         return toCSSCrossfadeValue(this)->hasFailedOrCanceledSubresources();
     if (classType() == ImageSetClass)
         return toCSSImageSetValue(this)->hasFailedOrCanceledSubresources();
 
     return false;
 }
 
 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));
 }
 
 bool CSSValue::equals(const CSSValue& other) const
 {
-    if (m_isTextClone) {
-        ASSERT(isCSSOMSafe());
-        return toTextCloneCSSValue(this)->cssText() == other.cssText();
-    }
-
     if (m_classType == other.m_classType) {
         switch (m_classType) {
         case BorderImageSliceClass:
             return compareCSSValues<CSSBorderImageSliceValue>(*this, other);
         case CanvasClass:
             return compareCSSValues<CSSCanvasValue>(*this, other);
         case CursorImageClass:
             return compareCSSValues<CSSCursorImageValue>(*this, other);
         case FontClass:
             return compareCSSValues<CSSFontValue>(*this, other);
@@ skipping 53 matching lines @@
         }
     } 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;
 }
 
 String CSSValue::cssText() const
 {
-    if (m_isTextClone) {
-         ASSERT(isCSSOMSafe());
-        return toTextCloneCSSValue(this)->cssText();
-    }
-    ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
-
     switch (classType()) {
     case BorderImageSliceClass:
         return toCSSBorderImageSliceValue(this)->customCSSText();
     case CanvasClass:
         return toCSSCanvasValue(this)->customCSSText();
     case CursorImageClass:
         return toCSSCursorImageValue(this)->customCSSText();
     case FontClass:
         return toCSSFontValue(this)->customCSSText();
     case FontFaceSrcClass:
@@ skipping 46 matching lines @@
         return toCSSSVGDocumentValue(this)->customCSSText();
     case CSSContentDistributionClass:
         return toCSSContentDistributionValue(this)->customCSSText();
     }
     ASSERT_NOT_REACHED();
     return String();
 }
 
 void CSSValue::destroy()
 {
-    if (m_isTextClone) {
-        ASSERT(isCSSOMSafe());
-        delete toTextCloneCSSValue(this);
-        return;
-    }
-    ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
-
     switch (classType()) {
     case BorderImageSliceClass:
         delete toCSSBorderImageSliceValue(this);
         return;
     case CanvasClass:
         delete toCSSCanvasValue(this);
         return;
     case CursorImageClass:
         delete toCSSCursorImageValue(this);
         return;
@@ skipping 74 matching lines @@
         return;
     case CSSContentDistributionClass:
         delete toCSSContentDistributionValue(this);
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
 void CSSValue::finalizeGarbageCollectedObject()
 {
-    if (m_isTextClone) {
-        ASSERT(isCSSOMSafe());
-        toTextCloneCSSValue(this)->~TextCloneCSSValue();
-        return;
-    }
-    ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
-
     switch (classType()) {
     case BorderImageSliceClass:
         toCSSBorderImageSliceValue(this)->~CSSBorderImageSliceValue();
         return;
     case CanvasClass:
         toCSSCanvasValue(this)->~CSSCanvasValue();
         return;
     case CursorImageClass:
         toCSSCursorImageValue(this)->~CSSCursorImageValue();
         return;
@@ skipping 74 matching lines @@
         return;
     case CSSContentDistributionClass:
         toCSSContentDistributionValue(this)->~CSSContentDistributionValue();
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
 void CSSValue::trace(Visitor* visitor)
 {
-    if (m_isTextClone) {
-        ASSERT(isCSSOMSafe());
-        toTextCloneCSSValue(this)->traceAfterDispatch(visitor);
-        return;
-    }
-    ASSERT(!isCSSOMSafe() || isSubtypeExposedToCSSOM());
-
     switch (classType()) {
     case BorderImageSliceClass:
         toCSSBorderImageSliceValue(this)->traceAfterDispatch(visitor);
         return;
     case CanvasClass:
         toCSSCanvasValue(this)->traceAfterDispatch(visitor);
         return;
     case CursorImageClass:
         toCSSCursorImageValue(this)->traceAfterDispatch(visitor);
         return;
@@ skipping 72 matching lines @@
     case CSSSVGDocumentClass:
         toCSSSVGDocumentValue(this)->traceAfterDispatch(visitor);
         return;
     case CSSContentDistributionClass:
         toCSSContentDistributionValue(this)->traceAfterDispatch(visitor);
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
-PassRefPtrWillBeRawPtr<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 CSSFilterClass:
-        return toCSSFilterValue(this)->cloneForCSSOM();
-    case CSSTransformClass:
-        return toCSSTransformValue(this)->cloneForCSSOM();
-    case ImageSetClass:
-        return toCSSImageSetValue(this)->cloneForCSSOM();
-    default:
-        ASSERT(!isSubtypeExposedToCSSOM());
-        return TextCloneCSSValue::create(classType(), cssText());
-    }
 }
-
-}