void reattachRenderTree(Element* current, const AttachContext& context)
{
AttachContext reattachContext(context);
reattachContext.performingReattach = true;
if (current->attached())
detachRenderTree(current, reattachContext);
attachRenderTree(current, reattachContext);
}
static void detachChildren(ContainerNode& current, DetachType detachType)
{
for (Node* child = current.firstChild(); child; child = child->nextSibling()) {
if (child->isTextNode()) {
Style::detachTextRenderer(*toText(child));
continue;
}
if (child->isElementNode())
detachRenderTree(*toElement(child), detachType);
}
current.clearChildNeedsStyleRecalc();
}
static void detachChildren(Element* current, const AttachContext& context)
{
AttachContext childrenContext(context);
childrenContext.resolvedStyle = 0;
for (Node* child = current->firstChild(); child; child = child->nextSibling()) {
if (child->isTextNode()) {
toText(child)->detachText();
continue;
}
if (child->isElementNode())
detachRenderTree(toElement(child), childrenContext);
}
current->clearChildNeedsStyleRecalc();
}
static void detachShadowRoot(ShadowRoot* shadowRoot, const AttachContext& context)
{
if (!shadowRoot->attached())
return;
Style::AttachContext childrenContext(context);
childrenContext.resolvedStyle = 0;
for (Node* child = shadowRoot->firstChild(); child; child = child->nextSibling()) {
if (child->isTextNode()) {
toText(child)->detachText();
continue;
}
if (child->isElementNode())
detachRenderTree(toElement(child), context);
}
shadowRoot->clearChildNeedsStyleRecalc();
shadowRoot->setAttached(false);
}
static Change resolveLocal(Element& current, Change inheritedChange)
{
Change localChange = Detach;
RefPtr<RenderStyle> newStyle;
RefPtr<RenderStyle> currentStyle = current.renderStyle();
Document& document = current.document();
if (currentStyle) {
newStyle = current.styleForRenderer();
localChange = determineChange(currentStyle.get(), newStyle.get(), document.settings());
}
if (localChange == Detach) {
if (current.attached())
detachRenderTree(current, ReattachDetach);
attachRenderTree(current, newStyle.get());
return Detach;
}
if (RenderObject* renderer = current.renderer()) {
if (localChange != NoChange || pseudoStyleCacheIsInvalid(renderer, newStyle.get()) || (inheritedChange == Force && renderer->requiresForcedStyleRecalcPropagation()) || current.styleChangeType() == SyntheticStyleChange)
renderer->setAnimatableStyle(newStyle.get());
else if (current.needsStyleRecalc()) {
// Although no change occurred, we use the new style so that the cousin style sharing code won't get
// fooled into believing this style is the same.
renderer->setStyleInternal(newStyle.get());
}
}
// If "rem" units are used anywhere in the document, and if the document element's font size changes, then go ahead and force font updating
// all the way down the tree. This is simpler than having to maintain a cache of objects (and such font size changes should be rare anyway).
if (document.styleSheetCollection()->usesRemUnits() && document.documentElement() == ¤t && localChange != NoChange && currentStyle && newStyle && currentStyle->fontSize() != newStyle->fontSize()) {
// Cached RenderStyles may depend on the re units.
if (StyleResolver* styleResolver = document.styleResolverIfExists())
styleResolver->invalidateMatchedPropertiesCache();
return Force;
}
if (inheritedChange == Force)
return Force;
if (current.styleChangeType() >= FullStyleChange)
return Force;
return localChange;
}
void reattachRenderTree(Element& current)
{
if (current.attached())
detachRenderTree(current, ReattachDetach);
attachRenderTree(current, nullptr);
}
void detachRenderTreeInReattachMode(Element& element)
{
detachRenderTree(element, ReattachDetach);
}
void detachRenderTree(Element& element)
{
detachRenderTree(element, NormalDetach);
}
