summaryrefslogtreecommitdiffstats
path: root/layout/base/RestyleManager.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /layout/base/RestyleManager.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'layout/base/RestyleManager.cpp')
-rw-r--r--layout/base/RestyleManager.cpp3881
1 files changed, 3881 insertions, 0 deletions
diff --git a/layout/base/RestyleManager.cpp b/layout/base/RestyleManager.cpp
new file mode 100644
index 0000000000..9c313a254c
--- /dev/null
+++ b/layout/base/RestyleManager.cpp
@@ -0,0 +1,3881 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/RestyleManager.h"
+
+#include "mozilla/AnimationUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/ComputedStyleInlines.h"
+#include "mozilla/DocumentStyleRootIterator.h"
+#include "mozilla/EffectSet.h"
+#include "mozilla/GeckoBindings.h"
+#include "mozilla/LayerAnimationInfo.h"
+#include "mozilla/layers/AnimationInfo.h"
+#include "mozilla/layout/ScrollAnchorContainer.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/PresShellInlines.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ServoBindings.h"
+#include "mozilla/ServoStyleSetInlines.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/SVGIntegrationUtils.h"
+#include "mozilla/SVGObserverUtils.h"
+#include "mozilla/SVGTextFrame.h"
+#include "mozilla/SVGUtils.h"
+#include "mozilla/Unused.h"
+#include "mozilla/ViewportFrame.h"
+#include "mozilla/IntegerRange.h"
+#include "mozilla/dom/ChildIterator.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "mozilla/dom/ElementInlines.h"
+#include "mozilla/dom/HTMLBodyElement.h"
+#include "mozilla/dom/HTMLInputElement.h"
+
+#include "ScrollSnap.h"
+#include "nsAnimationManager.h"
+#include "nsBlockFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsContentUtils.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsCSSRendering.h"
+#include "nsDocShell.h"
+#include "nsIFrame.h"
+#include "nsIFrameInlines.h"
+#include "nsImageFrame.h"
+#include "nsPlaceholderFrame.h"
+#include "nsPrintfCString.h"
+#include "nsRefreshDriver.h"
+#include "nsStyleChangeList.h"
+#include "nsStyleUtil.h"
+#include "nsTransitionManager.h"
+#include "StickyScrollContainer.h"
+#include "ActiveLayerTracker.h"
+
+#ifdef ACCESSIBILITY
+# include "nsAccessibilityService.h"
+#endif
+
+using mozilla::layers::AnimationInfo;
+using mozilla::layout::ScrollAnchorContainer;
+
+using namespace mozilla::dom;
+using namespace mozilla::layers;
+
+namespace mozilla {
+
+RestyleManager::RestyleManager(nsPresContext* aPresContext)
+ : mPresContext(aPresContext),
+ mRestyleGeneration(1),
+ mUndisplayedRestyleGeneration(1),
+ mInStyleRefresh(false),
+ mAnimationGeneration(0) {
+ MOZ_ASSERT(mPresContext);
+}
+
+void RestyleManager::ContentInserted(nsIContent* aChild) {
+ MOZ_ASSERT(aChild->GetParentNode());
+ if (aChild->IsElement()) {
+ StyleSet()->MaybeInvalidateForElementInsertion(*aChild->AsElement());
+ }
+ RestyleForInsertOrChange(aChild);
+}
+
+void RestyleManager::ContentAppended(nsIContent* aFirstNewContent) {
+ auto* container = aFirstNewContent->GetParentNode();
+ MOZ_ASSERT(container);
+
+#ifdef DEBUG
+ {
+ for (nsIContent* cur = aFirstNewContent; cur; cur = cur->GetNextSibling()) {
+ NS_ASSERTION(!cur->IsRootOfNativeAnonymousSubtree(),
+ "anonymous nodes should not be in child lists");
+ }
+ }
+#endif
+ StyleSet()->MaybeInvalidateForElementAppend(*aFirstNewContent);
+
+ const auto selectorFlags = container->GetSelectorFlags() &
+ NodeSelectorFlags::AllSimpleRestyleFlagsForAppend;
+ if (!selectorFlags) {
+ return;
+ }
+
+ // The container cannot be a document.
+ MOZ_ASSERT(container->IsElement() || container->IsShadowRoot());
+
+ if (selectorFlags & NodeSelectorFlags::HasEmptySelector) {
+ // see whether we need to restyle the container
+ bool wasEmpty = true; // :empty or :-moz-only-whitespace
+ for (nsIContent* cur = container->GetFirstChild(); cur != aFirstNewContent;
+ cur = cur->GetNextSibling()) {
+ // We don't know whether we're testing :empty or :-moz-only-whitespace,
+ // so be conservative and assume :-moz-only-whitespace (i.e., make
+ // IsSignificantChild less likely to be true, and thus make us more
+ // likely to restyle).
+ if (nsStyleUtil::IsSignificantChild(cur, false)) {
+ wasEmpty = false;
+ break;
+ }
+ }
+ if (wasEmpty && container->IsElement()) {
+ RestyleForEmptyChange(container->AsElement());
+ return;
+ }
+ }
+
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelector) {
+ if (container->IsElement()) {
+ auto* containerElement = container->AsElement();
+ PostRestyleEvent(containerElement, RestyleHint::RestyleSubtree(),
+ nsChangeHint(0));
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelectorNthAll) {
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthDependencyFromSibling(
+ containerElement->GetFirstElementChild());
+ }
+ } else {
+ RestylePreviousSiblings(aFirstNewContent);
+ RestyleSiblingsStartingWith(aFirstNewContent);
+ }
+ // Restyling the container is the most we can do here, so we're done.
+ return;
+ }
+
+ if (selectorFlags & NodeSelectorFlags::HasEdgeChildSelector) {
+ // restyle the last element child before this node
+ for (nsIContent* cur = aFirstNewContent->GetPreviousSibling(); cur;
+ cur = cur->GetPreviousSibling()) {
+ if (cur->IsElement()) {
+ auto* element = cur->AsElement();
+ PostRestyleEvent(element, RestyleHint::RestyleSubtree(),
+ nsChangeHint(0));
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthEdgeDependency(
+ *element);
+ break;
+ }
+ }
+ }
+}
+
+void RestyleManager::RestylePreviousSiblings(nsIContent* aStartingSibling) {
+ for (nsIContent* sibling = aStartingSibling; sibling;
+ sibling = sibling->GetPreviousSibling()) {
+ if (auto* element = Element::FromNode(sibling)) {
+ PostRestyleEvent(element, RestyleHint::RestyleSubtree(), nsChangeHint(0));
+ }
+ }
+}
+
+void RestyleManager::RestyleSiblingsStartingWith(nsIContent* aStartingSibling) {
+ for (nsIContent* sibling = aStartingSibling; sibling;
+ sibling = sibling->GetNextSibling()) {
+ if (auto* element = Element::FromNode(sibling)) {
+ PostRestyleEvent(element, RestyleHint::RestyleSubtree(), nsChangeHint(0));
+ }
+ }
+}
+
+void RestyleManager::RestyleForEmptyChange(Element* aContainer) {
+ PostRestyleEvent(aContainer, RestyleHint::RestyleSubtree(), nsChangeHint(0));
+ StyleSet()->MaybeInvalidateRelativeSelectorForEmptyDependency(*aContainer);
+
+ // In some cases (:empty + E, :empty ~ E), a change in the content of
+ // an element requires restyling its parent's siblings.
+ nsIContent* grandparent = aContainer->GetParent();
+ if (!grandparent || !(grandparent->GetSelectorFlags() &
+ NodeSelectorFlags::HasSlowSelectorLaterSiblings)) {
+ return;
+ }
+ RestyleSiblingsStartingWith(aContainer->GetNextSibling());
+}
+
+void RestyleManager::MaybeRestyleForEdgeChildChange(nsINode* aContainer,
+ nsIContent* aChangedChild) {
+ MOZ_ASSERT(aContainer->GetSelectorFlags() &
+ NodeSelectorFlags::HasEdgeChildSelector);
+ MOZ_ASSERT(aChangedChild->GetParent() == aContainer);
+ // restyle the previously-first element child if it is after this node
+ bool passedChild = false;
+ for (nsIContent* content = aContainer->GetFirstChild(); content;
+ content = content->GetNextSibling()) {
+ if (content == aChangedChild) {
+ passedChild = true;
+ continue;
+ }
+ if (content->IsElement()) {
+ if (passedChild) {
+ auto* element = content->AsElement();
+ PostRestyleEvent(element, RestyleHint::RestyleSubtree(),
+ nsChangeHint(0));
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthEdgeDependency(
+ *element);
+ }
+ break;
+ }
+ }
+ // restyle the previously-last element child if it is before this node
+ passedChild = false;
+ for (nsIContent* content = aContainer->GetLastChild(); content;
+ content = content->GetPreviousSibling()) {
+ if (content == aChangedChild) {
+ passedChild = true;
+ continue;
+ }
+ if (content->IsElement()) {
+ if (passedChild) {
+ auto* element = content->AsElement();
+ PostRestyleEvent(element, RestyleHint::RestyleSubtree(),
+ nsChangeHint(0));
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthEdgeDependency(
+ *element);
+ }
+ break;
+ }
+ }
+}
+
+template <typename CharT>
+bool WhitespaceOnly(const CharT* aBuffer, size_t aUpTo) {
+ for (auto index : IntegerRange(aUpTo)) {
+ if (!dom::IsSpaceCharacter(aBuffer[index])) {
+ return false;
+ }
+ }
+ return true;
+}
+
+template <typename CharT>
+bool WhitespaceOnlyChangedOnAppend(const CharT* aBuffer, size_t aOldLength,
+ size_t aNewLength) {
+ MOZ_ASSERT(aOldLength <= aNewLength);
+ if (!WhitespaceOnly(aBuffer, aOldLength)) {
+ // The old text was already not whitespace-only.
+ return false;
+ }
+
+ return !WhitespaceOnly(aBuffer + aOldLength, aNewLength - aOldLength);
+}
+
+static bool HasAnySignificantSibling(Element* aContainer, nsIContent* aChild) {
+ MOZ_ASSERT(aChild->GetParent() == aContainer);
+ for (nsIContent* child = aContainer->GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ if (child == aChild) {
+ continue;
+ }
+ // We don't know whether we're testing :empty or :-moz-only-whitespace,
+ // so be conservative and assume :-moz-only-whitespace (i.e., make
+ // IsSignificantChild less likely to be true, and thus make us more
+ // likely to restyle).
+ if (nsStyleUtil::IsSignificantChild(child, false)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void RestyleManager::CharacterDataChanged(
+ nsIContent* aContent, const CharacterDataChangeInfo& aInfo) {
+ nsINode* parent = aContent->GetParentNode();
+ MOZ_ASSERT(parent, "How were we notified of a stray node?");
+
+ const auto slowSelectorFlags =
+ parent->GetSelectorFlags() & NodeSelectorFlags::AllSimpleRestyleFlags;
+ if (!(slowSelectorFlags & (NodeSelectorFlags::HasEmptySelector |
+ NodeSelectorFlags::HasEdgeChildSelector))) {
+ // Nothing to do, no other slow selector can change as a result of this.
+ return;
+ }
+
+ if (!aContent->IsText()) {
+ // Doesn't matter to styling (could be a processing instruction or a
+ // comment), it can't change whether any selectors match or don't.
+ return;
+ }
+
+ if (MOZ_UNLIKELY(!parent->IsElement())) {
+ MOZ_ASSERT(parent->IsShadowRoot());
+ return;
+ }
+
+ if (MOZ_UNLIKELY(aContent->IsRootOfNativeAnonymousSubtree())) {
+ // This is an anonymous node and thus isn't in child lists, so isn't taken
+ // into account for selector matching the relevant selectors here.
+ return;
+ }
+
+ // Handle appends specially since they're common and we can know both the old
+ // and the new text exactly.
+ //
+ // TODO(emilio): This could be made much more general if :-moz-only-whitespace
+ // / :-moz-first-node and :-moz-last-node didn't exist. In that case we only
+ // need to know whether we went from empty to non-empty, and that's trivial to
+ // know, with CharacterDataChangeInfo...
+ if (!aInfo.mAppend) {
+ // FIXME(emilio): This restyles unnecessarily if the text node is the only
+ // child of the parent element. Fortunately, it's uncommon to have such
+ // nodes and this not being an append.
+ //
+ // See the testcase in bug 1427625 for a test-case that triggers this.
+ RestyleForInsertOrChange(aContent);
+ return;
+ }
+
+ const nsTextFragment* text = &aContent->AsText()->TextFragment();
+
+ const size_t oldLength = aInfo.mChangeStart;
+ const size_t newLength = text->GetLength();
+
+ const bool emptyChanged = !oldLength && newLength;
+
+ const bool whitespaceOnlyChanged =
+ text->Is2b()
+ ? WhitespaceOnlyChangedOnAppend(text->Get2b(), oldLength, newLength)
+ : WhitespaceOnlyChangedOnAppend(text->Get1b(), oldLength, newLength);
+
+ if (!emptyChanged && !whitespaceOnlyChanged) {
+ return;
+ }
+
+ if (slowSelectorFlags & NodeSelectorFlags::HasEmptySelector) {
+ if (!HasAnySignificantSibling(parent->AsElement(), aContent)) {
+ // We used to be empty, restyle the parent.
+ RestyleForEmptyChange(parent->AsElement());
+ return;
+ }
+ }
+
+ if (slowSelectorFlags & NodeSelectorFlags::HasEdgeChildSelector) {
+ MaybeRestyleForEdgeChildChange(parent, aContent);
+ }
+}
+
+// Restyling for a ContentInserted or CharacterDataChanged notification.
+// This could be used for ContentRemoved as well if we got the
+// notification before the removal happened (and sometimes
+// CharacterDataChanged is more like a removal than an addition).
+// The comments are written and variables are named in terms of it being
+// a ContentInserted notification.
+void RestyleManager::RestyleForInsertOrChange(nsIContent* aChild) {
+ nsINode* container = aChild->GetParentNode();
+ MOZ_ASSERT(container);
+
+ const auto selectorFlags =
+ container->GetSelectorFlags() & NodeSelectorFlags::AllSimpleRestyleFlags;
+ if (!selectorFlags) {
+ return;
+ }
+
+ NS_ASSERTION(!aChild->IsRootOfNativeAnonymousSubtree(),
+ "anonymous nodes should not be in child lists");
+
+ // The container cannot be a document.
+ MOZ_ASSERT(container->IsElement() || container->IsShadowRoot());
+
+ if (selectorFlags & NodeSelectorFlags::HasEmptySelector &&
+ container->IsElement()) {
+ // See whether we need to restyle the container due to :empty /
+ // :-moz-only-whitespace.
+ const bool wasEmpty =
+ !HasAnySignificantSibling(container->AsElement(), aChild);
+ if (wasEmpty) {
+ // FIXME(emilio): When coming from CharacterDataChanged this can restyle
+ // unnecessarily. Also can restyle unnecessarily if aChild is not
+ // significant anyway, though that's more unlikely.
+ RestyleForEmptyChange(container->AsElement());
+ return;
+ }
+ }
+
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelector) {
+ if (container->IsElement()) {
+ auto* containerElement = container->AsElement();
+ PostRestyleEvent(containerElement, RestyleHint::RestyleSubtree(),
+ nsChangeHint(0));
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelectorNthAll) {
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthDependencyFromSibling(
+ containerElement->GetFirstElementChild());
+ }
+ } else {
+ RestylePreviousSiblings(aChild);
+ RestyleSiblingsStartingWith(aChild);
+ }
+ // Restyling the container is the most we can do here, so we're done.
+ return;
+ }
+
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelectorLaterSiblings) {
+ // Restyle all later siblings.
+ RestyleSiblingsStartingWith(aChild->GetNextSibling());
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelectorNthAll) {
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthDependencyFromSibling(
+ aChild->GetNextElementSibling());
+ }
+ }
+
+ if (selectorFlags & NodeSelectorFlags::HasEdgeChildSelector) {
+ MaybeRestyleForEdgeChildChange(container, aChild);
+ }
+}
+
+void RestyleManager::ContentRemoved(nsIContent* aOldChild,
+ nsIContent* aFollowingSibling) {
+ auto* container = aOldChild->GetParentNode();
+ MOZ_ASSERT(container);
+
+ // Computed style data isn't useful for detached nodes, and we'll need to
+ // recompute it anyway if we ever insert the nodes back into a document.
+ if (auto* element = Element::FromNode(aOldChild)) {
+ RestyleManager::ClearServoDataFromSubtree(element);
+ // If this element is undisplayed or may have undisplayed descendants, we
+ // need to invalidate the cache, since there's the unlikely event of those
+ // elements getting destroyed and their addresses reused in a way that we
+ // look up the cache with their address for a different element before it's
+ // invalidated.
+ IncrementUndisplayedRestyleGeneration();
+ }
+ if (aOldChild->IsElement()) {
+ StyleSet()->MaybeInvalidateForElementRemove(*aOldChild->AsElement(),
+ aFollowingSibling);
+ }
+
+ const auto selectorFlags =
+ container->GetSelectorFlags() & NodeSelectorFlags::AllSimpleRestyleFlags;
+ if (!selectorFlags) {
+ return;
+ }
+
+ if (aOldChild->IsRootOfNativeAnonymousSubtree()) {
+ // This should be an assert, but this is called incorrectly in
+ // HTMLEditor::DeleteRefToAnonymousNode and the assertions were clogging
+ // up the logs. Make it an assert again when that's fixed.
+ MOZ_ASSERT(aOldChild->GetProperty(nsGkAtoms::restylableAnonymousNode),
+ "anonymous nodes should not be in child lists (bug 439258)");
+ }
+
+ // The container cannot be a document.
+ MOZ_ASSERT(container->IsElement() || container->IsShadowRoot());
+
+ if (selectorFlags & NodeSelectorFlags::HasEmptySelector &&
+ container->IsElement()) {
+ // see whether we need to restyle the container
+ bool isEmpty = true; // :empty or :-moz-only-whitespace
+ for (nsIContent* child = container->GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ // We don't know whether we're testing :empty or :-moz-only-whitespace,
+ // so be conservative and assume :-moz-only-whitespace (i.e., make
+ // IsSignificantChild less likely to be true, and thus make us more
+ // likely to restyle).
+ if (nsStyleUtil::IsSignificantChild(child, false)) {
+ isEmpty = false;
+ break;
+ }
+ }
+ if (isEmpty && container->IsElement()) {
+ RestyleForEmptyChange(container->AsElement());
+ return;
+ }
+ }
+
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelector) {
+ if (container->IsElement()) {
+ auto* containerElement = container->AsElement();
+ PostRestyleEvent(containerElement, RestyleHint::RestyleSubtree(),
+ nsChangeHint(0));
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelectorNthAll) {
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthDependencyFromSibling(
+ containerElement->GetFirstElementChild());
+ }
+ } else {
+ RestylePreviousSiblings(aOldChild);
+ RestyleSiblingsStartingWith(aOldChild);
+ }
+ // Restyling the container is the most we can do here, so we're done.
+ return;
+ }
+
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelectorLaterSiblings) {
+ // Restyle all later siblings.
+ RestyleSiblingsStartingWith(aFollowingSibling);
+ if (selectorFlags & NodeSelectorFlags::HasSlowSelectorNthAll) {
+ Element* nextSibling =
+ aFollowingSibling ? aFollowingSibling->IsElement()
+ ? aFollowingSibling->AsElement()
+ : aFollowingSibling->GetNextElementSibling()
+ : nullptr;
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthDependencyFromSibling(
+ nextSibling);
+ }
+ }
+
+ if (selectorFlags & NodeSelectorFlags::HasEdgeChildSelector) {
+ // restyle the now-first element child if it was after aOldChild
+ bool reachedFollowingSibling = false;
+ for (nsIContent* content = container->GetFirstChild(); content;
+ content = content->GetNextSibling()) {
+ if (content == aFollowingSibling) {
+ reachedFollowingSibling = true;
+ // do NOT continue here; we might want to restyle this node
+ }
+ if (content->IsElement()) {
+ if (reachedFollowingSibling) {
+ auto* element = content->AsElement();
+ PostRestyleEvent(element, RestyleHint::RestyleSubtree(),
+ nsChangeHint(0));
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthEdgeDependency(
+ *element);
+ }
+ break;
+ }
+ }
+ // restyle the now-last element child if it was before aOldChild
+ reachedFollowingSibling = (aFollowingSibling == nullptr);
+ for (nsIContent* content = container->GetLastChild(); content;
+ content = content->GetPreviousSibling()) {
+ if (content->IsElement()) {
+ if (reachedFollowingSibling) {
+ auto* element = content->AsElement();
+ PostRestyleEvent(element, RestyleHint::RestyleSubtree(),
+ nsChangeHint(0));
+ StyleSet()->MaybeInvalidateRelativeSelectorForNthEdgeDependency(
+ *element);
+ }
+ break;
+ }
+ if (content == aFollowingSibling) {
+ reachedFollowingSibling = true;
+ }
+ }
+ }
+}
+
+static bool StateChangeMayAffectFrame(const Element& aElement,
+ const nsIFrame& aFrame,
+ ElementState aStates) {
+ const bool brokenChanged = aStates.HasState(ElementState::BROKEN);
+ if (!brokenChanged) {
+ return false;
+ }
+
+ if (aFrame.IsGeneratedContentFrame()) {
+ // If it's other generated content, ignore state changes on it.
+ return aElement.IsHTMLElement(nsGkAtoms::mozgeneratedcontentimage);
+ }
+
+ if (aElement.IsAnyOfHTMLElements(nsGkAtoms::object, nsGkAtoms::embed)) {
+ // Broken affects object fallback behavior.
+ return true;
+ }
+
+ const bool mightChange = [&] {
+ if (aElement.IsHTMLElement(nsGkAtoms::img)) {
+ return true;
+ }
+ const auto* input = HTMLInputElement::FromNode(aElement);
+ return input && input->ControlType() == FormControlType::InputImage;
+ }();
+
+ if (!mightChange) {
+ return false;
+ }
+
+ const bool needsImageFrame =
+ nsImageFrame::ImageFrameTypeFor(aElement, *aFrame.Style()) !=
+ nsImageFrame::ImageFrameType::None;
+ return needsImageFrame != aFrame.IsImageFrameOrSubclass();
+}
+
+static bool RepaintForAppearance(nsIFrame& aFrame, const Element& aElement,
+ ElementState aStateMask) {
+ if (aStateMask.HasAtLeastOneOfStates(ElementState::HOVER |
+ ElementState::ACTIVE) &&
+ aElement.IsAnyOfXULElements(nsGkAtoms::checkbox, nsGkAtoms::radio)) {
+ // The checkbox inside these elements inherit hover state and so on, see
+ // nsNativeTheme::GetContentState.
+ // FIXME(emilio): Would be nice to not have these hard-coded.
+ return true;
+ }
+ auto appearance = aFrame.StyleDisplay()->EffectiveAppearance();
+ if (appearance == StyleAppearance::None) {
+ return false;
+ }
+ nsPresContext* pc = aFrame.PresContext();
+ nsITheme* theme = pc->Theme();
+ if (!theme->ThemeSupportsWidget(pc, &aFrame, appearance)) {
+ return false;
+ }
+ bool repaint = false;
+ theme->WidgetStateChanged(&aFrame, appearance, nullptr, &repaint, nullptr);
+ return repaint;
+}
+
+/**
+ * Calculates the change hint and the restyle hint for a given content state
+ * change.
+ */
+static nsChangeHint ChangeForContentStateChange(const Element& aElement,
+ ElementState aStateMask) {
+ auto changeHint = nsChangeHint(0);
+
+ // Any change to a content state that affects which frames we construct
+ // must lead to a frame reconstruct here if we already have a frame.
+ // Note that we never decide through non-CSS means to not create frames
+ // based on content states, so if we already don't have a frame we don't
+ // need to force a reframe -- if it's needed, the HasStateDependentStyle
+ // call will handle things.
+ if (nsIFrame* primaryFrame = aElement.GetPrimaryFrame()) {
+ if (StateChangeMayAffectFrame(aElement, *primaryFrame, aStateMask)) {
+ return nsChangeHint_ReconstructFrame;
+ }
+ if (RepaintForAppearance(*primaryFrame, aElement, aStateMask)) {
+ changeHint |= nsChangeHint_RepaintFrame;
+ }
+ primaryFrame->ElementStateChanged(aStateMask);
+ }
+
+ if (aStateMask.HasState(ElementState::VISITED)) {
+ // Exposing information to the page about whether the link is
+ // visited or not isn't really something we can worry about here.
+ // FIXME: We could probably do this a bit better.
+ changeHint |= nsChangeHint_RepaintFrame;
+ }
+
+ // This changes the applicable text-transform in the editor root.
+ if (aStateMask.HasState(ElementState::REVEALED)) {
+ // This is the same change hint as tweaking text-transform.
+ changeHint |= NS_STYLE_HINT_REFLOW;
+ }
+
+ return changeHint;
+}
+
+#ifdef DEBUG
+/* static */
+nsCString RestyleManager::ChangeHintToString(nsChangeHint aHint) {
+ nsCString result;
+ bool any = false;
+ const char* names[] = {"RepaintFrame",
+ "NeedReflow",
+ "ClearAncestorIntrinsics",
+ "ClearDescendantIntrinsics",
+ "NeedDirtyReflow",
+ "UpdateCursor",
+ "UpdateEffects",
+ "UpdateOpacityLayer",
+ "UpdateTransformLayer",
+ "ReconstructFrame",
+ "UpdateOverflow",
+ "UpdateSubtreeOverflow",
+ "UpdatePostTransformOverflow",
+ "UpdateParentOverflow",
+ "ChildrenOnlyTransform",
+ "RecomputePosition",
+ "UpdateContainingBlock",
+ "BorderStyleNoneChange",
+ "SchedulePaint",
+ "NeutralChange",
+ "InvalidateRenderingObservers",
+ "ReflowChangesSizeOrPosition",
+ "UpdateComputedBSize",
+ "UpdateUsesOpacity",
+ "UpdateBackgroundPosition",
+ "AddOrRemoveTransform",
+ "ScrollbarChange",
+ "UpdateTableCellSpans",
+ "VisibilityChange"};
+ static_assert(nsChangeHint_AllHints ==
+ static_cast<uint32_t>((1ull << ArrayLength(names)) - 1),
+ "Name list doesn't match change hints.");
+ uint32_t hint =
+ aHint & static_cast<uint32_t>((1ull << ArrayLength(names)) - 1);
+ uint32_t rest =
+ aHint & ~static_cast<uint32_t>((1ull << ArrayLength(names)) - 1);
+ if ((hint & NS_STYLE_HINT_REFLOW) == NS_STYLE_HINT_REFLOW) {
+ result.AppendLiteral("NS_STYLE_HINT_REFLOW");
+ hint = hint & ~NS_STYLE_HINT_REFLOW;
+ any = true;
+ } else if ((hint & nsChangeHint_AllReflowHints) ==
+ nsChangeHint_AllReflowHints) {
+ result.AppendLiteral("nsChangeHint_AllReflowHints");
+ hint = hint & ~nsChangeHint_AllReflowHints;
+ any = true;
+ } else if ((hint & NS_STYLE_HINT_VISUAL) == NS_STYLE_HINT_VISUAL) {
+ result.AppendLiteral("NS_STYLE_HINT_VISUAL");
+ hint = hint & ~NS_STYLE_HINT_VISUAL;
+ any = true;
+ }
+ for (uint32_t i = 0; i < ArrayLength(names); i++) {
+ if (hint & (1u << i)) {
+ if (any) {
+ result.AppendLiteral(" | ");
+ }
+ result.AppendPrintf("nsChangeHint_%s", names[i]);
+ any = true;
+ }
+ }
+ if (rest) {
+ if (any) {
+ result.AppendLiteral(" | ");
+ }
+ result.AppendPrintf("0x%0x", rest);
+ } else {
+ if (!any) {
+ result.AppendLiteral("nsChangeHint(0)");
+ }
+ }
+ return result;
+}
+#endif
+
+/**
+ * Frame construction helpers follow.
+ */
+#ifdef DEBUG
+static bool gInApplyRenderingChangeToTree = false;
+#endif
+
+/**
+ * Sync views on the frame and all of it's descendants (following placeholders).
+ * The change hint should be some combination of nsChangeHint_RepaintFrame,
+ * nsChangeHint_UpdateOpacityLayer and nsChangeHint_SchedulePaint, nothing else.
+ */
+static void SyncViewsAndInvalidateDescendants(nsIFrame*, nsChangeHint);
+
+static void StyleChangeReflow(nsIFrame* aFrame, nsChangeHint aHint);
+
+/**
+ * This helper function is used to find the correct SVG frame to target when we
+ * encounter nsChangeHint_ChildrenOnlyTransform; needed since sometimes we end
+ * up handling that hint while processing hints for one of the SVG frame's
+ * ancestor frames.
+ *
+ * The reason that we sometimes end up trying to process the hint for an
+ * ancestor of the SVG frame that the hint is intended for is due to the way we
+ * process restyle events. ApplyRenderingChangeToTree adjusts the frame from
+ * the restyled element's principle frame to one of its ancestor frames based
+ * on what nsCSSRendering::FindBackground returns, since the background style
+ * may have been propagated up to an ancestor frame. Processing hints using an
+ * ancestor frame is fine in general, but nsChangeHint_ChildrenOnlyTransform is
+ * a special case since it is intended to update a specific frame.
+ */
+static nsIFrame* GetFrameForChildrenOnlyTransformHint(nsIFrame* aFrame) {
+ if (aFrame->IsViewportFrame()) {
+ // This happens if the root-<svg> is fixed positioned, in which case we
+ // can't use aFrame->GetContent() to find the primary frame, since
+ // GetContent() returns nullptr for ViewportFrame.
+ aFrame = aFrame->PrincipalChildList().FirstChild();
+ }
+ // For an nsHTMLScrollFrame, this will get the SVG frame that has the
+ // children-only transforms:
+ aFrame = aFrame->GetContent()->GetPrimaryFrame();
+ if (aFrame->IsSVGOuterSVGFrame()) {
+ aFrame = aFrame->PrincipalChildList().FirstChild();
+ MOZ_ASSERT(aFrame->IsSVGOuterSVGAnonChildFrame(),
+ "Where is the SVGOuterSVGFrame's anon child??");
+ }
+ MOZ_ASSERT(aFrame->IsSVGContainerFrame(),
+ "Children-only transforms only expected on SVG frames");
+ return aFrame;
+}
+
+// This function tries to optimize a position style change by either
+// moving aFrame or ignoring the style change when it's safe to do so.
+// It returns true when that succeeds, otherwise it posts a reflow request
+// and returns false.
+static bool RecomputePosition(nsIFrame* aFrame) {
+ // It's pointless to move around frames that have never been reflowed or
+ // are dirty (i.e. they will be reflowed), or aren't affected by position
+ // styles.
+ if (aFrame->HasAnyStateBits(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
+ NS_FRAME_SVG_LAYOUT)) {
+ return true;
+ }
+
+ // Don't process position changes on table frames, since we already handle
+ // the dynamic position change on the table wrapper frame, and the
+ // reflow-based fallback code path also ignores positions on inner table
+ // frames.
+ if (aFrame->IsTableFrame()) {
+ return true;
+ }
+
+ const nsStyleDisplay* display = aFrame->StyleDisplay();
+ // Changes to the offsets of a non-positioned element can safely be ignored.
+ if (display->mPosition == StylePositionProperty::Static) {
+ return true;
+ }
+
+ // Don't process position changes on frames which have views or the ones which
+ // have a view somewhere in their descendants, because the corresponding view
+ // needs to be repositioned properly as well.
+ if (aFrame->HasView() ||
+ aFrame->HasAnyStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW)) {
+ return false;
+ }
+
+ if (aFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) {
+ // If the frame has an intrinsic block-size, we resolve its 'auto' margins
+ // after doing layout, since we need to know the frame's block size. See
+ // nsAbsoluteContainingBlock::ResolveAutoMarginsAfterLayout().
+ //
+ // Since the size of the frame doesn't change, we could modify the below
+ // computation to compute the margin correctly without doing a full reflow,
+ // however we decided to try doing a full reflow for now.
+ if (aFrame->HasIntrinsicKeywordForBSize()) {
+ WritingMode wm = aFrame->GetWritingMode();
+ const auto* styleMargin = aFrame->StyleMargin();
+ if (styleMargin->HasBlockAxisAuto(wm)) {
+ return false;
+ }
+ }
+ // Flexbox and Grid layout supports CSS Align and the optimizations below
+ // don't support that yet.
+ nsIFrame* ph = aFrame->GetPlaceholderFrame();
+ if (ph && ph->HasAnyStateBits(PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN)) {
+ return false;
+ }
+ }
+
+ // If we need to reposition any descendant that depends on our static
+ // position, then we also can't take the optimized path.
+ //
+ // TODO(emilio): It may be worth trying to find them and try to call
+ // RecomputePosition on them too instead of disabling the optimization...
+ if (aFrame->DescendantMayDependOnItsStaticPosition()) {
+ return false;
+ }
+
+ aFrame->SchedulePaint();
+
+ auto postPendingScrollAnchorOrResnap = [](nsIFrame* frame) {
+ if (frame->IsInScrollAnchorChain()) {
+ ScrollAnchorContainer* container = ScrollAnchorContainer::FindFor(frame);
+ frame->PresShell()->PostPendingScrollAnchorAdjustment(container);
+ }
+
+ // We need to trigger re-snapping to this content if we snapped to the
+ // content on the last scroll operation.
+ ScrollSnapUtils::PostPendingResnapIfNeededFor(frame);
+ };
+
+ // For relative positioning, we can simply update the frame rect
+ if (display->IsRelativelyOrStickyPositionedStyle()) {
+ if (aFrame->IsGridItem()) {
+ // A grid item's CB is its grid area, not the parent frame content area
+ // as is assumed below.
+ return false;
+ }
+ // Move the frame
+ if (display->mPosition == StylePositionProperty::Sticky) {
+ // Update sticky positioning for an entire element at once, starting with
+ // the first continuation or ib-split sibling.
+ // It's rare that the frame we already have isn't already the first
+ // continuation or ib-split sibling, but it can happen when styles differ
+ // across continuations such as ::first-line or ::first-letter, and in
+ // those cases we will generally (but maybe not always) do the work twice.
+ nsIFrame* firstContinuation =
+ nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame);
+
+ StickyScrollContainer::ComputeStickyOffsets(firstContinuation);
+ StickyScrollContainer* ssc =
+ StickyScrollContainer::GetStickyScrollContainerForFrame(
+ firstContinuation);
+ if (ssc) {
+ ssc->PositionContinuations(firstContinuation);
+ }
+ } else {
+ MOZ_ASSERT(display->IsRelativelyPositionedStyle(),
+ "Unexpected type of positioning");
+ for (nsIFrame* cont = aFrame; cont;
+ cont = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) {
+ nsIFrame* cb = cont->GetContainingBlock();
+ WritingMode wm = cb->GetWritingMode();
+ const LogicalSize cbSize = cb->ContentSize();
+ const LogicalMargin newLogicalOffsets =
+ ReflowInput::ComputeRelativeOffsets(wm, cont, cbSize);
+ const nsMargin newOffsets = newLogicalOffsets.GetPhysicalMargin(wm);
+
+ // ReflowInput::ApplyRelativePositioning would work here, but
+ // since we've already checked mPosition and aren't changing the frame's
+ // normal position, go ahead and add the offsets directly.
+ // First, we need to ensure that the normal position is stored though.
+ bool hasProperty;
+ nsPoint normalPosition = cont->GetNormalPosition(&hasProperty);
+ if (!hasProperty) {
+ cont->AddProperty(nsIFrame::NormalPositionProperty(), normalPosition);
+ }
+ cont->SetPosition(normalPosition +
+ nsPoint(newOffsets.left, newOffsets.top));
+ }
+ }
+
+ postPendingScrollAnchorOrResnap(aFrame);
+ return true;
+ }
+
+ // For the absolute positioning case, set up a fake HTML reflow input for
+ // the frame, and then get the offsets and size from it. If the frame's size
+ // doesn't need to change, we can simply update the frame position. Otherwise
+ // we fall back to a reflow.
+ UniquePtr<gfxContext> rc =
+ aFrame->PresShell()->CreateReferenceRenderingContext();
+
+ // Construct a bogus parent reflow input so that there's a usable reflow input
+ // for the containing block.
+ nsIFrame* parentFrame = aFrame->GetParent();
+ WritingMode parentWM = parentFrame->GetWritingMode();
+ WritingMode frameWM = aFrame->GetWritingMode();
+ LogicalSize parentSize = parentFrame->GetLogicalSize();
+
+ nsFrameState savedState = parentFrame->GetStateBits();
+ ReflowInput parentReflowInput(aFrame->PresContext(), parentFrame, rc.get(),
+ parentSize);
+ parentFrame->RemoveStateBits(~nsFrameState(0));
+ parentFrame->AddStateBits(savedState);
+
+ // The bogus parent state here was created with no parent state of its own,
+ // and therefore it won't have an mCBReflowInput set up.
+ // But we may need one (for InitCBReflowInput in a child state), so let's
+ // try to create one here for the cases where it will be needed.
+ Maybe<ReflowInput> cbReflowInput;
+ nsIFrame* cbFrame = parentFrame->GetContainingBlock();
+ if (cbFrame && (aFrame->GetContainingBlock() != parentFrame ||
+ parentFrame->IsTableFrame())) {
+ const auto cbWM = cbFrame->GetWritingMode();
+ LogicalSize cbSize = cbFrame->GetLogicalSize();
+ cbReflowInput.emplace(cbFrame->PresContext(), cbFrame, rc.get(), cbSize);
+ cbReflowInput->SetComputedLogicalMargin(
+ cbWM, cbFrame->GetLogicalUsedMargin(cbWM));
+ cbReflowInput->SetComputedLogicalPadding(
+ cbWM, cbFrame->GetLogicalUsedPadding(cbWM));
+ cbReflowInput->SetComputedLogicalBorderPadding(
+ cbWM, cbFrame->GetLogicalUsedBorderAndPadding(cbWM));
+ parentReflowInput.mCBReflowInput = cbReflowInput.ptr();
+ }
+
+ NS_WARNING_ASSERTION(parentSize.ISize(parentWM) != NS_UNCONSTRAINEDSIZE &&
+ parentSize.BSize(parentWM) != NS_UNCONSTRAINEDSIZE,
+ "parentSize should be valid");
+ parentReflowInput.SetComputedISize(std::max(parentSize.ISize(parentWM), 0));
+ parentReflowInput.SetComputedBSize(std::max(parentSize.BSize(parentWM), 0));
+ parentReflowInput.SetComputedLogicalMargin(parentWM, LogicalMargin(parentWM));
+
+ parentReflowInput.SetComputedLogicalPadding(
+ parentWM, parentFrame->GetLogicalUsedPadding(parentWM));
+ parentReflowInput.SetComputedLogicalBorderPadding(
+ parentWM, parentFrame->GetLogicalUsedBorderAndPadding(parentWM));
+ LogicalSize availSize = parentSize.ConvertTo(frameWM, parentWM);
+ availSize.BSize(frameWM) = NS_UNCONSTRAINEDSIZE;
+
+ ViewportFrame* viewport = do_QueryFrame(parentFrame);
+ nsSize cbSize =
+ viewport
+ ? viewport->AdjustReflowInputAsContainingBlock(&parentReflowInput)
+ .Size()
+ : aFrame->GetContainingBlock()->GetSize();
+ const nsMargin& parentBorder =
+ parentReflowInput.mStyleBorder->GetComputedBorder();
+ cbSize -= nsSize(parentBorder.LeftRight(), parentBorder.TopBottom());
+ LogicalSize lcbSize(frameWM, cbSize);
+ ReflowInput reflowInput(aFrame->PresContext(), parentReflowInput, aFrame,
+ availSize, Some(lcbSize));
+ nscoord computedISize = reflowInput.ComputedISize();
+ nscoord computedBSize = reflowInput.ComputedBSize();
+ const auto frameBP = reflowInput.ComputedLogicalBorderPadding(frameWM);
+ computedISize += frameBP.IStartEnd(frameWM);
+ if (computedBSize != NS_UNCONSTRAINEDSIZE) {
+ computedBSize += frameBP.BStartEnd(frameWM);
+ }
+ LogicalSize logicalSize = aFrame->GetLogicalSize(frameWM);
+ nsSize size = aFrame->GetSize();
+ // The RecomputePosition hint is not used if any offset changed between auto
+ // and non-auto. If computedSize.height == NS_UNCONSTRAINEDSIZE then the new
+ // element height will be its intrinsic height, and since 'top' and 'bottom''s
+ // auto-ness hasn't changed, the old height must also be its intrinsic
+ // height, which we can assume hasn't changed (or reflow would have
+ // been triggered).
+ if (computedISize == logicalSize.ISize(frameWM) &&
+ (computedBSize == NS_UNCONSTRAINEDSIZE ||
+ computedBSize == logicalSize.BSize(frameWM))) {
+ // If we're solving for 'left' or 'top', then compute it here, in order to
+ // match the reflow code path.
+ //
+ // TODO(emilio): It'd be nice if this did logical math instead, but it seems
+ // to me the math should work out on vertical writing modes as well. See Bug
+ // 1675861 for some hints.
+ const nsMargin offset = reflowInput.ComputedPhysicalOffsets();
+ const nsMargin margin = reflowInput.ComputedPhysicalMargin();
+
+ nscoord left = offset.left;
+ if (left == NS_AUTOOFFSET) {
+ left =
+ cbSize.width - offset.right - margin.right - size.width - margin.left;
+ }
+
+ nscoord top = offset.top;
+ if (top == NS_AUTOOFFSET) {
+ top = cbSize.height - offset.bottom - margin.bottom - size.height -
+ margin.top;
+ }
+
+ // Move the frame
+ nsPoint pos(parentBorder.left + left + margin.left,
+ parentBorder.top + top + margin.top);
+ aFrame->SetPosition(pos);
+
+ postPendingScrollAnchorOrResnap(aFrame);
+ return true;
+ }
+
+ // Fall back to a reflow
+ return false;
+}
+
+/**
+ * Return true if aFrame's subtree has placeholders for out-of-flow content
+ * that would be affected due to the change to
+ * `aPossiblyChangingContainingBlock` (and thus would need to get reframed).
+ *
+ * In particular, this function returns true if there are placeholders whose OOF
+ * frames may need to be reparented (via reframing) as a result of whatever
+ * change actually happened.
+ *
+ * The `aIs{Abs,Fixed}PosContainingBlock` params represent whether
+ * `aPossiblyChangingContainingBlock` is a containing block for abs pos / fixed
+ * pos stuff, respectively, for the _new_ style that the frame already has, not
+ * the old one.
+ */
+static bool ContainingBlockChangeAffectsDescendants(
+ nsIFrame* aPossiblyChangingContainingBlock, nsIFrame* aFrame,
+ bool aIsAbsPosContainingBlock, bool aIsFixedPosContainingBlock) {
+ // All fixed-pos containing blocks should also be abs-pos containing blocks.
+ MOZ_ASSERT_IF(aIsFixedPosContainingBlock, aIsAbsPosContainingBlock);
+
+ for (const auto& childList : aFrame->ChildLists()) {
+ for (nsIFrame* f : childList.mList) {
+ if (f->IsPlaceholderFrame()) {
+ nsIFrame* outOfFlow = nsPlaceholderFrame::GetRealFrameForPlaceholder(f);
+ // If SVG text frames could appear here, they could confuse us since
+ // they ignore their position style ... but they can't.
+ NS_ASSERTION(!outOfFlow->IsInSVGTextSubtree(),
+ "SVG text frames can't be out of flow");
+ // Top-layer frames don't change containing block based on direct
+ // ancestors.
+ auto* display = outOfFlow->StyleDisplay();
+ if (display->IsAbsolutelyPositionedStyle() &&
+ display->mTopLayer == StyleTopLayer::None) {
+ const bool isContainingBlock =
+ aIsFixedPosContainingBlock ||
+ (aIsAbsPosContainingBlock &&
+ display->mPosition == StylePositionProperty::Absolute);
+ // NOTE(emilio): aPossiblyChangingContainingBlock is guaranteed to be
+ // a first continuation, see the assertion in the caller.
+ nsIFrame* parent = outOfFlow->GetParent()->FirstContinuation();
+ if (isContainingBlock) {
+ // If we are becoming a containing block, we only need to reframe if
+ // this oof's current containing block is an ancestor of the new
+ // frame.
+ if (parent != aPossiblyChangingContainingBlock &&
+ nsLayoutUtils::IsProperAncestorFrame(
+ parent, aPossiblyChangingContainingBlock)) {
+ return true;
+ }
+ } else {
+ // If we are not a containing block anymore, we only need to reframe
+ // if we are the current containing block of the oof frame.
+ if (parent == aPossiblyChangingContainingBlock) {
+ return true;
+ }
+ }
+ }
+ }
+ // NOTE: It's tempting to check f->IsAbsPosContainingBlock() or
+ // f->IsFixedPosContainingBlock() here. However, that would only
+ // be testing the *new* style of the frame, which might exclude
+ // descendants that currently have this frame as an abs-pos
+ // containing block. Taking the codepath where we don't reframe
+ // could lead to an unsafe call to
+ // cont->MarkAsNotAbsoluteContainingBlock() before we've reframed
+ // the descendant and taken it off the absolute list.
+ if (ContainingBlockChangeAffectsDescendants(
+ aPossiblyChangingContainingBlock, f, aIsAbsPosContainingBlock,
+ aIsFixedPosContainingBlock)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+// Returns the frame that would serve as the containing block for aFrame's
+// positioned descendants, if aFrame had styles to make it a CB for such
+// descendants. (Typically this is just aFrame itself, or its insertion frame).
+//
+// Returns nullptr if this frame can't be easily determined.
+static nsIFrame* ContainingBlockForFrame(nsIFrame* aFrame) {
+ if (aFrame->IsFieldSetFrame()) {
+ // FIXME: This should be easily implementable.
+ return nullptr;
+ }
+ nsIFrame* insertionFrame = aFrame->GetContentInsertionFrame();
+ if (insertionFrame == aFrame) {
+ return insertionFrame;
+ }
+ // Generally frames with a different insertion frame are hard to deal with,
+ // but scrollframes are easy because the containing block is just the
+ // insertion frame.
+ if (aFrame->IsScrollFrame()) {
+ return insertionFrame;
+ }
+ // Combobox frames are easy as well because they can't have positioned
+ // children anyways.
+ // Button and table cell frames are also easy because the containing block is
+ // the frame itself.
+ if (aFrame->IsComboboxControlFrame() || aFrame->IsHTMLButtonControlFrame() ||
+ aFrame->IsTableCellFrame()) {
+ return aFrame;
+ }
+ return nullptr;
+}
+
+static bool NeedToReframeToUpdateContainingBlock(nsIFrame* aFrame,
+ nsIFrame* aMaybeChangingCB) {
+ // NOTE: This looks at the new style.
+ const bool isFixedContainingBlock = aFrame->IsFixedPosContainingBlock();
+ MOZ_ASSERT_IF(isFixedContainingBlock, aFrame->IsAbsPosContainingBlock());
+
+ const bool isAbsPosContainingBlock =
+ isFixedContainingBlock || aFrame->IsAbsPosContainingBlock();
+
+ for (nsIFrame* f = aFrame; f;
+ f = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(f)) {
+ if (ContainingBlockChangeAffectsDescendants(aMaybeChangingCB, f,
+ isAbsPosContainingBlock,
+ isFixedContainingBlock)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static void DoApplyRenderingChangeToTree(nsIFrame* aFrame,
+ nsChangeHint aChange) {
+ MOZ_ASSERT(gInApplyRenderingChangeToTree,
+ "should only be called within ApplyRenderingChangeToTree");
+
+ for (; aFrame;
+ aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame)) {
+ // Invalidate and sync views on all descendant frames, following
+ // placeholders. We don't need to update transforms in
+ // SyncViewsAndInvalidateDescendants, because there can't be any
+ // out-of-flows or popups that need to be transformed; all out-of-flow
+ // descendants of the transformed element must also be descendants of the
+ // transformed frame.
+ SyncViewsAndInvalidateDescendants(
+ aFrame, nsChangeHint(aChange & (nsChangeHint_RepaintFrame |
+ nsChangeHint_UpdateOpacityLayer |
+ nsChangeHint_SchedulePaint)));
+ // This must be set to true if the rendering change needs to
+ // invalidate content. If it's false, a composite-only paint
+ // (empty transaction) will be scheduled.
+ bool needInvalidatingPaint = false;
+
+ // if frame has view, will already be invalidated
+ if (aChange & nsChangeHint_RepaintFrame) {
+ // Note that this whole block will be skipped when painting is suppressed
+ // (due to our caller ApplyRendingChangeToTree() discarding the
+ // nsChangeHint_RepaintFrame hint). If you add handling for any other
+ // hints within this block, be sure that they too should be ignored when
+ // painting is suppressed.
+ needInvalidatingPaint = true;
+ aFrame->InvalidateFrameSubtree();
+ if ((aChange & nsChangeHint_UpdateEffects) &&
+ aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) {
+ // Need to update our overflow rects:
+ SVGUtils::ScheduleReflowSVG(aFrame);
+ }
+
+ ActiveLayerTracker::NotifyNeedsRepaint(aFrame);
+ }
+ if (aChange & nsChangeHint_UpdateOpacityLayer) {
+ // FIXME/bug 796697: we can get away with empty transactions for
+ // opacity updates in many cases.
+ needInvalidatingPaint = true;
+
+ ActiveLayerTracker::NotifyRestyle(aFrame, eCSSProperty_opacity);
+ if (SVGIntegrationUtils::UsingEffectsForFrame(aFrame)) {
+ // SVG effects paints the opacity without using
+ // nsDisplayOpacity. We need to invalidate manually.
+ aFrame->InvalidateFrameSubtree();
+ }
+ }
+ if ((aChange & nsChangeHint_UpdateTransformLayer) &&
+ aFrame->IsTransformed()) {
+ // Note: All the transform-like properties should map to the same
+ // layer activity index, so does the restyle count. Therefore, using
+ // eCSSProperty_transform should be fine.
+ ActiveLayerTracker::NotifyRestyle(aFrame, eCSSProperty_transform);
+ needInvalidatingPaint = true;
+ }
+ if (aChange & nsChangeHint_ChildrenOnlyTransform) {
+ needInvalidatingPaint = true;
+ nsIFrame* childFrame = GetFrameForChildrenOnlyTransformHint(aFrame)
+ ->PrincipalChildList()
+ .FirstChild();
+ for (; childFrame; childFrame = childFrame->GetNextSibling()) {
+ // Note: All the transform-like properties should map to the same
+ // layer activity index, so does the restyle count. Therefore, using
+ // eCSSProperty_transform should be fine.
+ ActiveLayerTracker::NotifyRestyle(childFrame, eCSSProperty_transform);
+ }
+ }
+ if (aChange & nsChangeHint_SchedulePaint) {
+ needInvalidatingPaint = true;
+ }
+ aFrame->SchedulePaint(needInvalidatingPaint
+ ? nsIFrame::PAINT_DEFAULT
+ : nsIFrame::PAINT_COMPOSITE_ONLY);
+ }
+}
+
+static void SyncViewsAndInvalidateDescendants(nsIFrame* aFrame,
+ nsChangeHint aChange) {
+ MOZ_ASSERT(gInApplyRenderingChangeToTree,
+ "should only be called within ApplyRenderingChangeToTree");
+
+ NS_ASSERTION(nsChangeHint_size_t(aChange) ==
+ (aChange & (nsChangeHint_RepaintFrame |
+ nsChangeHint_UpdateOpacityLayer |
+ nsChangeHint_SchedulePaint)),
+ "Invalid change flag");
+
+ aFrame->SyncFrameViewProperties();
+
+ for (const auto& [list, listID] : aFrame->ChildLists()) {
+ for (nsIFrame* child : list) {
+ if (!child->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) {
+ // only do frames that don't have placeholders
+ if (child->IsPlaceholderFrame()) {
+ // do the out-of-flow frame and its continuations
+ nsIFrame* outOfFlowFrame =
+ nsPlaceholderFrame::GetRealFrameForPlaceholder(child);
+ DoApplyRenderingChangeToTree(outOfFlowFrame, aChange);
+ } else if (listID == FrameChildListID::Popup) {
+ DoApplyRenderingChangeToTree(child, aChange);
+ } else { // regular frame
+ SyncViewsAndInvalidateDescendants(child, aChange);
+ }
+ }
+ }
+ }
+}
+
+static void ApplyRenderingChangeToTree(PresShell* aPresShell, nsIFrame* aFrame,
+ nsChangeHint aChange) {
+ // We check StyleDisplay()->HasTransformStyle() in addition to checking
+ // IsTransformed() since we can get here for some frames that don't support
+ // CSS transforms, and table frames, which are their own odd-ball, since the
+ // transform is handled by their wrapper, which _also_ gets a separate hint.
+ NS_ASSERTION(!(aChange & nsChangeHint_UpdateTransformLayer) ||
+ aFrame->IsTransformed() ||
+ aFrame->StyleDisplay()->HasTransformStyle(),
+ "Unexpected UpdateTransformLayer hint");
+
+ if (aPresShell->IsPaintingSuppressed()) {
+ // Don't allow synchronous rendering changes when painting is turned off.
+ aChange &= ~nsChangeHint_RepaintFrame;
+ if (!aChange) {
+ return;
+ }
+ }
+
+// Trigger rendering updates by damaging this frame and any
+// continuations of this frame.
+#ifdef DEBUG
+ gInApplyRenderingChangeToTree = true;
+#endif
+ if (aChange & nsChangeHint_RepaintFrame) {
+ // If the frame is the primary frame of either the body element or
+ // the html element, we propagate the repaint change hint to the
+ // viewport. This is necessary for background and scrollbar colors
+ // propagation.
+ if (aFrame->IsPrimaryFrameOfRootOrBodyElement()) {
+ nsIFrame* rootFrame = aPresShell->GetRootFrame();
+ MOZ_ASSERT(rootFrame, "No root frame?");
+ DoApplyRenderingChangeToTree(rootFrame, nsChangeHint_RepaintFrame);
+ aChange &= ~nsChangeHint_RepaintFrame;
+ if (!aChange) {
+ return;
+ }
+ }
+ }
+ DoApplyRenderingChangeToTree(aFrame, aChange);
+#ifdef DEBUG
+ gInApplyRenderingChangeToTree = false;
+#endif
+}
+
+static void AddSubtreeToOverflowTracker(
+ nsIFrame* aFrame, OverflowChangedTracker& aOverflowChangedTracker) {
+ if (aFrame->FrameMaintainsOverflow()) {
+ aOverflowChangedTracker.AddFrame(aFrame,
+ OverflowChangedTracker::CHILDREN_CHANGED);
+ }
+ for (const auto& childList : aFrame->ChildLists()) {
+ for (nsIFrame* child : childList.mList) {
+ AddSubtreeToOverflowTracker(child, aOverflowChangedTracker);
+ }
+ }
+}
+
+static void StyleChangeReflow(nsIFrame* aFrame, nsChangeHint aHint) {
+ IntrinsicDirty dirtyType;
+ if (aHint & nsChangeHint_ClearDescendantIntrinsics) {
+ NS_ASSERTION(aHint & nsChangeHint_ClearAncestorIntrinsics,
+ "Please read the comments in nsChangeHint.h");
+ NS_ASSERTION(aHint & nsChangeHint_NeedDirtyReflow,
+ "ClearDescendantIntrinsics requires NeedDirtyReflow");
+ dirtyType = IntrinsicDirty::FrameAncestorsAndDescendants;
+ } else if ((aHint & nsChangeHint_UpdateComputedBSize) &&
+ aFrame->HasAnyStateBits(
+ NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
+ dirtyType = IntrinsicDirty::FrameAncestorsAndDescendants;
+ } else if (aHint & nsChangeHint_ClearAncestorIntrinsics) {
+ dirtyType = IntrinsicDirty::FrameAndAncestors;
+ } else {
+ dirtyType = IntrinsicDirty::None;
+ }
+
+ if (aHint & nsChangeHint_UpdateComputedBSize) {
+ aFrame->SetHasBSizeChange(true);
+ }
+
+ nsFrameState dirtyBits;
+ if (aFrame->HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
+ dirtyBits = nsFrameState(0);
+ } else if ((aHint & nsChangeHint_NeedDirtyReflow) ||
+ dirtyType == IntrinsicDirty::FrameAncestorsAndDescendants) {
+ dirtyBits = NS_FRAME_IS_DIRTY;
+ } else {
+ dirtyBits = NS_FRAME_HAS_DIRTY_CHILDREN;
+ }
+
+ // If we're not going to clear any intrinsic sizes on the frames, and
+ // there are no dirty bits to set, then there's nothing to do.
+ if (dirtyType == IntrinsicDirty::None && !dirtyBits) return;
+
+ ReflowRootHandling rootHandling;
+ if (aHint & nsChangeHint_ReflowChangesSizeOrPosition) {
+ rootHandling = ReflowRootHandling::PositionOrSizeChange;
+ } else {
+ rootHandling = ReflowRootHandling::NoPositionOrSizeChange;
+ }
+
+ do {
+ aFrame->PresShell()->FrameNeedsReflow(aFrame, dirtyType, dirtyBits,
+ rootHandling);
+ aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame);
+ } while (aFrame);
+}
+
+// Get the next sibling which might have a frame. This only considers siblings
+// that stylo post-traversal looks at, so only elements and text. In
+// particular, it ignores comments.
+static nsIContent* NextSiblingWhichMayHaveFrame(nsIContent* aContent) {
+ for (nsIContent* next = aContent->GetNextSibling(); next;
+ next = next->GetNextSibling()) {
+ if (next->IsElement() || next->IsText()) {
+ return next;
+ }
+ }
+
+ return nullptr;
+}
+
+// If |aFrame| is dirty or has dirty children, then we can skip updating
+// overflows since that will happen when it's reflowed.
+static inline bool CanSkipOverflowUpdates(const nsIFrame* aFrame) {
+ return aFrame->HasAnyStateBits(NS_FRAME_IS_DIRTY |
+ NS_FRAME_HAS_DIRTY_CHILDREN);
+}
+
+static inline void TryToDealWithScrollbarChange(nsChangeHint& aHint,
+ nsIContent* aContent,
+ nsIFrame* aFrame,
+ nsPresContext* aPc) {
+ if (!(aHint & nsChangeHint_ScrollbarChange)) {
+ return;
+ }
+ aHint &= ~nsChangeHint_ScrollbarChange;
+ if (aHint & nsChangeHint_ReconstructFrame) {
+ return;
+ }
+
+ MOZ_ASSERT(aFrame, "If we're not reframing, we ought to have a frame");
+
+ const bool isRoot = aContent->IsInUncomposedDoc() && !aContent->GetParent();
+
+ // Only bother with this if we're the root or the body element, since:
+ // (a) It'd be *expensive* to reframe these particular nodes. They're
+ // at the root, so reframing would mean rebuilding the world.
+ // (b) It's often *unnecessary* to reframe for "overflow" changes on
+ // these particular nodes. In general, the only reason we reframe
+ // for "overflow" changes is so we can construct (or destroy) a
+ // scrollframe & scrollbars -- and the html/body nodes often don't
+ // need their own scrollframe/scrollbars because they coopt the ones
+ // on the viewport (which always exist). So depending on whether
+ // that's happening, we can skip the reframe for these nodes.
+ if (isRoot || aContent->IsHTMLElement(nsGkAtoms::body)) {
+ // If the restyled element provided/provides the scrollbar styles for
+ // the viewport before and/or after this restyle, AND it's not coopting
+ // that responsibility from some other element (which would need
+ // reconstruction to make its own scrollframe now), THEN: we don't need
+ // to reconstruct - we can just reflow, because no scrollframe is being
+ // added/removed.
+ Element* prevOverride = aPc->GetViewportScrollStylesOverrideElement();
+ Element* newOverride = aPc->UpdateViewportScrollStylesOverride();
+
+ const auto ProvidesScrollbarStyles = [&](nsIContent* aOverride) {
+ if (aOverride) {
+ return aOverride == aContent;
+ }
+ return isRoot;
+ };
+
+ if (ProvidesScrollbarStyles(prevOverride) ||
+ ProvidesScrollbarStyles(newOverride)) {
+ // If we get here, the restyled element provided the scrollbar styles
+ // for viewport before this restyle, OR it will provide them after.
+ if (!prevOverride || !newOverride || prevOverride == newOverride) {
+ // If we get here, the restyled element is NOT replacing (or being
+ // replaced by) some other element as the viewport's
+ // scrollbar-styles provider. (If it were, we'd potentially need to
+ // reframe to create a dedicated scrollframe for whichever element
+ // is being booted from providing viewport scrollbar styles.)
+ //
+ // Under these conditions, we're OK to assume that this "overflow"
+ // change only impacts the root viewport's scrollframe, which
+ // already exists, so we can simply reflow instead of reframing.
+ if (nsIScrollableFrame* sf = do_QueryFrame(aFrame)) {
+ sf->MarkScrollbarsDirtyForReflow();
+ } else if (nsIScrollableFrame* sf =
+ aPc->PresShell()->GetRootScrollFrameAsScrollable()) {
+ sf->MarkScrollbarsDirtyForReflow();
+ }
+ aHint |= nsChangeHint_ReflowHintsForScrollbarChange;
+ } else {
+ // If we changed the override element, we need to reconstruct as the old
+ // override element might start / stop being scrollable.
+ aHint |= nsChangeHint_ReconstructFrame;
+ }
+ return;
+ }
+ }
+
+ const bool scrollable = aFrame->StyleDisplay()->IsScrollableOverflow();
+ if (nsIScrollableFrame* sf = do_QueryFrame(aFrame)) {
+ if (scrollable && sf->HasAllNeededScrollbars()) {
+ sf->MarkScrollbarsDirtyForReflow();
+ // Once we've created scrollbars for a frame, don't bother reconstructing
+ // it just to remove them if we still need a scroll frame.
+ aHint |= nsChangeHint_ReflowHintsForScrollbarChange;
+ return;
+ }
+ } else if (aFrame->IsTextInputFrame()) {
+ // input / textarea for the most part don't honor overflow themselves, the
+ // editor root will deal with the change if needed.
+ // However the textarea intrinsic size relies on GetDesiredScrollbarSizes(),
+ // so we need to reflow the textarea itself, not just the inner control.
+ aHint |= nsChangeHint_ReflowHintsForScrollbarChange;
+ return;
+ } else if (!scrollable) {
+ // Something changed, but we don't have nor will have a scroll frame,
+ // there's nothing to do here.
+ return;
+ }
+
+ // Oh well, we couldn't optimize it out, just reconstruct frames for the
+ // subtree.
+ aHint |= nsChangeHint_ReconstructFrame;
+}
+
+static void TryToHandleContainingBlockChange(nsChangeHint& aHint,
+ nsIFrame* aFrame) {
+ if (!(aHint & nsChangeHint_UpdateContainingBlock)) {
+ return;
+ }
+ if (aHint & nsChangeHint_ReconstructFrame) {
+ return;
+ }
+ MOZ_ASSERT(aFrame, "If we're not reframing, we ought to have a frame");
+ nsIFrame* containingBlock = ContainingBlockForFrame(aFrame);
+ if (!containingBlock ||
+ NeedToReframeToUpdateContainingBlock(aFrame, containingBlock)) {
+ // The frame has positioned children that need to be reparented, or it can't
+ // easily be converted to/from being an abs-pos container correctly.
+ aHint |= nsChangeHint_ReconstructFrame;
+ return;
+ }
+ const bool isCb = aFrame->IsAbsPosContainingBlock();
+
+ // The absolute container should be containingBlock.
+ for (nsIFrame* cont = containingBlock; cont;
+ cont = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) {
+ // Normally frame construction would set state bits as needed,
+ // but we're not going to reconstruct the frame so we need to set
+ // them. It's because we need to set this state on each affected frame
+ // that we can't coalesce nsChangeHint_UpdateContainingBlock hints up
+ // to ancestors (i.e. it can't be an change hint that is handled for
+ // descendants).
+ if (isCb) {
+ if (!cont->IsAbsoluteContainer() &&
+ cont->HasAnyStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN)) {
+ cont->MarkAsAbsoluteContainingBlock();
+ }
+ } else if (cont->IsAbsoluteContainer()) {
+ if (cont->HasAbsolutelyPositionedChildren()) {
+ // If |cont| still has absolutely positioned children,
+ // we can't call MarkAsNotAbsoluteContainingBlock. This
+ // will remove a frame list that still has children in
+ // it that we need to keep track of.
+ // The optimization of removing it isn't particularly
+ // important, although it does mean we skip some tests.
+ NS_WARNING("skipping removal of absolute containing block");
+ } else {
+ cont->MarkAsNotAbsoluteContainingBlock();
+ }
+ }
+ }
+}
+
+void RestyleManager::ProcessRestyledFrames(nsStyleChangeList& aChangeList) {
+ NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),
+ "Someone forgot a script blocker");
+
+ // See bug 1378219 comment 9:
+ // Recursive calls here are a bit worrying, but apparently do happen in the
+ // wild (although not currently in any of our automated tests). Try to get a
+ // stack from Nightly/Dev channel to figure out what's going on and whether
+ // it's OK.
+ MOZ_DIAGNOSTIC_ASSERT(!mDestroyedFrames, "ProcessRestyledFrames recursion");
+
+ if (aChangeList.IsEmpty()) {
+ return;
+ }
+
+ // If mDestroyedFrames is null, we want to create a new hashtable here
+ // and destroy it on exit; but if it is already non-null (because we're in
+ // a recursive call), we will continue to use the existing table to
+ // accumulate destroyed frames, and NOT clear mDestroyedFrames on exit.
+ // We use a MaybeClearDestroyedFrames helper to conditionally reset the
+ // mDestroyedFrames pointer when this method returns.
+ typedef decltype(mDestroyedFrames) DestroyedFramesT;
+ class MOZ_RAII MaybeClearDestroyedFrames {
+ private:
+ DestroyedFramesT& mDestroyedFramesRef; // ref to caller's mDestroyedFrames
+ const bool mResetOnDestruction;
+
+ public:
+ explicit MaybeClearDestroyedFrames(DestroyedFramesT& aTarget)
+ : mDestroyedFramesRef(aTarget),
+ mResetOnDestruction(!aTarget) // reset only if target starts out null
+ {}
+ ~MaybeClearDestroyedFrames() {
+ if (mResetOnDestruction) {
+ mDestroyedFramesRef.reset(nullptr);
+ }
+ }
+ };
+
+ MaybeClearDestroyedFrames maybeClear(mDestroyedFrames);
+ if (!mDestroyedFrames) {
+ mDestroyedFrames = MakeUnique<nsTHashSet<const nsIFrame*>>();
+ }
+
+ AUTO_PROFILER_LABEL("RestyleManager::ProcessRestyledFrames", LAYOUT);
+
+ nsPresContext* presContext = PresContext();
+ nsCSSFrameConstructor* frameConstructor = presContext->FrameConstructor();
+
+ bool didUpdateCursor = false;
+
+ for (size_t i = 0; i < aChangeList.Length(); ++i) {
+ // Collect and coalesce adjacent siblings for lazy frame construction.
+ // Eventually it would be even better to make RecreateFramesForContent
+ // accept a range and coalesce all adjacent reconstructs (bug 1344139).
+ size_t lazyRangeStart = i;
+ while (i < aChangeList.Length() && aChangeList[i].mContent &&
+ aChangeList[i].mContent->HasFlag(NODE_NEEDS_FRAME) &&
+ (i == lazyRangeStart ||
+ NextSiblingWhichMayHaveFrame(aChangeList[i - 1].mContent) ==
+ aChangeList[i].mContent)) {
+ MOZ_ASSERT(aChangeList[i].mHint & nsChangeHint_ReconstructFrame);
+ MOZ_ASSERT(!aChangeList[i].mFrame);
+ ++i;
+ }
+ if (i != lazyRangeStart) {
+ nsIContent* start = aChangeList[lazyRangeStart].mContent;
+ nsIContent* end =
+ NextSiblingWhichMayHaveFrame(aChangeList[i - 1].mContent);
+ if (!end) {
+ frameConstructor->ContentAppended(
+ start, nsCSSFrameConstructor::InsertionKind::Sync);
+ } else {
+ frameConstructor->ContentRangeInserted(
+ start, end, nsCSSFrameConstructor::InsertionKind::Sync);
+ }
+ }
+ for (size_t j = lazyRangeStart; j < i; ++j) {
+ MOZ_ASSERT(!aChangeList[j].mContent->GetPrimaryFrame() ||
+ !aChangeList[j].mContent->HasFlag(NODE_NEEDS_FRAME));
+ }
+ if (i == aChangeList.Length()) {
+ break;
+ }
+
+ const nsStyleChangeData& data = aChangeList[i];
+ nsIFrame* frame = data.mFrame;
+ nsIContent* content = data.mContent;
+ nsChangeHint hint = data.mHint;
+ bool didReflowThisFrame = false;
+
+ NS_ASSERTION(!(hint & nsChangeHint_AllReflowHints) ||
+ (hint & nsChangeHint_NeedReflow),
+ "Reflow hint bits set without actually asking for a reflow");
+
+ // skip any frame that has been destroyed due to a ripple effect
+ if (frame && mDestroyedFrames->Contains(frame)) {
+ continue;
+ }
+
+ if (frame && frame->GetContent() != content) {
+ // XXXbz this is due to image maps messing with the primary frame of
+ // <area>s. See bug 135040. Remove this block once that's fixed.
+ frame = nullptr;
+ if (!(hint & nsChangeHint_ReconstructFrame)) {
+ continue;
+ }
+ }
+
+ TryToDealWithScrollbarChange(hint, content, frame, presContext);
+ TryToHandleContainingBlockChange(hint, frame);
+
+ if (hint & nsChangeHint_ReconstructFrame) {
+ // If we ever start passing true here, be careful of restyles
+ // that involve a reframe and animations. In particular, if the
+ // restyle we're processing here is an animation restyle, but
+ // the style resolution we will do for the frame construction
+ // happens async when we're not in an animation restyle already,
+ // problems could arise.
+ // We could also have problems with triggering of CSS transitions
+ // on elements whose frames are reconstructed, since we depend on
+ // the reconstruction happening synchronously.
+ frameConstructor->RecreateFramesForContent(
+ content, nsCSSFrameConstructor::InsertionKind::Sync);
+ continue;
+ }
+
+ MOZ_ASSERT(frame, "This shouldn't happen");
+ if (hint & nsChangeHint_AddOrRemoveTransform) {
+ for (nsIFrame* cont = frame; cont;
+ cont = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) {
+ if (cont->StyleDisplay()->HasTransform(cont)) {
+ cont->AddStateBits(NS_FRAME_MAY_BE_TRANSFORMED);
+ }
+ // Don't remove NS_FRAME_MAY_BE_TRANSFORMED since it may still be
+ // transformed by other means. It's OK to have the bit even if it's
+ // not needed.
+ }
+ // When dropping a running transform animation we will first add an
+ // nsChangeHint_UpdateTransformLayer hint as part of the animation-only
+ // restyle. During the subsequent regular restyle, if the animation was
+ // the only reason the element had any transform applied, we will add
+ // nsChangeHint_AddOrRemoveTransform as part of the regular restyle.
+ //
+ // With the Gecko backend, these two change hints are processed
+ // after each restyle but when using the Servo backend they accumulate
+ // and are processed together after we have already removed the
+ // transform as part of the regular restyle. Since we don't actually
+ // need the nsChangeHint_UpdateTransformLayer hint if we already have
+ // a nsChangeHint_AddOrRemoveTransform hint, and since we
+ // will fail an assertion in ApplyRenderingChangeToTree if we try
+ // specify nsChangeHint_UpdateTransformLayer but don't have any
+ // transform style, we just drop the unneeded hint here.
+ hint &= ~nsChangeHint_UpdateTransformLayer;
+ }
+
+ if (!frame->FrameMaintainsOverflow()) {
+ // frame does not maintain overflow rects, so avoid calling
+ // FinishAndStoreOverflow on it:
+ hint &=
+ ~(nsChangeHint_UpdateOverflow | nsChangeHint_ChildrenOnlyTransform |
+ nsChangeHint_UpdatePostTransformOverflow |
+ nsChangeHint_UpdateParentOverflow |
+ nsChangeHint_UpdateSubtreeOverflow);
+ }
+
+ if (!frame->HasAnyStateBits(NS_FRAME_MAY_BE_TRANSFORMED)) {
+ // Frame can not be transformed, and thus a change in transform will
+ // have no effect and we should not use either
+ // nsChangeHint_UpdatePostTransformOverflow or
+ // nsChangeHint_UpdateTransformLayerhint.
+ hint &= ~(nsChangeHint_UpdatePostTransformOverflow |
+ nsChangeHint_UpdateTransformLayer);
+ }
+
+ if ((hint & nsChangeHint_UpdateEffects) &&
+ frame == nsLayoutUtils::FirstContinuationOrIBSplitSibling(frame)) {
+ SVGObserverUtils::UpdateEffects(frame);
+ }
+ if ((hint & nsChangeHint_InvalidateRenderingObservers) ||
+ ((hint & nsChangeHint_UpdateOpacityLayer) &&
+ frame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT))) {
+ SVGObserverUtils::InvalidateRenderingObservers(frame);
+ frame->SchedulePaint();
+ }
+ if (hint & nsChangeHint_NeedReflow) {
+ StyleChangeReflow(frame, hint);
+ didReflowThisFrame = true;
+ }
+
+ // Here we need to propagate repaint frame change hint instead of update
+ // opacity layer change hint when we do opacity optimization for SVG.
+ // We can't do it in nsStyleEffects::CalcDifference() just like we do
+ // for the optimization for 0.99 over opacity values since we have no way
+ // to call SVGUtils::CanOptimizeOpacity() there.
+ if ((hint & nsChangeHint_UpdateOpacityLayer) &&
+ SVGUtils::CanOptimizeOpacity(frame)) {
+ hint &= ~nsChangeHint_UpdateOpacityLayer;
+ hint |= nsChangeHint_RepaintFrame;
+ }
+
+ if ((hint & nsChangeHint_UpdateUsesOpacity) && frame->IsTablePart()) {
+ NS_ASSERTION(hint & nsChangeHint_UpdateOpacityLayer,
+ "should only return UpdateUsesOpacity hint "
+ "when also returning UpdateOpacityLayer hint");
+ // When an internal table part (including cells) changes between
+ // having opacity 1 and non-1, it changes whether its
+ // backgrounds (and those of table parts inside of it) are
+ // painted as part of the table's nsDisplayTableBorderBackground
+ // display item, or part of its own display item. That requires
+ // invalidation, so change UpdateOpacityLayer to RepaintFrame.
+ hint &= ~nsChangeHint_UpdateOpacityLayer;
+ hint |= nsChangeHint_RepaintFrame;
+ }
+
+ // Opacity disables preserve-3d, so if we toggle it, then we also need
+ // to update the overflow areas of all potentially affected frames.
+ if ((hint & nsChangeHint_UpdateUsesOpacity) &&
+ frame->StyleDisplay()->mTransformStyle ==
+ StyleTransformStyle::Preserve3d) {
+ hint |= nsChangeHint_UpdateSubtreeOverflow;
+ }
+
+ if (hint & nsChangeHint_UpdateBackgroundPosition) {
+ // For most frame types, DLBI can detect background position changes,
+ // so we only need to schedule a paint.
+ hint |= nsChangeHint_SchedulePaint;
+ if (frame->IsTablePart() || frame->IsMathMLFrame()) {
+ // Table parts and MathML frames don't build display items for their
+ // backgrounds, so DLBI can't detect background-position changes for
+ // these frames. Repaint the whole frame.
+ hint |= nsChangeHint_RepaintFrame;
+ }
+ }
+
+ if (hint &
+ (nsChangeHint_RepaintFrame | nsChangeHint_UpdateOpacityLayer |
+ nsChangeHint_UpdateTransformLayer |
+ nsChangeHint_ChildrenOnlyTransform | nsChangeHint_SchedulePaint)) {
+ ApplyRenderingChangeToTree(presContext->PresShell(), frame, hint);
+ }
+
+ if (hint & (nsChangeHint_UpdateTransformLayer |
+ nsChangeHint_AddOrRemoveTransform)) {
+ // We need to trigger re-snapping to this content if we snapped to the
+ // content on the last scroll operation.
+ ScrollSnapUtils::PostPendingResnapIfNeededFor(frame);
+ }
+
+ if ((hint & nsChangeHint_RecomputePosition) && !didReflowThisFrame) {
+ // It is possible for this to fall back to a reflow
+ if (!RecomputePosition(frame)) {
+ StyleChangeReflow(frame, nsChangeHint_NeedReflow |
+ nsChangeHint_ReflowChangesSizeOrPosition);
+ didReflowThisFrame = true;
+ }
+ }
+ NS_ASSERTION(!(hint & nsChangeHint_ChildrenOnlyTransform) ||
+ (hint & nsChangeHint_UpdateOverflow),
+ "nsChangeHint_UpdateOverflow should be passed too");
+ if (!didReflowThisFrame &&
+ (hint & (nsChangeHint_UpdateOverflow |
+ nsChangeHint_UpdatePostTransformOverflow |
+ nsChangeHint_UpdateParentOverflow |
+ nsChangeHint_UpdateSubtreeOverflow))) {
+ if (hint & nsChangeHint_UpdateSubtreeOverflow) {
+ for (nsIFrame* cont = frame; cont;
+ cont = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) {
+ AddSubtreeToOverflowTracker(cont, mOverflowChangedTracker);
+ }
+ // The work we just did in AddSubtreeToOverflowTracker
+ // subsumes some of the other hints:
+ hint &= ~(nsChangeHint_UpdateOverflow |
+ nsChangeHint_UpdatePostTransformOverflow);
+ }
+ if (hint & nsChangeHint_ChildrenOnlyTransform) {
+ // We need to update overflows. The correct frame(s) to update depends
+ // on whether the ChangeHint came from an outer or an inner svg.
+ nsIFrame* hintFrame = GetFrameForChildrenOnlyTransformHint(frame);
+ NS_ASSERTION(!nsLayoutUtils::GetNextContinuationOrIBSplitSibling(frame),
+ "SVG frames should not have continuations "
+ "or ib-split siblings");
+ NS_ASSERTION(
+ !nsLayoutUtils::GetNextContinuationOrIBSplitSibling(hintFrame),
+ "SVG frames should not have continuations "
+ "or ib-split siblings");
+ if (hintFrame->IsSVGOuterSVGAnonChildFrame()) {
+ // The children only transform of an outer svg frame is applied to
+ // the outer svg's anonymous child frame (instead of to the
+ // anonymous child's children).
+
+ if (!CanSkipOverflowUpdates(hintFrame)) {
+ mOverflowChangedTracker.AddFrame(
+ hintFrame, OverflowChangedTracker::CHILDREN_CHANGED);
+ }
+ } else {
+ // The children only transform is applied to the child frames of an
+ // inner svg frame, so update the child overflows.
+ nsIFrame* childFrame = hintFrame->PrincipalChildList().FirstChild();
+ for (; childFrame; childFrame = childFrame->GetNextSibling()) {
+ MOZ_ASSERT(childFrame->IsSVGFrame(),
+ "Not expecting non-SVG children");
+ if (!CanSkipOverflowUpdates(childFrame)) {
+ mOverflowChangedTracker.AddFrame(
+ childFrame, OverflowChangedTracker::CHILDREN_CHANGED);
+ }
+ NS_ASSERTION(
+ !nsLayoutUtils::GetNextContinuationOrIBSplitSibling(childFrame),
+ "SVG frames should not have continuations "
+ "or ib-split siblings");
+ NS_ASSERTION(
+ childFrame->GetParent() == hintFrame,
+ "SVG child frame not expected to have different parent");
+ }
+ }
+ }
+ if (!CanSkipOverflowUpdates(frame)) {
+ if (hint & (nsChangeHint_UpdateOverflow |
+ nsChangeHint_UpdatePostTransformOverflow)) {
+ OverflowChangedTracker::ChangeKind changeKind;
+ // If we have both nsChangeHint_UpdateOverflow and
+ // nsChangeHint_UpdatePostTransformOverflow,
+ // CHILDREN_CHANGED is selected as it is
+ // strictly stronger.
+ if (hint & nsChangeHint_UpdateOverflow) {
+ changeKind = OverflowChangedTracker::CHILDREN_CHANGED;
+ } else {
+ changeKind = OverflowChangedTracker::TRANSFORM_CHANGED;
+ }
+ for (nsIFrame* cont = frame; cont;
+ cont =
+ nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) {
+ mOverflowChangedTracker.AddFrame(cont, changeKind);
+ }
+ }
+ // UpdateParentOverflow hints need to be processed in addition
+ // to the above, since if the processing of the above hints
+ // yields no change, the update will not propagate to the
+ // parent.
+ if (hint & nsChangeHint_UpdateParentOverflow) {
+ MOZ_ASSERT(frame->GetParent(),
+ "shouldn't get style hints for the root frame");
+ for (nsIFrame* cont = frame; cont;
+ cont =
+ nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) {
+ mOverflowChangedTracker.AddFrame(
+ cont->GetParent(), OverflowChangedTracker::CHILDREN_CHANGED);
+ }
+ }
+ }
+ }
+ if ((hint & nsChangeHint_UpdateCursor) && !didUpdateCursor) {
+ presContext->PresShell()->SynthesizeMouseMove(false);
+ didUpdateCursor = true;
+ }
+ if (hint & nsChangeHint_UpdateTableCellSpans) {
+ frameConstructor->UpdateTableCellSpans(content);
+ }
+ if (hint & nsChangeHint_VisibilityChange) {
+ frame->UpdateVisibleDescendantsState();
+ }
+ }
+
+ aChangeList.Clear();
+ FlushOverflowChangedTracker();
+}
+
+/* static */
+uint64_t RestyleManager::GetAnimationGenerationForFrame(nsIFrame* aStyleFrame) {
+ EffectSet* effectSet = EffectSet::GetForStyleFrame(aStyleFrame);
+ return effectSet ? effectSet->GetAnimationGeneration() : 0;
+}
+
+void RestyleManager::IncrementAnimationGeneration() {
+ // We update the animation generation at start of each call to
+ // ProcessPendingRestyles so we should ignore any subsequent (redundant)
+ // calls that occur while we are still processing restyles.
+ if (!mInStyleRefresh) {
+ ++mAnimationGeneration;
+ }
+}
+
+/* static */
+void RestyleManager::AddLayerChangesForAnimation(
+ nsIFrame* aStyleFrame, nsIFrame* aPrimaryFrame, Element* aElement,
+ nsChangeHint aHintForThisFrame, nsStyleChangeList& aChangeListToProcess) {
+ MOZ_ASSERT(aElement);
+ MOZ_ASSERT(!!aStyleFrame == !!aPrimaryFrame);
+ if (!aStyleFrame) {
+ return;
+ }
+
+ uint64_t frameGeneration =
+ RestyleManager::GetAnimationGenerationForFrame(aStyleFrame);
+
+ Maybe<nsCSSPropertyIDSet> effectiveAnimationProperties;
+
+ nsChangeHint hint = nsChangeHint(0);
+ auto maybeApplyChangeHint = [&](const Maybe<uint64_t>& aGeneration,
+ DisplayItemType aDisplayItemType) -> bool {
+ if (aGeneration && frameGeneration != *aGeneration) {
+ // If we have a transform layer but don't have any transform style, we
+ // probably just removed the transform but haven't destroyed the layer
+ // yet. In this case we will typically add the appropriate change hint
+ // (nsChangeHint_UpdateContainingBlock) when we compare styles so in
+ // theory we could skip adding any change hint here.
+ //
+ // However, sometimes when we compare styles we'll get no change. For
+ // example, if the transform style was 'none' when we sent the transform
+ // animation to the compositor and the current transform style is now
+ // 'none' we'll think nothing changed but actually we still need to
+ // trigger an update to clear whatever style the transform animation set
+ // on the compositor. To handle this case we simply set all the change
+ // hints relevant to removing transform style (since we don't know exactly
+ // what changes happened while the animation was running on the
+ // compositor).
+ //
+ // Note that we *don't* add nsChangeHint_UpdateTransformLayer since if we
+ // did, ApplyRenderingChangeToTree would complain that we're updating a
+ // transform layer without a transform.
+ if (aDisplayItemType == DisplayItemType::TYPE_TRANSFORM &&
+ !aStyleFrame->StyleDisplay()->HasTransformStyle()) {
+ // Add all the hints for a removing a transform if they are not already
+ // set for this frame.
+ if (!(NS_IsHintSubset(nsChangeHint_ComprehensiveAddOrRemoveTransform,
+ aHintForThisFrame))) {
+ hint |= nsChangeHint_ComprehensiveAddOrRemoveTransform;
+ }
+ return true;
+ }
+ hint |= LayerAnimationInfo::GetChangeHintFor(aDisplayItemType);
+ }
+
+ // We consider it's the first paint for the frame if we have an animation
+ // for the property but have no layer, for the case of WebRender, no
+ // corresponding animation info.
+ // Note that in case of animations which has properties preventing running
+ // on the compositor, e.g., width or height, corresponding layer is not
+ // created at all, but even in such cases, we normally set valid change
+ // hint for such animations in each tick, i.e. restyles in each tick. As
+ // a result, we usually do restyles for such animations in every tick on
+ // the main-thread. The only animations which will be affected by this
+ // explicit change hint are animations that have opacity/transform but did
+ // not have those properies just before. e.g, setting transform by
+ // setKeyframes or changing target element from other target which prevents
+ // running on the compositor, etc.
+ if (!aGeneration) {
+ nsChangeHint hintForDisplayItem =
+ LayerAnimationInfo::GetChangeHintFor(aDisplayItemType);
+ // We don't need to apply the corresponding change hint if we already have
+ // it.
+ if (NS_IsHintSubset(hintForDisplayItem, aHintForThisFrame)) {
+ return true;
+ }
+
+ if (!effectiveAnimationProperties) {
+ effectiveAnimationProperties.emplace(
+ nsLayoutUtils::GetAnimationPropertiesForCompositor(aStyleFrame));
+ }
+ const nsCSSPropertyIDSet& propertiesForDisplayItem =
+ LayerAnimationInfo::GetCSSPropertiesFor(aDisplayItemType);
+ if (effectiveAnimationProperties->Intersects(propertiesForDisplayItem)) {
+ hint |= hintForDisplayItem;
+ }
+ }
+ return true;
+ };
+
+ AnimationInfo::EnumerateGenerationOnFrame(
+ aStyleFrame, aElement, LayerAnimationInfo::sDisplayItemTypes,
+ maybeApplyChangeHint);
+
+ if (hint) {
+ // We apply the hint to the primary frame, not the style frame. Transform
+ // and opacity hints apply to the table wrapper box, not the table box.
+ aChangeListToProcess.AppendChange(aPrimaryFrame, aElement, hint);
+ }
+}
+
+RestyleManager::AnimationsWithDestroyedFrame::AnimationsWithDestroyedFrame(
+ RestyleManager* aRestyleManager)
+ : mRestyleManager(aRestyleManager),
+ mRestorePointer(mRestyleManager->mAnimationsWithDestroyedFrame) {
+ MOZ_ASSERT(!mRestyleManager->mAnimationsWithDestroyedFrame,
+ "shouldn't construct recursively");
+ mRestyleManager->mAnimationsWithDestroyedFrame = this;
+}
+
+void RestyleManager::AnimationsWithDestroyedFrame ::
+ StopAnimationsForElementsWithoutFrames() {
+ StopAnimationsWithoutFrame(mContents, PseudoStyleType::NotPseudo);
+ StopAnimationsWithoutFrame(mBeforeContents, PseudoStyleType::before);
+ StopAnimationsWithoutFrame(mAfterContents, PseudoStyleType::after);
+ StopAnimationsWithoutFrame(mMarkerContents, PseudoStyleType::marker);
+}
+
+void RestyleManager::AnimationsWithDestroyedFrame ::StopAnimationsWithoutFrame(
+ nsTArray<RefPtr<nsIContent>>& aArray, PseudoStyleType aPseudoType) {
+ nsAnimationManager* animationManager =
+ mRestyleManager->PresContext()->AnimationManager();
+ nsTransitionManager* transitionManager =
+ mRestyleManager->PresContext()->TransitionManager();
+ for (nsIContent* content : aArray) {
+ if (aPseudoType == PseudoStyleType::NotPseudo) {
+ if (content->GetPrimaryFrame()) {
+ continue;
+ }
+ } else if (aPseudoType == PseudoStyleType::before) {
+ if (nsLayoutUtils::GetBeforeFrame(content)) {
+ continue;
+ }
+ } else if (aPseudoType == PseudoStyleType::after) {
+ if (nsLayoutUtils::GetAfterFrame(content)) {
+ continue;
+ }
+ } else if (aPseudoType == PseudoStyleType::marker) {
+ if (nsLayoutUtils::GetMarkerFrame(content)) {
+ continue;
+ }
+ }
+ dom::Element* element = content->AsElement();
+
+ animationManager->StopAnimationsForElement(element, aPseudoType);
+ transitionManager->StopAnimationsForElement(element, aPseudoType);
+
+ // All other animations should keep running but not running on the
+ // *compositor* at this point.
+ if (EffectSet* effectSet = EffectSet::Get(element, aPseudoType)) {
+ for (KeyframeEffect* effect : *effectSet) {
+ effect->ResetIsRunningOnCompositor();
+ }
+ }
+ }
+}
+
+#ifdef DEBUG
+static bool IsAnonBox(const nsIFrame* aFrame) {
+ return aFrame->Style()->IsAnonBox();
+}
+
+static const nsIFrame* FirstContinuationOrPartOfIBSplit(
+ const nsIFrame* aFrame) {
+ if (!aFrame) {
+ return nullptr;
+ }
+
+ return nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame);
+}
+
+static const nsIFrame* ExpectedOwnerForChild(const nsIFrame* aFrame) {
+ const nsIFrame* parent = aFrame->GetParent();
+ if (aFrame->IsTableFrame()) {
+ MOZ_ASSERT(parent->IsTableWrapperFrame());
+ parent = parent->GetParent();
+ }
+
+ if (IsAnonBox(aFrame) && !aFrame->IsTextFrame()) {
+ if (parent->IsLineFrame()) {
+ parent = parent->GetParent();
+ }
+ return parent->IsViewportFrame() ? nullptr
+ : FirstContinuationOrPartOfIBSplit(parent);
+ }
+
+ if (aFrame->IsLineFrame()) {
+ // A ::first-line always ends up here via its block, which is therefore the
+ // right expected owner. That block can be an
+ // anonymous box. For example, we could have a ::first-line on a columnated
+ // block; the blockframe is the column-content anonymous box in that case.
+ // So we don't want to end up in the code below, which steps out of anon
+ // boxes. Just return the parent of the line frame, which is the block.
+ return parent;
+ }
+
+ if (aFrame->IsLetterFrame()) {
+ // Ditto for ::first-letter. A first-letter always arrives here via its
+ // direct parent, except when it's parented to a ::first-line.
+ if (parent->IsLineFrame()) {
+ parent = parent->GetParent();
+ }
+ return FirstContinuationOrPartOfIBSplit(parent);
+ }
+
+ if (parent->IsLetterFrame()) {
+ // Things never have ::first-letter as their expected parent. Go
+ // on up to the ::first-letter's parent.
+ parent = parent->GetParent();
+ }
+
+ parent = FirstContinuationOrPartOfIBSplit(parent);
+
+ // We've handled already anon boxes, so now we're looking at
+ // a frame of a DOM element or pseudo. Hop through anon and line-boxes
+ // generated by our DOM parent, and go find the owner frame for it.
+ while (parent && (IsAnonBox(parent) || parent->IsLineFrame())) {
+ auto pseudo = parent->Style()->GetPseudoType();
+ if (pseudo == PseudoStyleType::tableWrapper) {
+ const nsIFrame* tableFrame = parent->PrincipalChildList().FirstChild();
+ MOZ_ASSERT(tableFrame->IsTableFrame());
+ // Handle :-moz-table and :-moz-inline-table.
+ parent = IsAnonBox(tableFrame) ? parent->GetParent() : tableFrame;
+ } else {
+ // We get the in-flow parent here so that we can handle the OOF anonymous
+ // boxed to get the correct parent.
+ parent = parent->GetInFlowParent();
+ }
+ parent = FirstContinuationOrPartOfIBSplit(parent);
+ }
+
+ return parent;
+}
+
+// FIXME(emilio, bug 1633685): We should ideally figure out how to properly
+// restyle replicated fixed pos frames... We seem to assume everywhere that they
+// can't get restyled at the moment...
+static bool IsInReplicatedFixedPosTree(const nsIFrame* aFrame) {
+ if (!aFrame->PresContext()->IsPaginated()) {
+ return false;
+ }
+
+ for (; aFrame; aFrame = aFrame->GetParent()) {
+ if (aFrame->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
+ !aFrame->FirstContinuation()->IsPrimaryFrame() &&
+ nsLayoutUtils::IsReallyFixedPos(aFrame)) {
+ return true;
+ }
+ }
+
+ return true;
+}
+
+void ServoRestyleState::AssertOwner(const ServoRestyleState& aParent) const {
+ MOZ_ASSERT(mOwner);
+ MOZ_ASSERT(!mOwner->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW));
+ MOZ_ASSERT(!mOwner->IsColumnSpanInMulticolSubtree());
+ // We allow aParent.mOwner to be null, for cases when we're not starting at
+ // the root of the tree. We also allow aParent.mOwner to be somewhere up our
+ // expected owner chain not our immediate owner, which allows us creating long
+ // chains of ServoRestyleStates in some cases where it's just not worth it.
+ if (aParent.mOwner) {
+ const nsIFrame* owner = ExpectedOwnerForChild(mOwner);
+ if (owner != aParent.mOwner && !IsInReplicatedFixedPosTree(mOwner)) {
+ MOZ_ASSERT(IsAnonBox(owner),
+ "Should only have expected owner weirdness when anon boxes "
+ "are involved");
+ bool found = false;
+ for (; owner; owner = ExpectedOwnerForChild(owner)) {
+ if (owner == aParent.mOwner) {
+ found = true;
+ break;
+ }
+ }
+ MOZ_ASSERT(found, "Must have aParent.mOwner on our expected owner chain");
+ }
+ }
+}
+
+nsChangeHint ServoRestyleState::ChangesHandledFor(
+ const nsIFrame* aFrame) const {
+ if (!mOwner) {
+ MOZ_ASSERT(!mChangesHandled);
+ return mChangesHandled;
+ }
+
+ MOZ_ASSERT(mOwner == ExpectedOwnerForChild(aFrame) ||
+ IsInReplicatedFixedPosTree(aFrame),
+ "Missed some frame in the hierarchy?");
+ return mChangesHandled;
+}
+#endif
+
+void ServoRestyleState::AddPendingWrapperRestyle(nsIFrame* aWrapperFrame) {
+ MOZ_ASSERT(aWrapperFrame->Style()->IsWrapperAnonBox(),
+ "All our wrappers are anon boxes, and why would we restyle "
+ "non-inheriting ones?");
+ MOZ_ASSERT(aWrapperFrame->Style()->IsInheritingAnonBox(),
+ "All our wrappers are anon boxes, and why would we restyle "
+ "non-inheriting ones?");
+ MOZ_ASSERT(
+ aWrapperFrame->Style()->GetPseudoType() != PseudoStyleType::cellContent,
+ "Someone should be using TableAwareParentFor");
+ MOZ_ASSERT(
+ aWrapperFrame->Style()->GetPseudoType() != PseudoStyleType::tableWrapper,
+ "Someone should be using TableAwareParentFor");
+ // Make sure we only add first continuations.
+ aWrapperFrame = aWrapperFrame->FirstContinuation();
+ nsIFrame* last = mPendingWrapperRestyles.SafeLastElement(nullptr);
+ if (last == aWrapperFrame) {
+ // Already queued up, nothing to do.
+ return;
+ }
+
+ // Make sure to queue up parents before children. But don't queue up
+ // ancestors of non-anonymous boxes here; those are handled when we traverse
+ // their non-anonymous kids.
+ if (aWrapperFrame->ParentIsWrapperAnonBox()) {
+ AddPendingWrapperRestyle(TableAwareParentFor(aWrapperFrame));
+ }
+
+ // If the append fails, we'll fail to restyle properly, but that's probably
+ // better than crashing.
+ if (mPendingWrapperRestyles.AppendElement(aWrapperFrame, fallible)) {
+ aWrapperFrame->SetIsWrapperAnonBoxNeedingRestyle(true);
+ }
+}
+
+void ServoRestyleState::ProcessWrapperRestyles(nsIFrame* aParentFrame) {
+ size_t i = mPendingWrapperRestyleOffset;
+ while (i < mPendingWrapperRestyles.Length()) {
+ i += ProcessMaybeNestedWrapperRestyle(aParentFrame, i);
+ }
+
+ mPendingWrapperRestyles.TruncateLength(mPendingWrapperRestyleOffset);
+}
+
+size_t ServoRestyleState::ProcessMaybeNestedWrapperRestyle(nsIFrame* aParent,
+ size_t aIndex) {
+ // The frame at index aIndex is something we should restyle ourselves, but
+ // following frames may need separate ServoRestyleStates to restyle.
+ MOZ_ASSERT(aIndex < mPendingWrapperRestyles.Length());
+
+ nsIFrame* cur = mPendingWrapperRestyles[aIndex];
+ MOZ_ASSERT(cur->Style()->IsWrapperAnonBox());
+
+ // Where is cur supposed to inherit from? From its parent frame, except in
+ // the case when cur is a table, in which case it should be its grandparent.
+ // Also, not in the case when the resulting frame would be a first-line; in
+ // that case we should be inheriting from the block, and the first-line will
+ // do its fixup later if needed.
+ //
+ // Note that after we do all that fixup the parent we get might still not be
+ // aParent; for example aParent could be a scrollframe, in which case we
+ // should inherit from the scrollcontent frame. Or the parent might be some
+ // continuation of aParent.
+ //
+ // Try to assert as much as we can about the parent we actually end up using
+ // without triggering bogus asserts in all those various edge cases.
+ nsIFrame* parent = cur->GetParent();
+ if (cur->IsTableFrame()) {
+ MOZ_ASSERT(parent->IsTableWrapperFrame());
+ parent = parent->GetParent();
+ }
+ if (parent->IsLineFrame()) {
+ parent = parent->GetParent();
+ }
+ MOZ_ASSERT(FirstContinuationOrPartOfIBSplit(parent) == aParent ||
+ (parent->Style()->IsInheritingAnonBox() &&
+ parent->GetContent() == aParent->GetContent()));
+
+ // Now "this" is a ServoRestyleState for aParent, so if parent is not a next
+ // continuation (possibly across ib splits) of aParent we need a new
+ // ServoRestyleState for the kid.
+ Maybe<ServoRestyleState> parentRestyleState;
+ nsIFrame* parentForRestyle =
+ nsLayoutUtils::FirstContinuationOrIBSplitSibling(parent);
+ if (parentForRestyle != aParent) {
+ parentRestyleState.emplace(*parentForRestyle, *this, nsChangeHint_Empty,
+ Type::InFlow);
+ }
+ ServoRestyleState& curRestyleState =
+ parentRestyleState ? *parentRestyleState : *this;
+
+ // This frame may already have been restyled. Even if it has, we can't just
+ // return, because the next frame may be a kid of it that does need restyling.
+ if (cur->IsWrapperAnonBoxNeedingRestyle()) {
+ parentForRestyle->UpdateStyleOfChildAnonBox(cur, curRestyleState);
+ cur->SetIsWrapperAnonBoxNeedingRestyle(false);
+ }
+
+ size_t numProcessed = 1;
+
+ // Note: no overflow possible here, since aIndex < length.
+ if (aIndex + 1 < mPendingWrapperRestyles.Length()) {
+ nsIFrame* next = mPendingWrapperRestyles[aIndex + 1];
+ if (TableAwareParentFor(next) == cur &&
+ next->IsWrapperAnonBoxNeedingRestyle()) {
+ // It might be nice if we could do better than nsChangeHint_Empty. On
+ // the other hand, presumably our mChangesHandled already has the bits
+ // we really want here so in practice it doesn't matter.
+ ServoRestyleState childState(*cur, curRestyleState, nsChangeHint_Empty,
+ Type::InFlow,
+ /* aAssertWrapperRestyleLength = */ false);
+ numProcessed +=
+ childState.ProcessMaybeNestedWrapperRestyle(cur, aIndex + 1);
+ }
+ }
+
+ return numProcessed;
+}
+
+nsIFrame* ServoRestyleState::TableAwareParentFor(const nsIFrame* aChild) {
+ // We want to get the anon box parent for aChild. where aChild has
+ // ParentIsWrapperAnonBox().
+ //
+ // For the most part this is pretty straightforward, but there are two
+ // wrinkles. First, if aChild is a table, then we really want the parent of
+ // its table wrapper.
+ if (aChild->IsTableFrame()) {
+ aChild = aChild->GetParent();
+ MOZ_ASSERT(aChild->IsTableWrapperFrame());
+ }
+
+ nsIFrame* parent = aChild->GetParent();
+ // Now if parent is a cell-content frame, we actually want the cellframe.
+ if (parent->Style()->GetPseudoType() == PseudoStyleType::cellContent) {
+ parent = parent->GetParent();
+ } else if (parent->IsTableWrapperFrame()) {
+ // Must be a caption. In that case we want the table here.
+ MOZ_ASSERT(aChild->StyleDisplay()->mDisplay == StyleDisplay::TableCaption);
+ parent = parent->PrincipalChildList().FirstChild();
+ }
+ return parent;
+}
+
+void RestyleManager::PostRestyleEvent(Element* aElement,
+ RestyleHint aRestyleHint,
+ nsChangeHint aMinChangeHint) {
+ MOZ_ASSERT(!(aMinChangeHint & nsChangeHint_NeutralChange),
+ "Didn't expect explicit change hints to be neutral!");
+ if (MOZ_UNLIKELY(IsDisconnected()) ||
+ MOZ_UNLIKELY(PresContext()->PresShell()->IsDestroying())) {
+ return;
+ }
+
+ // We allow posting restyles from within change hint handling, but not from
+ // within the restyle algorithm itself.
+ MOZ_ASSERT(!ServoStyleSet::IsInServoTraversal());
+
+ if (!aRestyleHint && !aMinChangeHint) {
+ // FIXME(emilio): we should assert against this instead.
+ return; // Nothing to do.
+ }
+
+ // Assuming the restyle hints will invalidate cached style for
+ // getComputedStyle, since we don't know if any of the restyling that we do
+ // would affect undisplayed elements.
+ if (aRestyleHint) {
+ if (!(aRestyleHint & RestyleHint::ForAnimations())) {
+ mHaveNonAnimationRestyles = true;
+ }
+
+ IncrementUndisplayedRestyleGeneration();
+ }
+
+ // Processing change hints sometimes causes new change hints to be generated,
+ // and very occasionally, additional restyle hints. We collect the change
+ // hints manually to avoid re-traversing the DOM to find them.
+ if (mReentrantChanges && !aRestyleHint) {
+ mReentrantChanges->AppendElement(ReentrantChange{aElement, aMinChangeHint});
+ return;
+ }
+
+ if (aRestyleHint || aMinChangeHint) {
+ Servo_NoteExplicitHints(aElement, aRestyleHint, aMinChangeHint);
+ }
+}
+
+void RestyleManager::PostRestyleEventForAnimations(Element* aElement,
+ PseudoStyleType aPseudoType,
+ RestyleHint aRestyleHint) {
+ Element* elementToRestyle =
+ AnimationUtils::GetElementForRestyle(aElement, aPseudoType);
+
+ if (!elementToRestyle) {
+ // FIXME: Bug 1371107: When reframing happens,
+ // EffectCompositor::mElementsToRestyle still has unbound old pseudo
+ // element. We should drop it.
+ return;
+ }
+
+ mPresContext->TriggeredAnimationRestyle();
+
+ Servo_NoteExplicitHints(elementToRestyle, aRestyleHint, nsChangeHint(0));
+}
+
+void RestyleManager::RebuildAllStyleData(nsChangeHint aExtraHint,
+ RestyleHint aRestyleHint) {
+ // NOTE(emilio): The semantics of these methods are quite funny, in the sense
+ // that we're not supposed to need to rebuild the actual stylist data.
+ //
+ // That's handled as part of the MediumFeaturesChanged stuff, if needed.
+ //
+ // Clear the cached style data only if we are guaranteed to process the whole
+ // DOM tree again.
+ //
+ // FIXME(emilio): Decouple this, probably. This probably just wants to reset
+ // the "uses viewport units / uses rem" bits, and _maybe_ clear cached anon
+ // box styles and such... But it doesn't really always need to clear the
+ // initial style of the document and similar...
+ if (aRestyleHint.DefinitelyRecascadesAllSubtree()) {
+ StyleSet()->ClearCachedStyleData();
+ }
+
+ DocumentStyleRootIterator iter(mPresContext->Document());
+ while (Element* root = iter.GetNextStyleRoot()) {
+ PostRestyleEvent(root, aRestyleHint, aExtraHint);
+ }
+
+ // TODO(emilio, bz): Extensions can add/remove stylesheets that can affect
+ // non-inheriting anon boxes. It's not clear if we want to support that, but
+ // if we do, we need to re-selector-match them here.
+}
+
+/* static */
+void RestyleManager::ClearServoDataFromSubtree(Element* aElement,
+ IncludeRoot aIncludeRoot) {
+ if (aElement->HasServoData()) {
+ StyleChildrenIterator it(aElement);
+ for (nsIContent* n = it.GetNextChild(); n; n = it.GetNextChild()) {
+ if (n->IsElement()) {
+ ClearServoDataFromSubtree(n->AsElement(), IncludeRoot::Yes);
+ }
+ }
+ }
+
+ if (MOZ_LIKELY(aIncludeRoot == IncludeRoot::Yes)) {
+ aElement->ClearServoData();
+ MOZ_ASSERT(!aElement->HasAnyOfFlags(Element::kAllServoDescendantBits |
+ NODE_NEEDS_FRAME));
+ MOZ_ASSERT(aElement != aElement->OwnerDoc()->GetServoRestyleRoot());
+ }
+}
+
+/* static */
+void RestyleManager::ClearRestyleStateFromSubtree(Element* aElement) {
+ if (aElement->HasAnyOfFlags(Element::kAllServoDescendantBits)) {
+ StyleChildrenIterator it(aElement);
+ for (nsIContent* n = it.GetNextChild(); n; n = it.GetNextChild()) {
+ if (n->IsElement()) {
+ ClearRestyleStateFromSubtree(n->AsElement());
+ }
+ }
+ }
+
+ bool wasRestyled = false;
+ Unused << Servo_TakeChangeHint(aElement, &wasRestyled);
+ aElement->UnsetFlags(Element::kAllServoDescendantBits);
+}
+
+/**
+ * This struct takes care of encapsulating some common state that text nodes may
+ * need to track during the post-traversal.
+ *
+ * This is currently used to properly compute change hints when the parent
+ * element of this node is a display: contents node, and also to avoid computing
+ * the style for text children more than once per element.
+ */
+struct RestyleManager::TextPostTraversalState {
+ public:
+ TextPostTraversalState(Element& aParentElement, ComputedStyle* aParentContext,
+ bool aDisplayContentsParentStyleChanged,
+ ServoRestyleState& aParentRestyleState)
+ : mParentElement(aParentElement),
+ mParentContext(aParentContext),
+ mParentRestyleState(aParentRestyleState),
+ mStyle(nullptr),
+ mShouldPostHints(aDisplayContentsParentStyleChanged),
+ mShouldComputeHints(aDisplayContentsParentStyleChanged),
+ mComputedHint(nsChangeHint_Empty) {}
+
+ nsStyleChangeList& ChangeList() { return mParentRestyleState.ChangeList(); }
+
+ ComputedStyle& ComputeStyle(nsIContent* aTextNode) {
+ if (!mStyle) {
+ mStyle = mParentRestyleState.StyleSet().ResolveStyleForText(
+ aTextNode, &ParentStyle());
+ }
+ MOZ_ASSERT(mStyle);
+ return *mStyle;
+ }
+
+ void ComputeHintIfNeeded(nsIContent* aContent, nsIFrame* aTextFrame,
+ ComputedStyle& aNewStyle) {
+ MOZ_ASSERT(aTextFrame);
+ MOZ_ASSERT(aNewStyle.GetPseudoType() == PseudoStyleType::mozText);
+
+ if (MOZ_LIKELY(!mShouldPostHints)) {
+ return;
+ }
+
+ ComputedStyle* oldStyle = aTextFrame->Style();
+ MOZ_ASSERT(oldStyle->GetPseudoType() == PseudoStyleType::mozText);
+
+ // We rely on the fact that all the text children for the same element share
+ // style to avoid recomputing style differences for all of them.
+ //
+ // TODO(emilio): The above may not be true for ::first-{line,letter}, but
+ // we'll cross that bridge when we support those in stylo.
+ if (mShouldComputeHints) {
+ mShouldComputeHints = false;
+ uint32_t equalStructs;
+ mComputedHint = oldStyle->CalcStyleDifference(aNewStyle, &equalStructs);
+ mComputedHint = NS_RemoveSubsumedHints(
+ mComputedHint, mParentRestyleState.ChangesHandledFor(aTextFrame));
+ }
+
+ if (mComputedHint) {
+ mParentRestyleState.ChangeList().AppendChange(aTextFrame, aContent,
+ mComputedHint);
+ }
+ }
+
+ private:
+ ComputedStyle& ParentStyle() {
+ if (!mParentContext) {
+ mLazilyResolvedParentContext =
+ ServoStyleSet::ResolveServoStyle(mParentElement);
+ mParentContext = mLazilyResolvedParentContext;
+ }
+ return *mParentContext;
+ }
+
+ Element& mParentElement;
+ ComputedStyle* mParentContext;
+ RefPtr<ComputedStyle> mLazilyResolvedParentContext;
+ ServoRestyleState& mParentRestyleState;
+ RefPtr<ComputedStyle> mStyle;
+ bool mShouldPostHints;
+ bool mShouldComputeHints;
+ nsChangeHint mComputedHint;
+};
+
+static void UpdateBackdropIfNeeded(nsIFrame* aFrame, ServoStyleSet& aStyleSet,
+ nsStyleChangeList& aChangeList) {
+ const nsStyleDisplay* display = aFrame->Style()->StyleDisplay();
+ if (display->mTopLayer != StyleTopLayer::Top) {
+ return;
+ }
+
+ // Elements in the top layer are guaranteed to have absolute or fixed
+ // position per https://fullscreen.spec.whatwg.org/#new-stacking-layer.
+ MOZ_ASSERT(display->IsAbsolutelyPositionedStyle());
+
+ nsIFrame* backdropPlaceholder =
+ aFrame->GetChildList(FrameChildListID::Backdrop).FirstChild();
+ if (!backdropPlaceholder) {
+ return;
+ }
+
+ MOZ_ASSERT(backdropPlaceholder->IsPlaceholderFrame());
+ nsIFrame* backdropFrame =
+ nsPlaceholderFrame::GetRealFrameForPlaceholder(backdropPlaceholder);
+ MOZ_ASSERT(backdropFrame->IsBackdropFrame());
+ MOZ_ASSERT(backdropFrame->Style()->GetPseudoType() ==
+ PseudoStyleType::backdrop);
+
+ RefPtr<ComputedStyle> newStyle = aStyleSet.ResolvePseudoElementStyle(
+ *aFrame->GetContent()->AsElement(), PseudoStyleType::backdrop, nullptr,
+ aFrame->Style());
+
+ // NOTE(emilio): We can't use the changes handled for the owner of the
+ // backdrop frame, since it's out of flow, and parented to the viewport or
+ // canvas frame (depending on the `position` value).
+ MOZ_ASSERT(backdropFrame->GetParent()->IsViewportFrame() ||
+ backdropFrame->GetParent()->IsCanvasFrame());
+ nsTArray<nsIFrame*> wrappersToRestyle;
+ nsTArray<RefPtr<Element>> anchorsToSuppress;
+ ServoRestyleState state(aStyleSet, aChangeList, wrappersToRestyle,
+ anchorsToSuppress);
+ nsIFrame::UpdateStyleOfOwnedChildFrame(backdropFrame, newStyle, state);
+ MOZ_ASSERT(anchorsToSuppress.IsEmpty());
+}
+
+static void UpdateFirstLetterIfNeeded(nsIFrame* aFrame,
+ ServoRestyleState& aRestyleState) {
+ MOZ_ASSERT(
+ !aFrame->IsBlockFrameOrSubclass(),
+ "You're probably duplicating work with UpdatePseudoElementStyles!");
+ if (!aFrame->HasFirstLetterChild()) {
+ return;
+ }
+
+ // We need to find the block the first-letter is associated with so we can
+ // find the right element for the first-letter's style resolution. Might as
+ // well just delegate the whole thing to that block.
+ nsIFrame* block = aFrame->GetParent();
+ while (!block->IsBlockFrameOrSubclass()) {
+ block = block->GetParent();
+ }
+
+ static_cast<nsBlockFrame*>(block->FirstContinuation())
+ ->UpdateFirstLetterStyle(aRestyleState);
+}
+
+static void UpdateOneAdditionalComputedStyle(nsIFrame* aFrame, uint32_t aIndex,
+ ComputedStyle& aOldContext,
+ ServoRestyleState& aRestyleState) {
+ auto pseudoType = aOldContext.GetPseudoType();
+ MOZ_ASSERT(pseudoType != PseudoStyleType::NotPseudo);
+ MOZ_ASSERT(
+ !nsCSSPseudoElements::PseudoElementSupportsUserActionState(pseudoType));
+
+ RefPtr<ComputedStyle> newStyle =
+ aRestyleState.StyleSet().ResolvePseudoElementStyle(
+ *aFrame->GetContent()->AsElement(), pseudoType, nullptr,
+ aFrame->Style());
+
+ uint32_t equalStructs; // Not used, actually.
+ nsChangeHint childHint =
+ aOldContext.CalcStyleDifference(*newStyle, &equalStructs);
+ if (!aFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) &&
+ !aFrame->IsColumnSpanInMulticolSubtree()) {
+ childHint = NS_RemoveSubsumedHints(childHint,
+ aRestyleState.ChangesHandledFor(aFrame));
+ }
+
+ if (childHint) {
+ if (childHint & nsChangeHint_ReconstructFrame) {
+ // If we generate a reconstruct here, remove any non-reconstruct hints we
+ // may have already generated for this content.
+ aRestyleState.ChangeList().PopChangesForContent(aFrame->GetContent());
+ }
+ aRestyleState.ChangeList().AppendChange(aFrame, aFrame->GetContent(),
+ childHint);
+ }
+
+ aFrame->SetAdditionalComputedStyle(aIndex, newStyle);
+}
+
+static void UpdateAdditionalComputedStyles(nsIFrame* aFrame,
+ ServoRestyleState& aRestyleState) {
+ MOZ_ASSERT(aFrame);
+ MOZ_ASSERT(aFrame->GetContent() && aFrame->GetContent()->IsElement());
+
+ // FIXME(emilio): Consider adding a bit or something to avoid the initial
+ // virtual call?
+ uint32_t index = 0;
+ while (auto* oldStyle = aFrame->GetAdditionalComputedStyle(index)) {
+ UpdateOneAdditionalComputedStyle(aFrame, index++, *oldStyle, aRestyleState);
+ }
+}
+
+static void UpdateFramePseudoElementStyles(nsIFrame* aFrame,
+ ServoRestyleState& aRestyleState) {
+ if (nsBlockFrame* blockFrame = do_QueryFrame(aFrame)) {
+ blockFrame->UpdatePseudoElementStyles(aRestyleState);
+ } else {
+ UpdateFirstLetterIfNeeded(aFrame, aRestyleState);
+ }
+
+ UpdateBackdropIfNeeded(aFrame, aRestyleState.StyleSet(),
+ aRestyleState.ChangeList());
+}
+
+enum class ServoPostTraversalFlags : uint32_t {
+ Empty = 0,
+ // Whether parent was restyled.
+ ParentWasRestyled = 1 << 0,
+ // Skip sending accessibility notifications for all descendants.
+ SkipA11yNotifications = 1 << 1,
+ // Always send accessibility notifications if the element is shown.
+ // The SkipA11yNotifications flag above overrides this flag.
+ SendA11yNotificationsIfShown = 1 << 2,
+};
+
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(ServoPostTraversalFlags)
+
+static bool IsVisibleForA11y(const ComputedStyle& aStyle) {
+ return aStyle.StyleVisibility()->IsVisible() && !aStyle.StyleUI()->IsInert();
+}
+
+static bool IsSubtreeVisibleForA11y(const ComputedStyle& aStyle) {
+ return aStyle.StyleDisplay()->mContentVisibility !=
+ StyleContentVisibility::Hidden;
+}
+
+// Send proper accessibility notifications and return post traversal
+// flags for kids.
+static ServoPostTraversalFlags SendA11yNotifications(
+ nsPresContext* aPresContext, Element* aElement,
+ const ComputedStyle& aOldStyle, const ComputedStyle& aNewStyle,
+ ServoPostTraversalFlags aFlags) {
+ using Flags = ServoPostTraversalFlags;
+ MOZ_ASSERT(!(aFlags & Flags::SkipA11yNotifications) ||
+ !(aFlags & Flags::SendA11yNotificationsIfShown),
+ "The two a11y flags should never be set together");
+
+#ifdef ACCESSIBILITY
+ nsAccessibilityService* accService = GetAccService();
+ if (!accService) {
+ // If we don't have accessibility service, accessibility is not
+ // enabled. Just skip everything.
+ return Flags::Empty;
+ }
+
+ if (aNewStyle.StyleUIReset()->mMozSubtreeHiddenOnlyVisually !=
+ aOldStyle.StyleUIReset()->mMozSubtreeHiddenOnlyVisually) {
+ if (aElement->GetParent() &&
+ aElement->GetParent()->IsXULElement(nsGkAtoms::tabpanels)) {
+ accService->NotifyOfTabPanelVisibilityChange(
+ aPresContext->PresShell(), aElement,
+ aNewStyle.StyleUIReset()->mMozSubtreeHiddenOnlyVisually);
+ }
+ }
+
+ if (aFlags & Flags::SkipA11yNotifications) {
+ // Propagate the skipping flag to descendants.
+ return Flags::SkipA11yNotifications;
+ }
+
+ bool needsNotify = false;
+ const bool isVisible = IsVisibleForA11y(aNewStyle);
+ const bool wasVisible = IsVisibleForA11y(aOldStyle);
+
+ if (aFlags & Flags::SendA11yNotificationsIfShown) {
+ if (!isVisible) {
+ // Propagate the sending-if-shown flag to descendants.
+ return Flags::SendA11yNotificationsIfShown;
+ }
+ // We have asked accessibility service to remove the whole subtree
+ // of element which becomes invisible from the accessible tree, but
+ // this element is visible, so we need to add it back.
+ needsNotify = true;
+ } else {
+ // If we shouldn't skip in any case, we need to check whether our own
+ // visibility has changed.
+ // Also notify if the subtree visibility change due to content-visibility.
+ const bool isSubtreeVisible = IsSubtreeVisibleForA11y(aNewStyle);
+ const bool wasSubtreeVisible = IsSubtreeVisibleForA11y(aOldStyle);
+ needsNotify =
+ wasVisible != isVisible || wasSubtreeVisible != isSubtreeVisible;
+ }
+
+ if (needsNotify) {
+ PresShell* presShell = aPresContext->PresShell();
+ if (isVisible) {
+ accService->ContentRangeInserted(presShell, aElement,
+ aElement->GetNextSibling());
+ // We are adding the subtree. Accessibility service would handle
+ // descendants, so we should just skip them from notifying.
+ return Flags::SkipA11yNotifications;
+ }
+ if (wasVisible) {
+ // Remove the subtree of this invisible element, and ask any shown
+ // descendant to add themselves back.
+ accService->ContentRemoved(presShell, aElement);
+ return Flags::SendA11yNotificationsIfShown;
+ }
+ }
+#endif
+
+ return Flags::Empty;
+}
+
+bool RestyleManager::ProcessPostTraversal(Element* aElement,
+ ServoRestyleState& aRestyleState,
+ ServoPostTraversalFlags aFlags) {
+ nsIFrame* styleFrame = nsLayoutUtils::GetStyleFrame(aElement);
+ nsIFrame* primaryFrame = aElement->GetPrimaryFrame();
+
+ MOZ_DIAGNOSTIC_ASSERT(aElement->HasServoData(),
+ "Element without Servo data on a post-traversal? How?");
+
+ // NOTE(emilio): This is needed because for table frames the bit is set on the
+ // table wrapper (which is the primary frame), not on the table itself.
+ const bool isOutOfFlow =
+ primaryFrame && primaryFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
+
+ // We need this because any column-spanner's parent frame is not its DOM
+ // parent's primary frame. We need some special check similar to out-of-flow
+ // frames.
+ const bool isColumnSpan =
+ primaryFrame && primaryFrame->IsColumnSpanInMulticolSubtree();
+
+ // Grab the change hint from Servo.
+ bool wasRestyled = false;
+ nsChangeHint changeHint =
+ static_cast<nsChangeHint>(Servo_TakeChangeHint(aElement, &wasRestyled));
+
+ RefPtr<ComputedStyle> upToDateStyleIfRestyled =
+ wasRestyled ? ServoStyleSet::ResolveServoStyle(*aElement) : nullptr;
+
+ // We should really fix the weird primary frame mapping for image maps
+ // (bug 135040)...
+ if (styleFrame && styleFrame->GetContent() != aElement) {
+ MOZ_ASSERT(styleFrame->IsImageFrameOrSubclass());
+ styleFrame = nullptr;
+ }
+
+ // Handle lazy frame construction by posting a reconstruct for any lazily-
+ // constructed roots.
+ if (aElement->HasFlag(NODE_NEEDS_FRAME)) {
+ changeHint |= nsChangeHint_ReconstructFrame;
+ MOZ_ASSERT(!styleFrame);
+ }
+
+ if (styleFrame) {
+ MOZ_ASSERT(primaryFrame);
+
+ nsIFrame* maybeAnonBoxChild;
+ if (isOutOfFlow) {
+ maybeAnonBoxChild = primaryFrame->GetPlaceholderFrame();
+ } else {
+ maybeAnonBoxChild = primaryFrame;
+ // Do not subsume change hints for the column-spanner.
+ if (!isColumnSpan) {
+ changeHint = NS_RemoveSubsumedHints(
+ changeHint, aRestyleState.ChangesHandledFor(styleFrame));
+ }
+ }
+
+ // If the parent wasn't restyled, the styles of our anon box parents won't
+ // change either.
+ if ((aFlags & ServoPostTraversalFlags::ParentWasRestyled) &&
+ maybeAnonBoxChild->ParentIsWrapperAnonBox()) {
+ aRestyleState.AddPendingWrapperRestyle(
+ ServoRestyleState::TableAwareParentFor(maybeAnonBoxChild));
+ }
+
+ // If we don't have a ::marker pseudo-element, but need it, then
+ // reconstruct the frame. (The opposite situation implies 'display'
+ // changes so doesn't need to be handled explicitly here.)
+ if (wasRestyled && styleFrame->StyleDisplay()->IsListItem() &&
+ styleFrame->IsBlockFrameOrSubclass() &&
+ !nsLayoutUtils::GetMarkerPseudo(aElement)) {
+ RefPtr<ComputedStyle> pseudoStyle =
+ aRestyleState.StyleSet().ProbePseudoElementStyle(
+ *aElement, PseudoStyleType::marker, nullptr,
+ upToDateStyleIfRestyled);
+ if (pseudoStyle) {
+ changeHint |= nsChangeHint_ReconstructFrame;
+ }
+ }
+ }
+
+ // Although we shouldn't generate non-ReconstructFrame hints for elements with
+ // no frames, we can still get them here if they were explicitly posted by
+ // PostRestyleEvent, such as a RepaintFrame hint when a :link changes to be
+ // :visited. Skip processing these hints if there is no frame.
+ if ((styleFrame || (changeHint & nsChangeHint_ReconstructFrame)) &&
+ changeHint) {
+ aRestyleState.ChangeList().AppendChange(styleFrame, aElement, changeHint);
+ }
+
+ // If our change hint is reconstruct, we delegate to the frame constructor,
+ // which consumes the new style and expects the old style to be on the frame.
+ //
+ // XXXbholley: We should teach the frame constructor how to clear the dirty
+ // descendants bit to avoid the traversal here.
+ if (changeHint & nsChangeHint_ReconstructFrame) {
+ if (wasRestyled &&
+ StaticPrefs::layout_css_scroll_anchoring_suppressions_enabled()) {
+ const bool wasAbsPos =
+ styleFrame &&
+ styleFrame->StyleDisplay()->IsAbsolutelyPositionedStyle();
+ auto* newDisp = upToDateStyleIfRestyled->StyleDisplay();
+ // https://drafts.csswg.org/css-scroll-anchoring/#suppression-triggers
+ //
+ // We need to do the position check here rather than in
+ // DidSetComputedStyle because changing position reframes.
+ //
+ // We suppress adjustments whenever we change from being display: none to
+ // be an abspos.
+ //
+ // Similarly, for other changes from abspos to non-abspos styles.
+ //
+ // TODO(emilio): I _think_ chrome won't suppress adjustments whenever
+ // `display` changes. But that causes some infinite loops in cases like
+ // bug 1568778.
+ if (wasAbsPos != newDisp->IsAbsolutelyPositionedStyle()) {
+ aRestyleState.AddPendingScrollAnchorSuppression(aElement);
+ }
+ }
+ ClearRestyleStateFromSubtree(aElement);
+ return true;
+ }
+
+ // TODO(emilio): We could avoid some refcount traffic here, specially in the
+ // ComputedStyle case, which uses atomic refcounting.
+ //
+ // Hold the ComputedStyle alive, because it could become a dangling pointer
+ // during the replacement. In practice it's not a huge deal, but better not
+ // playing with dangling pointers if not needed.
+ //
+ // NOTE(emilio): We could keep around the old computed style for display:
+ // contents elements too, but we don't really need it right now.
+ RefPtr<ComputedStyle> oldOrDisplayContentsStyle =
+ styleFrame ? styleFrame->Style() : nullptr;
+
+ MOZ_ASSERT(!(styleFrame && Servo_Element_IsDisplayContents(aElement)),
+ "display: contents node has a frame, yet we didn't reframe it"
+ " above?");
+ const bool isDisplayContents = !styleFrame && aElement->HasServoData() &&
+ Servo_Element_IsDisplayContents(aElement);
+ if (isDisplayContents) {
+ oldOrDisplayContentsStyle = ServoStyleSet::ResolveServoStyle(*aElement);
+ }
+
+ Maybe<ServoRestyleState> thisFrameRestyleState;
+ if (styleFrame) {
+ auto type = isOutOfFlow || isColumnSpan ? ServoRestyleState::Type::OutOfFlow
+ : ServoRestyleState::Type::InFlow;
+
+ thisFrameRestyleState.emplace(*styleFrame, aRestyleState, changeHint, type);
+ }
+
+ // We can't really assume as used changes from display: contents elements (or
+ // other elements without frames).
+ ServoRestyleState& childrenRestyleState =
+ thisFrameRestyleState ? *thisFrameRestyleState : aRestyleState;
+
+ ComputedStyle* upToDateStyle =
+ wasRestyled ? upToDateStyleIfRestyled : oldOrDisplayContentsStyle;
+
+ ServoPostTraversalFlags childrenFlags =
+ wasRestyled ? ServoPostTraversalFlags::ParentWasRestyled
+ : ServoPostTraversalFlags::Empty;
+
+ if (wasRestyled && oldOrDisplayContentsStyle) {
+ MOZ_ASSERT(styleFrame || isDisplayContents);
+
+ // We want to walk all the continuations here, even the ones with different
+ // styles. In practice, the only reason we get continuations with different
+ // styles here is ::first-line (::first-letter never affects element
+ // styles). But in that case, newStyle is the right context for the
+ // _later_ continuations anyway (the ones not affected by ::first-line), not
+ // the earlier ones, so there is no point stopping right at the point when
+ // we'd actually be setting the right ComputedStyle.
+ //
+ // This does mean that we may be setting the wrong ComputedStyle on our
+ // initial continuations; ::first-line fixes that up after the fact.
+ for (nsIFrame* f = styleFrame; f; f = f->GetNextContinuation()) {
+ MOZ_ASSERT_IF(f != styleFrame, !f->GetAdditionalComputedStyle(0));
+ f->SetComputedStyle(upToDateStyle);
+ }
+
+ if (styleFrame) {
+ UpdateAdditionalComputedStyles(styleFrame, aRestyleState);
+ }
+
+ if (!aElement->GetParent()) {
+ // This is the root. Update styles on the viewport as needed.
+ ViewportFrame* viewport =
+ do_QueryFrame(mPresContext->PresShell()->GetRootFrame());
+ if (viewport) {
+ // NB: The root restyle state, not the one for our children!
+ viewport->UpdateStyle(aRestyleState);
+ }
+ }
+
+ // Some changes to animations don't affect the computed style and yet still
+ // require the layer to be updated. For example, pausing an animation via
+ // the Web Animations API won't affect an element's style but still
+ // requires to update the animation on the layer.
+ //
+ // We can sometimes reach this when the animated style is being removed.
+ // Since AddLayerChangesForAnimation checks if |styleFrame| has a transform
+ // style or not, we need to call it *after* setting |newStyle| to
+ // |styleFrame| to ensure the animated transform has been removed first.
+ AddLayerChangesForAnimation(styleFrame, primaryFrame, aElement, changeHint,
+ aRestyleState.ChangeList());
+
+ childrenFlags |= SendA11yNotifications(mPresContext, aElement,
+ *oldOrDisplayContentsStyle,
+ *upToDateStyle, aFlags);
+ }
+
+ const bool traverseElementChildren =
+ aElement->HasAnyOfFlags(Element::kAllServoDescendantBits);
+ const bool traverseTextChildren =
+ wasRestyled || aElement->HasFlag(NODE_DESCENDANTS_NEED_FRAMES);
+ bool recreatedAnyContext = wasRestyled;
+ if (traverseElementChildren || traverseTextChildren) {
+ StyleChildrenIterator it(aElement);
+ TextPostTraversalState textState(*aElement, upToDateStyle,
+ isDisplayContents && wasRestyled,
+ childrenRestyleState);
+ for (nsIContent* n = it.GetNextChild(); n; n = it.GetNextChild()) {
+ if (traverseElementChildren && n->IsElement()) {
+ recreatedAnyContext |= ProcessPostTraversal(
+ n->AsElement(), childrenRestyleState, childrenFlags);
+ } else if (traverseTextChildren && n->IsText()) {
+ recreatedAnyContext |= ProcessPostTraversalForText(
+ n, textState, childrenRestyleState, childrenFlags);
+ }
+ }
+ }
+
+ // We want to update frame pseudo-element styles after we've traversed our
+ // kids, because some of those updates (::first-line/::first-letter) need to
+ // modify the styles of the kids, and the child traversal above would just
+ // clobber those modifications.
+ if (styleFrame) {
+ if (wasRestyled) {
+ // Make sure to update anon boxes and pseudo bits after updating text,
+ // otherwise ProcessPostTraversalForText could clobber first-letter
+ // styles, for example.
+ styleFrame->UpdateStyleOfOwnedAnonBoxes(childrenRestyleState);
+ }
+ // Process anon box wrapper frames before ::first-line bits, but _after_
+ // owned anon boxes, since the children wrapper anon boxes could be
+ // inheriting from our own owned anon boxes.
+ childrenRestyleState.ProcessWrapperRestyles(styleFrame);
+ if (wasRestyled) {
+ UpdateFramePseudoElementStyles(styleFrame, childrenRestyleState);
+ } else if (traverseElementChildren &&
+ styleFrame->IsBlockFrameOrSubclass()) {
+ // Even if we were not restyled, if we're a block with a first-line and
+ // one of our descendant elements which is on the first line was restyled,
+ // we need to update the styles of things on the first line, because
+ // they're wrong now.
+ //
+ // FIXME(bz) Could we do better here? For example, could we keep track of
+ // frames that are "block with a ::first-line so we could avoid
+ // IsFrameOfType() and digging about for the first-line frame if not?
+ // Could we keep track of whether the element children we actually restyle
+ // are affected by first-line? Something else? Bug 1385443 tracks making
+ // this better.
+ nsIFrame* firstLineFrame =
+ static_cast<nsBlockFrame*>(styleFrame)->GetFirstLineFrame();
+ if (firstLineFrame) {
+ for (nsIFrame* kid : firstLineFrame->PrincipalChildList()) {
+ ReparentComputedStyleForFirstLine(kid);
+ }
+ }
+ }
+ }
+
+ aElement->UnsetFlags(Element::kAllServoDescendantBits);
+ return recreatedAnyContext;
+}
+
+bool RestyleManager::ProcessPostTraversalForText(
+ nsIContent* aTextNode, TextPostTraversalState& aPostTraversalState,
+ ServoRestyleState& aRestyleState, ServoPostTraversalFlags aFlags) {
+ // Handle lazy frame construction.
+ if (aTextNode->HasFlag(NODE_NEEDS_FRAME)) {
+ aPostTraversalState.ChangeList().AppendChange(
+ nullptr, aTextNode, nsChangeHint_ReconstructFrame);
+ return true;
+ }
+
+ // Handle restyle.
+ nsIFrame* primaryFrame = aTextNode->GetPrimaryFrame();
+ if (!primaryFrame) {
+ return false;
+ }
+
+ // If the parent wasn't restyled, the styles of our anon box parents won't
+ // change either.
+ if ((aFlags & ServoPostTraversalFlags::ParentWasRestyled) &&
+ primaryFrame->ParentIsWrapperAnonBox()) {
+ aRestyleState.AddPendingWrapperRestyle(
+ ServoRestyleState::TableAwareParentFor(primaryFrame));
+ }
+
+ ComputedStyle& newStyle = aPostTraversalState.ComputeStyle(aTextNode);
+ aPostTraversalState.ComputeHintIfNeeded(aTextNode, primaryFrame, newStyle);
+
+ // We want to walk all the continuations here, even the ones with different
+ // styles. In practice, the only reasons we get continuations with different
+ // styles are ::first-line and ::first-letter. But in those cases,
+ // newStyle is the right context for the _later_ continuations anyway (the
+ // ones not affected by ::first-line/::first-letter), not the earlier ones,
+ // so there is no point stopping right at the point when we'd actually be
+ // setting the right ComputedStyle.
+ //
+ // This does mean that we may be setting the wrong ComputedStyle on our
+ // initial continuations; ::first-line/::first-letter fix that up after the
+ // fact.
+ for (nsIFrame* f = primaryFrame; f; f = f->GetNextContinuation()) {
+ f->SetComputedStyle(&newStyle);
+ }
+
+ return true;
+}
+
+void RestyleManager::ClearSnapshots() {
+ for (auto iter = mSnapshots.Iter(); !iter.Done(); iter.Next()) {
+ iter.Key()->UnsetFlags(ELEMENT_HAS_SNAPSHOT | ELEMENT_HANDLED_SNAPSHOT);
+ iter.Remove();
+ }
+}
+
+ServoElementSnapshot& RestyleManager::SnapshotFor(Element& aElement) {
+ MOZ_DIAGNOSTIC_ASSERT(!mInStyleRefresh);
+
+ // NOTE(emilio): We can handle snapshots from a one-off restyle of those that
+ // we do to restyle stuff for reconstruction, for example.
+ //
+ // It seems to be the case that we always flush in between that happens and
+ // the next attribute change, so we can assert that we haven't handled the
+ // snapshot here yet. If this assertion didn't hold, we'd need to unset that
+ // flag from here too.
+ //
+ // Can't wait to make ProcessPendingRestyles the only entry-point for styling,
+ // so this becomes much easier to reason about. Today is not that day though.
+ MOZ_ASSERT(!aElement.HasFlag(ELEMENT_HANDLED_SNAPSHOT));
+
+ ServoElementSnapshot* snapshot =
+ mSnapshots.GetOrInsertNew(&aElement, aElement);
+ aElement.SetFlags(ELEMENT_HAS_SNAPSHOT);
+
+ // Now that we have a snapshot, make sure a restyle is triggered.
+ aElement.NoteDirtyForServo();
+ return *snapshot;
+}
+
+void RestyleManager::DoProcessPendingRestyles(ServoTraversalFlags aFlags) {
+ nsPresContext* presContext = PresContext();
+ PresShell* presShell = presContext->PresShell();
+
+ MOZ_ASSERT(presContext->Document(), "No document? Pshaw!");
+ // FIXME(emilio): In the "flush animations" case, ideally, we should only
+ // recascade animation styles running on the compositor, so we shouldn't care
+ // about other styles, or new rules that apply to the page...
+ //
+ // However, that's not true as of right now, see bug 1388031 and bug 1388692.
+ MOZ_ASSERT((aFlags & ServoTraversalFlags::FlushThrottledAnimations) ||
+ !presContext->HasPendingMediaQueryUpdates(),
+ "Someone forgot to update media queries?");
+ MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript(), "Missing a script blocker!");
+ MOZ_RELEASE_ASSERT(!mInStyleRefresh, "Reentrant call?");
+
+ if (MOZ_UNLIKELY(!presShell->DidInitialize())) {
+ // PresShell::FlushPendingNotifications doesn't early-return in the case
+ // where the PresShell hasn't yet been initialized (and therefore we haven't
+ // yet done the initial style traversal of the DOM tree). We should arguably
+ // fix up the callers and assert against this case, but we just detect and
+ // handle it for now.
+ return;
+ }
+
+ // It'd be bad!
+ PresShell::AutoAssertNoFlush noReentrantFlush(*presShell);
+
+ // Create a AnimationsWithDestroyedFrame during restyling process to
+ // stop animations and transitions on elements that have no frame at the end
+ // of the restyling process.
+ AnimationsWithDestroyedFrame animationsWithDestroyedFrame(this);
+
+ ServoStyleSet* styleSet = StyleSet();
+ Document* doc = presContext->Document();
+
+ // Ensure the refresh driver is active during traversal to avoid mutating
+ // mActiveTimer and mMostRecentRefresh time.
+ presContext->RefreshDriver()->MostRecentRefresh();
+
+ if (!doc->GetServoRestyleRoot()) {
+ // This might post new restyles, so need to do it here. Don't do it if we're
+ // already going to restyle tho, so that we don't potentially reflow with
+ // dirty styling.
+ presContext->UpdateContainerQueryStyles();
+ presContext->FinishedContainerQueryUpdate();
+ }
+
+ // Perform the Servo traversal, and the post-traversal if required. We do this
+ // in a loop because certain rare paths in the frame constructor can trigger
+ // additional style invalidations.
+ //
+ // FIXME(emilio): Confirm whether that's still true now that XBL is gone.
+ mInStyleRefresh = true;
+ if (mHaveNonAnimationRestyles) {
+ ++mAnimationGeneration;
+ }
+
+ if (mRestyleForCSSRuleChanges) {
+ aFlags |= ServoTraversalFlags::ForCSSRuleChanges;
+ }
+
+ while (styleSet->StyleDocument(aFlags)) {
+ ClearSnapshots();
+
+ // Select scroll anchors for frames that have been scrolled. Do this
+ // before processing restyled frames so that anchor nodes are correctly
+ // marked when directly moving frames with RecomputePosition.
+ presContext->PresShell()->FlushPendingScrollAnchorSelections();
+
+ nsStyleChangeList currentChanges;
+ bool anyStyleChanged = false;
+
+ // Recreate styles , and queue up change hints (which also handle lazy frame
+ // construction).
+ nsTArray<RefPtr<Element>> anchorsToSuppress;
+
+ {
+ DocumentStyleRootIterator iter(doc->GetServoRestyleRoot());
+ while (Element* root = iter.GetNextStyleRoot()) {
+ nsTArray<nsIFrame*> wrappersToRestyle;
+ ServoRestyleState state(*styleSet, currentChanges, wrappersToRestyle,
+ anchorsToSuppress);
+ ServoPostTraversalFlags flags = ServoPostTraversalFlags::Empty;
+ anyStyleChanged |= ProcessPostTraversal(root, state, flags);
+ }
+
+ // We want to suppress adjustments the current (before-change) scroll
+ // anchor container now, and save a reference to the content node so that
+ // we can suppress them in the after-change scroll anchor .
+ for (Element* element : anchorsToSuppress) {
+ if (nsIFrame* frame = element->GetPrimaryFrame()) {
+ if (auto* container = ScrollAnchorContainer::FindFor(frame)) {
+ container->SuppressAdjustments();
+ }
+ }
+ }
+ }
+
+ doc->ClearServoRestyleRoot();
+ ClearSnapshots();
+
+ // Process the change hints.
+ //
+ // Unfortunately, the frame constructor can generate new change hints while
+ // processing existing ones. We redirect those into a secondary queue and
+ // iterate until there's nothing left.
+ {
+ ReentrantChangeList newChanges;
+ mReentrantChanges = &newChanges;
+ while (!currentChanges.IsEmpty()) {
+ ProcessRestyledFrames(currentChanges);
+ MOZ_ASSERT(currentChanges.IsEmpty());
+ for (ReentrantChange& change : newChanges) {
+ if (!(change.mHint & nsChangeHint_ReconstructFrame) &&
+ !change.mContent->GetPrimaryFrame()) {
+ // SVG Elements post change hints without ensuring that the primary
+ // frame will be there after that (see bug 1366142).
+ //
+ // Just ignore those, since we can't really process them.
+ continue;
+ }
+ currentChanges.AppendChange(change.mContent->GetPrimaryFrame(),
+ change.mContent, change.mHint);
+ }
+ newChanges.Clear();
+ }
+ mReentrantChanges = nullptr;
+ }
+
+ // Suppress adjustments in the after-change scroll anchors if needed, now
+ // that we're done reframing everything.
+ for (Element* element : anchorsToSuppress) {
+ if (nsIFrame* frame = element->GetPrimaryFrame()) {
+ if (auto* container = ScrollAnchorContainer::FindFor(frame)) {
+ container->SuppressAdjustments();
+ }
+ }
+ }
+
+ if (anyStyleChanged) {
+ // Maybe no styles changed when:
+ //
+ // * Only explicit change hints were posted in the first place.
+ // * When an attribute or state change in the content happens not to need
+ // a restyle after all.
+ //
+ // In any case, we don't need to increment the restyle generation in that
+ // case.
+ IncrementRestyleGeneration();
+ }
+
+ mInStyleRefresh = false;
+ presContext->UpdateContainerQueryStyles();
+ mInStyleRefresh = true;
+ }
+
+ doc->ClearServoRestyleRoot();
+ presContext->FinishedContainerQueryUpdate();
+ presContext->UpdateHiddenByContentVisibilityForAnimationsIfNeeded();
+ ClearSnapshots();
+ styleSet->AssertTreeIsClean();
+
+ mHaveNonAnimationRestyles = false;
+ mRestyleForCSSRuleChanges = false;
+ mInStyleRefresh = false;
+
+ // Now that everything has settled, see if we have enough free rule nodes in
+ // the tree to warrant sweeping them.
+ styleSet->MaybeGCRuleTree();
+
+ // Note: We are in the scope of |animationsWithDestroyedFrame|, so
+ // |mAnimationsWithDestroyedFrame| is still valid.
+ MOZ_ASSERT(mAnimationsWithDestroyedFrame);
+ mAnimationsWithDestroyedFrame->StopAnimationsForElementsWithoutFrames();
+}
+
+#ifdef DEBUG
+static void VerifyFlatTree(const nsIContent& aContent) {
+ StyleChildrenIterator iter(&aContent);
+
+ for (auto* content = iter.GetNextChild(); content;
+ content = iter.GetNextChild()) {
+ MOZ_ASSERT(content->GetFlattenedTreeParentNodeForStyle() == &aContent);
+ VerifyFlatTree(*content);
+ }
+}
+#endif
+
+void RestyleManager::ProcessPendingRestyles() {
+ AUTO_PROFILER_LABEL_RELEVANT_FOR_JS("Styles", LAYOUT);
+#ifdef DEBUG
+ if (auto* root = mPresContext->Document()->GetRootElement()) {
+ VerifyFlatTree(*root);
+ }
+#endif
+
+ DoProcessPendingRestyles(ServoTraversalFlags::Empty);
+}
+
+void RestyleManager::ProcessAllPendingAttributeAndStateInvalidations() {
+ if (mSnapshots.IsEmpty()) {
+ return;
+ }
+ for (const auto& key : mSnapshots.Keys()) {
+ // Servo data for the element might have been dropped. (e.g. by removing
+ // from its document)
+ if (key->HasFlag(ELEMENT_HAS_SNAPSHOT)) {
+ Servo_ProcessInvalidations(StyleSet()->RawData(), key, &mSnapshots);
+ }
+ }
+ ClearSnapshots();
+}
+
+void RestyleManager::UpdateOnlyAnimationStyles() {
+ bool doCSS = PresContext()->EffectCompositor()->HasPendingStyleUpdates();
+ if (!doCSS) {
+ return;
+ }
+
+ DoProcessPendingRestyles(ServoTraversalFlags::FlushThrottledAnimations);
+}
+
+void RestyleManager::ElementStateChanged(Element* aElement,
+ ElementState aChangedBits) {
+#ifdef EARLY_BETA_OR_EARLIER
+ if (MOZ_UNLIKELY(mInStyleRefresh)) {
+ MOZ_CRASH_UNSAFE_PRINTF(
+ "Element state change during style refresh (%" PRIu64 ")",
+ aChangedBits.GetInternalValue());
+ }
+#endif
+
+ const ElementState kVisitedAndUnvisited =
+ ElementState::VISITED | ElementState::UNVISITED;
+
+ // We'll restyle when the relevant visited query finishes, regardless of the
+ // style (see Link::VisitedQueryFinished). So there's no need to do anything
+ // as a result of this state change just yet.
+ //
+ // Note that this check checks for _both_ bits: This is only true when visited
+ // changes to unvisited or vice-versa, but not when we start or stop being a
+ // link itself.
+ if (aChangedBits.HasAllStates(kVisitedAndUnvisited)) {
+ aChangedBits &= ~kVisitedAndUnvisited;
+ if (aChangedBits.IsEmpty()) {
+ return;
+ }
+ }
+
+ if (auto changeHint = ChangeForContentStateChange(*aElement, aChangedBits)) {
+ Servo_NoteExplicitHints(aElement, RestyleHint{0}, changeHint);
+ }
+
+ // Don't bother taking a snapshot if no rules depend on these state bits.
+ //
+ // We always take a snapshot for the LTR/RTL event states, since Servo doesn't
+ // track those bits in the same way, and we know that :dir() rules are always
+ // present in UA style sheets.
+ if (!aChangedBits.HasAtLeastOneOfStates(ElementState::DIR_STATES) &&
+ !StyleSet()->HasStateDependency(*aElement, aChangedBits)) {
+ return;
+ }
+
+ // Assuming we need to invalidate cached style in getComputedStyle for
+ // undisplayed elements, since we don't know if it is needed.
+ IncrementUndisplayedRestyleGeneration();
+
+ if (!aElement->HasServoData() &&
+ !(aElement->GetSelectorFlags() &
+ NodeSelectorFlags::RelativeSelectorSearchDirectionAncestorSibling)) {
+ return;
+ }
+
+ ServoElementSnapshot& snapshot = SnapshotFor(*aElement);
+ ElementState previousState = aElement->StyleState() ^ aChangedBits;
+ snapshot.AddState(previousState);
+
+ ServoStyleSet& styleSet = *StyleSet();
+ MaybeRestyleForNthOfState(styleSet, aElement, aChangedBits);
+ MaybeRestyleForRelativeSelectorState(styleSet, aElement, aChangedBits);
+}
+
+void RestyleManager::MaybeRestyleForNthOfState(ServoStyleSet& aStyleSet,
+ Element* aChild,
+ ElementState aChangedBits) {
+ const auto* parentNode = aChild->GetParentNode();
+ MOZ_ASSERT(parentNode);
+ const auto parentFlags = parentNode->GetSelectorFlags();
+ if (!(parentFlags & NodeSelectorFlags::HasSlowSelectorNthOf)) {
+ return;
+ }
+
+ if (aStyleSet.HasNthOfStateDependency(*aChild, aChangedBits)) {
+ RestyleSiblingsForNthOf(aChild, parentFlags);
+ }
+}
+
+static inline bool AttributeInfluencesOtherPseudoClassState(
+ const Element& aElement, const nsAtom* aAttribute) {
+ // We must record some state for :-moz-browser-frame,
+ // :-moz-table-border-nonzero, and :-moz-select-list-box.
+ if (aAttribute == nsGkAtoms::mozbrowser) {
+ return aElement.IsAnyOfHTMLElements(nsGkAtoms::iframe, nsGkAtoms::frame);
+ }
+
+ if (aAttribute == nsGkAtoms::border) {
+ return aElement.IsHTMLElement(nsGkAtoms::table);
+ }
+
+ if (aAttribute == nsGkAtoms::multiple || aAttribute == nsGkAtoms::size) {
+ return aElement.IsHTMLElement(nsGkAtoms::select);
+ }
+
+ return false;
+}
+
+static inline bool NeedToRecordAttrChange(
+ const ServoStyleSet& aStyleSet, const Element& aElement,
+ int32_t aNameSpaceID, nsAtom* aAttribute,
+ bool* aInfluencesOtherPseudoClassState) {
+ *aInfluencesOtherPseudoClassState =
+ AttributeInfluencesOtherPseudoClassState(aElement, aAttribute);
+
+ // If the attribute influences one of the pseudo-classes that are backed by
+ // attributes, we just record it.
+ if (*aInfluencesOtherPseudoClassState) {
+ return true;
+ }
+
+ // We assume that id and class attributes are used in class/id selectors, and
+ // thus record them.
+ //
+ // TODO(emilio): We keep a filter of the ids in use somewhere in the StyleSet,
+ // presumably we could try to filter the old and new id, but it's not clear
+ // it's worth it.
+ if (aNameSpaceID == kNameSpaceID_None &&
+ (aAttribute == nsGkAtoms::id || aAttribute == nsGkAtoms::_class)) {
+ return true;
+ }
+
+ // We always record lang="", even though we force a subtree restyle when it
+ // changes, since it can change how its siblings match :lang(..) due to
+ // selectors like :lang(..) + div.
+ if (aAttribute == nsGkAtoms::lang) {
+ return true;
+ }
+
+ // Otherwise, just record the attribute change if a selector in the page may
+ // reference it from an attribute selector.
+ return aStyleSet.MightHaveAttributeDependency(aElement, aAttribute);
+}
+
+void RestyleManager::AttributeWillChange(Element* aElement,
+ int32_t aNameSpaceID,
+ nsAtom* aAttribute, int32_t aModType) {
+ TakeSnapshotForAttributeChange(*aElement, aNameSpaceID, aAttribute);
+}
+
+void RestyleManager::ClassAttributeWillBeChangedBySMIL(Element* aElement) {
+ TakeSnapshotForAttributeChange(*aElement, kNameSpaceID_None,
+ nsGkAtoms::_class);
+}
+
+void RestyleManager::TakeSnapshotForAttributeChange(Element& aElement,
+ int32_t aNameSpaceID,
+ nsAtom* aAttribute) {
+ MOZ_DIAGNOSTIC_ASSERT(!mInStyleRefresh);
+
+ bool influencesOtherPseudoClassState;
+ if (!NeedToRecordAttrChange(*StyleSet(), aElement, aNameSpaceID, aAttribute,
+ &influencesOtherPseudoClassState)) {
+ return;
+ }
+
+ // We cannot tell if the attribute change will affect the styles of
+ // undisplayed elements, because we don't actually restyle those elements
+ // during the restyle traversal. So just assume that the attribute change can
+ // cause the style to change.
+ IncrementUndisplayedRestyleGeneration();
+
+ // Relative selector invalidation travels ancestor and earlier sibling
+ // direction, so it's very possible that it invalidates a styled element.
+ if (!aElement.HasServoData() &&
+ !(aElement.GetSelectorFlags() &
+ NodeSelectorFlags::RelativeSelectorSearchDirectionAncestorSibling)) {
+ return;
+ }
+
+ // Some other random attribute changes may also affect the transitions,
+ // so we also set this true here.
+ mHaveNonAnimationRestyles = true;
+
+ ServoElementSnapshot& snapshot = SnapshotFor(aElement);
+ snapshot.AddAttrs(aElement, aNameSpaceID, aAttribute);
+
+ if (influencesOtherPseudoClassState) {
+ snapshot.AddOtherPseudoClassState(aElement);
+ }
+}
+
+// For some attribute changes we must restyle the whole subtree:
+//
+// * lang="" and xml:lang="" can affect all descendants due to :lang()
+// * exportparts can affect all descendant parts. We could certainly integrate
+// it better in the invalidation machinery if it was necessary.
+static inline bool AttributeChangeRequiresSubtreeRestyle(
+ const Element& aElement, nsAtom* aAttr) {
+ if (aAttr == nsGkAtoms::exportparts) {
+ // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for
+ // exportparts attribute changes?
+ return !!aElement.GetShadowRoot();
+ }
+ return aAttr == nsGkAtoms::lang;
+}
+
+void RestyleManager::AttributeChanged(Element* aElement, int32_t aNameSpaceID,
+ nsAtom* aAttribute, int32_t aModType,
+ const nsAttrValue* aOldValue) {
+ MOZ_ASSERT(!mInStyleRefresh);
+
+ auto changeHint = nsChangeHint(0);
+ auto restyleHint = RestyleHint{0};
+
+ changeHint |= aElement->GetAttributeChangeHint(aAttribute, aModType);
+
+ MaybeRestyleForNthOfAttribute(aElement, aAttribute, aOldValue);
+ MaybeRestyleForRelativeSelectorAttribute(aElement, aAttribute, aOldValue);
+
+ if (aAttribute == nsGkAtoms::style) {
+ restyleHint |= RestyleHint::RESTYLE_STYLE_ATTRIBUTE;
+ } else if (AttributeChangeRequiresSubtreeRestyle(*aElement, aAttribute)) {
+ restyleHint |= RestyleHint::RestyleSubtree();
+ } else if (aElement->IsInShadowTree() && aAttribute == nsGkAtoms::part) {
+ // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for part
+ // attribute changes?
+ restyleHint |= RestyleHint::RESTYLE_SELF | RestyleHint::RESTYLE_PSEUDOS;
+ }
+
+ if (nsIFrame* primaryFrame = aElement->GetPrimaryFrame()) {
+ // See if we have appearance information for a theme.
+ StyleAppearance appearance =
+ primaryFrame->StyleDisplay()->EffectiveAppearance();
+ if (appearance != StyleAppearance::None) {
+ nsITheme* theme = PresContext()->Theme();
+ if (theme->ThemeSupportsWidget(PresContext(), primaryFrame, appearance)) {
+ bool repaint = false;
+ theme->WidgetStateChanged(primaryFrame, appearance, aAttribute,
+ &repaint, aOldValue);
+ if (repaint) {
+ changeHint |= nsChangeHint_RepaintFrame;
+ }
+ }
+ }
+
+ primaryFrame->AttributeChanged(aNameSpaceID, aAttribute, aModType);
+ }
+
+ if (restyleHint || changeHint) {
+ Servo_NoteExplicitHints(aElement, restyleHint, changeHint);
+ }
+
+ if (restyleHint) {
+ // Assuming we need to invalidate cached style in getComputedStyle for
+ // undisplayed elements, since we don't know if it is needed.
+ IncrementUndisplayedRestyleGeneration();
+
+ // If we change attributes, we have to mark this to be true, so we will
+ // increase the animation generation for the new created transition if any.
+ mHaveNonAnimationRestyles = true;
+ }
+}
+
+void RestyleManager::RestyleSiblingsForNthOf(Element* aChild,
+ NodeSelectorFlags aParentFlags) {
+ StyleSet()->RestyleSiblingsForNthOf(*aChild,
+ static_cast<uint32_t>(aParentFlags));
+}
+
+void RestyleManager::MaybeRestyleForNthOfAttribute(
+ Element* aChild, nsAtom* aAttribute, const nsAttrValue* aOldValue) {
+ const auto* parentNode = aChild->GetParentNode();
+ MOZ_ASSERT(parentNode);
+ const auto parentFlags = parentNode->GetSelectorFlags();
+ if (!(parentFlags & NodeSelectorFlags::HasSlowSelectorNthOf)) {
+ return;
+ }
+ if (!aChild->HasServoData()) {
+ return;
+ }
+
+ bool mightHaveNthOfDependency;
+ auto& styleSet = *StyleSet();
+ if (aAttribute == nsGkAtoms::id) {
+ auto* const oldAtom = aOldValue->Type() == nsAttrValue::eAtom
+ ? aOldValue->GetAtomValue()
+ : nullptr;
+ mightHaveNthOfDependency =
+ styleSet.MightHaveNthOfIDDependency(*aChild, oldAtom, aChild->GetID());
+ } else if (aAttribute == nsGkAtoms::_class) {
+ mightHaveNthOfDependency = styleSet.MightHaveNthOfClassDependency(*aChild);
+ } else {
+ mightHaveNthOfDependency =
+ styleSet.MightHaveNthOfAttributeDependency(*aChild, aAttribute);
+ }
+
+ if (mightHaveNthOfDependency) {
+ RestyleSiblingsForNthOf(aChild, parentFlags);
+ }
+}
+
+void RestyleManager::MaybeRestyleForRelativeSelectorAttribute(
+ Element* aElement, nsAtom* aAttribute, const nsAttrValue* aOldValue) {
+ if (!aElement->HasFlag(ELEMENT_HAS_SNAPSHOT)) {
+ return;
+ }
+ auto& styleSet = *StyleSet();
+ if (aAttribute == nsGkAtoms::id) {
+ auto* const oldAtom = aOldValue->Type() == nsAttrValue::eAtom
+ ? aOldValue->GetAtomValue()
+ : nullptr;
+ styleSet.MaybeInvalidateRelativeSelectorIDDependency(
+ *aElement, oldAtom, aElement->GetID(), Snapshots());
+ } else if (aAttribute == nsGkAtoms::_class) {
+ styleSet.MaybeInvalidateRelativeSelectorClassDependency(*aElement,
+ Snapshots());
+ } else {
+ styleSet.MaybeInvalidateRelativeSelectorAttributeDependency(
+ *aElement, aAttribute, Snapshots());
+ }
+}
+
+void RestyleManager::MaybeRestyleForRelativeSelectorState(
+ ServoStyleSet& aStyleSet, Element* aElement, ElementState aChangedBits) {
+ if (!aElement->HasFlag(ELEMENT_HAS_SNAPSHOT)) {
+ return;
+ }
+ aStyleSet.MaybeInvalidateRelativeSelectorStateDependency(
+ *aElement, aChangedBits, Snapshots());
+}
+
+void RestyleManager::ReparentComputedStyleForFirstLine(nsIFrame* aFrame) {
+ // This is only called when moving frames in or out of the first-line
+ // pseudo-element (or one of its descendants). We can't say much about
+ // aFrame's ancestors, unfortunately (e.g. during a dynamic insert into
+ // something inside an inline-block on the first line the ancestors could be
+ // totally arbitrary), but we will definitely find a line frame on the
+ // ancestor chain. Note that the lineframe may not actually be the one that
+ // corresponds to ::first-line; when we're moving _out_ of the ::first-line it
+ // will be one of the continuations instead.
+#ifdef DEBUG
+ {
+ nsIFrame* f = aFrame->GetParent();
+ while (f && !f->IsLineFrame()) {
+ f = f->GetParent();
+ }
+ MOZ_ASSERT(f, "Must have found a first-line frame");
+ }
+#endif
+
+ DoReparentComputedStyleForFirstLine(aFrame, *StyleSet());
+}
+
+static bool IsFrameAboutToGoAway(nsIFrame* aFrame) {
+ auto* element = Element::FromNode(aFrame->GetContent());
+ if (!element) {
+ return false;
+ }
+ return !element->HasServoData();
+}
+
+void RestyleManager::DoReparentComputedStyleForFirstLine(
+ nsIFrame* aFrame, ServoStyleSet& aStyleSet) {
+ if (aFrame->IsBackdropFrame()) {
+ // Style context of backdrop frame has no parent style, and thus we do not
+ // need to reparent it.
+ return;
+ }
+
+ if (IsFrameAboutToGoAway(aFrame)) {
+ // We're entering a display: none subtree, which we know it's going to get
+ // rebuilt. Don't bother reparenting.
+ return;
+ }
+
+ if (aFrame->IsPlaceholderFrame()) {
+ // Also reparent the out-of-flow and all its continuations. We're doing
+ // this to match Gecko for now, but it's not clear that this behavior is
+ // correct per spec. It's certainly pretty odd for out-of-flows whose
+ // containing block is not within the first line.
+ //
+ // Right now we're somewhat inconsistent in this testcase:
+ //
+ // <style>
+ // div { color: orange; clear: left; }
+ // div::first-line { color: blue; }
+ // </style>
+ // <div>
+ // <span style="float: left">What color is this text?</span>
+ // </div>
+ // <div>
+ // <span><span style="float: left">What color is this text?</span></span>
+ // </div>
+ //
+ // We make the first float orange and the second float blue. On the other
+ // hand, if the float were within an inline-block that was on the first
+ // line, arguably it _should_ inherit from the ::first-line...
+ nsIFrame* outOfFlow =
+ nsPlaceholderFrame::GetRealFrameForPlaceholder(aFrame);
+ MOZ_ASSERT(outOfFlow, "no out-of-flow frame");
+ for (; outOfFlow; outOfFlow = outOfFlow->GetNextContinuation()) {
+ DoReparentComputedStyleForFirstLine(outOfFlow, aStyleSet);
+ }
+ }
+
+ // FIXME(emilio): This is the only caller of GetParentComputedStyle, let's try
+ // to remove it?
+ nsIFrame* providerFrame;
+ ComputedStyle* newParentStyle =
+ aFrame->GetParentComputedStyle(&providerFrame);
+ // If our provider is our child, we want to reparent it first, because we
+ // inherit style from it.
+ bool isChild = providerFrame && providerFrame->GetParent() == aFrame;
+ nsIFrame* providerChild = nullptr;
+ if (isChild) {
+ DoReparentComputedStyleForFirstLine(providerFrame, aStyleSet);
+ // Get the style again after ReparentComputedStyle() which might have
+ // changed it.
+ newParentStyle = providerFrame->Style();
+ providerChild = providerFrame;
+ MOZ_ASSERT(!providerFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW),
+ "Out of flow provider?");
+ }
+
+ if (!newParentStyle) {
+ // No need to do anything here for this frame, but we should still reparent
+ // its descendants, because those may have styles that inherit from the
+ // parent of this frame (e.g. non-anonymous columns in an anonymous
+ // colgroup).
+ MOZ_ASSERT(aFrame->Style()->IsNonInheritingAnonBox(),
+ "Why did this frame not end up with a parent context?");
+ ReparentFrameDescendants(aFrame, providerChild, aStyleSet);
+ return;
+ }
+
+ bool isElement = aFrame->GetContent()->IsElement();
+
+ // We probably don't want to initiate transitions from ReparentComputedStyle,
+ // since we call it during frame construction rather than in response to
+ // dynamic changes.
+ // Also see the comment at the start of
+ // nsTransitionManager::ConsiderInitiatingTransition.
+ //
+ // We don't try to do the fancy copying from previous continuations that
+ // GeckoRestyleManager does here, because that relies on knowing the parents
+ // of ComputedStyles, and we don't know those.
+ ComputedStyle* oldStyle = aFrame->Style();
+ Element* ourElement = isElement ? aFrame->GetContent()->AsElement() : nullptr;
+ ComputedStyle* newParent = newParentStyle;
+
+ if (!providerFrame) {
+ // No providerFrame means we inherited from a display:contents thing. Our
+ // layout parent style is the style of our nearest ancestor frame. But we
+ // have to be careful to do that with our placeholder, not with us, if we're
+ // out of flow.
+ if (aFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) {
+ aFrame->FirstContinuation()
+ ->GetPlaceholderFrame()
+ ->GetLayoutParentStyleForOutOfFlow(&providerFrame);
+ } else {
+ providerFrame = nsIFrame::CorrectStyleParentFrame(
+ aFrame->GetParent(), oldStyle->GetPseudoType());
+ }
+ }
+ ComputedStyle* layoutParent = providerFrame->Style();
+
+ RefPtr<ComputedStyle> newStyle = aStyleSet.ReparentComputedStyle(
+ oldStyle, newParent, layoutParent, ourElement);
+ aFrame->SetComputedStyle(newStyle);
+
+ // This logic somewhat mirrors the logic in
+ // RestyleManager::ProcessPostTraversal.
+ if (isElement) {
+ // We can't use UpdateAdditionalComputedStyles as-is because it needs a
+ // ServoRestyleState and maintaining one of those during a _frametree_
+ // traversal is basically impossible.
+ int32_t index = 0;
+ while (auto* oldAdditionalStyle =
+ aFrame->GetAdditionalComputedStyle(index)) {
+ RefPtr<ComputedStyle> newAdditionalContext =
+ aStyleSet.ReparentComputedStyle(oldAdditionalStyle, newStyle,
+ newStyle, nullptr);
+ aFrame->SetAdditionalComputedStyle(index, newAdditionalContext);
+ ++index;
+ }
+ }
+
+ // Generally, owned anon boxes are our descendants. The only exceptions are
+ // tables (for the table wrapper) and inline frames (for the block part of the
+ // block-in-inline split). We're going to update our descendants when looping
+ // over kids, and we don't want to update the block part of a block-in-inline
+ // split if the inline is on the first line but the block is not (and if the
+ // block is, it's the child of something else on the first line and will get
+ // updated as a child). And given how this method ends up getting called, if
+ // we reach here for a table frame, we are already in the middle of
+ // reparenting the table wrapper frame. So no need to
+ // UpdateStyleOfOwnedAnonBoxes() here.
+
+ ReparentFrameDescendants(aFrame, providerChild, aStyleSet);
+
+ // We do not need to do the equivalent of UpdateFramePseudoElementStyles,
+ // because those are handled by our descendant walk.
+}
+
+void RestyleManager::ReparentFrameDescendants(nsIFrame* aFrame,
+ nsIFrame* aProviderChild,
+ ServoStyleSet& aStyleSet) {
+ for (const auto& childList : aFrame->ChildLists()) {
+ for (nsIFrame* child : childList.mList) {
+ // only do frames that are in flow
+ if (!child->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) &&
+ child != aProviderChild) {
+ DoReparentComputedStyleForFirstLine(child, aStyleSet);
+ }
+ }
+ }
+}
+
+} // namespace mozilla