Changeset 189987 in webkit

Timestamp:

Sep 18, 2015 3:25:08 PM (9 years ago)

Author:

Antti Koivisto

Message:

Support style isolation in shadow trees
​https://bugs.webkit.org/show_bug.cgi?id=149353

Reviewed by Ryosuke Niwa.

Allow ShadowRoots to have their own StyleResolvers.

This patch just adds the mechanism, all shadow roots still use the document resolver.

• css/StyleResolver.h:

(WebCore::StyleResolverParentPusher::push):
(WebCore::StyleResolverParentPusher::~StyleResolverParentPusher):

• dom/Element.cpp:

(WebCore::Element::absoluteLinkURL):
(WebCore::Element::styleResolver):

Helper function for getting the right StyleResolver for the element.

(WebCore::Element::resolveStyle):

Helper function for resolving element style.

• dom/Element.h:
• dom/ShadowRoot.cpp:

(WebCore::ShadowRoot::~ShadowRoot):
(WebCore::ShadowRoot::styleResolver):
(WebCore::ShadowRoot::cloneNode):

• dom/ShadowRoot.h:

(WebCore::ShadowRoot::resetStyleInheritance):

• editing/EditingStyle.cpp:

(WebCore::styleFromMatchedRulesForElement):

• html/HTMLTitleElement.cpp:

(WebCore::HTMLTitleElement::computedTextWithDirection):

• html/canvas/CanvasRenderingContext2D.cpp:

(WebCore::CanvasRenderingContext2D::setFont):

• inspector/InspectorCSSAgent.cpp:

(WebCore::InspectorCSSAgent::getMatchedStylesForNode):

• page/animation/KeyframeAnimation.cpp:

(WebCore::KeyframeAnimation::KeyframeAnimation):

• rendering/RenderElement.cpp:

(WebCore::RenderElement::getUncachedPseudoStyle):
(WebCore::RenderElement::containingBlockForFixedPosition):

• rendering/RenderNamedFlowFragment.cpp:

(WebCore::RenderNamedFlowFragment::checkRegionStyle):
(WebCore::RenderNamedFlowFragment::computeStyleInRegion):

• style/StyleResolveTree.cpp:

(WebCore::Style::styleForElement):

• svg/SVGElement.cpp:

(WebCore::SVGElement::customStyleForRenderer):
(WebCore::SVGElement::animatedSMILStyleProperties):

• svg/SVGElementRareData.h:

