diff options
Diffstat (limited to 'layout/base/RestyleManager.h')
| -rw-r--r-- | layout/base/RestyleManager.h | 573 |
1 files changed, 573 insertions, 0 deletions
diff --git a/layout/base/RestyleManager.h b/layout/base/RestyleManager.h new file mode 100644 index 0000000000..fea5a071dd --- /dev/null +++ b/layout/base/RestyleManager.h @@ -0,0 +1,573 @@ +/* -*- 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/. */ + +#ifndef mozilla_RestyleManager_h +#define mozilla_RestyleManager_h + +#include "mozilla/AutoRestore.h" +#include "mozilla/Maybe.h" +#include "mozilla/OverflowChangedTracker.h" +#include "mozilla/ServoElementSnapshot.h" +#include "mozilla/ServoElementSnapshotTable.h" +#include "nsChangeHint.h" +#include "nsPresContext.h" +#include "nsPresContextInlines.h" // XXX Shouldn't be included by header though +#include "nsStringFwd.h" +#include "nsTHashSet.h" + +class nsAttrValue; +class nsAtom; +class nsIFrame; +class nsStyleChangeList; +class nsStyleChangeList; + +namespace mozilla { + +class ServoStyleSet; + +namespace dom { +class Element; +} + +/** + * A stack class used to pass some common restyle state in a slightly more + * comfortable way than a bunch of individual arguments, and that also checks + * that the change hint used for optimization is correctly used in debug mode. + */ +class ServoRestyleState { + public: + ServoRestyleState( + ServoStyleSet& aStyleSet, nsStyleChangeList& aChangeList, + nsTArray<nsIFrame*>& aPendingWrapperRestyles, + nsTArray<RefPtr<dom::Element>>& aPendingScrollAnchorSuppressions) + : mStyleSet(aStyleSet), + mChangeList(aChangeList), + mPendingWrapperRestyles(aPendingWrapperRestyles), + mPendingScrollAnchorSuppressions(aPendingScrollAnchorSuppressions), + mPendingWrapperRestyleOffset(aPendingWrapperRestyles.Length()), + mChangesHandled(nsChangeHint(0)) +#ifdef DEBUG + // If !mOwner, then we wouldn't have processed our wrapper restyles, + // because we only process those when handling an element with a frame. + // But that's OK, because if we started our traversal at an element with + // no frame (e.g. it's display:contents), that means the wrapper frames + // in our list actually inherit from one of its ancestors, not from it, + // and hence not restyling them is OK. + , + mAssertWrapperRestyleLength(false) +#endif // DEBUG + { + } + + // We shouldn't assume that changes handled from our parent are handled for + // our children too if we're out of flow since they aren't necessarily + // parented in DOM order, and thus a change handled by a DOM ancestor doesn't + // necessarily mean that it's handled for an ancestor frame. + enum class Type { + InFlow, + OutOfFlow, + }; + + ServoRestyleState(const nsIFrame& aOwner, ServoRestyleState& aParentState, + nsChangeHint aHintForThisFrame, Type aType, + bool aAssertWrapperRestyleLength = true) + : mStyleSet(aParentState.mStyleSet), + mChangeList(aParentState.mChangeList), + mPendingWrapperRestyles(aParentState.mPendingWrapperRestyles), + mPendingScrollAnchorSuppressions( + aParentState.mPendingScrollAnchorSuppressions), + mPendingWrapperRestyleOffset( + aParentState.mPendingWrapperRestyles.Length()), + mChangesHandled(aType == Type::InFlow + ? aParentState.mChangesHandled | aHintForThisFrame + : aHintForThisFrame) +#ifdef DEBUG + , + mOwner(&aOwner), + mAssertWrapperRestyleLength(aAssertWrapperRestyleLength) +#endif + { + if (aType == Type::InFlow) { + AssertOwner(aParentState); + } + } + + ~ServoRestyleState() { + MOZ_ASSERT( + !mAssertWrapperRestyleLength || + mPendingWrapperRestyles.Length() == mPendingWrapperRestyleOffset, + "Someone forgot to call ProcessWrapperRestyles!"); + } + + nsStyleChangeList& ChangeList() { return mChangeList; } + ServoStyleSet& StyleSet() { return mStyleSet; } + +#ifdef DEBUG + void AssertOwner(const ServoRestyleState& aParentState) const; + nsChangeHint ChangesHandledFor(const nsIFrame*) const; +#else + void AssertOwner(const ServoRestyleState&) const {} + nsChangeHint ChangesHandledFor(const nsIFrame*) const { + return mChangesHandled; + } +#endif + + // Add a pending wrapper restyle. We don't have to do anything if the thing + // being added is already last in the list, but otherwise we do want to add + // it, in order for ProcessWrapperRestyles to work correctly. + void AddPendingWrapperRestyle(nsIFrame* aWrapperFrame); + + // Process wrapper restyles for this restyle state. This should be done + // before it comes off the stack. + void ProcessWrapperRestyles(nsIFrame* aParentFrame); + + // Get the table-aware parent for the given child. This will walk through + // outer table and cellcontent frames. + static nsIFrame* TableAwareParentFor(const nsIFrame* aChild); + + // When the value of the position property changes such as we stop or start + // being absolutely or fixed positioned, we need to suppress scroll anchoring + // adjustments to avoid breaking websites. + // + // We do need to process all this once we're done with all our reframes, + // to handle correctly the cases where we reconstruct an ancestor, like when + // you reframe an ib-split (see bug 1559627 for example). + // + // This doesn't handle nested reframes. We'd need to rework quite some code to + // do that, and so far it doesn't seem to be a problem in practice. + void AddPendingScrollAnchorSuppression(dom::Element* aElement) { + mPendingScrollAnchorSuppressions.AppendElement(aElement); + } + + private: + // Process a wrapper restyle at the given index, and restyles for any + // wrappers nested in it. Returns the number of entries from + // mPendingWrapperRestyles that we processed. The return value is always at + // least 1. + size_t ProcessMaybeNestedWrapperRestyle(nsIFrame* aParent, size_t aIndex); + + ServoStyleSet& mStyleSet; + nsStyleChangeList& mChangeList; + + // A list of pending wrapper restyles. Anonymous box wrapper frames that need + // restyling are added to this list when their non-anonymous kids are + // restyled. This avoids us having to do linear searches along the frame tree + // for these anonymous boxes. The problem then becomes that we can have + // multiple kids all with the same anonymous parent, and we don't want to + // restyle it more than once. We use mPendingWrapperRestyles to track which + // anonymous wrapper boxes we've requested be restyled and which of them have + // already been restyled. We use a single array propagated through + // ServoRestyleStates by reference, because in a situation like this: + // + // <div style="display: table"><span></span></div> + // + // We have multiple wrappers to restyle (cell, row, table-row-group) and we + // want to add them in to the list all at once but restyle them using + // different ServoRestyleStates with different owners. When this situation + // occurs, the relevant frames will be placed in the array with ancestors + // before descendants. + nsTArray<nsIFrame*>& mPendingWrapperRestyles; + + nsTArray<RefPtr<dom::Element>>& mPendingScrollAnchorSuppressions; + + // Since we're given a possibly-nonempty mPendingWrapperRestyles to start + // with, we need to keep track of where the part of it we're responsible for + // starts. + size_t mPendingWrapperRestyleOffset; + + const nsChangeHint mChangesHandled; + + // We track the "owner" frame of this restyle state, that is, the frame that + // generated the last change that is stored in mChangesHandled, in order to + // verify that we only use mChangesHandled for actual descendants of that + // frame (given DOM order isn't always frame order, and that there are a few + // special cases for stuff like wrapper frames, ::backdrop, and so on). +#ifdef DEBUG + const nsIFrame* mOwner{nullptr}; +#endif + + // Whether we should assert in our destructor that we've processed all of the + // relevant wrapper restyles. +#ifdef DEBUG + const bool mAssertWrapperRestyleLength; +#endif // DEBUG +}; + +enum class ServoPostTraversalFlags : uint32_t; + +class RestyleManager { + friend class ServoStyleSet; + + public: + typedef ServoElementSnapshotTable SnapshotTable; + typedef mozilla::dom::Element Element; + + // Get an integer that increments every time we process pending restyles. + // The value is never 0. + uint64_t GetRestyleGeneration() const { return mRestyleGeneration; } + // Unlike GetRestyleGeneration, which means the actual restyling count, + // GetUndisplayedRestyleGeneration represents any possible DOM changes that + // can cause restyling. This is needed for getComputedStyle to work with + // non-styled (e.g. display: none) elements. + uint64_t GetUndisplayedRestyleGeneration() const { + return mUndisplayedRestyleGeneration; + } + + void Disconnect() { mPresContext = nullptr; } + + ~RestyleManager() { + MOZ_ASSERT(!mAnimationsWithDestroyedFrame, + "leaving dangling pointers from AnimationsWithDestroyedFrame"); + MOZ_ASSERT(!mReentrantChanges); + } + +#ifdef DEBUG + static nsCString ChangeHintToString(nsChangeHint aHint); + + /** + * DEBUG ONLY method to verify integrity of style tree versus frame tree + */ + void DebugVerifyStyleTree(nsIFrame* aFrame); +#endif + + void FlushOverflowChangedTracker() { mOverflowChangedTracker.Flush(); } + + // Should be called when a frame is going to be destroyed and + // WillDestroyFrameTree hasn't been called yet. + void NotifyDestroyingFrame(nsIFrame* aFrame) { + mOverflowChangedTracker.RemoveFrame(aFrame); + // If ProcessRestyledFrames is tracking frames which have been + // destroyed (to avoid re-visiting them), add this one to its set. + if (mDestroyedFrames) { + mDestroyedFrames->Insert(aFrame); + } + } + + // Note: It's the caller's responsibility to make sure to wrap a + // ProcessRestyledFrames call in a view update batch and a script blocker. + // This function does not call ProcessAttachedQueue() on the binding manager. + // If the caller wants that to happen synchronously, it needs to handle that + // itself. + void ProcessRestyledFrames(nsStyleChangeList& aChangeList); + + bool IsInStyleRefresh() const { return mInStyleRefresh; } + + // AnimationsWithDestroyedFrame is used to stop animations and transitions + // on elements that have no frame at the end of the restyling process. + // It only lives during the restyling process. + class MOZ_STACK_CLASS AnimationsWithDestroyedFrame final { + public: + // Construct a AnimationsWithDestroyedFrame object. The caller must + // ensure that aRestyleManager lives at least as long as the + // object. (This is generally easy since the caller is typically a + // method of RestyleManager.) + explicit AnimationsWithDestroyedFrame(RestyleManager* aRestyleManager); + + // This method takes the content node for the generated content for + // animation/transition on ::before and ::after, rather than the + // content node for the real element. + void Put(nsIContent* aContent, ComputedStyle* aComputedStyle) { + MOZ_ASSERT(aContent); + PseudoStyleType pseudoType = aComputedStyle->GetPseudoType(); + if (pseudoType == PseudoStyleType::NotPseudo) { + mContents.AppendElement(aContent); + } else if (pseudoType == PseudoStyleType::before) { + MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == + nsGkAtoms::mozgeneratedcontentbefore); + mBeforeContents.AppendElement(aContent->GetParent()); + } else if (pseudoType == PseudoStyleType::after) { + MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == + nsGkAtoms::mozgeneratedcontentafter); + mAfterContents.AppendElement(aContent->GetParent()); + } else if (pseudoType == PseudoStyleType::marker) { + MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == + nsGkAtoms::mozgeneratedcontentmarker); + mMarkerContents.AppendElement(aContent->GetParent()); + } + } + + void StopAnimationsForElementsWithoutFrames(); + + private: + void StopAnimationsWithoutFrame(nsTArray<RefPtr<nsIContent>>& aArray, + PseudoStyleType aPseudoType); + + RestyleManager* mRestyleManager; + AutoRestore<AnimationsWithDestroyedFrame*> mRestorePointer; + + // Below three arrays might include elements that have already had their + // animations or transitions stopped. + // + // mBeforeContents, mAfterContents and mMarkerContents hold the real element + // rather than the content node for the generated content (which might + // change during a reframe) + nsTArray<RefPtr<nsIContent>> mContents; + nsTArray<RefPtr<nsIContent>> mBeforeContents; + nsTArray<RefPtr<nsIContent>> mAfterContents; + nsTArray<RefPtr<nsIContent>> mMarkerContents; + }; + + /** + * Return the current AnimationsWithDestroyedFrame struct, or null if we're + * not currently in a restyling operation. + */ + AnimationsWithDestroyedFrame* GetAnimationsWithDestroyedFrame() { + return mAnimationsWithDestroyedFrame; + } + + void ContentInserted(nsIContent* aChild); + void ContentAppended(nsIContent* aFirstNewContent); + + // This would be have the same logic as RestyleForInsertOrChange if we got the + // notification before the removal. However, we get it after, so we need the + // following sibling in addition to the old child. + // + // aFollowingSibling is the sibling that used to come after aOldChild before + // the removal. + void ContentRemoved(nsIContent* aOldChild, nsIContent* aFollowingSibling); + + // Restyling for a ContentInserted (notification after insertion) or + // for some CharacterDataChanged. + void RestyleForInsertOrChange(nsIContent* aChild); + + // Restyle for a CharacterDataChanged notification. In practice this can only + // affect :empty / :-moz-only-whitespace / :-moz-first-node / :-moz-last-node. + void CharacterDataChanged(nsIContent*, const CharacterDataChangeInfo&); + + void PostRestyleEvent(dom::Element*, RestyleHint, + nsChangeHint aMinChangeHint); + + /** + * Posts restyle hints for animations. + * This is only called for the second traversal for CSS animations during + * updating CSS animations in a SequentialTask. + * This function does neither register a refresh observer nor flag that a + * style flush is needed since this function is supposed to be called during + * restyling process and this restyle event will be processed in the second + * traversal of the same restyling process. + */ + void PostRestyleEventForAnimations(dom::Element*, PseudoStyleType, + RestyleHint); + + void NextRestyleIsForCSSRuleChanges() { mRestyleForCSSRuleChanges = true; } + + void RebuildAllStyleData(nsChangeHint aExtraHint, RestyleHint); + + void ProcessPendingRestyles(); + void ProcessAllPendingAttributeAndStateInvalidations(); + + void ElementStateChanged(Element*, dom::ElementState); + void AttributeWillChange(Element* aElement, int32_t aNameSpaceID, + nsAtom* aAttribute, int32_t aModType); + void ClassAttributeWillBeChangedBySMIL(dom::Element* aElement); + void AttributeChanged(dom::Element* aElement, int32_t aNameSpaceID, + nsAtom* aAttribute, int32_t aModType, + const nsAttrValue* aOldValue); + + // This is only used to reparent things when moving them in/out of the + // ::first-line. + void ReparentComputedStyleForFirstLine(nsIFrame*); + + /** + * Performs a Servo animation-only traversal to compute style for all nodes + * with the animation-only dirty bit in the document. + * + * This processes just the traversal for animation-only restyles and skips the + * normal traversal for other restyles unrelated to animations. + * This is used to bring throttled animations up-to-date such as when we need + * to get correct position for transform animations that are throttled because + * they are running on the compositor. + * + * This will traverse all of the document's style roots (that is, its document + * element, and the roots of the document-level native anonymous content). + */ + void UpdateOnlyAnimationStyles(); + + // Get a counter that increments on every style change, that we use to + // track whether off-main-thread animations are up-to-date. + uint64_t GetAnimationGeneration() const { return mAnimationGeneration; } + + // Typically only style frames have animations associated with them so this + // will likely return zero for anything that is not a style frame. + static uint64_t GetAnimationGenerationForFrame(nsIFrame* aStyleFrame); + + // Update the animation generation count to mark that animation state + // has changed. + // + // This is normally performed automatically by ProcessPendingRestyles + // but it is also called when we have out-of-band changes to animations + // such as changes made through the Web Animations API. + void IncrementAnimationGeneration(); + + // Apply change hints for animations on the compositor. + // + // There are some cases where we forcibly apply change hints for animations + // even if there is no change hint produced in order to synchronize with + // animations running on the compositor. + // + // For example: + // + // a) Pausing animations via the Web Animations API + // b) When the style before sending the animation to the compositor exactly + // the same as the current style + static void AddLayerChangesForAnimation( + nsIFrame* aStyleFrame, nsIFrame* aPrimaryFrame, Element* aElement, + nsChangeHint aHintForThisFrame, nsStyleChangeList& aChangeListToProcess); + + /** + * Whether to clear all the style data (including the element itself), or just + * the descendants' data. + */ + enum class IncludeRoot { + Yes, + No, + }; + + /** + * Clears the ServoElementData and HasDirtyDescendants from all elements + * in the subtree rooted at aElement. + */ + static void ClearServoDataFromSubtree(Element*, + IncludeRoot = IncludeRoot::Yes); + + /** + * Clears HasDirtyDescendants and RestyleData from all elements in the + * subtree rooted at aElement. + */ + static void ClearRestyleStateFromSubtree(Element* aElement); + + explicit RestyleManager(nsPresContext* aPresContext); + + protected: + /** + * Reparent the descendants of aFrame. This is used by ReparentComputedStyle + * and shouldn't be called by anyone else. aProviderChild, if non-null, is a + * child that was the style parent for aFrame and hence shouldn't be + * reparented. + */ + void ReparentFrameDescendants(nsIFrame* aFrame, nsIFrame* aProviderChild, + ServoStyleSet& aStyleSet); + + /** + * Performs post-Servo-traversal processing on this element and its + * descendants. + * + * Returns whether any style did actually change. There may be cases where we + * didn't need to change any style after all, for example, when a content + * attribute changes that happens not to have any effect on the style of that + * element or any descendant or sibling. + */ + bool ProcessPostTraversal(Element* aElement, ServoRestyleState& aRestyleState, + ServoPostTraversalFlags aFlags); + + struct TextPostTraversalState; + bool ProcessPostTraversalForText(nsIContent* aTextNode, + TextPostTraversalState& aState, + ServoRestyleState& aRestyleState, + ServoPostTraversalFlags aFlags); + + ServoStyleSet* StyleSet() const { return PresContext()->StyleSet(); } + + void RestyleForEmptyChange(Element* aContainer); + void MaybeRestyleForEdgeChildChange(Element* aContainer, + nsIContent* aChangedChild); + + bool IsDisconnected() const { return !mPresContext; } + + void IncrementRestyleGeneration() { + if (++mRestyleGeneration == 0) { + // Keep mRestyleGeneration from being 0, since that's what + // nsPresContext::GetRestyleGeneration returns when it no + // longer has a RestyleManager. + ++mRestyleGeneration; + } + IncrementUndisplayedRestyleGeneration(); + } + + void IncrementUndisplayedRestyleGeneration() { + if (++mUndisplayedRestyleGeneration == 0) { + // Ensure mUndisplayedRestyleGeneration > 0, for the same reason as + // IncrementRestyleGeneration. + ++mUndisplayedRestyleGeneration; + } + } + + nsPresContext* PresContext() const { + MOZ_ASSERT(mPresContext); + return mPresContext; + } + + private: + nsPresContext* mPresContext; // weak, can be null after Disconnect(). + uint64_t mRestyleGeneration; + uint64_t mUndisplayedRestyleGeneration; + + // Used to keep track of frames that have been destroyed during + // ProcessRestyledFrames, so we don't try to touch them again even if + // they're referenced again later in the changelist. + mozilla::UniquePtr<nsTHashSet<const nsIFrame*>> mDestroyedFrames; + + protected: + // True if we're in the middle of a nsRefreshDriver refresh + bool mInStyleRefresh; + + // The total number of animation flushes by this frame constructor. + // Used to keep the layer and animation manager in sync. + uint64_t mAnimationGeneration; + + OverflowChangedTracker mOverflowChangedTracker; + + AnimationsWithDestroyedFrame* mAnimationsWithDestroyedFrame = nullptr; + + const SnapshotTable& Snapshots() const { return mSnapshots; } + void ClearSnapshots(); + ServoElementSnapshot& SnapshotFor(Element&); + void TakeSnapshotForAttributeChange(Element&, int32_t aNameSpaceID, + nsAtom* aAttribute); + + void DoProcessPendingRestyles(ServoTraversalFlags aFlags); + + // Function to do the actual (recursive) work of + // ReparentComputedStyleForFirstLine, once we have asserted the invariants + // that only hold on the initial call. + void DoReparentComputedStyleForFirstLine(nsIFrame*, ServoStyleSet&); + + // We use a separate data structure from nsStyleChangeList because we need a + // frame to create nsStyleChangeList entries, and the primary frame may not be + // attached yet. + struct ReentrantChange { + nsCOMPtr<nsIContent> mContent; + nsChangeHint mHint; + }; + typedef AutoTArray<ReentrantChange, 10> ReentrantChangeList; + + // Only non-null while processing change hints. See the comment in + // ProcessPendingRestyles. + ReentrantChangeList* mReentrantChanges = nullptr; + + // We use this flag to track if the current restyle contains any non-animation + // update, which triggers a normal restyle, and so there might be any new + // transition created later. Therefore, if this flag is true, we need to + // increase mAnimationGeneration before creating new transitions, so their + // creation sequence will be correct. + bool mHaveNonAnimationRestyles = false; + + // Set to true when posting restyle events triggered by CSS rule changes. + // This flag is cleared once ProcessPendingRestyles has completed. + // When we process a traversal all descendants elements of the document + // triggered by CSS rule changes, we will need to update all elements with + // CSS animations. We propagate TraversalRestyleBehavior::ForCSSRuleChanges + // to traversal function if this flag is set. + bool mRestyleForCSSRuleChanges = false; + + // A hashtable with the elements that have changed state or attributes, in + // order to calculate restyle hints during the traversal. + SnapshotTable mSnapshots; +}; + +} // namespace mozilla + +#endif |