gecko-dev/layout/base/RestyleManager.h
Emilio Cobos Álvarez 619cb14d87 Bug 1299066: Make NS_STYLE_DISPLAY_* an enum class. Prefer indexing instead of linear search in the frame constructor r=heycam,bz
The main renaming was generated with the following python script:

```

import sys
import re

CAMEL_CASE_REGEX = re.compile(r"(^|_|-)([A-Z])([A-Z]+)")
DISPLAY_REGEX = re.compile(r"\bNS_STYLE_DISPLAY_([^M][A-Z_]+)\b")

def to_camel_case(ident):
  return re.sub(CAMEL_CASE_REGEX,
                lambda m: m.group(2) + m.group(3).lower(), ident)

def constant_to_enum(constant):
  return "StyleDisplay::" + to_camel_case(constant) + ("_" if constant == "NONE" else "")

def process_line(line):
  return re.sub(DISPLAY_REGEX,
                lambda m: constant_to_enum(m.group(1)), line)

lines = []
with open(sys.argv[1], "r") as f:
  for line in f:
    lines.append(process_line(line))

with open(sys.argv[1], "w") as f:
  for line in lines:
    f.write(line)
```

And the following shell commands:

```
find . -name '*.cpp' -exec python display.py {} \;
find . -name '*.h' -exec python display.py {} \;
```

MozReview-Commit-ID: 91xYCbLC2Vf
2016-09-01 20:41:17 -07:00

