| blob | 1c9d67c26f3e027316f3007e4539d0a29a2fc022 |
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
59 #ifdef ACCESSIBILITY
61 #endif
78 }
83 }
89 #ifdef DEBUG
90 {
94 }
95 }
96 #endif
102 }
104 // The container cannot be a document.
108 // see whether we need to restyle the container
112 // We don't know whether we're testing :empty or :-moz-only-whitespace,
113 // so be conservative and assume :-moz-only-whitespace (i.e., make
114 // IsSignificantChild less likely to be true, and thus make us more
115 // likely to restyle).
119 }
120 }
124 }
125 }
134 }
135 // Restyling the container is the most we can do here, so we're done.
137 }
140 // restyle the last element child before this node
147 }
148 }
149 }
150 }
157 }
158 }
159 }
166 }
167 }
168 }
173 // In some cases (:empty + E, :empty ~ E), a change in the content of
174 // an element requires restyling its parent's siblings.
179 }
181 }
187 // restyle the previously-first element child if it is after this node
194 }
199 }
201 }
202 }
203 // restyle the previously-last element child if it is before this node
210 }
215 }
217 }
218 }
219 }
226 }
227 }
229 }
236 // The old text was already not whitespace-only.
238 }
241 }
249 }
250 // We don't know whether we're testing :empty or :-moz-only-whitespace,
251 // so be conservative and assume :-moz-only-whitespace (i.e., make
252 // IsSignificantChild less likely to be true, and thus make us more
253 // likely to restyle).
256 }
257 }
260 }
270 // Nothing to do, no other slow selector can change as a result of this.
272 }
275 // Doesn't matter to styling (could be a processing instruction or a
276 // comment), it can't change whether any selectors match or don't.
278 }
283 }
286 // This is an anonymous node and thus isn't in child lists, so isn't taken
287 // into account for selector matching the relevant selectors here.
289 }
291 // Handle appends specially since they're common and we can know both the old
292 // and the new text exactly.
293 //
294 // TODO(emilio): This could be made much more general if :-moz-only-whitespace
295 // / :-moz-first-node and :-moz-last-node didn't exist. In that case we only
296 // need to know whether we went from empty to non-empty, and that's trivial to
297 // know, with CharacterDataChangeInfo...
299 // FIXME(emilio): This restyles unnecessarily if the text node is the only
300 // child of the parent element. Fortunately, it's uncommon to have such
301 // nodes and this not being an append.
302 //
303 // See the testcase in bug 1427625 for a test-case that triggers this.
306 }
322 }
326 // We used to be empty, restyle the parent.
329 }
330 }
334 }
335 }
337 // Restyling for a ContentInserted or CharacterDataChanged notification.
338 // This could be used for ContentRemoved as well if we got the
339 // notification before the removal happened (and sometimes
340 // CharacterDataChanged is more like a removal than an addition).
341 // The comments are written and variables are named in terms of it being
342 // a ContentInserted notification.
350 }
355 // The container cannot be a document.
359 // See whether we need to restyle the container due to :empty /
360 // :-moz-only-whitespace.
364 // FIXME(emilio): When coming from CharacterDataChanged this can restyle
365 // unnecessarily. Also can restyle unnecessarily if aChild is not
366 // significant anyway, though that's more unlikely.
369 }
370 }
379 }
380 // Restyling the container is the most we can do here, so we're done.
382 }
385 // Restyle all later siblings.
387 }
391 }
392 }
399 // Computed style data isn't useful for detached nodes, and we'll need to
400 // recompute it anyway if we ever insert the nodes back into a document.
403 // If this element is undisplayed or may have undisplayed descendants, we
404 // need to invalidate the cache, since there's the unlikely event of those
405 // elements getting destroyed and their addresses reused in a way that we
406 // look up the cache with their address for a different element before it's
407 // invalidated.
409 }
414 }
417 // This should be an assert, but this is called incorrectly in
418 // HTMLEditor::DeleteRefToAnonymousNode and the assertions were clogging
419 // up the logs. Make it an assert again when that's fixed.
422 }
424 // The container cannot be a document.
428 // see whether we need to restyle the container
432 // We don't know whether we're testing :empty or :-moz-only-whitespace,
433 // so be conservative and assume :-moz-only-whitespace (i.e., make
434 // IsSignificantChild less likely to be true, and thus make us more
435 // likely to restyle).
439 }
440 }
444 }
445 }
454 }
455 // Restyling the container is the most we can do here, so we're done.
457 }
460 // Restyle all later siblings.
462 }
465 // restyle the now-first element child if it was after aOldChild
471 // do NOT continue here; we might want to restyle this node
472 }
477 }
479 }
480 }
481 // restyle the now-last element child if it was before aOldChild
489 }
491 }
494 }
495 }
496 }
497 }
501 ElementState aStates) {
506 }
507 // If it's other generated content, ignore LOADING/etc state changes on it.
509 }
514 }
518 // Loading state doesn't affect <img>, see
519 // `nsImageFrame::ImageFrameTypeForElement`.
521 }
526 }
529 // <image> gets an SVGImageFrame all the time.
531 }
534 }
536 /**
537 * Calculates the change hint and the restyle hint for a given content state
538 * change.
539 */
541 ElementState aStateMask) {
544 // Any change to a content state that affects which frames we construct
545 // must lead to a frame reconstruct here if we already have a frame.
546 // Note that we never decide through non-CSS means to not create frames
547 // based on content states, so if we already don't have a frame we don't
548 // need to force a reframe -- if it's needed, the HasStateDependentStyle
549 // call will handle things.
553 }
555 StyleAppearance appearance =
566 }
567 }
568 }
570 }
573 // Exposing information to the page about whether the link is
574 // visited or not isn't really something we can worry about here.
575 // FIXME: We could probably do this a bit better.
577 }
579 // This changes the applicable text-transform in the editor root.
581 // This is the same change hint as tweaking text-transform.
583 }
586 }
588 #ifdef DEBUG
589 /* static */
591 nsCString result;
634 nsChangeHint_AllReflowHints) {
642 }
647 }
650 }
651 }
655 }
660 }
661 }
663 }
664 #endif
666 /**
667 * Frame construction helpers follow.
668 */
669 #ifdef DEBUG
671 #endif
673 /**
674 * Sync views on the frame and all of it's descendants (following placeholders).
675 * The change hint should be some combination of nsChangeHint_RepaintFrame,
676 * nsChangeHint_UpdateOpacityLayer and nsChangeHint_SchedulePaint, nothing else.
677 */
682 /**
683 * This helper function is used to find the correct SVG frame to target when we
684 * encounter nsChangeHint_ChildrenOnlyTransform; needed since sometimes we end
685 * up handling that hint while processing hints for one of the SVG frame's
686 * ancestor frames.
687 *
688 * The reason that we sometimes end up trying to process the hint for an
689 * ancestor of the SVG frame that the hint is intended for is due to the way we
690 * process restyle events. ApplyRenderingChangeToTree adjusts the frame from
691 * the restyled element's principle frame to one of its ancestor frames based
692 * on what nsCSSRendering::FindBackground returns, since the background style
693 * may have been propagated up to an ancestor frame. Processing hints using an
694 * ancestor frame is fine in general, but nsChangeHint_ChildrenOnlyTransform is
695 * a special case since it is intended to update a specific frame.
696 */
699 // This happens if the root-<svg> is fixed positioned, in which case we
700 // can't use aFrame->GetContent() to find the primary frame, since
701 // GetContent() returns nullptr for ViewportFrame.
703 }
704 // For an nsHTMLScrollFrame, this will get the SVG frame that has the
705 // children-only transforms:
711 }
715 }
717 // This function tries to optimize a position style change by either
718 // moving aFrame or ignoring the style change when it's safe to do so.
719 // It returns true when that succeeds, otherwise it posts a reflow request
720 // and returns false.
722 // It's pointless to move around frames that have never been reflowed or
723 // are dirty (i.e. they will be reflowed).
726 }
728 // Don't process position changes on table frames, since we already handle
729 // the dynamic position change on the table wrapper frame, and the
730 // reflow-based fallback code path also ignores positions on inner table
731 // frames.
734 }
737 // Changes to the offsets of a non-positioned element can safely be ignored.
740 }
742 // Don't process position changes on frames which have views or the ones which
743 // have a view somewhere in their descendants, because the corresponding view
744 // needs to be repositioned properly as well.
748 }
751 // If the frame has an intrinsic block-size, we resolve its 'auto' margins
752 // after doing layout, since we need to know the frame's block size. See
753 // nsAbsoluteContainingBlock::ResolveAutoMarginsAfterLayout().
754 //
755 // Since the size of the frame doesn't change, we could modify the below
756 // computation to compute the margin correctly without doing a full reflow,
757 // however we decided to try doing a full reflow for now.
763 }
764 }
765 // Flexbox and Grid layout supports CSS Align and the optimizations below
766 // don't support that yet.
770 }
771 }
773 // If we need to reposition any descendant that depends on our static
774 // position, then we also can't take the optimized path.
775 //
776 // TODO(emilio): It may be worth trying to find them and try to call
777 // RecomputePosition on them too instead of disabling the optimization...
780 }
788 }
790 // We need to trigger re-snapping to this content if we snapped to the
791 // content on the last scroll operation.
793 };
795 // For relative positioning, we can simply update the frame rect
798 // A grid item's CB is its grid area, not the parent frame content area
799 // as is assumed below.
801 }
802 // Move the frame
804 // Update sticky positioning for an entire element at once, starting with
805 // the first continuation or ib-split sibling.
806 // It's rare that the frame we already have isn't already the first
807 // continuation or ib-split sibling, but it can happen when styles differ
808 // across continuations such as ::first-line or ::first-letter, and in
809 // those cases we will generally (but maybe not always) do the work twice.
816 firstContinuation);
819 }
832 // ReflowInput::ApplyRelativePositioning would work here, but
833 // since we've already checked mPosition and aren't changing the frame's
834 // normal position, go ahead and add the offsets directly.
835 // First, we need to ensure that the normal position is stored though.
840 }
843 }
844 }
848 }
850 // For the absolute positioning case, set up a fake HTML reflow input for
851 // the frame, and then get the offsets and size from it. If the frame's size
852 // doesn't need to change, we can simply update the frame position. Otherwise
853 // we fall back to a reflow.
857 // Construct a bogus parent reflow input so that there's a usable reflow input
858 // for the containing block.
866 parentSize);
870 // The bogus parent state here was created with no parent state of its own,
871 // and therefore it won't have an mCBReflowInput set up.
872 // But we may need one (for InitCBReflowInput in a child state), so let's
873 // try to create one here for the cases where it will be needed.
888 }
905 nsSize cbSize =
906 viewport
922 }
925 // The RecomputePosition hint is not used if any offset changed between auto
926 // and non-auto. If computedSize.height == NS_UNCONSTRAINEDSIZE then the new
927 // element height will be its intrinsic height, and since 'top' and 'bottom''s
928 // auto-ness hasn't changed, the old height must also be its intrinsic
929 // height, which we can assume hasn't changed (or reflow would have
930 // been triggered).
934 // If we're solving for 'left' or 'top', then compute it here, in order to
935 // match the reflow code path.
936 //
937 // TODO(emilio): It'd be nice if this did logical math instead, but it seems
938 // to me the math should work out on vertical writing modes as well. See Bug
939 // 1675861 for some hints.
945 left =
947 }
953 }
955 // Move the frame
962 }
964 // Fall back to a reflow
966 }
972 }
973 }
975 }
977 /**
978 * Return true if aFrame's subtree has placeholders for out-of-flow content
979 * that would be affected due to the change to
980 * `aPossiblyChangingContainingBlock` (and thus would need to get reframed).
981 *
982 * In particular, this function returns true if there are placeholders whose OOF
983 * frames may need to be reparented (via reframing) as a result of whatever
984 * change actually happened.
985 *
986 * The `aIs{Abs,Fixed}PosContainingBlock` params represent whether
987 * `aPossiblyChangingContainingBlock` is a containing block for abs pos / fixed
988 * pos stuff, respectively, for the _new_ style that the frame already has, not
989 * the old one.
990 */
994 // All fixed-pos containing blocks should also be abs-pos containing blocks.
1001 // If SVG text frames could appear here, they could confuse us since
1002 // they ignore their position style ... but they can't.
1005 // Top-layer frames don't change containing block based on direct
1006 // ancestors.
1011 aIsFixedPosContainingBlock ||
1014 // NOTE(emilio): aPossiblyChangingContainingBlock is guaranteed to be
1015 // a first continuation, see the assertion in the caller.
1018 // If we are becoming a containing block, we only need to reframe if
1019 // this oof's current containing block is an ancestor of the new
1020 // frame.
1025 }
1027 // If we are not a containing block anymore, we only need to reframe
1028 // if we are the current containing block of the oof frame.
1031 }
1032 }
1033 }
1034 }
1035 // NOTE: It's tempting to check f->IsAbsPosContainingBlock() or
1036 // f->IsFixedPosContainingBlock() here. However, that would only
1037 // be testing the *new* style of the frame, which might exclude
1038 // descendants that currently have this frame as an abs-pos
1039 // containing block. Taking the codepath where we don't reframe
1040 // could lead to an unsafe call to
1041 // cont->MarkAsNotAbsoluteContainingBlock() before we've reframed
1042 // the descendant and taken it off the absolute list.
1045 aIsFixedPosContainingBlock)) {
1047 }
1048 }
1049 }
1051 }
1053 // Returns the frame that would serve as the containing block for aFrame's
1054 // positioned descendants, if aFrame had styles to make it a CB for such
1055 // descendants. (Typically this is just aFrame itself, or its insertion frame).
1056 //
1057 // Returns nullptr if this frame can't be easily determined.
1060 // FIXME: This should be easily implementable.
1062 }
1066 }
1067 // Generally frames with a different insertion frame are hard to deal with,
1068 // but scrollframes are easy because the containing block is just the
1069 // insertion frame.
1072 }
1073 // Combobox frames are easy as well because they can't have positioned
1074 // children anyways.
1075 // Button and table cell frames are also easy because the containing block is
1076 // the frame itself.
1080 }
1082 }
1086 // NOTE: This looks at the new style.
1096 isAbsPosContainingBlock,
1097 isFixedContainingBlock)) {
1099 }
1100 }
1102 }
1105 nsChangeHint aChange) {
1111 // Invalidate and sync views on all descendant frames, following
1112 // placeholders. We don't need to update transforms in
1113 // SyncViewsAndInvalidateDescendants, because there can't be any
1114 // out-of-flows or popups that need to be transformed; all out-of-flow
1115 // descendants of the transformed element must also be descendants of the
1116 // transformed frame.
1119 nsChangeHint_UpdateOpacityLayer |
1120 nsChangeHint_SchedulePaint)));
1121 // This must be set to true if the rendering change needs to
1122 // invalidate content. If it's false, a composite-only paint
1123 // (empty transaction) will be scheduled.
1126 // if frame has view, will already be invalidated
1128 // Note that this whole block will be skipped when painting is suppressed
1129 // (due to our caller ApplyRendingChangeToTree() discarding the
1130 // nsChangeHint_RepaintFrame hint). If you add handling for any other
1131 // hints within this block, be sure that they too should be ignored when
1132 // painting is suppressed.
1138 // Need to update our overflow rects:
1140 }
1143 }
1145 // FIXME/bug 796697: we can get away with empty transactions for
1146 // opacity updates in many cases.
1151 // SVG effects paints the opacity without using
1152 // nsDisplayOpacity. We need to invalidate manually.
1154 }
1155 }
1158 // Note: All the transform-like properties should map to the same
1159 // layer activity index, so does the restyle count. Therefore, using
1160 // eCSSProperty_transform should be fine.
1163 }
1170 // Note: All the transform-like properties should map to the same
1171 // layer activity index, so does the restyle count. Therefore, using
1172 // eCSSProperty_transform should be fine.
1174 }
1175 }
1178 }
1182 }
1183 }
1186 nsChangeHint aChange) {
1192 nsChangeHint_UpdateOpacityLayer |
1193 nsChangeHint_SchedulePaint)),
1201 // only do frames that don't have placeholders
1203 // do the out-of-flow frame and its continuations
1211 }
1212 }
1213 }
1214 }
1215 }
1218 nsChangeHint aChange) {
1219 // We check StyleDisplay()->HasTransformStyle() in addition to checking
1220 // IsTransformed() since we can get here for some frames that don't support
1221 // CSS transforms, and table frames, which are their own odd-ball, since the
1222 // transform is handled by their wrapper, which _also_ gets a separate hint.
1229 // Don't allow synchronous rendering changes when painting is turned off.
1233 }
1234 }
1236 // Trigger rendering updates by damaging this frame and any
1237 // continuations of this frame.
1238 #ifdef DEBUG
1240 #endif
1242 // If the frame is the primary frame of either the body element or
1243 // the html element, we propagate the repaint change hint to the
1244 // viewport. This is necessary for background and scrollbar colors
1245 // propagation.
1253 }
1254 }
1255 }
1257 #ifdef DEBUG
1259 #endif
1260 }
1267 }
1271 }
1272 }
1273 }
1276 IntrinsicDirty dirtyType;
1285 NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
1291 // The frame's computed BSize is changing, and we have a box ancestor
1292 // whose cached intrinsic height may need to be updated.
1296 }
1300 }
1302 nsFrameState dirtyBits;
1310 }
1312 // If we're not going to clear any intrinsic sizes on the frames, and
1313 // there are no dirty bits to set, then there's nothing to do.
1316 ReflowRootHandling rootHandling;
1321 }
1325 rootHandling);
1328 }
1330 // Get the next sibling which might have a frame. This only considers siblings
1331 // that stylo post-traversal looks at, so only elements and text. In
1332 // particular, it ignores comments.
1338 }
1339 }
1342 }
1344 // If |aFrame| is dirty or has dirty children, then we can skip updating
1345 // overflows since that will happen when it's reflowed.
1348 NS_FRAME_HAS_DIRTY_CHILDREN);
1349 }
1357 }
1361 }
1367 // Only bother with this if we're the root or the body element, since:
1368 // (a) It'd be *expensive* to reframe these particular nodes. They're
1369 // at the root, so reframing would mean rebuilding the world.
1370 // (b) It's often *unnecessary* to reframe for "overflow" changes on
1371 // these particular nodes. In general, the only reason we reframe
1372 // for "overflow" changes is so we can construct (or destroy) a
1373 // scrollframe & scrollbars -- and the html/body nodes often don't
1374 // need their own scrollframe/scrollbars because they coopt the ones
1375 // on the viewport (which always exist). So depending on whether
1376 // that's happening, we can skip the reframe for these nodes.
1378 // If the restyled element provided/provides the scrollbar styles for
1379 // the viewport before and/or after this restyle, AND it's not coopting
1380 // that responsibility from some other element (which would need
1381 // reconstruction to make its own scrollframe now), THEN: we don't need
1382 // to reconstruct - we can just reflow, because no scrollframe is being
1383 // added/removed.
1390 }
1392 };
1396 // If we get here, the restyled element provided the scrollbar styles
1397 // for viewport before this restyle, OR it will provide them after.
1399 // If we get here, the restyled element is NOT replacing (or being
1400 // replaced by) some other element as the viewport's
1401 // scrollbar-styles provider. (If it were, we'd potentially need to
1402 // reframe to create a dedicated scrollframe for whichever element
1403 // is being booted from providing viewport scrollbar styles.)
1404 //
1405 // Under these conditions, we're OK to assume that this "overflow"
1406 // change only impacts the root viewport's scrollframe, which
1407 // already exists, so we can simply reflow instead of reframing.
1413 }
1416 // If we changed the override element, we need to reconstruct as the old
1417 // override element might start / stop being scrollable.
1419 }
1421 }
1422 }
1428 // Once we've created scrollbars for a frame, don't bother reconstructing
1429 // it just to remove them if we still need a scroll frame.
1432 }
1434 // input / textarea for the most part don't honor overflow themselves, the
1435 // editor root will deal with the change if needed.
1436 // However the textarea intrinsic size relies on GetDesiredScrollbarSizes(),
1437 // so we need to reflow the textarea itself, not just the inner control.
1441 // Something changed, but we don't have nor will have a scroll frame,
1442 // there's nothing to do here.
1444 }
1446 // Oh well, we couldn't optimize it out, just reconstruct frames for the
1447 // subtree.
1449 }
1455 }
1458 }
1463 // The frame has positioned children that need to be reparented, or it can't
1464 // easily be converted to/from being an abs-pos container correctly.
1467 }
1470 // The absolute container should be containingBlock.
1473 // Normally frame construction would set state bits as needed,
1474 // but we're not going to reconstruct the frame so we need to set
1475 // them. It's because we need to set this state on each affected frame
1476 // that we can't coalesce nsChangeHint_UpdateContainingBlock hints up
1477 // to ancestors (i.e. it can't be an change hint that is handled for
1478 // descendants).
1483 }
1486 // If |cont| still has absolutely positioned children,
1487 // we can't call MarkAsNotAbsoluteContainingBlock. This
1488 // will remove a frame list that still has children in
1489 // it that we need to keep track of.
1490 // The optimization of removing it isn't particularly
1491 // important, although it does mean we skip some tests.
1495 }
1496 }
1497 }
1498 }
1504 // See bug 1378219 comment 9:
1505 // Recursive calls here are a bit worrying, but apparently do happen in the
1506 // wild (although not currently in any of our automated tests). Try to get a
1507 // stack from Nightly/Dev channel to figure out what's going on and whether
1508 // it's OK.
1513 }
1515 // If mDestroyedFrames is null, we want to create a new hashtable here
1516 // and destroy it on exit; but if it is already non-null (because we're in
1517 // a recursive call), we will continue to use the existing table to
1518 // accumulate destroyed frames, and NOT clear mDestroyedFrames on exit.
1519 // We use a MaybeClearDestroyedFrames helper to conditionally reset the
1520 // mDestroyedFrames pointer when this method returns.
1531 {}
1535 }
1536 }
1537 };
1542 }
1552 // Collect and coalesce adjacent siblings for lazy frame construction.
1553 // Eventually it would be even better to make RecreateFramesForContent
1554 // accept a range and coalesce all adjacent reconstructs (bug 1344139).
1564 }
1575 }
1576 }
1580 }
1583 }
1595 // skip any frame that has been destroyed due to a ripple effect
1598 }
1601 // XXXbz this is due to image maps messing with the primary frame of
1602 // <area>s. See bug 135040. Remove this block once that's fixed.
1606 }
1607 }
1613 // If we ever start passing true here, be careful of restyles
1614 // that involve a reframe and animations. In particular, if the
1615 // restyle we're processing here is an animation restyle, but
1616 // the style resolution we will do for the frame construction
1617 // happens async when we're not in an animation restyle already,
1618 // problems could arise.
1619 // We could also have problems with triggering of CSS transitions
1620 // on elements whose frames are reconstructed, since we depend on
1621 // the reconstruction happening synchronously.
1625 }
1633 }
1634 // Don't remove NS_FRAME_MAY_BE_TRANSFORMED since it may still be
1635 // transformed by other means. It's OK to have the bit even if it's
1636 // not needed.
1637 }
1638 }
1641 // frame does not maintain overflow rects, so avoid calling
1642 // FinishAndStoreOverflow on it:
1643 hint &=
1645 nsChangeHint_UpdatePostTransformOverflow |
1646 nsChangeHint_UpdateParentOverflow |
1647 nsChangeHint_UpdateSubtreeOverflow);
1648 }
1651 // Frame can not be transformed, and thus a change in transform will
1652 // have no effect and we should not use either
1653 // nsChangeHint_UpdatePostTransformOverflow or
1654 // nsChangeHint_UpdateTransformLayerhint.
1656 nsChangeHint_UpdateTransformLayer);
1657 }
1660 // When dropping a running transform animation we will first add an
1661 // nsChangeHint_UpdateTransformLayer hint as part of the animation-only
1662 // restyle. During the subsequent regular restyle, if the animation was
1663 // the only reason the element had any transform applied, we will add
1664 // nsChangeHint_AddOrRemoveTransform as part of the regular restyle.
1665 //
1666 // With the Gecko backend, these two change hints are processed
1667 // after each restyle but when using the Servo backend they accumulate
1668 // and are processed together after we have already removed the
1669 // transform as part of the regular restyle. Since we don't actually
1670 // need the nsChangeHint_UpdateTransformLayer hint if we already have
1671 // a nsChangeHint_AddOrRemoveTransform hint, and since we
1672 // will fail an assertion in ApplyRenderingChangeToTree if we try
1673 // specify nsChangeHint_UpdateTransformLayer but don't have any
1674 // transform style, we just drop the unneeded hint here.
1676 }
1681 }
1688 }
1692 }
1694 // Here we need to propagate repaint frame change hint instead of update
1695 // opacity layer change hint when we do opacity optimization for SVG.
1696 // We can't do it in nsStyleEffects::CalcDifference() just like we do
1697 // for the optimization for 0.99 over opacity values since we have no way
1698 // to call SVGUtils::CanOptimizeOpacity() there.
1703 }
1708 "should only return UpdateUsesOpacity hint "
1710 // When an internal table part (including cells) changes between
1711 // having opacity 1 and non-1, it changes whether its
1712 // backgrounds (and those of table parts inside of it) are
1713 // painted as part of the table's nsDisplayTableBorderBackground
1714 // display item, or part of its own display item. That requires
1715 // invalidation, so change UpdateOpacityLayer to RepaintFrame.
1718 }
1720 // Opacity disables preserve-3d, so if we toggle it, then we also need
1721 // to update the overflow areas of all potentially affected frames.
1726 }
1729 // For most frame types, DLBI can detect background position changes,
1730 // so we only need to schedule a paint.
1734 // Table parts and MathML frames don't build display items for their
1735 // backgrounds, so DLBI can't detect background-position changes for
1736 // these frames. Repaint the whole frame.
1738 }
1739 }
1743 nsChangeHint_UpdateTransformLayer |
1746 }
1748 // It is possible for this to fall back to a reflow
1751 nsChangeHint_ReflowChangesSizeOrPosition);
1753 }
1754 }
1760 nsChangeHint_UpdatePostTransformOverflow |
1761 nsChangeHint_UpdateParentOverflow |
1762 nsChangeHint_UpdateSubtreeOverflow))) {
1767 }
1768 // The work we just did in AddSubtreeToOverflowTracker
1769 // subsumes some of the other hints:
1771 nsChangeHint_UpdatePostTransformOverflow);
1772 }
1774 // We need to update overflows. The correct frame(s) to update depends
1775 // on whether the ChangeHint came from an outer or an inner svg.
1778 "SVG frames should not have continuations "
1782 "SVG frames should not have continuations "
1785 // The children only transform of an outer svg frame is applied to
1786 // the outer svg's anonymous child frame (instead of to the
1787 // anonymous child's children).
1792 }
1794 // The children only transform is applied to the child frames of an
1795 // inner svg frame, so update the child overflows.
1803 }
1806 "SVG frames should not have continuations "
1811 }
1812 }
1813 }
1816 nsChangeHint_UpdatePostTransformOverflow)) {
1818 // If we have both nsChangeHint_UpdateOverflow and
1819 // nsChangeHint_UpdatePostTransformOverflow,
1820 // CHILDREN_CHANGED is selected as it is
1821 // strictly stronger.
1826 }
1828 cont =
1831 }
1832 }
1833 // UpdateParentOverflow hints need to be processed in addition
1834 // to the above, since if the processing of the above hints
1835 // yields no change, the update will not propagate to the
1836 // parent.
1841 cont =
1845 }
1846 }
1847 }
1848 }
1852 }
1855 }
1858 }
1859 }
1863 }
1865 /* static */
1869 }
1872 // We update the animation generation at start of each call to
1873 // ProcessPendingRestyles so we should ignore any subsequent (redundant)
1874 // calls that occur while we are still processing restyles.
1877 }
1878 }
1880 /* static */
1888 }
1899 // If we have a transform layer but don't have any transform style, we
1900 // probably just removed the transform but haven't destroyed the layer
1901 // yet. In this case we will typically add the appropriate change hint
1902 // (nsChangeHint_UpdateContainingBlock) when we compare styles so in
1903 // theory we could skip adding any change hint here.
1904 //
1905 // However, sometimes when we compare styles we'll get no change. For
1906 // example, if the transform style was 'none' when we sent the transform
1907 // animation to the compositor and the current transform style is now
1908 // 'none' we'll think nothing changed but actually we still need to
1909 // trigger an update to clear whatever style the transform animation set
1910 // on the compositor. To handle this case we simply set all the change
1911 // hints relevant to removing transform style (since we don't know exactly
1912 // what changes happened while the animation was running on the
1913 // compositor).
1914 //
1915 // Note that we *don't* add nsChangeHint_UpdateTransformLayer since if we
1916 // did, ApplyRenderingChangeToTree would complain that we're updating a
1917 // transform layer without a transform.
1920 // Add all the hints for a removing a transform if they are not already
1921 // set for this frame.
1923 aHintForThisFrame))) {
1925 }
1927 }
1929 }
1931 // We consider it's the first paint for the frame if we have an animation
1932 // for the property but have no layer, for the case of WebRender, no
1933 // corresponding animation info.
1934 // Note that in case of animations which has properties preventing running
1935 // on the compositor, e.g., width or height, corresponding layer is not
1936 // created at all, but even in such cases, we normally set valid change
1937 // hint for such animations in each tick, i.e. restyles in each tick. As
1938 // a result, we usually do restyles for such animations in every tick on
1939 // the main-thread. The only animations which will be affected by this
1940 // explicit change hint are animations that have opacity/transform but did
1941 // not have those properies just before. e.g, setting transform by
1942 // setKeyframes or changing target element from other target which prevents
1943 // running on the compositor, etc.
1945 nsChangeHint hintForDisplayItem =
1947 // We don't need to apply the corresponding change hint if we already have
1948 // it.
1951 }
1956 }
1961 }
1962 }
1964 };
1968 maybeApplyChangeHint);
1971 // We apply the hint to the primary frame, not the style frame. Transform
1972 // and opacity hints apply to the table wrapper box, not the table box.
1974 }
1975 }
1984 }
1992 }
2004 }
2008 }
2012 }
2016 }
2017 }
2023 // All other animations should keep running but not running on the
2024 // *compositor* at this point.
2028 }
2029 }
2030 }
2031 }
2033 #ifdef DEBUG
2036 }
2042 }
2045 }
2052 }
2057 }
2060 }
2063 // A ::first-line always ends up here via its block, which is therefore the
2064 // right expected owner. That block can be an
2065 // anonymous box. For example, we could have a ::first-line on a columnated
2066 // block; the blockframe is the column-content anonymous box in that case.
2067 // So we don't want to end up in the code below, which steps out of anon
2068 // boxes. Just return the parent of the line frame, which is the block.
2070 }
2073 // Ditto for ::first-letter. A first-letter always arrives here via its
2074 // direct parent, except when it's parented to a ::first-line.
2077 }
2079 }
2082 // Things never have ::first-letter as their expected parent. Go
2083 // on up to the ::first-letter's parent.
2085 }
2089 // We've handled already anon boxes, so now we're looking at
2090 // a frame of a DOM element or pseudo. Hop through anon and line-boxes
2091 // generated by our DOM parent, and go find the owner frame for it.
2097 // Handle :-moz-table and :-moz-inline-table.
2100 // We get the in-flow parent here so that we can handle the OOF anonymous
2101 // boxed to get the correct parent.
2103 }
2105 }
2108 }
2110 // FIXME(emilio, bug 1633685): We should ideally figure out how to properly
2111 // restyle replicated fixed pos frames... We seem to assume everywhere that they
2112 // can't get restyled at the moment...
2116 }
2123 }
2124 }
2127 }
2133 // We allow aParent.mOwner to be null, for cases when we're not starting at
2134 // the root of the tree. We also allow aParent.mOwner to be somewhere up our
2135 // expected owner chain not our immediate owner, which allows us creating long
2136 // chains of ServoRestyleStates in some cases where it's just not worth it.
2141 "Should only have expected owner weirdness when anon boxes "
2148 }
2149 }
2151 }
2152 }
2153 }
2160 }
2166 }
2167 #endif
2171 "All our wrappers are anon boxes, and why would we restyle "
2174 "All our wrappers are anon boxes, and why would we restyle "
2182 // Make sure we only add first continuations.
2186 // Already queued up, nothing to do.
2188 }
2190 // Make sure to queue up parents before children. But don't queue up
2191 // ancestors of non-anonymous boxes here; those are handled when we traverse
2192 // their non-anonymous kids.
2195 }
2197 // If the append fails, we'll fail to restyle properly, but that's probably
2198 // better than crashing.
2201 }
2202 }
2208 }
2211 }
2215 // The frame at index aIndex is something we should restyle ourselves, but
2216 // following frames may need separate ServoRestyleStates to restyle.
2222 // Where is cur supposed to inherit from? From its parent frame, except in
2223 // the case when cur is a table, in which case it should be its grandparent.
2224 // Also, not in the case when the resulting frame would be a first-line; in
2225 // that case we should be inheriting from the block, and the first-line will
2226 // do its fixup later if needed.
2227 //
2228 // Note that after we do all that fixup the parent we get might still not be
2229 // aParent; for example aParent could be a scrollframe, in which case we
2230 // should inherit from the scrollcontent frame. Or the parent might be some
2231 // continuation of aParent.
2232 //
2233 // Try to assert as much as we can about the parent we actually end up using
2234 // without triggering bogus asserts in all those various edge cases.
2239 }
2242 }
2247 // Now "this" is a ServoRestyleState for aParent, so if parent is not a next
2248 // continuation (possibly across ib splits) of aParent we need a new
2249 // ServoRestyleState for the kid.
2256 }
2260 // This frame may already have been restyled. Even if it has, we can't just
2261 // return, because the next frame may be a kid of it that does need restyling.
2265 }
2269 // Note: no overflow possible here, since aIndex < length.
2274 // It might be nice if we could do better than nsChangeHint_Empty. On
2275 // the other hand, presumably our mChangesHandled already has the bits
2276 // we really want here so in practice it doesn't matter.
2280 numProcessed +=
2282 }
2283 }
2286 }
2289 // We want to get the anon box parent for aChild. where aChild has
2290 // ParentIsWrapperAnonBox().
2291 //
2292 // For the most part this is pretty straightforward, but there are two
2293 // wrinkles. First, if aChild is a table, then we really want the parent of
2294 // its table wrapper.
2298 }
2301 // Now if parent is a cell-content frame, we actually want the cellframe.
2305 // Must be a caption. In that case we want the table here.
2308 }
2310 }
2313 RestyleHint aRestyleHint,
2314 nsChangeHint aMinChangeHint) {
2320 }
2322 // We allow posting restyles from within change hint handling, but not from
2323 // within the restyle algorithm itself.
2327 // FIXME(emilio): we should assert against this instead.
2329 }
2331 // Assuming the restyle hints will invalidate cached style for
2332 // getComputedStyle, since we don't know if any of the restyling that we do
2333 // would affect undisplayed elements.
2337 }
2340 }
2342 // Processing change hints sometimes causes new change hints to be generated,
2343 // and very occasionally, additional restyle hints. We collect the change
2344 // hints manually to avoid re-traversing the DOM to find them.
2348 }
2352 }
2353 }
2356 PseudoStyleType aPseudoType,
2357 RestyleHint aRestyleHint) {
2362 // FIXME: Bug 1371107: When reframing happens,
2363 // EffectCompositor::mElementsToRestyle still has unbound old pseudo
2364 // element. We should drop it.
2366 }
2371 }
2374 RestyleHint aRestyleHint) {
2375 // NOTE(emilio): The semantics of these methods are quite funny, in the sense
2376 // that we're not supposed to need to rebuild the actual stylist data.
2377 //
2378 // That's handled as part of the MediumFeaturesChanged stuff, if needed.
2379 //
2380 // Clear the cached style data only if we are guaranteed to process the whole
2381 // DOM tree again.
2382 //
2383 // FIXME(emilio): Decouple this, probably. This probably just wants to reset
2384 // the "uses viewport units / uses rem" bits, and _maybe_ clear cached anon
2385 // box styles and such... But it doesn't really always need to clear the
2386 // initial style of the document and similar...
2389 }
2394 }
2396 // TODO(emilio, bz): Extensions can add/remove stylesheets that can affect
2397 // non-inheriting anon boxes. It's not clear if we want to support that, but
2398 // if we do, we need to re-selector-match them here.
2399 }
2401 /* static */
2403 IncludeRoot aIncludeRoot) {
2409 }
2410 }
2411 }
2416 NODE_NEEDS_FRAME));
2418 }
2419 }
2421 /* static */
2428 }
2429 }
2430 }
2435 }
2437 /**
2438 * This struct takes care of encapsulating some common state that text nodes may
2439 * need to track during the post-traversal.
2440 *
2441 * This is currently used to properly compute change hints when the parent
2442 * element of this node is a display: contents node, and also to avoid computing
2443 * the style for text children more than once per element.
2444 */
2464 }
2467 }
2476 }
2481 // We rely on the fact that all the text children for the same element share
2482 // style to avoid recomputing style differences for all of them.
2483 //
2484 // TODO(emilio): The above may not be true for ::first-{line,letter}, but
2485 // we'll cross that bridge when we support those in stylo.
2492 }
2496 mComputedHint);
2497 }
2498 }
2503 mLazilyResolvedParentContext =
2506 }
2508 }
2517 nsChangeHint mComputedHint;
2518 };
2525 }
2527 // Elements in the top layer are guaranteed to have absolute or fixed
2528 // position per https://fullscreen.spec.whatwg.org/#new-stacking-layer.
2535 }
2548 // NOTE(emilio): We can't use the changes handled for the owner of the
2549 // backdrop frame, since it's out of flow, and parented to the viewport or
2550 // canvas frame (depending on the `position` value).
2556 anchorsToSuppress);
2559 }
2568 }
2570 // We need to find the block the first-letter is associated with so we can
2571 // find the right element for the first-letter's style resolution. Might as
2572 // well just delegate the whole thing to that block.
2576 }
2580 }
2595 nsChangeHint childHint =
2601 }
2605 // If we generate a reconstruct here, remove any non-reconstruct hints we
2606 // may have already generated for this content.
2608 }
2610 childHint);
2611 }
2614 }
2621 // FIXME(emilio): Consider adding a bit or something to avoid the initial
2622 // virtual call?
2626 }
2627 }
2635 }
2639 }
2643 // Whether parent was restyled.
2645 // Skip sending accessibility notifications for all descendants.
2647 // Always send accessibility notifications if the element is shown.
2648 // The SkipA11yNotifications flag above overrides this flag.
2650 };
2654 // Send proper accessibility notifications and return post traversal
2655 // flags for kids.
2659 ServoPostTraversalFlags aFlags) {
2665 #ifdef ACCESSIBILITY
2668 // If we don't have accessibility service, accessibility is not
2669 // enabled. Just skip everything.
2671 }
2680 }
2681 }
2684 // Propagate the skipping flag to descendants.
2686 }
2693 // Propagate the sending-if-shown flag to descendants.
2695 }
2696 // We have asked accessibility service to remove the whole subtree
2697 // of element which becomes invisible from the accessible tree, but
2698 // this element is visible, so we need to add it back.
2701 // If we shouldn't skip in any case, we need to check whether our
2702 // own visibility has changed.
2706 }
2713 // We are adding the subtree. Accessibility service would handle
2714 // descendants, so we should just skip them from notifying.
2716 }
2717 // Remove the subtree of this invisible element, and ask any shown
2718 // descendant to add themselves back.
2721 }
2722 #endif
2725 }
2729 ServoPostTraversalFlags aFlags) {
2736 // NOTE(emilio): This is needed because for table frames the bit is set on the
2737 // table wrapper (which is the primary frame), not on the table itself.
2741 // We need this because any column-spanner's parent frame is not its DOM
2742 // parent's primary frame. We need some special check similar to out-of-flow
2743 // frames.
2747 // Grab the change hint from Servo.
2749 nsChangeHint changeHint =
2755 // We should really fix the weird primary frame mapping for image maps
2756 // (bug 135040)...
2760 }
2762 // Handle lazy frame construction by posting a reconstruct for any lazily-
2763 // constructed roots.
2767 }
2777 // Do not subsume change hints for the column-spanner.
2781 }
2782 }
2784 // If the parent wasn't restyled, the styles of our anon box parents won't
2785 // change either.
2790 }
2792 // If we don't have a ::marker pseudo-element, but need it, then
2793 // reconstruct the frame. (The opposite situation implies 'display'
2794 // changes so doesn't need to be handled explicitly here.)
2803 }
2804 }
2805 }
2807 // Although we shouldn't generate non-ReconstructFrame hints for elements with
2808 // no frames, we can still get them here if they were explicitly posted by
2809 // PostRestyleEvent, such as a RepaintFrame hint when a :link changes to be
2810 // :visited. Skip processing these hints if there is no frame.
2812 changeHint) {
2814 }
2816 // If our change hint is reconstruct, we delegate to the frame constructor,
2817 // which consumes the new style and expects the old style to be on the frame.
2818 //
2819 // XXXbholley: We should teach the frame constructor how to clear the dirty
2820 // descendants bit to avoid the traversal here.
2825 styleFrame &&
2828 // https://drafts.csswg.org/css-scroll-anchoring/#suppression-triggers
2829 //
2830 // We need to do the position check here rather than in
2831 // DidSetComputedStyle because changing position reframes.
2832 //
2833 // We suppress adjustments whenever we change from being display: none to
2834 // be an abspos.
2835 //
2836 // Similarly, for other changes from abspos to non-abspos styles.
2837 //
2838 // TODO(emilio): I _think_ chrome won't suppress adjustments whenever
2839 // `display` changes. But that causes some infinite loops in cases like
2840 // bug 1568778.
2843 }
2844 }
2847 }
2849 // TODO(emilio): We could avoid some refcount traffic here, specially in the
2850 // ComputedStyle case, which uses atomic refcounting.
2851 //
2852 // Hold the ComputedStyle alive, because it could become a dangling pointer
2853 // during the replacement. In practice it's not a huge deal, but better not
2854 // playing with dangling pointers if not needed.
2855 //
2856 // NOTE(emilio): We could keep around the old computed style for display:
2857 // contents elements too, but we don't really need it right now.
2862 "display: contents node has a frame, yet we didn't reframe it"
2868 }
2876 }
2878 // We can't really assume as used changes from display: contents elements (or
2879 // other elements without frames).
2886 ServoPostTraversalFlags childrenFlags =
2893 // We want to walk all the continuations here, even the ones with different
2894 // styles. In practice, the only reason we get continuations with different
2895 // styles here is ::first-line (::first-letter never affects element
2896 // styles). But in that case, newStyle is the right context for the
2897 // _later_ continuations anyway (the ones not affected by ::first-line), not
2898 // the earlier ones, so there is no point stopping right at the point when
2899 // we'd actually be setting the right ComputedStyle.
2900 //
2901 // This does mean that we may be setting the wrong ComputedStyle on our
2902 // initial continuations; ::first-line fixes that up after the fact.
2906 }
2910 }
2913 // This is the root. Update styles on the viewport as needed.
2917 // NB: The root restyle state, not the one for our children!
2919 }
2920 }
2922 // Some changes to animations don't affect the computed style and yet still
2923 // require the layer to be updated. For example, pausing an animation via
2924 // the Web Animations API won't affect an element's style but still
2925 // requires to update the animation on the layer.
2926 //
2927 // We can sometimes reach this when the animated style is being removed.
2928 // Since AddLayerChangesForAnimation checks if |styleFrame| has a transform
2929 // style or not, we need to call it *after* setting |newStyle| to
2930 // |styleFrame| to ensure the animated transform has been removed first.
2937 }
2948 childrenRestyleState);
2956 }
2957 }
2958 }
2960 // We want to update frame pseudo-element styles after we've traversed our
2961 // kids, because some of those updates (::first-line/::first-letter) need to
2962 // modify the styles of the kids, and the child traversal above would just
2963 // clobber those modifications.
2966 // Make sure to update anon boxes and pseudo bits after updating text,
2967 // otherwise ProcessPostTraversalForText could clobber first-letter
2968 // styles, for example.
2970 }
2971 // Process anon box wrapper frames before ::first-line bits, but _after_
2972 // owned anon boxes, since the children wrapper anon boxes could be
2973 // inheriting from our own owned anon boxes.
2979 // Even if we were not restyled, if we're a block with a first-line and
2980 // one of our descendant elements which is on the first line was restyled,
2981 // we need to update the styles of things on the first line, because
2982 // they're wrong now.
2983 //
2984 // FIXME(bz) Could we do better here? For example, could we keep track of
2985 // frames that are "block with a ::first-line so we could avoid
2986 // IsFrameOfType() and digging about for the first-line frame if not?
2987 // Could we keep track of whether the element children we actually restyle
2988 // are affected by first-line? Something else? Bug 1385443 tracks making
2989 // this better.
2995 }
2996 }
2997 }
2998 }
3002 }
3007 // Handle lazy frame construction.
3012 }
3014 // Handle restyle.
3018 }
3020 // If the parent wasn't restyled, the styles of our anon box parents won't
3021 // change either.
3026 }
3031 // We want to walk all the continuations here, even the ones with different
3032 // styles. In practice, the only reasons we get continuations with different
3033 // styles are ::first-line and ::first-letter. But in those cases,
3034 // newStyle is the right context for the _later_ continuations anyway (the
3035 // ones not affected by ::first-line/::first-letter), not the earlier ones,
3036 // so there is no point stopping right at the point when we'd actually be
3037 // setting the right ComputedStyle.
3038 //
3039 // This does mean that we may be setting the wrong ComputedStyle on our
3040 // initial continuations; ::first-line/::first-letter fix that up after the
3041 // fact.
3044 }
3047 }
3053 }
3054 }
3059 // NOTE(emilio): We can handle snapshots from a one-off restyle of those that
3060 // we do to restyle stuff for reconstruction, for example.
3061 //
3062 // It seems to be the case that we always flush in between that happens and
3063 // the next attribute change, so we can assert that we haven't handled the
3064 // snapshot here yet. If this assertion didn't hold, we'd need to unset that
3065 // flag from here too.
3066 //
3067 // Can't wait to make ProcessPendingRestyles the only entry-point for styling,
3068 // so this becomes much easier to reason about. Today is not that day though.
3076 // Now that we have a snapshot, make sure a restyle is triggered.
3079 }
3086 // FIXME(emilio): In the "flush animations" case, ideally, we should only
3087 // recascade animation styles running on the compositor, so we shouldn't care
3088 // about other styles, or new rules that apply to the page...
3089 //
3090 // However, that's not true as of right now, see bug 1388031 and bug 1388692.
3098 // PresShell::FlushPendingNotifications doesn't early-return in the case
3099 // where the PresShell hasn't yet been initialized (and therefore we haven't
3100 // yet done the initial style traversal of the DOM tree). We should arguably
3101 // fix up the callers and assert against this case, but we just detect and
3102 // handle it for now.
3104 }
3106 // It'd be bad!
3109 // Create a AnimationsWithDestroyedFrame during restyling process to
3110 // stop animations and transitions on elements that have no frame at the end
3111 // of the restyling process.
3117 // Ensure the refresh driver is active during traversal to avoid mutating
3118 // mActiveTimer and mMostRecentRefresh time.
3122 // This might post new restyles, so need to do it here. Don't do it if we're
3123 // already going to restyle tho, so that we don't potentially reflow with
3124 // dirty styling.
3127 }
3129 // Perform the Servo traversal, and the post-traversal if required. We do this
3130 // in a loop because certain rare paths in the frame constructor can trigger
3131 // additional style invalidations.
3132 //
3133 // FIXME(emilio): Confirm whether that's still true now that XBL is gone.
3137 }
3141 }
3146 // Select scroll anchors for frames that have been scrolled. Do this
3147 // before processing restyled frames so that anchor nodes are correctly
3148 // marked when directly moving frames with RecomputePosition.
3151 nsStyleChangeList currentChanges;
3154 // Recreate styles , and queue up change hints (which also handle lazy frame
3155 // construction).
3158 {
3164 anchorsToSuppress);
3167 }
3169 // We want to suppress adjustments the current (before-change) scroll
3170 // anchor container now, and save a reference to the content node so that
3171 // we can suppress them in the after-change scroll anchor .
3176 }
3177 }
3178 }
3179 }
3184 // Process the change hints.
3185 //
3186 // Unfortunately, the frame constructor can generate new change hints while
3187 // processing existing ones. We redirect those into a secondary queue and
3188 // iterate until there's nothing left.
3189 {
3192 ReentrantChangeList newChanges;
3200 // SVG Elements post change hints without ensuring that the primary
3201 // frame will be there after that (see bug 1366142).
3202 //
3203 // Just ignore those, since we can't really process them.
3205 }
3208 }
3210 }
3212 }
3214 // Suppress adjustments in the after-change scroll anchors if needed, now
3215 // that we're done reframing everything.
3220 }
3221 }
3222 }
3225 // Maybe no styles changed when:
3226 //
3227 // * Only explicit change hints were posted in the first place.
3228 // * When an attribute or state change in the content happens not to need
3229 // a restyle after all.
3230 //
3231 // In any case, we don't need to increment the restyle generation in that
3232 // case.
3234 }
3239 }
3250 // Now that everything has settled, see if we have enough free rule nodes in
3251 // the tree to warrant sweeping them.
3254 // Note: We are in the scope of |animationsWithDestroyedFrame|, so
3255 // |mAnimationsWithDestroyedFrame| is still valid.
3258 }
3260 #ifdef DEBUG
3268 }
3269 }
3270 #endif
3274 #ifdef DEBUG
3277 }
3278 #endif
3281 }
3286 }
3288 // Servo data for the element might have been dropped. (e.g. by removing
3289 // from its document)
3292 }
3293 }
3295 }
3301 }
3304 }
3307 ElementState aChangedBits) {
3308 #ifdef EARLY_BETA_OR_EARLIER
3313 }
3314 #endif
3319 // When visited links are disabled, they cannot influence style for obvious
3320 // reasons.
3321 //
3322 // When layout.css.always-repaint-on-unvisited is true, we'll restyle when the
3323 // relevant visited query finishes, regardless of the style (see
3324 // Link::VisitedQueryFinished). So there's no need to do anything as a result
3325 // of this state change just yet.
3326 //
3327 // Note that this check checks for _both_ bits: This is only true when visited
3328 // changes to unvisited or vice-versa, but not when we start or stop being a
3329 // link itself.
3336 }
3337 }
3338 }
3342 }
3344 // Don't bother taking a snapshot if no rules depend on these state bits.
3345 //
3346 // We always take a snapshot for the LTR/RTL event states, since Servo doesn't
3347 // track those bits in the same way, and we know that :dir() rules are always
3348 // present in UA style sheets.
3352 }
3354 // Assuming we need to invalidate cached style in getComputedStyle for
3355 // undisplayed elements, since we don't know if it is needed.
3360 }
3365 }
3369 // We must record some state for :-moz-browser-frame,
3370 // :-moz-table-border-nonzero, and :-moz-select-list-box.
3373 }
3377 }
3381 }
3384 }
3393 // If the attribute influences one of the pseudo-classes that are backed by
3394 // attributes, we just record it.
3397 }
3399 // We assume that id and class attributes are used in class/id selectors, and
3400 // thus record them.
3401 //
3402 // TODO(emilio): We keep a filter of the ids in use somewhere in the StyleSet,
3403 // presumably we could try to filter the old and new id, but it's not clear
3404 // it's worth it.
3408 }
3410 // We always record lang="", even though we force a subtree restyle when it
3411 // changes, since it can change how its siblings match :lang(..) due to
3412 // selectors like :lang(..) + div.
3415 }
3417 // Otherwise, just record the attribute change if a selector in the page may
3418 // reference it from an attribute selector.
3420 }
3426 }
3431 }
3442 }
3444 // We cannot tell if the attribute change will affect the styles of
3445 // undisplayed elements, because we don't actually restyle those elements
3446 // during the restyle traversal. So just assume that the attribute change can
3447 // cause the style to change.
3452 }
3454 // Some other random attribute changes may also affect the transitions,
3455 // so we also set this true here.
3463 }
3464 }
3466 // For some attribute changes we must restyle the whole subtree:
3467 //
3468 // * <td> is affected by the cellpadding on its ancestor table
3469 // * lang="" and xml:lang="" can affect all descendants due to :lang()
3470 // * exportparts can affect all descendant parts. We could certainly integrate
3471 // it better in the invalidation machinery if it was necessary.
3476 }
3477 // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for exportparts
3478 // attribute changes?
3481 }
3483 }
3500 // FIXME(emilio): Does this really need to re-selector-match?
3503 // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for part
3504 // attribute changes?
3506 }
3509 // See if we have appearance information for a theme.
3510 StyleAppearance appearance =
3520 }
3521 }
3522 }
3525 }
3529 }
3532 // Assuming we need to invalidate cached style in getComputedStyle for
3533 // undisplayed elements, since we don't know if it is needed.
3536 // If we change attributes, we have to mark this to be true, so we will
3537 // increase the animation generation for the new created transition if any.
3539 }
3540 }
3543 // This is only called when moving frames in or out of the first-line
3544 // pseudo-element (or one of its descendants). We can't say much about
3545 // aFrame's ancestors, unfortunately (e.g. during a dynamic insert into
3546 // something inside an inline-block on the first line the ancestors could be
3547 // totally arbitrary), but we will definitely find a line frame on the
3548 // ancestor chain. Note that the lineframe may not actually be the one that
3549 // corresponds to ::first-line; when we're moving _out_ of the ::first-line it
3550 // will be one of the continuations instead.
3551 #ifdef DEBUG
3552 {
3556 }
3558 }
3559 #endif
3562 }
3567 // Style context of backdrop frame has no parent style, and thus we do not
3568 // need to reparent it.
3570 }
3573 // Also reparent the out-of-flow and all its continuations. We're doing
3574 // this to match Gecko for now, but it's not clear that this behavior is
3575 // correct per spec. It's certainly pretty odd for out-of-flows whose
3576 // containing block is not within the first line.
3577 //
3578 // Right now we're somewhat inconsistent in this testcase:
3579 //
3580 // <style>
3581 // div { color: orange; clear: left; }
3582 // div::first-line { color: blue; }
3583 // </style>
3584 // <div>
3585 // <span style="float: left">What color is this text?</span>
3586 // </div>
3587 // <div>
3588 // <span><span style="float: left">What color is this text?</span></span>
3589 // </div>
3590 //
3591 // We make the first float orange and the second float blue. On the other
3592 // hand, if the float were within an inline-block that was on the first
3593 // line, arguably it _should_ inherit from the ::first-line...
3599 }
3600 }
3602 // FIXME(emilio): This is the only caller of GetParentComputedStyle, let's try
3603 // to remove it?
3607 // If our provider is our child, we want to reparent it first, because we
3608 // inherit style from it.
3613 // Get the style again after ReparentComputedStyle() which might have
3614 // changed it.
3619 }
3622 // No need to do anything here for this frame, but we should still reparent
3623 // its descendants, because those may have styles that inherit from the
3624 // parent of this frame (e.g. non-anonymous columns in an anonymous
3625 // colgroup).
3630 }
3634 // We probably don't want to initiate transitions from ReparentComputedStyle,
3635 // since we call it during frame construction rather than in response to
3636 // dynamic changes.
3637 // Also see the comment at the start of
3638 // nsTransitionManager::ConsiderInitiatingTransition.
3639 //
3640 // We don't try to do the fancy copying from previous continuations that
3641 // GeckoRestyleManager does here, because that relies on knowing the parents
3642 // of ComputedStyles, and we don't know those.
3651 "How could we get a ::first-line parent style without having "
3653 // If newParent is a ::first-line style, get the parent blockframe, and then
3654 // correct it for our pseudo as needed (e.g. stepping out of anon boxes).
3655 // Use the resulting style for the "parent style ignoring ::first-line".
3662 }
3665 // No providerFrame means we inherited from a display:contents thing. Our
3666 // layout parent style is the style of our nearest ancestor frame. But we
3667 // have to be careful to do that with our placeholder, not with us, if we're
3668 // out of flow.
3676 }
3677 }
3682 ourElement);
3685 // This logic somewhat mirrors the logic in
3686 // RestyleManager::ProcessPostTraversal.
3688 // We can't use UpdateAdditionalComputedStyles as-is because it needs a
3689 // ServoRestyleState and maintaining one of those during a _frametree_
3690 // traversal is basically impossible.
3699 }
3700 }
3702 // Generally, owned anon boxes are our descendants. The only exceptions are
3703 // tables (for the table wrapper) and inline frames (for the block part of the
3704 // block-in-inline split). We're going to update our descendants when looping
3705 // over kids, and we don't want to update the block part of a block-in-inline
3706 // split if the inline is on the first line but the block is not (and if the
3707 // block is, it's the child of something else on the first line and will get
3708 // updated as a child). And given how this method ends up getting called, if
3709 // we reach here for a table frame, we are already in the middle of
3710 // reparenting the table wrapper frame. So no need to
3711 // UpdateStyleOfOwnedAnonBoxes() here.
3715 // We do not need to do the equivalent of UpdateFramePseudoElementStyles,
3716 // because those are handled by our descendant walk.
3717 }
3724 // We're getting into a display: none subtree, avoid reparenting into stuff
3725 // that is going to go away anyway in seconds.
3727 }
3730 // only do frames that are in flow
3734 }
3735 }
3736 }
3737 }