webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 184 insertions, 98 deletions

diff --git a/Source/WebCore/css/StyleRule.cpp b/Source/WebCore/css/StyleRule.cpp
index 172498507..60d1dbb42 100644
--- a/Source/WebCore/css/StyleRule.cpp
+++ b/Source/WebCore/css/StyleRule.cpp
@@ -22,84 +22,85 @@
 #include "config.h"
 #include "StyleRule.h"
 
-#include "CSSCharsetRule.h"
+#include "CSSDeferredParser.h"
 #include "CSSFontFaceRule.h"
-#include "CSSHostRule.h"
 #include "CSSImportRule.h"
+#include "CSSKeyframeRule.h"
+#include "CSSKeyframesRule.h"
 #include "CSSMediaRule.h"
+#include "CSSNamespaceRule.h"
 #include "CSSPageRule.h"
 #include "CSSStyleRule.h"
 #include "CSSSupportsRule.h"
 #include "CSSUnknownRule.h"
+#include "MediaList.h"
 #include "StyleProperties.h"
 #include "StyleRuleImport.h"
-#include "WebKitCSSKeyframeRule.h"
-#include "WebKitCSSKeyframesRule.h"
 #include "WebKitCSSRegionRule.h"
 #include "WebKitCSSViewportRule.h"
 
 namespace WebCore {
 
 struct SameSizeAsStyleRuleBase : public WTF::RefCountedBase {
-    unsigned bitfields;
+    unsigned bitfields : 5;
 };
 
 COMPILE_ASSERT(sizeof(StyleRuleBase) == sizeof(SameSizeAsStyleRuleBase), StyleRuleBase_should_stay_small);
 
-PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet) const
+RefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet) const
 {
-    return createCSSOMWrapper(parentSheet, 0);
+    return createCSSOMWrapper(parentSheet, nullptr);
 }
 
-PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSRule* parentRule) const
+RefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSRule* parentRule) const
 { 
-    return createCSSOMWrapper(0, parentRule);
+    return createCSSOMWrapper(nullptr, parentRule);
 }
 
 void StyleRuleBase::destroy()
 {
     switch (type()) {
     case Style:
-        delete static_cast<StyleRule*>(this);
+        delete downcast<StyleRule>(this);
         return;
     case Page:
-        delete static_cast<StyleRulePage*>(this);
+        delete downcast<StyleRulePage>(this);
         return;
     case FontFace:
-        delete static_cast<StyleRuleFontFace*>(this);
+        delete downcast<StyleRuleFontFace>(this);
         return;
     case Media:
-        delete static_cast<StyleRuleMedia*>(this);
+        delete downcast<StyleRuleMedia>(this);
         return;
-#if ENABLE(CSS3_CONDITIONAL_RULES)
     case Supports:
-        delete static_cast<StyleRuleSupports*>(this);
+        delete downcast<StyleRuleSupports>(this);
         return;
-#endif
 #if ENABLE(CSS_REGIONS)
     case Region:
-        delete static_cast<StyleRuleRegion*>(this);
+        delete downcast<StyleRuleRegion>(this);
         return;
 #endif
     case Import:
-        delete static_cast<StyleRuleImport*>(this);
+        delete downcast<StyleRuleImport>(this);
         return;
     case Keyframes:
-        delete static_cast<StyleRuleKeyframes*>(this);
-        return;
-#if ENABLE(SHADOW_DOM)
-    case HostInternal:
-        delete static_cast<StyleRuleHost*>(this);
+        delete downcast<StyleRuleKeyframes>(this);
         return;
-#endif
 #if ENABLE(CSS_DEVICE_ADAPTATION)
     case Viewport:
-        delete static_cast<StyleRuleViewport*>(this);
+        delete downcast<StyleRuleViewport>(this);
         return;
 #endif
-    case Unknown:
-    case Charset:
+    case Namespace:
+        delete downcast<StyleRuleNamespace>(this);
+        return;
     case Keyframe:
+        delete downcast<StyleRuleKeyframe>(this);
+        return;
+    case Charset:
+        delete downcast<StyleRuleCharset>(this);
+        return;
+    case Unknown:
 #if !ENABLE(CSS_REGIONS)
     case Region:
 #endif
@@ -109,37 +110,32 @@ void StyleRuleBase::destroy()
     ASSERT_NOT_REACHED();
 }
 
-PassRef<StyleRuleBase> StyleRuleBase::copy() const
+Ref<StyleRuleBase> StyleRuleBase::copy() const
 {
     switch (type()) {
     case Style:
-        return static_cast<const StyleRule*>(this)->copy();
+        return downcast<StyleRule>(*this).copy();
     case Page:
-        return static_cast<const StyleRulePage*>(this)->copy();
+        return downcast<StyleRulePage>(*this).copy();
     case FontFace:
-        return static_cast<const StyleRuleFontFace*>(this)->copy();
+        return downcast<StyleRuleFontFace>(*this).copy();
     case Media:
-        return static_cast<const StyleRuleMedia*>(this)->copy();
-#if ENABLE(CSS3_CONDITIONAL_RULES)
+        return downcast<StyleRuleMedia>(*this).copy();
     case Supports:
-        return static_cast<const StyleRuleSupports*>(this)->copy();
-#endif
+        return downcast<StyleRuleSupports>(*this).copy();
 #if ENABLE(CSS_REGIONS)
     case Region:
-        return static_cast<const StyleRuleRegion*>(this)->copy();
+        return downcast<StyleRuleRegion>(*this).copy();
 #endif
     case Keyframes:
-        return static_cast<const StyleRuleKeyframes*>(this)->copy();
-#if ENABLE(SHADOW_DOM)
-    case HostInternal:
-        return static_cast<const StyleRuleHost*>(this)->copy();
-#endif
+        return downcast<StyleRuleKeyframes>(*this).copy();
 #if ENABLE(CSS_DEVICE_ADAPTATION)
     case Viewport:
-        return static_cast<const StyleRuleViewport*>(this)->copy();
+        return downcast<StyleRuleViewport>(*this).copy();
 #endif
     case Import:
-        // FIXME: Copy import rules.
+    case Namespace:
+        // FIXME: Copy import and namespace rules.
         break;
     case Unknown:
     case Charset:
@@ -150,53 +146,47 @@ PassRef<StyleRuleBase> StyleRuleBase::copy() const
         break;
     }
     CRASH();
-    // HACK: EFL won't build without this (old GCC with crappy -Werror=return-type)
-    return PassRef<StyleRuleBase>(*static_cast<StyleRuleBase*>(nullptr));
 }
 
-PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const
+RefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const
 {
     RefPtr<CSSRule> rule;
-    StyleRuleBase* self = const_cast<StyleRuleBase*>(this);
+    StyleRuleBase& self = const_cast<StyleRuleBase&>(*this);
     switch (type()) {
     case Style:
-        rule = CSSStyleRule::create(static_cast<StyleRule*>(self), parentSheet);
+        rule = CSSStyleRule::create(downcast<StyleRule>(self), parentSheet);
         break;
     case Page:
-        rule = CSSPageRule::create(static_cast<StyleRulePage*>(self), parentSheet);
+        rule = CSSPageRule::create(downcast<StyleRulePage>(self), parentSheet);
         break;
     case FontFace:
-        rule = CSSFontFaceRule::create(static_cast<StyleRuleFontFace*>(self), parentSheet);
+        rule = CSSFontFaceRule::create(downcast<StyleRuleFontFace>(self), parentSheet);
         break;
     case Media:
-        rule = CSSMediaRule::create(static_cast<StyleRuleMedia*>(self), parentSheet);
+        rule = CSSMediaRule::create(downcast<StyleRuleMedia>(self), parentSheet);
         break;
-#if ENABLE(CSS3_CONDITIONAL_RULES)
     case Supports:
-        rule = CSSSupportsRule::create(static_cast<StyleRuleSupports*>(self), parentSheet);
+        rule = CSSSupportsRule::create(downcast<StyleRuleSupports>(self), parentSheet);
         break;
-#endif
 #if ENABLE(CSS_REGIONS)
     case Region:
-        rule = WebKitCSSRegionRule::create(static_cast<StyleRuleRegion*>(self), parentSheet);
+        rule = WebKitCSSRegionRule::create(downcast<StyleRuleRegion>(self), parentSheet);
         break;
 #endif
     case Import:
-        rule = CSSImportRule::create(static_cast<StyleRuleImport*>(self), parentSheet);
+        rule = CSSImportRule::create(downcast<StyleRuleImport>(self), parentSheet);
         break;
     case Keyframes:
-        rule = WebKitCSSKeyframesRule::create(static_cast<StyleRuleKeyframes*>(self), parentSheet);
+        rule = CSSKeyframesRule::create(downcast<StyleRuleKeyframes>(self), parentSheet);
         break;
 #if ENABLE(CSS_DEVICE_ADAPTATION)
     case Viewport:
-        rule = WebKitCSSViewportRule::create(static_cast<StyleRuleViewport*>(self), parentSheet);
+        rule = WebKitCSSViewportRule::create(downcast<StyleRuleViewport>(self), parentSheet);
         break;
 #endif
-#if ENABLE(SHADOW_DOM)
-    case HostInternal:
-        rule = CSSHostRule::create(static_cast<StyleRuleHost*>(self), parentSheet);
+    case Namespace:
+        rule = CSSNamespaceRule::create(downcast<StyleRuleNamespace>(self), parentSheet);
         break;
-#endif
     case Unknown:
     case Charset:
     case Keyframe:
@@ -204,11 +194,11 @@ PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet
     case Region:
 #endif
         ASSERT_NOT_REACHED();
-        return 0;
+        return nullptr;
     }
     if (parentRule)
         rule->setParentRule(parentRule);
-    return rule.release();
+    return rule;
 }
 
 unsigned StyleRule::averageSizeInBytes()
@@ -216,15 +206,15 @@ unsigned StyleRule::averageSizeInBytes()
     return sizeof(StyleRule) + sizeof(CSSSelector) + StyleProperties::averageSizeInBytes();
 }
 
