| blob | 4791ba0a1ce69825b812a93d8eeefe406eee4110 |
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 /**
7 * Code responsible for managing style changes: tracking what style
8 * changes need to happen, scheduling them, and doing them.
9 */
40 #ifdef ACCESSIBILITY
42 #endif
60 ELEMENT_IS_POTENTIAL_RESTYLE_ROOT)
62 ELEMENT_IS_POTENTIAL_ANIMATION_RESTYLE_ROOT)
63 {
66 }
68 void
70 {
72 }
74 #ifdef DEBUG
75 // To ensure that the functions below are only called within
76 // |ApplyRenderingChangeToTree|.
78 #endif
80 static void
82 nsChangeHint aChange);
84 /**
85 * Sync views on aFrame and all of aFrame's descendants (following placeholders),
86 * if aChange has nsChangeHint_SyncFrameView.
87 * Calls DoApplyRenderingChangeToTree on all aFrame's out-of-flow descendants
88 * (following placeholders), if aChange has nsChangeHint_RepaintFrame.
89 * aFrame should be some combination of nsChangeHint_SyncFrameView,
90 * nsChangeHint_RepaintFrame, nsChangeHint_UpdateOpacityLayer and
91 * nsChangeHint_SchedulePaint, nothing else.
92 */
93 static void
95 nsChangeHint aChange)
96 {
100 nsChangeHint_SyncFrameView |
101 nsChangeHint_UpdateOpacityLayer |
102 nsChangeHint_SchedulePaint)),
110 }
111 }
119 // only do frames that don't have placeholders
121 // do the out-of-flow frame and its continuations
129 }
130 }
131 }
132 }
133 }
135 /**
136 * To handle nsChangeHint_ChildrenOnlyTransform we must iterate over the child
137 * frames of the SVG frame concerned. This helper function is used to find that
138 * SVG frame when we encounter nsChangeHint_ChildrenOnlyTransform to ensure
139 * that we iterate over the intended children, since sometimes we end up
140 * handling that hint while processing hints for one of the SVG frame's
141 * ancestor frames.
142 *
143 * The reason that we sometimes end up trying to process the hint for an
144 * ancestor of the SVG frame that the hint is intended for is due to the way we
145 * process restyle events. ApplyRenderingChangeToTree adjusts the frame from
146 * the restyled element's principle frame to one of its ancestor frames based
147 * on what nsCSSRendering::FindBackground returns, since the background style
148 * may have been propagated up to an ancestor frame. Processing hints using an
149 * ancestor frame is fine in general, but nsChangeHint_ChildrenOnlyTransform is
150 * a special case since it is intended to update the children of a specific
151 * frame.
152 */
155 {
157 // This happens if the root-<svg> is fixed positioned, in which case we
158 // can't use aFrame->GetContent() to find the primary frame, since
159 // GetContent() returns nullptr for ViewportFrame.
161 }
162 // For an nsHTMLScrollFrame, this will get the SVG frame that has the
163 // children-only transforms:
169 }
174 }
176 static void
178 nsChangeHint aChange)
179 {
184 // Invalidate and sync views on all descendant frames, following placeholders.
185 // We don't need to update transforms in SyncViewsAndInvalidateDescendants, because
186 // there can't be any out-of-flows or popups that need to be transformed;
187 // all out-of-flow descendants of the transformed element must also be
188 // descendants of the transformed frame.
191 nsChangeHint_SyncFrameView |
192 nsChangeHint_UpdateOpacityLayer |
193 nsChangeHint_SchedulePaint)));
194 // This must be set to true if the rendering change needs to
195 // invalidate content. If it's false, a composite-only paint
196 // (empty transaction) will be scheduled.
199 // if frame has view, will already be invalidated
201 // Note that this whole block will be skipped when painting is suppressed
202 // (due to our caller ApplyRendingChangeToTree() discarding the
203 // nsChangeHint_RepaintFrame hint). If you add handling for any other
204 // hints within this block, be sure that they too should be ignored when
205 // painting is suppressed.
211 // Need to update our overflow rects:
213 }
214 }
217 // Invalidate and reflow the entire SVGTextFrame:
221 aFrame,
228 }
229 }
231 // FIXME/bug 796697: we can get away with empty transactions for
232 // opacity updates in many cases.
237 // SVG effects paints the opacity without using
238 // nsDisplayOpacity. We need to invalidate manually.
240 }
241 }
245 // If we're not already going to do an invalidating paint, see
246 // if we can get away with only updating the transform on a
247 // layer for this frame, and not scheduling an invalidating
248 // paint.
254 // Since we're not going to paint, we need to resend animation
255 // data to the layer.
259 }
260 }
261 }
268 }
269 }
272 }
276 }
277 }
279 static void
282 nsChangeHint aChange)
283 {
284 // We check StyleDisplay()->HasTransformStyle() in addition to checking
285 // IsTransformed() since we can get here for some frames that don't support
286 // CSS transforms.
294 // Don't allow synchronous rendering changes when painting is turned off.
298 }
299 }
301 // Trigger rendering updates by damaging this frame and any
302 // continuations of this frame.
303 #ifdef DEBUG
305 #endif
307 // If the frame's background is propagated to an ancestor, walk up to
308 // that ancestor and apply the RepaintFrame change hint to it.
314 }
321 }
322 }
323 }
325 #ifdef DEBUG
327 #endif
328 }
330 bool
332 {
333 // Don't process position changes on table frames, since we already handle
334 // the dynamic position change on the outer table frame, and the reflow-based
335 // fallback code path also ignores positions on inner table frames.
338 }
341 // Changes to the offsets of a non-positioned element can safely be ignored.
344 }
346 // Don't process position changes on frames which have views or the ones which
347 // have a view somewhere in their descendants, because the corresponding view
348 // needs to be repositioned properly as well.
353 }
357 // For relative positioning, we can simply update the frame rect
360 // We don't currently support relative positioning of inner table
361 // elements (bug 35168). If we apply offsets to things we haven't
362 // previously offset, we'll get confused. So bail.
364 }
367 // Move the frame
369 // Update sticky positioning for an entire element at once, starting with
370 // the first continuation or ib-split sibling.
371 // It's rare that the frame we already have isn't already the first
372 // continuation or ib-split sibling, but it can happen when styles differ
373 // across continuations such as ::first-line or ::first-letter, and in
374 // those cases we will generally (but maybe not always) do the work twice.
383 }
390 nsMargin newOffsets;
400 // nsHTMLReflowState::ApplyRelativePositioning would work here, but
401 // since we've already checked mPosition and aren't changing the frame's
402 // normal position, go ahead and add the offsets directly.
405 }
406 }
409 }
411 // For the absolute positioning case, set up a fake HTML reflow state for
412 // the frame, and then get the offsets and size from it. If the frame's size
413 // doesn't need to change, we can simply update the frame position. Otherwise
414 // we fall back to a reflow.
418 // Construct a bogus parent reflow state so that there's a usable
419 // containing block reflow state.
458 }
460 // The RecomputePosition hint is not used if any offset changed between auto
461 // and non-auto. If computedSize.height == NS_INTRINSICSIZE then the new
462 // element height will be its intrinsic height, and since 'top' and 'bottom''s
463 // auto-ness hasn't changed, the old height must also be its intrinsic
464 // height, which we can assume hasn't changed (or reflow would have
465 // been triggered).
468 // If we're solving for 'left' or 'top', then compute it here, in order to
469 // match the reflow code path.
476 }
484 }
486 // Move the frame
494 }
496 // Fall back to a reflow
499 }
501 void
503 {
513 }
515 nsFrameState dirtyBits;
522 }
524 // If we're not going to clear any intrinsic sizes on the frames, and
525 // there are no dirty bits to set, then there's nothing to do.
533 }
535 void
537 {
539 aFrame,
547 }
548 }
549 }
553 /**
554 * Return true if aFrame's subtree has placeholders for out-of-flow content
555 * whose 'position' style's bit in aPositionMask is set.
556 */
557 static bool
559 {
569 // If SVG text frames could appear here, they could confuse us since
570 // they ignore their position style ... but they can't.
575 }
576 }
579 }
580 }
581 }
582 }
584 }
586 static bool
588 {
595 // Don't call aFrame->IsPositioned here, since that returns true if
596 // the frame already has a transform, and we want to ignore that here
599 // This frame is a container for abs-pos descendants whether or not it
600 // has a transform.
601 // So abs-pos descendants are no problem; we only need to reframe if
602 // we have fixed-pos descendants.
605 // This frame may not be a container for abs-pos descendants already.
606 // So reframe if we have abs-pos or fixed-pos descendants.
609 }
614 }
615 }
617 }
619 nsresult
621 {
631 // Make sure to not rebuild quote or counter lists while we're
632 // processing restyles
637 // Mark frames so that we skip frames that die along the way, bug 123049.
638 // A frame can be in the list multiple times with different hints. Further
639 // optmization is possible if nsStyleChangeList::AppendChange could coalesce
648 }
649 }
659 nsChangeHint hint;
666 // skip any frame that has been destroyed due to a ripple effect
669 }
672 // XXXbz this is due to image maps messing with the primary frame of
673 // <area>s. See bug 135040. Remove this block once that's fixed.
677 }
678 }
685 // The frame has positioned children that need to be reparented, or
686 // it can't easily be converted to/from being an abs-pos container correctly.
691 // Normally frame construction would set state bits as needed,
692 // but we're not going to reconstruct the frame so we need to set them.
693 // It's because we need to set this state on each affected frame
694 // that we can't coalesce nsChangeHint_AddOrRemoveTransform hints up
695 // to ancestors (i.e. it can't be an inherited change hint).
697 // If a transform has been added, we'll be taking this path,
698 // but we may be taking this path even if a transform has been
699 // removed. It's OK to add the bit even if it's not needed.
704 }
706 // Don't remove NS_FRAME_MAY_BE_TRANSFORMED since it may still by
707 // transformed by other means. It's OK to have the bit even if it's
708 // not needed.
711 }
712 }
713 }
714 }
715 }
717 // If we ever start passing true here, be careful of restyles
718 // that involve a reframe and animations. In particular, if the
719 // restyle we're processing here is an animation restyle, but
720 // the style resolution we will do for the frame construction
721 // happens async when we're not in an animation restyle already,
722 // problems could arise.
723 // We could also have problems with triggering of CSS transitions
724 // on elements whose frames are reconstructed, since we depend on
725 // the reconstruction happening synchronously.
732 // frame does not maintain overflow rects, so avoid calling
733 // FinishAndStoreOverflow on it:
737 nsChangeHint_UpdatePostTransformOverflow)));
738 }
741 // Frame can not be transformed, and thus a change in transform will
742 // have no effect and we should not use the
743 // nsChangeHint_UpdatePostTransformOverflow hint.
745 }
751 }
752 }
756 }
762 }
765 // It is possible for this to fall back to a reflow
768 }
769 }
775 nsChangeHint_UpdatePostTransformOverflow |
776 nsChangeHint_UpdateSubtreeOverflow))) {
779 }
782 // The overflow areas of the child frames need to be updated:
786 "SVG frames should not have continuations "
789 "SVG frames should not have continuations "
794 // If |childFrame| is dirty or has dirty children, we don't bother
795 // updating overflows since that will happen when it's reflowed.
800 }
802 "SVG frames should not have continuations "
806 }
807 }
808 // If |frame| is dirty or has dirty children, we don't bother updating
809 // overflows since that will happen when it's reflowed.
812 // If we have both nsChangeHint_UpdateOverflow and
813 // nsChangeHint_UpdatePostTransformOverflow, CHILDREN_AND_PARENT_CHANGED
814 // is selected as it is stronger.
816 nsChangeHint_UpdateSubtreeOverflow)) {
820 }
824 }
825 }
826 }
830 }
831 }
832 }
836 // cleanup references and verify the style tree. Note that the latter needs
837 // to happen once we've processed the whole list, since until then the tree
838 // is not in fact in a consistent state.
845 }
847 #ifdef DEBUG
848 // reget frame from content since it may have been regenerated...
855 }
856 }
861 }
862 #endif
863 }
867 }
869 void
872 nsChangeHint aMinHint,
874 nsRestyleHint aRestyleHint)
875 {
879 // XXXbz this is due to image maps messing with the primary frame pointer
880 // of <area>s. See bug 135040. We can remove this block once that's fixed.
882 }
886 // If we're restyling the root element and there are 'rem' units in
887 // use, handle dynamic changes to the definition of a 'rem' here.
895 // The basis for 'rem' units has changed.
900 }
902 }
903 }
904 }
910 aRestyleHint);
912 // We're restyling an element with no frame, so we should try to
913 // make one if its new style says it should have one. But in order
914 // to try to honor the restyle hint (which we'd like to do so that,
915 // for example, an animation-only style flush doesn't flush other
916 // buffered style changes), we only do this if the restyle hint says
917 // we have *some* restyling for this frame. This means we'll
918 // potentially get ahead of ourselves in that case, but not as much
919 // as we would if we didn't check the restyle hint.
921 }
922 }
929 // Forwarded nsIDocumentObserver method, to handle restyling (and
930 // passing the notification to the frame).
931 nsresult
933 EventStates aStateMask)
934 {
935 // XXXbz it would be good if this function only took Elements, but
936 // we'd have to make ESM guarantee that usefully.
939 }
947 // Any change to a content state that affects which frames we construct
948 // must lead to a frame reconstruct here if we already have a frame.
949 // Note that we never decide through non-CSS means to not create frames
950 // based on content states, so if we already don't have a frame we don't
951 // need to force a reframe -- if it's needed, the HasStateDependentStyle
952 // call will handle things.
957 // If it's generated content, ignore LOADING/etc state changes on it.
960 NS_EVENT_STATE_USERDISABLED |
961 NS_EVENT_STATE_SUPPRESSED |
962 NS_EVENT_STATE_LOADING)) {
974 }
975 }
976 }
977 }
982 }
985 nsRestyleHint rshint;
989 aStateMask);
991 pseudoType)) {
992 // If aElement is a pseudo-element, we want to check to see whether there
993 // are any state-dependent rules applying to that pseudo.
995 pseudoType);
998 aStateMask);
1001 }
1005 }
1008 // Exposing information to the page about whether the link is
1009 // visited or not isn't really something we can worry about here.
1010 // FIXME: We could probably do this a bit better.
1012 }
1016 }
1018 // Forwarded nsIMutationObserver method, to handle restyling.
1019 void
1024 {
1025 nsRestyleHint rshint =
1027 aElement,
1028 aAttribute,
1029 aModType,
1032 }
1034 // Forwarded nsIMutationObserver method, to handle restyling (and
1035 // passing the notification to the frame).
1036 void
1041 {
1042 // Hold onto the PresShell to prevent ourselves from being destroyed.
1043 // XXXbz how, exactly, would this attribute change cause us to be
1044 // destroyed from inside this function?
1047 // Get the frame associated with the content which is the highest in the frame tree
1050 #if 0
1054 #endif
1056 // the style tag has its own interpretation based on aHint
1061 #ifdef MOZ_XUL
1062 // The following listbox widget trap prevents offscreen listbox widget
1063 // content from being removed and re-inserted (which is what would
1064 // happen otherwise).
1074 }
1078 {
1085 }
1086 }
1091 // See if we have appearance information for a theme.
1100 }
1101 }
1103 // let the frame deal with it now, so we don't have to deal later
1105 // XXXwaterson should probably check for IB split siblings
1106 // here, and propagate the AttributeChanged notification to
1107 // them, as well. Currently, inline frames don't do anything on
1108 // this notification, so it's not that big a deal.
1109 }
1111 // See if we can optimize away the style re-resolution -- must be called after
1112 // the frame's AttributeChanged() in case it does something that affects the style
1113 nsRestyleHint rshint =
1115 aElement,
1116 aAttribute,
1117 aModType,
1121 }
1123 void
1125 {
1126 // In some cases (:empty + E, :empty ~ E), a change if the content of
1127 // an element requires restyling its parent's siblings.
1133 }
1135 }
1137 void
1140 {
1142 #ifdef DEBUG
1143 {
1147 }
1148 }
1149 #endif
1157 // see whether we need to restyle the container
1162 // We don't know whether we're testing :empty or :-moz-only-whitespace,
1163 // so be conservative and assume :-moz-only-whitespace (i.e., make
1164 // IsSignificantChild less likely to be true, and thus make us more
1165 // likely to restyle).
1169 }
1170 }
1174 }
1175 }
1179 // Restyling the container is the most we can do here, so we're done.
1181 }
1184 // restyle the last element child before this node
1186 cur;
1191 }
1192 }
1193 }
1194 }
1196 // Needed since we can't use PostRestyleEvent on non-elements (with
1197 // eRestyle_LaterSiblings or nsRestyleHint(eRestyle_Subtree |
1198 // eRestyle_LaterSiblings) as appropriate).
1199 static void
1202 {
1206 aRestyleManager->
1209 NS_STYLE_HINT_NONE);
1211 }
1212 }
1213 }
1215 // Restyling for a ContentInserted or CharacterDataChanged notification.
1216 // This could be used for ContentRemoved as well if we got the
1217 // notification before the removal happened (and sometimes
1218 // CharacterDataChanged is more like a removal than an addition).
1219 // The comments are written and variables are named in terms of it being
1220 // a ContentInserted notification.
1221 void
1224 {
1233 // see whether we need to restyle the container
1236 child;
1240 // We don't know whether we're testing :empty or :-moz-only-whitespace,
1241 // so be conservative and assume :-moz-only-whitespace (i.e., make
1242 // IsSignificantChild less likely to be true, and thus make us more
1243 // likely to restyle).
1247 }
1248 }
1252 }
1253 }
1257 // Restyling the container is the most we can do here, so we're done.
1259 }
1262 // Restyle all later siblings.
1264 }
1267 // restyle the previously-first element child if it is after this node
1270 content;
1275 }
1279 NS_STYLE_HINT_NONE);
1280 }
1282 }
1283 }
1284 // restyle the previously-last element child if it is before this node
1287 content;
1292 }
1296 NS_STYLE_HINT_NONE);
1297 }
1299 }
1300 }
1301 }
1302 }
1304 void
1308 {
1310 // This should be an assert, but this is called incorrectly in
1311 // nsHTMLEditor::DeleteRefToAnonymousNode and the assertions were clogging
1312 // up the logs. Make it an assert again when that's fixed.
1314 }
1321 // see whether we need to restyle the container
1324 child;
1326 // We don't know whether we're testing :empty or :-moz-only-whitespace,
1327 // so be conservative and assume :-moz-only-whitespace (i.e., make
1328 // IsSignificantChild less likely to be true, and thus make us more
1329 // likely to restyle).
1333 }
1334 }
1338 }
1339 }
1343 // Restyling the container is the most we can do here, so we're done.
1345 }
1348 // Restyle all later siblings.
1350 }
1353 // restyle the now-first element child if it was after aOldChild
1356 content;
1360 // do NOT continue here; we might want to restyle this node
1361 }
1365 NS_STYLE_HINT_NONE);
1366 }
1368 }
1369 }
1370 // restyle the now-last element child if it was before aOldChild
1373 content;
1378 }
1380 }
1383 }
1384 }
1385 }
1386 }
1388 void
1390 {
1392 "Should not reconstruct the root of the frame tree. "
1403 // Make sure that the viewmanager will outlive the presshell
1406 // Processing the style changes could cause a flush that propagates to
1407 // the parent frame and thus destroys the pres shell.
1410 // We may reconstruct frames below and hence process anything that is in the
1411 // tree. We don't want to get notified to process those items again after.
1414 nsAutoScriptBlocker scriptBlocker;
1418 // FIXME (bug 1047928): Many of the callers probably don't need
1419 // eRestyle_Subtree because they're changing things that affect data
1420 // computation rather than selector matching; we could have a restyle
1421 // hint passed in, and substantially improve the performance of things
1422 // like pref changes and the restyling that we do for downloadable
1423 // font loads.
1428 // Make sure that we process any pending animation restyles from the
1429 // above style change. Note that we can *almost* implement the above
1430 // by just posting a style change -- except we really need to restyle
1431 // the root frame rather than the root element's primary frame.
1433 }
1435 void
1437 nsChangeHint aExtraHint,
1438 nsRestyleHint aRestyleHint)
1439 {
1440 // Tell the style set to get the old rule tree out of the way
1441 // so we can recalculate while maintaining rule tree immutability
1445 }
1448 // We want this hint to apply to the root node's primary frame
1449 // rather than the root frame, since it's the primary frame that has
1450 // the styles for the root element (rather than the ancestors of the
1451 // primary frame whose mContent is the root node but which have
1452 // different styles). If we use up the hint for one of the
1453 // ancestors that we hit first, then we'll fail to do the restyling
1454 // we need to do.
1457 // If the root element is gone, dropping the hint on the floor
1458 // should be fine.
1460 }
1462 }
1464 // Recalculate all of the style contexts for the document
1465 // Note that we can ignore the return value of ComputeStyleChangeFor
1466 // because we never need to reframe the root frame
1467 // XXX This could be made faster by not rerunning rule matching
1468 // (but note that nsPresShell::SetPreferenceStyleRules currently depends
1469 // on us re-running rule matching here
1470 // XXX Does it matter that we're passing aExtraHint to the real root
1471 // frame and not the root node's primary frame? (We could do
1472 // roughly what we do for aRestyleHint above.)
1473 // Note: The restyle tracker we pass in here doesn't matter.
1478 // Tell the style set it's safe to destroy the old rule tree. We
1479 // must do this after the ProcessRestyledFrames call in case the
1480 // change list has frame reconstructs in it (since frames to be
1481 // reconstructed will still have their old style context pointers
1482 // until they are destroyed).
1484 }
1486 void
1488 {
1497 }
1499 // First do any queued-up frame creation. (We should really
1500 // merge this into the rest of the process, though; see bug 827239.)
1503 // Process non-animation restyles...
1508 // Before we process any restyles, we need to ensure that style
1509 // resulting from any throttled animations (animations that we're
1510 // running entirely on the compositor thread) is up-to-date, so that
1511 // if any style changes we cause trigger transitions, we have the
1512 // correct old style for starting the transition.
1517 }
1521 #ifdef DEBUG
1523 #endif
1525 // ...and then process animation restyles. This needs to happen
1526 // second because we need to start animations that resulted from the
1527 // first set of restyles (e.g., CSS transitions with negative
1528 // transition-delay), and because we need to immediately
1529 // restyle-with-animation any just-restyled elements that are
1530 // mid-transition (since processing the non-animation restyle ignores
1531 // the running transition so it can check for a new change on the same
1532 // property, and then posts an immediate animation style change).
1539 "We should not have posted new non-animation restyles while "
1543 // We probably wasted a lot of work up above, but this seems safest
1544 // and it should be rarely used.
1545 // This might add us as a refresh observer again; that's ok.
1547 }
1548 }
1550 void
1552 {
1553 // Make sure to not rebuild quote or counter lists while we're
1554 // processing restyles
1558 }
1560 void
1562 {
1565 // Set mInStyleRefresh to false now, since the EndUpdate call might
1566 // add more restyles.
1571 #ifdef DEBUG
1573 #endif
1574 }
1576 void
1578 {
1582 }
1591 ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT);
1594 // FIXME: We should have the transition manager and animation manager
1595 // add only the elements for which animations are currently throttled
1596 // (i.e., animating on the compositor with main-thread style updates
1597 // suppressed).
1604 }
1606 void
1608 nsRestyleHint aRestyleHint,
1609 nsChangeHint aMinChangeHint,
1611 {
1614 }
1617 // Nothing to do here
1619 }
1626 }
1628 void
1630 {
1631 // Make sure we're not in a style refresh; if we are, we still have
1632 // a call to ProcessPendingRestyles coming and there's no need to
1633 // add ourselves as a refresh observer until then.
1639 }
1641 // Unconditionally flag our document as needing a flush. The other
1642 // option here would be a dedicated boolean to track whether we need
1643 // to do so (set here and unset in ProcessPendingRestyles).
1645 }
1647 void
1649 {
1651 "Should not reconstruct the root of the frame tree. "
1657 // Get a restyle event posted if necessary
1659 }
1661 #ifdef DEBUG
1662 static void
1664 {
1667 nsAutoString name;
1671 }
1677 nsAutoString buffer;
1681 }
1683 }
1684 }
1686 static void
1688 {
1697 }
1703 }
1706 }
1708 static void
1711 {
1712 // get the contexts not provided
1715 }
1718 // Get the correct parent context from the frame
1719 // - if the frame is a placeholder, we get the out of flow frame's context
1720 // as the parent context instead of asking the frame
1722 // get the parent context from the frame (indirectly)
1726 // aParentContext could still be null
1727 }
1737 }
1746 }
1747 }
1749 }
1757 }
1758 }
1761 // Either childStyleIfVisited has aContext->GetParent()->GetStyleIfVisited()
1762 // as the parent or it has a different rulenode from aContext _and_ has
1763 // aContext->GetParent() as the parent.
1772 }
1773 }
1775 static void
1778 {
1788 // only do frames that are in flow
1790 // placeholder: first recurse and verify the out of flow frame,
1791 // then verify the placeholder's context
1795 // recurse to out of flow frame, letting the parent context get resolved
1800 // verify placeholder using the parent frame's context as
1801 // parent context
1803 }
1806 }
1807 }
1808 }
1809 }
1811 // do additional contexts
1817 }
1818 }
1820 void
1822 {
1827 }
1828 }
1832 // aContent must be the content for the frame in question, which may be
1833 // :before/:after content
1840 {
1843 }
1845 // Notify the transition manager, and if it starts a transition,
1846 // it will give us back a transition-covering style rule which
1847 // we'll use to get *another* style context. We want to ignore
1848 // any already-running transitions, but cover up any that we're
1849 // currently starting with their start value so we don't start
1850 // them again for descendants that inherit that value.
1859 }
1860 }
1866 {
1867 // We don't expect XUL tree stuff here.
1872 // XXX see the comments about the various element confusion in
1873 // ElementRestyler::Restyle.
1876 }
1880 }
1887 }
1899 }
1906 // Get content for nearest nsNumberControlFrame:
1912 }
1914 }
1918 }
1923 }
1925 /**
1926 * FIXME: Temporary. Should merge with following function.
1927 */
1930 {
1931 // Account for {ib} splits when looking for "prevContinuation". In
1932 // particular, for the first-continuation of a part of an {ib} split
1933 // we want to use the previous ib-split sibling of the previous
1934 // ib-split sibling of aFrame, which should have the same style
1935 // context as aFrame itself. In particular, if aFrame is the first
1936 // continuation of an inline part of a block-in-inline split then its
1937 // previous ib-split sibling is a block, and the previous ib-split
1938 // sibling of _that_ is an inline, just like aFrame. Similarly, if
1939 // aFrame is the first continuation of a block part of an
1940 // block-in-inline split (a block-in-inline wrapper block), then its
1941 // previous ib-split sibling is an inline and the previous ib-split
1942 // sibling of that is either another block-in-inline wrapper block box
1943 // or null.
1947 // We're the first continuation, so we can just get the frame
1948 // property directly
1954 }
1955 }
1962 }
1964 /**
1965 * Get the previous continuation or similar ib-split sibling (assuming
1966 * block/inline alternation), conditionally on it having the same style.
1967 * This assumes that we're not between resolving the two (i.e., that
1968 * they're both already resolved.
1969 */
1972 {
1976 }
1985 }
1987 }
1989 /**
1990 * Get the next continuation or similar ib-split sibling (assuming
1991 * block/inline alternation), conditionally on it having the same style.
1992 *
1993 * Since this is used when deciding to copy the new style context, it
1994 * takes as an argument the old style context to check if the style is
1995 * the same. When it is used in other contexts (i.e., where the next
1996 * continuation would already have the new style context), the current
1997 * style context should be passed.
1998 */
2003 {
2004 // See GetPrevContinuationWithSameStyle about {ib} splits.
2009 // We're the last continuation, so we have to hop back to the first
2010 // before getting the frame property
2016 }
2017 }
2021 }
2034 }
2035 }
2037 }
2039 nsresult
2041 {
2043 // Also reparent the out-of-flow and all its continuations.
2050 }
2052 // DO NOT verify the style tree before reparenting. The frame
2053 // tree has already been changed, so this check would just fail.
2070 }
2071 // XXX need to do something here to produce the correct style context for
2072 // an IB split whose first inline part is inside a first-line frame.
2073 // Currently the first IB anonymous block's style context takes the first
2074 // part's style context as parent, which is wrong since first-line style
2075 // should not apply to the anonymous block.
2077 #ifdef DEBUG
2078 {
2079 // Check that our assumption that continuations of the same
2080 // pseudo-type and with the same style context parent have the
2081 // same style context is valid before the reresolution. (We need
2082 // to check the pseudo-type and style context parent because of
2083 // :first-letter and :first-line, where we create styled and
2084 // unstyled letter/line frames distinguished by pseudo-type, and
2085 // then need to distinguish their descendants based on having
2086 // different parents.)
2097 }
2098 }
2099 #endif
2105 prevContinuation &&
2110 // Just use the style context from the frame's previous
2111 // continuation (see assertion about aFrame->GetNextContinuation()
2112 // above, which we would have previously hit for aFrame's previous
2113 // continuation).
2119 aFrame,
2127 pseudoElement);
2128 }
2132 // We probably don't want to initiate transitions from
2133 // ReparentStyleContext, since we call it during frame
2134 // construction rather than in response to dynamic changes.
2135 // Also see the comment at the start of
2136 // nsTransitionManager::ConsiderStartingTransition.
2137 #if 0
2141 }
2142 #endif
2144 // Make sure to call CalcStyleDifference so that the new context ends
2145 // up resolving all the structs the old context resolved.
2149 // The style change is always 0 because we have the same rulenode and
2150 // CalcStyleDifference optimizes us away. That's OK, though:
2151 // reparenting should never trigger a frame reconstruct, and whenever
2152 // it's happening we already plan to reflow and repaint the frames.
2155 }
2164 // only do frames that are in flow
2167 #ifdef DEBUG
2175 }
2176 #endif
2178 }
2179 }
2180 }
2182 // If this frame is part of an IB split, then the style context of
2183 // the next part of the split might be a child of our style context.
2184 // Reparent its style context just in case one of our ancestors
2185 // (split or not) hasn't done so already). It's not a problem to
2186 // reparent the same frame twice because the "if (newContext !=
2187 // oldContext)" check will prevent us from redoing work.
2194 }
2195 }
2197 // do additional contexts
2208 // Make sure to call CalcStyleDifference so that the new
2209 // context ends up resolving all the structs the old context
2210 // resolved.
2214 // The style change is always 0 because we have the same
2215 // rulenode and CalcStyleDifference optimizes us away. That's
2216 // OK, though: reparenting should never trigger a frame
2217 // reconstruct, and whenever it's happening we already plan to
2218 // reflow and repaint the frames.
2221 }
2224 }
2225 }
2226 #ifdef DEBUG
2228 #endif
2229 }
2230 }
2233 }
2238 nsChangeHint aHintsHandledByAncestors,
2242 aVisibleKidsOfHiddenElement)
2246 // XXXldb Why does it make sense to use aParentContent? (See
2247 // comment above assertion at start of ElementRestyler::Restyle.)
2257 #ifdef ACCESSIBILITY
2262 #endif
2263 {
2264 }
2272 // XXXldb Why does it make sense to use aParentContent? (See
2273 // comment above assertion at start of ElementRestyler::Restyle.)
2284 #ifdef ACCESSIBILITY
2289 #endif
2290 {
2292 // Note that the out-of-flow may not be a geometric descendant of
2293 // the frame where we started the reresolve. Therefore, even if
2294 // mHintsHandled already includes nsChangeHint_AllReflowHints we
2295 // don't want to pass that on to the out-of-flow reresolve, since
2296 // that can lead to the out-of-flow not getting reflowed when it
2297 // should be (eg a reresolve starting at <body> that involves
2298 // reflowing the <body> would miss reflowing fixed-pos nodes that
2299 // also need reflow). In the cases when the out-of-flow _is_ a
2300 // geometric descendant of a frame we already have a reflow hint
2301 // for, reflow coalescing should keep us from doing the work twice.
2303 }
2304 }
2312 // XXXldb Why does it make sense to use aParentContent? (See
2313 // comment above assertion at start of ElementRestyler::Restyle.)
2319 // assume the worst
2320 nsChangeHint_Hints_NotHandledForDescendants)
2325 #ifdef ACCESSIBILITY
2330 #endif
2331 {
2332 }
2334 void
2337 nsChangeHint aChangeToAssume)
2338 {
2339 // Check some invariants about replacing one style context with another.
2346 mParentFrameHintsNotHandledForDescendants);
2351 // nsChangeHint_UpdateEffects is inherited, but it can be set due to changes
2352 // in inherited properties (fill and stroke). Avoid propagating it into
2353 // text nodes.
2357 }
2363 }
2364 }
2367 }
2369 /**
2370 * Recompute style for mFrame (which should not have a prev continuation
2371 * with the same style), all of its next continuations with the same
2372 * style, and all ib-split siblings of the same type (either block or
2373 * inline, skipping the intermediates of the other type) and accumulate
2374 * changes into mChangeList given that mHintsHandled is already accumulated
2375 * for an ancestor.
2376 * mParentContent is the content node used to resolve the parent style
2377 * context. This means that, for pseudo-elements, it is the content
2378 * that should be used for selector matching (rather than the fake
2379 * content node attached to the frame).
2380 */
2381 void
2383 {
2384 // It would be nice if we could make stronger assertions here; they
2385 // would let us simplify the ?: expressions below setting |content|
2386 // and |pseudoContent| in sensible ways as well as making what
2387 // |content| and |pseudoContent| mean, and their relationship to
2388 // |mFrame->GetContent()|, make more sense. However, we can't,
2389 // because of frame trees like the one in
2390 // https://bugzilla.mozilla.org/show_bug.cgi?id=472353#c14 . Once we
2391 // fix bug 242277 we should be able to make this make more sense.
2404 // If we're we're resolving from the root of the frame tree (which
2405 // we do in DoRebuildAllStyleData), we need to avoid getting the
2406 // root's restyle data until we get to its primary frame, since
2407 // it's the primary frame that has the styles for the root element
2408 // (rather than the ancestors of the primary frame whose mContent
2409 // is the root node but which have different styles). If we use
2410 // up the hint for one of the ancestors that we hit first, then
2411 // we'll fail to do the restyling we need to do.
2418 }
2421 }
2422 }
2426 {
2429 // TEMPORARY (until bug 918064): Call RestyleSelf for each
2430 // continuation or block-in-inline sibling.
2437 }
2440 // If we have more continuations with different style (e.g., because
2441 // we're inside a ::first-letter or ::first-line), put the restyle
2442 // hint back.
2445 }
2446 }
2449 }
2451 void
2453 {
2457 // XXXldb get new context from prev-in-flow if possible, to avoid
2458 // duplication. (Or should we just let |GetContext| handle that?)
2459 // Getting the hint would be nice too, but that's harder.
2461 // XXXbryner we may be able to avoid some of the refcounting goop here.
2462 // We do need a reference to oldContext for the lifetime of this function, and it's possible
2463 // that the frame has the last reference to it, so AddRef it here.
2469 #ifdef ACCESSIBILITY
2472 #endif
2478 // Get the frame providing the parent style context. If it is a
2479 // child, then resolve the provider first.
2485 else
2487 }
2490 "Postcondition for GetParentStyleContextFrame() violated. "
2491 "That means we need to add the current element to the "
2494 // resolve the provider here (before aSelf below).
2496 // assumeDifferenceHint forces the parent's change to be also
2497 // applied to this frame, no matter what
2498 // nsStyleContext::CalcStyleDifference says. CalcStyleDifference
2499 // can't be trusted because it assumes any changes to the parent
2500 // style context provider will be automatically propagated to
2501 // the frame(s) with child style contexts.
2508 // The provider's new context becomes the parent context of
2509 // aSelf's context.
2511 // Set |mResolvedChild| so we don't bother resolving the
2512 // provider again.
2514 }
2517 // We don't actually know what the parent style context's
2518 // non-inherited hints were, so assume the worst.
2519 mParentFrameHintsNotHandledForDescendants =
2520 nsChangeHint_Hints_NotHandledForDescendants;
2521 }
2523 // do primary context
2529 prevContinuation &&
2534 // Just use the style context from the frame's previous
2535 // continuation.
2537 }
2542 }
2551 newContext =
2553 pseudoElement);
2555 // Use ResolveStyleWithReplacement either for actual replacements
2556 // or, with no replacements, as a substitute for
2557 // ReparentStyleContext that rebuilds the path in the rule tree
2558 // rather than reusing the rule node, as we need to do during a
2559 // rule tree reconstruct.
2560 newContext =
2562 aRestyleHint);
2563 }
2566 parentContext);
2567 }
2573 // XXX what other pseudos do we need to treat like this?
2575 pseudoType,
2576 parentContext,
2577 mTreeMatchContext);
2579 // This pseudo should no longer exist; gotta reframe
2582 nsChangeHint_ReconstructFrame);
2583 // We're reframing anyway; just keep the same context
2585 }
2587 // Don't expect XUL tree stuff here, since it needs a comparator and
2588 // all.
2598 pseudoType,
2599 parentContext,
2600 pseudoElement);
2601 }
2602 }
2606 // Skip parent display based style fixup for anonymous subtrees:
2611 mTreeMatchContext);
2612 }
2613 }
2622 // We're the root of the style context tree and the new style
2623 // context returned has the same rule node. This means that
2624 // we can use FindChildWithRules to keep a lot of the old
2625 // style contexts around. However, we need to start from the
2626 // same root.
2628 }
2629 }
2637 }
2640 // If the frame gets regenerated, let it keep its old context,
2641 // which is important to maintain various invariants about
2642 // frame types matching their style contexts.
2643 // Note that this check even makes sense if we didn't call
2644 // CaptureChange because of copyFromContinuation being true,
2645 // since we'll have copied the existing context from the
2646 // previous continuation, so newContext == oldContext.
2648 }
2649 }
2652 // do additional contexts
2653 // XXXbz might be able to avoid selector matching here in some
2654 // cases; won't worry about it for now.
2670 // Use ResolveStyleWithReplacement as a substitute for
2671 // ReparentStyleContext that rebuilds the path in the rule tree
2672 // rather than reusing the rule node, as we need to do during a
2673 // rule tree reconstruct.
2674 newExtraContext =
2676 oldExtraContext,
2683 newExtraContext =
2685 pseudoElement);
2686 }
2689 newContext);
2691 // Don't expect XUL tree stuff here, since it needs a comparator and
2692 // all.
2697 extraPseudoType,
2698 newContext,
2700 }
2708 }
2709 }
2710 }
2711 }
2713 void
2715 {
2716 // We'd like style resolution to be exact in the sense that an
2717 // animation-only style flush flushes only the styles it requests
2718 // flushing and doesn't update any other styles. This means avoiding
2719 // constructing new frames during such a flush.
2720 //
2721 // For a ::before or ::after, we'll do an eRestyle_Subtree due to
2722 // RestyleHintForOp in nsCSSRuleProcessor.cpp (via its
2723 // HasAttributeDependentStyle or HasStateDependentStyle), given that
2724 // we store pseudo-elements in selectors like they were children.
2725 //
2726 // Also, it's faster to skip the work we do on undisplayed children
2727 // and pseudo-elements when we can skip it.
2732 // Check whether we might need to create a new ::before frame.
2733 // There's no need to do this if we're planning to reframe already
2734 // or if we're not forcing restyles on kids.
2735 // It's also important to check mHintsHandled since we use
2736 // mFrame->StyleContext(), which is out of date if mHintsHandled has a
2737 // ReconstructFrame hint. Using an out of date style context could
2738 // trigger assertions about mismatched rule trees.
2740 mightReframePseudos) {
2742 }
2744 // There is no need to waste time crawling into a frame's children
2745 // on a frame change. The act of reconstructing frames will force
2746 // new style contexts to be resolved on all of this frame's
2747 // descendants anyway, so we want to avoid wasting time processing
2748 // style contexts that we're just going to throw away anyway. - dwh
2749 // It's also important to check mHintsHandled since reresolving the
2750 // kids would use mFrame->StyleContext(), which is out of date if
2751 // mHintsHandled has a ReconstructFrame hint; doing this could trigger
2752 // assertions about mismatched rule trees.
2761 }
2764 }
2766 // Check whether we might need to create a new ::after frame.
2767 // See comments above regarding :before.
2769 mightReframePseudos) {
2771 }
2772 }
2774 void
2776 {
2777 // When the root element is display:none, we still construct *some*
2778 // frames that have the root element as their mContent, down to the
2779 // DocElementContainingBlock.
2790 }
2792 // No need to do this if we're planning to reframe already.
2793 // It's also important to check mHintsHandled since we use
2794 // mFrame->StyleContext(), which is out of date if mHintsHandled
2795 // has a ReconstructFrame hint. Using an out of date style
2796 // context could trigger assertions about mismatched rule trees.
2803 }
2810 "Shouldn't have random pseudo style contexts in the "
2813 // Get the parent of the undisplayed content and check if it is a XBL
2814 // children element. Push the children element as an ancestor here because it does
2815 // not have a frame and would not otherwise be pushed as an ancestor.
2820 }
2827 thisChildHint =
2829 }
2833 undisplayedContext =
2836 mTreeMatchContext);
2839 // Use ResolveStyleWithReplacement either for actual
2840 // replacements, or as a substitute for ReparentStyleContext
2841 // that rebuilds the path in the rule tree rather than reusing
2842 // the rule node, as we need to do during a rule tree
2843 // reconstruct.
2844 undisplayedContext =
2848 thisChildHint);
2850 undisplayedContext =
2854 }
2860 NS_STYLE_HINT_FRAMECHANGE);
2861 // The node should be removed from the undisplayed map when
2862 // we reframe it.
2864 // update the undisplayed node with the new context
2866 }
2867 }
2868 }
2869 }
2871 void
2873 {
2874 // Make sure not to do this for pseudo-frames or frames that
2875 // can't have generated content.
2879 // Our content insertion frame might have gotten flagged
2882 // Check for a new :before pseudo and an existing :before
2883 // frame, but only if the frame is the first continuation.
2886 // Checking for a :before frame is cheaper than getting the
2887 // :before style context.
2892 mPresContext)) {
2893 // Have to create the new :before frame
2896 nsChangeHint_ReconstructFrame);
2897 }
2898 }
2899 }
2900 }
2902 /**
2903 * aFrame is the last continuation or block-in-inline sibling that this
2904 * ElementRestyler is restyling.
2905 */
2906 void
2908 {
2909 // Make sure not to do this for pseudo-frames or frames that
2910 // can't have generated content.
2914 // Our content insertion frame might have gotten flagged
2917 // Check for new :after content, but only if the frame is the
2918 // last continuation.
2922 // Getting the :after frame is more expensive than getting the pseudo
2923 // context, so get the pseudo context first.
2927 mPresContext) &&
2929 // have to create the new :after frame
2932 nsChangeHint_ReconstructFrame);
2933 }
2934 }
2935 }
2936 }
2938 void
2940 {
2941 #ifdef ACCESSIBILITY
2942 // Notify a11y for primary frame only if it's a root frame of visibility
2943 // changes or its parent frame was hidden while it stays visible and
2944 // it is not inside a {ib} split or is the first frame of {ib} split.
2952 // Notify a11y the element (perhaps with its children) was shown.
2953 // We don't fall into this case if this element gets or stays shown
2954 // while its parent becomes hidden.
2958 // The element is being hidden; its children may stay visible, or
2959 // become visible after being hidden previously. If we'll find
2960 // visible children then we should notify a11y about that as if
2961 // they were inserted into tree. Notify a11y this element was
2962 // hidden.
2965 }
2966 }
2969 // Notify a11y that element stayed visible while its parent was
2970 // hidden.
2973 }
2974 }
2975 #endif
2976 }
2978 void
2980 nsRestyleHint aChildRestyleHint)
2981 {
2986 }
2991 // Out-of-flows are reached through their placeholders. Continuations
2992 // and block-in-inline splits are reached through those chains.
2995 // Get the parent of the child frame's content and check if it
2996 // is a XBL children element. Push the children element as an
2997 // ancestor here because it does not have a frame and would not
2998 // otherwise be pushed as an ancestor.
3000 // Check if the frame has a content because |child| may be a
3001 // nsPageFrame that does not have a content.
3006 }
3008 // only do frames that are in flow
3010 // get out of flow frame and recur there
3017 // |nsFrame::GetParentStyleContextFrame| checks being out
3018 // of flow so that this works correctly.
3021 // Later continuations are likely restyled as a result of
3022 // the restyling of the previous continuation.
3023 // (Currently that's always true, but it's likely to
3024 // change if we implement overflow:fragments or similar.)
3026 }
3028 FOR_OUT_OF_FLOW_CHILD);
3032 // reresolve placeholder's context under the same parent
3033 // as the out-of-flow frame
3036 }
3041 }
3042 }
3043 }
3044 }
3045 }
3046 // XXX need to do overflow frames???
3047 }
3049 void
3051 {
3052 #ifdef ACCESSIBILITY
3053 // Send notifications about visibility changes.
3061 content,
3063 }
3071 // Process children staying shown.
3076 childContent,
3078 }
3080 }
3081 }
3082 #endif
3083 }
3087 {
3090 // Might we have ib-split siblings?
3092 // nothing more to do here
3094 }
3098 }
3100 void
3102 nsChangeHint aMinChange,
3104 nsRestyleHint aRestyleHint)
3105 {
3106 // Create a ReframingStyleContexts struct on the stack and put it in
3107 // our mReframingStyleContexts for the scope of this function.
3110 ReframingStyleContexts reframingStyleContexts;
3113 nsStyleChangeList changeList;
3117 }
3119 void
3122 nsChangeHint aMinChange,
3124 nsRestyleHint aRestyleHint)
3125 {
3132 }
3137 // We want to start with this frame and walk all its next-in-flows,
3138 // as well as all its ib-split siblings and their next-in-flows,
3139 // reresolving style on all the frames we encounter in this walk that
3140 // we didn't reach already. In the normal case, this will mean only
3141 // restyling the first two block-in-inline splits and no
3142 // continuations, and skipping everything else. However, when we have
3143 // a style change targeted at an element inside a context where styles
3144 // vary between continuations (e.g., a style change on an element that
3145 // extends from inside a styled ::first-line to outside of that first
3146 // line), we might restyle more than that.
3159 // Outer loop over ib-split siblings
3162 // We already handled this element when dealing with its earlier
3163 // continuation.
3165 }
3167 // Inner loop over next-in-flows of the current frame
3170 treeMatchContext,
3171 visibleKidsOfHiddenElement);
3176 // If it's going to cause a framechange, then don't bother
3177 // with the continuations or ib-split siblings since they'll be
3178 // clobbered by the frame reconstruct anyway.
3182 }
3183 }
3184 }
3185 }