(WebCore::SVGElementRareData::overrideComputedStyle):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/StyleResolver.h (modified) (2 diffs)
• dom/Element.cpp (modified) (1 diff)
• dom/Element.h (modified) (1 diff)
• dom/ShadowRoot.cpp (modified) (2 diffs)
• dom/ShadowRoot.h (modified) (2 diffs)
• editing/EditingStyle.cpp (modified) (1 diff)
• html/HTMLTitleElement.cpp (modified) (1 diff)
• html/canvas/CanvasRenderingContext2D.cpp (modified) (1 diff)
• inspector/InspectorCSSAgent.cpp (modified) (2 diffs)
• page/animation/KeyframeAnimation.cpp (modified) (1 diff)
• rendering/RenderElement.cpp (modified) (1 diff)
• rendering/RenderNamedFlowFragment.cpp (modified) (2 diffs)
• style/StyleResolveTree.cpp (modified) (1 diff)
• svg/SVGElement.cpp (modified) (1 diff)
• svg/SVGElementRareData.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-09-18  Antti Koivisto  <antti@apple.com>
+
+        Support style isolation in shadow trees
+        https://bugs.webkit.org/show_bug.cgi?id=149353
+
+        Reviewed by Ryosuke Niwa.
+
+        Allow ShadowRoots to have their own StyleResolvers.
+
+        This patch just adds the mechanism, all shadow roots still use the document resolver.
+
+        * css/StyleResolver.h:
+        (WebCore::StyleResolverParentPusher::push):
+        (WebCore::StyleResolverParentPusher::~StyleResolverParentPusher):
+        * dom/Element.cpp:
+        (WebCore::Element::absoluteLinkURL):
+        (WebCore::Element::styleResolver):
+
+            Helper function for getting the right StyleResolver for the element.
+
+        (WebCore::Element::resolveStyle):
+
+            Helper function for resolving element style.
+
+        * dom/Element.h:
+        * dom/ShadowRoot.cpp:
+        (WebCore::ShadowRoot::~ShadowRoot):
+        (WebCore::ShadowRoot::styleResolver):
+        (WebCore::ShadowRoot::cloneNode):
+        * dom/ShadowRoot.h:
+        (WebCore::ShadowRoot::resetStyleInheritance):
+        * editing/EditingStyle.cpp:
+        (WebCore::styleFromMatchedRulesForElement):
+        * html/HTMLTitleElement.cpp:
+        (WebCore::HTMLTitleElement::computedTextWithDirection):
+        * html/canvas/CanvasRenderingContext2D.cpp:
+        (WebCore::CanvasRenderingContext2D::setFont):
+        * inspector/InspectorCSSAgent.cpp:
+        (WebCore::InspectorCSSAgent::getMatchedStylesForNode):
+        * page/animation/KeyframeAnimation.cpp:
+        (WebCore::KeyframeAnimation::KeyframeAnimation):
+        * rendering/RenderElement.cpp:
+        (WebCore::RenderElement::getUncachedPseudoStyle):
+        (WebCore::RenderElement::containingBlockForFixedPosition):
+        * rendering/RenderNamedFlowFragment.cpp:
+        (WebCore::RenderNamedFlowFragment::checkRegionStyle):
+        (WebCore::RenderNamedFlowFragment::computeStyleInRegion):
+        * style/StyleResolveTree.cpp:
+        (WebCore::Style::styleForElement):
+        * svg/SVGElement.cpp:
+        (WebCore::SVGElement::customStyleForRenderer):
+        (WebCore::SVGElement::animatedSMILStyleProperties):
+        * svg/SVGElementRareData.h:
+        (WebCore::SVGElementRareData::overrideComputedStyle):
+
 2015-09-18  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebCore/css/StyleResolver.h

@@ -579 +579 @@
         if (m_pushedStyleResolver)
             return;
-        m_pushedStyleResolver = &m_parent->document().ensureStyleResolver();
+        m_pushedStyleResolver = &m_parent->styleResolver();
         m_pushedStyleResolver->pushParentElement(m_parent);
     }
@@ -588 +588 @@
         // This tells us that our pushed style selector is in a bad state,
         // so we should just bail out in that scenario.
-        ASSERT(m_pushedStyleResolver == &m_parent->document().ensureStyleResolver());
-        if (m_pushedStyleResolver != &m_parent->document().ensureStyleResolver())
-            return;
+        ASSERT(m_pushedStyleResolver == &m_parent->styleResolver());
         m_pushedStyleResolver->popParentElement(m_parent);
     }

trunk/Source/WebCore/dom/Element.cpp

@@ -1382 +1382 @@
 }
 
+StyleResolver& Element::styleResolver()
+{
+    if (auto* shadowRoot = containingShadowRoot())
+        return shadowRoot->styleResolver();
+
+    return document().ensureStyleResolver();
+}
+
+Ref<RenderStyle> Element::resolveStyle(RenderStyle* parentStyle)
+{
+    return styleResolver().styleForElement(this, parentStyle);
+}
+
 // Returns true is the given attribute is an event handler.
 // We consider an event handler any attribute that begins with "on".

trunk/Source/WebCore/dom/Element.h

@@ -488 +488 @@
     WEBCORE_EXPORT URL absoluteLinkURL() const;
 