-StyleRule::StyleRule(int sourceLine, PassRef<StyleProperties> properties)
-    : StyleRuleBase(Style, sourceLine)
-    , m_properties(std::move(properties))
+StyleRule::StyleRule(Ref<StylePropertiesBase>&& properties)
+    : StyleRuleBase(Style)
+    , m_properties(WTFMove(properties))
 {
 }
 
 StyleRule::StyleRule(const StyleRule& o)
     : StyleRuleBase(o)
-    , m_properties(o.m_properties->mutableCopy())
+    , m_properties(o.properties().mutableCopy())
     , m_selectorList(o.m_selectorList)
 {
 }
@@ -233,21 +223,28 @@ StyleRule::~StyleRule()
 {
 }
 
+const StyleProperties& StyleRule::properties() const
+{
+    if (m_properties->type() == DeferredPropertiesType)
+        m_properties = downcast<DeferredStyleProperties>(m_properties.get()).parseDeferredProperties();
+    return downcast<StyleProperties>(m_properties.get());
+}
+
 MutableStyleProperties& StyleRule::mutableProperties()
 {
-    if (!m_properties->isMutable())
-        m_properties = m_properties->mutableCopy();
-    return static_cast<MutableStyleProperties&>(m_properties.get());
+    if (!is<MutableStyleProperties>(m_properties.get()))
+        m_properties = properties().mutableCopy();
+    return downcast<MutableStyleProperties>(m_properties.get());
 }
 
-PassRef<StyleRule> StyleRule::create(int sourceLine, const Vector<const CSSSelector*>& selectors, PassRef<StyleProperties> properties)
+Ref<StyleRule> StyleRule::create(const Vector<const CSSSelector*>& selectors, Ref<StyleProperties>&& properties)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!selectors.isEmpty());
     CSSSelector* selectorListArray = reinterpret_cast<CSSSelector*>(fastMalloc(sizeof(CSSSelector) * selectors.size()));
     for (unsigned i = 0; i < selectors.size(); ++i)
         new (NotNull, &selectorListArray[i]) CSSSelector(*selectors.at(i));
     selectorListArray[selectors.size() - 1].setLastInSelectorList();
-    auto rule = StyleRule::create(sourceLine, std::move(properties));
+    auto rule = StyleRule::create(WTFMove(properties));
     rule.get().parserAdoptSelectorArray(selectorListArray);
     return rule;
 }
@@ -265,7 +262,7 @@ Vector<RefPtr<StyleRule>> StyleRule::splitIntoMultipleRulesWithMaximumSelectorCo
             componentsInThisSelector.append(component);
 
         if (componentsInThisSelector.size() + componentsSinceLastSplit.size() > maxCount && !componentsSinceLastSplit.isEmpty()) {
-            rules.append(create(sourceLine(), componentsSinceLastSplit, const_cast<StyleProperties&>(m_properties.get())));
+            rules.append(create(componentsSinceLastSplit, const_cast<StyleProperties&>(properties())));
             componentsSinceLastSplit.clear();
         }
 
@@ -273,14 +270,14 @@ Vector<RefPtr<StyleRule>> StyleRule::splitIntoMultipleRulesWithMaximumSelectorCo
     }
 
     if (!componentsSinceLastSplit.isEmpty())
-        rules.append(create(sourceLine(), componentsSinceLastSplit, const_cast<StyleProperties&>(m_properties.get())));
+        rules.append(create(componentsSinceLastSplit, const_cast<StyleProperties&>(properties())));
 
     return rules;
 }
 