886 lines
36 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
/**
* Code responsible for managing style changes: tracking what style
* changes need to happen, scheduling them, and doing them.
*/
#ifndef mozilla_RestyleManager_h
#define mozilla_RestyleManager_h
#include "mozilla/RestyleLogging.h"
#include "mozilla/RestyleManagerBase.h"
#include "nsISupportsImpl.h"
#include "nsChangeHint.h"
#include "RestyleTracker.h"
#include "nsPresContext.h"
#include "nsRefreshDriver.h"
#include "nsRefPtrHashtable.h"
#include "nsTransitionManager.h"
class nsIFrame;
class nsStyleChangeList;
struct TreeMatchContext;
namespace mozilla {
enum class CSSPseudoElementType : uint8_t;
class EventStates;
struct UndisplayedNode;
namespace dom {
class Element;
} // namespace dom
class RestyleManager final : public RestyleManagerBase
{
public:
typedef RestyleManagerBase base_type;
friend class RestyleTracker;
friend class ElementRestyler;
explicit RestyleManager(nsPresContext* aPresContext);
private:
// Private destructor, to discourage deletion outside of Release():
~RestyleManager()
{
MOZ_ASSERT(!mReframingStyleContexts,
"temporary member should be nulled out before destruction");
MOZ_ASSERT(!mAnimationsWithDestroyedFrame,
"leaving dangling pointers from AnimationsWithDestroyedFrame");
}
public:
NS_INLINE_DECL_REFCOUNTING(mozilla::RestyleManager)
// Forwarded nsIDocumentObserver method, to handle restyling (and
// passing the notification to the frame).
nsresult ContentStateChanged(nsIContent* aContent,
EventStates aStateMask);
// Forwarded nsIMutationObserver method, to handle restyling.
void AttributeWillChange(Element* aElement,
int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType,
const nsAttrValue* aNewValue);
// Forwarded nsIMutationObserver method, to handle restyling (and
// passing the notification to the frame).
void AttributeChanged(Element* aElement,
int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType,
const nsAttrValue* aOldValue);
// 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; }
static uint64_t GetAnimationGenerationForFrame(nsIFrame* aFrame);
// 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() {
// 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 (!mIsProcessingRestyles) {
++mAnimationGeneration;
}
}
// Whether rule matching should skip styles associated with animation
bool SkipAnimationRules() const { return mSkipAnimationRules; }
void SetSkipAnimationRules(bool aSkipAnimationRules) {
mSkipAnimationRules = aSkipAnimationRules;
}
/**
* Reparent the style contexts of this frame subtree. The parent frame of
* aFrame must be changed to the new parent before this function is called;
* the new parent style context will be automatically computed based on the
* new position in the frame tree.
*
* @param aFrame the root of the subtree to reparent. Must not be null.
*/
nsresult ReparentStyleContext(nsIFrame* aFrame);
void ClearSelectors() {
mPendingRestyles.ClearSelectors();
}
private:
// Used when restyling an element with a frame.
void ComputeAndProcessStyleChange(nsIFrame* aFrame,
nsChangeHint aMinChange,
RestyleTracker& aRestyleTracker,
nsRestyleHint aRestyleHint,
const RestyleHintData& aRestyleHintData);
// Used when restyling a display:contents element.
void ComputeAndProcessStyleChange(nsStyleContext* aNewContext,
Element* aElement,
nsChangeHint aMinChange,
RestyleTracker& aRestyleTracker,
nsRestyleHint aRestyleHint,
const RestyleHintData& aRestyleHintData);
public:
/**
* In order to start CSS transitions on elements that are being
* reframed, we need to stash their style contexts somewhere during
* the reframing process.
*
* In all cases, the content node in the hash table is the real
* content node, not the anonymous content node we create for ::before
* or ::after. The content node passed to the Get and Put methods is,
* however, the content node to be associate with the frame's style
* context.
*/
typedef nsRefPtrHashtable<nsRefPtrHashKey<nsIContent>, nsStyleContext>
ReframingStyleContextTable;
class MOZ_STACK_CLASS ReframingStyleContexts final {
public:
/**
* Construct a ReframingStyleContexts 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 ReframingStyleContexts(RestyleManager* aRestyleManager);
~ReframingStyleContexts();
void Put(nsIContent* aContent, nsStyleContext* aStyleContext) {
MOZ_ASSERT(aContent);
CSSPseudoElementType pseudoType = aStyleContext->GetPseudoType();
if (pseudoType == CSSPseudoElementType::NotPseudo) {
mElementContexts.Put(aContent, aStyleContext);
} else if (pseudoType == CSSPseudoElementType::before) {
MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore);
mBeforePseudoContexts.Put(aContent->GetParent(), aStyleContext);
} else if (pseudoType == CSSPseudoElementType::after) {
MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentafter);
mAfterPseudoContexts.Put(aContent->GetParent(), aStyleContext);
}
}
nsStyleContext* Get(nsIContent* aContent,
CSSPseudoElementType aPseudoType) {
MOZ_ASSERT(aContent);
if (aPseudoType == CSSPseudoElementType::NotPseudo) {
return mElementContexts.GetWeak(aContent);
}
if (aPseudoType == CSSPseudoElementType::before) {
MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore);
return mBeforePseudoContexts.GetWeak(aContent->GetParent());
}
if (aPseudoType == CSSPseudoElementType::after) {
MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentafter);
return mAfterPseudoContexts.GetWeak(aContent->GetParent());
}
MOZ_ASSERT(false, "unexpected aPseudoType");
return nullptr;
}
private:
RestyleManager* mRestyleManager;
AutoRestore<ReframingStyleContexts*> mRestorePointer;
ReframingStyleContextTable mElementContexts;
ReframingStyleContextTable mBeforePseudoContexts;
ReframingStyleContextTable mAfterPseudoContexts;
};
/**
* Return the current ReframingStyleContexts struct, or null if we're
* not currently in a restyling operation.
*/
ReframingStyleContexts* GetReframingStyleContexts() {
return mReframingStyleContexts;
}
/**
* Try starting a transition for an element or a ::before or ::after
* pseudo-element, given an old and new style context. This may
* change the new style context if a transition is started. Returns
* true iff it does change aNewStyleContext.
*
* For the pseudo-elements, aContent must be the anonymous content
* that we're creating for that pseudo-element, not the real element.
*/
static bool
TryStartingTransition(nsPresContext* aPresContext, nsIContent* aContent,
nsStyleContext* aOldStyleContext,
RefPtr<nsStyleContext>* aNewStyleContext /* inout */);
// 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, nsStyleContext* aStyleContext) {
MOZ_ASSERT(aContent);
CSSPseudoElementType pseudoType = aStyleContext->GetPseudoType();
if (pseudoType == CSSPseudoElementType::NotPseudo) {
mContents.AppendElement(aContent);
} else if (pseudoType == CSSPseudoElementType::before) {
MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore);
mBeforeContents.AppendElement(aContent->GetParent());
} else if (pseudoType == CSSPseudoElementType::after) {
MOZ_ASSERT(aContent->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentafter);
mAfterContents.AppendElement(aContent->GetParent());
}
}
void StopAnimationsForElementsWithoutFrames();
private:
void StopAnimationsWithoutFrame(nsTArray<RefPtr<nsIContent>>& aArray,
CSSPseudoElementType aPseudoType);
RestyleManager* mRestyleManager;
AutoRestore<AnimationsWithDestroyedFrame*> mRestorePointer;
// Below three arrays might include elements that have already had their
// animations or transitions stopped.
//
// mBeforeContents and mAfterContents 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;
};
/**
* Return the current AnimationsWithDestroyedFrame struct, or null if we're
* not currently in a restyling operation.
*/
AnimationsWithDestroyedFrame* GetAnimationsWithDestroyedFrame() {
return mAnimationsWithDestroyedFrame;
}
private:
void RestyleForEmptyChange(Element* aContainer);
public:
// Handle ContentInserted notifications.
void ContentInserted(nsINode* aContainer, nsIContent* aChild)
{
RestyleForInsertOrChange(aContainer, aChild);
}
// Handle ContentAppended notifications.
void ContentAppended(nsIContent* aContainer, nsIContent* aFirstNewContent)
{
RestyleForAppend(aContainer, aFirstNewContent);
}
// Handle ContentRemoved notifications.
//
// 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. |aContainer| must be
// non-null; when the container is null, no work is needed. aFollowingSibling
// is the sibling that used to come after aOldChild before the removal.
void ContentRemoved(nsINode* aContainer, nsIContent* aOldChild,
nsIContent* aFollowingSibling);
// Restyling for a ContentInserted (notification after insertion) or
// for a CharacterDataChanged. |aContainer| must be non-null; when
// the container is null, no work is needed.
void RestyleForInsertOrChange(nsINode* aContainer, nsIContent* aChild);
// Restyling for a ContentAppended (notification after insertion) or
// for a CharacterDataChanged. |aContainer| must be non-null; when
// the container is null, no work is needed.
void RestyleForAppend(nsIContent* aContainer, nsIContent* aFirstNewContent);
// Process any pending restyles. This should be called after
// CreateNeededFrames.
// Note: It's the caller's responsibility to make sure to wrap a
// ProcessPendingRestyles 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 ProcessPendingRestyles();
// Returns whether there are any pending restyles.
bool HasPendingRestyles() { return mPendingRestyles.Count() != 0; }
private:
// ProcessPendingRestyles calls into one of our RestyleTracker
// objects. It then calls back to these functions at the beginning
// and end of its work.
void BeginProcessingRestyles(RestyleTracker& aRestyleTracker);
void EndProcessingRestyles();
public:
// Update styles for animations that are running on the compositor and
// whose updating is suppressed on the main thread (to save
// unnecessary work), while leaving all other aspects of style
// out-of-date.
//
// Performs an animation-only style flush to make styles from
// throttled transitions up-to-date prior to processing an unrelated
// style change, so that any transitions triggered by that style
// change produce correct results.
//
// In more detail: when we're able to run animations on the
// compositor, we sometimes "throttle" these animations by skipping
// updating style data on the main thread. However, whenever we
// process a normal (non-animation) style change, any changes in
// computed style on elements that have transition-* properties set
// may need to trigger new transitions; this process requires knowing
// both the old and new values of the property. To do this correctly,
// we need to have an up-to-date *old* value of the property on the
// primary frame. So the purpose of the mini-flush is to update the
// style for all throttled transitions and animations to the current
// animation state without making any other updates, so that when we
// process the queued style updates we'll have correct old data to
// compare against. When we do this, we don't bother touching frames
// other than primary frames.
void UpdateOnlyAnimationStyles();
// Rebuilds all style data by throwing out the old rule tree and
// building a new one, and additionally applying aExtraHint (which
// must not contain nsChangeHint_ReconstructFrame) to the root frame.
//
// aRestyleHint says which restyle hint to use for the computation;
// the only sensible values to use are eRestyle_Subtree (which says
// that the rebuild must run selector matching) and nsRestyleHint(0)
// (which says that rerunning selector matching is not required. (The
// method adds eRestyle_ForceDescendants internally, and including it
// in the restyle hint is harmless; some callers (e.g.,
// nsPresContext::MediaFeatureValuesChanged) might do this for their
// own reasons.)
void RebuildAllStyleData(nsChangeHint aExtraHint,
nsRestyleHint aRestyleHint);
/**
* Notify the frame constructor that an element needs to have its
* style recomputed.
* @param aElement: The element to be restyled.
* @param aRestyleHint: Which nodes need to have selector matching run
* on them.
* @param aMinChangeHint: A minimum change hint for aContent and its
* descendants.
* @param aRestyleHintData: Additional data to go with aRestyleHint.
*/
void PostRestyleEvent(Element* aElement,
nsRestyleHint aRestyleHint,
nsChangeHint aMinChangeHint,
const RestyleHintData* aRestyleHintData = nullptr);
void PostRestyleEventForLazyConstruction()
{
PostRestyleEventInternal(true);
}
public:
/**
* Asynchronously clear style data from the root frame downwards and ensure
* it will all be rebuilt. This is safe to call anytime; it will schedule
* a restyle and take effect next time style changes are flushed.
* This method is used to recompute the style data when some change happens
* outside of any style rules, like a color preference change or a change
* in a system font size, or to fix things up when an optimization in the
* style data has become invalid. We assume that the root frame will not
* need to be reframed.
*
* For parameters, see RebuildAllStyleData.
*/
void PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint,
nsRestyleHint aRestyleHint);
#ifdef DEBUG
bool InRebuildAllStyleData() const { return mInRebuildAllStyleData; }
#endif
#ifdef RESTYLE_LOGGING
/**
* Returns whether a restyle event currently being processed by this
* RestyleManager should be logged.
*/
bool ShouldLogRestyle() {
return ShouldLogRestyle(PresContext());
}
/**
* Returns whether a restyle event currently being processed for the
* document with the specified nsPresContext should be logged.
*/
static bool ShouldLogRestyle(nsPresContext* aPresContext) {
return aPresContext->RestyleLoggingEnabled() &&
(!aPresContext->TransitionManager()->
InAnimationOnlyStyleUpdate() ||
AnimationRestyleLoggingEnabled());
}
static bool RestyleLoggingInitiallyEnabled() {
static bool enabled = getenv("MOZ_DEBUG_RESTYLE") != 0;
return enabled;
}
static bool AnimationRestyleLoggingEnabled() {
static bool animations = getenv("MOZ_DEBUG_RESTYLE_ANIMATIONS") != 0;
return animations;
}
// Set MOZ_DEBUG_RESTYLE_STRUCTS to a comma-separated string of
// style struct names -- such as "Font,SVGReset" -- to log the style context
// tree and those cached struct pointers before each restyle. This
// function returns a bitfield of the structs named in the
// environment variable.
static uint32_t StructsToLog();
static nsCString StructNamesToString(uint32_t aSIDs);
int32_t& LoggingDepth() { return mLoggingDepth; }
#endif
private:
inline nsStyleSet* StyleSet() const {
MOZ_ASSERT(PresContext()->StyleSet()->IsGecko(),
"RestyleManager should only be used with a Gecko-flavored "
"style backend");
return PresContext()->StyleSet()->AsGecko();
}
/* aMinHint is the minimal change that should be made to the element */
// XXXbz do we really need the aPrimaryFrame argument here?
void RestyleElement(Element* aElement,
nsIFrame* aPrimaryFrame,
nsChangeHint aMinHint,
RestyleTracker& aRestyleTracker,
nsRestyleHint aRestyleHint,
const RestyleHintData& aRestyleHintData);
void StartRebuildAllStyleData(RestyleTracker& aRestyleTracker);
void FinishRebuildAllStyleData();
bool ShouldStartRebuildAllFor(RestyleTracker& aRestyleTracker) {
// When we process our primary restyle tracker and we have a pending
// rebuild-all, we need to process it.
return mDoRebuildAllStyleData &&
&aRestyleTracker == &mPendingRestyles;
}
void ProcessRestyles(RestyleTracker& aRestyleTracker) {
// Fast-path the common case (esp. for the animation restyle
// tracker) of not having anything to do.
if (aRestyleTracker.Count() || ShouldStartRebuildAllFor(aRestyleTracker)) {
IncrementRestyleGeneration();
aRestyleTracker.DoProcessRestyles();
}
}
private:
// True if we need to reconstruct the rule tree the next time we
// process restyles.
bool mDoRebuildAllStyleData : 1;
// True if we're currently in the process of reconstructing the rule tree.
bool mInRebuildAllStyleData : 1;
// Whether rule matching should skip styles associated with animation
bool mSkipAnimationRules : 1;
bool mHavePendingNonAnimationRestyles : 1;
nsChangeHint mRebuildAllExtraHint;
nsRestyleHint mRebuildAllRestyleHint;
// The total number of animation flushes by this frame constructor.
// Used to keep the layer and animation manager in sync.
uint64_t mAnimationGeneration;
ReframingStyleContexts* mReframingStyleContexts;
AnimationsWithDestroyedFrame* mAnimationsWithDestroyedFrame;
RestyleTracker mPendingRestyles;
// Are we currently in the middle of a call to ProcessRestyles?
// This flag is used both as a debugging aid to assert that we are not
// performing nested calls to ProcessPendingRestyles, as well as to ignore
// redundant calls to IncrementAnimationGeneration.
bool mIsProcessingRestyles;
#ifdef RESTYLE_LOGGING
int32_t mLoggingDepth;
#endif
};
/**
* An ElementRestyler is created for *each* element in a subtree that we
* recompute styles for.
*/
class ElementRestyler final
{
public:
typedef mozilla::dom::Element Element;
struct ContextToClear {
RefPtr<nsStyleContext> mStyleContext;
uint32_t mStructs;
};
// Construct for the root of the subtree that we're restyling.
ElementRestyler(nsPresContext* aPresContext,
nsIFrame* aFrame,
nsStyleChangeList* aChangeList,
nsChangeHint aHintsHandledByAncestors,
RestyleTracker& aRestyleTracker,
nsTArray<nsCSSSelector*>& aSelectorsForDescendants,
TreeMatchContext& aTreeMatchContext,
nsTArray<nsIContent*>& aVisibleKidsOfHiddenElement,
nsTArray<ContextToClear>& aContextsToClear,
nsTArray<RefPtr<nsStyleContext>>& aSwappedStructOwners);
// Construct for an element whose parent is being restyled.
enum ConstructorFlags {
FOR_OUT_OF_FLOW_CHILD = 1<<0
};
ElementRestyler(const ElementRestyler& aParentRestyler,
nsIFrame* aFrame,
uint32_t aConstructorFlags);
// Construct for a frame whose parent is being restyled, but whose
// style context is the parent style context for its parent frame.
// (This is only used for table frames, whose style contexts are used
// as the parent style context for their table wrapper frame. We should
// probably try to get rid of this exception and have the inheritance go
// the other way.)
enum ParentContextFromChildFrame { PARENT_CONTEXT_FROM_CHILD_FRAME };
ElementRestyler(ParentContextFromChildFrame,
const ElementRestyler& aParentFrameRestyler,
nsIFrame* aFrame);
// For restyling undisplayed content only (mFrame==null).
ElementRestyler(nsPresContext* aPresContext,
nsIContent* aContent,
nsStyleChangeList* aChangeList,
nsChangeHint aHintsHandledByAncestors,
RestyleTracker& aRestyleTracker,
nsTArray<nsCSSSelector*>& aSelectorsForDescendants,
TreeMatchContext& aTreeMatchContext,
nsTArray<nsIContent*>& aVisibleKidsOfHiddenElement,
nsTArray<ContextToClear>& aContextsToClear,
nsTArray<RefPtr<nsStyleContext>>& aSwappedStructOwners);
/**
* Restyle our frame's element and its subtree.
*
* Use eRestyle_Self for the aRestyleHint argument to mean
* "reresolve our style context but not kids", use eRestyle_Subtree
* to mean "reresolve our style context and kids", and use
* nsRestyleHint(0) to mean recompute a new style context for our
* current parent and existing rulenode, and the same for kids.
*/
void Restyle(nsRestyleHint aRestyleHint);
/**
* mHintsHandled changes over time; it starts off as the hints that
* have been handled by ancestors, and by the end of Restyle it
* represents the hints that have been handled for this frame. This
* method is intended to be called after Restyle, to find out what
* hints have been handled for this frame.
*/
nsChangeHint HintsHandledForFrame() { return mHintsHandled; }
/**
* Called from RestyleManager::ComputeAndProcessStyleChange to restyle
* children of a display:contents element.
*/
void RestyleChildrenOfDisplayContentsElement(nsIFrame* aParentFrame,
nsStyleContext* aNewContext,
nsChangeHint aMinHint,
RestyleTracker& aRestyleTracker,
nsRestyleHint aRestyleHint,
const RestyleHintData&
aRestyleHintData);
/**
* Re-resolve the style contexts for a frame tree, building aChangeList
* based on the resulting style changes, plus aMinChange applied to aFrame.
*/
static void ComputeStyleChangeFor(nsIFrame* aFrame,
nsStyleChangeList* aChangeList,
nsChangeHint aMinChange,
RestyleTracker& aRestyleTracker,
nsRestyleHint aRestyleHint,
const RestyleHintData& aRestyleHintData,
nsTArray<ContextToClear>& aContextsToClear,
nsTArray<RefPtr<nsStyleContext>>&
aSwappedStructOwners);
#ifdef RESTYLE_LOGGING
bool ShouldLogRestyle() {
return RestyleManager::ShouldLogRestyle(mPresContext);
}
#endif
private:
inline nsStyleSet* StyleSet() const;
// Enum class for the result of RestyleSelf, which indicates whether the
// restyle procedure should continue to the children, and how.
//
// These values must be ordered so that later values imply that all
// the work of the earlier values is also done.
enum class RestyleResult : uint8_t {
// default initial value
eNone,
// we left the old style context on the frame; do not restyle children
eStop,
// we got a new style context on this frame, but we know that children
// do not depend on the changed values; do not restyle children
eStopWithStyleChange,
// continue restyling children
eContinue,
// continue restyling children with eRestyle_ForceDescendants set
eContinueAndForceDescendants
};
struct SwapInstruction
{
RefPtr<nsStyleContext> mOldContext;
RefPtr<nsStyleContext> mNewContext;
uint32_t mStructsToSwap;
};
/**
* First half of Restyle().
*/
RestyleResult RestyleSelf(nsIFrame* aSelf,
nsRestyleHint aRestyleHint,
uint32_t* aSwappedStructs,
nsTArray<SwapInstruction>& aSwaps);
/**
* Restyle the children of this frame (and, in turn, their children).
*
* Second half of Restyle().
*/
void RestyleChildren(nsRestyleHint aChildRestyleHint);
/**
* Returns true iff a selector in mSelectorsForDescendants matches aElement.
* This is called when processing a eRestyle_SomeDescendants restyle hint.
*/
bool SelectorMatchesForRestyle(Element* aElement);
/**
* Returns true iff aRestyleHint indicates that we should be restyling.
* Specifically, this will return true when eRestyle_Self or
* eRestyle_Subtree is present, or if eRestyle_SomeDescendants is
* present and the specified element matches one of the selectors in
* mSelectorsForDescendants.
*/
bool MustRestyleSelf(nsRestyleHint aRestyleHint, Element* aElement);
/**
* Returns true iff aRestyleHint indicates that we can call
* ReparentStyleContext rather than any other restyling method of
* nsStyleSet that looks up a new rule node, and if we are
* not in the process of reconstructing the whole rule tree.
* This is used to check whether it is appropriate to call
* ReparentStyleContext.
*/
bool CanReparentStyleContext(nsRestyleHint aRestyleHint);
/**
* Helpers for Restyle().
*/
void AddLayerChangesForAnimation();
bool MoveStyleContextsForContentChildren(nsIFrame* aParent,
nsStyleContext* aOldContext,
nsTArray<nsStyleContext*>& aContextsToMove);
bool MoveStyleContextsForChildren(nsStyleContext* aOldContext);
/**
* Helpers for RestyleSelf().
*/
void CaptureChange(nsStyleContext* aOldContext,
nsStyleContext* aNewContext,
nsChangeHint aChangeToAssume,
uint32_t* aEqualStructs,
uint32_t* aSamePointerStructs);
void ComputeRestyleResultFromFrame(nsIFrame* aSelf,
RestyleResult& aRestyleResult,
bool& aCanStopWithStyleChange);
void ComputeRestyleResultFromNewContext(nsIFrame* aSelf,
nsStyleContext* aNewContext,
RestyleResult& aRestyleResult,
bool& aCanStopWithStyleChange);
// Helpers for RestyleChildren().
void RestyleUndisplayedDescendants(nsRestyleHint aChildRestyleHint);
bool MustCheckUndisplayedContent(nsIFrame* aFrame,
nsIContent*& aUndisplayedParent);
/**
* In the following two methods, aParentStyleContext is either
* mFrame->StyleContext() if we have a frame, or a display:contents
* style context if we don't.
*/
void DoRestyleUndisplayedDescendants(nsRestyleHint aChildRestyleHint,
nsIContent* aParent,
nsStyleContext* aParentStyleContext);
void RestyleUndisplayedNodes(nsRestyleHint aChildRestyleHint,
UndisplayedNode* aUndisplayed,
nsIContent* aUndisplayedParent,
nsStyleContext* aParentStyleContext,
const StyleDisplay aDisplay);
void MaybeReframeForBeforePseudo();
void MaybeReframeForAfterPseudo(nsIFrame* aFrame);
void MaybeReframeForPseudo(CSSPseudoElementType aPseudoType,
nsIFrame* aGenConParentFrame,
nsIFrame* aFrame,
nsIContent* aContent,
nsStyleContext* aStyleContext);
#ifdef DEBUG
bool MustReframeForBeforePseudo();
bool MustReframeForAfterPseudo(nsIFrame* aFrame);
#endif
bool MustReframeForPseudo(CSSPseudoElementType aPseudoType,
nsIFrame* aGenConParentFrame,
nsIFrame* aFrame,
nsIContent* aContent,
nsStyleContext* aStyleContext);
void RestyleContentChildren(nsIFrame* aParent,
nsRestyleHint aChildRestyleHint);
void InitializeAccessibilityNotifications(nsStyleContext* aNewContext);
void SendAccessibilityNotifications();
enum DesiredA11yNotifications {
eSkipNotifications,
eSendAllNotifications,
eNotifyIfShown
};
enum A11yNotificationType {
eDontNotify,
eNotifyShown,
eNotifyHidden
};
// These methods handle the eRestyle_SomeDescendants hint by traversing
// down the frame tree (and then when reaching undisplayed content,
// the flattened content tree) find elements that match a selector
// in mSelectorsForDescendants and call AddPendingRestyle for them.
void ConditionallyRestyleChildren();
void ConditionallyRestyleChildren(nsIFrame* aFrame,
Element* aRestyleRoot);
void ConditionallyRestyleContentChildren(nsIFrame* aFrame,
Element* aRestyleRoot);
void ConditionallyRestyleUndisplayedDescendants(nsIFrame* aFrame,
Element* aRestyleRoot);
void DoConditionallyRestyleUndisplayedDescendants(nsIContent* aParent,
Element* aRestyleRoot);
void ConditionallyRestyleUndisplayedNodes(UndisplayedNode* aUndisplayed,
nsIContent* aUndisplayedParent,
const StyleDisplay aDisplay,
Element* aRestyleRoot);
void ConditionallyRestyleContentDescendants(Element* aElement,
Element* aRestyleRoot);
bool ConditionallyRestyle(nsIFrame* aFrame, Element* aRestyleRoot);
bool ConditionallyRestyle(Element* aElement, Element* aRestyleRoot);
#ifdef RESTYLE_LOGGING
int32_t& LoggingDepth() { return mLoggingDepth; }
#endif
#ifdef DEBUG
static nsCString RestyleResultToString(RestyleResult aRestyleResult);
#endif
private:
nsPresContext* const mPresContext;
nsIFrame* const mFrame;
nsIContent* const mParentContent;
// |mContent| is the node that we used for rule matching of
// normal elements (not pseudo-elements) and for which we generate
// framechange hints if we need them.
nsIContent* const mContent;
nsStyleChangeList* const mChangeList;
// We have already generated change list entries for hints listed in
// mHintsHandled (initially it's those handled by ancestors, but by
// the end of Restyle it is those handled for this frame as well). We
// need to generate a new change list entry for the frame when its
// style comparision returns a hint other than one of these hints.
nsChangeHint mHintsHandled;
// See nsStyleContext::CalcStyleDifference
nsChangeHint mParentFrameHintsNotHandledForDescendants;
nsChangeHint mHintsNotHandledForDescendants;
RestyleTracker& mRestyleTracker;
nsTArray<nsCSSSelector*>& mSelectorsForDescendants;
TreeMatchContext& mTreeMatchContext;
nsIFrame* mResolvedChild; // child that provides our parent style context
// Array of style context subtrees in which we need to clear out cached
// structs at the end of the restyle (after change hints have been
// processed).
nsTArray<ContextToClear>& mContextsToClear;
// Style contexts that had old structs swapped into it and which should
// stay alive until the end of the restyle. (See comment in
// ElementRestyler::Restyle.)
nsTArray<RefPtr<nsStyleContext>>& mSwappedStructOwners;
// Whether this is the root of the restyle.
bool mIsRootOfRestyle;
#ifdef ACCESSIBILITY
const DesiredA11yNotifications mDesiredA11yNotifications;
DesiredA11yNotifications mKidsDesiredA11yNotifications;
A11yNotificationType mOurA11yNotification;
nsTArray<nsIContent*>& mVisibleKidsOfHiddenElement;
bool mWasFrameVisible;
#endif
#ifdef RESTYLE_LOGGING
int32_t mLoggingDepth;
#endif
};
/**
* This pushes any display:contents nodes onto a TreeMatchContext.
* Use it before resolving style for kids of aParent where aParent
* (and further ancestors) may be display:contents nodes which have
* not yet been pushed onto TreeMatchContext.
*/
class MOZ_RAII AutoDisplayContentsAncestorPusher final
{
public:
typedef mozilla::dom::Element Element;
AutoDisplayContentsAncestorPusher(TreeMatchContext& aTreeMatchContext,
nsPresContext* aPresContext,
nsIContent* aParent);
~AutoDisplayContentsAncestorPusher();
bool IsEmpty() const { return mAncestors.Length() == 0; }
private:
TreeMatchContext& mTreeMatchContext;
nsPresContext* const mPresContext;
AutoTArray<mozilla::dom::Element*, 4> mAncestors;
};
} // namespace mozilla
#endif /* mozilla_RestyleManager_h */