+    StyleResolver& styleResolver();
+    Ref<RenderStyle> resolveStyle(RenderStyle* parentStyle);
+
 protected:
     Element(const QualifiedName&, Document&, ConstructionType);

trunk/Source/WebCore/dom/ShadowRoot.cpp

@@ -40 +40 @@
 struct SameSizeAsShadowRoot : public DocumentFragment, public TreeScope {
     unsigned countersAndFlags[1];
+    void* styleResolver;
     void* host;
 #if ENABLE(SHADOW_DOM)
@@ -69 +70 @@
     // destructed tree scope in each descendant.
     removeDetachedChildren();
+}
+
+StyleResolver& ShadowRoot::styleResolver()
+{
+    if (m_styleResolver)
+        return *m_styleResolver;
+
+    return document().ensureStyleResolver();
 }
 

trunk/Source/WebCore/dom/ShadowRoot.h

@@ -56 +56 @@
     virtual ~ShadowRoot();
 
+    StyleResolver& styleResolver();
+
     bool resetStyleInheritance() const { return m_resetStyleInheritance; }
     void setResetStyleInheritance(bool);
@@ -100 +102 @@
     Type m_type;
 
+    std::unique_ptr<StyleResolver> m_styleResolver;
+
     Element* m_host;
 

trunk/Source/WebCore/editing/EditingStyle.cpp

@@ -1278 +1278 @@
 {
     RefPtr<MutableStyleProperties> style = MutableStyleProperties::create();
-    auto matchedRules = element->document().ensureStyleResolver().styleRulesForElement(element, rulesToInclude);
+    auto matchedRules = element->styleResolver().styleRulesForElement(element, rulesToInclude);
     for (unsigned i = 0; i < matchedRules.size(); ++i) {
         if (matchedRules[i]->isStyleRule())

trunk/Source/WebCore/html/HTMLTitleElement.cpp

@@ -83 +83 @@
         direction = computedStyle->direction();
     else {
-        Ref<RenderStyle> style(document().ensureStyleResolver().styleForElement(this, parentElement() ? parentElement()->renderStyle() : nullptr));
+        auto style = resolveStyle(parentElement() ? parentElement()->renderStyle() : nullptr);
         direction = style.get().direction();
     }

trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

@@ -2164 +2164 @@
 
     // Now map the font property longhands into the style.
-    StyleResolver& styleResolver = canvas()->document().ensureStyleResolver();
+    StyleResolver& styleResolver = canvas()->styleResolver();
     styleResolver.applyPropertyToStyle(CSSPropertyFontFamily, parsedStyle->getPropertyCSSValue(CSSPropertyFontFamily).get(), &newStyle.get());
     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontStyle, parsedStyle->getPropertyCSSValue(CSSPropertyFontStyle).get());

trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp

@@ -572 +572 @@
 
     // Matched rules.
-    StyleResolver& styleResolver = element->document().ensureStyleResolver();
+    StyleResolver& styleResolver = element->styleResolver();
     auto matchedRules = styleResolver.pseudoStyleRulesForElement(element, elementPseudoId, StyleResolver::AllCSSRules);
     matchedCSSRules = buildArrayForMatchedRuleList(matchedRules, styleResolver, element, elementPseudoId);
@@ -599 +599 @@
             Element* parentElement = element->parentElement();
             while (parentElement) {
-                StyleResolver& parentStyleResolver = parentElement->document().ensureStyleResolver();
+                StyleResolver& parentStyleResolver = parentElement->styleResolver();
                 auto parentMatchedRules = parentStyleResolver.styleRulesForElement(parentElement, StyleResolver::AllCSSRules);
                 auto entry = Inspector::Protocol::CSS::InheritedStyleEntry::create()

trunk/Source/WebCore/page/animation/KeyframeAnimation.cpp

@@ -50 +50 @@
     // Get the keyframe RenderStyles
     if (m_object && m_object->element())
-        m_object->document().ensureStyleResolver().keyframeStylesForAnimation(m_object->element(), unanimatedStyle, m_keyframes);
+        m_object->element()->styleResolver().keyframeStylesForAnimation(m_object->element(), unanimatedStyle, m_keyframes);
 
     // Update the m_transformFunctionListValid flag based on whether the function lists in the keyframes match.

trunk/Source/WebCore/rendering/RenderElement.cpp

@@ -1538 +1538 @@
         return nullptr;
 
+    auto& styleResolver = element()->styleResolver();
+
     if (pseudoStyleRequest.pseudoId == FIRST_LINE_INHERITED) {
-        RefPtr<RenderStyle> result = document().ensureStyleResolver().styleForElement(element(), parentStyle, DisallowStyleSharing);
+        RefPtr<RenderStyle> result = styleResolver.styleForElement(element(), parentStyle, DisallowStyleSharing);
         result->setStyleType(FIRST_LINE_INHERITED);
         return result.release();
     }
 
-    return document().ensureStyleResolver().pseudoStyleForElement(element(), pseudoStyleRequest, parentStyle);
+    return styleResolver.pseudoStyleForElement(element(), pseudoStyleRequest, parentStyle);
 }
 

trunk/Source/WebCore/rendering/RenderNamedFlowFragment.cpp

@@ -343 +343 @@
     // FIXME: Region styling doesn't work for pseudo elements.
     if (!isPseudoElement())
-        customRegionStyle = view().document().ensureStyleResolver().checkRegionStyle(generatingElement());
+        customRegionStyle = generatingElement()->styleResolver().checkRegionStyle(generatingElement());
     setHasCustomRegionStyle(customRegionStyle);
     downcast<RenderNamedFlowThread>(*m_flowThread).checkRegionsWithStyling();
@@ -353 +353 @@
 
     // FIXME: Region styling fails for pseudo-elements because the renderers don't have a node.
-    RefPtr<RenderStyle> renderObjectRegionStyle = renderer.view().document().ensureStyleResolver().styleForElement(renderer.element(), &parentStyle, DisallowStyleSharing, MatchAllRules, this);
+    RefPtr<RenderStyle> renderObjectRegionStyle = renderer.element()->styleResolver().styleForElement(renderer.element(), &parentStyle, DisallowStyleSharing, MatchAllRules, this);
 
     return renderObjectRegionStyle.release();

trunk/Source/WebCore/style/StyleResolveTree.cpp

@@ -142 +142 @@
             return style.releaseNonNull();
     }
-    return element.document().ensureStyleResolver().styleForElement(&element, &inheritedStyle);
+    return element.resolveStyle(&inheritedStyle);
 }
 

trunk/Source/WebCore/svg/SVGElement.cpp

@@ -793 +793 @@
 {
     if (!correspondingElement())
-        return document().ensureStyleResolver().styleForElement(this, &parentStyle);
-
-    return document().ensureStyleResolver().styleForElement(correspondingElement(), &parentStyle, DisallowStyleSharing);
+        return resolveStyle(&parentStyle);
+
+    return styleResolver().styleForElement(correspondingElement(), &parentStyle, DisallowStyleSharing);
 }
 

trunk/Source/WebCore/svg/SVGElementRareData.h

@@ -73 +73 @@
         if (!m_overrideComputedStyle || m_needsOverrideComputedStyleUpdate) {
             // The style computed here contains no CSS Animations/Transitions or SMIL induced rules - this is needed to compute the "base value" for the SMIL animation sandwhich model.
-            m_overrideComputedStyle = element->document().ensureStyleResolver().styleForElement(element, parentStyle, DisallowStyleSharing, MatchAllRulesExcludingSMIL);
+            m_overrideComputedStyle = element->styleResolver().styleForElement(element, parentStyle, DisallowStyleSharing, MatchAllRulesExcludingSMIL);
             m_needsOverrideComputedStyleUpdate = false;
         }