-StyleRulePage::StyleRulePage(PassRef<StyleProperties> properties)
+StyleRulePage::StyleRulePage(Ref<StyleProperties>&& properties)
     : StyleRuleBase(Page)
-    , m_properties(std::move(properties))
+    , m_properties(WTFMove(properties))
 {
 }
 
@@ -297,14 +294,14 @@ StyleRulePage::~StyleRulePage()
 
 MutableStyleProperties& StyleRulePage::mutableProperties()
 {
-    if (!m_properties->isMutable())
+    if (!is<MutableStyleProperties>(m_properties.get()))
         m_properties = m_properties->mutableCopy();
-    return static_cast<MutableStyleProperties&>(m_properties.get());
+    return downcast<MutableStyleProperties>(m_properties.get());
 }
 
-StyleRuleFontFace::StyleRuleFontFace(PassRef<StyleProperties> properties)
-    : StyleRuleBase(FontFace, 0)
-    , m_properties(std::move(properties))
+StyleRuleFontFace::StyleRuleFontFace(Ref<StyleProperties>&& properties)
+    : StyleRuleBase(FontFace)
+    , m_properties(WTFMove(properties))
 {
 }
 
@@ -320,39 +317,85 @@ StyleRuleFontFace::~StyleRuleFontFace()
 
 MutableStyleProperties& StyleRuleFontFace::mutableProperties()
 {
-    if (!m_properties->isMutable())
+    if (!is<MutableStyleProperties>(m_properties.get()))
         m_properties = m_properties->mutableCopy();
-    return static_cast<MutableStyleProperties&>(m_properties.get());
+    return downcast<MutableStyleProperties>(m_properties.get());
+}
+
+DeferredStyleGroupRuleList::DeferredStyleGroupRuleList(const CSSParserTokenRange& range, CSSDeferredParser& parser)
+    : m_parser(parser)
+{
+    size_t length = range.end() - range.begin();
+    m_tokens.reserveCapacity(length);
+    m_tokens.append(range.begin(), length);
+}
+
+void DeferredStyleGroupRuleList::parseDeferredRules(Vector<RefPtr<StyleRuleBase>>& childRules)
+{
+    m_parser->parseRuleList(m_tokens, childRules);
 }
 
+void DeferredStyleGroupRuleList::parseDeferredKeyframes(StyleRuleKeyframes& keyframesRule)
+{
+    m_parser->parseKeyframeList(m_tokens, keyframesRule);
+}
+    
 StyleRuleGroup::StyleRuleGroup(Type type, Vector<RefPtr<StyleRuleBase>>& adoptRule)
-    : StyleRuleBase(type, 0)
+    : StyleRuleBase(type)
 {
     m_childRules.swap(adoptRule);
 }
 
+StyleRuleGroup::StyleRuleGroup(Type type, std::unique_ptr<DeferredStyleGroupRuleList>&& deferredRules)
+    : StyleRuleBase(type)
+    , m_deferredRules(WTFMove(deferredRules))
+{
+}
+
 StyleRuleGroup::StyleRuleGroup(const StyleRuleGroup& o)
     : StyleRuleBase(o)
 {
-    m_childRules.reserveInitialCapacity(o.m_childRules.size());
-    for (unsigned i = 0, size = o.m_childRules.size(); i < size; ++i)
-        m_childRules.uncheckedAppend(o.m_childRules[i]->copy());
+    m_childRules.reserveInitialCapacity(o.childRules().size());
+    for (auto& childRule : o.childRules())
+        m_childRules.uncheckedAppend(childRule->copy());
+}
+
+const Vector<RefPtr<StyleRuleBase>>& StyleRuleGroup::childRules() const
+{
+    parseDeferredRulesIfNeeded();
+    return m_childRules;
 }
 
-void StyleRuleGroup::wrapperInsertRule(unsigned index, PassRef<StyleRuleBase> rule)
+void StyleRuleGroup::wrapperInsertRule(unsigned index, Ref<StyleRuleBase>&& rule)
 {
-    m_childRules.insert(index, std::move(rule));
+    parseDeferredRulesIfNeeded();
+    m_childRules.insert(index, WTFMove(rule));
 }
     
 void StyleRuleGroup::wrapperRemoveRule(unsigned index)
 {
+    parseDeferredRulesIfNeeded();
     m_childRules.remove(index);
 }
 
