author Boris Chiou <>
Thu, 19 Oct 2017 10:51:55 +0800
changeset 432748 a3f558c2926173a6ff6adcf6f9f641662ed0fce8
parent 431368 e5bd13138738491c93fe3b1351f670b7202050c3
permissions -rw-r--r--
Bug 1303235 - Part 1: Add ResolveServoStyleByAddingAnimation. r=hiro, a=ritu We need to create a temporary ServoStyleContext with the animation value for calculating the Cumulative change hints. MozReview-Commit-ID: JzArnaGqVeV

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

#ifndef mozilla_ServoStyleSet_h
#define mozilla_ServoStyleSet_h

#include "mozilla/EffectCompositor.h"
#include "mozilla/EnumeratedArray.h"
#include "mozilla/EventStates.h"
#include "mozilla/PostTraversalTask.h"
#include "mozilla/ServoBindingTypes.h"
#include "mozilla/ServoElementSnapshot.h"
#include "mozilla/ServoUtils.h"
#include "mozilla/StyleSheetInlines.h"
#include "mozilla/SheetType.h"
#include "mozilla/UniquePtr.h"
#include "MainThreadUtils.h"
#include "nsCSSPseudoElements.h"
#include "nsCSSAnonBoxes.h"
#include "nsChangeHint.h"
#include "nsIAtom.h"
#include "nsIMemoryReporter.h"
#include "nsTArray.h"

namespace mozilla {
namespace dom {
class Element;
} // namespace dom
class CSSStyleSheet;
class ServoRestyleManager;
class ServoStyleSheet;
struct Keyframe;
class ServoElementSnapshotTable;
class ServoStyleContext;
class ServoStyleRuleMap;
} // namespace mozilla
class nsCSSCounterStyleRule;
class nsIContent;
class nsIDocument;
class nsPresContext;
struct nsTimingFunction;
struct RawServoRuleNode;
struct TreeMatchContext;

namespace mozilla {

// A few flags used to track which kind of stylist state we may need to
// update.
enum class StylistState : uint8_t {
  // The stylist is not dirty, we should do nothing.
  NotDirty = 0,

  // The style sheets have changed, so we need to update the style data.
  StyleSheetsDirty = 1 << 0,

  // Some of the style sheets of the bound elements in binding manager have
  // changed, so we need to tell the binding manager to update style data.
  XBLStyleSheetsDirty = 1 << 1,


// Bitfield type to represent Servo stylesheet origins.
enum class OriginFlags : uint8_t {
  UserAgent = 0x01,
  User      = 0x02,
  Author    = 0x04,
  All       = 0x07,


 * The set of style sheets that apply to a document, backed by a Servo
 * Stylist.  A ServoStyleSet contains ServoStyleSheets.
class ServoStyleSet
  friend class ServoRestyleManager;
  typedef ServoElementSnapshotTable SnapshotTable;

  static bool IsInServoTraversal()
    // The callers of this function are generally main-thread-only _except_
    // for potentially running during the Servo traversal, in which case they may
    // take special paths that avoid writing to caches and the like. In order
    // to allow those callers to branch efficiently without checking TLS, we
    // maintain this static boolean. However, the danger is that those callers
    // are generally unprepared to deal with non-Servo-but-also-non-main-thread
    // callers, and are likely to take the main-thread codepath if this function
    // returns false. So we assert against other non-main-thread callers here.
    MOZ_ASSERT(sInServoTraversal || NS_IsMainThread());
    return sInServoTraversal;

#ifdef DEBUG
  // Used for debug assertions. We make this debug-only to prevent callers from
  // accidentally using it instead of IsInServoTraversal, which is cheaper. We
  // can change this if a use-case arises.
  static bool IsCurrentThreadInServoTraversal();

  static ServoStyleSet* Current()
    return sInServoTraversal;

  // The kind of styleset we have.
  // We use ServoStyleSet also from XBL bindings, and some stuff needs to be
  // different between them.
  enum class Kind : uint8_t {
    // A "master" StyleSet.
    // This one is owned by a pres shell for a given document.

    // A StyleSet for XBL, which is owned by a given XBL binding.

  explicit ServoStyleSet(Kind aKind);

  static UniquePtr<ServoStyleSet>
  CreateXBLServoStyleSet(nsPresContext* aPresContext,
                         const nsTArray<RefPtr<ServoStyleSheet>>& aNewSheets);

