diff options
Diffstat (limited to 'layout/style/nsStyleStruct.cpp')
| -rw-r--r-- | layout/style/nsStyleStruct.cpp | 3604 |
1 files changed, 3604 insertions, 0 deletions
diff --git a/layout/style/nsStyleStruct.cpp b/layout/style/nsStyleStruct.cpp new file mode 100644 index 0000000000..123a1b3304 --- /dev/null +++ b/layout/style/nsStyleStruct.cpp @@ -0,0 +1,3604 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * structs that contain the data provided by ComputedStyle, the + * internal API for computed style data for an element + */ + +#include "nsStyleStruct.h" +#include "nsStyleStructInlines.h" +#include "nsStyleConsts.h" +#include "nsString.h" +#include "nsPresContext.h" +#include "nsIWidget.h" +#include "nsCRTGlue.h" +#include "nsCSSProps.h" +#include "nsDeviceContext.h" +#include "nsStyleUtil.h" +#include "nsIURIMutator.h" + +#include "nsCOMPtr.h" + +#include "nsBidiUtils.h" +#include "nsLayoutUtils.h" + +#include "imgIRequest.h" +#include "imgIContainer.h" +#include "CounterStyleManager.h" + +#include "mozilla/dom/AnimationEffectBinding.h" // for PlaybackDirection +#include "mozilla/dom/BaseKeyframeTypesBinding.h" // for CompositeOperation +#include "mozilla/dom/DocGroup.h" +#include "mozilla/dom/ImageTracker.h" +#include "mozilla/CORSMode.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/GeckoBindings.h" +#include "mozilla/PreferenceSheet.h" +#include "mozilla/SchedulerGroup.h" +#include "mozilla/StaticPresData.h" +#include "mozilla/Likely.h" +#include "nsIURI.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/DocumentInlines.h" +#include <algorithm> +#include "ImageLoader.h" +#include "mozilla/StaticPrefs_layout.h" + +using namespace mozilla; +using namespace mozilla::dom; + +static const nscoord kMediumBorderWidth = nsPresContext::CSSPixelsToAppUnits(3); + +// We set the size limit of style structs to 504 bytes so that when they +// are allocated by Servo side with Arc, the total size doesn't exceed +// 512 bytes, which minimizes allocator slop. +static constexpr size_t kStyleStructSizeLimit = 504; + +template <typename Struct, size_t Actual, size_t Limit> +struct AssertSizeIsLessThan { + static_assert(Actual == sizeof(Struct), "Bogus invocation"); + static_assert(Actual <= Limit, + "Style struct became larger than the size limit"); + static constexpr bool instantiate = true; +}; + +#define STYLE_STRUCT(name_) \ + static_assert(AssertSizeIsLessThan<nsStyle##name_, sizeof(nsStyle##name_), \ + kStyleStructSizeLimit>::instantiate, \ + ""); +#include "nsStyleStructList.h" +#undef STYLE_STRUCT + +bool StyleCssUrlData::operator==(const StyleCssUrlData& aOther) const { + // This very intentionally avoids comparing LoadData and such. + const auto& extra = extra_data.get(); + const auto& otherExtra = aOther.extra_data.get(); + if (extra.BaseURI() != otherExtra.BaseURI() || + extra.Principal() != otherExtra.Principal() || + cors_mode != aOther.cors_mode) { + // NOTE(emilio): This does pointer comparison, but it's what URLValue used + // to do. That's ok though since this is only used for style struct diffing. + return false; + } + return serialization == aOther.serialization; +} + +StyleLoadData::~StyleLoadData() { Gecko_LoadData_Drop(this); } + +already_AddRefed<nsIURI> StyleComputedUrl::ResolveLocalRef( + nsIURI* aBase) const { + nsCOMPtr<nsIURI> result = GetURI(); + if (result && IsLocalRef()) { + nsCString ref; + result->GetRef(ref); + + nsresult rv = NS_MutateURI(aBase).SetRef(ref).Finalize(result); + + if (NS_FAILED(rv)) { + // If setting the ref failed, just return the original URI. + result = aBase; + } + } + return result.forget(); +} + +already_AddRefed<nsIURI> StyleComputedUrl::ResolveLocalRef( + const nsIContent* aContent) const { + return ResolveLocalRef(aContent->GetBaseURI()); +} + +void StyleComputedUrl::ResolveImage(Document& aDocument, + const StyleComputedUrl* aOldImage) { + MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread()); + + StyleLoadData& data = LoadData(); + + MOZ_ASSERT(!(data.flags & StyleLoadDataFlags::TRIED_TO_RESOLVE_IMAGE)); + + data.flags |= StyleLoadDataFlags::TRIED_TO_RESOLVE_IMAGE; + + MOZ_ASSERT(NS_IsMainThread()); + + // TODO(emilio, bug 1440442): This is a hackaround to avoid flickering due the + // lack of non-http image caching in imagelib (bug 1406134), which causes + // stuff like bug 1439285. Cleanest fix if that doesn't get fixed is bug + // 1440305, but that seems too risky, and a lot of work to do before 60. + // + // Once that's fixed, the "old style" argument to TriggerImageLoads can go + // away, and same for mSharedCount in the image loader and so on. + const bool reuseProxy = nsContentUtils::IsChromeDoc(&aDocument) && + aOldImage && aOldImage->IsImageResolved() && + *this == *aOldImage; + + RefPtr<imgRequestProxy> request; + if (reuseProxy) { + request = aOldImage->LoadData().resolved_image; + if (request) { + css::ImageLoader::NoteSharedLoad(request); + } + } else { + request = css::ImageLoader::LoadImage(*this, aDocument); + } + + if (!request) { + return; + } + + data.resolved_image = request.forget().take(); + + // Boost priority now that we know the image is present in the ComputedStyle + // of some frame. + data.resolved_image->BoostPriority(imgIRequest::CATEGORY_FRAME_STYLE); +} + +/** + * Runnable to release the image request's mRequestProxy + * and mImageTracker on the main thread, and to perform + * any necessary unlocking and untracking of the image. + */ +class StyleImageRequestCleanupTask final : public mozilla::Runnable { + public: + explicit StyleImageRequestCleanupTask(StyleLoadData& aData) + : mozilla::Runnable("StyleImageRequestCleanupTask"), + mRequestProxy(dont_AddRef(aData.resolved_image)) { + MOZ_ASSERT(mRequestProxy); + aData.resolved_image = nullptr; + } + + NS_IMETHOD Run() final { + MOZ_ASSERT(NS_IsMainThread()); + css::ImageLoader::UnloadImage(mRequestProxy); + return NS_OK; + } + + protected: + virtual ~StyleImageRequestCleanupTask() { + MOZ_ASSERT(!mRequestProxy || NS_IsMainThread(), + "mRequestProxy destructor need to run on the main thread!"); + } + + private: + // Since we always dispatch this runnable to the main thread, these will be + // released on the main thread when the runnable itself is released. + RefPtr<imgRequestProxy> mRequestProxy; +}; + +// This is defined here for parallelism with LoadURI. +void Gecko_LoadData_Drop(StyleLoadData* aData) { + if (aData->resolved_image) { + // We want to dispatch this async to prevent reentrancy issues, as + // imgRequestProxy going away can destroy documents, etc, see bug 1677555. + auto task = MakeRefPtr<StyleImageRequestCleanupTask>(*aData); + SchedulerGroup::Dispatch(task.forget()); + } + + // URIs are safe to refcount from any thread. + NS_IF_RELEASE(aData->resolved_uri); +} + +// -------------------- +// nsStyleFont +// +nsStyleFont::nsStyleFont(const nsStyleFont& aSrc) + : mFont(aSrc.mFont), + mSize(aSrc.mSize), + mFontSizeFactor(aSrc.mFontSizeFactor), + mFontSizeOffset(aSrc.mFontSizeOffset), + mFontSizeKeyword(aSrc.mFontSizeKeyword), + mFontPalette(aSrc.mFontPalette), + mMathDepth(aSrc.mMathDepth), + mLineHeight(aSrc.mLineHeight), + mMathVariant(aSrc.mMathVariant), + mMathStyle(aSrc.mMathStyle), + mMinFontSizeRatio(aSrc.mMinFontSizeRatio), + mExplicitLanguage(aSrc.mExplicitLanguage), + mXTextScale(aSrc.mXTextScale), + mScriptUnconstrainedSize(aSrc.mScriptUnconstrainedSize), + mScriptMinSize(aSrc.mScriptMinSize), + mLanguage(aSrc.mLanguage) { + MOZ_COUNT_CTOR(nsStyleFont); +} + +static StyleXTextScale InitialTextScale(const Document& aDoc) { + if (nsContentUtils::IsChromeDoc(&aDoc) || + nsContentUtils::IsPDFJS(aDoc.NodePrincipal())) { + return StyleXTextScale::ZoomOnly; + } + return StyleXTextScale::All; +} + +nsStyleFont::nsStyleFont(const Document& aDocument) + : mFont(*aDocument.GetFontPrefsForLang(nullptr)->GetDefaultFont( + StyleGenericFontFamily::None)), + mSize(ZoomText(aDocument, mFont.size)), + mFontSizeFactor(1.0), + mFontSizeOffset{0}, + mFontSizeKeyword(StyleFontSizeKeyword::Medium), + mFontPalette(StyleFontPalette::Normal()), + mMathDepth(0), + mLineHeight(StyleLineHeight::Normal()), + mMathVariant(StyleMathVariant::None), + mMathStyle(StyleMathStyle::Normal), + mXTextScale(InitialTextScale(aDocument)), + mScriptUnconstrainedSize(mSize), + mScriptMinSize(Length::FromPixels( + CSSPixel::FromPoints(kMathMLDefaultScriptMinSizePt))), + mLanguage(aDocument.GetLanguageForStyle()) { + MOZ_COUNT_CTOR(nsStyleFont); + MOZ_ASSERT(NS_IsMainThread()); + mFont.family.is_initial = true; + mFont.size = mSize; + if (MinFontSizeEnabled()) { + const Length minimumFontSize = + aDocument.GetFontPrefsForLang(mLanguage)->mMinimumFontSize; + mFont.size = Length::FromPixels( + std::max(mSize.ToCSSPixels(), minimumFontSize.ToCSSPixels())); + } +} + +nsChangeHint nsStyleFont::CalcDifference(const nsStyleFont& aNewData) const { + MOZ_ASSERT(mXTextScale == aNewData.mXTextScale, + "expected -x-text-scale to be the same on both nsStyleFonts"); + if (mSize != aNewData.mSize || mLanguage != aNewData.mLanguage || + mExplicitLanguage != aNewData.mExplicitLanguage || + mMathVariant != aNewData.mMathVariant || + mMathStyle != aNewData.mMathStyle || + mMinFontSizeRatio != aNewData.mMinFontSizeRatio || + mLineHeight != aNewData.mLineHeight) { + return NS_STYLE_HINT_REFLOW; + } + + switch (mFont.CalcDifference(aNewData.mFont)) { + case nsFont::MaxDifference::eLayoutAffecting: + return NS_STYLE_HINT_REFLOW; + + case nsFont::MaxDifference::eVisual: + return NS_STYLE_HINT_VISUAL; + + case nsFont::MaxDifference::eNone: + break; + } + + if (mFontPalette != aNewData.mFontPalette) { + return NS_STYLE_HINT_VISUAL; + } + + // XXX Should any of these cause a non-nsChangeHint_NeutralChange change? + if (mMathDepth != aNewData.mMathDepth || + mScriptUnconstrainedSize != aNewData.mScriptUnconstrainedSize || + mScriptMinSize != aNewData.mScriptMinSize) { + return nsChangeHint_NeutralChange; + } + + return nsChangeHint(0); +} + +Length nsStyleFont::ZoomText(const Document& aDocument, Length aSize) { + if (auto* pc = aDocument.GetPresContext()) { + aSize.ScaleBy(pc->TextZoom()); + } + return aSize; +} + +template <typename T> +static StyleRect<T> StyleRectWithAllSides(const T& aSide) { + return {aSide, aSide, aSide, aSide}; +} + +nsStyleMargin::nsStyleMargin() + : mMargin(StyleRectWithAllSides( + LengthPercentageOrAuto::LengthPercentage(LengthPercentage::Zero()))), + mScrollMargin(StyleRectWithAllSides(StyleLength{0.})), + mOverflowClipMargin(StyleLength::Zero()) { + MOZ_COUNT_CTOR(nsStyleMargin); +} + +nsStyleMargin::nsStyleMargin(const nsStyleMargin& aSrc) + : mMargin(aSrc.mMargin), + mScrollMargin(aSrc.mScrollMargin), + mOverflowClipMargin(aSrc.mOverflowClipMargin) { + MOZ_COUNT_CTOR(nsStyleMargin); +} + +nsChangeHint nsStyleMargin::CalcDifference( + const nsStyleMargin& aNewData) const { + nsChangeHint hint = nsChangeHint(0); + + if (mMargin != aNewData.mMargin) { + // Margin differences can't affect descendant intrinsic sizes and + // don't need to force children to reflow. + hint |= nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition | + nsChangeHint_ClearAncestorIntrinsics; + } + + if (mScrollMargin != aNewData.mScrollMargin) { + // FIXME: Bug 1530253 Support re-snapping when scroll-margin changes. + hint |= nsChangeHint_NeutralChange; + } + + if (mOverflowClipMargin != aNewData.mOverflowClipMargin) { + hint |= nsChangeHint_UpdateOverflow | nsChangeHint_RepaintFrame; + } + + return hint; +} + +nsStylePadding::nsStylePadding() + : mPadding(StyleRectWithAllSides(LengthPercentage::Zero())), + mScrollPadding(StyleRectWithAllSides(LengthPercentageOrAuto::Auto())) { + MOZ_COUNT_CTOR(nsStylePadding); +} + +nsStylePadding::nsStylePadding(const nsStylePadding& aSrc) + : mPadding(aSrc.mPadding), mScrollPadding(aSrc.mScrollPadding) { + MOZ_COUNT_CTOR(nsStylePadding); +} + +nsChangeHint nsStylePadding::CalcDifference( + const nsStylePadding& aNewData) const { + nsChangeHint hint = nsChangeHint(0); + + if (mPadding != aNewData.mPadding) { + // Padding differences can't affect descendant intrinsic sizes, but do need + // to force children to reflow so that we can reposition them, since their + // offsets are from our frame bounds but our content rect's position within + // those bounds is moving. + // FIXME: It would be good to return a weaker hint here that doesn't + // force reflow of all descendants, but the hint would need to force + // reflow of the frame's children (see how + // ReflowInput::InitResizeFlags initializes the inline-resize flag). + hint |= NS_STYLE_HINT_REFLOW & ~nsChangeHint_ClearDescendantIntrinsics; + } + + if (mScrollPadding != aNewData.mScrollPadding) { + // FIXME: Bug 1530253 Support re-snapping when scroll-padding changes. + hint |= nsChangeHint_NeutralChange; + } + + return hint; +} + +static inline BorderRadius ZeroBorderRadius() { + auto zero = LengthPercentage::Zero(); + return {{{zero, zero}}, {{zero, zero}}, {{zero, zero}}, {{zero, zero}}}; +} + +nsStyleBorder::nsStyleBorder() + : mBorderRadius(ZeroBorderRadius()), + mBorderImageSource(StyleImage::None()), + mBorderImageWidth( + StyleRectWithAllSides(StyleBorderImageSideWidth::Number(1.))), + mBorderImageOutset( + StyleRectWithAllSides(StyleNonNegativeLengthOrNumber::Number(0.))), + mBorderImageSlice( + {StyleRectWithAllSides(StyleNumberOrPercentage::Percentage({1.})), + false}), + mBorderImageRepeatH(StyleBorderImageRepeat::Stretch), + mBorderImageRepeatV(StyleBorderImageRepeat::Stretch), + mFloatEdge(StyleFloatEdge::ContentBox), + mBoxDecorationBreak(StyleBoxDecorationBreak::Slice), + mBorderTopColor(StyleColor::CurrentColor()), + mBorderRightColor(StyleColor::CurrentColor()), + mBorderBottomColor(StyleColor::CurrentColor()), + mBorderLeftColor(StyleColor::CurrentColor()), + mComputedBorder(0, 0, 0, 0) { + MOZ_COUNT_CTOR(nsStyleBorder); + + nscoord medium = kMediumBorderWidth; + for (const auto side : mozilla::AllPhysicalSides()) { + mBorder.Side(side) = medium; + mBorderStyle[side] = StyleBorderStyle::None; + } +} + +nsStyleBorder::nsStyleBorder(const nsStyleBorder& aSrc) + : mBorderRadius(aSrc.mBorderRadius), + mBorderImageSource(aSrc.mBorderImageSource), + mBorderImageWidth(aSrc.mBorderImageWidth), + mBorderImageOutset(aSrc.mBorderImageOutset), + mBorderImageSlice(aSrc.mBorderImageSlice), + mBorderImageRepeatH(aSrc.mBorderImageRepeatH), + mBorderImageRepeatV(aSrc.mBorderImageRepeatV), + mFloatEdge(aSrc.mFloatEdge), + mBoxDecorationBreak(aSrc.mBoxDecorationBreak), + mBorderTopColor(aSrc.mBorderTopColor), + mBorderRightColor(aSrc.mBorderRightColor), + mBorderBottomColor(aSrc.mBorderBottomColor), + mBorderLeftColor(aSrc.mBorderLeftColor), + mComputedBorder(aSrc.mComputedBorder), + mBorder(aSrc.mBorder) { + MOZ_COUNT_CTOR(nsStyleBorder); + for (const auto side : mozilla::AllPhysicalSides()) { + mBorderStyle[side] = aSrc.mBorderStyle[side]; + } +} + +void nsStyleBorder::TriggerImageLoads(Document& aDocument, + const nsStyleBorder* aOldStyle) { + MOZ_ASSERT(NS_IsMainThread()); + + mBorderImageSource.ResolveImage( + aDocument, aOldStyle ? &aOldStyle->mBorderImageSource : nullptr); +} + +nsMargin nsStyleBorder::GetImageOutset() const { + // We don't check whether there is a border-image (which is OK since + // the initial values yields 0 outset) so that we don't have to + // reflow to update overflow areas when an image loads. + nsMargin outset; + for (const auto s : mozilla::AllPhysicalSides()) { + const auto& coord = mBorderImageOutset.Get(s); + nscoord value; + if (coord.IsLength()) { + value = coord.AsLength().ToAppUnits(); + } else { + MOZ_ASSERT(coord.IsNumber()); + value = coord.AsNumber() * mComputedBorder.Side(s); + } + outset.Side(s) = value; + } + return outset; +} + +nsChangeHint nsStyleBorder::CalcDifference( + const nsStyleBorder& aNewData) const { + // FIXME: XXXbz: As in nsStylePadding::CalcDifference, many of these + // differences should not need to clear descendant intrinsics. + // FIXME: It would be good to return a weaker hint for the + // GetComputedBorder() differences (and perhaps others) that doesn't + // force reflow of all descendants, but the hint would need to force + // reflow of the frame's children (see how + // ReflowInput::InitResizeFlags initializes the inline-resize flag). + if (GetComputedBorder() != aNewData.GetComputedBorder() || + mFloatEdge != aNewData.mFloatEdge || + mBorderImageOutset != aNewData.mBorderImageOutset || + mBoxDecorationBreak != aNewData.mBoxDecorationBreak) { + return NS_STYLE_HINT_REFLOW; + } + + for (const auto ix : mozilla::AllPhysicalSides()) { + // See the explanation in nsChangeHint.h of + // nsChangeHint_BorderStyleNoneChange . + // Furthermore, even though we know *this* side is 0 width, just + // assume a repaint hint for some other change rather than bother + // tracking this result through the rest of the function. + if (HasVisibleStyle(ix) != aNewData.HasVisibleStyle(ix)) { + return nsChangeHint_RepaintFrame | nsChangeHint_BorderStyleNoneChange; + } + } + + // Note that mBorderStyle stores not only the border style but also + // color-related flags. Given that we've already done an mComputedBorder + // comparison, border-style differences can only lead to a repaint hint. So + // it's OK to just compare the values directly -- if either the actual + // style or the color flags differ we want to repaint. + for (const auto ix : mozilla::AllPhysicalSides()) { + if (mBorderStyle[ix] != aNewData.mBorderStyle[ix] || + BorderColorFor(ix) != aNewData.BorderColorFor(ix)) { + return nsChangeHint_RepaintFrame; + } + } + + // Note that border radius also controls the outline radius if the + // layout.css.outline-follows-border-radius.enabled pref is set. Any + // optimizations here should apply to both. + if (mBorderRadius != aNewData.mBorderRadius) { + return nsChangeHint_RepaintFrame; + } + + // Loading status of the border image can be accessed in main thread only + // while CalcDifference might be executed on a background thread. As a + // result, we have to check mBorderImage* fields even before border image was + // actually loaded. + if (!mBorderImageSource.IsNone() || !aNewData.mBorderImageSource.IsNone()) { + if (mBorderImageSource != aNewData.mBorderImageSource || + mBorderImageRepeatH != aNewData.mBorderImageRepeatH || + mBorderImageRepeatV != aNewData.mBorderImageRepeatV || + mBorderImageSlice != aNewData.mBorderImageSlice || + mBorderImageWidth != aNewData.mBorderImageWidth) { + return nsChangeHint_RepaintFrame; + } + } + + // mBorder is the specified border value. Changes to this don't + // need any change processing, since we operate on the computed + // border values instead. + if (mBorder != aNewData.mBorder) { + return nsChangeHint_NeutralChange; + } + + // mBorderImage* fields are checked only when border-image is not 'none'. + if (mBorderImageSource != aNewData.mBorderImageSource || + mBorderImageRepeatH != aNewData.mBorderImageRepeatH || + mBorderImageRepeatV != aNewData.mBorderImageRepeatV || + mBorderImageSlice != aNewData.mBorderImageSlice || + mBorderImageWidth != aNewData.mBorderImageWidth) { + return nsChangeHint_NeutralChange; + } + + return nsChangeHint(0); +} + +nsStyleOutline::nsStyleOutline() + : mOutlineWidth(kMediumBorderWidth), + mOutlineOffset({0.0f}), + mOutlineColor(StyleColor::CurrentColor()), + mOutlineStyle(StyleOutlineStyle::BorderStyle(StyleBorderStyle::None)), + mActualOutlineWidth(0) { + MOZ_COUNT_CTOR(nsStyleOutline); +} + +nsStyleOutline::nsStyleOutline(const nsStyleOutline& aSrc) + : mOutlineWidth(aSrc.mOutlineWidth), + mOutlineOffset(aSrc.mOutlineOffset), + mOutlineColor(aSrc.mOutlineColor), + mOutlineStyle(aSrc.mOutlineStyle), + mActualOutlineWidth(aSrc.mActualOutlineWidth) { + MOZ_COUNT_CTOR(nsStyleOutline); +} + +nsChangeHint nsStyleOutline::CalcDifference( + const nsStyleOutline& aNewData) const { + const bool shouldPaintOutline = ShouldPaintOutline(); + // We need the explicit 'outline-style: auto' check because + // 'outline-style: auto' effectively also changes 'outline-width'. + if (shouldPaintOutline != aNewData.ShouldPaintOutline() || + mActualOutlineWidth != aNewData.mActualOutlineWidth || + mOutlineStyle.IsAuto() != aNewData.mOutlineStyle.IsAuto() || + (shouldPaintOutline && mOutlineOffset != aNewData.mOutlineOffset)) { + return nsChangeHint_UpdateOverflow | nsChangeHint_SchedulePaint | + nsChangeHint_RepaintFrame; + } + + if (mOutlineStyle != aNewData.mOutlineStyle || + mOutlineColor != aNewData.mOutlineColor) { + return shouldPaintOutline ? nsChangeHint_RepaintFrame + : nsChangeHint_NeutralChange; + } + + if (mOutlineWidth != aNewData.mOutlineWidth || + mOutlineOffset != aNewData.mOutlineOffset) { + return nsChangeHint_NeutralChange; + } + + return nsChangeHint(0); +} + +nsSize nsStyleOutline::EffectiveOffsetFor(const nsRect& aRect) const { + const nscoord offset = mOutlineOffset.ToAppUnits(); + + if (offset >= 0) { + // Fast path for non-negative offset values + return nsSize(offset, offset); + } + + return nsSize(std::max(offset, -(aRect.Width() / 2)), + std::max(offset, -(aRect.Height() / 2))); +} + +// -------------------- +// nsStyleList +// +nsStyleList::nsStyleList() + : mListStylePosition(StyleListStylePosition::Outside), + mQuotes(StyleQuotes::Auto()), + mListStyleImage(StyleImage::None()) { + MOZ_COUNT_CTOR(nsStyleList); + MOZ_ASSERT(NS_IsMainThread()); + + mCounterStyle = nsGkAtoms::disc; +} + +nsStyleList::nsStyleList(const nsStyleList& aSource) + : mListStylePosition(aSource.mListStylePosition), + mCounterStyle(aSource.mCounterStyle), + mQuotes(aSource.mQuotes), + mListStyleImage(aSource.mListStyleImage) { + MOZ_COUNT_CTOR(nsStyleList); +} + +void nsStyleList::TriggerImageLoads(Document& aDocument, + const nsStyleList* aOldStyle) { + MOZ_ASSERT(NS_IsMainThread()); + mListStyleImage.ResolveImage( + aDocument, aOldStyle ? &aOldStyle->mListStyleImage : nullptr); +} + +nsChangeHint nsStyleList::CalcDifference(const nsStyleList& aNewData, + const ComputedStyle& aOldStyle) const { + // If the quotes implementation is ever going to change we might not need + // a framechange here and a reflow should be sufficient. See bug 35768. + if (mQuotes != aNewData.mQuotes) { + return nsChangeHint_ReconstructFrame; + } + nsChangeHint hint = nsChangeHint(0); + // Only elements whose display value is list-item can be affected by + // list-style-{position,type,image}. This also relies on that when the display + // value changes from something else to list-item, that change itself would + // cause ReconstructFrame. + if (mListStylePosition != aNewData.mListStylePosition || + mCounterStyle != aNewData.mCounterStyle || + mListStyleImage != aNewData.mListStyleImage) { + if (aOldStyle.StyleDisplay()->IsListItem()) { + return nsChangeHint_ReconstructFrame; + } + // list-style-image may affect nsImageFrame for XUL elements, but that is + // dealt with explicitly in nsImageFrame::DidSetComputedStyle. + hint = nsChangeHint_NeutralChange; + } + return hint; +} + +already_AddRefed<nsIURI> nsStyleList::GetListStyleImageURI() const { + if (!mListStyleImage.IsUrl()) { + return nullptr; + } + + return do_AddRef(mListStyleImage.AsUrl().GetURI()); +} + +// -------------------- +// nsStyleXUL +// +nsStyleXUL::nsStyleXUL() + : mBoxFlex(0.0f), + mBoxOrdinal(1), + mBoxAlign(StyleBoxAlign::Stretch), + mBoxDirection(StyleBoxDirection::Normal), + mBoxOrient(StyleBoxOrient::Horizontal), + mBoxPack(StyleBoxPack::Start) { + MOZ_COUNT_CTOR(nsStyleXUL); +} + +nsStyleXUL::nsStyleXUL(const nsStyleXUL& aSource) + : mBoxFlex(aSource.mBoxFlex), + mBoxOrdinal(aSource.mBoxOrdinal), + mBoxAlign(aSource.mBoxAlign), + mBoxDirection(aSource.mBoxDirection), + mBoxOrient(aSource.mBoxOrient), + mBoxPack(aSource.mBoxPack) { + MOZ_COUNT_CTOR(nsStyleXUL); +} + +nsChangeHint nsStyleXUL::CalcDifference(const nsStyleXUL& aNewData) const { + if (mBoxAlign == aNewData.mBoxAlign && + mBoxDirection == aNewData.mBoxDirection && + mBoxFlex == aNewData.mBoxFlex && mBoxOrient == aNewData.mBoxOrient && + mBoxPack == aNewData.mBoxPack && mBoxOrdinal == aNewData.mBoxOrdinal) { + return nsChangeHint(0); + } + if (mBoxOrdinal != aNewData.mBoxOrdinal) { + return nsChangeHint_ReconstructFrame; + } + return NS_STYLE_HINT_REFLOW; +} + +// -------------------- +// nsStyleColumn +// +/* static */ const uint32_t nsStyleColumn::kMaxColumnCount; +/* static */ const uint32_t nsStyleColumn::kColumnCountAuto; + +nsStyleColumn::nsStyleColumn() + : mColumnWidth(LengthOrAuto::Auto()), + mColumnRuleColor(StyleColor::CurrentColor()), + mColumnRuleStyle(StyleBorderStyle::None), + mColumnRuleWidth(kMediumBorderWidth), + mActualColumnRuleWidth(0) { + MOZ_COUNT_CTOR(nsStyleColumn); +} + +nsStyleColumn::nsStyleColumn(const nsStyleColumn& aSource) + : mColumnCount(aSource.mColumnCount), + mColumnWidth(aSource.mColumnWidth), + mColumnRuleColor(aSource.mColumnRuleColor), + mColumnRuleStyle(aSource.mColumnRuleStyle), + mColumnFill(aSource.mColumnFill), + mColumnSpan(aSource.mColumnSpan), + mColumnRuleWidth(aSource.mColumnRuleWidth), + mActualColumnRuleWidth(aSource.mActualColumnRuleWidth) { + MOZ_COUNT_CTOR(nsStyleColumn); +} + +nsChangeHint nsStyleColumn::CalcDifference( + const nsStyleColumn& aNewData) const { + if (mColumnWidth.IsAuto() != aNewData.mColumnWidth.IsAuto() || + mColumnCount != aNewData.mColumnCount || + mColumnSpan != aNewData.mColumnSpan) { + // We force column count changes to do a reframe, because it's tricky to + // handle some edge cases where the column count gets smaller and content + // overflows. + // XXX not ideal + return nsChangeHint_ReconstructFrame; + } + + if (mColumnWidth != aNewData.mColumnWidth || + mColumnFill != aNewData.mColumnFill) { + return NS_STYLE_HINT_REFLOW; + } + + if (mActualColumnRuleWidth != aNewData.mActualColumnRuleWidth || + mColumnRuleStyle != aNewData.mColumnRuleStyle || + mColumnRuleColor != aNewData.mColumnRuleColor) { + return NS_STYLE_HINT_VISUAL; + } + + if (mColumnRuleWidth != aNewData.mColumnRuleWidth) { + return nsChangeHint_NeutralChange; + } + + return nsChangeHint(0); +} + +using SVGPaintFallback = StyleGenericSVGPaintFallback<StyleColor>; + +// -------------------- +// nsStyleSVG +// +nsStyleSVG::nsStyleSVG() + : mFill{StyleSVGPaintKind::Color(StyleColor::Black()), + SVGPaintFallback::Unset()}, + mStroke{StyleSVGPaintKind::None(), SVGPaintFallback::Unset()}, + mMarkerEnd(StyleUrlOrNone::None()), + mMarkerMid(StyleUrlOrNone::None()), + mMarkerStart(StyleUrlOrNone::None()), + mMozContextProperties{{}, {0}}, + mStrokeDasharray(StyleSVGStrokeDashArray::Values({})), + mStrokeDashoffset( + StyleSVGLength::LengthPercentage(LengthPercentage::Zero())), + mStrokeWidth( + StyleSVGWidth::LengthPercentage(LengthPercentage::FromPixels(1.0f))), + mFillOpacity(StyleSVGOpacity::Opacity(1.0f)), + mStrokeMiterlimit(4.0f), + mStrokeOpacity(StyleSVGOpacity::Opacity(1.0f)), + mClipRule(StyleFillRule::Nonzero), + mColorInterpolation(StyleColorInterpolation::Srgb), + mColorInterpolationFilters(StyleColorInterpolation::Linearrgb), + mFillRule(StyleFillRule::Nonzero), + mPaintOrder(0), + mShapeRendering(StyleShapeRendering::Auto), + mStrokeLinecap(StyleStrokeLinecap::Butt), + mStrokeLinejoin(StyleStrokeLinejoin::Miter), + mDominantBaseline(StyleDominantBaseline::Auto), + mTextAnchor(StyleTextAnchor::Start) { + MOZ_COUNT_CTOR(nsStyleSVG); +} + +nsStyleSVG::nsStyleSVG(const nsStyleSVG& aSource) + : mFill(aSource.mFill), + mStroke(aSource.mStroke), + mMarkerEnd(aSource.mMarkerEnd), + mMarkerMid(aSource.mMarkerMid), + mMarkerStart(aSource.mMarkerStart), + mMozContextProperties(aSource.mMozContextProperties), + mStrokeDasharray(aSource.mStrokeDasharray), + mStrokeDashoffset(aSource.mStrokeDashoffset), + mStrokeWidth(aSource.mStrokeWidth), + mFillOpacity(aSource.mFillOpacity), + mStrokeMiterlimit(aSource.mStrokeMiterlimit), + mStrokeOpacity(aSource.mStrokeOpacity), + mClipRule(aSource.mClipRule), + mColorInterpolation(aSource.mColorInterpolation), + mColorInterpolationFilters(aSource.mColorInterpolationFilters), + mFillRule(aSource.mFillRule), + mPaintOrder(aSource.mPaintOrder), + mShapeRendering(aSource.mShapeRendering), + mStrokeLinecap(aSource.mStrokeLinecap), + mStrokeLinejoin(aSource.mStrokeLinejoin), + mDominantBaseline(aSource.mDominantBaseline), + mTextAnchor(aSource.mTextAnchor) { + MOZ_COUNT_CTOR(nsStyleSVG); +} + +static bool PaintURIChanged(const StyleSVGPaint& aPaint1, + const StyleSVGPaint& aPaint2) { + if (aPaint1.kind.IsPaintServer() != aPaint2.kind.IsPaintServer()) { + return true; + } + return aPaint1.kind.IsPaintServer() && + aPaint1.kind.AsPaintServer() != aPaint2.kind.AsPaintServer(); +} + +nsChangeHint nsStyleSVG::CalcDifference(const nsStyleSVG& aNewData) const { + nsChangeHint hint = nsChangeHint(0); + + if (mMarkerEnd != aNewData.mMarkerEnd || mMarkerMid != aNewData.mMarkerMid || + mMarkerStart != aNewData.mMarkerStart) { + // Markers currently contribute to SVGGeometryFrame::mRect, + // so we need a reflow as well as a repaint. No intrinsic sizes need + // to change, so nsChangeHint_NeedReflow is sufficient. + return nsChangeHint_UpdateEffects | nsChangeHint_NeedReflow | + nsChangeHint_RepaintFrame; + } + + if (mFill != aNewData.mFill || mStroke != aNewData.mStroke || + mFillOpacity != aNewData.mFillOpacity || + mStrokeOpacity != aNewData.mStrokeOpacity) { + hint |= nsChangeHint_RepaintFrame; + if (HasStroke() != aNewData.HasStroke() || + (!HasStroke() && HasFill() != aNewData.HasFill())) { + // Frame bounds and overflow rects depend on whether we "have" fill or + // stroke. Whether we have stroke or not just changed, or else we have no + // stroke (in which case whether we have fill or not is significant to + // frame bounds) and whether we have fill or not just changed. In either + // case we need to reflow so the frame rect is updated. + // XXXperf this is a waste on non SVGGeometryFrames. + hint |= nsChangeHint_NeedReflow; + } + if (PaintURIChanged(mFill, aNewData.mFill) || + PaintURIChanged(mStroke, aNewData.mStroke)) { + hint |= nsChangeHint_UpdateEffects; + } + } + + // Stroke currently contributes to SVGGeometryFrame::mRect, so + // we need a reflow here. No intrinsic sizes need to change, so + // nsChangeHint_NeedReflow is sufficient. + // Note that stroke-dashoffset does not affect SVGGeometryFrame::mRect. + // text-anchor and dominant-baseline changes also require a reflow since + // they change frames' rects. + if (mStrokeWidth != aNewData.mStrokeWidth || + mStrokeMiterlimit != aNewData.mStrokeMiterlimit || + mStrokeLinecap != aNewData.mStrokeLinecap || + mStrokeLinejoin != aNewData.mStrokeLinejoin || + mDominantBaseline != aNewData.mDominantBaseline || + mTextAnchor != aNewData.mTextAnchor) { + return hint | nsChangeHint_NeedReflow | nsChangeHint_RepaintFrame; + } + + if (hint & nsChangeHint_RepaintFrame) { + return hint; // we don't add anything else below + } + + if (mStrokeDashoffset != aNewData.mStrokeDashoffset || + mClipRule != aNewData.mClipRule || + mColorInterpolation != aNewData.mColorInterpolation || + mColorInterpolationFilters != aNewData.mColorInterpolationFilters || + mFillRule != aNewData.mFillRule || mPaintOrder != aNewData.mPaintOrder || + mShapeRendering != aNewData.mShapeRendering || + mStrokeDasharray != aNewData.mStrokeDasharray || + mMozContextProperties.bits != aNewData.mMozContextProperties.bits) { + return hint | nsChangeHint_RepaintFrame; + } + + if (!hint) { + if (mMozContextProperties.idents != aNewData.mMozContextProperties.idents) { + hint = nsChangeHint_NeutralChange; + } + } + + return hint; +} + +// -------------------- +// nsStyleSVGReset +// +nsStyleSVGReset::nsStyleSVGReset() + : mX(LengthPercentage::Zero()), + mY(LengthPercentage::Zero()), + mCx(LengthPercentage::Zero()), + mCy(LengthPercentage::Zero()), + mRx(NonNegativeLengthPercentageOrAuto::Auto()), + mRy(NonNegativeLengthPercentageOrAuto::Auto()), + mR(NonNegativeLengthPercentage::Zero()), + mMask(nsStyleImageLayers::LayerType::Mask), + mClipPath(StyleClipPath::None()), + mStopColor(StyleColor::Black()), + mFloodColor(StyleColor::Black()), + mLightingColor(StyleColor::White()), + mStopOpacity(1.0f), + mFloodOpacity(1.0f), + mVectorEffect(StyleVectorEffect::None), + mMaskType(StyleMaskType::Luminance), + mD(StyleDProperty::None()) { + MOZ_COUNT_CTOR(nsStyleSVGReset); +} + +nsStyleSVGReset::nsStyleSVGReset(const nsStyleSVGReset& aSource) + : mX(aSource.mX), + mY(aSource.mY), + mCx(aSource.mCx), + mCy(aSource.mCy), + mRx(aSource.mRx), + mRy(aSource.mRy), + mR(aSource.mR), + mMask(aSource.mMask), + mClipPath(aSource.mClipPath), + mStopColor(aSource.mStopColor), + mFloodColor(aSource.mFloodColor), + mLightingColor(aSource.mLightingColor), + mStopOpacity(aSource.mStopOpacity), + mFloodOpacity(aSource.mFloodOpacity), + mVectorEffect(aSource.mVectorEffect), + mMaskType(aSource.mMaskType), + mD(aSource.mD) { + MOZ_COUNT_CTOR(nsStyleSVGReset); +} + +void nsStyleSVGReset::TriggerImageLoads(Document& aDocument, + const nsStyleSVGReset* aOldStyle) { + MOZ_ASSERT(NS_IsMainThread()); + // NOTE(emilio): we intentionally don't call TriggerImageLoads for clip-path. + + NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, mMask) { + auto& image = mMask.mLayers[i].mImage; + if (!image.IsImageRequestType()) { + continue; + } + const auto* url = image.GetImageRequestURLValue(); + // If the url is a local ref, it must be a <mask-resource>, so we don't + // need to resolve the style image. + if (url->IsLocalRef()) { + continue; + } +#if 0 + // XXX The old style system also checks whether this is a reference to + // the current document with reference, but it doesn't seem to be a + // behavior mentioned anywhere, so we comment out the code for now. + nsIURI* docURI = aPresContext->Document()->GetDocumentURI(); + if (url->EqualsExceptRef(docURI)) { + continue; + } +#endif + // Otherwise, we may need the image even if it has a reference, in case + // the referenced element isn't a valid SVG <mask> element. + const auto* oldImage = (aOldStyle && aOldStyle->mMask.mLayers.Length() > i) + ? &aOldStyle->mMask.mLayers[i].mImage + : nullptr; + + image.ResolveImage(aDocument, oldImage); + } +} + +nsChangeHint nsStyleSVGReset::CalcDifference( + const nsStyleSVGReset& aNewData) const { + nsChangeHint hint = nsChangeHint(0); + + if (mX != aNewData.mX || mY != aNewData.mY || mCx != aNewData.mCx || + mCy != aNewData.mCy || mR != aNewData.mR || mRx != aNewData.mRx || + mRy != aNewData.mRy || mD != aNewData.mD) { + hint |= nsChangeHint_InvalidateRenderingObservers | nsChangeHint_NeedReflow; + } + + if (mClipPath != aNewData.mClipPath) { + hint |= nsChangeHint_UpdateEffects | nsChangeHint_RepaintFrame; + } + + if (mVectorEffect != aNewData.mVectorEffect) { + // Stroke currently affects SVGGeometryFrame::mRect, and + // vector-effect affect stroke. As a result we need to reflow if + // vector-effect changes in order to have SVGGeometryFrame:: + // ReflowSVG called to update its mRect. No intrinsic sizes need + // to change so nsChangeHint_NeedReflow is sufficient. + hint |= nsChangeHint_NeedReflow | nsChangeHint_RepaintFrame; + } else if (mStopColor != aNewData.mStopColor || + mFloodColor != aNewData.mFloodColor || + mLightingColor != aNewData.mLightingColor || + mStopOpacity != aNewData.mStopOpacity || + mFloodOpacity != aNewData.mFloodOpacity || + mMaskType != aNewData.mMaskType || mD != aNewData.mD) { + hint |= nsChangeHint_RepaintFrame; + } + + hint |= + mMask.CalcDifference(aNewData.mMask, nsStyleImageLayers::LayerType::Mask); + + return hint; +} + +bool nsStyleSVGReset::HasMask() const { + for (uint32_t i = 0; i < mMask.mImageCount; i++) { + if (!mMask.mLayers[i].mImage.IsNone()) { + return true; + } + } + + return false; +} + +// -------------------- +// nsStylePage +// + +nsStylePage::nsStylePage(const nsStylePage& aSrc) + : mSize(aSrc.mSize), + mPage(aSrc.mPage), + mPageOrientation(aSrc.mPageOrientation) { + MOZ_COUNT_CTOR(nsStylePage); +} + +nsChangeHint nsStylePage::CalcDifference(const nsStylePage& aNewData) const { + // Page rule styling only matters when printing or using print preview. + if (aNewData.mSize != mSize || aNewData.mPage != mPage || + aNewData.mPageOrientation != mPageOrientation) { + return nsChangeHint_NeutralChange; + } + return nsChangeHint_Empty; +} + +// -------------------- +// nsStylePosition +// +nsStylePosition::nsStylePosition() + : mObjectPosition(Position::FromPercentage(0.5f)), + mOffset(StyleRectWithAllSides(LengthPercentageOrAuto::Auto())), + mWidth(StyleSize::Auto()), + mMinWidth(StyleSize::Auto()), + mMaxWidth(StyleMaxSize::None()), + mHeight(StyleSize::Auto()), + mMinHeight(StyleSize::Auto()), + mMaxHeight(StyleMaxSize::None()), + mFlexBasis(StyleFlexBasis::Size(StyleSize::Auto())), + mAspectRatio(StyleAspectRatio::Auto()), + mGridAutoFlow(StyleGridAutoFlow::ROW), + mMasonryAutoFlow( + {StyleMasonryPlacement::Pack, StyleMasonryItemOrder::DefiniteFirst}), + mAlignContent({StyleAlignFlags::NORMAL}), + mAlignItems({StyleAlignFlags::NORMAL}), + mAlignSelf({StyleAlignFlags::AUTO}), + mJustifyContent({StyleAlignFlags::NORMAL}), + mJustifyItems({{StyleAlignFlags::LEGACY}, {StyleAlignFlags::NORMAL}}), + mJustifySelf({StyleAlignFlags::AUTO}), + mFlexDirection(StyleFlexDirection::Row), + mFlexWrap(StyleFlexWrap::Nowrap), + mObjectFit(StyleObjectFit::Fill), + mBoxSizing(StyleBoxSizing::Content), + mOrder(0), + mFlexGrow(0.0f), + mFlexShrink(1.0f), + mZIndex(StyleZIndex::Auto()), + mGridTemplateColumns(StyleGridTemplateComponent::None()), + mGridTemplateRows(StyleGridTemplateComponent::None()), + mGridTemplateAreas(StyleGridTemplateAreas::None()), + mColumnGap(NonNegativeLengthPercentageOrNormal::Normal()), + mRowGap(NonNegativeLengthPercentageOrNormal::Normal()), + mContainIntrinsicWidth(StyleContainIntrinsicSize::None()), + mContainIntrinsicHeight(StyleContainIntrinsicSize::None()) { + MOZ_COUNT_CTOR(nsStylePosition); + + // The initial value of grid-auto-columns and grid-auto-rows is 'auto', + // which computes to 'minmax(auto, auto)'. + + // Other members get their default constructors + // which initialize them to representations of their respective initial value. + // mGridTemplate{Rows,Columns}: false and empty arrays for 'none' + // mGrid{Column,Row}{Start,End}: false/0/empty values for 'auto' +} + +nsStylePosition::nsStylePosition(const nsStylePosition& aSource) + : mAlignTracks(aSource.mAlignTracks), + mJustifyTracks(aSource.mJustifyTracks), + mObjectPosition(aSource.mObjectPosition), + mOffset(aSource.mOffset), + mWidth(aSource.mWidth), + mMinWidth(aSource.mMinWidth), + mMaxWidth(aSource.mMaxWidth), + mHeight(aSource.mHeight), + mMinHeight(aSource.mMinHeight), + mMaxHeight(aSource.mMaxHeight), + mFlexBasis(aSource.mFlexBasis), + mGridAutoColumns(aSource.mGridAutoColumns), + mGridAutoRows(aSource.mGridAutoRows), + mAspectRatio(aSource.mAspectRatio), + mGridAutoFlow(aSource.mGridAutoFlow), + mMasonryAutoFlow(aSource.mMasonryAutoFlow), + mAlignContent(aSource.mAlignContent), + mAlignItems(aSource.mAlignItems), + mAlignSelf(aSource.mAlignSelf), + mJustifyContent(aSource.mJustifyContent), + mJustifyItems(aSource.mJustifyItems), + mJustifySelf(aSource.mJustifySelf), + mFlexDirection(aSource.mFlexDirection), + mFlexWrap(aSource.mFlexWrap), + mObjectFit(aSource.mObjectFit), + mBoxSizing(aSource.mBoxSizing), + mOrder(aSource.mOrder), + mFlexGrow(aSource.mFlexGrow), + mFlexShrink(aSource.mFlexShrink), + mZIndex(aSource.mZIndex), + mGridTemplateColumns(aSource.mGridTemplateColumns), + mGridTemplateRows(aSource.mGridTemplateRows), + mGridTemplateAreas(aSource.mGridTemplateAreas), + mGridColumnStart(aSource.mGridColumnStart), + mGridColumnEnd(aSource.mGridColumnEnd), + mGridRowStart(aSource.mGridRowStart), + mGridRowEnd(aSource.mGridRowEnd), + mColumnGap(aSource.mColumnGap), + mRowGap(aSource.mRowGap), + mContainIntrinsicWidth(aSource.mContainIntrinsicWidth), + mContainIntrinsicHeight(aSource.mContainIntrinsicHeight) { + MOZ_COUNT_CTOR(nsStylePosition); +} + +static bool IsAutonessEqual(const StyleRect<LengthPercentageOrAuto>& aSides1, + const StyleRect<LengthPercentageOrAuto>& aSides2) { + for (const auto side : mozilla::AllPhysicalSides()) { + if (aSides1.Get(side).IsAuto() != aSides2.Get(side).IsAuto()) { + return false; + } + } + return true; +} + +nsChangeHint nsStylePosition::CalcDifference( + const nsStylePosition& aNewData, const ComputedStyle& aOldStyle) const { + if (mGridTemplateColumns.IsMasonry() != + aNewData.mGridTemplateColumns.IsMasonry() || + mGridTemplateRows.IsMasonry() != aNewData.mGridTemplateRows.IsMasonry()) { + // XXXmats this could be optimized to AllReflowHints with a bit of work, + // but I'll assume this is a very rare use case in practice. (bug 1623886) + return nsChangeHint_ReconstructFrame; + } + + nsChangeHint hint = nsChangeHint(0); + + // Changes to "z-index" require a repaint. + if (mZIndex != aNewData.mZIndex) { + hint |= nsChangeHint_RepaintFrame; + } + + // Changes to "object-fit" & "object-position" require a repaint. They + // may also require a reflow, if we have a nsSubDocumentFrame, so that we + // can adjust the size & position of the subdocument. + if (mObjectFit != aNewData.mObjectFit || + mObjectPosition != aNewData.mObjectPosition) { + hint |= nsChangeHint_RepaintFrame | nsChangeHint_NeedReflow; + } + + if (mContainIntrinsicWidth != aNewData.mContainIntrinsicWidth || + mContainIntrinsicHeight != aNewData.mContainIntrinsicHeight) { + hint |= NS_STYLE_HINT_REFLOW; + } + + if (mOrder != aNewData.mOrder) { + // "order" impacts both layout order and stacking order, so we need both a + // reflow and a repaint when it changes. (Technically, we only need a + // reflow if we're in a multi-line flexbox (which we can't be sure about, + // since that's determined by styling on our parent) -- there, "order" can + // affect which flex line we end up on, & hence can affect our sizing by + // changing the group of flex items we're competing with for space.) + return hint | nsChangeHint_RepaintFrame | nsChangeHint_AllReflowHints; + } + + if (mBoxSizing != aNewData.mBoxSizing) { + // Can affect both widths and heights; just a bad scene. + return hint | nsChangeHint_AllReflowHints; + } + + if (mAlignItems != aNewData.mAlignItems || + mAlignSelf != aNewData.mAlignSelf || + mJustifyTracks != aNewData.mJustifyTracks || + mAlignTracks != aNewData.mAlignTracks) { + return hint | nsChangeHint_AllReflowHints; + } + + // Properties that apply to flex items: + // XXXdholbert These should probably be more targeted (bug 819536) + if (mFlexBasis != aNewData.mFlexBasis || mFlexGrow != aNewData.mFlexGrow || + mFlexShrink != aNewData.mFlexShrink) { + return hint | nsChangeHint_AllReflowHints; + } + + // Properties that apply to flex containers: + // - flex-direction can swap a flex container between vertical & horizontal. + // - flex-wrap changes whether a flex container's children are wrapped, which + // impacts their sizing/positioning and hence impacts the container's size. + if (mFlexDirection != aNewData.mFlexDirection || + mFlexWrap != aNewData.mFlexWrap) { + return hint | nsChangeHint_AllReflowHints; + } + + // Properties that apply to grid containers: + // FIXME: only for grid containers + // (ie. 'display: grid' or 'display: inline-grid') + if (mGridTemplateColumns != aNewData.mGridTemplateColumns || + mGridTemplateRows != aNewData.mGridTemplateRows || + mGridTemplateAreas != aNewData.mGridTemplateAreas || + mGridAutoColumns != aNewData.mGridAutoColumns || + mGridAutoRows != aNewData.mGridAutoRows || + mGridAutoFlow != aNewData.mGridAutoFlow || + mMasonryAutoFlow != aNewData.mMasonryAutoFlow) { + return hint | nsChangeHint_AllReflowHints; + } + + // Properties that apply to grid items: + // FIXME: only for grid items + // (ie. parent frame is 'display: grid' or 'display: inline-grid') + if (mGridColumnStart != aNewData.mGridColumnStart || + mGridColumnEnd != aNewData.mGridColumnEnd || + mGridRowStart != aNewData.mGridRowStart || + mGridRowEnd != aNewData.mGridRowEnd || + mColumnGap != aNewData.mColumnGap || mRowGap != aNewData.mRowGap) { + return hint | nsChangeHint_AllReflowHints; + } + + // Changing 'justify-content/items/self' might affect the positioning, + // but it won't affect any sizing. + if (mJustifyContent != aNewData.mJustifyContent || + mJustifyItems.computed != aNewData.mJustifyItems.computed || + mJustifySelf != aNewData.mJustifySelf) { + hint |= nsChangeHint_NeedReflow; + } + + // No need to do anything if specified justify-items changes, as long as the + // computed one (tested above) is unchanged. + if (mJustifyItems.specified != aNewData.mJustifyItems.specified) { + hint |= nsChangeHint_NeutralChange; + } + + // 'align-content' doesn't apply to a single-line flexbox but we don't know + // if we're a flex container at this point so we can't optimize for that. + if (mAlignContent != aNewData.mAlignContent) { + hint |= nsChangeHint_NeedReflow; + } + + bool widthChanged = mWidth != aNewData.mWidth || + mMinWidth != aNewData.mMinWidth || + mMaxWidth != aNewData.mMaxWidth; + bool heightChanged = mHeight != aNewData.mHeight || + mMinHeight != aNewData.mMinHeight || + mMaxHeight != aNewData.mMaxHeight; + + if (widthChanged || heightChanged) { + // It doesn't matter whether we're looking at the old or new visibility + // struct, since a change between vertical and horizontal writing-mode will + // cause a reframe. + const bool isVertical = aOldStyle.StyleVisibility()->mWritingMode != + StyleWritingModeProperty::HorizontalTb; + if (isVertical ? widthChanged : heightChanged) { + hint |= nsChangeHint_ReflowHintsForBSizeChange; + } + if (isVertical ? heightChanged : widthChanged) { + hint |= nsChangeHint_ReflowHintsForISizeChange; + } + } + + if (mAspectRatio != aNewData.mAspectRatio) { + hint |= nsChangeHint_ReflowHintsForISizeChange | + nsChangeHint_ReflowHintsForBSizeChange; + } + + // If any of the offsets have changed, then return the respective hints + // so that we would hopefully be able to avoid reflowing. + // Note that it is possible that we'll need to reflow when processing + // restyles, but we don't have enough information to make a good decision + // right now. + // Don't try to handle changes between "auto" and non-auto efficiently; + // that's tricky to do and will hardly ever be able to avoid a reflow. + if (mOffset != aNewData.mOffset) { + if (IsAutonessEqual(mOffset, aNewData.mOffset)) { + hint |= + nsChangeHint_RecomputePosition | nsChangeHint_UpdateParentOverflow; + } else { + hint |= + nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition; + } + } + return hint; +} + +const StyleContainIntrinsicSize& nsStylePosition::ContainIntrinsicBSize( + const WritingMode& aWM) const { + return aWM.IsVertical() ? mContainIntrinsicWidth : mContainIntrinsicHeight; +} + +const StyleContainIntrinsicSize& nsStylePosition::ContainIntrinsicISize( + const WritingMode& aWM) const { + return aWM.IsVertical() ? mContainIntrinsicHeight : mContainIntrinsicWidth; +} + +StyleAlignSelf nsStylePosition::UsedAlignSelf( + const ComputedStyle* aParent) const { + if (mAlignSelf._0 != StyleAlignFlags::AUTO) { + return mAlignSelf; + } + if (MOZ_LIKELY(aParent)) { + auto parentAlignItems = aParent->StylePosition()->mAlignItems; + MOZ_ASSERT(!(parentAlignItems._0 & StyleAlignFlags::LEGACY), + "align-items can't have 'legacy'"); + return {parentAlignItems._0}; + } + return {StyleAlignFlags::NORMAL}; +} + +StyleJustifySelf nsStylePosition::UsedJustifySelf( + const ComputedStyle* aParent) const { + if (mJustifySelf._0 != StyleAlignFlags::AUTO) { + return mJustifySelf; + } + if (MOZ_LIKELY(aParent)) { + const auto& inheritedJustifyItems = + aParent->StylePosition()->mJustifyItems.computed; + return {inheritedJustifyItems._0 & ~StyleAlignFlags::LEGACY}; + } + return {StyleAlignFlags::NORMAL}; +} + +// -------------------- +// nsStyleTable +// + +nsStyleTable::nsStyleTable() + : mLayoutStrategy(StyleTableLayout::Auto), mXSpan(1) { + MOZ_COUNT_CTOR(nsStyleTable); +} + +nsStyleTable::nsStyleTable(const nsStyleTable& aSource) + : mLayoutStrategy(aSource.mLayoutStrategy), mXSpan(aSource.mXSpan) { + MOZ_COUNT_CTOR(nsStyleTable); +} + +nsChangeHint nsStyleTable::CalcDifference(const nsStyleTable& aNewData) const { + if (mXSpan != aNewData.mXSpan || + mLayoutStrategy != aNewData.mLayoutStrategy) { + return nsChangeHint_ReconstructFrame; + } + return nsChangeHint(0); +} + +// ----------------------- +// nsStyleTableBorder + +nsStyleTableBorder::nsStyleTableBorder() + : mBorderSpacingCol(0), + mBorderSpacingRow(0), + mBorderCollapse(StyleBorderCollapse::Separate), + mCaptionSide(StyleCaptionSide::Top), + mEmptyCells(StyleEmptyCells::Show) { + MOZ_COUNT_CTOR(nsStyleTableBorder); +} + +nsStyleTableBorder::nsStyleTableBorder(const nsStyleTableBorder& aSource) + : mBorderSpacingCol(aSource.mBorderSpacingCol), + mBorderSpacingRow(aSource.mBorderSpacingRow), + mBorderCollapse(aSource.mBorderCollapse), + mCaptionSide(aSource.mCaptionSide), + mEmptyCells(aSource.mEmptyCells) { + MOZ_COUNT_CTOR(nsStyleTableBorder); +} + +nsChangeHint nsStyleTableBorder::CalcDifference( + const nsStyleTableBorder& aNewData) const { + // Border-collapse changes need a reframe, because we use a different frame + // class for table cells in the collapsed border model. This is used to + // conserve memory when using the separated border model (collapsed borders + // require extra state to be stored). + if (mBorderCollapse != aNewData.mBorderCollapse) { + return nsChangeHint_ReconstructFrame; + } + + if (mCaptionSide == aNewData.mCaptionSide && + mBorderSpacingCol == aNewData.mBorderSpacingCol && + mBorderSpacingRow == aNewData.mBorderSpacingRow) { + if (mEmptyCells == aNewData.mEmptyCells) { + return nsChangeHint(0); + } + return NS_STYLE_HINT_VISUAL; + } + return NS_STYLE_HINT_REFLOW; +} + +template <typename T> +static bool GradientItemsAreOpaque( + Span<const StyleGenericGradientItem<StyleColor, T>> aItems) { + for (auto& stop : aItems) { + if (stop.IsInterpolationHint()) { + continue; + } + + auto& color = stop.IsSimpleColorStop() ? stop.AsSimpleColorStop() + : stop.AsComplexColorStop().color; + if (color.MaybeTransparent()) { + // We don't know the foreground color here, so if it's being used + // we must assume it might be transparent. + return false; + } + } + + return true; +} + +template <> +bool StyleGradient::IsOpaque() const { + if (IsLinear()) { + return GradientItemsAreOpaque(AsLinear().items.AsSpan()); + } + if (IsRadial()) { + return GradientItemsAreOpaque(AsRadial().items.AsSpan()); + } + return GradientItemsAreOpaque(AsConic().items.AsSpan()); +} + +template <> +bool StyleImage::IsOpaque() const { + if (IsImageSet()) { + return FinalImage().IsOpaque(); + } + + if (!IsComplete()) { + return false; + } + + if (IsGradient()) { + return AsGradient()->IsOpaque(); + } + + if (IsElement()) { + return false; + } + + MOZ_ASSERT(IsImageRequestType(), "unexpected image type"); + MOZ_ASSERT(GetImageRequest(), "should've returned earlier above"); + + nsCOMPtr<imgIContainer> imageContainer; + GetImageRequest()->GetImage(getter_AddRefs(imageContainer)); + MOZ_ASSERT(imageContainer, "IsComplete() said image container is ready"); + + return imageContainer->WillDrawOpaqueNow(); +} + +template <> +bool StyleImage::IsComplete() const { + switch (tag) { + case Tag::None: + return false; + case Tag::Gradient: + case Tag::Element: + return true; + case Tag::Url: { + if (!IsResolved()) { + return false; + } + imgRequestProxy* req = GetImageRequest(); + if (!req) { + return false; + } + uint32_t status = imgIRequest::STATUS_ERROR; + return NS_SUCCEEDED(req->GetImageStatus(&status)) && + (status & imgIRequest::STATUS_SIZE_AVAILABLE) && + (status & imgIRequest::STATUS_FRAME_COMPLETE); + } + case Tag::ImageSet: + return FinalImage().IsComplete(); + // Bug 546052 cross-fade not yet implemented. + case Tag::CrossFade: + return true; + } + MOZ_ASSERT_UNREACHABLE("unexpected image type"); + return false; +} + +template <> +bool StyleImage::IsSizeAvailable() const { + switch (tag) { + case Tag::None: + return false; + case Tag::Gradient: + case Tag::Element: + return true; + case Tag::Url: { + imgRequestProxy* req = GetImageRequest(); + if (!req) { + return false; + } + uint32_t status = imgIRequest::STATUS_ERROR; + return NS_SUCCEEDED(req->GetImageStatus(&status)) && + !(status & imgIRequest::STATUS_ERROR) && + (status & imgIRequest::STATUS_SIZE_AVAILABLE); + } + case Tag::ImageSet: + return FinalImage().IsSizeAvailable(); + case Tag::CrossFade: + // TODO: Bug 546052 cross-fade not yet implemented. + return true; + } + MOZ_ASSERT_UNREACHABLE("unexpected image type"); + return false; +} + +template <> +void StyleImage::ResolveImage(Document& aDoc, const StyleImage* aOld) { + if (IsResolved()) { + return; + } + const auto* old = aOld ? aOld->GetImageRequestURLValue() : nullptr; + const auto* url = GetImageRequestURLValue(); + // We could avoid this const_cast generating more code but it's not really + // worth it. + const_cast<StyleComputedImageUrl*>(url)->ResolveImage(aDoc, old); +} + +template <> +ImageResolution StyleImage::GetResolution(const ComputedStyle& aStyle) const { + ImageResolution resolution; + if (imgRequestProxy* request = GetImageRequest()) { + RefPtr<imgIContainer> image; + request->GetImage(getter_AddRefs(image)); + if (image) { + resolution = image->GetResolution(); + } + } + if (IsImageSet()) { + const auto& set = *AsImageSet(); + auto items = set.items.AsSpan(); + if (MOZ_LIKELY(set.selected_index < items.Length())) { + float r = items[set.selected_index].resolution._0; + resolution.ScaleBy(r); + } + } + if (aStyle.EffectiveZoom() != StyleZoom::ONE) { + resolution.ScaleBy(1.0f / aStyle.EffectiveZoom().ToFloat()); + } + return resolution; +} + +// -------------------- +// nsStyleImageLayers +// + +const nsCSSPropertyID nsStyleImageLayers::kBackgroundLayerTable[] = { + eCSSProperty_background, // shorthand + eCSSProperty_background_color, // color + eCSSProperty_background_image, // image + eCSSProperty_background_repeat, // repeat + eCSSProperty_background_position_x, // positionX + eCSSProperty_background_position_y, // positionY + eCSSProperty_background_clip, // clip + eCSSProperty_background_origin, // origin + eCSSProperty_background_size, // size + eCSSProperty_background_attachment, // attachment + eCSSProperty_UNKNOWN, // maskMode + eCSSProperty_UNKNOWN // composite +}; + +const nsCSSPropertyID nsStyleImageLayers::kMaskLayerTable[] = { + eCSSProperty_mask, // shorthand + eCSSProperty_UNKNOWN, // color + eCSSProperty_mask_image, // image + eCSSProperty_mask_repeat, // repeat + eCSSProperty_mask_position_x, // positionX + eCSSProperty_mask_position_y, // positionY + eCSSProperty_mask_clip, // clip + eCSSProperty_mask_origin, // origin + eCSSProperty_mask_size, // size + eCSSProperty_UNKNOWN, // attachment + eCSSProperty_mask_mode, // maskMode + eCSSProperty_mask_composite // composite +}; + +nsStyleImageLayers::nsStyleImageLayers(nsStyleImageLayers::LayerType aType) + : mAttachmentCount(1), + mClipCount(1), + mOriginCount(1), + mRepeatCount(1), + mPositionXCount(1), + mPositionYCount(1), + mImageCount(1), + mSizeCount(1), + mMaskModeCount(1), + mBlendModeCount(1), + mCompositeCount(1), + mLayers(nsStyleAutoArray<Layer>::WITH_SINGLE_INITIAL_ELEMENT) { + // Ensure first layer is initialized as specified layer type + mLayers[0].Initialize(aType); +} + +nsStyleImageLayers::nsStyleImageLayers(const nsStyleImageLayers& aSource) + : mAttachmentCount(aSource.mAttachmentCount), + mClipCount(aSource.mClipCount), + mOriginCount(aSource.mOriginCount), + mRepeatCount(aSource.mRepeatCount), + mPositionXCount(aSource.mPositionXCount), + mPositionYCount(aSource.mPositionYCount), + mImageCount(aSource.mImageCount), + mSizeCount(aSource.mSizeCount), + mMaskModeCount(aSource.mMaskModeCount), + mBlendModeCount(aSource.mBlendModeCount), + mCompositeCount(aSource.mCompositeCount), + mLayers(aSource.mLayers.Clone()) {} + +static bool AnyLayerIsElementImage(const nsStyleImageLayers& aLayers) { + NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, aLayers) { + if (aLayers.mLayers[i].mImage.FinalImage().IsElement()) { + return true; + } + } + return false; +} + +nsChangeHint nsStyleImageLayers::CalcDifference( + const nsStyleImageLayers& aNewLayers, LayerType aType) const { + nsChangeHint hint = nsChangeHint(0); + + // If the number of visible images changes, then it's easy-peasy. + if (mImageCount != aNewLayers.mImageCount) { + hint |= nsChangeHint_RepaintFrame; + if (aType == nsStyleImageLayers::LayerType::Mask || + AnyLayerIsElementImage(*this) || AnyLayerIsElementImage(aNewLayers)) { + hint |= nsChangeHint_UpdateEffects; + } + return hint; + } + + const nsStyleImageLayers& moreLayers = + mLayers.Length() > aNewLayers.mLayers.Length() ? *this : aNewLayers; + const nsStyleImageLayers& lessLayers = + mLayers.Length() > aNewLayers.mLayers.Length() ? aNewLayers : *this; + + for (size_t i = 0; i < moreLayers.mLayers.Length(); ++i) { + const Layer& moreLayersLayer = moreLayers.mLayers[i]; + if (i < moreLayers.mImageCount) { + // This is a visible image we're diffing, we may need to repaint. + const Layer& lessLayersLayer = lessLayers.mLayers[i]; + nsChangeHint layerDifference = + moreLayersLayer.CalcDifference(lessLayersLayer); + if (layerDifference && + (moreLayersLayer.mImage.FinalImage().IsElement() || + lessLayersLayer.mImage.FinalImage().IsElement())) { + layerDifference |= + nsChangeHint_UpdateEffects | nsChangeHint_RepaintFrame; + } + hint |= layerDifference; + continue; + } + if (hint) { + // If they're different by now, we're done. + return hint; + } + if (i >= lessLayers.mLayers.Length()) { + // The layer count differs, we know some property has changed, but if we + // got here we know it won't affect rendering. + return nsChangeHint_NeutralChange; + } + + const Layer& lessLayersLayer = lessLayers.mLayers[i]; + MOZ_ASSERT(moreLayersLayer.mImage.IsNone()); + MOZ_ASSERT(lessLayersLayer.mImage.IsNone()); + if (moreLayersLayer.CalcDifference(lessLayersLayer)) { + // We don't care about the difference returned, we know it's not visible, + // but if something changed, then we need to return the neutral change. + return nsChangeHint_NeutralChange; + } + } + + if (hint) { + // If they're different by now, we're done. + return hint; + } + + // We could have same layers and values, but different count still. + if (mAttachmentCount != aNewLayers.mAttachmentCount || + mBlendModeCount != aNewLayers.mBlendModeCount || + mClipCount != aNewLayers.mClipCount || + mCompositeCount != aNewLayers.mCompositeCount || + mMaskModeCount != aNewLayers.mMaskModeCount || + mOriginCount != aNewLayers.mOriginCount || + mRepeatCount != aNewLayers.mRepeatCount || + mPositionXCount != aNewLayers.mPositionXCount || + mPositionYCount != aNewLayers.mPositionYCount || + mSizeCount != aNewLayers.mSizeCount) { + hint |= nsChangeHint_NeutralChange; + } + + return hint; +} + +nsStyleImageLayers& nsStyleImageLayers::operator=( + const nsStyleImageLayers& aOther) { + mAttachmentCount = aOther.mAttachmentCount; + mClipCount = aOther.mClipCount; + mOriginCount = aOther.mOriginCount; + mRepeatCount = aOther.mRepeatCount; + mPositionXCount = aOther.mPositionXCount; + mPositionYCount = aOther.mPositionYCount; + mImageCount = aOther.mImageCount; + mSizeCount = aOther.mSizeCount; + mMaskModeCount = aOther.mMaskModeCount; + mBlendModeCount = aOther.mBlendModeCount; + mCompositeCount = aOther.mCompositeCount; + mLayers = aOther.mLayers.Clone(); + + return *this; +} + +bool nsStyleImageLayers::operator==(const nsStyleImageLayers& aOther) const { + if (mAttachmentCount != aOther.mAttachmentCount || + mClipCount != aOther.mClipCount || mOriginCount != aOther.mOriginCount || + mRepeatCount != aOther.mRepeatCount || + mPositionXCount != aOther.mPositionXCount || + mPositionYCount != aOther.mPositionYCount || + mImageCount != aOther.mImageCount || mSizeCount != aOther.mSizeCount || + mMaskModeCount != aOther.mMaskModeCount || + mBlendModeCount != aOther.mBlendModeCount) { + return false; + } + + if (mLayers.Length() != aOther.mLayers.Length()) { + return false; + } + + for (uint32_t i = 0; i < mLayers.Length(); i++) { + if (mLayers[i].mPosition != aOther.mLayers[i].mPosition || + mLayers[i].mImage != aOther.mLayers[i].mImage || + mLayers[i].mSize != aOther.mLayers[i].mSize || + mLayers[i].mClip != aOther.mLayers[i].mClip || + mLayers[i].mOrigin != aOther.mLayers[i].mOrigin || + mLayers[i].mAttachment != aOther.mLayers[i].mAttachment || + mLayers[i].mBlendMode != aOther.mLayers[i].mBlendMode || + mLayers[i].mComposite != aOther.mLayers[i].mComposite || + mLayers[i].mMaskMode != aOther.mLayers[i].mMaskMode || + mLayers[i].mRepeat != aOther.mLayers[i].mRepeat) { + return false; + } + } + + return true; +} + +static bool SizeDependsOnPositioningAreaSize(const StyleBackgroundSize& aSize, + const StyleImage& aImage) { + MOZ_ASSERT(!aImage.IsNone(), "caller should have handled this"); + MOZ_ASSERT(!aImage.IsImageSet(), "caller should have handled this"); + + // Contain and cover straightforwardly depend on frame size. + if (aSize.IsCover() || aSize.IsContain()) { + return true; + } + + MOZ_ASSERT(aSize.IsExplicitSize()); + const auto& size = aSize.AsExplicitSize(); + + // If either dimension contains a non-zero percentage, rendering for that + // dimension straightforwardly depends on frame size. + if (size.width.HasPercent() || size.height.HasPercent()) { + return true; + } + + // If both dimensions are fixed lengths, there's no dependency. + if (!size.width.IsAuto() && !size.height.IsAuto()) { + return false; + } + + // Gradient rendering depends on frame size when auto is involved because + // gradients have no intrinsic ratio or dimensions, and therefore the relevant + // dimension is "treat[ed] as 100%". + if (aImage.IsGradient()) { + return true; + } + + // XXX Element rendering for auto or fixed length doesn't depend on frame size + // according to the spec. However, we don't implement the spec yet, so + // for now we bail and say element() plus auto affects ultimate size. + if (aImage.IsElement()) { + return true; + } + + MOZ_ASSERT(aImage.IsImageRequestType(), "Missed some image"); + if (auto* request = aImage.GetImageRequest()) { + nsCOMPtr<imgIContainer> imgContainer; + request->GetImage(getter_AddRefs(imgContainer)); + if (imgContainer) { + CSSIntSize imageSize; + AspectRatio imageRatio; + bool hasWidth, hasHeight; + // We could bother getting the right resolution here but it doesn't matter + // since we ignore `imageSize`. + nsLayoutUtils::ComputeSizeForDrawing(imgContainer, ImageResolution(), + imageSize, imageRatio, hasWidth, + hasHeight); + + // If the image has a fixed width and height, rendering never depends on + // the frame size. + if (hasWidth && hasHeight) { + return false; + } + + // If the image has an intrinsic ratio, rendering will depend on frame + // size when background-size is all auto. + if (imageRatio) { + return size.width.IsAuto() == size.height.IsAuto(); + } + + // Otherwise, rendering depends on frame size when the image dimensions + // and background-size don't complement each other. + return !(hasWidth && size.width.IsLengthPercentage()) && + !(hasHeight && size.height.IsLengthPercentage()); + } + } + + // Passed the gauntlet: no dependency. + return false; +} + +nsStyleImageLayers::Layer::Layer() + : mImage(StyleImage::None()), + mSize(StyleBackgroundSize::ExplicitSize(LengthPercentageOrAuto::Auto(), + LengthPercentageOrAuto::Auto())), + + mClip(StyleGeometryBox::BorderBox), + mAttachment(StyleImageLayerAttachment::Scroll), + mBlendMode(StyleBlend::Normal), + mComposite(StyleMaskComposite::Add), + mMaskMode(StyleMaskMode::MatchSource) {} + +nsStyleImageLayers::Layer::~Layer() = default; + +void nsStyleImageLayers::Layer::Initialize( + nsStyleImageLayers::LayerType aType) { + mPosition = Position::FromPercentage(0.); + + if (aType == LayerType::Background) { + mOrigin = StyleGeometryBox::PaddingBox; + } else { + MOZ_ASSERT(aType == LayerType::Mask, "unsupported layer type."); + mOrigin = StyleGeometryBox::BorderBox; + } +} + +bool nsStyleImageLayers::Layer:: + RenderingMightDependOnPositioningAreaSizeChange() const { + // Do we even have an image? + if (mImage.IsNone()) { + return false; + } + + return mPosition.DependsOnPositioningAreaSize() || + SizeDependsOnPositioningAreaSize(mSize, mImage.FinalImage()) || + mRepeat.DependsOnPositioningAreaSize(); +} + +bool nsStyleImageLayers::Layer::operator==(const Layer& aOther) const { + return mAttachment == aOther.mAttachment && mClip == aOther.mClip && + mOrigin == aOther.mOrigin && mRepeat == aOther.mRepeat && + mBlendMode == aOther.mBlendMode && mPosition == aOther.mPosition && + mSize == aOther.mSize && mImage == aOther.mImage && + mMaskMode == aOther.mMaskMode && mComposite == aOther.mComposite; +} + +template <class ComputedValueItem> +static void FillImageLayerList( + nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers, + ComputedValueItem nsStyleImageLayers::Layer::*aResultLocation, + uint32_t aItemCount, uint32_t aFillCount) { + MOZ_ASSERT(aFillCount <= aLayers.Length(), "unexpected array length"); + for (uint32_t sourceLayer = 0, destLayer = aItemCount; destLayer < aFillCount; + ++sourceLayer, ++destLayer) { + aLayers[destLayer].*aResultLocation = aLayers[sourceLayer].*aResultLocation; + } +} + +// The same as FillImageLayerList, but for values stored in +// layer.mPosition.*aResultLocation instead of layer.*aResultLocation. +static void FillImageLayerPositionCoordList( + nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers, + LengthPercentage Position::*aResultLocation, uint32_t aItemCount, + uint32_t aFillCount) { + MOZ_ASSERT(aFillCount <= aLayers.Length(), "unexpected array length"); + for (uint32_t sourceLayer = 0, destLayer = aItemCount; destLayer < aFillCount; + ++sourceLayer, ++destLayer) { + aLayers[destLayer].mPosition.*aResultLocation = + aLayers[sourceLayer].mPosition.*aResultLocation; + } +} + +void nsStyleImageLayers::FillAllLayers(uint32_t aMaxItemCount) { + // Delete any extra items. We need to keep layers in which any + // property was specified. + mLayers.TruncateLengthNonZero(aMaxItemCount); + + uint32_t fillCount = mImageCount; + FillImageLayerList(mLayers, &Layer::mImage, mImageCount, fillCount); + FillImageLayerList(mLayers, &Layer::mRepeat, mRepeatCount, fillCount); + FillImageLayerList(mLayers, &Layer::mAttachment, mAttachmentCount, fillCount); + FillImageLayerList(mLayers, &Layer::mClip, mClipCount, fillCount); + FillImageLayerList(mLayers, &Layer::mBlendMode, mBlendModeCount, fillCount); + FillImageLayerList(mLayers, &Layer::mOrigin, mOriginCount, fillCount); + FillImageLayerPositionCoordList(mLayers, &Position::horizontal, + mPositionXCount, fillCount); + FillImageLayerPositionCoordList(mLayers, &Position::vertical, mPositionYCount, + fillCount); + FillImageLayerList(mLayers, &Layer::mSize, mSizeCount, fillCount); + FillImageLayerList(mLayers, &Layer::mMaskMode, mMaskModeCount, fillCount); + FillImageLayerList(mLayers, &Layer::mComposite, mCompositeCount, fillCount); +} + +static bool UrlValuesEqual(const StyleImage& aImage, + const StyleImage& aOtherImage) { + const auto* url = aImage.GetImageRequestURLValue(); + const auto* other = aOtherImage.GetImageRequestURLValue(); + return url == other || (url && other && *url == *other); +} + +nsChangeHint nsStyleImageLayers::Layer::CalcDifference( + const nsStyleImageLayers::Layer& aNewLayer) const { + nsChangeHint hint = nsChangeHint(0); + if (!UrlValuesEqual(mImage, aNewLayer.mImage)) { + hint |= nsChangeHint_RepaintFrame | nsChangeHint_UpdateEffects; + } else if (mAttachment != aNewLayer.mAttachment || mClip != aNewLayer.mClip || + mOrigin != aNewLayer.mOrigin || mRepeat != aNewLayer.mRepeat || + mBlendMode != aNewLayer.mBlendMode || mSize != aNewLayer.mSize || + mImage != aNewLayer.mImage || mMaskMode != aNewLayer.mMaskMode || + mComposite != aNewLayer.mComposite) { + hint |= nsChangeHint_RepaintFrame; + } + + if (mPosition != aNewLayer.mPosition) { + hint |= nsChangeHint_UpdateBackgroundPosition; + } + + return hint; +} + +// -------------------- +// nsStyleBackground +// + +nsStyleBackground::nsStyleBackground() + : mImage(nsStyleImageLayers::LayerType::Background), + mBackgroundColor(StyleColor::Transparent()) { + MOZ_COUNT_CTOR(nsStyleBackground); +} + +nsStyleBackground::nsStyleBackground(const nsStyleBackground& aSource) + : mImage(aSource.mImage), mBackgroundColor(aSource.mBackgroundColor) { + MOZ_COUNT_CTOR(nsStyleBackground); +} + +void nsStyleBackground::TriggerImageLoads(Document& aDocument, + const nsStyleBackground* aOldStyle) { + MOZ_ASSERT(NS_IsMainThread()); + mImage.ResolveImages(aDocument, aOldStyle ? &aOldStyle->mImage : nullptr); +} + +nsChangeHint nsStyleBackground::CalcDifference( + const nsStyleBackground& aNewData) const { + nsChangeHint hint = nsChangeHint(0); + if (mBackgroundColor != aNewData.mBackgroundColor) { + hint |= nsChangeHint_RepaintFrame; + } + + hint |= mImage.CalcDifference(aNewData.mImage, + nsStyleImageLayers::LayerType::Background); + + return hint; +} + +bool nsStyleBackground::HasFixedBackground(nsIFrame* aFrame) const { + NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, mImage) { + const nsStyleImageLayers::Layer& layer = mImage.mLayers[i]; + if (layer.mAttachment == StyleImageLayerAttachment::Fixed && + !layer.mImage.IsNone() && !nsLayoutUtils::IsTransformed(aFrame)) { + return true; + } + } + return false; +} + +nscolor nsStyleBackground::BackgroundColor(const nsIFrame* aFrame) const { + return mBackgroundColor.CalcColor(aFrame); +} + +nscolor nsStyleBackground::BackgroundColor(const ComputedStyle* aStyle) const { + return mBackgroundColor.CalcColor(*aStyle); +} + +bool nsStyleBackground::IsTransparent(const nsIFrame* aFrame) const { + return IsTransparent(aFrame->Style()); +} + +bool nsStyleBackground::IsTransparent(const ComputedStyle* aStyle) const { + return BottomLayer().mImage.IsNone() && mImage.mImageCount == 1 && + NS_GET_A(BackgroundColor(aStyle)) == 0; +} + +StyleTransition::StyleTransition(const StyleTransition& aCopy) = default; + +bool StyleTransition::operator==(const StyleTransition& aOther) const { + return mTimingFunction == aOther.mTimingFunction && + mDuration == aOther.mDuration && mDelay == aOther.mDelay && + mProperty == aOther.mProperty; +} + +StyleAnimation::StyleAnimation(const StyleAnimation& aCopy) = default; + +bool StyleAnimation::operator==(const StyleAnimation& aOther) const { + return mTimingFunction == aOther.mTimingFunction && + mDuration == aOther.mDuration && mDelay == aOther.mDelay && + mName == aOther.mName && mDirection == aOther.mDirection && + mFillMode == aOther.mFillMode && mPlayState == aOther.mPlayState && + mIterationCount == aOther.mIterationCount && + mComposition == aOther.mComposition && mTimeline == aOther.mTimeline; +} + +// -------------------- +// nsStyleDisplay +// +nsStyleDisplay::nsStyleDisplay() + : mDisplay(StyleDisplay::Inline), + mOriginalDisplay(StyleDisplay::Inline), + mContentVisibility(StyleContentVisibility::Visible), + mContainerType(StyleContainerType::Normal), + mAppearance(StyleAppearance::None), + mContain(StyleContain::NONE), + mEffectiveContainment(StyleContain::NONE), + mDefaultAppearance(StyleAppearance::None), + mPosition(StylePositionProperty::Static), + mFloat(StyleFloat::None), + mClear(StyleClear::None), + mBreakInside(StyleBreakWithin::Auto), + mBreakBefore(StyleBreakBetween::Auto), + mBreakAfter(StyleBreakBetween::Auto), + mOverflowX(StyleOverflow::Visible), + mOverflowY(StyleOverflow::Visible), + mOverflowClipBoxBlock(StyleOverflowClipBox::PaddingBox), + mOverflowClipBoxInline(StyleOverflowClipBox::PaddingBox), + mScrollbarGutter(StyleScrollbarGutter::AUTO), + mResize(StyleResize::None), + mOrient(StyleOrient::Inline), + mIsolation(StyleIsolation::Auto), + mTopLayer(StyleTopLayer::None), + mTouchAction(StyleTouchAction::AUTO), + mScrollBehavior(StyleScrollBehavior::Auto), + mOverscrollBehaviorX(StyleOverscrollBehavior::Auto), + mOverscrollBehaviorY(StyleOverscrollBehavior::Auto), + mOverflowAnchor(StyleOverflowAnchor::Auto), + mScrollSnapAlign{StyleScrollSnapAlignKeyword::None, + StyleScrollSnapAlignKeyword::None}, + mScrollSnapStop{StyleScrollSnapStop::Normal}, + mScrollSnapType{StyleScrollSnapAxis::Both, + StyleScrollSnapStrictness::None}, + mBackfaceVisibility(StyleBackfaceVisibility::Visible), + mTransformStyle(StyleTransformStyle::Flat), + mTransformBox(StyleTransformBox::ViewBox), + mRotate(StyleRotate::None()), + mTranslate(StyleTranslate::None()), + mScale(StyleScale::None()), + mWillChange{{}, {0}}, + mOffsetPath(StyleOffsetPath::None()), + mOffsetDistance(LengthPercentage::Zero()), + mOffsetRotate{true, StyleAngle{0.0}}, + mOffsetAnchor(StylePositionOrAuto::Auto()), + mOffsetPosition(StyleOffsetPosition::Normal()), + mTransformOrigin{LengthPercentage::FromPercentage(0.5), + LengthPercentage::FromPercentage(0.5), + {0.}}, + mChildPerspective(StylePerspective::None()), + mPerspectiveOrigin(Position::FromPercentage(0.5f)), + mVerticalAlign( + StyleVerticalAlign::Keyword(StyleVerticalAlignKeyword::Baseline)), + mBaselineSource(StyleBaselineSource::Auto), + mWebkitLineClamp(0), + mShapeMargin(LengthPercentage::Zero()), + mShapeOutside(StyleShapeOutside::None()) { + MOZ_COUNT_CTOR(nsStyleDisplay); +} + +nsStyleDisplay::nsStyleDisplay(const nsStyleDisplay& aSource) + : mDisplay(aSource.mDisplay), + mOriginalDisplay(aSource.mOriginalDisplay), + mContentVisibility(aSource.mContentVisibility), + mContainerType(aSource.mContainerType), + mAppearance(aSource.mAppearance), + mContain(aSource.mContain), + mEffectiveContainment(aSource.mEffectiveContainment), + mDefaultAppearance(aSource.mDefaultAppearance), + mPosition(aSource.mPosition), + mFloat(aSource.mFloat), + mClear(aSource.mClear), + mBreakInside(aSource.mBreakInside), + mBreakBefore(aSource.mBreakBefore), + mBreakAfter(aSource.mBreakAfter), + mOverflowX(aSource.mOverflowX), + mOverflowY(aSource.mOverflowY), + mOverflowClipBoxBlock(aSource.mOverflowClipBoxBlock), + mOverflowClipBoxInline(aSource.mOverflowClipBoxInline), + mScrollbarGutter(aSource.mScrollbarGutter), + mResize(aSource.mResize), + mOrient(aSource.mOrient), + mIsolation(aSource.mIsolation), + mTopLayer(aSource.mTopLayer), + mTouchAction(aSource.mTouchAction), + mScrollBehavior(aSource.mScrollBehavior), + mOverscrollBehaviorX(aSource.mOverscrollBehaviorX), + mOverscrollBehaviorY(aSource.mOverscrollBehaviorY), + mOverflowAnchor(aSource.mOverflowAnchor), + mScrollSnapAlign(aSource.mScrollSnapAlign), + mScrollSnapStop(aSource.mScrollSnapStop), + mScrollSnapType(aSource.mScrollSnapType), + mBackfaceVisibility(aSource.mBackfaceVisibility), + mTransformStyle(aSource.mTransformStyle), + mTransformBox(aSource.mTransformBox), + mTransform(aSource.mTransform), + mRotate(aSource.mRotate), + mTranslate(aSource.mTranslate), + mScale(aSource.mScale), + mContainerName(aSource.mContainerName), + mWillChange(aSource.mWillChange), + mOffsetPath(aSource.mOffsetPath), + mOffsetDistance(aSource.mOffsetDistance), + mOffsetRotate(aSource.mOffsetRotate), + mOffsetAnchor(aSource.mOffsetAnchor), + mOffsetPosition(aSource.mOffsetPosition), + mTransformOrigin(aSource.mTransformOrigin), + mChildPerspective(aSource.mChildPerspective), + mPerspectiveOrigin(aSource.mPerspectiveOrigin), + mVerticalAlign(aSource.mVerticalAlign), + mBaselineSource(aSource.mBaselineSource), + mWebkitLineClamp(aSource.mWebkitLineClamp), + mShapeImageThreshold(aSource.mShapeImageThreshold), + mShapeMargin(aSource.mShapeMargin), + mShapeOutside(aSource.mShapeOutside) { + MOZ_COUNT_CTOR(nsStyleDisplay); +} + +void nsStyleDisplay::TriggerImageLoads(Document& aDocument, + const nsStyleDisplay* aOldStyle) { + MOZ_ASSERT(NS_IsMainThread()); + + if (mShapeOutside.IsImage()) { + const auto* old = aOldStyle && aOldStyle->mShapeOutside.IsImage() + ? &aOldStyle->mShapeOutside.AsImage() + : nullptr; + // Const-cast is ugly but legit, we could avoid it by generating mut-casts + // with cbindgen. + const_cast<StyleImage&>(mShapeOutside.AsImage()) + .ResolveImage(aDocument, old); + } +} + +template <typename TransformLike> +static inline nsChangeHint CompareTransformValues( + const TransformLike& aOldTransform, const TransformLike& aNewTransform) { + nsChangeHint result = nsChangeHint(0); + + // Note: If we add a new change hint for transform changes here, we have to + // modify KeyframeEffect::CalculateCumulativeChangeHint too! + if (aOldTransform != aNewTransform) { + result |= nsChangeHint_UpdateTransformLayer; + if (!aOldTransform.IsNone() && !aNewTransform.IsNone()) { + result |= nsChangeHint_UpdatePostTransformOverflow; + } else { + result |= nsChangeHint_UpdateOverflow; + } + } + + return result; +} + +static inline nsChangeHint CompareMotionValues( + const nsStyleDisplay& aDisplay, const nsStyleDisplay& aNewDisplay) { + if (aDisplay.mOffsetPath == aNewDisplay.mOffsetPath) { + if (aDisplay.mOffsetDistance == aNewDisplay.mOffsetDistance && + aDisplay.mOffsetRotate == aNewDisplay.mOffsetRotate && + aDisplay.mOffsetAnchor == aNewDisplay.mOffsetAnchor && + aDisplay.mOffsetPosition == aNewDisplay.mOffsetPosition) { + return nsChangeHint(0); + } + + // No motion path transform is applied. + if (aDisplay.mOffsetPath.IsNone()) { + return nsChangeHint_NeutralChange; + } + } + + // TODO: Bug 1482737: This probably doesn't need to UpdateOverflow + // (or UpdateTransformLayer) if there's already a transform. + // Set the same hints as what we use for transform because motion path is + // a kind of transform and will be combined with other transforms. + nsChangeHint result = nsChangeHint_UpdateTransformLayer; + if (!aDisplay.mOffsetPath.IsNone() && !aNewDisplay.mOffsetPath.IsNone()) { + result |= nsChangeHint_UpdatePostTransformOverflow; + } else { + result |= nsChangeHint_UpdateOverflow; + } + return result; +} + +static bool ScrollbarGenerationChanged(const nsStyleDisplay& aOld, + const nsStyleDisplay& aNew) { + auto changed = [](StyleOverflow aOld, StyleOverflow aNew) { + return aOld != aNew && + (aOld == StyleOverflow::Hidden || aNew == StyleOverflow::Hidden); + }; + return changed(aOld.mOverflowX, aNew.mOverflowX) || + changed(aOld.mOverflowY, aNew.mOverflowY); +} + +static bool AppearanceValueAffectsFrames(StyleAppearance aAppearance, + StyleAppearance aDefaultAppearance) { + switch (aAppearance) { + case StyleAppearance::Textfield: + // This is for <input type=number/search> where we allow authors to + // specify a |-moz-appearance:textfield| to get a control without buttons. + // We need to reframe since this affects the spinbox creation in + // nsNumber/SearchControlFrame::CreateAnonymousContent. + return aDefaultAppearance == StyleAppearance::NumberInput || + aDefaultAppearance == StyleAppearance::Searchfield; + case StyleAppearance::Menulist: + // This affects the menulist button creation. + return aDefaultAppearance == StyleAppearance::Menulist; + default: + return false; + } +} + +nsChangeHint nsStyleDisplay::CalcDifference( + const nsStyleDisplay& aNewData, const ComputedStyle& aOldStyle) const { + if (mDisplay != aNewData.mDisplay || + (mFloat == StyleFloat::None) != (aNewData.mFloat == StyleFloat::None) || + mTopLayer != aNewData.mTopLayer || mResize != aNewData.mResize) { + return nsChangeHint_ReconstructFrame; + } + + auto oldAppearance = EffectiveAppearance(); + auto newAppearance = aNewData.EffectiveAppearance(); + if (oldAppearance != newAppearance) { + // Changes to the relevant default appearance changes in + // AppearanceValueRequiresFrameReconstruction require reconstruction on + // their own, so we can just pick either the new or the old. + if (AppearanceValueAffectsFrames(oldAppearance, mDefaultAppearance) || + AppearanceValueAffectsFrames(newAppearance, mDefaultAppearance)) { + return nsChangeHint_ReconstructFrame; + } + } + + auto hint = nsChangeHint(0); + const auto containmentDiff = + mEffectiveContainment ^ aNewData.mEffectiveContainment; + if (containmentDiff) { + if (containmentDiff & StyleContain::STYLE) { + // Style containment affects counters so we need to re-frame. + return nsChangeHint_ReconstructFrame; + } + if (containmentDiff & (StyleContain::PAINT | StyleContain::LAYOUT)) { + // Paint and layout containment boxes are absolutely/fixed positioning + // containers. + hint |= nsChangeHint_UpdateContainingBlock; + } + // The other container types only need a reflow. + hint |= nsChangeHint_AllReflowHints | nsChangeHint_RepaintFrame; + } + if (mPosition != aNewData.mPosition) { + if (IsAbsolutelyPositionedStyle() || + aNewData.IsAbsolutelyPositionedStyle()) { + // This changes our parent relationship on the frame tree and / or needs + // to create a placeholder, so gotta reframe. There are some cases (when + // switching from fixed to absolute or viceversa, if our containing block + // happens to remain the same, i.e., if it has a transform or such) where + // this wouldn't really be needed (though we'd still need to move the + // frame from one child list to another). In any case we don't have a hand + // to that information from here, and it doesn't seem like a case worth + // optimizing for. + return nsChangeHint_ReconstructFrame; + } + // We start or stop being a containing block for abspos descendants. This + // also causes painting to change, as we'd become a pseudo-stacking context. + if (IsRelativelyOrStickyPositionedStyle() != + aNewData.IsRelativelyOrStickyPositionedStyle()) { + hint |= nsChangeHint_UpdateContainingBlock | nsChangeHint_RepaintFrame; + } + if (IsPositionForcingStackingContext() != + aNewData.IsPositionForcingStackingContext()) { + hint |= nsChangeHint_RepaintFrame; + } + // On top of that: if the above ends up not reframing, we need a reflow to + // compute our relative, static or sticky position. + hint |= nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition; + } + + if (mScrollSnapAlign != aNewData.mScrollSnapAlign || + mScrollSnapType != aNewData.mScrollSnapType || + mScrollSnapStop != aNewData.mScrollSnapStop) { + hint |= nsChangeHint_RepaintFrame; + } + if (mScrollBehavior != aNewData.mScrollBehavior) { + hint |= nsChangeHint_NeutralChange; + } + + if (mOverflowX != aNewData.mOverflowX || mOverflowY != aNewData.mOverflowY) { + const bool isScrollable = IsScrollableOverflow(); + if (isScrollable != aNewData.IsScrollableOverflow()) { + // We may need to construct or destroy a scroll frame as a result of this + // change. If we don't, we still need to update our overflow in some cases + // (like svg:foreignObject), which ignore the scrollable-ness of our + // overflow. + hint |= nsChangeHint_ScrollbarChange | nsChangeHint_UpdateOverflow | + nsChangeHint_RepaintFrame; + } else if (isScrollable) { + if (ScrollbarGenerationChanged(*this, aNewData)) { + // We might need to reframe in the case of hidden -> non-hidden case + // though, since nsHTMLScrollFrame::CreateAnonymousContent avoids + // creating scrollbars altogether for overflow: hidden. That seems it + // could create some interesting perf cliffs... + hint |= nsChangeHint_ScrollbarChange; + } else { + // Otherwise, for changes where both overflow values are scrollable, + // means that scrollbars may appear or disappear. We need to reflow, + // since reflow is what determines which scrollbars if any are visible. + hint |= nsChangeHint_ReflowHintsForScrollbarChange; + } + } else { + // Otherwise this is a change between 'visible' and 'clip'. + // Here only whether we have a 'clip' changes, so just repaint and + // update our overflow areas in that case. + hint |= nsChangeHint_UpdateOverflow | nsChangeHint_RepaintFrame; + } + } + + if (mScrollbarGutter != aNewData.mScrollbarGutter) { + if (IsScrollableOverflow() || aOldStyle.IsRootElementStyle()) { + // Changing scrollbar-gutter affects available inline-size of a inner + // scrolled frame, so we need a reflow for scrollbar change. Note that the + // root is always scrollable in HTML, even if its style doesn't say so. + hint |= nsChangeHint_ReflowHintsForScrollbarChange; + } else { + // scrollbar-gutter only applies to scroll containers. + hint |= nsChangeHint_NeutralChange; + } + } + + if (mFloat != aNewData.mFloat) { + // Changing which side we're floating on (float:none was handled above). + hint |= nsChangeHint_ReflowHintsForFloatAreaChange; + } + + if (mShapeOutside != aNewData.mShapeOutside || + mShapeMargin != aNewData.mShapeMargin || + mShapeImageThreshold != aNewData.mShapeImageThreshold) { + if (aNewData.mFloat != StyleFloat::None) { + // If we are floating, and our shape-outside, shape-margin, or + // shape-image-threshold are changed, our descendants are not impacted, + // but our ancestor and siblings are. + hint |= nsChangeHint_ReflowHintsForFloatAreaChange; + } else { + // shape-outside or shape-margin or shape-image-threshold changed, + // but we don't need to reflow because we're not floating. + hint |= nsChangeHint_NeutralChange; + } + } + + if (mWebkitLineClamp != aNewData.mWebkitLineClamp || + mVerticalAlign != aNewData.mVerticalAlign || + mBaselineSource != aNewData.mBaselineSource) { + // XXX Can this just be AllReflowHints + RepaintFrame, and be included in + // the block below? + hint |= NS_STYLE_HINT_REFLOW; + } + + // XXX the following is conservative, for now: changing float breaking + // shouldn't necessarily require a repaint, reflow should suffice. + // + // FIXME(emilio): We definitely change the frame tree in nsCSSFrameConstructor + // based on break-before / break-after... Shouldn't that reframe? + if (mClear != aNewData.mClear || mBreakInside != aNewData.mBreakInside || + mBreakBefore != aNewData.mBreakBefore || + mBreakAfter != aNewData.mBreakAfter || + mAppearance != aNewData.mAppearance || + mDefaultAppearance != aNewData.mDefaultAppearance || + mOrient != aNewData.mOrient || + mOverflowClipBoxBlock != aNewData.mOverflowClipBoxBlock || + mOverflowClipBoxInline != aNewData.mOverflowClipBoxInline) { + hint |= nsChangeHint_AllReflowHints | nsChangeHint_RepaintFrame; + } + + if (mIsolation != aNewData.mIsolation) { + hint |= nsChangeHint_RepaintFrame; + } + + /* If we've added or removed the transform property, we need to reconstruct + * the frame to add or remove the view object, and also to handle abs-pos and + * fixed-pos containers. + */ + if (HasTransformStyle() != aNewData.HasTransformStyle()) { + hint |= nsChangeHint_ComprehensiveAddOrRemoveTransform; + } else { + /* Otherwise, if we've kept the property lying around and we already had a + * transform, we need to see whether or not we've changed the transform. + * If so, we need to recompute its overflow rect (which probably changed + * if the transform changed) and to redraw within the bounds of that new + * overflow rect. + * + * If the property isn't present in either style struct, we still do the + * comparisons but turn all the resulting change hints into + * nsChangeHint_NeutralChange. + */ + nsChangeHint transformHint = CalcTransformPropertyDifference(aNewData); + + if (transformHint) { + if (HasTransformStyle()) { + hint |= transformHint; + } else { + hint |= nsChangeHint_NeutralChange; + } + } + } + + if (HasPerspectiveStyle() != aNewData.HasPerspectiveStyle()) { + // A change from/to being a containing block for position:fixed. + hint |= nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateOverflow | + nsChangeHint_RepaintFrame; + } else if (mChildPerspective != aNewData.mChildPerspective) { + hint |= nsChangeHint_UpdateOverflow | nsChangeHint_RepaintFrame; + } + + // Note that the HasTransformStyle() != aNewData.HasTransformStyle() + // test above handles relevant changes in the StyleWillChangeBit_TRANSFORM + // bit, which in turn handles frame reconstruction for changes in the + // containing block of fixed-positioned elements. + auto willChangeBitsChanged = mWillChange.bits ^ aNewData.mWillChange.bits; + + if (willChangeBitsChanged & + (StyleWillChangeBits::STACKING_CONTEXT_UNCONDITIONAL | + StyleWillChangeBits::SCROLL | StyleWillChangeBits::OPACITY | + StyleWillChangeBits::PERSPECTIVE | StyleWillChangeBits::TRANSFORM | + StyleWillChangeBits::Z_INDEX)) { + hint |= nsChangeHint_RepaintFrame; + } + + if (willChangeBitsChanged & + (StyleWillChangeBits::FIXPOS_CB_NON_SVG | StyleWillChangeBits::TRANSFORM | + StyleWillChangeBits::PERSPECTIVE | StyleWillChangeBits::POSITION | + StyleWillChangeBits::CONTAIN)) { + hint |= nsChangeHint_UpdateContainingBlock; + } + + // If touch-action is changed, we need to regenerate the event regions on + // the layers and send it over to the compositor for APZ to handle. + if (mTouchAction != aNewData.mTouchAction) { + hint |= nsChangeHint_RepaintFrame; + } + + // If overscroll-behavior has changed, the changes are picked up + // during a repaint. + if (mOverscrollBehaviorX != aNewData.mOverscrollBehaviorX || + mOverscrollBehaviorY != aNewData.mOverscrollBehaviorY) { + hint |= nsChangeHint_SchedulePaint; + } + + if (mOriginalDisplay != aNewData.mOriginalDisplay) { + // Our hypothetical box position may have changed. + // + // Note that it doesn't matter if we look at the old or the new struct, + // since a change on whether we need a hypothetical position would trigger + // reflow anyway. + if (IsAbsolutelyPositionedStyle() && + aOldStyle.StylePosition()->NeedsHypotheticalPositionIfAbsPos()) { + hint |= + nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition; + } else { + hint |= nsChangeHint_NeutralChange; + } + } + + // Note: Our current behavior for handling changes to the + // transition-duration, transition-delay, and transition-timing-function + // properties is to do nothing. In other words, the transition + // property that matters is what it is when the transition begins, and + // we don't stop a transition later because the transition property + // changed. + // We do handle changes to transition-property, but we don't need to + // bother with anything here, since the transition manager is notified + // of any ComputedStyle change anyway. + + // Note: Likewise, for animation-*, the animation manager gets + // notified about every new ComputedStyle constructed, and it uses + // that opportunity to handle dynamic changes appropriately. + + // But we still need to return nsChangeHint_NeutralChange for these + // properties, since some data did change in the style struct. + + // TODO(emilio): Figure out change hints for container-name, maybe it needs to + // be handled by the style system as a special-case (since it changes + // container-query selection on descendants). + // container-type / contain / content-visibility are handled by the + // mEffectiveContainment check. + if (!hint && (mWillChange != aNewData.mWillChange || + mOverflowAnchor != aNewData.mOverflowAnchor || + mContentVisibility != aNewData.mContentVisibility || + mContainerType != aNewData.mContainerType || + mContain != aNewData.mContain || + mContainerName != aNewData.mContainerName)) { + hint |= nsChangeHint_NeutralChange; + } + + return hint; +} + +nsChangeHint nsStyleDisplay::CalcTransformPropertyDifference( + const nsStyleDisplay& aNewData) const { + nsChangeHint transformHint = nsChangeHint(0); + + transformHint |= CompareTransformValues(mTransform, aNewData.mTransform); + transformHint |= CompareTransformValues(mRotate, aNewData.mRotate); + transformHint |= CompareTransformValues(mTranslate, aNewData.mTranslate); + transformHint |= CompareTransformValues(mScale, aNewData.mScale); + transformHint |= CompareMotionValues(*this, aNewData); + + if (mTransformOrigin != aNewData.mTransformOrigin) { + transformHint |= nsChangeHint_UpdateTransformLayer | + nsChangeHint_UpdatePostTransformOverflow; + } + + if (mPerspectiveOrigin != aNewData.mPerspectiveOrigin || + mTransformStyle != aNewData.mTransformStyle || + mTransformBox != aNewData.mTransformBox) { + transformHint |= nsChangeHint_UpdateOverflow | nsChangeHint_RepaintFrame; + } + + if (mBackfaceVisibility != aNewData.mBackfaceVisibility) { + transformHint |= nsChangeHint_RepaintFrame; + } + + return transformHint; +} + +// -------------------- +// nsStyleVisibility +// + +nsStyleVisibility::nsStyleVisibility(const Document& aDocument) + : mDirection(aDocument.GetBidiOptions() == IBMBIDI_TEXTDIRECTION_RTL + ? StyleDirection::Rtl + : StyleDirection::Ltr), + mVisible(StyleVisibility::Visible), + mImageRendering(StyleImageRendering::Auto), + mWritingMode(StyleWritingModeProperty::HorizontalTb), + mTextOrientation(StyleTextOrientation::Mixed), + mMozBoxCollapse(StyleMozBoxCollapse::Flex), + mPrintColorAdjust(StylePrintColorAdjust::Economy), + mImageOrientation(StyleImageOrientation::FromImage) { + MOZ_COUNT_CTOR(nsStyleVisibility); +} + +nsStyleVisibility::nsStyleVisibility(const nsStyleVisibility& aSource) + : mDirection(aSource.mDirection), + mVisible(aSource.mVisible), + mImageRendering(aSource.mImageRendering), + mWritingMode(aSource.mWritingMode), + mTextOrientation(aSource.mTextOrientation), + mMozBoxCollapse(aSource.mMozBoxCollapse), + mPrintColorAdjust(aSource.mPrintColorAdjust), + mImageOrientation(aSource.mImageOrientation) { + MOZ_COUNT_CTOR(nsStyleVisibility); +} + +nsChangeHint nsStyleVisibility::CalcDifference( + const nsStyleVisibility& aNewData) const { + nsChangeHint hint = nsChangeHint(0); + + if (mDirection != aNewData.mDirection || + mWritingMode != aNewData.mWritingMode) { + // It's important that a change in mWritingMode results in frame + // reconstruction, because it may affect intrinsic size (see + // nsSubDocumentFrame::GetIntrinsicISize/BSize). + // Also, the used writing-mode value is now a field on nsIFrame and some + // classes (e.g. table rows/cells) copy their value from an ancestor. + return nsChangeHint_ReconstructFrame; + } + if (mImageOrientation != aNewData.mImageOrientation) { + hint |= nsChangeHint_AllReflowHints | nsChangeHint_RepaintFrame; + } + if (mVisible != aNewData.mVisible) { + if (mVisible == StyleVisibility::Visible || + aNewData.mVisible == StyleVisibility::Visible) { + hint |= nsChangeHint_VisibilityChange; + } + if (mVisible == StyleVisibility::Collapse || + aNewData.mVisible == StyleVisibility::Collapse) { + hint |= NS_STYLE_HINT_REFLOW; + } else { + hint |= NS_STYLE_HINT_VISUAL; + } + } + if (mTextOrientation != aNewData.mTextOrientation || + mMozBoxCollapse != aNewData.mMozBoxCollapse) { + hint |= NS_STYLE_HINT_REFLOW; + } + if (mImageRendering != aNewData.mImageRendering) { + hint |= nsChangeHint_RepaintFrame; + } + if (mPrintColorAdjust != aNewData.mPrintColorAdjust) { + // color-adjust only affects media where dynamic changes can't happen. + hint |= nsChangeHint_NeutralChange; + } + return hint; +} + +StyleImageOrientation nsStyleVisibility::UsedImageOrientation( + imgIRequest* aRequest, StyleImageOrientation aOrientation) { + if (aOrientation == StyleImageOrientation::FromImage || !aRequest) { + return aOrientation; + } + + nsCOMPtr<nsIPrincipal> triggeringPrincipal = + aRequest->GetTriggeringPrincipal(); + + // If the request was for a blob, the request may not have a triggering + // principal and we should use the input orientation. + if (!triggeringPrincipal) { + return aOrientation; + } + + nsCOMPtr<nsIURI> uri = aRequest->GetURI(); + // If the image request is a data uri, then treat the request as a + // same origin request. + bool isSameOrigin = + uri->SchemeIs("data") || triggeringPrincipal->IsSameOrigin(uri); + + // If the image request is a cross-origin request that does not use CORS, + // do not enforce the image orientation found in the style. Use the image + // orientation found in the exif data. + if (!isSameOrigin && !nsLayoutUtils::ImageRequestUsesCORS(aRequest)) { + return StyleImageOrientation::FromImage; + } + + return aOrientation; +} + +//----------------------- +// nsStyleContent +// + +nsStyleContent::nsStyleContent() : mContent(StyleContent::Normal()) { + MOZ_COUNT_CTOR(nsStyleContent); +} + +nsStyleContent::nsStyleContent(const nsStyleContent& aSource) + : mContent(aSource.mContent), + mCounterIncrement(aSource.mCounterIncrement), + mCounterReset(aSource.mCounterReset), + mCounterSet(aSource.mCounterSet) { + MOZ_COUNT_CTOR(nsStyleContent); +} + +nsChangeHint nsStyleContent::CalcDifference( + const nsStyleContent& aNewData) const { + // Unfortunately we need to reframe even if the content lengths are the same; + // a simple reflow will not pick up different text or different image URLs, + // since we set all that up in the CSSFrameConstructor + if (mContent != aNewData.mContent || + mCounterIncrement != aNewData.mCounterIncrement || + mCounterReset != aNewData.mCounterReset || + mCounterSet != aNewData.mCounterSet) { + return nsChangeHint_ReconstructFrame; + } + + return nsChangeHint(0); +} + +void nsStyleContent::TriggerImageLoads(Document& aDoc, + const nsStyleContent* aOld) { + if (!mContent.IsItems()) { + return; + } + + Span<const StyleContentItem> oldItems; + if (aOld && aOld->mContent.IsItems()) { + oldItems = aOld->mContent.AsItems().AsSpan(); + } + + auto items = mContent.AsItems().AsSpan(); + + for (size_t i = 0; i < items.Length(); ++i) { + const auto& item = items[i]; + if (!item.IsImage()) { + continue; + } + const auto& image = item.AsImage(); + const auto* oldImage = i < oldItems.Length() && oldItems[i].IsImage() + ? &oldItems[i].AsImage() + : nullptr; + const_cast<StyleImage&>(image).ResolveImage(aDoc, oldImage); + } +} + +// -------------------- +// nsStyleTextReset +// + +nsStyleTextReset::nsStyleTextReset() + : mTextDecorationLine(StyleTextDecorationLine::NONE), + mTextDecorationStyle(StyleTextDecorationStyle::Solid), + mUnicodeBidi(StyleUnicodeBidi::Normal), + mInitialLetterSink(0), + mInitialLetterSize(0.0f), + mTextDecorationColor(StyleColor::CurrentColor()), + mTextDecorationThickness(StyleTextDecorationLength::Auto()) { + MOZ_COUNT_CTOR(nsStyleTextReset); +} + +nsStyleTextReset::nsStyleTextReset(const nsStyleTextReset& aSource) + : mTextOverflow(aSource.mTextOverflow), + mTextDecorationLine(aSource.mTextDecorationLine), + mTextDecorationStyle(aSource.mTextDecorationStyle), + mUnicodeBidi(aSource.mUnicodeBidi), + mInitialLetterSink(aSource.mInitialLetterSink), + mInitialLetterSize(aSource.mInitialLetterSize), + mTextDecorationColor(aSource.mTextDecorationColor), + mTextDecorationThickness(aSource.mTextDecorationThickness) { + MOZ_COUNT_CTOR(nsStyleTextReset); +} + +nsChangeHint nsStyleTextReset::CalcDifference( + const nsStyleTextReset& aNewData) const { + if (mUnicodeBidi != aNewData.mUnicodeBidi || + mInitialLetterSink != aNewData.mInitialLetterSink || + mInitialLetterSize != aNewData.mInitialLetterSize) { + return NS_STYLE_HINT_REFLOW; + } + + if (mTextDecorationLine != aNewData.mTextDecorationLine || + mTextDecorationStyle != aNewData.mTextDecorationStyle || + mTextDecorationThickness != aNewData.mTextDecorationThickness) { + // Changes to our text-decoration line can impact our overflow area & + // also our descendants' overflow areas (particularly for text-frame + // descendants). So, we update those areas & trigger a repaint. + return nsChangeHint_RepaintFrame | nsChangeHint_UpdateSubtreeOverflow | + nsChangeHint_SchedulePaint; + } + + // Repaint for decoration color changes + if (mTextDecorationColor != aNewData.mTextDecorationColor) { + return nsChangeHint_RepaintFrame; + } + + if (mTextOverflow != aNewData.mTextOverflow) { + return nsChangeHint_RepaintFrame; + } + + return nsChangeHint(0); +} + +// -------------------- +// nsStyleText +// + +static StyleAbsoluteColor DefaultColor(const Document& aDocument) { + return StyleAbsoluteColor::FromColor( + PreferenceSheet::PrefsFor(aDocument) + .ColorsFor(aDocument.DefaultColorScheme()) + .mDefault); +} + +nsStyleText::nsStyleText(const Document& aDocument) + : mColor(DefaultColor(aDocument)), + mForcedColorAdjust(StyleForcedColorAdjust::Auto), + mTextTransform(StyleTextTransform::None()), + mTextAlign(StyleTextAlign::Start), + mTextAlignLast(StyleTextAlignLast::Auto), + mTextJustify(StyleTextJustify::Auto), + mHyphens(StyleHyphens::Manual), + mRubyAlign(StyleRubyAlign::SpaceAround), + mRubyPosition(StyleRubyPosition::AlternateOver), + mTextSizeAdjust(StyleTextSizeAdjust::Auto), + mTextCombineUpright(StyleTextCombineUpright::None), + mMozControlCharacterVisibility( + StaticPrefs::layout_css_control_characters_visible() + ? StyleMozControlCharacterVisibility::Visible + : StyleMozControlCharacterVisibility::Hidden), + mTextRendering(StyleTextRendering::Auto), + mTextEmphasisColor(StyleColor::CurrentColor()), + mWebkitTextFillColor(StyleColor::CurrentColor()), + mWebkitTextStrokeColor(StyleColor::CurrentColor()), + mTabSize(StyleNonNegativeLengthOrNumber::Number(8.f)), + mWordSpacing(LengthPercentage::Zero()), + mLetterSpacing({0.}), + mTextUnderlineOffset(LengthPercentageOrAuto::Auto()), + mTextDecorationSkipInk(StyleTextDecorationSkipInk::Auto), + mTextUnderlinePosition(StyleTextUnderlinePosition::AUTO), + mWebkitTextStrokeWidth(0), + mTextEmphasisStyle(StyleTextEmphasisStyle::None()) { + MOZ_COUNT_CTOR(nsStyleText); + RefPtr<nsAtom> language = aDocument.GetContentLanguageAsAtomForStyle(); + mTextEmphasisPosition = + language && nsStyleUtil::MatchesLanguagePrefix(language, u"zh") + ? StyleTextEmphasisPosition::UNDER + : StyleTextEmphasisPosition::OVER; +} + +nsStyleText::nsStyleText(const nsStyleText& aSource) + : mColor(aSource.mColor), + mForcedColorAdjust(aSource.mForcedColorAdjust), + mTextTransform(aSource.mTextTransform), + mTextAlign(aSource.mTextAlign), + mTextAlignLast(aSource.mTextAlignLast), + mTextJustify(aSource.mTextJustify), + mWhiteSpaceCollapse(aSource.mWhiteSpaceCollapse), + mTextWrapMode(aSource.mTextWrapMode), + mLineBreak(aSource.mLineBreak), + mWordBreak(aSource.mWordBreak), + mOverflowWrap(aSource.mOverflowWrap), + mHyphens(aSource.mHyphens), + mRubyAlign(aSource.mRubyAlign), + mRubyPosition(aSource.mRubyPosition), + mTextSizeAdjust(aSource.mTextSizeAdjust), + mTextCombineUpright(aSource.mTextCombineUpright), + mMozControlCharacterVisibility(aSource.mMozControlCharacterVisibility), + mTextEmphasisPosition(aSource.mTextEmphasisPosition), + mTextRendering(aSource.mTextRendering), + mTextEmphasisColor(aSource.mTextEmphasisColor), + mWebkitTextFillColor(aSource.mWebkitTextFillColor), + mWebkitTextStrokeColor(aSource.mWebkitTextStrokeColor), + mTabSize(aSource.mTabSize), + mWordSpacing(aSource.mWordSpacing), + mLetterSpacing(aSource.mLetterSpacing), + mTextIndent(aSource.mTextIndent), + mTextUnderlineOffset(aSource.mTextUnderlineOffset), + mTextDecorationSkipInk(aSource.mTextDecorationSkipInk), + mTextUnderlinePosition(aSource.mTextUnderlinePosition), + mWebkitTextStrokeWidth(aSource.mWebkitTextStrokeWidth), + mTextShadow(aSource.mTextShadow), + mTextEmphasisStyle(aSource.mTextEmphasisStyle), + mHyphenateCharacter(aSource.mHyphenateCharacter), + mWebkitTextSecurity(aSource.mWebkitTextSecurity), + mTextWrapStyle(aSource.mTextWrapStyle) { + MOZ_COUNT_CTOR(nsStyleText); +} + +nsChangeHint nsStyleText::CalcDifference(const nsStyleText& aNewData) const { + if (WhiteSpaceOrNewlineIsSignificant() != + aNewData.WhiteSpaceOrNewlineIsSignificant()) { + // This may require construction of suppressed text frames + return nsChangeHint_ReconstructFrame; + } + + if (mTextCombineUpright != aNewData.mTextCombineUpright || + mMozControlCharacterVisibility != + aNewData.mMozControlCharacterVisibility) { + return nsChangeHint_ReconstructFrame; + } + + if ((mTextAlign != aNewData.mTextAlign) || + (mTextAlignLast != aNewData.mTextAlignLast) || + (mTextTransform != aNewData.mTextTransform) || + (mWhiteSpaceCollapse != aNewData.mWhiteSpaceCollapse) || + (mTextWrapMode != aNewData.mTextWrapMode) || + (mLineBreak != aNewData.mLineBreak) || + (mWordBreak != aNewData.mWordBreak) || + (mOverflowWrap != aNewData.mOverflowWrap) || + (mHyphens != aNewData.mHyphens) || (mRubyAlign != aNewData.mRubyAlign) || + (mRubyPosition != aNewData.mRubyPosition) || + (mTextSizeAdjust != aNewData.mTextSizeAdjust) || + (mLetterSpacing != aNewData.mLetterSpacing) || + (mTextIndent != aNewData.mTextIndent) || + (mTextJustify != aNewData.mTextJustify) || + (mWordSpacing != aNewData.mWordSpacing) || + (mTabSize != aNewData.mTabSize) || + (mHyphenateCharacter != aNewData.mHyphenateCharacter) || + (mWebkitTextSecurity != aNewData.mWebkitTextSecurity) || + (mTextWrapStyle != aNewData.mTextWrapStyle)) { + return NS_STYLE_HINT_REFLOW; + } + + if (HasEffectiveTextEmphasis() != aNewData.HasEffectiveTextEmphasis() || + (HasEffectiveTextEmphasis() && + mTextEmphasisPosition != aNewData.mTextEmphasisPosition)) { + // Text emphasis position change could affect line height calculation. + return nsChangeHint_AllReflowHints | nsChangeHint_RepaintFrame; + } + + nsChangeHint hint = nsChangeHint(0); + + // text-rendering changes require a reflow since they change SVG + // frames' rects. + if (mTextRendering != aNewData.mTextRendering) { + hint |= nsChangeHint_NeedReflow | nsChangeHint_RepaintFrame; + } + + if (mTextShadow != aNewData.mTextShadow || + mTextEmphasisStyle != aNewData.mTextEmphasisStyle || + mWebkitTextStrokeWidth != aNewData.mWebkitTextStrokeWidth || + mTextUnderlineOffset != aNewData.mTextUnderlineOffset || + mTextDecorationSkipInk != aNewData.mTextDecorationSkipInk || + mTextUnderlinePosition != aNewData.mTextUnderlinePosition) { + hint |= nsChangeHint_UpdateSubtreeOverflow | nsChangeHint_SchedulePaint | + nsChangeHint_RepaintFrame; + + // We don't add any other hints below. + return hint; + } + + if (mColor != aNewData.mColor) { + hint |= nsChangeHint_RepaintFrame; + } + + if (mTextEmphasisColor != aNewData.mTextEmphasisColor || + mWebkitTextFillColor != aNewData.mWebkitTextFillColor || + mWebkitTextStrokeColor != aNewData.mWebkitTextStrokeColor) { + hint |= nsChangeHint_SchedulePaint | nsChangeHint_RepaintFrame; + } + + if (hint) { + return hint; + } + + if (mTextEmphasisPosition != aNewData.mTextEmphasisPosition || + mForcedColorAdjust != aNewData.mForcedColorAdjust) { + return nsChangeHint_NeutralChange; + } + + return nsChangeHint(0); +} + +LogicalSide nsStyleText::TextEmphasisSide(WritingMode aWM) const { + bool noLeftBit = !(mTextEmphasisPosition & StyleTextEmphasisPosition::LEFT); + DebugOnly<bool> noRightBit = + !(mTextEmphasisPosition & StyleTextEmphasisPosition::RIGHT); + bool noOverBit = !(mTextEmphasisPosition & StyleTextEmphasisPosition::OVER); + DebugOnly<bool> noUnderBit = + !(mTextEmphasisPosition & StyleTextEmphasisPosition::UNDER); + + MOZ_ASSERT((noOverBit != noUnderBit) && + ((noLeftBit != noRightBit) || noRightBit)); + mozilla::Side side = aWM.IsVertical() ? (noLeftBit ? eSideRight : eSideLeft) + : (noOverBit ? eSideBottom : eSideTop); + LogicalSide result = aWM.LogicalSideForPhysicalSide(side); + MOZ_ASSERT(IsBlock(result)); + return result; +} + +//----------------------- +// nsStyleUI +// + +nsStyleUI::nsStyleUI() + : mInert(StyleInert::None), + mMozTheme(StyleMozTheme::Auto), + mUserInput(StyleUserInput::Auto), + mUserModify(StyleUserModify::ReadOnly), + mUserFocus(StyleUserFocus::Normal), + mPointerEvents(StylePointerEvents::Auto), + mCursor{{}, StyleCursorKind::Auto}, + mAccentColor(StyleColorOrAuto::Auto()), + mCaretColor(StyleColorOrAuto::Auto()), + mScrollbarColor(StyleScrollbarColor::Auto()), + mColorScheme(StyleColorScheme{{}, {}}) { + MOZ_COUNT_CTOR(nsStyleUI); +} + +nsStyleUI::nsStyleUI(const nsStyleUI& aSource) + : mInert(aSource.mInert), + mMozTheme(aSource.mMozTheme), + mUserInput(aSource.mUserInput), + mUserModify(aSource.mUserModify), + mUserFocus(aSource.mUserFocus), + mPointerEvents(aSource.mPointerEvents), + mCursor(aSource.mCursor), + mAccentColor(aSource.mAccentColor), + mCaretColor(aSource.mCaretColor), + mScrollbarColor(aSource.mScrollbarColor), + mColorScheme(aSource.mColorScheme) { + MOZ_COUNT_CTOR(nsStyleUI); +} + +void nsStyleUI::TriggerImageLoads(Document& aDocument, + const nsStyleUI* aOldStyle) { + MOZ_ASSERT(NS_IsMainThread()); + + auto cursorImages = mCursor.images.AsSpan(); + auto oldCursorImages = aOldStyle ? aOldStyle->mCursor.images.AsSpan() + : Span<const StyleCursorImage>(); + for (size_t i = 0; i < cursorImages.Length(); ++i) { + const auto& cursor = cursorImages[i]; + const auto* oldCursorImage = + oldCursorImages.Length() > i ? &oldCursorImages[i].image : nullptr; + const_cast<StyleCursorImage&>(cursor).image.ResolveImage(aDocument, + oldCursorImage); + } +} + +nsChangeHint nsStyleUI::CalcDifference(const nsStyleUI& aNewData) const { + // SVGGeometryFrame's mRect depends on stroke _and_ on the value of + // pointer-events. See SVGGeometryFrame::ReflowSVG's use of GetHitTestFlags. + // (Only a reflow, no visual change.) + // + // pointer-events changes can change event regions overrides on layers and + // so needs a repaint. + const auto kPointerEventsHint = + nsChangeHint_NeedReflow | nsChangeHint_SchedulePaint; + + nsChangeHint hint = nsChangeHint(0); + if (mCursor != aNewData.mCursor) { + hint |= nsChangeHint_UpdateCursor; + } + + if (mPointerEvents != aNewData.mPointerEvents) { + hint |= kPointerEventsHint; + } + + if (mUserModify != aNewData.mUserModify) { + hint |= NS_STYLE_HINT_VISUAL; + } + + if (mInert != aNewData.mInert) { + // inert affects pointer-events, user-modify, user-select, user-focus and + // -moz-user-input, do the union of all them (minus + // nsChangeHint_NeutralChange which isn't needed if there's any other hint). + hint |= NS_STYLE_HINT_VISUAL | kPointerEventsHint; + } + + if (mUserFocus != aNewData.mUserFocus || mUserInput != aNewData.mUserInput) { + hint |= nsChangeHint_NeutralChange; + } + + if (mCaretColor != aNewData.mCaretColor || + mAccentColor != aNewData.mAccentColor || + mScrollbarColor != aNewData.mScrollbarColor || + mMozTheme != aNewData.mMozTheme || + mColorScheme != aNewData.mColorScheme) { + hint |= nsChangeHint_RepaintFrame; + } + + return hint; +} + +//----------------------- +// nsStyleUIReset +// + +nsStyleUIReset::nsStyleUIReset() + : mUserSelect(StyleUserSelect::Auto), + mScrollbarWidth(StyleScrollbarWidth::Auto), + mMozForceBrokenImageIcon(false), + mMozSubtreeHiddenOnlyVisually(false), + mIMEMode(StyleImeMode::Auto), + mWindowDragging(StyleWindowDragging::Default), + mWindowShadow(StyleWindowShadow::Auto), + mWindowOpacity(1.0), + mMozWindowInputRegionMargin(StyleLength::Zero()), + mWindowTransformOrigin{LengthPercentage::FromPercentage(0.5), + LengthPercentage::FromPercentage(0.5), + {0.}}, + mTransitions( + nsStyleAutoArray<StyleTransition>::WITH_SINGLE_INITIAL_ELEMENT), + mTransitionTimingFunctionCount(1), + mTransitionDurationCount(1), + mTransitionDelayCount(1), + mTransitionPropertyCount(1), + mAnimations( + nsStyleAutoArray<StyleAnimation>::WITH_SINGLE_INITIAL_ELEMENT), + mAnimationTimingFunctionCount(1), + mAnimationDurationCount(1), + mAnimationDelayCount(1), + mAnimationNameCount(1), + mAnimationDirectionCount(1), + mAnimationFillModeCount(1), + mAnimationPlayStateCount(1), + mAnimationIterationCountCount(1), + mAnimationCompositionCount(1), + mAnimationTimelineCount(1), + mScrollTimelines( + nsStyleAutoArray<StyleScrollTimeline>::WITH_SINGLE_INITIAL_ELEMENT), + mScrollTimelineNameCount(1), + mScrollTimelineAxisCount(1), + mViewTimelines( + nsStyleAutoArray<StyleViewTimeline>::WITH_SINGLE_INITIAL_ELEMENT), + mViewTimelineNameCount(1), + mViewTimelineAxisCount(1), + mViewTimelineInsetCount(1) { + MOZ_COUNT_CTOR(nsStyleUIReset); +} + +nsStyleUIReset::nsStyleUIReset(const nsStyleUIReset& aSource) + : mUserSelect(aSource.mUserSelect), + mScrollbarWidth(aSource.mScrollbarWidth), + mMozForceBrokenImageIcon(aSource.mMozForceBrokenImageIcon), + mMozSubtreeHiddenOnlyVisually(aSource.mMozSubtreeHiddenOnlyVisually), + mIMEMode(aSource.mIMEMode), + mWindowDragging(aSource.mWindowDragging), + mWindowShadow(aSource.mWindowShadow), + mWindowOpacity(aSource.mWindowOpacity), + mMozWindowInputRegionMargin(aSource.mMozWindowInputRegionMargin), + mMozWindowTransform(aSource.mMozWindowTransform), + mWindowTransformOrigin(aSource.mWindowTransformOrigin), + mTransitions(aSource.mTransitions.Clone()), + mTransitionTimingFunctionCount(aSource.mTransitionTimingFunctionCount), + mTransitionDurationCount(aSource.mTransitionDurationCount), + mTransitionDelayCount(aSource.mTransitionDelayCount), + mTransitionPropertyCount(aSource.mTransitionPropertyCount), + mAnimations(aSource.mAnimations.Clone()), + mAnimationTimingFunctionCount(aSource.mAnimationTimingFunctionCount), + mAnimationDurationCount(aSource.mAnimationDurationCount), + mAnimationDelayCount(aSource.mAnimationDelayCount), + mAnimationNameCount(aSource.mAnimationNameCount), + mAnimationDirectionCount(aSource.mAnimationDirectionCount), + mAnimationFillModeCount(aSource.mAnimationFillModeCount), + mAnimationPlayStateCount(aSource.mAnimationPlayStateCount), + mAnimationIterationCountCount(aSource.mAnimationIterationCountCount), + mAnimationCompositionCount(aSource.mAnimationCompositionCount), + mAnimationTimelineCount(aSource.mAnimationTimelineCount), + mScrollTimelines(aSource.mScrollTimelines.Clone()), + mScrollTimelineNameCount(aSource.mScrollTimelineNameCount), + mScrollTimelineAxisCount(aSource.mScrollTimelineAxisCount), + mViewTimelines(aSource.mViewTimelines.Clone()), + mViewTimelineNameCount(aSource.mViewTimelineNameCount), + mViewTimelineAxisCount(aSource.mViewTimelineAxisCount), + mViewTimelineInsetCount(aSource.mViewTimelineInsetCount) { + MOZ_COUNT_CTOR(nsStyleUIReset); +} + +nsChangeHint nsStyleUIReset::CalcDifference( + const nsStyleUIReset& aNewData) const { + nsChangeHint hint = nsChangeHint(0); + + if (mMozForceBrokenImageIcon != aNewData.mMozForceBrokenImageIcon) { + hint |= nsChangeHint_ReconstructFrame; + } + if (mMozSubtreeHiddenOnlyVisually != aNewData.mMozSubtreeHiddenOnlyVisually) { + hint |= nsChangeHint_RepaintFrame; + } + if (mScrollbarWidth != aNewData.mScrollbarWidth) { + // For scrollbar-width change, we need some special handling similar + // to overflow properties. Specifically, we may need to reconstruct + // the scrollbar or force reflow of the viewport scrollbar. + hint |= nsChangeHint_ScrollbarChange; + } + if (mWindowShadow != aNewData.mWindowShadow) { + // We really need just an nsChangeHint_SyncFrameView, except + // on an ancestor of the frame, so we get that by doing a + // reflow. + hint |= NS_STYLE_HINT_REFLOW; + } + if (mUserSelect != aNewData.mUserSelect) { + hint |= NS_STYLE_HINT_VISUAL; + } + + if (mWindowDragging != aNewData.mWindowDragging) { + hint |= nsChangeHint_SchedulePaint; + } + + if (!hint && + (mTransitions != aNewData.mTransitions || + mTransitionTimingFunctionCount != + aNewData.mTransitionTimingFunctionCount || + mTransitionDurationCount != aNewData.mTransitionDurationCount || + mTransitionDelayCount != aNewData.mTransitionDelayCount || + mTransitionPropertyCount != aNewData.mTransitionPropertyCount || + mAnimations != aNewData.mAnimations || + mAnimationTimingFunctionCount != + aNewData.mAnimationTimingFunctionCount || + mAnimationDurationCount != aNewData.mAnimationDurationCount || + mAnimationDelayCount != aNewData.mAnimationDelayCount || + mAnimationNameCount != aNewData.mAnimationNameCount || + mAnimationDirectionCount != aNewData.mAnimationDirectionCount || + mAnimationFillModeCount != aNewData.mAnimationFillModeCount || + mAnimationPlayStateCount != aNewData.mAnimationPlayStateCount || + mAnimationIterationCountCount != + aNewData.mAnimationIterationCountCount || + mAnimationCompositionCount != aNewData.mAnimationCompositionCount || + mAnimationTimelineCount != aNewData.mAnimationTimelineCount || + mIMEMode != aNewData.mIMEMode || + mWindowOpacity != aNewData.mWindowOpacity || + mMozWindowInputRegionMargin != aNewData.mMozWindowInputRegionMargin || + mMozWindowTransform != aNewData.mMozWindowTransform || + mScrollTimelines != aNewData.mScrollTimelines || + mScrollTimelineNameCount != aNewData.mScrollTimelineNameCount || + mScrollTimelineAxisCount != aNewData.mScrollTimelineAxisCount || + mViewTimelines != aNewData.mViewTimelines || + mViewTimelineNameCount != aNewData.mViewTimelineNameCount || + mViewTimelineAxisCount != aNewData.mViewTimelineAxisCount || + mViewTimelineInsetCount != aNewData.mViewTimelineInsetCount)) { + hint |= nsChangeHint_NeutralChange; + } + + return hint; +} + +StyleScrollbarWidth nsStyleUIReset::ScrollbarWidth() const { + if (MOZ_UNLIKELY(StaticPrefs::layout_css_scrollbar_width_thin_disabled())) { + if (mScrollbarWidth == StyleScrollbarWidth::Thin) { + return StyleScrollbarWidth::Auto; + } + } + return mScrollbarWidth; +} + +//----------------------- +// nsStyleEffects +// + +nsStyleEffects::nsStyleEffects() + : mClip(StyleClipRectOrAuto::Auto()), + mOpacity(1.0f), + mMixBlendMode(StyleBlend::Normal) { + MOZ_COUNT_CTOR(nsStyleEffects); +} + +nsStyleEffects::nsStyleEffects(const nsStyleEffects& aSource) + : mFilters(aSource.mFilters), + mBoxShadow(aSource.mBoxShadow), + mBackdropFilters(aSource.mBackdropFilters), + mClip(aSource.mClip), + mOpacity(aSource.mOpacity), + mMixBlendMode(aSource.mMixBlendMode) { + MOZ_COUNT_CTOR(nsStyleEffects); +} + +static bool AnyAutonessChanged(const StyleClipRectOrAuto& aOld, + const StyleClipRectOrAuto& aNew) { + if (aOld.IsAuto() != aNew.IsAuto()) { + return true; + } + if (aOld.IsAuto()) { + return false; + } + const auto& oldRect = aOld.AsRect(); + const auto& newRect = aNew.AsRect(); + return oldRect.top.IsAuto() != newRect.top.IsAuto() || + oldRect.right.IsAuto() != newRect.right.IsAuto() || + oldRect.bottom.IsAuto() != newRect.bottom.IsAuto() || + oldRect.left.IsAuto() != newRect.left.IsAuto(); +} + +nsChangeHint nsStyleEffects::CalcDifference( + const nsStyleEffects& aNewData) const { + nsChangeHint hint = nsChangeHint(0); + + if (mBoxShadow != aNewData.mBoxShadow) { + // Update overflow regions & trigger DLBI to be sure it's noticed. + // Also request a repaint, since it's possible that only the color + // of the shadow is changing (and UpdateOverflow/SchedulePaint won't + // repaint for that, since they won't know what needs invalidating.) + hint |= nsChangeHint_UpdateOverflow | nsChangeHint_SchedulePaint | + nsChangeHint_RepaintFrame; + } + + if (AnyAutonessChanged(mClip, aNewData.mClip)) { + hint |= nsChangeHint_AllReflowHints | nsChangeHint_RepaintFrame; + } else if (mClip != aNewData.mClip) { + // If the clip has changed, we just need to update overflow areas. DLBI + // will handle the invalidation. + hint |= nsChangeHint_UpdateOverflow | nsChangeHint_SchedulePaint; + } + + if (mOpacity != aNewData.mOpacity) { + hint |= nsChangeHint_UpdateOpacityLayer; + + // If we're going from the optimized >=0.99 opacity value to 1.0 or back, + // then repaint the frame because DLBI will not catch the invalidation. + // Otherwise, just update the opacity layer. + if ((mOpacity >= 0.99f && mOpacity < 1.0f && aNewData.mOpacity == 1.0f) || + (aNewData.mOpacity >= 0.99f && aNewData.mOpacity < 1.0f && + mOpacity == 1.0f)) { + hint |= nsChangeHint_RepaintFrame; + } else { + if ((mOpacity == 1.0f) != (aNewData.mOpacity == 1.0f)) { + hint |= nsChangeHint_UpdateUsesOpacity; + } + } + } + + if (HasFilters() != aNewData.HasFilters()) { + // A change from/to being a containing block for position:fixed. + hint |= nsChangeHint_UpdateContainingBlock; + } + + if (mFilters != aNewData.mFilters) { + hint |= nsChangeHint_UpdateEffects | nsChangeHint_RepaintFrame | + nsChangeHint_UpdateOverflow; + } + + if (mMixBlendMode != aNewData.mMixBlendMode) { + hint |= nsChangeHint_RepaintFrame; + } + + if (HasBackdropFilters() != aNewData.HasBackdropFilters()) { + // A change from/to being a containing block for position:fixed. + hint |= nsChangeHint_UpdateContainingBlock; + } + + if (mBackdropFilters != aNewData.mBackdropFilters) { + hint |= nsChangeHint_UpdateEffects | nsChangeHint_RepaintFrame; + } + + return hint; +} + +static bool TransformOperationHasPercent(const StyleTransformOperation& aOp) { + switch (aOp.tag) { + case StyleTransformOperation::Tag::TranslateX: + return aOp.AsTranslateX().HasPercent(); + case StyleTransformOperation::Tag::TranslateY: + return aOp.AsTranslateY().HasPercent(); + case StyleTransformOperation::Tag::TranslateZ: + return false; + case StyleTransformOperation::Tag::Translate3D: { + const auto& translate = aOp.AsTranslate3D(); + // NOTE(emilio): z translation is a `<length>`, so can't have percentages. + return translate._0.HasPercent() || translate._1.HasPercent(); + } + case StyleTransformOperation::Tag::Translate: { + const auto& translate = aOp.AsTranslate(); + return translate._0.HasPercent() || translate._1.HasPercent(); + } + case StyleTransformOperation::Tag::AccumulateMatrix: { + const auto& accum = aOp.AsAccumulateMatrix(); + return accum.from_list.HasPercent() || accum.to_list.HasPercent(); + } + case StyleTransformOperation::Tag::InterpolateMatrix: { + const auto& interpolate = aOp.AsInterpolateMatrix(); + return interpolate.from_list.HasPercent() || + interpolate.to_list.HasPercent(); + } + case StyleTransformOperation::Tag::Perspective: + case StyleTransformOperation::Tag::RotateX: + case StyleTransformOperation::Tag::RotateY: + case StyleTransformOperation::Tag::RotateZ: + case StyleTransformOperation::Tag::Rotate: + case StyleTransformOperation::Tag::Rotate3D: + case StyleTransformOperation::Tag::SkewX: + case StyleTransformOperation::Tag::SkewY: + case StyleTransformOperation::Tag::Skew: + case StyleTransformOperation::Tag::ScaleX: + case StyleTransformOperation::Tag::ScaleY: + case StyleTransformOperation::Tag::ScaleZ: + case StyleTransformOperation::Tag::Scale: + case StyleTransformOperation::Tag::Scale3D: + case StyleTransformOperation::Tag::Matrix: + case StyleTransformOperation::Tag::Matrix3D: + return false; + default: + MOZ_ASSERT_UNREACHABLE("Unknown transform operation"); + return false; + } +} + +template <> +bool StyleTransform::HasPercent() const { + for (const auto& op : Operations()) { + if (TransformOperationHasPercent(op)) { + return true; + } + } + return false; +} + +template <> +void StyleCalcNode::ScaleLengthsBy(float aScale) { + auto ScaleNode = [aScale](const StyleCalcNode& aNode) { + // This const_cast could be removed by generating more mut-casts, if + // needed. + const_cast<StyleCalcNode&>(aNode).ScaleLengthsBy(aScale); + }; + + switch (tag) { + case Tag::Leaf: { + const auto& leaf = AsLeaf(); + if (leaf.IsLength()) { + // This const_cast could be removed by generating more mut-casts, if + // needed. + const_cast<Length&>(leaf.AsLength()).ScaleBy(aScale); + } + break; + } + case Tag::Clamp: { + const auto& clamp = AsClamp(); + ScaleNode(*clamp.min); + ScaleNode(*clamp.center); + ScaleNode(*clamp.max); + break; + } + case Tag::Round: { + const auto& round = AsRound(); + ScaleNode(*round.value); + ScaleNode(*round.step); + break; + } + case Tag::ModRem: { + const auto& modRem = AsModRem(); + ScaleNode(*modRem.dividend); + ScaleNode(*modRem.divisor); + break; + } + case Tag::MinMax: { + for (const auto& child : AsMinMax()._0.AsSpan()) { + ScaleNode(child); + } + break; + } + case Tag::Sum: { + for (const auto& child : AsSum().AsSpan()) { + ScaleNode(child); + } + break; + } + case Tag::Product: { + for (const auto& child : AsProduct().AsSpan()) { + ScaleNode(child); + } + break; + } + case Tag::Negate: { + const auto& negate = AsNegate(); + ScaleNode(*negate); + break; + } + case Tag::Invert: { + const auto& invert = AsInvert(); + ScaleNode(*invert); + break; + } + case Tag::Hypot: { + for (const auto& child : AsHypot().AsSpan()) { + ScaleNode(child); + } + break; + } + case Tag::Abs: { + const auto& abs = AsAbs(); + ScaleNode(*abs); + break; + } + case Tag::Sign: { + const auto& sign = AsSign(); + ScaleNode(*sign); + break; + } + } +} + +nscoord StyleCalcLengthPercentage::Resolve(nscoord aBasis, + CoordRounder aRounder) const { + CSSCoord result = ResolveToCSSPixels(CSSPixel::FromAppUnits(aBasis)); + return aRounder(result * AppUnitsPerCSSPixel()); +} + +bool nsStyleDisplay::PrecludesSizeContainmentOrContentVisibilityWithFrame( + const nsIFrame& aFrame) const { + // The spec says that in the case of SVG, the contain property only applies + // to <svg> elements that have an associated CSS layout box. + // https://drafts.csswg.org/css-contain/#contain-property + // Internal SVG elements do not use the standard CSS box model, and wouldn't + // be affected by size containment. By disabling it we prevent them from + // becoming query containers for size features. + if (aFrame.HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { + return true; + } + + // Note: The spec for size containment says it should have no effect + // - on non-atomic, inline-level boxes. + // - on internal ruby boxes. + // - if inner display type is table. + // - on internal table boxes. + // https://drafts.csswg.org/css-contain/#containment-size + bool isNonReplacedInline = aFrame.IsLineParticipant() && !aFrame.IsReplaced(); + return isNonReplacedInline || IsInternalRubyDisplayType() || + DisplayInside() == mozilla::StyleDisplayInside::Table || + IsInnerTableStyle(); +} + +ContainSizeAxes nsStyleDisplay::GetContainSizeAxes( + const nsIFrame& aFrame) const { + // Short circuit for no containment whatsoever + if (MOZ_LIKELY(!mEffectiveContainment)) { + return ContainSizeAxes(false, false); + } + + if (PrecludesSizeContainmentOrContentVisibilityWithFrame(aFrame)) { + return ContainSizeAxes(false, false); + } + + // https://drafts.csswg.org/css-contain-2/#content-visibility + // If this content skips its content via content-visibility, it always has + // size containment. + if (MOZ_LIKELY(!(mEffectiveContainment & StyleContain::SIZE)) && + MOZ_UNLIKELY(aFrame.HidesContent())) { + return ContainSizeAxes(true, true); + } + + return ContainSizeAxes( + static_cast<bool>(mEffectiveContainment & StyleContain::INLINE_SIZE), + static_cast<bool>(mEffectiveContainment & StyleContain::BLOCK_SIZE)); +} + +StyleContentVisibility nsStyleDisplay::ContentVisibility( + const nsIFrame& aFrame) const { + if (MOZ_LIKELY(mContentVisibility == StyleContentVisibility::Visible)) { + return StyleContentVisibility::Visible; + } + // content-visibility applies to elements for which size containment applies. + // https://drafts.csswg.org/css-contain/#content-visibility + if (PrecludesSizeContainmentOrContentVisibilityWithFrame(aFrame)) { + return StyleContentVisibility::Visible; + } + return mContentVisibility; +} + +static nscoord Resolve(const StyleContainIntrinsicSize& aSize, + nscoord aNoneValue, const nsIFrame& aFrame, + LogicalAxis aAxis) { + if (aSize.IsNone()) { + return aNoneValue; + } + if (aSize.IsLength()) { + return aSize.AsLength().ToAppUnits(); + } + MOZ_ASSERT(aSize.HasAuto()); + if (const auto* element = Element::FromNodeOrNull(aFrame.GetContent())) { + Maybe<float> lastSize = aAxis == eLogicalAxisBlock + ? element->GetLastRememberedBSize() + : element->GetLastRememberedISize(); + if (lastSize && aFrame.HidesContent()) { + return CSSPixel::ToAppUnits(*lastSize); + } + } + if (aSize.IsAutoNone()) { + return aNoneValue; + } + return aSize.AsAutoLength().ToAppUnits(); +} + +Maybe<nscoord> ContainSizeAxes::ContainIntrinsicBSize( + const nsIFrame& aFrame, nscoord aNoneValue) const { + if (!mBContained) { + return Nothing(); + } + const StyleContainIntrinsicSize& bSize = + aFrame.StylePosition()->ContainIntrinsicBSize(aFrame.GetWritingMode()); + return Some(Resolve(bSize, aNoneValue, aFrame, eLogicalAxisBlock)); +} + +Maybe<nscoord> ContainSizeAxes::ContainIntrinsicISize( + const nsIFrame& aFrame, nscoord aNoneValue) const { + if (!mIContained) { + return Nothing(); + } + const StyleContainIntrinsicSize& iSize = + aFrame.StylePosition()->ContainIntrinsicISize(aFrame.GetWritingMode()); + return Some(Resolve(iSize, aNoneValue, aFrame, eLogicalAxisInline)); +} + +nsSize ContainSizeAxes::ContainSize(const nsSize& aUncontainedSize, + const nsIFrame& aFrame) const { + if (!IsAny()) { + return aUncontainedSize; + } + if (aFrame.GetWritingMode().IsVertical()) { + return nsSize( + ContainIntrinsicBSize(aFrame).valueOr(aUncontainedSize.Width()), + ContainIntrinsicISize(aFrame).valueOr(aUncontainedSize.Height())); + } + return nsSize( + ContainIntrinsicISize(aFrame).valueOr(aUncontainedSize.Width()), + ContainIntrinsicBSize(aFrame).valueOr(aUncontainedSize.Height())); +} + +IntrinsicSize ContainSizeAxes::ContainIntrinsicSize( + const IntrinsicSize& aUncontainedSize, const nsIFrame& aFrame) const { + if (!IsAny()) { + return aUncontainedSize; + } + IntrinsicSize result(aUncontainedSize); + const bool isVerticalWM = aFrame.GetWritingMode().IsVertical(); + if (Maybe<nscoord> containBSize = ContainIntrinsicBSize(aFrame)) { + (isVerticalWM ? result.width : result.height) = containBSize; + } + if (Maybe<nscoord> containISize = ContainIntrinsicISize(aFrame)) { + (isVerticalWM ? result.height : result.width) = containISize; + } + return result; +} |