| blob | 86420bb4055d77494771972a441bd30cf8cc8832 |
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/. */
58 #ifdef ACCESSIBILITY
60 #endif
77 }
83 }
85 }
91 #ifdef DEBUG
92 {
96 }
97 }
98 #endif
101 }
107 }
109 // The container cannot be a document.
113 // see whether we need to restyle the container
117 // We don't know whether we're testing :empty or :-moz-only-whitespace,
118 // so be conservative and assume :-moz-only-whitespace (i.e., make
119 // IsSignificantChild less likely to be true, and thus make us more
120 // likely to restyle).
124 }
125 }
129 }
130 }
140 }
144 }
145 // Restyling the container is the most we can do here, so we're done.
147 }
150 // restyle the last element child before this node
160 }
161 }
162 }
163 }
170 }
171 }
172 }
179 }
180 }
181 }
187 // In some cases (:empty + E, :empty ~ E), a change in the content of
188 // an element requires restyling its parent's siblings.
193 }
195 }
202 // restyle the previously-first element child if it is after this node
209 }
217 }
219 }
220 }
221 // restyle the previously-last element child if it is before this node
228 }
236 }
238 }
239 }
240 }
247 }
248 }
250 }
257 // The old text was already not whitespace-only.
259 }
262 }
270 }
271 // We don't know whether we're testing :empty or :-moz-only-whitespace,
272 // so be conservative and assume :-moz-only-whitespace (i.e., make
273 // IsSignificantChild less likely to be true, and thus make us more
274 // likely to restyle).
277 }
278 }
281 }
292 // Nothing to do, no other slow selector can change as a result of this.
294 }
297 // Doesn't matter to styling (could be a processing instruction or a
298 // comment), it can't change whether any selectors match or don't.
300 }
305 }
308 // This is an anonymous node and thus isn't in child lists, so isn't taken
309 // into account for selector matching the relevant selectors here.
311 }
313 // Handle appends specially since they're common and we can know both the old
314 // and the new text exactly.
315 //
316 // TODO(emilio): This could be made much more general if :-moz-only-whitespace
317 // / :-moz-first-node and :-moz-last-node didn't exist. In that case we only
318 // need to know whether we went from empty to non-empty, and that's trivial to
319 // know, with CharacterDataChangeInfo...
321 // FIXME(emilio): This restyles unnecessarily if the text node is the only
322 // child of the parent element. Fortunately, it's uncommon to have such
323 // nodes and this not being an append.
324 //
325 // See the testcase in bug 1427625 for a test-case that triggers this.
328 }
344 }
348 // We used to be empty, restyle the parent.
351 }
352 }
356 }
357 }
359 // Restyling for a ContentInserted or CharacterDataChanged notification.
360 // This could be used for ContentRemoved as well if we got the
361 // notification before the removal happened (and sometimes
362 // CharacterDataChanged is more like a removal than an addition).
363 // The comments are written and variables are named in terms of it being
364 // a ContentInserted notification.
373 }
378 // The container cannot be a document.
383 // See whether we need to restyle the container due to :empty /
384 // :-moz-only-whitespace.
388 // FIXME(emilio): When coming from CharacterDataChanged this can restyle
389 // unnecessarily. Also can restyle unnecessarily if aChild is not
390 // significant anyway, though that's more unlikely.
393 }
394 }
404 }
408 }
409 // Restyling the container is the most we can do here, so we're done.
411 }
414 // Restyle all later siblings.
419 }
420 }
424 }
425 }
432 // Computed style data isn't useful for detached nodes, and we'll need to
433 // recompute it anyway if we ever insert the nodes back into a document.
436 // If this element is undisplayed or may have undisplayed descendants, we
437 // need to invalidate the cache, since there's the unlikely event of those
438 // elements getting destroyed and their addresses reused in a way that we
439 // look up the cache with their address for a different element before it's
440 // invalidated.
442 }
445 aFollowingSibling);
446 }
452 }
455 // This should be an assert, but this is called incorrectly in
456 // HTMLEditor::DeleteRefToAnonymousNode and the assertions were clogging
457 // up the logs. Make it an assert again when that's fixed.
460 }
462 // The container cannot be a document.
467 // see whether we need to restyle the container
471 // We don't know whether we're testing :empty or :-moz-only-whitespace,
472 // so be conservative and assume :-moz-only-whitespace (i.e., make
473 // IsSignificantChild less likely to be true, and thus make us more
474 // likely to restyle).
478 }
479 }
483 }
484 }
494 }
498 }
499 // Restyling the container is the most we can do here, so we're done.
501 }
504 // Restyle all later siblings.
513 nextSibling);
514 }
515 }
518 // restyle the now-first element child if it was after aOldChild
524 // do NOT continue here; we might want to restyle this node
525 }
533 }
535 }
536 }
537 // restyle the now-last element child if it was before aOldChild
548 }
550 }
553 }
554 }
555 }
556 }
560 ElementState aStates) {
564 }
567 // If it's other generated content, ignore state changes on it.
569 }
572 // Broken affects object fallback behavior.
574 }
579 }
582 }();
586 }
592 }
595 ElementState aStateMask) {
599 // The checkbox inside these elements inherit hover state and so on, see
600 // nsNativeTheme::GetContentState.
601 // FIXME(emilio): Would be nice to not have these hard-coded.
603 }
607 }
612 }
616 }
618 /**
619 * Calculates the change hint and the restyle hint for a given content state
620 * change.
621 */
623 ElementState aStateMask) {
626 // Any change to a content state that affects which frames we construct
627 // must lead to a frame reconstruct here if we already have a frame.
628 // Note that we never decide through non-CSS means to not create frames
629 // based on content states, so if we already don't have a frame we don't
630 // need to force a reframe -- if it's needed, the HasStateDependentStyle
631 // call will handle things.
635 }
638 }
640 }
643 // Exposing information to the page about whether the link is
644 // visited or not isn't really something we can worry about here.
645 // FIXME: We could probably do this a bit better.
647 }
649 // This changes the applicable text-transform in the editor root.
651 // This is the same change hint as tweaking text-transform.
653 }
656 }
658 #ifdef DEBUG
659 /* static */
661 nsCString result;
704 nsChangeHint_AllReflowHints) {
712 }
717 }
720 }
721 }
725 }
730 }
731 }
733 }
734 #endif
736 /**
737 * Frame construction helpers follow.
738 */
739 #ifdef DEBUG
741 #endif
743 /**
744 * Sync views on the frame and all of it's descendants (following placeholders).
745 * The change hint should be some combination of nsChangeHint_RepaintFrame,
746 * nsChangeHint_UpdateOpacityLayer and nsChangeHint_SchedulePaint, nothing else.
747 */
752 /**
753 * This helper function is used to find the correct SVG frame to target when we
754 * encounter nsChangeHint_ChildrenOnlyTransform; needed since sometimes we end
755 * up handling that hint while processing hints for one of the SVG frame's
756 * ancestor frames.
757 *
758 * The reason that we sometimes end up trying to process the hint for an
759 * ancestor of the SVG frame that the hint is intended for is due to the way we
760 * process restyle events. ApplyRenderingChangeToTree adjusts the frame from
761 * the restyled element's principle frame to one of its ancestor frames based
762 * on what nsCSSRendering::FindBackground returns, since the background style
763 * may have been propagated up to an ancestor frame. Processing hints using an
764 * ancestor frame is fine in general, but nsChangeHint_ChildrenOnlyTransform is
765 * a special case since it is intended to update a specific frame.
766 */
769 // This happens if the root-<svg> is fixed positioned, in which case we
770 // can't use aFrame->GetContent() to find the primary frame, since
771 // GetContent() returns nullptr for ViewportFrame.
773 }
774 // For an nsHTMLScrollFrame, this will get the SVG frame that has the
775 // children-only transforms:
781 }
785 }
787 // This function tries to optimize a position style change by either
788 // moving aFrame or ignoring the style change when it's safe to do so.
789 // It returns true when that succeeds, otherwise it posts a reflow request
790 // and returns false.
792 // It's pointless to move around frames that have never been reflowed or
793 // are dirty (i.e. they will be reflowed), or aren't affected by position
794 // styles.
796 NS_FRAME_SVG_LAYOUT)) {
798 }
800 // Don't process position changes on table frames, since we already handle
801 // the dynamic position change on the table wrapper frame, and the
802 // reflow-based fallback code path also ignores positions on inner table
803 // frames.
806 }
809 // Changes to the offsets of a non-positioned element can safely be ignored.
812 }
814 // Don't process position changes on frames which have views or the ones which
815 // have a view somewhere in their descendants, because the corresponding view
816 // needs to be repositioned properly as well.
820 }
823 // If the frame has an intrinsic block-size, we resolve its 'auto' margins
824 // after doing layout, since we need to know the frame's block size. See
825 // nsAbsoluteContainingBlock::ResolveAutoMarginsAfterLayout().
826 //
827 // Since the size of the frame doesn't change, we could modify the below
828 // computation to compute the margin correctly without doing a full reflow,
829 // however we decided to try doing a full reflow for now.
835 }
836 }
837 // Flexbox and Grid layout supports CSS Align and the optimizations below
838 // don't support that yet.
842 }
843 }
845 // If we need to reposition any descendant that depends on our static
846 // position, then we also can't take the optimized path.
847 //
848 // TODO(emilio): It may be worth trying to find them and try to call
849 // RecomputePosition on them too instead of disabling the optimization...
852 }
860 }
862 // We need to trigger re-snapping to this content if we snapped to the
863 // content on the last scroll operation.
865 };
867 // For relative positioning, we can simply update the frame rect
870 // A grid item's CB is its grid area, not the parent frame content area
871 // as is assumed below.
873 }
874 // Move the frame
876 // Update sticky positioning for an entire element at once, starting with
877 // the first continuation or ib-split sibling.
878 // It's rare that the frame we already have isn't already the first
879 // continuation or ib-split sibling, but it can happen when styles differ
880 // across continuations such as ::first-line or ::first-letter, and in
881 // those cases we will generally (but maybe not always) do the work twice.
888 firstContinuation);
891 }
904 // ReflowInput::ApplyRelativePositioning would work here, but
905 // since we've already checked mPosition and aren't changing the frame's
906 // normal position, go ahead and add the offsets directly.
907 // First, we need to ensure that the normal position is stored though.
912 }
915 }
916 }
920 }
922 // For the absolute positioning case, set up a fake HTML reflow input for
923 // the frame, and then get the offsets and size from it. If the frame's size
924 // doesn't need to change, we can simply update the frame position. Otherwise
925 // we fall back to a reflow.
929 // Construct a bogus parent reflow input so that there's a usable reflow input
930 // for the containing block.
938 parentSize);
942 // The bogus parent state here was created with no parent state of its own,
943 // and therefore it won't have an mCBReflowInput set up.
944 // But we may need one (for InitCBReflowInput in a child state), so let's
945 // try to create one here for the cases where it will be needed.
960 }
977 nsSize cbSize =
978 viewport
994 }
997 // The RecomputePosition hint is not used if any offset changed between auto
998 // and non-auto. If computedSize.height == NS_UNCONSTRAINEDSIZE then the new
999 // element height will be its intrinsic height, and since 'top' and 'bottom''s
1000 // auto-ness hasn't changed, the old height must also be its intrinsic
1001 // height, which we can assume hasn't changed (or reflow would have
1002 // been triggered).
1006 // If we're solving for 'left' or 'top', then compute it here, in order to
1007 // match the reflow code path.
1008 //
1009 // TODO(emilio): It'd be nice if this did logical math instead, but it seems
1010 // to me the math should work out on vertical writing modes as well. See Bug
1011 // 1675861 for some hints.
1017 left =
1019 }
1025 }
1027 // Move the frame
1034 }
1036 // Fall back to a reflow
1038 }
1040 /**
1041 * Return true if aFrame's subtree has placeholders for out-of-flow content
1042 * that would be affected due to the change to
1043 * `aPossiblyChangingContainingBlock` (and thus would need to get reframed).
1044 *
1045 * In particular, this function returns true if there are placeholders whose OOF
1046 * frames may need to be reparented (via reframing) as a result of whatever
1047 * change actually happened.
1048 *
1049 * The `aIs{Abs,Fixed}PosContainingBlock` params represent whether
1050 * `aPossiblyChangingContainingBlock` is a containing block for abs pos / fixed
1051 * pos stuff, respectively, for the _new_ style that the frame already has, not
1052 * the old one.
1053 */
1057 // All fixed-pos containing blocks should also be abs-pos containing blocks.
1064 // If SVG text frames could appear here, they could confuse us since
1065 // they ignore their position style ... but they can't.
1068 // Top-layer frames don't change containing block based on direct
1069 // ancestors.
1074 aIsFixedPosContainingBlock ||
1077 // NOTE(emilio): aPossiblyChangingContainingBlock is guaranteed to be
1078 // a first continuation, see the assertion in the caller.
1081 // If we are becoming a containing block, we only need to reframe if
1082 // this oof's current containing block is an ancestor of the new
1083 // frame.
1088 }
1090 // If we are not a containing block anymore, we only need to reframe
1091 // if we are the current containing block of the oof frame.
1094 }
1095 }
1096 }
1097 }
1098 // NOTE: It's tempting to check f->IsAbsPosContainingBlock() or
1099 // f->IsFixedPosContainingBlock() here. However, that would only
1100 // be testing the *new* style of the frame, which might exclude
1101 // descendants that currently have this frame as an abs-pos
1102 // containing block. Taking the codepath where we don't reframe
1103 // could lead to an unsafe call to
1104 // cont->MarkAsNotAbsoluteContainingBlock() before we've reframed
1105 // the descendant and taken it off the absolute list.
1108 aIsFixedPosContainingBlock)) {
1110 }
1111 }
1112 }
1114 }
1116 // Returns the frame that would serve as the containing block for aFrame's
1117 // positioned descendants, if aFrame had styles to make it a CB for such
1118 // descendants. (Typically this is just aFrame itself, or its insertion frame).
1119 //
1120 // Returns nullptr if this frame can't be easily determined.
1123 // FIXME: This should be easily implementable.
1125 }
1129 }
1130 // Generally frames with a different insertion frame are hard to deal with,
1131 // but scrollframes are easy because the containing block is just the
1132 // insertion frame.
1135 }
1136 // Combobox frames are easy as well because they can't have positioned
1137 // children anyways.
1138 // Button and table cell frames are also easy because the containing block is
1139 // the frame itself.
1143 }
1145 }
1149 // NOTE: This looks at the new style.
1159 isAbsPosContainingBlock,
1160 isFixedContainingBlock)) {
1162 }
1163 }
1165 }
1168 nsChangeHint aChange) {
1174 // Invalidate and sync views on all descendant frames, following
1175 // placeholders. We don't need to update transforms in
1176 // SyncViewsAndInvalidateDescendants, because there can't be any
1177 // out-of-flows or popups that need to be transformed; all out-of-flow
1178 // descendants of the transformed element must also be descendants of the
1179 // transformed frame.
1182 nsChangeHint_UpdateOpacityLayer |
1183 nsChangeHint_SchedulePaint)));
1184 // This must be set to true if the rendering change needs to
1185 // invalidate content. If it's false, a composite-only paint
1186 // (empty transaction) will be scheduled.
1189 // if frame has view, will already be invalidated
1191 // Note that this whole block will be skipped when painting is suppressed
1192 // (due to our caller ApplyRendingChangeToTree() discarding the
1193 // nsChangeHint_RepaintFrame hint). If you add handling for any other
1194 // hints within this block, be sure that they too should be ignored when
1195 // painting is suppressed.
1200 // Need to update our overflow rects:
1202 }
1205 }
1207 // FIXME/bug 796697: we can get away with empty transactions for
1208 // opacity updates in many cases.
1213 // SVG effects paints the opacity without using
1214 // nsDisplayOpacity. We need to invalidate manually.
1216 }
1217 }
1220 // Note: All the transform-like properties should map to the same
1221 // layer activity index, so does the restyle count. Therefore, using
1222 // eCSSProperty_transform should be fine.
1225 }
1232 // Note: All the transform-like properties should map to the same
1233 // layer activity index, so does the restyle count. Therefore, using
1234 // eCSSProperty_transform should be fine.
1236 }
1237 }
1240 }
1244 }
1245 }
1248 nsChangeHint aChange) {
1254 nsChangeHint_UpdateOpacityLayer |
1255 nsChangeHint_SchedulePaint)),
1263 // only do frames that don't have placeholders
1265 // do the out-of-flow frame and its continuations
1273 }
1274 }
1275 }
1276 }
1277 }
1280 nsChangeHint aChange) {
1281 // We check StyleDisplay()->HasTransformStyle() in addition to checking
1282 // IsTransformed() since we can get here for some frames that don't support
1283 // CSS transforms, and table frames, which are their own odd-ball, since the
1284 // transform is handled by their wrapper, which _also_ gets a separate hint.
1291 // Don't allow synchronous rendering changes when painting is turned off.
1295 }
1296 }
1298 // Trigger rendering updates by damaging this frame and any
1299 // continuations of this frame.
1300 #ifdef DEBUG
1302 #endif
1304 // If the frame is the primary frame of either the body element or
1305 // the html element, we propagate the repaint change hint to the
1306 // viewport. This is necessary for background and scrollbar colors
1307 // propagation.
1315 }
1316 }
1317 }
1319 #ifdef DEBUG
1321 #endif
1322 }
1329 }
1333 }
1334 }
1335 }
1338 IntrinsicDirty dirtyType;
1347 NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
1353 }
1357 }
1359 nsFrameState dirtyBits;
1367 }
1369 // If we're not going to clear any intrinsic sizes on the frames, and
1370 // there are no dirty bits to set, then there's nothing to do.
1373 ReflowRootHandling rootHandling;
1378 }
1382 rootHandling);
1385 }
1387 // Get the next sibling which might have a frame. This only considers siblings
1388 // that stylo post-traversal looks at, so only elements and text. In
1389 // particular, it ignores comments.
1395 }
1396 }
1399 }
1401 // If |aFrame| is dirty or has dirty children, then we can skip updating
1402 // overflows since that will happen when it's reflowed.
1405 NS_FRAME_HAS_DIRTY_CHILDREN);
1406 }
1414 }
1418 }
1424 // Only bother with this if we're the root or the body element, since:
1425 // (a) It'd be *expensive* to reframe these particular nodes. They're
1426 // at the root, so reframing would mean rebuilding the world.
1427 // (b) It's often *unnecessary* to reframe for "overflow" changes on
1428 // these particular nodes. In general, the only reason we reframe
1429 // for "overflow" changes is so we can construct (or destroy) a
1430 // scrollframe & scrollbars -- and the html/body nodes often don't
1431 // need their own scrollframe/scrollbars because they coopt the ones
1432 // on the viewport (which always exist). So depending on whether
1433 // that's happening, we can skip the reframe for these nodes.
1435 // If the restyled element provided/provides the scrollbar styles for
1436 // the viewport before and/or after this restyle, AND it's not coopting
1437 // that responsibility from some other element (which would need
1438 // reconstruction to make its own scrollframe now), THEN: we don't need
1439 // to reconstruct - we can just reflow, because no scrollframe is being
1440 // added/removed.
1447 }
1449 };
1453 // If we get here, the restyled element provided the scrollbar styles
1454 // for viewport before this restyle, OR it will provide them after.
1456 // If we get here, the restyled element is NOT replacing (or being
1457 // replaced by) some other element as the viewport's
1458 // scrollbar-styles provider. (If it were, we'd potentially need to
1459 // reframe to create a dedicated scrollframe for whichever element
1460 // is being booted from providing viewport scrollbar styles.)
1461 //
1462 // Under these conditions, we're OK to assume that this "overflow"
1463 // change only impacts the root viewport's scrollframe, which
1464 // already exists, so we can simply reflow instead of reframing.
1470 }
1473 // If we changed the override element, we need to reconstruct as the old
1474 // override element might start / stop being scrollable.
1476 }
1478 }
1479 }
1485 // Once we've created scrollbars for a frame, don't bother reconstructing
1486 // it just to remove them if we still need a scroll frame.
1489 }
1491 // input / textarea for the most part don't honor overflow themselves, the
1492 // editor root will deal with the change if needed.
1493 // However the textarea intrinsic size relies on GetDesiredScrollbarSizes(),
1494 // so we need to reflow the textarea itself, not just the inner control.
1498 // Something changed, but we don't have nor will have a scroll frame,
1499 // there's nothing to do here.
1501 }
1503 // Oh well, we couldn't optimize it out, just reconstruct frames for the
1504 // subtree.
1506 }
1512 }
1515 }
1520 // The frame has positioned children that need to be reparented, or it can't
1521 // easily be converted to/from being an abs-pos container correctly.
1524 }
1527 // The absolute container should be containingBlock.
1530 // Normally frame construction would set state bits as needed,
1531 // but we're not going to reconstruct the frame so we need to set
1532 // them. It's because we need to set this state on each affected frame
1533 // that we can't coalesce nsChangeHint_UpdateContainingBlock hints up
1534 // to ancestors (i.e. it can't be an change hint that is handled for
1535 // descendants).
1540 }
1543 // If |cont| still has absolutely positioned children,
1544 // we can't call MarkAsNotAbsoluteContainingBlock. This
1545 // will remove a frame list that still has children in
1546 // it that we need to keep track of.
1547 // The optimization of removing it isn't particularly
1548 // important, although it does mean we skip some tests.
1552 }
1553 }
1554 }
1555 }
1561 // See bug 1378219 comment 9:
1562 // Recursive calls here are a bit worrying, but apparently do happen in the
1563 // wild (although not currently in any of our automated tests). Try to get a
1564 // stack from Nightly/Dev channel to figure out what's going on and whether
1565 // it's OK.
1570 }
1572 // If mDestroyedFrames is null, we want to create a new hashtable here
1573 // and destroy it on exit; but if it is already non-null (because we're in
1574 // a recursive call), we will continue to use the existing table to
1575 // accumulate destroyed frames, and NOT clear mDestroyedFrames on exit.
1576 // We use a MaybeClearDestroyedFrames helper to conditionally reset the
1577 // mDestroyedFrames pointer when this method returns.
1588 {}
1592 }
1593 }
1594 };
1599 }
1609 // Collect and coalesce adjacent siblings for lazy frame construction.
1610 // Eventually it would be even better to make RecreateFramesForContent
1611 // accept a range and coalesce all adjacent reconstructs (bug 1344139).
1621 }
1632 }
1633 }
1637 }
1640 }
1652 // skip any frame that has been destroyed due to a ripple effect
1655 }
1658 // XXXbz this is due to image maps messing with the primary frame of
1659 // <area>s. See bug 135040. Remove this block once that's fixed.
1663 }
1664 }
1670 // If we ever start passing true here, be careful of restyles
1671 // that involve a reframe and animations. In particular, if the
1672 // restyle we're processing here is an animation restyle, but
1673 // the style resolution we will do for the frame construction
1674 // happens async when we're not in an animation restyle already,
1675 // problems could arise.
1676 // We could also have problems with triggering of CSS transitions
1677 // on elements whose frames are reconstructed, since we depend on
1678 // the reconstruction happening synchronously.
1682 }
1690 }
1691 // Don't remove NS_FRAME_MAY_BE_TRANSFORMED since it may still be
1692 // transformed by other means. It's OK to have the bit even if it's
1693 // not needed.
1694 }
1695 // When dropping a running transform animation we will first add an
1696 // nsChangeHint_UpdateTransformLayer hint as part of the animation-only
1697 // restyle. During the subsequent regular restyle, if the animation was
1698 // the only reason the element had any transform applied, we will add
1699 // nsChangeHint_AddOrRemoveTransform as part of the regular restyle.
1700 //
1701 // With the Gecko backend, these two change hints are processed
1702 // after each restyle but when using the Servo backend they accumulate
1703 // and are processed together after we have already removed the
1704 // transform as part of the regular restyle. Since we don't actually
1705 // need the nsChangeHint_UpdateTransformLayer hint if we already have
1706 // a nsChangeHint_AddOrRemoveTransform hint, and since we
1707 // will fail an assertion in ApplyRenderingChangeToTree if we try
1708 // specify nsChangeHint_UpdateTransformLayer but don't have any
1709 // transform style, we just drop the unneeded hint here.
1711 }
1714 // frame does not maintain overflow rects, so avoid calling
1715 // FinishAndStoreOverflow on it:
1716 hint &=
1718 nsChangeHint_UpdatePostTransformOverflow |
1719 nsChangeHint_UpdateParentOverflow |
1720 nsChangeHint_UpdateSubtreeOverflow);
1721 }
1724 // Frame can not be transformed, and thus a change in transform will
1725 // have no effect and we should not use either
1726 // nsChangeHint_UpdatePostTransformOverflow or
1727 // nsChangeHint_UpdateTransformLayerhint.
1729 nsChangeHint_UpdateTransformLayer);
1730 }
1735 }
1741 }
1745 }
1747 // Here we need to propagate repaint frame change hint instead of update
1748 // opacity layer change hint when we do opacity optimization for SVG.
1749 // We can't do it in nsStyleEffects::CalcDifference() just like we do
1750 // for the optimization for 0.99 over opacity values since we have no way
1751 // to call SVGUtils::CanOptimizeOpacity() there.
1756 }
1760 "should only return UpdateUsesOpacity hint "
1762 // When an internal table part (including cells) changes between
1763 // having opacity 1 and non-1, it changes whether its
1764 // backgrounds (and those of table parts inside of it) are
1765 // painted as part of the table's nsDisplayTableBorderBackground
1766 // display item, or part of its own display item. That requires
1767 // invalidation, so change UpdateOpacityLayer to RepaintFrame.
1770 }
1772 // Opacity disables preserve-3d, so if we toggle it, then we also need
1773 // to update the overflow areas of all potentially affected frames.
1778 }
1781 // For most frame types, DLBI can detect background position changes,
1782 // so we only need to schedule a paint.
1785 // Table parts and MathML frames don't build display items for their
1786 // backgrounds, so DLBI can't detect background-position changes for
1787 // these frames. Repaint the whole frame.
1789 }
1790 }
1794 nsChangeHint_UpdateTransformLayer |
1797 }
1800 nsChangeHint_AddOrRemoveTransform)) {
1801 // We need to trigger re-snapping to this content if we snapped to the
1802 // content on the last scroll operation.
1804 }
1807 // It is possible for this to fall back to a reflow
1810 nsChangeHint_ReflowChangesSizeOrPosition);
1812 }
1813 }
1819 nsChangeHint_UpdatePostTransformOverflow |
1820 nsChangeHint_UpdateParentOverflow |
1821 nsChangeHint_UpdateSubtreeOverflow))) {
1826 }
1827 // The work we just did in AddSubtreeToOverflowTracker
1828 // subsumes some of the other hints:
1830 nsChangeHint_UpdatePostTransformOverflow);
1831 }
1833 // We need to update overflows. The correct frame(s) to update depends
1834 // on whether the ChangeHint came from an outer or an inner svg.
1837 "SVG frames should not have continuations "
1841 "SVG frames should not have continuations "
1844 // The children only transform of an outer svg frame is applied to
1845 // the outer svg's anonymous child frame (instead of to the
1846 // anonymous child's children).
1851 }
1853 // The children only transform is applied to the child frames of an
1854 // inner svg frame, so update the child overflows.
1862 }
1865 "SVG frames should not have continuations "
1870 }
1871 }
1872 }
1875 nsChangeHint_UpdatePostTransformOverflow)) {
1877 // If we have both nsChangeHint_UpdateOverflow and
1878 // nsChangeHint_UpdatePostTransformOverflow,
1879 // CHILDREN_CHANGED is selected as it is
1880 // strictly stronger.
1885 }
1887 cont =
1890 }
1891 }
1892 // UpdateParentOverflow hints need to be processed in addition
1893 // to the above, since if the processing of the above hints
1894 // yields no change, the update will not propagate to the
1895 // parent.
1900 cont =
1904 }
1905 }
1906 }
1907 }
1911 }
1914 }
1917 }
1918 }
1922 }
1924 /* static */
1928 }
1931 // We update the animation generation at start of each call to
1932 // ProcessPendingRestyles so we should ignore any subsequent (redundant)
1933 // calls that occur while we are still processing restyles.
1936 }
1937 }
1939 /* static */
1947 }
1958 // If we have a transform layer but don't have any transform style, we
1959 // probably just removed the transform but haven't destroyed the layer
1960 // yet. In this case we will typically add the appropriate change hint
1961 // (nsChangeHint_UpdateContainingBlock) when we compare styles so in
1962 // theory we could skip adding any change hint here.
1963 //
1964 // However, sometimes when we compare styles we'll get no change. For
1965 // example, if the transform style was 'none' when we sent the transform
1966 // animation to the compositor and the current transform style is now
1967 // 'none' we'll think nothing changed but actually we still need to
1968 // trigger an update to clear whatever style the transform animation set
1969 // on the compositor. To handle this case we simply set all the change
1970 // hints relevant to removing transform style (since we don't know exactly
1971 // what changes happened while the animation was running on the
1972 // compositor).
1973 //
1974 // Note that we *don't* add nsChangeHint_UpdateTransformLayer since if we
1975 // did, ApplyRenderingChangeToTree would complain that we're updating a
1976 // transform layer without a transform.
1979 // Add all the hints for a removing a transform if they are not already
1980 // set for this frame.
1982 aHintForThisFrame))) {
1984 }
1986 }
1988 }
1990 // We consider it's the first paint for the frame if we have an animation
1991 // for the property but have no layer, for the case of WebRender, no
1992 // corresponding animation info.
1993 // Note that in case of animations which has properties preventing running
1994 // on the compositor, e.g., width or height, corresponding layer is not
1995 // created at all, but even in such cases, we normally set valid change
1996 // hint for such animations in each tick, i.e. restyles in each tick. As
1997 // a result, we usually do restyles for such animations in every tick on
1998 // the main-thread. The only animations which will be affected by this
1999 // explicit change hint are animations that have opacity/transform but did
2000 // not have those properies just before. e.g, setting transform by
2001 // setKeyframes or changing target element from other target which prevents
2002 // running on the compositor, etc.
2004 nsChangeHint hintForDisplayItem =
2006 // We don't need to apply the corresponding change hint if we already have
2007 // it.
2010 }
2015 }
2020 }
2021 }
2023 };
2027 maybeApplyChangeHint);
2030 // We apply the hint to the primary frame, not the style frame. Transform
2031 // and opacity hints apply to the table wrapper box, not the table box.
2033 }
2034 }
2043 }
2051 }
2063 }
2067 }
2071 }
2075 }
2076 }
2082 // All other animations should keep running but not running on the
2083 // *compositor* at this point.
2087 }
2088 }
2089 }
2090 }
2092 #ifdef DEBUG
2095 }
2101 }
2104 }
2111 }
2116 }
2119 }
2122 // A ::first-line always ends up here via its block, which is therefore the
2123 // right expected owner. That block can be an
2124 // anonymous box. For example, we could have a ::first-line on a columnated
2125 // block; the blockframe is the column-content anonymous box in that case.
2126 // So we don't want to end up in the code below, which steps out of anon
2127 // boxes. Just return the parent of the line frame, which is the block.
2129 }
2132 // Ditto for ::first-letter. A first-letter always arrives here via its
2133 // direct parent, except when it's parented to a ::first-line.
2136 }
2138 }
2141 // Things never have ::first-letter as their expected parent. Go
2142 // on up to the ::first-letter's parent.
2144 }
2148 // We've handled already anon boxes, so now we're looking at
2149 // a frame of a DOM element or pseudo. Hop through anon and line-boxes
2150 // generated by our DOM parent, and go find the owner frame for it.
2156 // Handle :-moz-table and :-moz-inline-table.
2159 // We get the in-flow parent here so that we can handle the OOF anonymous
2160 // boxed to get the correct parent.
2162 }
2164 }
2167 }
2169 // FIXME(emilio, bug 1633685): We should ideally figure out how to properly
2170 // restyle replicated fixed pos frames... We seem to assume everywhere that they
2171 // can't get restyled at the moment...
2175 }
2182 }
2183 }
2186 }
2192 // We allow aParent.mOwner to be null, for cases when we're not starting at
2193 // the root of the tree. We also allow aParent.mOwner to be somewhere up our
2194 // expected owner chain not our immediate owner, which allows us creating long
2195 // chains of ServoRestyleStates in some cases where it's just not worth it.
2200 "Should only have expected owner weirdness when anon boxes "
2207 }
2208 }
2210 }
2211 }
2212 }
2219 }
2225 }
2226 #endif
2230 "All our wrappers are anon boxes, and why would we restyle "
2233 "All our wrappers are anon boxes, and why would we restyle "
2241 // Make sure we only add first continuations.
2245 // Already queued up, nothing to do.
2247 }
2249 // Make sure to queue up parents before children. But don't queue up
2250 // ancestors of non-anonymous boxes here; those are handled when we traverse
2251 // their non-anonymous kids.
2254 }
2256 // If the append fails, we'll fail to restyle properly, but that's probably
2257 // better than crashing.
2260 }
2261 }
2267 }
2270 }
2274 // The frame at index aIndex is something we should restyle ourselves, but
2275 // following frames may need separate ServoRestyleStates to restyle.
2281 // Where is cur supposed to inherit from? From its parent frame, except in
2282 // the case when cur is a table, in which case it should be its grandparent.
2283 // Also, not in the case when the resulting frame would be a first-line; in
2284 // that case we should be inheriting from the block, and the first-line will
2285 // do its fixup later if needed.
2286 //
2287 // Note that after we do all that fixup the parent we get might still not be
2288 // aParent; for example aParent could be a scrollframe, in which case we
2289 // should inherit from the scrollcontent frame. Or the parent might be some
2290 // continuation of aParent.
2291 //
2292 // Try to assert as much as we can about the parent we actually end up using
2293 // without triggering bogus asserts in all those various edge cases.
2298 }
2301 }
2306 // Now "this" is a ServoRestyleState for aParent, so if parent is not a next
2307 // continuation (possibly across ib splits) of aParent we need a new
2308 // ServoRestyleState for the kid.
2315 }
2319 // This frame may already have been restyled. Even if it has, we can't just
2320 // return, because the next frame may be a kid of it that does need restyling.
2324 }
2328 // Note: no overflow possible here, since aIndex < length.
2333 // It might be nice if we could do better than nsChangeHint_Empty. On
2334 // the other hand, presumably our mChangesHandled already has the bits
2335 // we really want here so in practice it doesn't matter.
2339 numProcessed +=
2341 }
2342 }
2345 }
2348 // We want to get the anon box parent for aChild. where aChild has
2349 // ParentIsWrapperAnonBox().
2350 //
2351 // For the most part this is pretty straightforward, but there are two
2352 // wrinkles. First, if aChild is a table, then we really want the parent of
2353 // its table wrapper.
2357 }
2360 // Now if parent is a cell-content frame, we actually want the cellframe.
2364 // Must be a caption. In that case we want the table here.
2367 }
2369 }
2372 RestyleHint aRestyleHint,
2373 nsChangeHint aMinChangeHint) {
2379 }
2381 // We allow posting restyles from within change hint handling, but not from
2382 // within the restyle algorithm itself.
2386 // FIXME(emilio): we should assert against this instead.
2388 }
2390 // Assuming the restyle hints will invalidate cached style for
2391 // getComputedStyle, since we don't know if any of the restyling that we do
2392 // would affect undisplayed elements.
2396 }
2399 }
2401 // Processing change hints sometimes causes new change hints to be generated,
2402 // and very occasionally, additional restyle hints. We collect the change
2403 // hints manually to avoid re-traversing the DOM to find them.
2407 }
2411 }
2412 }
2415 PseudoStyleType aPseudoType,
2416 RestyleHint aRestyleHint) {
2421 // FIXME: Bug 1371107: When reframing happens,
2422 // EffectCompositor::mElementsToRestyle still has unbound old pseudo
2423 // element. We should drop it.
2425 }
2430 }
2433 RestyleHint aRestyleHint) {
2434 // NOTE(emilio): The semantics of these methods are quite funny, in the sense
2435 // that we're not supposed to need to rebuild the actual stylist data.
2436 //
2437 // That's handled as part of the MediumFeaturesChanged stuff, if needed.
2438 //
2439 // Clear the cached style data only if we are guaranteed to process the whole
2440 // DOM tree again.
2441 //
2442 // FIXME(emilio): Decouple this, probably. This probably just wants to reset
2443 // the "uses viewport units / uses rem" bits, and _maybe_ clear cached anon
2444 // box styles and such... But it doesn't really always need to clear the
2445 // initial style of the document and similar...
2448 }
2453 }
2455 // TODO(emilio, bz): Extensions can add/remove stylesheets that can affect
2456 // non-inheriting anon boxes. It's not clear if we want to support that, but
2457 // if we do, we need to re-selector-match them here.
2458 }
2460 /* static */
2462 IncludeRoot aIncludeRoot) {
2468 }
2469 }
2470 }
2475 NODE_NEEDS_FRAME));
2477 }
2478 }
2480 /* static */
2487 }
2488 }
2489 }
2494 }
2496 /**
2497 * This struct takes care of encapsulating some common state that text nodes may
2498 * need to track during the post-traversal.
2499 *
2500 * This is currently used to properly compute change hints when the parent
2501 * element of this node is a display: contents node, and also to avoid computing
2502 * the style for text children more than once per element.
2503 */
2523 }
2526 }
2535 }
2540 // We rely on the fact that all the text children for the same element share
2541 // style to avoid recomputing style differences for all of them.
2542 //
2543 // TODO(emilio): The above may not be true for ::first-{line,letter}, but
2544 // we'll cross that bridge when we support those in stylo.
2551 }
2555 mComputedHint);
2556 }
2557 }
2562 mLazilyResolvedParentContext =
2565 }
2567 }
2576 nsChangeHint mComputedHint;
2577 };
2584 }
2586 // Elements in the top layer are guaranteed to have absolute or fixed
2587 // position per https://fullscreen.spec.whatwg.org/#new-stacking-layer.
2594 }
2607 // NOTE(emilio): We can't use the changes handled for the owner of the
2608 // backdrop frame, since it's out of flow, and parented to the viewport or
2609 // canvas frame (depending on the `position` value).
2615 anchorsToSuppress);
2618 }
2627 }
2629 // We need to find the block the first-letter is associated with so we can
2630 // find the right element for the first-letter's style resolution. Might as
2631 // well just delegate the whole thing to that block.
2635 }
2639 }
2655 nsChangeHint childHint =
2661 }
2665 // If we generate a reconstruct here, remove any non-reconstruct hints we
2666 // may have already generated for this content.
2668 }
2670 childHint);
2671 }
2674 }
2681 // FIXME(emilio): Consider adding a bit or something to avoid the initial
2682 // virtual call?
2686 }
2687 }
2695 }
2699 }
2703 // Whether parent was restyled.
2705 // Skip sending accessibility notifications for all descendants.
2707 // Always send accessibility notifications if the element is shown.
2708 // The SkipA11yNotifications flag above overrides this flag.
2710 };
2714 // Send proper accessibility notifications and return post traversal
2715 // flags for kids.
2719 ServoPostTraversalFlags aFlags) {
2725 #ifdef ACCESSIBILITY
2728 // If we don't have accessibility service, accessibility is not
2729 // enabled. Just skip everything.
2731 }
2740 }
2741 }
2744 // Propagate the skipping flag to descendants.
2746 }
2753 // Propagate the sending-if-shown flag to descendants.
2755 }
2756 // We have asked accessibility service to remove the whole subtree
2757 // of element which becomes invisible from the accessible tree, but
2758 // this element is visible, so we need to add it back.
2761 // If we shouldn't skip in any case, we need to check whether our
2762 // own visibility has changed.
2766 }
2773 // We are adding the subtree. Accessibility service would handle
2774 // descendants, so we should just skip them from notifying.
2776 }
2777 // Remove the subtree of this invisible element, and ask any shown
2778 // descendant to add themselves back.
2781 }
2782 #endif
2785 }
2789 ServoPostTraversalFlags aFlags) {
2796 // NOTE(emilio): This is needed because for table frames the bit is set on the
2797 // table wrapper (which is the primary frame), not on the table itself.
2801 // We need this because any column-spanner's parent frame is not its DOM
2802 // parent's primary frame. We need some special check similar to out-of-flow
2803 // frames.
2807 // Grab the change hint from Servo.
2809 nsChangeHint changeHint =
2815 // We should really fix the weird primary frame mapping for image maps
2816 // (bug 135040)...
2820 }
2822 // Handle lazy frame construction by posting a reconstruct for any lazily-
2823 // constructed roots.
2827 }
2837 // Do not subsume change hints for the column-spanner.
2841 }
2842 }
2844 // If the parent wasn't restyled, the styles of our anon box parents won't
2845 // change either.
2850 }
2852 // If we don't have a ::marker pseudo-element, but need it, then
2853 // reconstruct the frame. (The opposite situation implies 'display'
2854 // changes so doesn't need to be handled explicitly here.)
2861 upToDateStyleIfRestyled);
2864 }
2865 }
2866 }
2868 // Although we shouldn't generate non-ReconstructFrame hints for elements with
2869 // no frames, we can still get them here if they were explicitly posted by
2870 // PostRestyleEvent, such as a RepaintFrame hint when a :link changes to be
2871 // :visited. Skip processing these hints if there is no frame.
2873 changeHint) {
2875 }
2877 // If our change hint is reconstruct, we delegate to the frame constructor,
2878 // which consumes the new style and expects the old style to be on the frame.
2879 //
2880 // XXXbholley: We should teach the frame constructor how to clear the dirty
2881 // descendants bit to avoid the traversal here.
2886 styleFrame &&
2889 // https://drafts.csswg.org/css-scroll-anchoring/#suppression-triggers
2890 //
2891 // We need to do the position check here rather than in
2892 // DidSetComputedStyle because changing position reframes.
2893 //
2894 // We suppress adjustments whenever we change from being display: none to
2895 // be an abspos.
2896 //
2897 // Similarly, for other changes from abspos to non-abspos styles.
2898 //
2899 // TODO(emilio): I _think_ chrome won't suppress adjustments whenever
2900 // `display` changes. But that causes some infinite loops in cases like
2901 // bug 1568778.
2904 }
2905 }
2908 }
2910 // TODO(emilio): We could avoid some refcount traffic here, specially in the
2911 // ComputedStyle case, which uses atomic refcounting.
2912 //
2913 // Hold the ComputedStyle alive, because it could become a dangling pointer
2914 // during the replacement. In practice it's not a huge deal, but better not
2915 // playing with dangling pointers if not needed.
2916 //
2917 // NOTE(emilio): We could keep around the old computed style for display:
2918 // contents elements too, but we don't really need it right now.
2923 "display: contents node has a frame, yet we didn't reframe it"
2929 }
2937 }
2939 // We can't really assume as used changes from display: contents elements (or
2940 // other elements without frames).
2947 ServoPostTraversalFlags childrenFlags =
2954 // We want to walk all the continuations here, even the ones with different
2955 // styles. In practice, the only reason we get continuations with different
2956 // styles here is ::first-line (::first-letter never affects element
2957 // styles). But in that case, newStyle is the right context for the
2958 // _later_ continuations anyway (the ones not affected by ::first-line), not
2959 // the earlier ones, so there is no point stopping right at the point when
2960 // we'd actually be setting the right ComputedStyle.
2961 //
2962 // This does mean that we may be setting the wrong ComputedStyle on our
2963 // initial continuations; ::first-line fixes that up after the fact.
2967 }
2971 }
2974 // This is the root. Update styles on the viewport as needed.
2978 // NB: The root restyle state, not the one for our children!
2980 }
2981 }
2983 // Some changes to animations don't affect the computed style and yet still
2984 // require the layer to be updated. For example, pausing an animation via
2985 // the Web Animations API won't affect an element's style but still
2986 // requires to update the animation on the layer.
2987 //
2988 // We can sometimes reach this when the animated style is being removed.
2989 // Since AddLayerChangesForAnimation checks if |styleFrame| has a transform
2990 // style or not, we need to call it *after* setting |newStyle| to
2991 // |styleFrame| to ensure the animated transform has been removed first.
2998 }
3009 childrenRestyleState);
3017 }
3018 }
3019 }
3021 // We want to update frame pseudo-element styles after we've traversed our
3022 // kids, because some of those updates (::first-line/::first-letter) need to
3023 // modify the styles of the kids, and the child traversal above would just
3024 // clobber those modifications.
3027 // Make sure to update anon boxes and pseudo bits after updating text,
3028 // otherwise ProcessPostTraversalForText could clobber first-letter
3029 // styles, for example.
3031 }
3032 // Process anon box wrapper frames before ::first-line bits, but _after_
3033 // owned anon boxes, since the children wrapper anon boxes could be
3034 // inheriting from our own owned anon boxes.
3040 // Even if we were not restyled, if we're a block with a first-line and
3041 // one of our descendant elements which is on the first line was restyled,
3042 // we need to update the styles of things on the first line, because
3043 // they're wrong now.
3044 //
3045 // FIXME(bz) Could we do better here? For example, could we keep track of
3046 // frames that are "block with a ::first-line so we could avoid
3047 // IsFrameOfType() and digging about for the first-line frame if not?
3048 // Could we keep track of whether the element children we actually restyle
3049 // are affected by first-line? Something else? Bug 1385443 tracks making
3050 // this better.
3056 }
3057 }
3058 }
3059 }
3063 }
3068 // Handle lazy frame construction.
3073 }
3075 // Handle restyle.
3079 }
3081 // If the parent wasn't restyled, the styles of our anon box parents won't
3082 // change either.
3087 }
3092 // We want to walk all the continuations here, even the ones with different
3093 // styles. In practice, the only reasons we get continuations with different
3094 // styles are ::first-line and ::first-letter. But in those cases,
3095 // newStyle is the right context for the _later_ continuations anyway (the
3096 // ones not affected by ::first-line/::first-letter), not the earlier ones,
3097 // so there is no point stopping right at the point when we'd actually be
3098 // setting the right ComputedStyle.
3099 //
3100 // This does mean that we may be setting the wrong ComputedStyle on our
3101 // initial continuations; ::first-line/::first-letter fix that up after the
3102 // fact.
3105 }
3108 }
3114 }
3115 }
3120 // NOTE(emilio): We can handle snapshots from a one-off restyle of those that
3121 // we do to restyle stuff for reconstruction, for example.
3122 //
3123 // It seems to be the case that we always flush in between that happens and
3124 // the next attribute change, so we can assert that we haven't handled the
3125 // snapshot here yet. If this assertion didn't hold, we'd need to unset that
3126 // flag from here too.
3127 //
3128 // Can't wait to make ProcessPendingRestyles the only entry-point for styling,
3129 // so this becomes much easier to reason about. Today is not that day though.
3136 // Now that we have a snapshot, make sure a restyle is triggered.
3139 }
3146 // FIXME(emilio): In the "flush animations" case, ideally, we should only
3147 // recascade animation styles running on the compositor, so we shouldn't care
3148 // about other styles, or new rules that apply to the page...
3149 //
3150 // However, that's not true as of right now, see bug 1388031 and bug 1388692.
3158 // PresShell::FlushPendingNotifications doesn't early-return in the case
3159 // where the PresShell hasn't yet been initialized (and therefore we haven't
3160 // yet done the initial style traversal of the DOM tree). We should arguably
3161 // fix up the callers and assert against this case, but we just detect and
3162 // handle it for now.
3164 }
3166 // It'd be bad!
3169 // Create a AnimationsWithDestroyedFrame during restyling process to
3170 // stop animations and transitions on elements that have no frame at the end
3171 // of the restyling process.
3177 // Ensure the refresh driver is active during traversal to avoid mutating
3178 // mActiveTimer and mMostRecentRefresh time.
3182 // This might post new restyles, so need to do it here. Don't do it if we're
3183 // already going to restyle tho, so that we don't potentially reflow with
3184 // dirty styling.
3187 }
3189 // Perform the Servo traversal, and the post-traversal if required. We do this
3190 // in a loop because certain rare paths in the frame constructor can trigger
3191 // additional style invalidations.
3192 //
3193 // FIXME(emilio): Confirm whether that's still true now that XBL is gone.
3197 }
3201 }
3206 // Select scroll anchors for frames that have been scrolled. Do this
3207 // before processing restyled frames so that anchor nodes are correctly
3208 // marked when directly moving frames with RecomputePosition.
3211 nsStyleChangeList currentChanges;
3214 // Recreate styles , and queue up change hints (which also handle lazy frame
3215 // construction).
3218 {
3223 anchorsToSuppress);
3226 }
3228 // We want to suppress adjustments the current (before-change) scroll
3229 // anchor container now, and save a reference to the content node so that
3230 // we can suppress them in the after-change scroll anchor .
3235 }
3236 }
3237 }
3238 }
3243 // Process the change hints.
3244 //
3245 // Unfortunately, the frame constructor can generate new change hints while
3246 // processing existing ones. We redirect those into a secondary queue and
3247 // iterate until there's nothing left.
3248 {
3249 ReentrantChangeList newChanges;
3257 // SVG Elements post change hints without ensuring that the primary
3258 // frame will be there after that (see bug 1366142).
3259 //
3260 // Just ignore those, since we can't really process them.
3262 }
3265 }
3267 }
3269 }
3271 // Suppress adjustments in the after-change scroll anchors if needed, now
3272 // that we're done reframing everything.
3277 }
3278 }
3279 }
3282 // Maybe no styles changed when:
3283 //
3284 // * Only explicit change hints were posted in the first place.
3285 // * When an attribute or state change in the content happens not to need
3286 // a restyle after all.
3287 //
3288 // In any case, we don't need to increment the restyle generation in that
3289 // case.
3291 }
3296 }
3307 // Now that everything has settled, see if we have enough free rule nodes in
3308 // the tree to warrant sweeping them.
3311 // Note: We are in the scope of |animationsWithDestroyedFrame|, so
3312 // |mAnimationsWithDestroyedFrame| is still valid.
3315 }
3317 #ifdef DEBUG
3325 }
3326 }
3327 #endif
3331 #ifdef DEBUG
3334 }
3335 #endif
3338 }
3343 }
3345 // Servo data for the element might have been dropped. (e.g. by removing
3346 // from its document)
3349 }
3350 }
3352 }
3358 }
3361 }
3364 ElementState aChangedBits) {
3365 #ifdef EARLY_BETA_OR_EARLIER
3370 }
3371 #endif
3376 // We'll restyle when the relevant visited query finishes, regardless of the
3377 // style (see Link::VisitedQueryFinished). So there's no need to do anything
3378 // as a result of this state change just yet.
3379 //
3380 // Note that this check checks for _both_ bits: This is only true when visited
3381 // changes to unvisited or vice-versa, but not when we start or stop being a
3382 // link itself.
3387 }
3388 }
3392 }
3394 // Don't bother taking a snapshot if no rules depend on these state bits.
3395 //
3396 // We always take a snapshot for the LTR/RTL event states, since Servo doesn't
3397 // track those bits in the same way, and we know that :dir() rules are always
3398 // present in UA style sheets.
3402 }
3404 // Assuming we need to invalidate cached style in getComputedStyle for
3405 // undisplayed elements, since we don't know if it is needed.
3410 }
3419 }
3423 ElementState aChangedBits) {
3429 }
3433 }
3434 }
3438 // We must record some state for :-moz-browser-frame,
3439 // :-moz-table-border-nonzero, and :-moz-select-list-box.
3442 }
3446 }
3450 }
3453 }
3462 // If the attribute influences one of the pseudo-classes that are backed by
3463 // attributes, we just record it.
3466 }
3468 // We assume that id and class attributes are used in class/id selectors, and
3469 // thus record them.
3470 //
3471 // TODO(emilio): We keep a filter of the ids in use somewhere in the StyleSet,
3472 // presumably we could try to filter the old and new id, but it's not clear
3473 // it's worth it.
3477 }
3479 // We always record lang="", even though we force a subtree restyle when it
3480 // changes, since it can change how its siblings match :lang(..) due to
3481 // selectors like :lang(..) + div.
3484 }
3486 // Otherwise, just record the attribute change if a selector in the page may
3487 // reference it from an attribute selector.
3489 }
3495 }
3500 }
3511 }
3513 // We cannot tell if the attribute change will affect the styles of
3514 // undisplayed elements, because we don't actually restyle those elements
3515 // during the restyle traversal. So just assume that the attribute change can
3516 // cause the style to change.
3519 // Relative selector invalidation travels ancestor and earlier sibling
3520 // direction, so it's very possible that it invalidates a styled element.
3525 }
3527 // Some other random attribute changes may also affect the transitions,
3528 // so we also set this true here.
3536 }
3537 }
3539 // For some attribute changes we must restyle the whole subtree:
3540 //
3541 // * lang="" and xml:lang="" can affect all descendants due to :lang()
3542 // * exportparts can affect all descendant parts. We could certainly integrate
3543 // it better in the invalidation machinery if it was necessary.
3547 // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for
3548 // exportparts attribute changes?
3550 }
3552 }
3572 // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for part
3573 // attribute changes?
3575 }
3578 // See if we have appearance information for a theme.
3579 StyleAppearance appearance =
3589 }
3590 }
3591 }
3594 }
3598 }
3601 // Assuming we need to invalidate cached style in getComputedStyle for
3602 // undisplayed elements, since we don't know if it is needed.
3605 // If we change attributes, we have to mark this to be true, so we will
3606 // increase the animation generation for the new created transition if any.
3608 }
3609 }
3612 NodeSelectorFlags aParentFlags) {
3615 }
3624 }
3627 }
3635 mightHaveNthOfDependency =
3640 mightHaveNthOfDependency =
3642 }
3646 }
3647 }
3653 }
3667 }
3668 }
3674 }
3677 }
3680 // This is only called when moving frames in or out of the first-line
3681 // pseudo-element (or one of its descendants). We can't say much about
3682 // aFrame's ancestors, unfortunately (e.g. during a dynamic insert into
3683 // something inside an inline-block on the first line the ancestors could be
3684 // totally arbitrary), but we will definitely find a line frame on the
3685 // ancestor chain. Note that the lineframe may not actually be the one that
3686 // corresponds to ::first-line; when we're moving _out_ of the ::first-line it
3687 // will be one of the continuations instead.
3688 #ifdef DEBUG
3689 {
3693 }
3695 }
3696 #endif
3699 }
3705 }
3707 }
3712 // Style context of backdrop frame has no parent style, and thus we do not
3713 // need to reparent it.
3715 }
3718 // We're entering a display: none subtree, which we know it's going to get
3719 // rebuilt. Don't bother reparenting.
3721 }
3724 // Also reparent the out-of-flow and all its continuations. We're doing
3725 // this to match Gecko for now, but it's not clear that this behavior is
3726 // correct per spec. It's certainly pretty odd for out-of-flows whose
3727 // containing block is not within the first line.
3728 //
3729 // Right now we're somewhat inconsistent in this testcase:
3730 //
3731 // <style>
3732 // div { color: orange; clear: left; }
3733 // div::first-line { color: blue; }
3734 // </style>
3735 // <div>
3736 // <span style="float: left">What color is this text?</span>
3737 // </div>
3738 // <div>
3739 // <span><span style="float: left">What color is this text?</span></span>
3740 // </div>
3741 //
3742 // We make the first float orange and the second float blue. On the other
3743 // hand, if the float were within an inline-block that was on the first
3744 // line, arguably it _should_ inherit from the ::first-line...
3750 }
3751 }
3753 // FIXME(emilio): This is the only caller of GetParentComputedStyle, let's try
3754 // to remove it?
3758 // If our provider is our child, we want to reparent it first, because we
3759 // inherit style from it.
3764 // Get the style again after ReparentComputedStyle() which might have
3765 // changed it.
3770 }
3773 // No need to do anything here for this frame, but we should still reparent
3774 // its descendants, because those may have styles that inherit from the
3775 // parent of this frame (e.g. non-anonymous columns in an anonymous
3776 // colgroup).
3781 }
3785 // We probably don't want to initiate transitions from ReparentComputedStyle,
3786 // since we call it during frame construction rather than in response to
3787 // dynamic changes.
3788 // Also see the comment at the start of
3789 // nsTransitionManager::ConsiderInitiatingTransition.
3790 //
3791 // We don't try to do the fancy copying from previous continuations that
3792 // GeckoRestyleManager does here, because that relies on knowing the parents
3793 // of ComputedStyles, and we don't know those.
3799 // No providerFrame means we inherited from a display:contents thing. Our
3800 // layout parent style is the style of our nearest ancestor frame. But we
3801 // have to be careful to do that with our placeholder, not with us, if we're
3802 // out of flow.
3810 }
3811 }
3818 // This logic somewhat mirrors the logic in
3819 // RestyleManager::ProcessPostTraversal.
3821 // We can't use UpdateAdditionalComputedStyles as-is because it needs a
3822 // ServoRestyleState and maintaining one of those during a _frametree_
3823 // traversal is basically impossible.
3832 }
3833 }
3835 // Generally, owned anon boxes are our descendants. The only exceptions are
3836 // tables (for the table wrapper) and inline frames (for the block part of the
3837 // block-in-inline split). We're going to update our descendants when looping
3838 // over kids, and we don't want to update the block part of a block-in-inline
3839 // split if the inline is on the first line but the block is not (and if the
3840 // block is, it's the child of something else on the first line and will get
3841 // updated as a child). And given how this method ends up getting called, if
3842 // we reach here for a table frame, we are already in the middle of
3843 // reparenting the table wrapper frame. So no need to
3844 // UpdateStyleOfOwnedAnonBoxes() here.
3848 // We do not need to do the equivalent of UpdateFramePseudoElementStyles,
3849 // because those are handled by our descendant walk.
3850 }
3857 // only do frames that are in flow
3861 }
3862 }
3863 }
3864 }