| blob | 8c0751209382b614588ae72f1f06564c9e301aa7 |
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 #ifdef DEBUG
2093 }
2099 }
2102 }
2109 }
2114 }
2117 }
2120 // A ::first-line always ends up here via its block, which is therefore the
2121 // right expected owner. That block can be an
2122 // anonymous box. For example, we could have a ::first-line on a columnated
2123 // block; the blockframe is the column-content anonymous box in that case.
2124 // So we don't want to end up in the code below, which steps out of anon
2125 // boxes. Just return the parent of the line frame, which is the block.
2127 }
2130 // Ditto for ::first-letter. A first-letter always arrives here via its
2131 // direct parent, except when it's parented to a ::first-line.
2134 }
2136 }
2139 // Things never have ::first-letter as their expected parent. Go
2140 // on up to the ::first-letter's parent.
2142 }
2146 // We've handled already anon boxes, so now we're looking at
2147 // a frame of a DOM element or pseudo. Hop through anon and line-boxes
2148 // generated by our DOM parent, and go find the owner frame for it.
2154 // Handle :-moz-table and :-moz-inline-table.
2157 // We get the in-flow parent here so that we can handle the OOF anonymous
2158 // boxed to get the correct parent.
2160 }
2162 }
2165 }
2167 // FIXME(emilio, bug 1633685): We should ideally figure out how to properly
2168 // restyle replicated fixed pos frames... We seem to assume everywhere that they
2169 // can't get restyled at the moment...
2173 }
2180 }
2181 }
2184 }
2190 // We allow aParent.mOwner to be null, for cases when we're not starting at
2191 // the root of the tree. We also allow aParent.mOwner to be somewhere up our
2192 // expected owner chain not our immediate owner, which allows us creating long
2193 // chains of ServoRestyleStates in some cases where it's just not worth it.
2198 "Should only have expected owner weirdness when anon boxes "
2205 }
2206 }
2208 }
2209 }
2210 }
2217 }
2223 }
2224 #endif
2228 "All our wrappers are anon boxes, and why would we restyle "
2231 "All our wrappers are anon boxes, and why would we restyle "
2239 // Make sure we only add first continuations.
2243 // Already queued up, nothing to do.
2245 }
2247 // Make sure to queue up parents before children. But don't queue up
2248 // ancestors of non-anonymous boxes here; those are handled when we traverse
2249 // their non-anonymous kids.
2252 }
2254 // If the append fails, we'll fail to restyle properly, but that's probably
2255 // better than crashing.
2258 }
2259 }
2265 }
2268 }
2272 // The frame at index aIndex is something we should restyle ourselves, but
2273 // following frames may need separate ServoRestyleStates to restyle.
2279 // Where is cur supposed to inherit from? From its parent frame, except in
2280 // the case when cur is a table, in which case it should be its grandparent.
2281 // Also, not in the case when the resulting frame would be a first-line; in
2282 // that case we should be inheriting from the block, and the first-line will
2283 // do its fixup later if needed.
2284 //
2285 // Note that after we do all that fixup the parent we get might still not be
2286 // aParent; for example aParent could be a scrollframe, in which case we
2287 // should inherit from the scrollcontent frame. Or the parent might be some
2288 // continuation of aParent.
2289 //
2290 // Try to assert as much as we can about the parent we actually end up using
2291 // without triggering bogus asserts in all those various edge cases.
2296 }
2299 }
2304 // Now "this" is a ServoRestyleState for aParent, so if parent is not a next
2305 // continuation (possibly across ib splits) of aParent we need a new
2306 // ServoRestyleState for the kid.
2313 }
2317 // This frame may already have been restyled. Even if it has, we can't just
2318 // return, because the next frame may be a kid of it that does need restyling.
2322 }
2326 // Note: no overflow possible here, since aIndex < length.
2331 // It might be nice if we could do better than nsChangeHint_Empty. On
2332 // the other hand, presumably our mChangesHandled already has the bits
2333 // we really want here so in practice it doesn't matter.
2337 numProcessed +=
2339 }
2340 }
2343 }
2346 // We want to get the anon box parent for aChild. where aChild has
2347 // ParentIsWrapperAnonBox().
2348 //
2349 // For the most part this is pretty straightforward, but there are two
2350 // wrinkles. First, if aChild is a table, then we really want the parent of
2351 // its table wrapper.
2355 }
2358 // Now if parent is a cell-content frame, we actually want the cellframe.
2362 // Must be a caption. In that case we want the table here.
2365 }
2367 }
2370 RestyleHint aRestyleHint,
2371 nsChangeHint aMinChangeHint) {
2377 }
2379 // We allow posting restyles from within change hint handling, but not from
2380 // within the restyle algorithm itself.
2384 // FIXME(emilio): we should assert against this instead.
2386 }
2388 // Assuming the restyle hints will invalidate cached style for
2389 // getComputedStyle, since we don't know if any of the restyling that we do
2390 // would affect undisplayed elements.
2394 }
2397 }
2399 // Processing change hints sometimes causes new change hints to be generated,
2400 // and very occasionally, additional restyle hints. We collect the change
2401 // hints manually to avoid re-traversing the DOM to find them.
2405 }
2409 }
2410 }
2413 PseudoStyleType aPseudoType,
2414 RestyleHint aRestyleHint) {
2419 // FIXME: Bug 1371107: When reframing happens,
2420 // EffectCompositor::mElementsToRestyle still has unbound old pseudo
2421 // element. We should drop it.
2423 }
2428 }
2431 RestyleHint aRestyleHint) {
2432 // NOTE(emilio): The semantics of these methods are quite funny, in the sense
2433 // that we're not supposed to need to rebuild the actual stylist data.
2434 //
2435 // That's handled as part of the MediumFeaturesChanged stuff, if needed.
2436 //
2437 // Clear the cached style data only if we are guaranteed to process the whole
2438 // DOM tree again.
2439 //
2440 // FIXME(emilio): Decouple this, probably. This probably just wants to reset
2441 // the "uses viewport units / uses rem" bits, and _maybe_ clear cached anon
2442 // box styles and such... But it doesn't really always need to clear the
2443 // initial style of the document and similar...
2446 }
2451 }
2453 // TODO(emilio, bz): Extensions can add/remove stylesheets that can affect
2454 // non-inheriting anon boxes. It's not clear if we want to support that, but
2455 // if we do, we need to re-selector-match them here.
2456 }
2458 /* static */
2460 IncludeRoot aIncludeRoot) {
2466 }
2467 }
2468 }
2473 NODE_NEEDS_FRAME));
2475 }
2476 }
2478 /* static */
2485 }
2486 }
2487 }
2492 }
2494 /**
2495 * This struct takes care of encapsulating some common state that text nodes may
2496 * need to track during the post-traversal.
2497 *
2498 * This is currently used to properly compute change hints when the parent
2499 * element of this node is a display: contents node, and also to avoid computing
2500 * the style for text children more than once per element.
2501 */
2521 }
2524 }
2533 }
2538 // We rely on the fact that all the text children for the same element share
2539 // style to avoid recomputing style differences for all of them.
2540 //
2541 // TODO(emilio): The above may not be true for ::first-{line,letter}, but
2542 // we'll cross that bridge when we support those in stylo.
2549 }
2553 mComputedHint);
2554 }
2555 }
2560 mLazilyResolvedParentContext =
2563 }
2565 }
2574 nsChangeHint mComputedHint;
2575 };
2582 }
2584 // Elements in the top layer are guaranteed to have absolute or fixed
2585 // position per https://fullscreen.spec.whatwg.org/#new-stacking-layer.
2592 }
2605 // NOTE(emilio): We can't use the changes handled for the owner of the
2606 // backdrop frame, since it's out of flow, and parented to the viewport or
2607 // canvas frame (depending on the `position` value).
2613 anchorsToSuppress);
2616 }
2625 }
2627 // We need to find the block the first-letter is associated with so we can
2628 // find the right element for the first-letter's style resolution. Might as
2629 // well just delegate the whole thing to that block.
2633 }
2637 }
2653 nsChangeHint childHint =
2659 }
2663 // If we generate a reconstruct here, remove any non-reconstruct hints we
2664 // may have already generated for this content.
2666 }
2668 childHint);
2669 }
2672 }
2679 // FIXME(emilio): Consider adding a bit or something to avoid the initial
2680 // virtual call?
2684 }
2685 }
2693 }
2697 }
2701 // Whether parent was restyled.
2703 // Skip sending accessibility notifications for all descendants.
2705 // Always send accessibility notifications if the element is shown.
2706 // The SkipA11yNotifications flag above overrides this flag.
2708 };
2712 #ifdef ACCESSIBILITY
2715 }
2720 }
2721 #endif
2723 // Send proper accessibility notifications and return post traversal
2724 // flags for kids.
2728 ServoPostTraversalFlags aFlags) {
2734 #ifdef ACCESSIBILITY
2737 // If we don't have accessibility service, accessibility is not
2738 // enabled. Just skip everything.
2740 }
2749 }
2750 }
2753 // Propagate the skipping flag to descendants.
2755 }
2763 // Propagate the sending-if-shown flag to descendants.
2765 }
2766 // We have asked accessibility service to remove the whole subtree
2767 // of element which becomes invisible from the accessible tree, but
2768 // this element is visible, so we need to add it back.
2771 // If we shouldn't skip in any case, we need to check whether our own
2772 // visibility has changed.
2773 // Also notify if the subtree visibility change due to content-visibility.
2776 needsNotify =
2778 }
2785 // We are adding the subtree. Accessibility service would handle
2786 // descendants, so we should just skip them from notifying.
2788 }
2790 // Remove the subtree of this invisible element, and ask any shown
2791 // descendant to add themselves back.
2794 }
2795 }
2796 #endif
2799 }
2803 ServoPostTraversalFlags aFlags) {
2810 // NOTE(emilio): This is needed because for table frames the bit is set on the
2811 // table wrapper (which is the primary frame), not on the table itself.
2815 // We need this because any column-spanner's parent frame is not its DOM
2816 // parent's primary frame. We need some special check similar to out-of-flow
2817 // frames.
2821 // Grab the change hint from Servo.
2823 nsChangeHint changeHint =
2829 // We should really fix the weird primary frame mapping for image maps
2830 // (bug 135040)...
2834 }
2836 // Handle lazy frame construction by posting a reconstruct for any lazily-
2837 // constructed roots.
2841 }
2851 // Do not subsume change hints for the column-spanner.
2855 }
2856 }
2858 // If the parent wasn't restyled, the styles of our anon box parents won't
2859 // change either.
2864 }
2866 // If we don't have a ::marker pseudo-element, but need it, then
2867 // reconstruct the frame. (The opposite situation implies 'display'
2868 // changes so doesn't need to be handled explicitly here.)
2875 upToDateStyleIfRestyled);
2878 }
2879 }
2880 }
2882 // Although we shouldn't generate non-ReconstructFrame hints for elements with
2883 // no frames, we can still get them here if they were explicitly posted by
2884 // PostRestyleEvent, such as a RepaintFrame hint when a :link changes to be
2885 // :visited. Skip processing these hints if there is no frame.
2887 changeHint) {
2889 }
2891 // If our change hint is reconstruct, we delegate to the frame constructor,
2892 // which consumes the new style and expects the old style to be on the frame.
2893 //
2894 // XXXbholley: We should teach the frame constructor how to clear the dirty
2895 // descendants bit to avoid the traversal here.
2900 styleFrame &&
2903 // https://drafts.csswg.org/css-scroll-anchoring/#suppression-triggers
2904 //
2905 // We need to do the position check here rather than in
2906 // DidSetComputedStyle because changing position reframes.
2907 //
2908 // We suppress adjustments whenever we change from being display: none to
2909 // be an abspos.
2910 //
2911 // Similarly, for other changes from abspos to non-abspos styles.
2912 //
2913 // TODO(emilio): I _think_ chrome won't suppress adjustments whenever
2914 // `display` changes. But that causes some infinite loops in cases like
2915 // bug 1568778.
2918 }
2919 }
2922 }
2924 // TODO(emilio): We could avoid some refcount traffic here, specially in the
2925 // ComputedStyle case, which uses atomic refcounting.
2926 //
2927 // Hold the ComputedStyle alive, because it could become a dangling pointer
2928 // during the replacement. In practice it's not a huge deal, but better not
2929 // playing with dangling pointers if not needed.
2930 //
2931 // NOTE(emilio): We could keep around the old computed style for display:
2932 // contents elements too, but we don't really need it right now.
2937 "display: contents node has a frame, yet we didn't reframe it"
2943 }
2951 }
2953 // We can't really assume as used changes from display: contents elements (or
2954 // other elements without frames).
2961 ServoPostTraversalFlags childrenFlags =
2968 // We want to walk all the continuations here, even the ones with different
2969 // styles. In practice, the only reason we get continuations with different
2970 // styles here is ::first-line (::first-letter never affects element
2971 // styles). But in that case, newStyle is the right context for the
2972 // _later_ continuations anyway (the ones not affected by ::first-line), not
2973 // the earlier ones, so there is no point stopping right at the point when
2974 // we'd actually be setting the right ComputedStyle.
2975 //
2976 // This does mean that we may be setting the wrong ComputedStyle on our
2977 // initial continuations; ::first-line fixes that up after the fact.
2981 }
2985 }
2988 // This is the root. Update styles on the viewport as needed.
2992 // NB: The root restyle state, not the one for our children!
2994 }
2995 }
2997 // Some changes to animations don't affect the computed style and yet still
2998 // require the layer to be updated. For example, pausing an animation via
2999 // the Web Animations API won't affect an element's style but still
3000 // requires to update the animation on the layer.
3001 //
3002 // We can sometimes reach this when the animated style is being removed.
3003 // Since AddLayerChangesForAnimation checks if |styleFrame| has a transform
3004 // style or not, we need to call it *after* setting |newStyle| to
3005 // |styleFrame| to ensure the animated transform has been removed first.
3012 }
3023 childrenRestyleState);
3031 }
3032 }
3033 }
3035 // We want to update frame pseudo-element styles after we've traversed our
3036 // kids, because some of those updates (::first-line/::first-letter) need to
3037 // modify the styles of the kids, and the child traversal above would just
3038 // clobber those modifications.
3041 // Make sure to update anon boxes and pseudo bits after updating text,
3042 // otherwise ProcessPostTraversalForText could clobber first-letter
3043 // styles, for example.
3045 }
3046 // Process anon box wrapper frames before ::first-line bits, but _after_
3047 // owned anon boxes, since the children wrapper anon boxes could be
3048 // inheriting from our own owned anon boxes.
3054 // Even if we were not restyled, if we're a block with a first-line and
3055 // one of our descendant elements which is on the first line was restyled,
3056 // we need to update the styles of things on the first line, because
3057 // they're wrong now.
3058 //
3059 // FIXME(bz) Could we do better here? For example, could we keep track of
3060 // frames that are "block with a ::first-line so we could avoid
3061 // IsFrameOfType() and digging about for the first-line frame if not?
3062 // Could we keep track of whether the element children we actually restyle
3063 // are affected by first-line? Something else? Bug 1385443 tracks making
3064 // this better.
3070 }
3071 }
3072 }
3073 }
3077 }
3082 // Handle lazy frame construction.
3087 }
3089 // Handle restyle.
3093 }
3095 // If the parent wasn't restyled, the styles of our anon box parents won't
3096 // change either.
3101 }
3106 // We want to walk all the continuations here, even the ones with different
3107 // styles. In practice, the only reasons we get continuations with different
3108 // styles are ::first-line and ::first-letter. But in those cases,
3109 // newStyle is the right context for the _later_ continuations anyway (the
3110 // ones not affected by ::first-line/::first-letter), not the earlier ones,
3111 // so there is no point stopping right at the point when we'd actually be
3112 // setting the right ComputedStyle.
3113 //
3114 // This does mean that we may be setting the wrong ComputedStyle on our
3115 // initial continuations; ::first-line/::first-letter fix that up after the
3116 // fact.
3119 }
3122 }
3128 }
3129 }
3134 // NOTE(emilio): We can handle snapshots from a one-off restyle of those that
3135 // we do to restyle stuff for reconstruction, for example.
3136 //
3137 // It seems to be the case that we always flush in between that happens and
3138 // the next attribute change, so we can assert that we haven't handled the
3139 // snapshot here yet. If this assertion didn't hold, we'd need to unset that
3140 // flag from here too.
3141 //
3142 // Can't wait to make ProcessPendingRestyles the only entry-point for styling,
3143 // so this becomes much easier to reason about. Today is not that day though.
3150 // Now that we have a snapshot, make sure a restyle is triggered.
3153 }
3160 // FIXME(emilio): In the "flush animations" case, ideally, we should only
3161 // recascade animation styles running on the compositor, so we shouldn't care
3162 // about other styles, or new rules that apply to the page...
3163 //
3164 // However, that's not true as of right now, see bug 1388031 and bug 1388692.
3172 // PresShell::FlushPendingNotifications doesn't early-return in the case
3173 // where the PresShell hasn't yet been initialized (and therefore we haven't
3174 // yet done the initial style traversal of the DOM tree). We should arguably
3175 // fix up the callers and assert against this case, but we just detect and
3176 // handle it for now.
3178 }
3180 // It'd be bad!
3183 // Create a AnimationsWithDestroyedFrame during restyling process to
3184 // stop animations and transitions on elements that have no frame at the end
3185 // of the restyling process.
3191 // Ensure the refresh driver is active during traversal to avoid mutating
3192 // mActiveTimer and mMostRecentRefresh time.
3196 // This might post new restyles, so need to do it here. Don't do it if we're
3197 // already going to restyle tho, so that we don't potentially reflow with
3198 // dirty styling.
3201 }
3203 // Perform the Servo traversal, and the post-traversal if required. We do this
3204 // in a loop because certain rare paths in the frame constructor can trigger
3205 // additional style invalidations.
3206 //
3207 // FIXME(emilio): Confirm whether that's still true now that XBL is gone.
3211 }
3215 }
3220 // Select scroll anchors for frames that have been scrolled. Do this
3221 // before processing restyled frames so that anchor nodes are correctly
3222 // marked when directly moving frames with RecomputePosition.
3225 nsStyleChangeList currentChanges;
3228 // Recreate styles , and queue up change hints (which also handle lazy frame
3229 // construction).
3232 {
3237 anchorsToSuppress);
3240 }
3242 // We want to suppress adjustments the current (before-change) scroll
3243 // anchor container now, and save a reference to the content node so that
3244 // we can suppress them in the after-change scroll anchor .
3249 }
3250 }
3251 }
3252 }
3257 // Process the change hints.
3258 //
3259 // Unfortunately, the frame constructor can generate new change hints while
3260 // processing existing ones. We redirect those into a secondary queue and
3261 // iterate until there's nothing left.
3262 {
3263 ReentrantChangeList newChanges;
3271 // SVG Elements post change hints without ensuring that the primary
3272 // frame will be there after that (see bug 1366142).
3273 //
3274 // Just ignore those, since we can't really process them.
3276 }
3279 }
3281 }
3283 }
3285 // Suppress adjustments in the after-change scroll anchors if needed, now
3286 // that we're done reframing everything.
3291 }
3292 }
3293 }
3296 // Maybe no styles changed when:
3297 //
3298 // * Only explicit change hints were posted in the first place.
3299 // * When an attribute or state change in the content happens not to need
3300 // a restyle after all.
3301 //
3302 // In any case, we don't need to increment the restyle generation in that
3303 // case.
3305 }
3310 }
3322 // Now that everything has settled, see if we have enough free rule nodes in
3323 // the tree to warrant sweeping them.
3326 // Note: We are in the scope of |animationsWithDestroyedFrame|, so
3327 // |mAnimationsWithDestroyedFrame| is still valid.
3330 }
3332 #ifdef DEBUG
3340 }
3341 }
3342 #endif
3346 #ifdef DEBUG
3349 }
3350 #endif
3353 }
3358 }
3360 // Servo data for the element might have been dropped. (e.g. by removing
3361 // from its document)
3364 }
3365 }
3367 }
3373 }
3376 }
3379 ElementState aChangedBits) {
3380 #ifdef EARLY_BETA_OR_EARLIER
3385 }
3386 #endif
3391 // We'll restyle when the relevant visited query finishes, regardless of the
3392 // style (see Link::VisitedQueryFinished). So there's no need to do anything
3393 // as a result of this state change just yet.
3394 //
3395 // Note that this check checks for _both_ bits: This is only true when visited
3396 // changes to unvisited or vice-versa, but not when we start or stop being a
3397 // link itself.
3402 }
3403 }
3407 }
3409 // Don't bother taking a snapshot if no rules depend on these state bits.
3410 //
3411 // We always take a snapshot for the LTR/RTL event states, since Servo doesn't
3412 // track those bits in the same way, and we know that :dir() rules are always
3413 // present in UA style sheets.
3417 }
3419 // Assuming we need to invalidate cached style in getComputedStyle for
3420 // undisplayed elements, since we don't know if it is needed.
3427 }
3436 }
3440 ElementState aChangedBits) {
3446 }
3450 }
3451 }
3455 // We must record some state for :-moz-table-border-nonzero and
3456 // :-moz-select-list-box.
3460 }
3464 }
3467 }
3476 // If the attribute influences one of the pseudo-classes that are backed by
3477 // attributes, we just record it.
3480 }
3482 // We assume that id and class attributes are used in class/id selectors, and
3483 // thus record them.
3484 //
3485 // TODO(emilio): We keep a filter of the ids in use somewhere in the StyleSet,
3486 // presumably we could try to filter the old and new id, but it's not clear
3487 // it's worth it.
3491 }
3493 // We always record lang="", even though we force a subtree restyle when it
3494 // changes, since it can change how its siblings match :lang(..) due to
3495 // selectors like :lang(..) + div.
3498 }
3500 // Otherwise, just record the attribute change if a selector in the page may
3501 // reference it from an attribute selector.
3503 }
3509 }
3514 }
3525 }
3527 // We cannot tell if the attribute change will affect the styles of
3528 // undisplayed elements, because we don't actually restyle those elements
3529 // during the restyle traversal. So just assume that the attribute change can
3530 // cause the style to change.
3533 // Relative selector invalidation travels ancestor and earlier sibling
3534 // direction, so it's very possible that it invalidates a styled element.
3539 }
3541 // Some other random attribute changes may also affect the transitions,
3542 // so we also set this true here.
3550 }
3551 }
3553 // For some attribute changes we must restyle the whole subtree:
3554 //
3555 // * lang="" and xml:lang="" can affect all descendants due to :lang()
3556 // * exportparts can affect all descendant parts. We could certainly integrate
3557 // it better in the invalidation machinery if it was necessary.
3561 // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for
3562 // exportparts attribute changes?
3564 }
3566 }
3586 // TODO(emilio, bug 1598094): Maybe finer-grained invalidation for part
3587 // attribute changes?
3589 }
3592 // See if we have appearance information for a theme.
3593 StyleAppearance appearance =
3603 }
3604 }
3605 }
3608 }
3612 }
3615 // Assuming we need to invalidate cached style in getComputedStyle for
3616 // undisplayed elements, since we don't know if it is needed.
3619 // If we change attributes, we have to mark this to be true, so we will
3620 // increase the animation generation for the new created transition if any.
3622 }
3623 }
3626 NodeSelectorFlags aParentFlags) {
3629 }
3638 }
3641 }
3649 mightHaveNthOfDependency =
3654 mightHaveNthOfDependency =
3656 }
3660 }
3661 }
3667 }
3681 }
3682 }
3688 }
3691 }
3694 // This is only called when moving frames in or out of the first-line
3695 // pseudo-element (or one of its descendants). We can't say much about
3696 // aFrame's ancestors, unfortunately (e.g. during a dynamic insert into
3697 // something inside an inline-block on the first line the ancestors could be
3698 // totally arbitrary), but we will definitely find a line frame on the
3699 // ancestor chain. Note that the lineframe may not actually be the one that
3700 // corresponds to ::first-line; when we're moving _out_ of the ::first-line it
3701 // will be one of the continuations instead.
3702 #ifdef DEBUG
3703 {
3707 }
3709 }
3710 #endif
3713 }
3719 }
3721 }
3726 // Style context of backdrop frame has no parent style, and thus we do not
3727 // need to reparent it.
3729 }
3732 // We're entering a display: none subtree, which we know it's going to get
3733 // rebuilt. Don't bother reparenting.
3735 }
3738 // Also reparent the out-of-flow and all its continuations. We're doing
3739 // this to match Gecko for now, but it's not clear that this behavior is
3740 // correct per spec. It's certainly pretty odd for out-of-flows whose
3741 // containing block is not within the first line.
3742 //
3743 // Right now we're somewhat inconsistent in this testcase:
3744 //
3745 // <style>
3746 // div { color: orange; clear: left; }
3747 // div::first-line { color: blue; }
3748 // </style>
3749 // <div>
3750 // <span style="float: left">What color is this text?</span>
3751 // </div>
3752 // <div>
3753 // <span><span style="float: left">What color is this text?</span></span>
3754 // </div>
3755 //
3756 // We make the first float orange and the second float blue. On the other
3757 // hand, if the float were within an inline-block that was on the first
3758 // line, arguably it _should_ inherit from the ::first-line...
3764 }
3765 }
3767 // FIXME(emilio): This is the only caller of GetParentComputedStyle, let's try
3768 // to remove it?
3772 // If our provider is our child, we want to reparent it first, because we
3773 // inherit style from it.
3778 // Get the style again after ReparentComputedStyle() which might have
3779 // changed it.
3784 }
3787 // No need to do anything here for this frame, but we should still reparent
3788 // its descendants, because those may have styles that inherit from the
3789 // parent of this frame (e.g. non-anonymous columns in an anonymous
3790 // colgroup).
3795 }
3799 // We probably don't want to initiate transitions from ReparentComputedStyle,
3800 // since we call it during frame construction rather than in response to
3801 // dynamic changes.
3802 // Also see the comment at the start of
3803 // nsTransitionManager::ConsiderInitiatingTransition.
3804 //
3805 // We don't try to do the fancy copying from previous continuations that
3806 // GeckoRestyleManager does here, because that relies on knowing the parents
3807 // of ComputedStyles, and we don't know those.
3813 // No providerFrame means we inherited from a display:contents thing. Our
3814 // layout parent style is the style of our nearest ancestor frame. But we
3815 // have to be careful to do that with our placeholder, not with us, if we're
3816 // out of flow.
3824 }
3825 }
3832 // This logic somewhat mirrors the logic in
3833 // RestyleManager::ProcessPostTraversal.
3835 // We can't use UpdateAdditionalComputedStyles as-is because it needs a
3836 // ServoRestyleState and maintaining one of those during a _frametree_
3837 // traversal is basically impossible.
3846 }
3847 }
3849 // Generally, owned anon boxes are our descendants. The only exceptions are
3850 // tables (for the table wrapper) and inline frames (for the block part of the
3851 // block-in-inline split). We're going to update our descendants when looping
3852 // over kids, and we don't want to update the block part of a block-in-inline
3853 // split if the inline is on the first line but the block is not (and if the
3854 // block is, it's the child of something else on the first line and will get
3855 // updated as a child). And given how this method ends up getting called, if
3856 // we reach here for a table frame, we are already in the middle of
3857 // reparenting the table wrapper frame. So no need to
3858 // UpdateStyleOfOwnedAnonBoxes() here.
3862 // We do not need to do the equivalent of UpdateFramePseudoElementStyles,
3863 // because those are handled by our descendant walk.
3864 }
3871 // only do frames that are in flow
3875 }
3876 }
3877 }
3878 }