| blob | 81ffebf89a575b34c3f350c878d26b5fabd33878 |
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
105 }
107 // The container cannot be a document.
111 // see whether we need to restyle the container
115 // We don't know whether we're testing :empty or :-moz-only-whitespace,
116 // so be conservative and assume :-moz-only-whitespace (i.e., make
117 // IsSignificantChild less likely to be true, and thus make us more
118 // likely to restyle).
122 }
123 }
127 }
128 }
138 }
142 }
143 // Restyling the container is the most we can do here, so we're done.
145 }
148 // restyle the last element child before this node
158 }
159 }
160 }
161 }
168 }
169 }
170 }
177 }
178 }
179 }
185 // In some cases (:empty + E, :empty ~ E), a change in the content of
186 // an element requires restyling its parent's siblings.
191 }
193 }
200 // restyle the previously-first element child if it is after this node
207 }
215 }
217 }
218 }
219 // restyle the previously-last element child if it is before this node
226 }
234 }
236 }
237 }
238 }
245 }
246 }
248 }
255 // The old text was already not whitespace-only.
257 }
260 }
268 }
269 // We don't know whether we're testing :empty or :-moz-only-whitespace,
270 // so be conservative and assume :-moz-only-whitespace (i.e., make
271 // IsSignificantChild less likely to be true, and thus make us more
272 // likely to restyle).
275 }
276 }
279 }
290 // Nothing to do, no other slow selector can change as a result of this.
292 }
295 // Doesn't matter to styling (could be a processing instruction or a
296 // comment), it can't change whether any selectors match or don't.
298 }
303 }
306 // This is an anonymous node and thus isn't in child lists, so isn't taken
307 // into account for selector matching the relevant selectors here.
309 }
311 // Handle appends specially since they're common and we can know both the old
312 // and the new text exactly.
313 //
314 // TODO(emilio): This could be made much more general if :-moz-only-whitespace
315 // / :-moz-first-node and :-moz-last-node didn't exist. In that case we only
316 // need to know whether we went from empty to non-empty, and that's trivial to
317 // know, with CharacterDataChangeInfo...
319 // FIXME(emilio): This restyles unnecessarily if the text node is the only
320 // child of the parent element. Fortunately, it's uncommon to have such
321 // nodes and this not being an append.
322 //
323 // See the testcase in bug 1427625 for a test-case that triggers this.
326 }
342 }
346 // We used to be empty, restyle the parent.
349 }
350 }
354 }
355 }
357 // Restyling for a ContentInserted or CharacterDataChanged notification.
358 // This could be used for ContentRemoved as well if we got the
359 // notification before the removal happened (and sometimes
360 // CharacterDataChanged is more like a removal than an addition).
361 // The comments are written and variables are named in terms of it being
362 // a ContentInserted notification.
371 }
376 // The container cannot be a document.
381 // See whether we need to restyle the container due to :empty /
382 // :-moz-only-whitespace.
386 // FIXME(emilio): When coming from CharacterDataChanged this can restyle
387 // unnecessarily. Also can restyle unnecessarily if aChild is not
388 // significant anyway, though that's more unlikely.
391 }
392 }
402 }
406 }
407 // Restyling the container is the most we can do here, so we're done.
409 }
412 // Restyle all later siblings.
417 }
418 }
422 }
423 }
430 // Computed style data isn't useful for detached nodes, and we'll need to
431 // recompute it anyway if we ever insert the nodes back into a document.
434 // If this element is undisplayed or may have undisplayed descendants, we
435 // need to invalidate the cache, since there's the unlikely event of those
436 // elements getting destroyed and their addresses reused in a way that we
437 // look up the cache with their address for a different element before it's
438 // invalidated.
440 }
443 aFollowingSibling);
444 }
450 }
453 // This should be an assert, but this is called incorrectly in
454 // HTMLEditor::DeleteRefToAnonymousNode and the assertions were clogging
455 // up the logs. Make it an assert again when that's fixed.
458 }
460 // The container cannot be a document.
465 // see whether we need to restyle the container
469 // We don't know whether we're testing :empty or :-moz-only-whitespace,
470 // so be conservative and assume :-moz-only-whitespace (i.e., make
471 // IsSignificantChild less likely to be true, and thus make us more
472 // likely to restyle).
476 }
477 }
481 }
482 }
492 }
496 }
497 // Restyling the container is the most we can do here, so we're done.
499 }
502 // Restyle all later siblings.
511 nextSibling);
512 }
513 }
516 // restyle the now-first element child if it was after aOldChild
522 // do NOT continue here; we might want to restyle this node
523 }
531 }
533 }
534 }
535 // restyle the now-last element child if it was before aOldChild
546 }
548 }
551 }
552 }
553 }
554 }
558 ElementState aStates) {
562 }
565 // If it's other generated content, ignore state changes on it.
567 }
570 // Broken affects object fallback behavior.
572 }
577 }
580 }();
584 }
590 }
593 ElementState aStateMask) {
597 // The checkbox inside these elements inherit hover state and so on, see
598 // nsNativeTheme::GetContentState.
599 // FIXME(emilio): Would be nice to not have these hard-coded.
601 }
605 }
610 }
614 }
616 /**
617 * Calculates the change hint and the restyle hint for a given content state
618 * change.
619 */
621 ElementState aStateMask) {
624 // Any change to a content state that affects which frames we construct
625 // must lead to a frame reconstruct here if we already have a frame.
626 // Note that we never decide through non-CSS means to not create frames
627 // based on content states, so if we already don't have a frame we don't
628 // need to force a reframe -- if it's needed, the HasStateDependentStyle
629 // call will handle things.
633 }
636 }
638 }
641 // Exposing information to the page about whether the link is
642 // visited or not isn't really something we can worry about here.
643 // FIXME: We could probably do this a bit better.
645 }
647 // This changes the applicable text-transform in the editor root.
649 // This is the same change hint as tweaking text-transform.
651 }
654 }
656 #ifdef DEBUG
657 /* static */
659 nsCString result;
702 nsChangeHint_AllReflowHints) {
710 }
715 }
718 }
719 }
723 }
728 }
729 }
731 }
732 #endif
734 /**
735 * Frame construction helpers follow.
736 */
737 #ifdef DEBUG
739 #endif
741 /**
742 * Sync views on the frame and all of it's descendants (following placeholders).
743 * The change hint should be some combination of nsChangeHint_RepaintFrame,
744 * nsChangeHint_UpdateOpacityLayer and nsChangeHint_SchedulePaint, nothing else.
745 */
750 /**
751 * This helper function is used to find the correct SVG frame to target when we
752 * encounter nsChangeHint_ChildrenOnlyTransform; needed since sometimes we end
753 * up handling that hint while processing hints for one of the SVG frame's
754 * ancestor frames.
755 *
756 * The reason that we sometimes end up trying to process the hint for an
757 * ancestor of the SVG frame that the hint is intended for is due to the way we
758 * process restyle events. ApplyRenderingChangeToTree adjusts the frame from
759 * the restyled element's principle frame to one of its ancestor frames based
760 * on what nsCSSRendering::FindBackground returns, since the background style
761 * may have been propagated up to an ancestor frame. Processing hints using an
762 * ancestor frame is fine in general, but nsChangeHint_ChildrenOnlyTransform is
763 * a special case since it is intended to update a specific frame.
764 */
767 // This happens if the root-<svg> is fixed positioned, in which case we
768 // can't use aFrame->GetContent() to find the primary frame, since
769 // GetContent() returns nullptr for ViewportFrame.
771 }
772 // For an nsHTMLScrollFrame, this will get the SVG frame that has the
773 // children-only transforms:
779 }
783 }
785 // This function tries to optimize a position style change by either
786 // moving aFrame or ignoring the style change when it's safe to do so.
787 // It returns true when that succeeds, otherwise it posts a reflow request
788 // and returns false.
790 // It's pointless to move around frames that have never been reflowed or
791 // are dirty (i.e. they will be reflowed), or aren't affected by position
792 // styles.
794 NS_FRAME_SVG_LAYOUT)) {
796 }
798 // Don't process position changes on table frames, since we already handle
799 // the dynamic position change on the table wrapper frame, and the
800 // reflow-based fallback code path also ignores positions on inner table
801 // frames.
804 }
807 // Changes to the offsets of a non-positioned element can safely be ignored.
810 }
812 // Don't process position changes on frames which have views or the ones which
813 // have a view somewhere in their descendants, because the corresponding view
814 // needs to be repositioned properly as well.
818 }
821 // If the frame has an intrinsic block-size, we resolve its 'auto' margins
822 // after doing layout, since we need to know the frame's block size. See
823 // nsAbsoluteContainingBlock::ResolveAutoMarginsAfterLayout().
824 //
825 // Since the size of the frame doesn't change, we could modify the below
826 // computation to compute the margin correctly without doing a full reflow,
827 // however we decided to try doing a full reflow for now.
833 }
834 }
835 // Flexbox and Grid layout supports CSS Align and the optimizations below
836 // don't support that yet.
840 }
841 }
843 // If we need to reposition any descendant that depends on our static
844 // position, then we also can't take the optimized path.
845 //
846 // TODO(emilio): It may be worth trying to find them and try to call
847 // RecomputePosition on them too instead of disabling the optimization...
850 }
858 }
860 // We need to trigger re-snapping to this content if we snapped to the
861 // content on the last scroll operation.
863 };
865 // For relative positioning, we can simply update the frame rect
868 // A grid item's CB is its grid area, not the parent frame content area
869 // as is assumed below.
871 }
872 // Move the frame
874 // Update sticky positioning for an entire element at once, starting with
875 // the first continuation or ib-split sibling.
876 // It's rare that the frame we already have isn't already the first
877 // continuation or ib-split sibling, but it can happen when styles differ
878 // across continuations such as ::first-line or ::first-letter, and in
879 // those cases we will generally (but maybe not always) do the work twice.
886 firstContinuation);
889 }
902 // ReflowInput::ApplyRelativePositioning would work here, but
903 // since we've already checked mPosition and aren't changing the frame's
904 // normal position, go ahead and add the offsets directly.
905 // First, we need to ensure that the normal position is stored though.
910 }
913 }
914 }
918 }
920 // For the absolute positioning case, set up a fake HTML reflow input for
921 // the frame, and then get the offsets and size from it. If the frame's size
922 // doesn't need to change, we can simply update the frame position. Otherwise
923 // we fall back to a reflow.
927 // Construct a bogus parent reflow input so that there's a usable reflow input
928 // for the containing block.
936 parentSize);
940 // The bogus parent state here was created with no parent state of its own,
941 // and therefore it won't have an mCBReflowInput set up.
942 // But we may need one (for InitCBReflowInput in a child state), so let's
943 // try to create one here for the cases where it will be needed.
958 }
975 nsSize cbSize =
976 viewport
992 }
995 // The RecomputePosition hint is not used if any offset changed between auto
996 // and non-auto. If computedSize.height == NS_UNCONSTRAINEDSIZE then the new
997 // element height will be its intrinsic height, and since 'top' and 'bottom''s
998 // auto-ness hasn't changed, the old height must also be its intrinsic
999 // height, which we can assume hasn't changed (or reflow would have
1000 // been triggered).
1004 // If we're solving for 'left' or 'top', then compute it here, in order to
1005 // match the reflow code path.
1006 //
1007 // TODO(emilio): It'd be nice if this did logical math instead, but it seems
1008 // to me the math should work out on vertical writing modes as well. See Bug
1009 // 1675861 for some hints.
1015 left =
1017 }
1023 }
1025 // Move the frame
1032 }
1034 // Fall back to a reflow
1036 }
1038 /**
1039 * Return true if aFrame's subtree has placeholders for out-of-flow content
1040 * that would be affected due to the change to
1041 * `aPossiblyChangingContainingBlock` (and thus would need to get reframed).
1042 *
1043 * In particular, this function returns true if there are placeholders whose OOF
1044 * frames may need to be reparented (via reframing) as a result of whatever
1045 * change actually happened.
1046 *
1047 * The `aIs{Abs,Fixed}PosContainingBlock` params represent whether
1048 * `aPossiblyChangingContainingBlock` is a containing block for abs pos / fixed
1049 * pos stuff, respectively, for the _new_ style that the frame already has, not
1050 * the old one.
1051 */
1055 // All fixed-pos containing blocks should also be abs-pos containing blocks.
1062 // If SVG text frames could appear here, they could confuse us since
1063 // they ignore their position style ... but they can't.
1066 // Top-layer frames don't change containing block based on direct
1067 // ancestors.
1072 aIsFixedPosContainingBlock ||
1075 // NOTE(emilio): aPossiblyChangingContainingBlock is guaranteed to be
1076 // a first continuation, see the assertion in the caller.
1079 // If we are becoming a containing block, we only need to reframe if
1080 // this oof's current containing block is an ancestor of the new
1081 // frame.
1086 }
1088 // If we are not a containing block anymore, we only need to reframe
1089 // if we are the current containing block of the oof frame.
1092 }
1093 }
1094 }
1095 }
1096 // NOTE: It's tempting to check f->IsAbsPosContainingBlock() or
1097 // f->IsFixedPosContainingBlock() here. However, that would only
1098 // be testing the *new* style of the frame, which might exclude
1099 // descendants that currently have this frame as an abs-pos
1100 // containing block. Taking the codepath where we don't reframe
1101 // could lead to an unsafe call to
1102 // cont->MarkAsNotAbsoluteContainingBlock() before we've reframed
1103 // the descendant and taken it off the absolute list.
1106 aIsFixedPosContainingBlock)) {
1108 }
1109 }
1110 }
1112 }
1114 // Returns the frame that would serve as the containing block for aFrame's
1115 // positioned descendants, if aFrame had styles to make it a CB for such
1116 // descendants. (Typically this is just aFrame itself, or its insertion frame).
1117 //
1118 // Returns nullptr if this frame can't be easily determined.
1121 // FIXME: This should be easily implementable.
1123 }
1127 }
1128 // Generally frames with a different insertion frame are hard to deal with,
1129 // but scrollframes are easy because the containing block is just the
1130 // insertion frame.
1133 }
1134 // Combobox frames are easy as well because they can't have positioned
1135 // children anyways.
1136 // Button and table cell frames are also easy because the containing block is
1137 // the frame itself.
1141 }
1143 }
1147 // NOTE: This looks at the new style.
1157 isAbsPosContainingBlock,
1158 isFixedContainingBlock)) {
1160 }
1161 }
1163 }
1166 nsChangeHint aChange) {
1172 // Invalidate and sync views on all descendant frames, following
1173 // placeholders. We don't need to update transforms in
1174 // SyncViewsAndInvalidateDescendants, because there can't be any
1175 // out-of-flows or popups that need to be transformed; all out-of-flow
1176 // descendants of the transformed element must also be descendants of the
1177 // transformed frame.
1180 nsChangeHint_UpdateOpacityLayer |
1181 nsChangeHint_SchedulePaint)));
1182 // This must be set to true if the rendering change needs to
1183 // invalidate content. If it's false, a composite-only paint
1184 // (empty transaction) will be scheduled.
1187 // if frame has view, will already be invalidated
1189 // Note that this whole block will be skipped when painting is suppressed
1190 // (due to our caller ApplyRendingChangeToTree() discarding the
1191 // nsChangeHint_RepaintFrame hint). If you add handling for any other
1192 // hints within this block, be sure that they too should be ignored when
1193 // painting is suppressed.
1198 // Need to update our overflow rects:
1200 }
1203 }
1205 // FIXME/bug 796697: we can get away with empty transactions for
1206 // opacity updates in many cases.
1211 // SVG effects paints the opacity without using
1212 // nsDisplayOpacity. We need to invalidate manually.
1214 }
1215 }
1218 // Note: All the transform-like properties should map to the same
1219 // layer activity index, so does the restyle count. Therefore, using
1220 // eCSSProperty_transform should be fine.
1223 }
1230 // Note: All the transform-like properties should map to the same
1231 // layer activity index, so does the restyle count. Therefore, using
1232 // eCSSProperty_transform should be fine.
1234 }
1235 }
1238 }
1242 }
1243 }
1246 nsChangeHint aChange) {
1252 nsChangeHint_UpdateOpacityLayer |
1253 nsChangeHint_SchedulePaint)),
1261 // only do frames that don't have placeholders
1263 // do the out-of-flow frame and its continuations
1271 }
1272 }
1273 }
1274 }
1275 }
1278 nsChangeHint aChange) {
1279 // We check StyleDisplay()->HasTransformStyle() in addition to checking
1280 // IsTransformed() since we can get here for some frames that don't support
1281 // CSS transforms, and table frames, which are their own odd-ball, since the
1282 // transform is handled by their wrapper, which _also_ gets a separate hint.
1289 // Don't allow synchronous rendering changes when painting is turned off.
1293 }
1294 }
1296 // Trigger rendering updates by damaging this frame and any
1297 // continuations of this frame.
1298 #ifdef DEBUG
1300 #endif
1302 // If the frame is the primary frame of either the body element or
1303 // the html element, we propagate the repaint change hint to the
1304 // viewport. This is necessary for background and scrollbar colors
1305 // propagation.
1313 }
1314 }
1315 }
1317 #ifdef DEBUG
1319 #endif
1320 }
1327 }
1331 }
1332 }
1333 }
1336 IntrinsicDirty dirtyType;
1345 NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
1351 }
1355 }
1357 nsFrameState dirtyBits;
1365 }
1367 // If we're not going to clear any intrinsic sizes on the frames, and
1368 // there are no dirty bits to set, then there's nothing to do.
1371 ReflowRootHandling rootHandling;
1376 }
1380 rootHandling);
1383 }
1385 // Get the next sibling which might have a frame. This only considers siblings
1386 // that stylo post-traversal looks at, so only elements and text. In
1387 // particular, it ignores comments.
1393 }
1394 }
1397 }
1399 // If |aFrame| is dirty or has dirty children, then we can skip updating
1400 // overflows since that will happen when it's reflowed.
1403 NS_FRAME_HAS_DIRTY_CHILDREN);
1404 }
1412 }
1416 }
1422 // Only bother with this if we're the root or the body element, since:
1423 // (a) It'd be *expensive* to reframe these particular nodes. They're
1424 // at the root, so reframing would mean rebuilding the world.
1425 // (b) It's often *unnecessary* to reframe for "overflow" changes on
1426 // these particular nodes. In general, the only reason we reframe
1427 // for "overflow" changes is so we can construct (or destroy) a
1428 // scrollframe & scrollbars -- and the html/body nodes often don't
1429 // need their own scrollframe/scrollbars because they coopt the ones
1430 // on the viewport (which always exist). So depending on whether
1431 // that's happening, we can skip the reframe for these nodes.
1433 // If the restyled element provided/provides the scrollbar styles for
1434 // the viewport before and/or after this restyle, AND it's not coopting
1435 // that responsibility from some other element (which would need
1436 // reconstruction to make its own scrollframe now), THEN: we don't need
1437 // to reconstruct - we can just reflow, because no scrollframe is being
1438 // added/removed.
1445 }
1447 };
1451 // If we get here, the restyled element provided the scrollbar styles
1452 // for viewport before this restyle, OR it will provide them after.
1454 // If we get here, the restyled element is NOT replacing (or being
1455 // replaced by) some other element as the viewport's
1456 // scrollbar-styles provider. (If it were, we'd potentially need to
1457 // reframe to create a dedicated scrollframe for whichever element
1458 // is being booted from providing viewport scrollbar styles.)
1459 //
1460 // Under these conditions, we're OK to assume that this "overflow"
1461 // change only impacts the root viewport's scrollframe, which
1462 // already exists, so we can simply reflow instead of reframing.
1468 }
1471 // If we changed the override element, we need to reconstruct as the old
1472 // override element might start / stop being scrollable.
1474 }
1476 }
1477 }
1483 // Once we've created scrollbars for a frame, don't bother reconstructing
1484 // it just to remove them if we still need a scroll frame.
1487 }
1489 // input / textarea for the most part don't honor overflow themselves, the
1490 // editor root will deal with the change if needed.
1491 // However the textarea intrinsic size relies on GetDesiredScrollbarSizes(),
1492 // so we need to reflow the textarea itself, not just the inner control.
1496 // Something changed, but we don't have nor will have a scroll frame,
1497 // there's nothing to do here.
1499 }
1501 // Oh well, we couldn't optimize it out, just reconstruct frames for the
1502 // subtree.
1504 }
1510 }
1513 }
1518 // The frame has positioned children that need to be reparented, or it can't
1519 // easily be converted to/from being an abs-pos container correctly.
1522 }
1525 // The absolute container should be containingBlock.
1528 // Normally frame construction would set state bits as needed,
1529 // but we're not going to reconstruct the frame so we need to set
1530 // them. It's because we need to set this state on each affected frame
1531 // that we can't coalesce nsChangeHint_UpdateContainingBlock hints up
1532 // to ancestors (i.e. it can't be an change hint that is handled for
1533 // descendants).
1538 }
1541 // If |cont| still has absolutely positioned children,
1542 // we can't call MarkAsNotAbsoluteContainingBlock. This
1543 // will remove a frame list that still has children in
1544 // it that we need to keep track of.
1545 // The optimization of removing it isn't particularly
1546 // important, although it does mean we skip some tests.
1550 }
1551 }
1552 }
1553 }
1559 // See bug 1378219 comment 9:
1560 // Recursive calls here are a bit worrying, but apparently do happen in the
1561 // wild (although not currently in any of our automated tests). Try to get a
1562 // stack from Nightly/Dev channel to figure out what's going on and whether
1563 // it's OK.
1568 }
1570 // If mDestroyedFrames is null, we want to create a new hashtable here
1571 // and destroy it on exit; but if it is already non-null (because we're in
1572 // a recursive call), we will continue to use the existing table to
1573 // accumulate destroyed frames, and NOT clear mDestroyedFrames on exit.
1574 // We use a MaybeClearDestroyedFrames helper to conditionally reset the
1575 // mDestroyedFrames pointer when this method returns.
1586 {}
1590 }
1591 }
1592 };
1597 }
1607 // Collect and coalesce adjacent siblings for lazy frame construction.
1608 // Eventually it would be even better to make RecreateFramesForContent
1609 // accept a range and coalesce all adjacent reconstructs (bug 1344139).
1619 }
1630 }
1631 }
1635 }
1638 }
1650 // skip any frame that has been destroyed due to a ripple effect
1653 }
1656 // XXXbz this is due to image maps messing with the primary frame of
1657 // <area>s. See bug 135040. Remove this block once that's fixed.
1661 }
1662 }
1668 // If we ever start passing true here, be careful of restyles
1669 // that involve a reframe and animations. In particular, if the
1670 // restyle we're processing here is an animation restyle, but
1671 // the style resolution we will do for the frame construction
1672 // happens async when we're not in an animation restyle already,
1673 // problems could arise.
1674 // We could also have problems with triggering of CSS transitions
1675 // on elements whose frames are reconstructed, since we depend on
1676 // the reconstruction happening synchronously.
1680 }
1688 }
1689 // Don't remove NS_FRAME_MAY_BE_TRANSFORMED since it may still be
1690 // transformed by other means. It's OK to have the bit even if it's
1691 // not needed.
1692 }
1693 // When dropping a running transform animation we will first add an
1694 // nsChangeHint_UpdateTransformLayer hint as part of the animation-only
1695 // restyle. During the subsequent regular restyle, if the animation was
1696 // the only reason the element had any transform applied, we will add
1697 // nsChangeHint_AddOrRemoveTransform as part of the regular restyle.
1698 //
1699 // With the Gecko backend, these two change hints are processed
1700 // after each restyle but when using the Servo backend they accumulate
1701 // and are processed together after we have already removed the
1702 // transform as part of the regular restyle. Since we don't actually
1703 // need the nsChangeHint_UpdateTransformLayer hint if we already have
1704 // a nsChangeHint_AddOrRemoveTransform hint, and since we
1705 // will fail an assertion in ApplyRenderingChangeToTree if we try
1706 // specify nsChangeHint_UpdateTransformLayer but don't have any
1707 // transform style, we just drop the unneeded hint here.
1709 }
1712 // frame does not maintain overflow rects, so avoid calling
1713 // FinishAndStoreOverflow on it:
1714 hint &=
1716 nsChangeHint_UpdatePostTransformOverflow |
1717 nsChangeHint_UpdateParentOverflow |
1718 nsChangeHint_UpdateSubtreeOverflow);
1719 }
1722 // Frame can not be transformed, and thus a change in transform will
1723 // have no effect and we should not use either
1724 // nsChangeHint_UpdatePostTransformOverflow or
1725 // nsChangeHint_UpdateTransformLayerhint.
1727 nsChangeHint_UpdateTransformLayer);
1728 }
1733 }
1739 }
1743 }
1745 // Here we need to propagate repaint frame change hint instead of update
1746 // opacity layer change hint when we do opacity optimization for SVG.
1747 // We can't do it in nsStyleEffects::CalcDifference() just like we do
1748 // for the optimization for 0.99 over opacity values since we have no way
1749 // to call SVGUtils::CanOptimizeOpacity() there.
1754 }
1758 "should only return UpdateUsesOpacity hint "
1760 // When an internal table part (including cells) changes between
1761 // having opacity 1 and non-1, it changes whether its
1762 // backgrounds (and those of table parts inside of it) are
1763 // painted as part of the table's nsDisplayTableBorderBackground
1764 // display item, or part of its own display item. That requires
1765 // invalidation, so change UpdateOpacityLayer to RepaintFrame.
1768 }
1770 // Opacity disables preserve-3d, so if we toggle it, then we also need
1771 // to update the overflow areas of all potentially affected frames.
1776 }
1779 // For most frame types, DLBI can detect background position changes,
1780 // so we only need to schedule a paint.
1783 // Table parts and MathML frames don't build display items for their
1784 // backgrounds, so DLBI can't detect background-position changes for
1785 // these frames. Repaint the whole frame.
1787 }
1788 }
1792 nsChangeHint_UpdateTransformLayer |
1795 }
1798 nsChangeHint_AddOrRemoveTransform)) {
1799 // We need to trigger re-snapping to this content if we snapped to the
1800 // content on the last scroll operation.
1802 }
1805 // It is possible for this to fall back to a reflow
1808 nsChangeHint_ReflowChangesSizeOrPosition);
1810 }
1811 }
1817 nsChangeHint_UpdatePostTransformOverflow |
1818 nsChangeHint_UpdateParentOverflow |
1819 nsChangeHint_UpdateSubtreeOverflow))) {
1824 }
1825 // The work we just did in AddSubtreeToOverflowTracker
1826 // subsumes some of the other hints:
1828 nsChangeHint_UpdatePostTransformOverflow);
1829 }
1831 // We need to update overflows. The correct frame(s) to update depends
1832 // on whether the ChangeHint came from an outer or an inner svg.
1835 "SVG frames should not have continuations "
1839 "SVG frames should not have continuations "
1842 // The children only transform of an outer svg frame is applied to
1843 // the outer svg's anonymous child frame (instead of to the
1844 // anonymous child's children).
1849 }
1851 // The children only transform is applied to the child frames of an
1852 // inner svg frame, so update the child overflows.
1860 }
1863 "SVG frames should not have continuations "
1868 }
1869 }
1870 }
1873 nsChangeHint_UpdatePostTransformOverflow)) {
1875 // If we have both nsChangeHint_UpdateOverflow and
1876 // nsChangeHint_UpdatePostTransformOverflow,
1877 // CHILDREN_CHANGED is selected as it is
1878 // strictly stronger.
1883 }
1885 cont =
1888 }
1889 }
1890 // UpdateParentOverflow hints need to be processed in addition
1891 // to the above, since if the processing of the above hints
1892 // yields no change, the update will not propagate to the
1893 // parent.
1898 cont =
1902 }
1903 }
1904 }
1905 }
1909 }
1912 }
1915 }
1916 }
1920 }
1922 /* static */
1926 }
1929 // We update the animation generation at start of each call to
1930 // ProcessPendingRestyles so we should ignore any subsequent (redundant)
1931 // calls that occur while we are still processing restyles.
1934 }
1935 }
1937 /* static */
1945 }
1956 // If we have a transform layer but don't have any transform style, we
1957 // probably just removed the transform but haven't destroyed the layer
1958 // yet. In this case we will typically add the appropriate change hint
1959 // (nsChangeHint_UpdateContainingBlock) when we compare styles so in
1960 // theory we could skip adding any change hint here.
1961 //
1962 // However, sometimes when we compare styles we'll get no change. For
1963 // example, if the transform style was 'none' when we sent the transform
1964 // animation to the compositor and the current transform style is now
1965 // 'none' we'll think nothing changed but actually we still need to
1966 // trigger an update to clear whatever style the transform animation set
1967 // on the compositor. To handle this case we simply set all the change
1968 // hints relevant to removing transform style (since we don't know exactly
1969 // what changes happened while the animation was running on the
1970 // compositor).
1971 //
1972 // Note that we *don't* add nsChangeHint_UpdateTransformLayer since if we
1973 // did, ApplyRenderingChangeToTree would complain that we're updating a
1974 // transform layer without a transform.
1977 // Add all the hints for a removing a transform if they are not already
1978 // set for this frame.
1980 aHintForThisFrame))) {
1982 }
1984 }
1986 }
1988 // We consider it's the first paint for the frame if we have an animation
1989 // for the property but have no layer, for the case of WebRender, no
1990 // corresponding animation info.
1991 // Note that in case of animations which has properties preventing running
1992 // on the compositor, e.g., width or height, corresponding layer is not
1993 // created at all, but even in such cases, we normally set valid change
1994 // hint for such animations in each tick, i.e. restyles in each tick. As
1995 // a result, we usually do restyles for such animations in every tick on
1996 // the main-thread. The only animations which will be affected by this
1997 // explicit change hint are animations that have opacity/transform but did
1998 // not have those properies just before. e.g, setting transform by
1999 // setKeyframes or changing target element from other target which prevents
2000 // running on the compositor, etc.
2002 nsChangeHint hintForDisplayItem =
2004 // We don't need to apply the corresponding change hint if we already have
2005 // it.
2008 }
2013 }
2018 }
2019 }
2021 };
2025 maybeApplyChangeHint);
2028 // We apply the hint to the primary frame, not the style frame. Transform
2029 // and opacity hints apply to the table wrapper box, not the table box.
2031 }
2032 }
2041 }
2049 }
2061 }
2065 }
2069 }
2073 }
2074 }
2080 // All other animations should keep running but not running on the
2081 // *compositor* at this point.
2085 }
2086 }
2087 }
2088 }
2090 // When using handled hints by an ancestor, we need to make sure that our
2091 // ancestor in the DOM tree is actually our ancestor in the flat tree.
2092 // Otherwise, we can't guarantee that e.g. a repaint from an ancestor in the DOM
2093 // will really end up repainting us.
2096 // An out of flow can be parented in other part of the tree.
2098 }
2100 // Any column-spanner's parent frame is not its DOM parent's primary frame.
2102 }
2104 // This one is more subtle. captions are in-flow children of the table
2105 // frame. But they are parented to the table wrapper. So hints handled for
2106 // the inner table might not be applicable to us.
2108 }
2110 }
2112 #ifdef DEBUG
2115 }
2121 }
2124 }
2131 }
2136 }
2139 }
2142 // A ::first-line always ends up here via its block, which is therefore the
2143 // right expected owner. That block can be an
2144 // anonymous box. For example, we could have a ::first-line on a columnated
2145 // block; the blockframe is the column-content anonymous box in that case.
2146 // So we don't want to end up in the code below, which steps out of anon
2147 // boxes. Just return the parent of the line frame, which is the block.
2149 }
2152 // Ditto for ::first-letter. A first-letter always arrives here via its
2153 // direct parent, except when it's parented to a ::first-line.
2156 }
2158 }
2161 // Things never have ::first-letter as their expected parent. Go
2162 // on up to the ::first-letter's parent.
2164 }
2168 // We've handled already anon boxes, so now we're looking at
2169 // a frame of a DOM element or pseudo. Hop through anon and line-boxes
2170 // generated by our DOM parent, and go find the owner frame for it.
2176 // Handle :-moz-table and :-moz-inline-table.
2179 // We get the in-flow parent here so that we can handle the OOF anonymous
2180 // boxed to get the correct parent.
2182 }
2184 }
2187 }
2189 // FIXME(emilio, bug 1633685): We should ideally figure out how to properly
2190 // restyle replicated fixed pos frames... We seem to assume everywhere that they
2191 // can't get restyled at the moment...
2195 }
2202 }
2203 }
2206 }
2211 // We allow aParent.mOwner to be null, for cases when we're not starting at
2212 // the root of the tree. We also allow aParent.mOwner to be somewhere up our
2213 // expected owner chain not our immediate owner, which allows us creating long
2214 // chains of ServoRestyleStates in some cases where it's just not worth it.
2219 "Should only have expected owner weirdness when anon boxes "
2226 }
2227 }
2229 }
2230 }
2231 }
2238 }
2244 }
2245 #endif
2249 "All our wrappers are anon boxes, and why would we restyle "
2252 "All our wrappers are anon boxes, and why would we restyle "
2260 // Make sure we only add first continuations.
2264 // Already queued up, nothing to do.
2266 }
2268 // Make sure to queue up parents before children. But don't queue up
2269 // ancestors of non-anonymous boxes here; those are handled when we traverse
2270 // their non-anonymous kids.
2273 }
2275 // If the append fails, we'll fail to restyle properly, but that's probably
2276 // better than crashing.
2279 }
2280 }
2286 }
2289 }
2293 // The frame at index aIndex is something we should restyle ourselves, but
2294 // following frames may need separate ServoRestyleStates to restyle.
2300 // Where is cur supposed to inherit from? From its parent frame, except in
2301 // the case when cur is a table, in which case it should be its grandparent.
2302 // Also, not in the case when the resulting frame would be a first-line; in
2303 // that case we should be inheriting from the block, and the first-line will
2304 // do its fixup later if needed.
2305 //
2306 // Note that after we do all that fixup the parent we get might still not be
2307 // aParent; for example aParent could be a scrollframe, in which case we
2308 // should inherit from the scrollcontent frame. Or the parent might be some
2309 // continuation of aParent.
2310 //
2311 // Try to assert as much as we can about the parent we actually end up using
2312 // without triggering bogus asserts in all those various edge cases.
2317 }
2320 }
2325 // Now "this" is a ServoRestyleState for aParent, so if parent is not a next
2326 // continuation (possibly across ib splits) of aParent we need a new
2327 // ServoRestyleState for the kid.
2334 }
2338 // This frame may already have been restyled. Even if it has, we can't just
2339 // return, because the next frame may be a kid of it that does need restyling.
2343 }
2347 // Note: no overflow possible here, since aIndex < length.
2352 // It might be nice if we could do better than nsChangeHint_Empty. On
2353 // the other hand, presumably our mChangesHandled already has the bits
2354 // we really want here so in practice it doesn't matter.
2358 numProcessed +=
2360 }
2361 }
2364 }
2367 // We want to get the anon box parent for aChild. where aChild has
2368 // ParentIsWrapperAnonBox().
2369 //
2370 // For the most part this is pretty straightforward, but there are two
2371 // wrinkles. First, if aChild is a table, then we really want the parent of
2372 // its table wrapper.
2376 }
2379 // Now if parent is a cell-content frame, we actually want the cellframe.
2383 // Must be a caption. In that case we want the table here.
2386 }
2388 }
2391 RestyleHint aRestyleHint,
2392 nsChangeHint aMinChangeHint) {
2398 }
2400 // We allow posting restyles from within change hint handling, but not from
2401 // within the restyle algorithm itself.
2405 // FIXME(emilio): we should assert against this instead.
2407 }
2409 // Assuming the restyle hints will invalidate cached style for
2410 // getComputedStyle, since we don't know if any of the restyling that we do
2411 // would affect undisplayed elements.
2415 }
2418 }
2420 // Processing change hints sometimes causes new change hints to be generated,
2421 // and very occasionally, additional restyle hints. We collect the change
2422 // hints manually to avoid re-traversing the DOM to find them.
2426 }
2430 }
2431 }
2434 PseudoStyleType aPseudoType,
2435 RestyleHint aRestyleHint) {
2440 // FIXME: Bug 1371107: When reframing happens,
2441 // EffectCompositor::mElementsToRestyle still has unbound old pseudo
2442 // element. We should drop it.
2444 }
2449 }
2452 RestyleHint aRestyleHint) {
2453 // NOTE(emilio): The semantics of these methods are quite funny, in the sense
2454 // that we're not supposed to need to rebuild the actual stylist data.
2455 //
2456 // That's handled as part of the MediumFeaturesChanged stuff, if needed.
2457 //
2458 // Clear the cached style data only if we are guaranteed to process the whole
2459 // DOM tree again.
2460 //
2461 // FIXME(emilio): Decouple this, probably. This probably just wants to reset
2462 // the "uses viewport units / uses rem" bits, and _maybe_ clear cached anon
2463 // box styles and such... But it doesn't really always need to clear the
2464 // initial style of the document and similar...
2467 }
2472 }
2474 // TODO(emilio, bz): Extensions can add/remove stylesheets that can affect
2475 // non-inheriting anon boxes. It's not clear if we want to support that, but
2476 // if we do, we need to re-selector-match them here.
2477 }
2479 /* static */
2481 IncludeRoot aIncludeRoot) {
2487 }
2488 }
2489 }
2494 NODE_NEEDS_FRAME));
2496 }
2497 }
2499 /* static */
2506 }
2507 }
2508 }
2513 }
2515 /**
2516 * This struct takes care of encapsulating some common state that text nodes may
2517 * need to track during the post-traversal.
2518 *
2519 * This is currently used to properly compute change hints when the parent
2520 * element of this node is a display: contents node, and also to avoid computing
2521 * the style for text children more than once per element.
2522 */
2542 }
2545 }
2554 }
2559 // We rely on the fact that all the text children for the same element share
2560 // style to avoid recomputing style differences for all of them.
2561 //
2562 // TODO(emilio): The above may not be true for ::first-{line,letter}, but
2563 // we'll cross that bridge when we support those in stylo.
2570 }
2574 mComputedHint);
2575 }
2576 }
2581 mLazilyResolvedParentContext =
2584 }
2586 }
2595 nsChangeHint mComputedHint;
2596 };
2603 }
2605 // Elements in the top layer are guaranteed to have absolute or fixed
2606 // position per https://fullscreen.spec.whatwg.org/#new-stacking-layer.
2613 }
2626 // NOTE(emilio): We can't use the changes handled for the owner of the
2627 // backdrop frame, since it's out of flow, and parented to the viewport or
2628 // canvas frame (depending on the `position` value).
2634 anchorsToSuppress);
2637 }
2646 }
2648 // We need to find the block the first-letter is associated with so we can
2649 // find the right element for the first-letter's style resolution. Might as
2650 // well just delegate the whole thing to that block.
2654 }
2658 }
2674 nsChangeHint childHint =
2679 }
2683 // If we generate a reconstruct here, remove any non-reconstruct hints we
2684 // may have already generated for this content.
2686 }
2688 childHint);
2689 }
2692 }
2699 // FIXME(emilio): Consider adding a bit or something to avoid the initial
2700 // virtual call?
2704 }
2705 }
2713 }
2717 }
2721 // Whether parent was restyled.
2723 // Skip sending accessibility notifications for all descendants.
2725 // Always send accessibility notifications if the element is shown.
2726 // The SkipA11yNotifications flag above overrides this flag.
2728 };
2732 #ifdef ACCESSIBILITY
2735 }
2740 }
2741 #endif
2743 // Send proper accessibility notifications and return post traversal
2744 // flags for kids.
2748 ServoPostTraversalFlags aFlags) {
2754 #ifdef ACCESSIBILITY
2757 // If we don't have accessibility service, accessibility is not
2758 // enabled. Just skip everything.
2760 }
2769 }
2770 }
2773 // Propagate the skipping flag to descendants.
2775 }
2783 // Propagate the sending-if-shown flag to descendants.
2785 }
2786 // We have asked accessibility service to remove the whole subtree
2787 // of element which becomes invisible from the accessible tree, but
2788 // this element is visible, so we need to add it back.
2791 // If we shouldn't skip in any case, we need to check whether our own
2792 // visibility has changed.
2793 // Also notify if the subtree visibility change due to content-visibility.
2796 needsNotify =
2798 }
2805 // We are adding the subtree. Accessibility service would handle
2806 // descendants, so we should just skip them from notifying.
2808 }
2810 // Remove the subtree of this invisible element, and ask any shown
2811 // descendant to add themselves back.
2814 }
2815 }
2816 #endif
2819 }
2823 ServoPostTraversalFlags aFlags) {
2830 // NOTE(emilio): This is needed because for table frames the bit is set on the
2831 // table wrapper (which is the primary frame), not on the table itself.
2838 // Grab the change hint from Servo.
2840 nsChangeHint changeHint =
2846 // We should really fix the weird primary frame mapping for image maps
2847 // (bug 135040)...
2851 }
2853 // Handle lazy frame construction by posting a reconstruct for any lazily-
2854 // constructed roots.
2858 }
2868 }
2870 // Do not subsume change hints for the column-spanner.
2874 }
2876 // If the parent wasn't restyled, the styles of our anon box parents won't
2877 // change either.
2882 }
2884 // If we don't have a ::marker pseudo-element, but need it, then
2885 // reconstruct the frame. (The opposite situation implies 'display'
2886 // changes so doesn't need to be handled explicitly here.)
2893 upToDateStyleIfRestyled);
2896 }
2897 }
2898 }
2900 // Although we shouldn't generate non-ReconstructFrame hints for elements with
2901 // no frames, we can still get them here if they were explicitly posted by
2902 // PostRestyleEvent, such as a RepaintFrame hint when a :link changes to be
2903 // :visited. Skip processing these hints if there is no frame.
2905 changeHint) {
2907 }
2909 // If our change hint is reconstruct, we delegate to the frame constructor,
2910 // which consumes the new style and expects the old style to be on the frame.
2911 //
2912 // XXXbholley: We should teach the frame constructor how to clear the dirty
2913 // descendants bit to avoid the traversal here.
2918 styleFrame &&
2921 // https://drafts.csswg.org/css-scroll-anchoring/#suppression-triggers
2922 //
2923 // We need to do the position check here rather than in
2924 // DidSetComputedStyle because changing position reframes.
2925 //
2926 // We suppress adjustments whenever we change from being display: none to
2927 // be an abspos.
2928 //
2929 // Similarly, for other changes from abspos to non-abspos styles.
2930 //
2931 // TODO(emilio): I _think_ chrome won't suppress adjustments whenever
2932 // `display` changes. But that causes some infinite loops in cases like
2933 // bug 1568778.
2936 }
2937 }
2940 }
2942 // TODO(emilio): We could avoid some refcount traffic here, specially in the
2943 // ComputedStyle case, which uses atomic refcounting.
2944 //
2945 // Hold the ComputedStyle alive, because it could become a dangling pointer
2946 // during the replacement. In practice it's not a huge deal, but better not
2947 // playing with dangling pointers if not needed.
2948 //
2949 // NOTE(emilio): We could keep around the old computed style for display:
2950 // contents elements too, but we don't really need it right now.
2955 "display: contents node has a frame, yet we didn't reframe it"
2961 }
2968 }
2970 // We can't really assume as used changes from display: contents elements (or
2971 // other elements without frames).
2978 ServoPostTraversalFlags childrenFlags =
2985 // We want to walk all the continuations here, even the ones with different
2986 // styles. In practice, the only reason we get continuations with different
2987 // styles here is ::first-line (::first-letter never affects element
2988 // styles). But in that case, newStyle is the right context for the
2989 // _later_ continuations anyway (the ones not affected by ::first-line), not
2990 // the earlier ones, so there is no point stopping right at the point when
2991 // we'd actually be setting the right ComputedStyle.
2992 //
2993 // This does mean that we may be setting the wrong ComputedStyle on our
2994 // initial continuations; ::first-line fixes that up after the fact.
2998 }
3002 }
3005 // This is the root. Update styles on the viewport as needed.
3009 // NB: The root restyle state, not the one for our children!
3011 }
3012 }
3014 // Some changes to animations don't affect the computed style and yet still
3015 // require the layer to be updated. For example, pausing an animation via
3016 // the Web Animations API won't affect an element's style but still
3017 // requires to update the animation on the layer.
3018 //
3019 // We can sometimes reach this when the animated style is being removed.
3020 // Since AddLayerChangesForAnimation checks if |styleFrame| has a transform
3021 // style or not, we need to call it *after* setting |newStyle| to
3022 // |styleFrame| to ensure the animated transform has been removed first.
3029 }
3040 childrenRestyleState);
3048 }
3049 }
3050 }
3052 // We want to update frame pseudo-element styles after we've traversed our
3053 // kids, because some of those updates (::first-line/::first-letter) need to
3054 // modify the styles of the kids, and the child traversal above would just
3055 // clobber those modifications.
3058 // Make sure to update anon boxes and pseudo bits after updating text,
3059 // otherwise ProcessPostTraversalForText could clobber first-letter
3060 // styles, for example.
3062 }
3063 // Process anon box wrapper frames before ::first-line bits, but _after_
3064 // owned anon boxes, since the children wrapper anon boxes could be
3065 // inheriting from our own owned anon boxes.
3071 // Even if we were not restyled, if we're a block with a first-line and
3072 // one of our descendant elements which is on the first line was restyled,
3073 // we need to update the styles of things on the first line, because
3074 // they're wrong now.
3075 //
3076 // FIXME(bz) Could we do better here? For example, could we keep track of
3077 // frames that are "block with a ::first-line so we could avoid
3078 // IsFrameOfType() and digging about for the first-line frame if not?
3079 // Could we keep track of whether the element children we actually restyle
3080 // are affected by first-line? Something else? Bug 1385443 tracks making
3081 // this better.
3087 }
3088 }
3089 }
3090 }
3094 }
3099 // Handle lazy frame construction.
3104 }
3106 // Handle restyle.
3110 }
3112 // If the parent wasn't restyled, the styles of our anon box parents won't
3113 // change either.
3118 }
3123 // We want to walk all the continuations here, even the ones with different
3124 // styles. In practice, the only reasons we get continuations with different
3125 // styles are ::first-line and ::first-letter. But in those cases,
3126 // newStyle is the right context for the _later_ continuations anyway (the
3127 // ones not affected by ::first-line/::first-letter), not the earlier ones,
3128 // so there is no point stopping right at the point when we'd actually be
3129 // setting the right ComputedStyle.
3130 //
3131 // This does mean that we may be setting the wrong ComputedStyle on our
3132 // initial continuations; ::first-line/::first-letter fix that up after the
3133 // fact.
3136 }
3139 }
3145 }
3146 }
3151 // NOTE(emilio): We can handle snapshots from a one-off restyle of those that
3152 // we do to restyle stuff for reconstruction, for example.
3153 //
3154 // It seems to be the case that we always flush in between that happens and
3155 // the next attribute change, so we can assert that we haven't handled the
3156 // snapshot here yet. If this assertion didn't hold, we'd need to unset that
3157 // flag from here too.
3158 //
3159 // Can't wait to make ProcessPendingRestyles the only entry-point for styling,
3160 // so this becomes much easier to reason about. Today is not that day though.
3167 // Now that we have a snapshot, make sure a restyle is triggered.
3170 }
3177 // FIXME(emilio): In the "flush animations" case, ideally, we should only
3178 // recascade animation styles running on the compositor, so we shouldn't care
3179 // about other styles, or new rules that apply to the page...
3180 //
3181 // However, that's not true as of right now, see bug 1388031 and bug 1388692.
3189 // PresShell::FlushPendingNotifications doesn't early-return in the case
3190 // where the PresShell hasn't yet been initialized (and therefore we haven't
3191 // yet done the initial style traversal of the DOM tree). We should arguably
3192 // fix up the callers and assert against this case, but we just detect and
3193 // handle it for now.
3195 }
3197 // It'd be bad!
3200 // Create a AnimationsWithDestroyedFrame during restyling process to
3201 // stop animations and transitions on elements that have no frame at the end
3202 // of the restyling process.
3208 // Ensure the refresh driver is active during traversal to avoid mutating
3209 // mActiveTimer and mMostRecentRefresh time.
3213 // This might post new restyles, so need to do it here. Don't do it if we're
3214 // already going to restyle tho, so that we don't potentially reflow with
3215 // dirty styling.
3218 }
3220 // Perform the Servo traversal, and the post-traversal if required. We do this
3221 // in a loop because certain rare paths in the frame constructor can trigger
3222 // additional style invalidations.
3223 //
3224 // FIXME(emilio): Confirm whether that's still true now that XBL is gone.
3228 }
3232 }
3237 // Select scroll anchors for frames that have been scrolled. Do this
3238 // before processing restyled frames so that anchor nodes are correctly
3239 // marked when directly moving frames with RecomputePosition.
3242 nsStyleChangeList currentChanges;
3245 // Recreate styles , and queue up change hints (which also handle lazy frame
3246 // construction).
3249 {
3254 anchorsToSuppress);
3257 }
3259 // We want to suppress adjustments the current (before-change) scroll
3260 // anchor container now, and save a reference to the content node so that
3261 // we can suppress them in the after-change scroll anchor .
3266 }
3267 }
3268 }
3269 }
3274 // Process the change hints.
3275 //
3276 // Unfortunately, the frame constructor can generate new change hints while
3277 // processing existing ones. We redirect those into a secondary queue and
3278 // iterate until there's nothing left.
3279 {
3280 ReentrantChangeList newChanges;
3288 // SVG Elements post change hints without ensuring that the primary
3289 // frame will be there after that (see bug 1366142).
3290 //
3291 // Just ignore those, since we can't really process them.
3293 }
3296 }
3298 }
3300 }
3302 // Suppress adjustments in the after-change scroll anchors if needed, now
3303 // that we're done reframing everything.
3308 }
3309 }
3310 }
3313 // Maybe no styles changed when:
3314 //
3315 // * Only explicit change hints were posted in the first place.
3316 // * When an attribute or state change in the content happens not to need
3317 // a restyle after all.
3318 //
3319 // In any case, we don't need to increment the restyle generation in that
3320 // case.
3322 }
3327 }
3339 // Now that everything has settled, see if we have enough free rule nodes in
3340 // the tree to warrant sweeping them.
3343 // Note: We are in the scope of |animationsWithDestroyedFrame|, so
3344 // |mAnimationsWithDestroyedFrame| is still valid.
3347 }
3349 #ifdef DEBUG
3357 }
3358 }
3359 #endif
3363 #ifdef DEBUG
3366 }
3367 #endif
3370 }
3375 }
3377 // Servo data for the element might have been dropped. (e.g. by removing
3378 // from its document)
3381 }
3382 }
3384 }
3390 }
3393 }
3396 ElementState aChangedBits) {
3397 #ifdef EARLY_BETA_OR_EARLIER
3402 }
3403 #endif
3408 // We'll restyle when the relevant visited query finishes, regardless of the
3409 // style (see Link::VisitedQueryFinished). So there's no need to do anything
3410 // as a result of this state change just yet.
3411 //
3412 // Note that this check checks for _both_ bits: This is only true when visited
3413 // changes to unvisited or vice-versa, but not when we start or stop being a
3414 // link itself.
3419 }
3420 }
3424 }
3426 // Don't bother taking a snapshot if no rules depend on these state bits.
3427 //
3428 // We always take a snapshot for the LTR/RTL event states, since Servo doesn't
3429 // track those bits in the same way, and we know that :dir() rules are always
3430 // present in UA style sheets.
3434 }
3436 // Assuming we need to invalidate cached style in getComputedStyle for
3437 // undisplayed elements, since we don't know if it is needed.
3444 }
3453 }
3460 // Relative selector invalidation travels ancestor and earlier sibling
3461 // direction, so it's very possible that it invalidates a styled element.
3466 }
3470 }
3477 }
3487 }
3491 }
3492 }
3496 ElementState aChangedBits) {
3502 }
3506 }
3507 }
3511 // We must record some state for :-moz-table-border-nonzero and
3512 // :-moz-select-list-box.
3516 }
3520 }
3523 }
3532 // If the attribute influences one of the pseudo-classes that are backed by
3533 // attributes, we just record it.
3536 }
3538 // We assume that id and class attributes are used in class/id selectors, and
3539 // thus record them.
3540 //
3541 // TODO(emilio): We keep a filter of the ids in use somewhere in the StyleSet,
3542 // presumably we could try to filter the old and new id, but it's not clear
3543 // it's worth it.
3547 }
3549 // We always record lang="", even though we force a subtree restyle when it
3550 // changes, since it can change how its siblings match :lang(..) due to
3551 // selectors like :lang(..) + div.
3554 }
3556 // Otherwise, just record the attribute change if a selector in the page may
3557 // reference it from an attribute selector.
3559 }
3565 }
3570 }
3581 }
3583 // We cannot tell if the attribute change will affect the styles of
3584 // undisplayed elements, because we don't actually restyle those elements
3585 // during the restyle traversal. So just assume that the attribute change can
3586 // cause the style to change.
3589 // Relative selector invalidation travels ancestor and earlier sibling
3590 // direction, so it's very possible that it invalidates a styled element.
3595 }
3597 // Some other random attribute changes may also affect the transitions,
3598 // so we also set this true here.
3606 }
3607 }
3609 // For some attribute changes we must restyle the whole subtree:
3610 //
3611 // * lang="" and xml:lang="" can affect all descendants due to :lang()
3612 // * exportparts can affect all descendant parts. We could certainly integrate
3613 // it better in the invalidation machinery if it was necessary.
3617 // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for
3618 // exportparts attribute changes?
3620 }
3622 }
3642 // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for part
3643 // attribute changes?
3645 }
3648 // See if we have appearance information for a theme.
3649 StyleAppearance appearance =
3659 }
3660 }
3661 }
3664 }
3668 }
3671 // Assuming we need to invalidate cached style in getComputedStyle for
3672 // undisplayed elements, since we don't know if it is needed.
3675 // If we change attributes, we have to mark this to be true, so we will
3676 // increase the animation generation for the new created transition if any.
3678 }
3679 }
3682 NodeSelectorFlags aParentFlags) {
3685 }
3694 }
3697 }
3705 mightHaveNthOfDependency =
3710 mightHaveNthOfDependency =
3712 }
3716 }
3717 }
3723 }
3737 }
3738 }
3744 }
3747 }
3750 // This is only called when moving frames in or out of the first-line
3751 // pseudo-element (or one of its descendants). We can't say much about
3752 // aFrame's ancestors, unfortunately (e.g. during a dynamic insert into
3753 // something inside an inline-block on the first line the ancestors could be
3754 // totally arbitrary), but we will definitely find a line frame on the
3755 // ancestor chain. Note that the lineframe may not actually be the one that
3756 // corresponds to ::first-line; when we're moving _out_ of the ::first-line it
3757 // will be one of the continuations instead.
3758 #ifdef DEBUG
3759 {
3763 }
3765 }
3766 #endif
3769 }
3775 }
3777 }
3782 // Style context of backdrop frame has no parent style, and thus we do not
3783 // need to reparent it.
3785 }
3788 // We're entering a display: none subtree, which we know it's going to get
3789 // rebuilt. Don't bother reparenting.
3791 }
3794 // Also reparent the out-of-flow and all its continuations. We're doing
3795 // this to match Gecko for now, but it's not clear that this behavior is
3796 // correct per spec. It's certainly pretty odd for out-of-flows whose
3797 // containing block is not within the first line.
3798 //
3799 // Right now we're somewhat inconsistent in this testcase:
3800 //
3801 // <style>
3802 // div { color: orange; clear: left; }
3803 // div::first-line { color: blue; }
3804 // </style>
3805 // <div>
3806 // <span style="float: left">What color is this text?</span>
3807 // </div>
3808 // <div>
3809 // <span><span style="float: left">What color is this text?</span></span>
3810 // </div>
3811 //
3812 // We make the first float orange and the second float blue. On the other
3813 // hand, if the float were within an inline-block that was on the first
3814 // line, arguably it _should_ inherit from the ::first-line...
3820 }
3821 }
3823 // FIXME(emilio): This is the only caller of GetParentComputedStyle, let's try
3824 // to remove it?
3828 // If our provider is our child, we want to reparent it first, because we
3829 // inherit style from it.
3834 // Get the style again after ReparentComputedStyle() which might have
3835 // changed it.
3840 }
3843 // No need to do anything here for this frame, but we should still reparent
3844 // its descendants, because those may have styles that inherit from the
3845 // parent of this frame (e.g. non-anonymous columns in an anonymous
3846 // colgroup).
3851 }
3855 // We probably don't want to initiate transitions from ReparentComputedStyle,
3856 // since we call it during frame construction rather than in response to
3857 // dynamic changes.
3858 // Also see the comment at the start of
3859 // nsTransitionManager::ConsiderInitiatingTransition.
3860 //
3861 // We don't try to do the fancy copying from previous continuations that
3862 // GeckoRestyleManager does here, because that relies on knowing the parents
3863 // of ComputedStyles, and we don't know those.
3869 // No providerFrame means we inherited from a display:contents thing. Our
3870 // layout parent style is the style of our nearest ancestor frame. But we
3871 // have to be careful to do that with our placeholder, not with us, if we're
3872 // out of flow.
3880 }
3881 }
3888 // This logic somewhat mirrors the logic in
3889 // RestyleManager::ProcessPostTraversal.
3891 // We can't use UpdateAdditionalComputedStyles as-is because it needs a
3892 // ServoRestyleState and maintaining one of those during a _frametree_
3893 // traversal is basically impossible.
3902 }
3903 }
3905 // Generally, owned anon boxes are our descendants. The only exceptions are
3906 // tables (for the table wrapper) and inline frames (for the block part of the
3907 // block-in-inline split). We're going to update our descendants when looping
3908 // over kids, and we don't want to update the block part of a block-in-inline
3909 // split if the inline is on the first line but the block is not (and if the
3910 // block is, it's the child of something else on the first line and will get
3911 // updated as a child). And given how this method ends up getting called, if
3912 // we reach here for a table frame, we are already in the middle of
3913 // reparenting the table wrapper frame. So no need to
3914 // UpdateStyleOfOwnedAnonBoxes() here.
3918 // We do not need to do the equivalent of UpdateFramePseudoElementStyles,
3919 // because those are handled by our descendant walk.
3920 }
3927 // only do frames that are in flow
3931 }
3932 }
3933 }
3934 }