  void Init(nsPresContext* aPresContext, nsBindingManager* aBindingManager);
  void BeginShutdown();
  void Shutdown();

  void RecordStyleSheetChange(mozilla::ServoStyleSheet*, StyleSheet::ChangeType);

  void RecordShadowStyleChange(mozilla::dom::ShadowRoot* aShadowRoot) {
    // FIXME(emilio): When we properly support shadow dom we'll need to do
    // better.

  bool StyleSheetsHaveChanged() const
    return StylistNeedsUpdate();

  nsRestyleHint MediumFeaturesChanged(bool aViewportChanged);

  // aViewportChanged outputs whether any viewport units is used.
  bool MediumFeaturesChangedRules(bool* aViewportUnitsUsed);

  void InvalidateStyleForCSSRuleChanges();

  void AddSizeOfIncludingThis(nsWindowSizes& aSizes) const;
  const RawServoStyleSet* RawSet() const {
    return mRawSet.get();

  bool GetAuthorStyleDisabled() const;
  nsresult SetAuthorStyleDisabled(bool aStyleDisabled);

  void BeginUpdate();
  nsresult EndUpdate();

  ResolveStyleFor(dom::Element* aElement,
                  ServoStyleContext* aParentContext,
                  LazyComputeBehavior aMayCompute);

  // Get a style context for a text node (which no rules will match).
  // The returned style context will have nsCSSAnonBoxes::mozText as its pseudo.
  // (Perhaps mozText should go away and we shouldn't even create style
  // contexts for such content nodes, when text-combine-upright is not
  // present.  However, not doing any rule matching for them is a first step.)
  ResolveStyleForText(nsIContent* aTextNode,
                      ServoStyleContext* aParentContext);

  // Get a style context for a first-letter continuation (which no rules will
  // match).
  // The returned style context will have
  // nsCSSAnonBoxes::firstLetterContinuation as its pseudo.
  // (Perhaps nsCSSAnonBoxes::firstLetterContinuation should go away and we
  // shouldn't even create style contexts for such frames.  However, not doing
  // any rule matching for them is a first step.  And right now we do use this
  // style context for some things)
  ResolveStyleForFirstLetterContinuation(ServoStyleContext* aParentContext);

  // Get a style context for a placeholder frame (which no rules will match).
  // The returned style context will have nsCSSAnonBoxes::oofPlaceholder as
  // its pseudo.
  // (Perhaps nsCSSAnonBoxes::oofPaceholder should go away and we shouldn't even
  // create style contexts for placeholders.  However, not doing any rule
  // matching for them is a first step.)

  // Get a style context for a pseudo-element.  aParentElement must be
  // non-null.  aPseudoID is the CSSPseudoElementType for the
  // pseudo-element.  aPseudoElement must be non-null if the pseudo-element
  // type is one that allows user action pseudo-classes after it or allows
  // style attributes; otherwise, it is ignored.
  ResolvePseudoElementStyle(dom::Element* aOriginatingElement,
                            CSSPseudoElementType aType,
                            ServoStyleContext* aParentContext,
                            dom::Element* aPseudoElement);

  // Resolves style for a (possibly-pseudo) Element without assuming that the
  // style has been resolved. If the element was unstyled and a new style
  // context was resolved, it is not stored in the DOM. (That is, the element
  // remains unstyled.) |aPeudoTag| and |aPseudoType| must match.
  ResolveStyleLazily(dom::Element* aElement,
                     CSSPseudoElementType aPseudoType,
                     nsIAtom* aPseudoTag,
                     StyleRuleInclusion aRules =

  // Get a style context for an anonymous box.  aPseudoTag is the pseudo-tag to
  // use and must be non-null.  It must be an anon box, and must be one that
  // inherits style from the given aParentContext.
  ResolveInheritingAnonymousBoxStyle(nsIAtom* aPseudoTag,
                                     ServoStyleContext* aParentContext);

  // Get a style context for an anonymous box that does not inherit style from
  // anything.  aPseudoTag is the pseudo-tag to use and must be non-null.  It
  // must be an anon box, and must be a non-inheriting one.
  ResolveNonInheritingAnonymousBoxStyle(nsIAtom* aPseudoTag);

  // manage the set of style sheets in the style set
  nsresult AppendStyleSheet(SheetType aType, ServoStyleSheet* aSheet);
  nsresult PrependStyleSheet(SheetType aType, ServoStyleSheet* aSheet);
  nsresult RemoveStyleSheet(SheetType aType, ServoStyleSheet* aSheet);
  nsresult ReplaceSheets(SheetType aType,
                         const nsTArray<RefPtr<ServoStyleSheet>>& aNewSheets);
  nsresult InsertStyleSheetBefore(SheetType aType,
                                  ServoStyleSheet* aNewSheet,
                                  ServoStyleSheet* aReferenceSheet);

  int32_t SheetCount(SheetType aType) const;
  ServoStyleSheet* StyleSheetAt(SheetType aType, int32_t aIndex) const;

  void AppendAllXBLStyleSheets(nsTArray<StyleSheet*>& aArray) const;

  template<typename Func>
  void EnumerateStyleSheetArrays(Func aCallback) const {
    for (const auto& sheetArray : mSheets) {

  nsresult RemoveDocStyleSheet(ServoStyleSheet* aSheet);
  nsresult AddDocStyleSheet(ServoStyleSheet* aSheet, nsIDocument* aDocument);

  // check whether there is ::before/::after style for an element
  ProbePseudoElementStyle(dom::Element* aOriginatingElement,
                          mozilla::CSSPseudoElementType aType,
                          ServoStyleContext* aParentContext);

   * Performs a Servo traversal to compute style for all dirty nodes in the
   * document.
   * 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).
   * We specify |ForCSSRuleChanges| to try to update all CSS animations
   * when we call this function due to CSS rule changes since @keyframes rules
   * may have changed.
   * Returns true if a post-traversal is required.
  bool StyleDocument(ServoTraversalFlags aFlags);

   * Eagerly styles a subtree of unstyled nodes that was just appended to the
   * tree. This is used in situations where we need the style immediately and
   * cannot wait for a future batch restyle.
  void StyleNewSubtree(dom::Element* aRoot);

   * Like the above, but skips the root node, and only styles unstyled children.
   * When potentially appending multiple children, it's preferable to call
   * StyleNewChildren on the node rather than making multiple calls to
   * StyleNewSubtree on each child, since it allows for more parallelism.
  void StyleNewChildren(dom::Element* aParent);

   * Eagerly styles the children of an element that has just had an XBL
   * binding applied to it.  Some XBL consumers attach bindings to elements
   * that have not been styled yet, and in such cases, this will do the
   * equivalent of StyleNewSubtree instead.
  void StyleNewlyBoundElement(dom::Element* aElement);

   * Helper for correctly calling UpdateStylist without paying the cost of an
   * extra function call in the common no-rebuild-needed case.
  void UpdateStylistIfNeeded()
    if (StylistNeedsUpdate()) {

   * Checks whether the rule tree has crossed its threshold for unused nodes,
   * and if so, frees them.
  void MaybeGCRuleTree();

   * Returns true if the given element may be used as the root of a style
   * traversal. Reasons for false include having an unstyled parent, or having
   * a parent that is display:none.
   * Most traversal callsites don't need to check this, but some do.
  bool MayTraverseFrom(dom::Element* aElement);

#ifdef DEBUG
  void AssertTreeIsClean();
  void AssertTreeIsClean() {}

   * Clears any cached style data that may depend on all sorts of computed
   * values.
   * Right now this clears the non-inheriting style context cache, and resets
   * the default computed values.
   * This does _not_, however, clear the stylist.
  void ClearCachedStyleData();

   * Notifies the Servo stylesheet that the document's compatibility mode has changed.
  void CompatibilityModeChanged();

   * Resolve style for the given element, and return it as a
   * ServoStyleContext.
   * FIXME(emilio): Is there a point in this after bug 1367904?
  already_AddRefed<ServoStyleContext> ResolveServoStyle(dom::Element* aElement);

  bool GetKeyframesForName(const nsString& aName,
                           const nsTimingFunction& aTimingFunction,
                           nsTArray<Keyframe>& aKeyframes);

  GetComputedKeyframeValuesFor(const nsTArray<Keyframe>& aKeyframes,
                               dom::Element* aElement,
                               const ServoStyleContext* aContext);

  GetAnimationValues(RawServoDeclarationBlock* aDeclarations,
                     dom::Element* aElement,
                     const ServoStyleContext* aContext,
                     nsTArray<RefPtr<RawServoAnimationValue>>& aAnimationValues);

  bool AppendFontFaceRules(nsTArray<nsFontFaceRuleContainer>& aArray);

  nsCSSCounterStyleRule* CounterStyleRuleForName(nsIAtom* aName);

  // Get all the currently-active font feature values set.
  already_AddRefed<gfxFontFeatureValueSet> BuildFontFeatureValueSet();

  GetBaseContextForElement(dom::Element* aElement,
                           ServoStyleContext* aParentContext,
                           nsPresContext* aPresContext,
                           nsIAtom* aPseudoTag,
                           CSSPseudoElementType aPseudoType,
                           const ServoStyleContext* aStyle);

  // Get a style context that represents |aStyle|, but as though
  // it additionally matched the rules of the newly added |aAnimaitonaValue|.
  // We use this function to temporarily generate a ServoStyleContext for
  // calculating the cumulative change hints.
  // This must hold:
  //   The additional rules must be appropriate for the transition
  //   level of the cascade, which is the highest level of the cascade.
  //   (This is the case for one current caller, the cover rule used
  //   for CSS transitions.)
  // Note: |aElement| should be the generated element if it is pseudo.
  ResolveServoStyleByAddingAnimation(dom::Element* aElement,
                                     const ServoStyleContext* aStyle,
                                     RawServoAnimationValue* aAnimationValue);

   * Resolve style for a given declaration block with/without the parent style.
   * If the parent style is not specified, the document default computed values
   * is used.
  ResolveForDeclarations(const ServoStyleContext* aParentOrNull,
                         RawServoDeclarationBlockBorrowed aDeclarations);

  ComputeAnimationValue(dom::Element* aElement,
                        RawServoDeclarationBlock* aDeclaration,
                        const ServoStyleContext* aContext);

  void AppendTask(PostTraversalTask aTask)

    // We currently only use PostTraversalTasks while the Servo font metrics
    // mutex is locked.  If we need to use them in other situations during
    // a traversal, we should assert that we've taken appropriate
    // synchronization measures.


  // Returns true if a restyle of the document is needed due to cloning
  // sheet inners.
  bool EnsureUniqueInnerOnCSSSheets();

  // Called by StyleSheet::EnsureUniqueInner to let us know it cloned
  // its inner.
  void SetNeedsRestyleAfterEnsureUniqueInner() {
    mNeedsRestyleAfterEnsureUniqueInner = true;

  // Returns the style rule map.
  ServoStyleRuleMap* StyleRuleMap();

  // Return whether this is the last PresContext which uses this XBL styleset.
  bool IsPresContextChanged(nsPresContext* aPresContext) const {
    return aPresContext != mLastPresContextUsesXBLStyleSet;

  // Set PresContext (i.e. Device) for mRawSet. This should be called only
  // by XBL stylesets. Returns true if there is any rule changing.
  bool SetPresContext(nsPresContext* aPresContext);

   * Returns true if a modification to an an attribute with the specified
   * local name might require us to restyle the element.
   * This function allows us to skip taking a an attribute snapshot when
   * the modified attribute doesn't appear in an attribute selector in
   * a style sheet.
  bool MightHaveAttributeDependency(const dom::Element& aElement,
                                    nsIAtom* aAttribute) const;

   * Returns true if a change in event state on an element might require
   * us to restyle the element.
   * This function allows us to skip taking a state snapshot when
   * the changed state isn't depended upon by any pseudo-class selectors
   * in a style sheet.
  bool HasStateDependency(const dom::Element& aElement,
                          EventStates aState) const;

   * Get a new style context that uses the same rules as the given style context
   * but has a different parent.
   * aElement is non-null if this is a style context for a frame whose mContent
   * is an element and which has no pseudo on its style context (so it's the
   * actual style for the element being passed).
  ReparentStyleContext(ServoStyleContext* aStyleContext,
                       ServoStyleContext* aNewParent,
                       ServoStyleContext* aNewParentIgnoringFirstLine,
                       ServoStyleContext* aNewLayoutParent,
                       Element* aElement);

  friend class AutoSetInServoTraversal;
  friend class AutoPrepareTraversal;

  bool ShouldTraverseInParallel() const;

   * Gets the pending snapshots to handle from the restyle manager.
  const SnapshotTable& Snapshots();

  bool IsMaster() const { return mKind == Kind::Master; }
  bool IsForXBL() const { return mKind == Kind::ForXBL; }

   * Resolve all ServoDeclarationBlocks attached to mapped
   * presentation attributes cached on the document.
   * Call this before jumping into Servo's style system.
  void ResolveMappedAttrDeclarationBlocks();

   * Clear our cached mNonInheritingStyleContexts.
   * We do this when we want to make sure those style contexts won't live too
   * long (e.g. when rebuilding all style data or when shutting down the style
   * set).
  void ClearNonInheritingStyleContexts();

   * Perform processes that we should do before traversing.
   * When aRoot is null, the entire document is pre-traversed.  Otherwise,
   * only the subtree rooted at aRoot is pre-traversed.
  void PreTraverse(ServoTraversalFlags aFlags,
                   dom::Element* aRoot = nullptr);

  // Subset of the pre-traverse steps that involve syncing up data
  void PreTraverseSync();

   * Records that the contents of style sheets at the specified origin have
   * changed since the last.  Calling this will ensure that the Stylist
   * rebuilds its selector maps.
  void MarkOriginsDirty(OriginFlags aChangedOrigins);

   * Note that the stylist needs a style flush due to style sheet changes.
  void SetStylistStyleSheetsDirty()
    mStylistState |= StylistState::StyleSheetsDirty;

  void SetStylistXBLStyleSheetsDirty()
    mStylistState |= StylistState::XBLStyleSheetsDirty;

  bool StylistNeedsUpdate() const
    return mStylistState != StylistState::NotDirty;

   * Update the stylist as needed to ensure style data is up-to-date.
   * This should only be called if StylistNeedsUpdate returns true.
  void UpdateStylist();

    ResolveStyleLazilyInternal(dom::Element* aElement,
                               CSSPseudoElementType aPseudoType,
                               nsIAtom* aPseudoTag,
                               const ServoStyleContext* aParentContext,
                               StyleRuleInclusion aRules =
                               bool aIgnoreExistingStyles = false);

  void RunPostTraversalTasks();

  void PrependSheetOfType(SheetType aType,
                          ServoStyleSheet* aSheet);

  void AppendSheetOfType(SheetType aType,
                         ServoStyleSheet* aSheet);

  void InsertSheetOfType(SheetType aType,
                         ServoStyleSheet* aSheet,
                         ServoStyleSheet* aBeforeSheet);

  void RemoveSheetOfType(SheetType aType,
                         ServoStyleSheet* aSheet);

  const Kind mKind;

  // Nullptr if this is an XBL style set.
  nsPresContext* MOZ_NON_OWNING_REF mPresContext = nullptr;

  // Because XBL style set could be used by multiple PresContext, we need to
  // store the last PresContext pointer which uses this XBL styleset for
  // computing medium rule changes.
  void* MOZ_NON_OWNING_REF mLastPresContextUsesXBLStyleSet = nullptr;

  UniquePtr<RawServoStyleSet> mRawSet;
  EnumeratedArray<SheetType, SheetType::Count,
                  nsTArray<RefPtr<ServoStyleSheet>>> mSheets;
  bool mAuthorStyleDisabled;
  StylistState mStylistState;
  uint64_t mUserFontSetUpdateGeneration;
  uint32_t mUserFontCacheUpdateGeneration;

  bool mNeedsRestyleAfterEnsureUniqueInner;

  // Stores pointers to our cached style contexts for non-inheriting anonymous
  // boxes.
                  RefPtr<ServoStyleContext>> mNonInheritingStyleContexts;

  // Tasks to perform after a traversal, back on the main thread.
  // These are similar to Servo's SequentialTasks, except that they are
  // posted by C++ code running on style worker threads.
  nsTArray<PostTraversalTask> mPostTraversalTasks;

  // Map from raw Servo style rule to Gecko's wrapper object.
  // Constructed lazily when requested by devtools.
  RefPtr<ServoStyleRuleMap> mStyleRuleMap;

  // This can be null if we are used to hold XBL style sheets.
  RefPtr<nsBindingManager> mBindingManager;

  static ServoStyleSet* sInServoTraversal;

class UACacheReporter final : public nsIMemoryReporter

  ~UACacheReporter() {}

} // namespace mozilla

#endif // mozilla_ServoStyleSet_h