#include "config.h"
#include "core/css/StyleRule.h"
-#include "RuntimeEnabledFeatures.h"
#include "core/css/CSSFilterRule.h"
#include "core/css/CSSFontFaceRule.h"
-#include "core/css/CSSHostRule.h"
#include "core/css/CSSImportRule.h"
#include "core/css/CSSKeyframesRule.h"
#include "core/css/CSSMediaRule.h"
#include "core/css/CSSPageRule.h"
-#include "core/css/CSSRegionRule.h"
#include "core/css/CSSStyleRule.h"
#include "core/css/CSSSupportsRule.h"
#include "core/css/CSSViewportRule.h"
#include "core/css/StylePropertySet.h"
#include "core/css/StyleRuleImport.h"
-namespace WebCore {
+namespace blink {
-struct SameSizeAsStyleRuleBase : public WTF::RefCountedBase {
+struct SameSizeAsStyleRuleBase : public RefCountedWillBeRefCountedGarbageCollected<SameSizeAsStyleRuleBase> {
unsigned bitfields;
};
COMPILE_ASSERT(sizeof(StyleRuleBase) <= sizeof(SameSizeAsStyleRuleBase), StyleRuleBase_should_stay_small);
-PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet) const
+PassRefPtrWillBeRawPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet) const
{
return createCSSOMWrapper(parentSheet, 0);
}
-PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSRule* parentRule) const
+PassRefPtrWillBeRawPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSRule* parentRule) const
{
return createCSSOMWrapper(0, parentRule);
}
-void StyleRuleBase::destroy()
+void StyleRuleBase::trace(Visitor* visitor)
{
switch (type()) {
case Style:
- delete toStyleRule(this);
+ toStyleRule(this)->traceAfterDispatch(visitor);
return;
case Page:
- delete static_cast<StyleRulePage*>(this);
+ toStyleRulePage(this)->traceAfterDispatch(visitor);
return;
case FontFace:
- delete static_cast<StyleRuleFontFace*>(this);
+ toStyleRuleFontFace(this)->traceAfterDispatch(visitor);
return;
case Media:
- delete static_cast<StyleRuleMedia*>(this);
+ toStyleRuleMedia(this)->traceAfterDispatch(visitor);
return;
case Supports:
- delete static_cast<StyleRuleSupports*>(this);
+ toStyleRuleSupports(this)->traceAfterDispatch(visitor);
+ return;
+ case Import:
+ toStyleRuleImport(this)->traceAfterDispatch(visitor);
+ return;
+ case Keyframes:
+ toStyleRuleKeyframes(this)->traceAfterDispatch(visitor);
+ return;
+ case Viewport:
+ toStyleRuleViewport(this)->traceAfterDispatch(visitor);
+ return;
+ case Filter:
+ toStyleRuleFilter(this)->traceAfterDispatch(visitor);
+ return;
+ case Unknown:
+ case Charset:
+ case Keyframe:
+ ASSERT_NOT_REACHED();
+ return;
+ }
+ ASSERT_NOT_REACHED();
+}
+
+void StyleRuleBase::finalizeGarbageCollectedObject()
+{
+ switch (type()) {
+ case Style:
+ toStyleRule(this)->~StyleRule();
return;
- case Region:
- delete static_cast<StyleRuleRegion*>(this);
+ case Page:
+ toStyleRulePage(this)->~StyleRulePage();
+ return;
+ case FontFace:
+ toStyleRuleFontFace(this)->~StyleRuleFontFace();
+ return;
+ case Media:
+ toStyleRuleMedia(this)->~StyleRuleMedia();
+ return;
+ case Supports:
+ toStyleRuleSupports(this)->~StyleRuleSupports();
return;
case Import:
- delete static_cast<StyleRuleImport*>(this);
+ toStyleRuleImport(this)->~StyleRuleImport();
return;
case Keyframes:
- delete static_cast<StyleRuleKeyframes*>(this);
+ toStyleRuleKeyframes(this)->~StyleRuleKeyframes();
+ return;
+ case Viewport:
+ toStyleRuleViewport(this)->~StyleRuleViewport();
return;
- case HostInternal:
- delete static_cast<StyleRuleHost*>(this);
+ case Filter:
+ toStyleRuleFilter(this)->~StyleRuleFilter();
+ return;
+ case Unknown:
+ case Charset:
+ case Keyframe:
+ ASSERT_NOT_REACHED();
+ return;
+ }
+ ASSERT_NOT_REACHED();
+}
+
+void StyleRuleBase::destroy()
+{
+ switch (type()) {
+ case Style:
+ delete toStyleRule(this);
+ return;
+ case Page:
+ delete toStyleRulePage(this);
+ return;
+ case FontFace:
+ delete toStyleRuleFontFace(this);
+ return;
+ case Media:
+ delete toStyleRuleMedia(this);
+ return;
+ case Supports:
+ delete toStyleRuleSupports(this);
+ return;
+ case Import:
+ delete toStyleRuleImport(this);
+ return;
+ case Keyframes:
+ delete toStyleRuleKeyframes(this);
return;
case Viewport:
- delete static_cast<StyleRuleViewport*>(this);
+ delete toStyleRuleViewport(this);
return;
case Filter:
- delete static_cast<StyleRuleFilter*>(this);
+ delete toStyleRuleFilter(this);
return;
case Unknown:
case Charset:
ASSERT_NOT_REACHED();
}
-PassRefPtr<StyleRuleBase> StyleRuleBase::copy() const
+PassRefPtrWillBeRawPtr<StyleRuleBase> StyleRuleBase::copy() const
{
switch (type()) {
case Style:
- return static_cast<const StyleRule*>(this)->copy();
+ return toStyleRule(this)->copy();
case Page:
- return static_cast<const StyleRulePage*>(this)->copy();
+ return toStyleRulePage(this)->copy();
case FontFace:
- return static_cast<const StyleRuleFontFace*>(this)->copy();
+ return toStyleRuleFontFace(this)->copy();
case Media:
- return static_cast<const StyleRuleMedia*>(this)->copy();
+ return toStyleRuleMedia(this)->copy();
case Supports:
- return static_cast<const StyleRuleSupports*>(this)->copy();
- case Region:
- return static_cast<const StyleRuleRegion*>(this)->copy();
+ return toStyleRuleSupports(this)->copy();
case Import:
// FIXME: Copy import rules.
ASSERT_NOT_REACHED();
- return 0;
+ return nullptr;
case Keyframes:
- return static_cast<const StyleRuleKeyframes*>(this)->copy();
- case HostInternal:
- return static_cast<const StyleRuleHost*>(this)->copy();
+ return toStyleRuleKeyframes(this)->copy();
case Viewport:
- return static_cast<const StyleRuleViewport*>(this)->copy();
+ return toStyleRuleViewport(this)->copy();
case Filter:
- return static_cast<const StyleRuleFilter*>(this)->copy();
+ return toStyleRuleFilter(this)->copy();
case Unknown:
case Charset:
case Keyframe:
ASSERT_NOT_REACHED();
- return 0;
+ return nullptr;
}
ASSERT_NOT_REACHED();
- return 0;
+ return nullptr;
}
-PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const
+PassRefPtrWillBeRawPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const
{
- RefPtr<CSSRule> rule;
+ RefPtrWillBeRawPtr<CSSRule> rule = nullptr;
StyleRuleBase* self = const_cast<StyleRuleBase*>(this);
switch (type()) {
case Style:
rule = CSSStyleRule::create(toStyleRule(self), parentSheet);
break;
case Page:
- rule = CSSPageRule::create(static_cast<StyleRulePage*>(self), parentSheet);
+ rule = CSSPageRule::create(toStyleRulePage(self), parentSheet);
break;
case FontFace:
- rule = CSSFontFaceRule::create(static_cast<StyleRuleFontFace*>(self), parentSheet);
+ rule = CSSFontFaceRule::create(toStyleRuleFontFace(self), parentSheet);
break;
case Media:
- rule = CSSMediaRule::create(static_cast<StyleRuleMedia*>(self), parentSheet);
+ rule = CSSMediaRule::create(toStyleRuleMedia(self), parentSheet);
break;
case Supports:
- rule = CSSSupportsRule::create(static_cast<StyleRuleSupports*>(self), parentSheet);
- break;
- case Region:
- rule = CSSRegionRule::create(static_cast<StyleRuleRegion*>(self), parentSheet);
+ rule = CSSSupportsRule::create(toStyleRuleSupports(self), parentSheet);
break;
case Import:
- rule = CSSImportRule::create(static_cast<StyleRuleImport*>(self), parentSheet);
+ rule = CSSImportRule::create(toStyleRuleImport(self), parentSheet);
break;
case Keyframes:
- rule = CSSKeyframesRule::create(static_cast<StyleRuleKeyframes*>(self), parentSheet);
+ rule = CSSKeyframesRule::create(toStyleRuleKeyframes(self), parentSheet);
break;
case Viewport:
- rule = CSSViewportRule::create(static_cast<StyleRuleViewport*>(self), parentSheet);
- break;
- case HostInternal:
- rule = CSSHostRule::create(static_cast<StyleRuleHost*>(self), parentSheet);
+ rule = CSSViewportRule::create(toStyleRuleViewport(self), parentSheet);
break;
case Filter:
- rule = CSSFilterRule::create(static_cast<StyleRuleFilter*>(self), parentSheet);
+ rule = CSSFilterRule::create(toStyleRuleFilter(self), parentSheet);
break;
case Unknown:
case Charset:
case Keyframe:
ASSERT_NOT_REACHED();
- return 0;
+ return nullptr;
}
if (parentRule)
rule->setParentRule(parentRule);
{
}
-MutableStylePropertySet* StyleRule::mutableProperties()
+MutableStylePropertySet& StyleRule::mutableProperties()
{
if (!m_properties->isMutable())
m_properties = m_properties->mutableCopy();
- return static_cast<MutableStylePropertySet*>(m_properties.get());
+ return *toMutableStylePropertySet(m_properties.get());
}
-void StyleRule::setProperties(PassRefPtr<StylePropertySet> properties)
+void StyleRule::setProperties(PassRefPtrWillBeRawPtr<StylePropertySet> properties)
{
m_properties = properties;
}
+void StyleRule::traceAfterDispatch(Visitor* visitor)
+{
+ visitor->trace(m_properties);
+ StyleRuleBase::traceAfterDispatch(visitor);
+}
+
StyleRulePage::StyleRulePage()
: StyleRuleBase(Page)
{
{
}
-MutableStylePropertySet* StyleRulePage::mutableProperties()
+MutableStylePropertySet& StyleRulePage::mutableProperties()
{
if (!m_properties->isMutable())
m_properties = m_properties->mutableCopy();
- return static_cast<MutableStylePropertySet*>(m_properties.get());
+ return *toMutableStylePropertySet(m_properties.get());
}
-void StyleRulePage::setProperties(PassRefPtr<StylePropertySet> properties)
+void StyleRulePage::setProperties(PassRefPtrWillBeRawPtr<StylePropertySet> properties)
{
m_properties = properties;
}
+void StyleRulePage::traceAfterDispatch(Visitor* visitor)
+{
+ visitor->trace(m_properties);
+ StyleRuleBase::traceAfterDispatch(visitor);
+}
+
StyleRuleFontFace::StyleRuleFontFace()
: StyleRuleBase(FontFace)
{
{
}
-MutableStylePropertySet* StyleRuleFontFace::mutableProperties()
+MutableStylePropertySet& StyleRuleFontFace::mutableProperties()
{
if (!m_properties->isMutable())
m_properties = m_properties->mutableCopy();
- return static_cast<MutableStylePropertySet*>(m_properties.get());
+ return *toMutableStylePropertySet(m_properties);
}
-void StyleRuleFontFace::setProperties(PassRefPtr<StylePropertySet> properties)
+void StyleRuleFontFace::setProperties(PassRefPtrWillBeRawPtr<StylePropertySet> properties)
{
m_properties = properties;
}
-StyleRuleGroup::StyleRuleGroup(Type type, Vector<RefPtr<StyleRuleBase> >& adoptRule)
+void StyleRuleFontFace::traceAfterDispatch(Visitor* visitor)
+{
+ visitor->trace(m_properties);
+ StyleRuleBase::traceAfterDispatch(visitor);
+}
+
+StyleRuleGroup::StyleRuleGroup(Type type, WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase> >& adoptRule)
: StyleRuleBase(type)
{
m_childRules.swap(adoptRule);
m_childRules[i] = o.m_childRules[i]->copy();
}
-void StyleRuleGroup::wrapperInsertRule(unsigned index, PassRefPtr<StyleRuleBase> rule)
+void StyleRuleGroup::wrapperInsertRule(unsigned index, PassRefPtrWillBeRawPtr<StyleRuleBase> rule)
{
m_childRules.insert(index, rule);
}
m_childRules.remove(index);
}
-StyleRuleMedia::StyleRuleMedia(PassRefPtr<MediaQuerySet> media, Vector<RefPtr<StyleRuleBase> >& adoptRules)
+void StyleRuleGroup::traceAfterDispatch(Visitor* visitor)
+{
+ visitor->trace(m_childRules);
+ StyleRuleBase::traceAfterDispatch(visitor);
+}
+
+StyleRuleMedia::StyleRuleMedia(PassRefPtrWillBeRawPtr<MediaQuerySet> media, WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase> >& adoptRules)
: StyleRuleGroup(Media, adoptRules)
, m_mediaQueries(media)
{
m_mediaQueries = o.m_mediaQueries->copy();
}
-StyleRuleSupports::StyleRuleSupports(const String& conditionText, bool conditionIsSupported, Vector<RefPtr<StyleRuleBase> >& adoptRules)
+void StyleRuleMedia::traceAfterDispatch(Visitor* visitor)
+{
+ visitor->trace(m_mediaQueries);
+ StyleRuleGroup::traceAfterDispatch(visitor);
+}
+
+StyleRuleSupports::StyleRuleSupports(const String& conditionText, bool conditionIsSupported, WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase> >& adoptRules)
: StyleRuleGroup(Supports, adoptRules)
, m_conditionText(conditionText)
, m_conditionIsSupported(conditionIsSupported)
{
}
-StyleRuleRegion::StyleRuleRegion(Vector<OwnPtr<CSSParserSelector> >* selectors, Vector<RefPtr<StyleRuleBase> >& adoptRules)
- : StyleRuleGroup(Region, adoptRules)
-{
- ASSERT(RuntimeEnabledFeatures::cssRegionsEnabled());
- m_selectorList.adoptSelectorVector(*selectors);
-}
-
-StyleRuleRegion::StyleRuleRegion(const StyleRuleRegion& o)
- : StyleRuleGroup(o)
- , m_selectorList(o.m_selectorList)
-{
- ASSERT(RuntimeEnabledFeatures::cssRegionsEnabled());
-}
-
StyleRuleViewport::StyleRuleViewport()
: StyleRuleBase(Viewport)
{
{
}
-MutableStylePropertySet* StyleRuleViewport::mutableProperties()
+MutableStylePropertySet& StyleRuleViewport::mutableProperties()
{
if (!m_properties->isMutable())
m_properties = m_properties->mutableCopy();
- return static_cast<MutableStylePropertySet*>(m_properties.get());
+ return *toMutableStylePropertySet(m_properties);
}
-void StyleRuleViewport::setProperties(PassRefPtr<StylePropertySet> properties)
+void StyleRuleViewport::setProperties(PassRefPtrWillBeRawPtr<StylePropertySet> properties)
{
m_properties = properties;
}
+void StyleRuleViewport::traceAfterDispatch(Visitor* visitor)
+{
+ visitor->trace(m_properties);
+ StyleRuleBase::traceAfterDispatch(visitor);
+}
+
StyleRuleFilter::StyleRuleFilter(const String& filterName)
: StyleRuleBase(Filter)
, m_filterName(filterName)
{
}
-MutableStylePropertySet* StyleRuleFilter::mutableProperties()
+MutableStylePropertySet& StyleRuleFilter::mutableProperties()
{
if (!m_properties->isMutable())
m_properties = m_properties->mutableCopy();
- return static_cast<MutableStylePropertySet*>(m_properties.get());
+ return *toMutableStylePropertySet(m_properties);
}
-void StyleRuleFilter::setProperties(PassRefPtr<StylePropertySet> properties)
+void StyleRuleFilter::setProperties(PassRefPtrWillBeRawPtr<StylePropertySet> properties)
{
m_properties = properties;
}
-} // namespace WebCore
+void StyleRuleFilter::traceAfterDispatch(Visitor* visitor)
+{
+ visitor->trace(m_properties);
+ StyleRuleBase::traceAfterDispatch(visitor);
+}
+
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff