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); }