-
-StyleRuleMedia::StyleRuleMedia(PassRefPtr<MediaQuerySet> media, Vector<RefPtr<StyleRuleBase>>& adoptRules)
+void StyleRuleGroup::parseDeferredRulesIfNeeded() const
+{
+    if (!m_deferredRules)
+        return;
+    
+    m_deferredRules->parseDeferredRules(m_childRules);
+    m_deferredRules = nullptr;
+}
+    
+StyleRuleMedia::StyleRuleMedia(Ref<MediaQuerySet>&& media, Vector<RefPtr<StyleRuleBase>>& adoptRules)
     : StyleRuleGroup(Media, adoptRules)
-    , m_mediaQueries(media)
+    , m_mediaQueries(WTFMove(media))
+{
+}
+
+StyleRuleMedia::StyleRuleMedia(Ref<MediaQuerySet>&& media, std::unique_ptr<DeferredStyleGroupRuleList>&& deferredRules)
+    : StyleRuleGroup(Media, WTFMove(deferredRules))
+    , m_mediaQueries(WTFMove(media))
 {
 }
 
@@ -364,7 +407,6 @@ StyleRuleMedia::StyleRuleMedia(const StyleRuleMedia& o)
 }
 
 
-#if ENABLE(CSS3_CONDITIONAL_RULES)
 StyleRuleSupports::StyleRuleSupports(const String& conditionText, bool conditionIsSupported, Vector<RefPtr<StyleRuleBase>>& adoptRules)
     : StyleRuleGroup(Supports, adoptRules)
     , m_conditionText(conditionText)
@@ -372,20 +414,32 @@ StyleRuleSupports::StyleRuleSupports(const String& conditionText, bool condition
 {
 }
 
+StyleRuleSupports::StyleRuleSupports(const String& conditionText, bool conditionIsSupported,  std::unique_ptr<DeferredStyleGroupRuleList>&& deferredRules)
+    : StyleRuleGroup(Supports, WTFMove(deferredRules))
+    , m_conditionText(conditionText)
+    , m_conditionIsSupported(conditionIsSupported)
+{
+}
+
 StyleRuleSupports::StyleRuleSupports(const StyleRuleSupports& o)
     : StyleRuleGroup(o)
     , m_conditionText(o.m_conditionText)
     , m_conditionIsSupported(o.m_conditionIsSupported)
 {
 }
-#endif
 
-StyleRuleRegion::StyleRuleRegion(Vector<OwnPtr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules)
+StyleRuleRegion::StyleRuleRegion(Vector<std::unique_ptr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules)
     : StyleRuleGroup(Region, adoptRules)
 {
     m_selectorList.adoptSelectorVector(*selectors);
 }
 
+StyleRuleRegion::StyleRuleRegion(CSSSelectorList& selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules)
+    : StyleRuleGroup(Region, adoptRules)
+    , m_selectorList(WTFMove(selectors))
+{
+}
+
 StyleRuleRegion::StyleRuleRegion(const StyleRuleRegion& o)
     : StyleRuleGroup(o)
     , m_selectorList(o.m_selectorList)
@@ -394,9 +448,9 @@ StyleRuleRegion::StyleRuleRegion(const StyleRuleRegion& o)
 
 
 #if ENABLE(CSS_DEVICE_ADAPTATION)
-StyleRuleViewport::StyleRuleViewport(PassRef<StyleProperties> properties)
+StyleRuleViewport::StyleRuleViewport(Ref<StyleProperties>&& properties)
     : StyleRuleBase(Viewport, 0)
-    , m_properties(std::move(properties))
+    , m_properties(WTFMove(properties))
 {
 }
 
@@ -418,4 +472,36 @@ MutableStyleProperties& StyleRuleViewport::mutableProperties()
 }
 #endif // ENABLE(CSS_DEVICE_ADAPTATION)
 
+StyleRuleCharset::StyleRuleCharset()
+    : StyleRuleBase(Charset)
+{
+}
+
+StyleRuleCharset::StyleRuleCharset(const StyleRuleCharset& o)
+    : StyleRuleBase(o)
+{
+}
+
+StyleRuleCharset::~StyleRuleCharset()
+{
+}
+
+StyleRuleNamespace::StyleRuleNamespace(AtomicString prefix, AtomicString uri)
+    : StyleRuleBase(Namespace)
+    , m_prefix(prefix)
+    , m_uri(uri)
+{
+}
+
+StyleRuleNamespace::StyleRuleNamespace(const StyleRuleNamespace& o)
+    : StyleRuleBase(o)
+    , m_prefix(o.m_prefix)
+    , m_uri(o.m_uri)
+{
+}
+
+StyleRuleNamespace::~StyleRuleNamespace()
+{
+}
+
 } // namespace WebCore