gecko-dev/layout/base/RestyleManager.h

/* -*- 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);

  /**
   * Posts restyle hints for siblings of an element and their descendants if the
   * element's parent has NODE_HAS_SLOW_SELECTOR_NTH_OF and the element has a
   * relevant state dependency.
   */
  void MaybeRestyleForNthOfState(ServoStyleSet& aStyleSet, dom::Element* aChild,
                                 dom::ElementState aChangedBits);

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

  /**
   * Restyle an element's previous and/or next siblings.
   */
  void RestyleSiblingsForNthOf(dom::Element* aChild,
                               NodeSelectorFlags aParentFlags);

  /**
   * Posts restyle hints for siblings of an element and their descendants if the
   * element's parent has NODE_HAS_SLOW_SELECTOR_NTH_OF and the element has a
   * relevant attribute dependency.
   */
  void MaybeRestyleForNthOfAttribute(dom::Element* aChild, nsAtom* aAttribute,
                                     const nsAttrValue* aOldValue);

  void MaybeRestyleForRelativeSelectorAttribute(dom::Element* aElement,
                                                nsAtom* aAttribute,
                                                const nsAttrValue* aOldValue);
  void MaybeRestyleForRelativeSelectorState(ServoStyleSet& aStyleSet,
                                            dom::Element* aElement,
                                            dom::ElementState aChangedBits);

  // 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 RestylePreviousSiblings(nsIContent* aStartingSibling);
  void RestyleSiblingsStartingWith(nsIContent* aStartingSibling);

  void RestyleForEmptyChange(Element* aContainer);
  void MaybeRestyleForEdgeChildChange(nsINode* 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