/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* 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 nsStyleContext, the * internal API for computed style data for an element */ #include "nsStyleStruct.h" #include "nsStyleStructInlines.h" #include "nsStyleConsts.h" #include "nsThemeConstants.h" #include "nsString.h" #include "nsPresContext.h" #include "nsIAppShellService.h" #include "nsIWidget.h" #include "nsCRTGlue.h" #include "nsCSSParser.h" #include "nsCSSProps.h" #include "nsDeviceContext.h" #include "nsStyleUtil.h" #include "nsCOMPtr.h" #include "nsBidiUtils.h" #include "nsLayoutUtils.h" #include "imgIRequest.h" #include "imgIContainer.h" #include "CounterStyleManager.h" #include "mozilla/dom/AnimationEffectReadOnlyBinding.h" // for PlaybackDirection #include "mozilla/dom/ImageTracker.h" #include "mozilla/Likely.h" #include "nsIURI.h" #include "nsIDocument.h" #include using namespace mozilla; using namespace mozilla::dom; static_assert((((1 << nsStyleStructID_Length) - 1) & ~(NS_STYLE_INHERIT_MASK)) == 0, "Not enough bits in NS_STYLE_INHERIT_MASK"); /* static */ const int32_t nsStyleGridLine::kMinLine; /* static */ const int32_t nsStyleGridLine::kMaxLine; static bool EqualURIs(nsIURI *aURI1, nsIURI *aURI2) { bool eq; return aURI1 == aURI2 || // handle null==null, and optimize (aURI1 && aURI2 && NS_SUCCEEDED(aURI1->Equals(aURI2, &eq)) && // not equal on fail eq); } static bool DefinitelyEqualURIs(css::URLValueData* aURI1, css::URLValueData* aURI2) { return aURI1 == aURI2 || (aURI1 && aURI2 && aURI1->DefinitelyEqualURIs(*aURI2)); } static bool DefinitelyEqualURIsAndPrincipal(css::URLValueData* aURI1, css::URLValueData* aURI2) { return aURI1 == aURI2 || (aURI1 && aURI2 && aURI1->DefinitelyEqualURIsAndPrincipal(*aURI2)); } static bool EqualImages(imgIRequest *aImage1, imgIRequest* aImage2) { if (aImage1 == aImage2) { return true; } if (!aImage1 || !aImage2) { return false; } nsCOMPtr uri1, uri2; aImage1->GetURI(getter_AddRefs(uri1)); aImage2->GetURI(getter_AddRefs(uri2)); return EqualURIs(uri1, uri2); } static bool DefinitelyEqualImages(nsStyleImageRequest* aRequest1, nsStyleImageRequest* aRequest2) { if (aRequest1 == aRequest2) { return true; } if (!aRequest1 || !aRequest2) { return false; } return aRequest1->DefinitelyEquals(*aRequest2); } // A nullsafe wrapper for strcmp. We depend on null-safety. static int safe_strcmp(const char16_t* a, const char16_t* b) { if (!a || !b) { return (int)(a - b); } return NS_strcmp(a, b); } int32_t StyleStructContext::AppUnitsPerDevPixel() { return DeviceContext()->AppUnitsPerDevPixel(); } nsDeviceContext* StyleStructContext::HackilyFindSomeDeviceContext() { nsCOMPtr appShell(do_GetService("@mozilla.org/appshell/appShellService;1")); MOZ_ASSERT(appShell); nsCOMPtr win; appShell->GetHiddenDOMWindow(getter_AddRefs(win)); return nsLayoutUtils::GetDeviceContextForScreenInfo(static_cast(win.get())); } static bool AreShadowArraysEqual(nsCSSShadowArray* lhs, nsCSSShadowArray* rhs); // -------------------- // nsStyleFont // nsStyleFont::nsStyleFont(const nsFont& aFont, StyleStructContext aContext) : mFont(aFont) , mSize(nsStyleFont::ZoomText(aContext, mFont.size)) , mGenericID(kGenericFont_NONE) , mScriptLevel(0) , mMathVariant(NS_MATHML_MATHVARIANT_NONE) , mMathDisplay(NS_MATHML_DISPLAYSTYLE_INLINE) , mMinFontSizeRatio(100) // 100% , mExplicitLanguage(false) , mAllowZoom(true) , mScriptUnconstrainedSize(mSize) , mScriptMinSize(nsPresContext::CSSTwipsToAppUnits( NS_POINTS_TO_TWIPS(NS_MATHML_DEFAULT_SCRIPT_MIN_SIZE_PT))) , mScriptSizeMultiplier(NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER) , mLanguage(GetLanguage(aContext)) { MOZ_COUNT_CTOR(nsStyleFont); mFont.size = mSize; } nsStyleFont::nsStyleFont(const nsStyleFont& aSrc) : mFont(aSrc.mFont) , mSize(aSrc.mSize) , mGenericID(aSrc.mGenericID) , mScriptLevel(aSrc.mScriptLevel) , mMathVariant(aSrc.mMathVariant) , mMathDisplay(aSrc.mMathDisplay) , mMinFontSizeRatio(aSrc.mMinFontSizeRatio) , mExplicitLanguage(aSrc.mExplicitLanguage) , mAllowZoom(aSrc.mAllowZoom) , mScriptUnconstrainedSize(aSrc.mScriptUnconstrainedSize) , mScriptMinSize(aSrc.mScriptMinSize) , mScriptSizeMultiplier(aSrc.mScriptSizeMultiplier) , mLanguage(aSrc.mLanguage) { MOZ_COUNT_CTOR(nsStyleFont); } nsStyleFont::nsStyleFont(StyleStructContext aContext) : nsStyleFont(*aContext.GetDefaultFont(kPresContext_DefaultVariableFont_ID), aContext) { } void nsStyleFont::Destroy(nsPresContext* aContext) { this->~nsStyleFont(); aContext->PresShell()-> FreeByObjectID(eArenaObjectID_nsStyleFont, this); } void nsStyleFont::EnableZoom(nsPresContext* aContext, bool aEnable) { if (mAllowZoom == aEnable) { return; } mAllowZoom = aEnable; if (mAllowZoom) { mSize = nsStyleFont::ZoomText(aContext, mSize); mFont.size = nsStyleFont::ZoomText(aContext, mFont.size); mScriptUnconstrainedSize = nsStyleFont::ZoomText(aContext, mScriptUnconstrainedSize); } else { mSize = nsStyleFont::UnZoomText(aContext, mSize); mFont.size = nsStyleFont::UnZoomText(aContext, mFont.size); mScriptUnconstrainedSize = nsStyleFont::UnZoomText(aContext, mScriptUnconstrainedSize); } } nsChangeHint nsStyleFont::CalcDifference(const nsStyleFont& aNewData) const { MOZ_ASSERT(mAllowZoom == aNewData.mAllowZoom, "expected mAllowZoom to be the same on both nsStyleFonts"); if (mSize != aNewData.mSize || mFont != aNewData.mFont || mLanguage != aNewData.mLanguage || mExplicitLanguage != aNewData.mExplicitLanguage || mMathVariant != aNewData.mMathVariant || mMathDisplay != aNewData.mMathDisplay || mMinFontSizeRatio != aNewData.mMinFontSizeRatio) { return NS_STYLE_HINT_REFLOW; } // XXX Should any of these cause a non-nsChangeHint_NeutralChange change? if (mGenericID != aNewData.mGenericID || mScriptLevel != aNewData.mScriptLevel || mScriptUnconstrainedSize != aNewData.mScriptUnconstrainedSize || mScriptMinSize != aNewData.mScriptMinSize || mScriptSizeMultiplier != aNewData.mScriptSizeMultiplier) { return nsChangeHint_NeutralChange; } return nsChangeHint(0); } /* static */ nscoord nsStyleFont::ZoomText(StyleStructContext aContext, nscoord aSize) { // aSize can be negative (e.g.: calc(-1px)) so we can't assert that here. // The caller is expected deal with that. return NSToCoordTruncClamped(float(aSize) * aContext.TextZoom()); } /* static */ nscoord nsStyleFont::UnZoomText(nsPresContext *aPresContext, nscoord aSize) { // aSize can be negative (e.g.: calc(-1px)) so we can't assert that here. // The caller is expected deal with that. return NSToCoordTruncClamped(float(aSize) / aPresContext->TextZoom()); } /* static */ already_AddRefed nsStyleFont::GetLanguage(StyleStructContext aContext) { RefPtr language = aContext.GetContentLanguage(); if (!language) { // we didn't find a (usable) Content-Language, so we fall back // to whatever the presContext guessed from the charset // NOTE this should not be used elsewhere, because we want websites // to use UTF-8 with proper language tag, instead of relying on // deriving language from charset. See bug 1040668 comment 67. language = aContext.GetLanguageFromCharset(); } return language.forget(); } static nscoord CalcCoord(const nsStyleCoord& aCoord, const nscoord* aEnumTable, int32_t aNumEnums) { if (aCoord.GetUnit() == eStyleUnit_Enumerated) { MOZ_ASSERT(aEnumTable, "must have enum table"); int32_t value = aCoord.GetIntValue(); if (0 <= value && value < aNumEnums) { return aEnumTable[aCoord.GetIntValue()]; } NS_NOTREACHED("unexpected enum value"); return 0; } MOZ_ASSERT(aCoord.ConvertsToLength(), "unexpected unit"); return nsRuleNode::ComputeCoordPercentCalc(aCoord, 0); } nsStyleMargin::nsStyleMargin(StyleStructContext aContext) { MOZ_COUNT_CTOR(nsStyleMargin); nsStyleCoord zero(0, nsStyleCoord::CoordConstructor); NS_FOR_CSS_SIDES(side) { mMargin.Set(side, zero); } } nsStyleMargin::nsStyleMargin(const nsStyleMargin& aSrc) : mMargin(aSrc.mMargin) { MOZ_COUNT_CTOR(nsStyleMargin); } void nsStyleMargin::Destroy(nsPresContext* aContext) { this->~nsStyleMargin(); aContext->PresShell()-> FreeByObjectID(eArenaObjectID_nsStyleMargin, this); } nsChangeHint nsStyleMargin::CalcDifference(const nsStyleMargin& aNewData) const { if (mMargin == aNewData.mMargin) { return nsChangeHint(0); } // Margin differences can't affect descendant intrinsic sizes and // don't need to force children to reflow. return nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition | nsChangeHint_ClearAncestorIntrinsics; } nsStylePadding::nsStylePadding(StyleStructContext aContext) { MOZ_COUNT_CTOR(nsStylePadding); nsStyleCoord zero(0, nsStyleCoord::CoordConstructor); NS_FOR_CSS_SIDES(side) { mPadding.Set(side, zero); } } nsStylePadding::nsStylePadding(const nsStylePadding& aSrc) : mPadding(aSrc.mPadding) { MOZ_COUNT_CTOR(nsStylePadding); } void nsStylePadding::Destroy(nsPresContext* aContext) { this->~nsStylePadding(); aContext->PresShell()-> FreeByObjectID(eArenaObjectID_nsStylePadding, this); } nsChangeHint nsStylePadding::CalcDifference(const nsStylePadding& aNewData) const { if (mPadding == aNewData.mPadding) { return nsChangeHint(0); } // 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). return NS_STYLE_HINT_REFLOW & ~nsChangeHint_ClearDescendantIntrinsics; } nsStyleBorder::nsStyleBorder(StyleStructContext aContext) : mBorderColors(nullptr) , mBorderImageFill(NS_STYLE_BORDER_IMAGE_SLICE_NOFILL) , mBorderImageRepeatH(NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH) , mBorderImageRepeatV(NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH) , mFloatEdge(StyleFloatEdge::ContentBox) , mBoxDecorationBreak(StyleBoxDecorationBreak::Slice) , mComputedBorder(0, 0, 0, 0) { MOZ_COUNT_CTOR(nsStyleBorder); NS_FOR_CSS_HALF_CORNERS (corner) { mBorderRadius.Set(corner, nsStyleCoord(0, nsStyleCoord::CoordConstructor)); } nscoord medium = (StaticPresData::Get()->GetBorderWidthTable())[NS_STYLE_BORDER_WIDTH_MEDIUM]; NS_FOR_CSS_SIDES(side) { mBorderImageSlice.Set(side, nsStyleCoord(1.0f, eStyleUnit_Percent)); mBorderImageWidth.Set(side, nsStyleCoord(1.0f, eStyleUnit_Factor)); mBorderImageOutset.Set(side, nsStyleCoord(0.0f, eStyleUnit_Factor)); mBorder.Side(side) = medium; mBorderStyle[side] = NS_STYLE_BORDER_STYLE_NONE; mBorderColor[side] = StyleComplexColor::CurrentColor(); } mTwipsPerPixel = aContext.DevPixelsToAppUnits(1); } nsBorderColors::~nsBorderColors() { NS_CSS_DELETE_LIST_MEMBER(nsBorderColors, this, mNext); } nsBorderColors* nsBorderColors::Clone(bool aDeep) const { nsBorderColors* result = new nsBorderColors(mColor); if (MOZ_UNLIKELY(!result)) { return result; } if (aDeep) { NS_CSS_CLONE_LIST_MEMBER(nsBorderColors, this, mNext, result, (false)); } return result; } nsStyleBorder::nsStyleBorder(const nsStyleBorder& aSrc) : mBorderColors(nullptr) , mBorderRadius(aSrc.mBorderRadius) , mBorderImageSource(aSrc.mBorderImageSource) , mBorderImageSlice(aSrc.mBorderImageSlice) , mBorderImageWidth(aSrc.mBorderImageWidth) , mBorderImageOutset(aSrc.mBorderImageOutset) , mBorderImageFill(aSrc.mBorderImageFill) , mBorderImageRepeatH(aSrc.mBorderImageRepeatH) , mBorderImageRepeatV(aSrc.mBorderImageRepeatV) , mFloatEdge(aSrc.mFloatEdge) , mBoxDecorationBreak(aSrc.mBoxDecorationBreak) , mComputedBorder(aSrc.mComputedBorder) , mBorder(aSrc.mBorder) , mTwipsPerPixel(aSrc.mTwipsPerPixel) { MOZ_COUNT_CTOR(nsStyleBorder); if (aSrc.mBorderColors) { EnsureBorderColors(); for (int32_t i = 0; i < 4; i++) { if (aSrc.mBorderColors[i]) { mBorderColors[i] = aSrc.mBorderColors[i]->Clone(); } else { mBorderColors[i] = nullptr; } } } NS_FOR_CSS_SIDES(side) { mBorderStyle[side] = aSrc.mBorderStyle[side]; mBorderColor[side] = aSrc.mBorderColor[side]; } } nsStyleBorder::~nsStyleBorder() { MOZ_COUNT_DTOR(nsStyleBorder); if (mBorderColors) { for (int32_t i = 0; i < 4; i++) { delete mBorderColors[i]; } delete [] mBorderColors; } } void nsStyleBorder::FinishStyle(nsPresContext* aPresContext) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(aPresContext->StyleSet()->IsServo()); mBorderImageSource.ResolveImage(aPresContext); } 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; NS_FOR_CSS_SIDES(s) { nsStyleCoord coord = mBorderImageOutset.Get(s); nscoord value; switch (coord.GetUnit()) { case eStyleUnit_Coord: value = coord.GetCoordValue(); break; case eStyleUnit_Factor: value = coord.GetFactorValue() * mComputedBorder.Side(s); break; default: NS_NOTREACHED("unexpected CSS unit for image outset"); value = 0; break; } outset.Side(s) = value; } return outset; } void nsStyleBorder::Destroy(nsPresContext* aContext) { this->~nsStyleBorder(); aContext->PresShell()-> FreeByObjectID(eArenaObjectID_nsStyleBorder, this); } 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 (mTwipsPerPixel != aNewData.mTwipsPerPixel || GetComputedBorder() != aNewData.GetComputedBorder() || mFloatEdge != aNewData.mFloatEdge || mBorderImageOutset != aNewData.mBorderImageOutset || mBoxDecorationBreak != aNewData.mBoxDecorationBreak) { return NS_STYLE_HINT_REFLOW; } NS_FOR_CSS_SIDES(ix) { // 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. NS_FOR_CSS_SIDES(ix) { if (mBorderStyle[ix] != aNewData.mBorderStyle[ix] || mBorderColor[ix] != aNewData.mBorderColor[ix]) { return nsChangeHint_RepaintFrame; } } if (mBorderRadius != aNewData.mBorderRadius || !mBorderColors != !aNewData.mBorderColors) { return nsChangeHint_RepaintFrame; } if (IsBorderImageLoaded() || aNewData.IsBorderImageLoaded()) { if (mBorderImageSource != aNewData.mBorderImageSource || mBorderImageRepeatH != aNewData.mBorderImageRepeatH || mBorderImageRepeatV != aNewData.mBorderImageRepeatV || mBorderImageSlice != aNewData.mBorderImageSlice || mBorderImageFill != aNewData.mBorderImageFill || mBorderImageWidth != aNewData.mBorderImageWidth || mBorderImageOutset != aNewData.mBorderImageOutset) { return nsChangeHint_RepaintFrame; } } // Note that at this point if mBorderColors is non-null so is // aNewData.mBorderColors if (mBorderColors) { NS_FOR_CSS_SIDES(ix) { if (!nsBorderColors::Equal(mBorderColors[ix], aNewData.mBorderColors[ix])) { 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; } return nsChangeHint(0); } nsStyleOutline::nsStyleOutline(StyleStructContext aContext) : mOutlineWidth(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated) , mOutlineOffset(0) , mOutlineColor(StyleComplexColor::CurrentColor()) , mOutlineStyle(NS_STYLE_BORDER_STYLE_NONE) , mActualOutlineWidth(0) , mTwipsPerPixel(aContext.DevPixelsToAppUnits(1)) { MOZ_COUNT_CTOR(nsStyleOutline); // spacing values not inherited nsStyleCoord zero(0, nsStyleCoord::CoordConstructor); NS_FOR_CSS_HALF_CORNERS(corner) { mOutlineRadius.Set(corner, zero); } } nsStyleOutline::nsStyleOutline(const nsStyleOutline& aSrc) : mOutlineRadius(aSrc.mOutlineRadius) , mOutlineWidth(aSrc.mOutlineWidth) , mOutlineOffset(aSrc.mOutlineOffset) , mOutlineColor(aSrc.mOutlineColor) , mOutlineStyle(aSrc.mOutlineStyle) , mActualOutlineWidth(aSrc.mActualOutlineWidth) , mTwipsPerPixel(aSrc.mTwipsPerPixel) { MOZ_COUNT_CTOR(nsStyleOutline); } void nsStyleOutline::RecalcData() { if (NS_STYLE_BORDER_STYLE_NONE == mOutlineStyle) { mActualOutlineWidth = 0; } else { MOZ_ASSERT(mOutlineWidth.ConvertsToLength() || mOutlineWidth.GetUnit() == eStyleUnit_Enumerated); // Clamp negative calc() to 0. mActualOutlineWidth = std::max(CalcCoord(mOutlineWidth, StaticPresData::Get()->GetBorderWidthTable(), 3), 0); mActualOutlineWidth = NS_ROUND_BORDER_TO_PIXELS(mActualOutlineWidth, mTwipsPerPixel); } } nsChangeHint nsStyleOutline::CalcDifference(const nsStyleOutline& aNewData) const { if (mActualOutlineWidth != aNewData.mActualOutlineWidth || (mActualOutlineWidth > 0 && mOutlineOffset != aNewData.mOutlineOffset)) { return nsChangeHint_UpdateOverflow | nsChangeHint_SchedulePaint; } if (mOutlineStyle != aNewData.mOutlineStyle || mOutlineColor != aNewData.mOutlineColor || mOutlineRadius != aNewData.mOutlineRadius) { if (mActualOutlineWidth > 0) { return nsChangeHint_RepaintFrame; } return nsChangeHint_NeutralChange; } if (mOutlineWidth != aNewData.mOutlineWidth || mOutlineOffset != aNewData.mOutlineOffset || mTwipsPerPixel != aNewData.mTwipsPerPixel) { return nsChangeHint_NeutralChange; } return nsChangeHint(0); } // -------------------- // nsStyleList // nsStyleList::nsStyleList(StyleStructContext aContext) : mListStylePosition(NS_STYLE_LIST_STYLE_POSITION_OUTSIDE) , mCounterStyle(aContext.BuildCounterStyle(NS_LITERAL_STRING("disc"))) { MOZ_COUNT_CTOR(nsStyleList); SetQuotesInitial(); } nsStyleList::~nsStyleList() { MOZ_COUNT_DTOR(nsStyleList); } nsStyleList::nsStyleList(const nsStyleList& aSource) : mListStylePosition(aSource.mListStylePosition) , mListStyleImage(aSource.mListStyleImage) , mCounterStyle(aSource.mCounterStyle) , mQuotes(aSource.mQuotes) , mImageRegion(aSource.mImageRegion) { MOZ_COUNT_CTOR(nsStyleList); } void nsStyleList::FinishStyle(nsPresContext* aPresContext) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(aPresContext->StyleSet()->IsServo()); if (mListStyleImage && !mListStyleImage->IsResolved()) { mListStyleImage->Resolve(aPresContext); } } void nsStyleList::SetQuotesInherit(const nsStyleList* aOther) { mQuotes = aOther->mQuotes; } void nsStyleList::SetQuotesInitial() { if (!sInitialQuotes) { // The initial value for quotes is the en-US typographic convention: // outermost are LEFT and RIGHT DOUBLE QUOTATION MARK, alternating // with LEFT and RIGHT SINGLE QUOTATION MARK. static const char16_t initialQuotes[8] = { 0x201C, 0, 0x201D, 0, 0x2018, 0, 0x2019, 0 }; sInitialQuotes = new nsStyleQuoteValues; sInitialQuotes->mQuotePairs.AppendElement( std::make_pair(nsDependentString(&initialQuotes[0], 1), nsDependentString(&initialQuotes[2], 1))); sInitialQuotes->mQuotePairs.AppendElement( std::make_pair(nsDependentString(&initialQuotes[4], 1), nsDependentString(&initialQuotes[6], 1))); } mQuotes = sInitialQuotes; } void nsStyleList::SetQuotesNone() { if (!sNoneQuotes) { sNoneQuotes = new nsStyleQuoteValues; } mQuotes = sNoneQuotes; } void nsStyleList::SetQuotes(nsStyleQuoteValues::QuotePairArray&& aValues) { mQuotes = new nsStyleQuoteValues; mQuotes->mQuotePairs = Move(aValues); } const nsStyleQuoteValues::QuotePairArray& nsStyleList::GetQuotePairs() const { return mQuotes->mQuotePairs; } nsChangeHint nsStyleList::CalcDifference(const nsStyleList& aNewData) 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 && (mQuotes || aNewData.mQuotes) && GetQuotePairs() != aNewData.GetQuotePairs()) { return nsChangeHint_ReconstructFrame; } if (mListStylePosition != aNewData.mListStylePosition) { return nsChangeHint_ReconstructFrame; } if (DefinitelyEqualImages(mListStyleImage, aNewData.mListStyleImage) && mCounterStyle == aNewData.mCounterStyle) { if (mImageRegion.IsEqualInterior(aNewData.mImageRegion)) { return nsChangeHint(0); } if (mImageRegion.width == aNewData.mImageRegion.width && mImageRegion.height == aNewData.mImageRegion.height) { return NS_STYLE_HINT_VISUAL; } } return NS_STYLE_HINT_REFLOW; } StaticRefPtr nsStyleList::sInitialQuotes; StaticRefPtr nsStyleList::sNoneQuotes; // -------------------- // nsStyleXUL // nsStyleXUL::nsStyleXUL(StyleStructContext aContext) : mBoxFlex(0.0f) , mBoxOrdinal(1) , mBoxAlign(StyleBoxAlign::Stretch) , mBoxDirection(StyleBoxDirection::Normal) , mBoxOrient(StyleBoxOrient::Horizontal) , mBoxPack(StyleBoxPack::Start) , mStretchStack(true) { MOZ_COUNT_CTOR(nsStyleXUL); } nsStyleXUL::~nsStyleXUL() { MOZ_COUNT_DTOR(nsStyleXUL); } nsStyleXUL::nsStyleXUL(const nsStyleXUL& aSource) : mBoxFlex(aSource.mBoxFlex) , mBoxOrdinal(aSource.mBoxOrdinal) , mBoxAlign(aSource.mBoxAlign) , mBoxDirection(aSource.mBoxDirection) , mBoxOrient(aSource.mBoxOrient) , mBoxPack(aSource.mBoxPack) , mStretchStack(aSource.mStretchStack) { 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 && mStretchStack == aNewData.mStretchStack) { return nsChangeHint(0); } if (mBoxOrdinal != aNewData.mBoxOrdinal) { return nsChangeHint_ReconstructFrame; } return NS_STYLE_HINT_REFLOW; } // -------------------- // nsStyleColumn // /* static */ const uint32_t nsStyleColumn::kMaxColumnCount; nsStyleColumn::nsStyleColumn(StyleStructContext aContext) : mColumnCount(NS_STYLE_COLUMN_COUNT_AUTO) , mColumnWidth(eStyleUnit_Auto) , mColumnRuleColor(StyleComplexColor::CurrentColor()) , mColumnRuleStyle(NS_STYLE_BORDER_STYLE_NONE) , mColumnFill(NS_STYLE_COLUMN_FILL_BALANCE) , mColumnRuleWidth((StaticPresData::Get() ->GetBorderWidthTable())[NS_STYLE_BORDER_WIDTH_MEDIUM]) , mTwipsPerPixel(aContext.AppUnitsPerDevPixel()) { MOZ_COUNT_CTOR(nsStyleColumn); } nsStyleColumn::~nsStyleColumn() { MOZ_COUNT_DTOR(nsStyleColumn); } nsStyleColumn::nsStyleColumn(const nsStyleColumn& aSource) : mColumnCount(aSource.mColumnCount) , mColumnWidth(aSource.mColumnWidth) , mColumnRuleColor(aSource.mColumnRuleColor) , mColumnRuleStyle(aSource.mColumnRuleStyle) , mColumnFill(aSource.mColumnFill) , mColumnRuleWidth(aSource.mColumnRuleWidth) , mTwipsPerPixel(aSource.mTwipsPerPixel) { MOZ_COUNT_CTOR(nsStyleColumn); } nsChangeHint nsStyleColumn::CalcDifference(const nsStyleColumn& aNewData) const { if ((mColumnWidth.GetUnit() == eStyleUnit_Auto) != (aNewData.mColumnWidth.GetUnit() == eStyleUnit_Auto) || mColumnCount != aNewData.mColumnCount) { // 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 (GetComputedColumnRuleWidth() != aNewData.GetComputedColumnRuleWidth() || mColumnRuleStyle != aNewData.mColumnRuleStyle || mColumnRuleColor != aNewData.mColumnRuleColor) { return NS_STYLE_HINT_VISUAL; } // XXX Is it right that we never check mTwipsPerPixel to return a // non-nsChangeHint_NeutralChange hint? if (mColumnRuleWidth != aNewData.mColumnRuleWidth || mTwipsPerPixel != aNewData.mTwipsPerPixel) { return nsChangeHint_NeutralChange; } return nsChangeHint(0); } // -------------------- // nsStyleSVG // nsStyleSVG::nsStyleSVG(StyleStructContext aContext) : mFill(eStyleSVGPaintType_Color) // Will be initialized to NS_RGB(0, 0, 0) , mStroke(eStyleSVGPaintType_None) , mStrokeDashoffset(0, nsStyleCoord::CoordConstructor) , mStrokeWidth(nsPresContext::CSSPixelsToAppUnits(1), nsStyleCoord::CoordConstructor) , mFillOpacity(1.0f) , mStrokeMiterlimit(4.0f) , mStrokeOpacity(1.0f) , mClipRule(StyleFillRule::Nonzero) , mColorInterpolation(NS_STYLE_COLOR_INTERPOLATION_SRGB) , mColorInterpolationFilters(NS_STYLE_COLOR_INTERPOLATION_LINEARRGB) , mFillRule(StyleFillRule::Nonzero) , mPaintOrder(NS_STYLE_PAINT_ORDER_NORMAL) , mShapeRendering(NS_STYLE_SHAPE_RENDERING_AUTO) , mStrokeLinecap(NS_STYLE_STROKE_LINECAP_BUTT) , mStrokeLinejoin(NS_STYLE_STROKE_LINEJOIN_MITER) , mTextAnchor(NS_STYLE_TEXT_ANCHOR_START) , mContextFlags((eStyleSVGOpacitySource_Normal << FILL_OPACITY_SOURCE_SHIFT) | (eStyleSVGOpacitySource_Normal << STROKE_OPACITY_SOURCE_SHIFT)) { MOZ_COUNT_CTOR(nsStyleSVG); } nsStyleSVG::~nsStyleSVG() { MOZ_COUNT_DTOR(nsStyleSVG); } nsStyleSVG::nsStyleSVG(const nsStyleSVG& aSource) : mFill(aSource.mFill) , mStroke(aSource.mStroke) , mMarkerEnd(aSource.mMarkerEnd) , mMarkerMid(aSource.mMarkerMid) , mMarkerStart(aSource.mMarkerStart) , 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) , mTextAnchor(aSource.mTextAnchor) , mContextFlags(aSource.mContextFlags) { MOZ_COUNT_CTOR(nsStyleSVG); } static bool PaintURIChanged(const nsStyleSVGPaint& aPaint1, const nsStyleSVGPaint& aPaint2) { if (aPaint1.Type() != aPaint2.Type()) { return aPaint1.Type() == eStyleSVGPaintType_Server || aPaint2.Type() == eStyleSVGPaintType_Server; } return aPaint1.Type() == eStyleSVGPaintType_Server && !DefinitelyEqualURIs(aPaint1.GetPaintServer(), aPaint2.GetPaintServer()); } nsChangeHint nsStyleSVG::CalcDifference(const nsStyleSVG& aNewData) const { nsChangeHint hint = nsChangeHint(0); if (!DefinitelyEqualURIs(mMarkerEnd, aNewData.mMarkerEnd) || !DefinitelyEqualURIs(mMarkerMid, aNewData.mMarkerMid) || !DefinitelyEqualURIs(mMarkerStart, aNewData.mMarkerStart)) { // Markers currently contribute to nsSVGPathGeometryFrame::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_NeedDirtyReflow | // XXX remove me: bug 876085 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 nsSVGPathGeometryFrames. hint |= nsChangeHint_NeedReflow | nsChangeHint_NeedDirtyReflow; // XXX remove me: bug 876085 } if (PaintURIChanged(mFill, aNewData.mFill) || PaintURIChanged(mStroke, aNewData.mStroke)) { hint |= nsChangeHint_UpdateEffects; } } // Stroke currently contributes to nsSVGPathGeometryFrame::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 nsSVGPathGeometryFrame::mRect. // text-anchor changes also require a reflow since it changes frames' rects. if (mStrokeWidth != aNewData.mStrokeWidth || mStrokeMiterlimit != aNewData.mStrokeMiterlimit || mStrokeLinecap != aNewData.mStrokeLinecap || mStrokeLinejoin != aNewData.mStrokeLinejoin || mTextAnchor != aNewData.mTextAnchor) { return hint | nsChangeHint_NeedReflow | nsChangeHint_NeedDirtyReflow | // XXX remove me: bug 876085 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 || mContextFlags != aNewData.mContextFlags) { return hint | nsChangeHint_RepaintFrame; } return hint; } // -------------------- // StyleBasicShape nsCSSKeyword StyleBasicShape::GetShapeTypeName() const { switch (mType) { case StyleBasicShapeType::Polygon: return eCSSKeyword_polygon; case StyleBasicShapeType::Circle: return eCSSKeyword_circle; case StyleBasicShapeType::Ellipse: return eCSSKeyword_ellipse; case StyleBasicShapeType::Inset: return eCSSKeyword_inset; } NS_NOTREACHED("unexpected type"); return eCSSKeyword_UNKNOWN; } // -------------------- // nsStyleFilter // nsStyleFilter::nsStyleFilter() : mType(NS_STYLE_FILTER_NONE) , mDropShadow(nullptr) { MOZ_COUNT_CTOR(nsStyleFilter); } nsStyleFilter::nsStyleFilter(const nsStyleFilter& aSource) : mType(NS_STYLE_FILTER_NONE) , mDropShadow(nullptr) { MOZ_COUNT_CTOR(nsStyleFilter); if (aSource.mType == NS_STYLE_FILTER_URL) { SetURL(aSource.mURL); } else if (aSource.mType == NS_STYLE_FILTER_DROP_SHADOW) { SetDropShadow(aSource.mDropShadow); } else if (aSource.mType != NS_STYLE_FILTER_NONE) { SetFilterParameter(aSource.mFilterParameter, aSource.mType); } } nsStyleFilter::~nsStyleFilter() { ReleaseRef(); MOZ_COUNT_DTOR(nsStyleFilter); } nsStyleFilter& nsStyleFilter::operator=(const nsStyleFilter& aOther) { if (this == &aOther) { return *this; } if (aOther.mType == NS_STYLE_FILTER_URL) { SetURL(aOther.mURL); } else if (aOther.mType == NS_STYLE_FILTER_DROP_SHADOW) { SetDropShadow(aOther.mDropShadow); } else if (aOther.mType != NS_STYLE_FILTER_NONE) { SetFilterParameter(aOther.mFilterParameter, aOther.mType); } else { ReleaseRef(); mType = NS_STYLE_FILTER_NONE; } return *this; } bool nsStyleFilter::operator==(const nsStyleFilter& aOther) const { if (mType != aOther.mType) { return false; } if (mType == NS_STYLE_FILTER_URL) { return DefinitelyEqualURIs(mURL, aOther.mURL); } else if (mType == NS_STYLE_FILTER_DROP_SHADOW) { return *mDropShadow == *aOther.mDropShadow; } else if (mType != NS_STYLE_FILTER_NONE) { return mFilterParameter == aOther.mFilterParameter; } return true; } void nsStyleFilter::ReleaseRef() { if (mType == NS_STYLE_FILTER_DROP_SHADOW) { NS_ASSERTION(mDropShadow, "expected pointer"); mDropShadow->Release(); } else if (mType == NS_STYLE_FILTER_URL) { NS_ASSERTION(mURL, "expected pointer"); mURL->Release(); } mURL = nullptr; } void nsStyleFilter::SetFilterParameter(const nsStyleCoord& aFilterParameter, int32_t aType) { ReleaseRef(); mFilterParameter = aFilterParameter; mType = aType; } bool nsStyleFilter::SetURL(css::URLValue* aURL) { ReleaseRef(); mURL = aURL; mURL->AddRef(); mType = NS_STYLE_FILTER_URL; return true; } void nsStyleFilter::SetDropShadow(nsCSSShadowArray* aDropShadow) { NS_ASSERTION(aDropShadow, "expected pointer"); ReleaseRef(); mDropShadow = aDropShadow; mDropShadow->AddRef(); mType = NS_STYLE_FILTER_DROP_SHADOW; } // -------------------- // nsStyleSVGReset // nsStyleSVGReset::nsStyleSVGReset(StyleStructContext aContext) : mMask(nsStyleImageLayers::LayerType::Mask) , mStopColor(NS_RGB(0, 0, 0)) , mFloodColor(NS_RGB(0, 0, 0)) , mLightingColor(NS_RGB(255, 255, 255)) , mStopOpacity(1.0f) , mFloodOpacity(1.0f) , mDominantBaseline(NS_STYLE_DOMINANT_BASELINE_AUTO) , mVectorEffect(NS_STYLE_VECTOR_EFFECT_NONE) , mMaskType(NS_STYLE_MASK_TYPE_LUMINANCE) { MOZ_COUNT_CTOR(nsStyleSVGReset); } nsStyleSVGReset::~nsStyleSVGReset() { MOZ_COUNT_DTOR(nsStyleSVGReset); } nsStyleSVGReset::nsStyleSVGReset(const nsStyleSVGReset& aSource) : mMask(aSource.mMask) , mClipPath(aSource.mClipPath) , mStopColor(aSource.mStopColor) , mFloodColor(aSource.mFloodColor) , mLightingColor(aSource.mLightingColor) , mStopOpacity(aSource.mStopOpacity) , mFloodOpacity(aSource.mFloodOpacity) , mDominantBaseline(aSource.mDominantBaseline) , mVectorEffect(aSource.mVectorEffect) , mMaskType(aSource.mMaskType) { MOZ_COUNT_CTOR(nsStyleSVGReset); } void nsStyleSVGReset::Destroy(nsPresContext* aContext) { this->~nsStyleSVGReset(); aContext->PresShell()-> FreeByObjectID(mozilla::eArenaObjectID_nsStyleSVGReset, this); } void nsStyleSVGReset::FinishStyle(nsPresContext* aPresContext) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(aPresContext->StyleSet()->IsServo()); mMask.ResolveImages(aPresContext); } nsChangeHint nsStyleSVGReset::CalcDifference(const nsStyleSVGReset& aNewData) const { nsChangeHint hint = nsChangeHint(0); if (mClipPath != aNewData.mClipPath) { hint |= nsChangeHint_UpdateEffects | nsChangeHint_RepaintFrame; // clip-path changes require that we update the PreEffectsBBoxProperty, // which is done during overflow computation. hint |= nsChangeHint_UpdateOverflow; } if (mDominantBaseline != aNewData.mDominantBaseline) { // XXXjwatt: why NS_STYLE_HINT_REFLOW? Isn't that excessive? hint |= NS_STYLE_HINT_REFLOW; } else if (mVectorEffect != aNewData.mVectorEffect) { // Stroke currently affects nsSVGPathGeometryFrame::mRect, and // vector-effect affect stroke. As a result we need to reflow if // vector-effect changes in order to have nsSVGPathGeometryFrame:: // ReflowSVG called to update its mRect. No intrinsic sizes need // to change so nsChangeHint_NeedReflow is sufficient. hint |= nsChangeHint_NeedReflow | nsChangeHint_NeedDirtyReflow | // XXX remove me: bug 876085 nsChangeHint_RepaintFrame; } else if (mStopColor != aNewData.mStopColor || mFloodColor != aNewData.mFloodColor || mLightingColor != aNewData.mLightingColor || mStopOpacity != aNewData.mStopOpacity || mFloodOpacity != aNewData.mFloodOpacity || mMaskType != aNewData.mMaskType) { hint |= nsChangeHint_RepaintFrame; } hint |= mMask.CalcDifference(aNewData.mMask, nsStyleImageLayers::LayerType::Mask); return hint; } // nsStyleSVGPaint implementation nsStyleSVGPaint::nsStyleSVGPaint(nsStyleSVGPaintType aType) : mType(aType) , mFallbackColor(NS_RGB(0, 0, 0)) { MOZ_ASSERT(aType == nsStyleSVGPaintType(0) || aType == eStyleSVGPaintType_None || aType == eStyleSVGPaintType_Color); mPaint.mColor = NS_RGB(0, 0, 0); } nsStyleSVGPaint::nsStyleSVGPaint(const nsStyleSVGPaint& aSource) : nsStyleSVGPaint(nsStyleSVGPaintType(0)) { Assign(aSource); } nsStyleSVGPaint::~nsStyleSVGPaint() { Reset(); } void nsStyleSVGPaint::Reset() { switch (mType) { case eStyleSVGPaintType_None: break; case eStyleSVGPaintType_Color: mPaint.mColor = NS_RGB(0, 0, 0); break; case eStyleSVGPaintType_Server: mPaint.mPaintServer->Release(); mPaint.mPaintServer = nullptr; [[fallthrough]]; case eStyleSVGPaintType_ContextFill: case eStyleSVGPaintType_ContextStroke: mFallbackColor = NS_RGB(0, 0, 0); break; } mType = nsStyleSVGPaintType(0); } nsStyleSVGPaint& nsStyleSVGPaint::operator=(const nsStyleSVGPaint& aOther) { if (this != &aOther) { Assign(aOther); } return *this; } void nsStyleSVGPaint::Assign(const nsStyleSVGPaint& aOther) { MOZ_ASSERT(aOther.mType != nsStyleSVGPaintType(0), "shouldn't copy uninitialized nsStyleSVGPaint"); switch (aOther.mType) { case eStyleSVGPaintType_None: SetNone(); break; case eStyleSVGPaintType_Color: SetColor(aOther.mPaint.mColor); break; case eStyleSVGPaintType_Server: SetPaintServer(aOther.mPaint.mPaintServer, aOther.mFallbackColor); break; case eStyleSVGPaintType_ContextFill: case eStyleSVGPaintType_ContextStroke: SetContextValue(aOther.mType, aOther.mFallbackColor); break; } } void nsStyleSVGPaint::SetNone() { Reset(); mType = eStyleSVGPaintType_None; } void nsStyleSVGPaint::SetContextValue(nsStyleSVGPaintType aType, nscolor aFallbackColor) { MOZ_ASSERT(aType == eStyleSVGPaintType_ContextFill || aType == eStyleSVGPaintType_ContextStroke); Reset(); mType = aType; mFallbackColor = aFallbackColor; } void nsStyleSVGPaint::SetColor(nscolor aColor) { Reset(); mType = eStyleSVGPaintType_Color; mPaint.mColor = aColor; } void nsStyleSVGPaint::SetPaintServer(css::URLValue* aPaintServer, nscolor aFallbackColor) { MOZ_ASSERT(aPaintServer); Reset(); mType = eStyleSVGPaintType_Server; mPaint.mPaintServer = aPaintServer; mPaint.mPaintServer->AddRef(); mFallbackColor = aFallbackColor; } bool nsStyleSVGPaint::operator==(const nsStyleSVGPaint& aOther) const { if (mType != aOther.mType) { return false; } switch (mType) { case eStyleSVGPaintType_Color: return mPaint.mColor == aOther.mPaint.mColor; case eStyleSVGPaintType_Server: return DefinitelyEqualURIs(mPaint.mPaintServer, aOther.mPaint.mPaintServer) && mFallbackColor == aOther.mFallbackColor; case eStyleSVGPaintType_ContextFill: case eStyleSVGPaintType_ContextStroke: return mFallbackColor == aOther.mFallbackColor; default: MOZ_ASSERT(mType == eStyleSVGPaintType_None, "Unexpected SVG paint type"); return true; } } // -------------------- // nsStylePosition // nsStylePosition::nsStylePosition(StyleStructContext aContext) : mWidth(eStyleUnit_Auto) , mMinWidth(eStyleUnit_Auto) , mMaxWidth(eStyleUnit_None) , mHeight(eStyleUnit_Auto) , mMinHeight(eStyleUnit_Auto) , mMaxHeight(eStyleUnit_None) , mFlexBasis(eStyleUnit_Auto) , mGridAutoColumnsMin(eStyleUnit_Auto) , mGridAutoColumnsMax(eStyleUnit_Auto) , mGridAutoRowsMin(eStyleUnit_Auto) , mGridAutoRowsMax(eStyleUnit_Auto) , mAspectRatio(0.0f) , mGridAutoFlow(NS_STYLE_GRID_AUTO_FLOW_ROW) , mBoxSizing(StyleBoxSizing::Content) , mAlignContent(NS_STYLE_ALIGN_NORMAL) , mAlignItems(NS_STYLE_ALIGN_NORMAL) , mAlignSelf(NS_STYLE_ALIGN_AUTO) , mJustifyContent(NS_STYLE_JUSTIFY_NORMAL) , mJustifyItems(NS_STYLE_JUSTIFY_AUTO) , mJustifySelf(NS_STYLE_JUSTIFY_AUTO) , mFlexDirection(NS_STYLE_FLEX_DIRECTION_ROW) , mFlexWrap(NS_STYLE_FLEX_WRAP_NOWRAP) , mObjectFit(NS_STYLE_OBJECT_FIT_FILL) , mOrder(NS_STYLE_ORDER_INITIAL) , mFlexGrow(0.0f) , mFlexShrink(1.0f) , mZIndex(eStyleUnit_Auto) , mColumnGap(eStyleUnit_Normal) , mRowGap(eStyleUnit_Normal) { MOZ_COUNT_CTOR(nsStylePosition); // positioning values not inherited mObjectPosition.SetInitialPercentValues(0.5f); nsStyleCoord autoCoord(eStyleUnit_Auto); NS_FOR_CSS_SIDES(side) { mOffset.Set(side, autoCoord); } // 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. // mGridTemplateAreas: nullptr for 'none' // mGridTemplate{Rows,Columns}: false and empty arrays for 'none' // mGrid{Column,Row}{Start,End}: false/0/empty values for 'auto' } nsStylePosition::~nsStylePosition() { MOZ_COUNT_DTOR(nsStylePosition); } nsStylePosition::nsStylePosition(const nsStylePosition& aSource) : 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) , mGridAutoColumnsMin(aSource.mGridAutoColumnsMin) , mGridAutoColumnsMax(aSource.mGridAutoColumnsMax) , mGridAutoRowsMin(aSource.mGridAutoRowsMin) , mGridAutoRowsMax(aSource.mGridAutoRowsMax) , mAspectRatio(aSource.mAspectRatio) , mGridAutoFlow(aSource.mGridAutoFlow) , mBoxSizing(aSource.mBoxSizing) , 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) , 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) { MOZ_COUNT_CTOR(nsStylePosition); } static bool IsAutonessEqual(const nsStyleSides& aSides1, const nsStyleSides& aSides2) { NS_FOR_CSS_SIDES(side) { if ((aSides1.GetUnit(side) == eStyleUnit_Auto) != (aSides2.GetUnit(side) == eStyleUnit_Auto)) { return false; } } return true; } nsChangeHint nsStylePosition::CalcDifference(const nsStylePosition& aNewData, const nsStyleVisibility* aOldStyleVisibility) const { 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 (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; } // Properties that apply to flex items: // XXXdholbert These should probably be more targeted (bug 819536) if (mAlignSelf != aNewData.mAlignSelf || 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. // - align-items can change the sizing of a flex container & the positioning // of its children. // - flex-wrap changes whether a flex container's children are wrapped, which // impacts their sizing/positioning and hence impacts the container's size. if (mAlignItems != aNewData.mAlignItems || 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 || mGridAutoColumnsMin != aNewData.mGridAutoColumnsMin || mGridAutoColumnsMax != aNewData.mGridAutoColumnsMax || mGridAutoRowsMin != aNewData.mGridAutoRowsMin || mGridAutoRowsMax != aNewData.mGridAutoRowsMax || mGridAutoFlow != aNewData.mGridAutoFlow) { 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 != aNewData.mJustifyItems || mJustifySelf != aNewData.mJustifySelf) { hint |= nsChangeHint_NeedReflow; } // '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 aOldStyleVisibility is null, we don't need to bother with any of // these tests, since we know that the element never had its // nsStyleVisibility accessed, which means it couldn't have done // layout. // Note that we pass an nsStyleVisibility here because we don't want // to cause a new struct to be computed during // nsStyleContext::CalcStyleDifference, which can lead to incorrect // style data. // 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, and it's easier to pass the old. if (aOldStyleVisibility) { bool isVertical = WritingMode(aOldStyleVisibility).IsVertical(); if (isVertical ? widthChanged : heightChanged) { hint |= nsChangeHint_ReflowHintsForBSizeChange; } if (isVertical ? heightChanged : widthChanged) { hint |= nsChangeHint_ReflowHintsForISizeChange; } if (mAspectRatio != aNewData.mAspectRatio) { hint |= nsChangeHint_ReflowHintsForISizeChange | nsChangeHint_ReflowHintsForBSizeChange; } } else { if (widthChanged || heightChanged) { hint |= nsChangeHint_NeutralChange; } } // 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_AllReflowHints; } } return hint; } /* static */ bool nsStylePosition::WidthCoordDependsOnContainer(const nsStyleCoord &aCoord) { return aCoord.HasPercent() || (aCoord.GetUnit() == eStyleUnit_Enumerated && (aCoord.GetIntValue() == NS_STYLE_WIDTH_FIT_CONTENT || aCoord.GetIntValue() == NS_STYLE_WIDTH_AVAILABLE)); } uint8_t nsStylePosition::UsedAlignSelf(nsStyleContext* aParent) const { if (mAlignSelf != NS_STYLE_ALIGN_AUTO) { return mAlignSelf; } if (MOZ_LIKELY(aParent)) { auto parentAlignItems = aParent->StylePosition()->mAlignItems; MOZ_ASSERT(!(parentAlignItems & NS_STYLE_ALIGN_LEGACY), "align-items can't have 'legacy'"); return parentAlignItems; } return NS_STYLE_ALIGN_NORMAL; } uint8_t nsStylePosition::ComputedJustifyItems(nsStyleContext* aParent) const { if (mJustifyItems != NS_STYLE_JUSTIFY_AUTO) { return mJustifyItems; } if (MOZ_LIKELY(aParent)) { auto inheritedJustifyItems = aParent->StylePosition()->ComputedJustifyItems(aParent->GetParent()); // "If the inherited value of justify-items includes the 'legacy' keyword, // 'auto' computes to the inherited value." Otherwise, 'normal'. if (inheritedJustifyItems & NS_STYLE_JUSTIFY_LEGACY) { return inheritedJustifyItems; } } return NS_STYLE_JUSTIFY_NORMAL; } uint8_t nsStylePosition::UsedJustifySelf(nsStyleContext* aParent) const { if (mJustifySelf != NS_STYLE_JUSTIFY_AUTO) { return mJustifySelf; } if (MOZ_LIKELY(aParent)) { auto inheritedJustifyItems = aParent->StylePosition()-> ComputedJustifyItems(aParent->GetParent()); return inheritedJustifyItems & ~NS_STYLE_JUSTIFY_LEGACY; } return NS_STYLE_JUSTIFY_NORMAL; } // -------------------- // nsStyleTable // nsStyleTable::nsStyleTable(StyleStructContext aContext) : mLayoutStrategy(NS_STYLE_TABLE_LAYOUT_AUTO) , mSpan(1) { MOZ_COUNT_CTOR(nsStyleTable); } nsStyleTable::~nsStyleTable() { MOZ_COUNT_DTOR(nsStyleTable); } nsStyleTable::nsStyleTable(const nsStyleTable& aSource) : mLayoutStrategy(aSource.mLayoutStrategy) , mSpan(aSource.mSpan) { MOZ_COUNT_CTOR(nsStyleTable); } nsChangeHint nsStyleTable::CalcDifference(const nsStyleTable& aNewData) const { if (mSpan != aNewData.mSpan || mLayoutStrategy != aNewData.mLayoutStrategy) { return nsChangeHint_ReconstructFrame; } return nsChangeHint(0); } // ----------------------- // nsStyleTableBorder nsStyleTableBorder::nsStyleTableBorder(StyleStructContext aContext) : mBorderSpacingCol(0) , mBorderSpacingRow(0) , mBorderCollapse(NS_STYLE_BORDER_SEPARATE) , mCaptionSide(NS_STYLE_CAPTION_SIDE_TOP) , mEmptyCells(NS_STYLE_TABLE_EMPTY_CELLS_SHOW) { MOZ_COUNT_CTOR(nsStyleTableBorder); } nsStyleTableBorder::~nsStyleTableBorder() { MOZ_COUNT_DTOR(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; } else { return NS_STYLE_HINT_REFLOW; } } // -------------------- // nsStyleColor // nsStyleColor::nsStyleColor(StyleStructContext aContext) : mColor(aContext.DefaultColor()) { MOZ_COUNT_CTOR(nsStyleColor); } nsStyleColor::nsStyleColor(const nsStyleColor& aSource) : mColor(aSource.mColor) { MOZ_COUNT_CTOR(nsStyleColor); } nsChangeHint nsStyleColor::CalcDifference(const nsStyleColor& aNewData) const { if (mColor == aNewData.mColor) { return nsChangeHint(0); } return nsChangeHint_RepaintFrame; } // -------------------- // nsStyleGradient // bool nsStyleGradient::operator==(const nsStyleGradient& aOther) const { MOZ_ASSERT(mSize == NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER || mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR, "incorrect combination of shape and size"); MOZ_ASSERT(aOther.mSize == NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER || aOther.mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR, "incorrect combination of shape and size"); if (mShape != aOther.mShape || mSize != aOther.mSize || mRepeating != aOther.mRepeating || mLegacySyntax != aOther.mLegacySyntax || mBgPosX != aOther.mBgPosX || mBgPosY != aOther.mBgPosY || mAngle != aOther.mAngle || mRadiusX != aOther.mRadiusX || mRadiusY != aOther.mRadiusY) { return false; } if (mStops.Length() != aOther.mStops.Length()) { return false; } for (uint32_t i = 0; i < mStops.Length(); i++) { const auto& stop1 = mStops[i]; const auto& stop2 = aOther.mStops[i]; if (stop1.mLocation != stop2.mLocation || stop1.mIsInterpolationHint != stop2.mIsInterpolationHint || (!stop1.mIsInterpolationHint && stop1.mColor != stop2.mColor)) { return false; } } return true; } nsStyleGradient::nsStyleGradient() : mShape(NS_STYLE_GRADIENT_SHAPE_LINEAR) , mSize(NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER) , mRepeating(false) , mLegacySyntax(false) { } bool nsStyleGradient::IsOpaque() { for (uint32_t i = 0; i < mStops.Length(); i++) { if (NS_GET_A(mStops[i].mColor) < 255) { return false; } } return true; } bool nsStyleGradient::HasCalc() { for (uint32_t i = 0; i < mStops.Length(); i++) { if (mStops[i].mLocation.IsCalcUnit()) { return true; } } return mBgPosX.IsCalcUnit() || mBgPosY.IsCalcUnit() || mAngle.IsCalcUnit() || mRadiusX.IsCalcUnit() || mRadiusY.IsCalcUnit(); } // -------------------- // nsStyleImageRequest /** * Runnable to release the nsStyleImageRequest's mRequestProxy, * mImageValue and mImageValue on the main thread, and to perform * any necessary unlocking and untracking of the image. */ class StyleImageRequestCleanupTask : public mozilla::Runnable { public: typedef nsStyleImageRequest::Mode Mode; StyleImageRequestCleanupTask(Mode aModeFlags, already_AddRefed aRequestProxy, already_AddRefed aImageValue, already_AddRefed aImageTracker) : mModeFlags(aModeFlags) , mRequestProxy(aRequestProxy) , mImageValue(aImageValue) , mImageTracker(aImageTracker) { } NS_IMETHOD Run() final { MOZ_ASSERT(NS_IsMainThread()); if (!mRequestProxy) { return NS_OK; } if (mModeFlags & Mode::Track) { MOZ_ASSERT(mImageTracker); mImageTracker->Remove(mRequestProxy); } else { mRequestProxy->UnlockImage(); } if (mModeFlags & Mode::Discard) { mRequestProxy->RequestDiscard(); } return NS_OK; } protected: virtual ~StyleImageRequestCleanupTask() { MOZ_ASSERT(NS_IsMainThread()); } private: Mode mModeFlags; // 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 mRequestProxy; RefPtr mImageValue; RefPtr mImageTracker; }; nsStyleImageRequest::nsStyleImageRequest(Mode aModeFlags, imgRequestProxy* aRequestProxy, css::ImageValue* aImageValue, ImageTracker* aImageTracker) : mRequestProxy(aRequestProxy) , mImageValue(aImageValue) , mImageTracker(aImageTracker) , mModeFlags(aModeFlags) , mResolved(true) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(aRequestProxy); MOZ_ASSERT(aImageValue); MOZ_ASSERT(!!(aModeFlags & Mode::Track) == !!aImageTracker); MaybeTrackAndLock(); } nsStyleImageRequest::nsStyleImageRequest( Mode aModeFlags, nsStringBuffer* aURLBuffer, already_AddRefed> aBaseURI, already_AddRefed> aReferrer, already_AddRefed> aPrincipal) : mModeFlags(aModeFlags) , mResolved(false) { mImageValue = new css::ImageValue(aURLBuffer, Move(aBaseURI), Move(aReferrer), Move(aPrincipal)); } nsStyleImageRequest::~nsStyleImageRequest() { // We may or may not be being destroyed on the main thread. To clean // up, we must untrack and unlock the image (depending on mModeFlags), // and release mRequestProxy and mImageValue, all on the main thread. { RefPtr task = new StyleImageRequestCleanupTask(mModeFlags, mRequestProxy.forget(), mImageValue.forget(), mImageTracker.forget()); if (NS_IsMainThread()) { task->Run(); } else { NS_DispatchToMainThread(task.forget()); } } MOZ_ASSERT(!mRequestProxy); MOZ_ASSERT(!mImageValue); MOZ_ASSERT(!mImageTracker); } bool nsStyleImageRequest::Resolve(nsPresContext* aPresContext) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(!IsResolved(), "already resolved"); mResolved = true; // For now, just have unique nsCSSValue/ImageValue objects. We should // really store the ImageValue on the Servo specified value, so that we can // share imgRequestProxys that come from the same rule in the same // document. mImageValue->Initialize(aPresContext->Document()); nsCSSValue value; value.SetImageValue(mImageValue); mRequestProxy = value.GetPossiblyStaticImageValue(aPresContext->Document(), aPresContext); if (!mRequestProxy) { // The URL resolution or image load failed. return false; } if (mModeFlags & Mode::Track) { mImageTracker = aPresContext->Document()->ImageTracker(); } MaybeTrackAndLock(); return true; } void nsStyleImageRequest::MaybeTrackAndLock() { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(IsResolved()); MOZ_ASSERT(mRequestProxy); if (mModeFlags & Mode::Track) { MOZ_ASSERT(mImageTracker); mImageTracker->Add(mRequestProxy); } else { MOZ_ASSERT(!mImageTracker); mRequestProxy->LockImage(); } } bool nsStyleImageRequest::DefinitelyEquals(const nsStyleImageRequest& aOther) const { return DefinitelyEqualURIs(mImageValue, aOther.mImageValue); } // -------------------- // CachedBorderImageData // void CachedBorderImageData::SetCachedSVGViewportSize( const mozilla::Maybe& aSVGViewportSize) { mCachedSVGViewportSize = aSVGViewportSize; } const mozilla::Maybe& CachedBorderImageData::GetCachedSVGViewportSize() { return mCachedSVGViewportSize; } void CachedBorderImageData::PurgeCachedImages() { mSubImages.Clear(); } void CachedBorderImageData::SetSubImage(uint8_t aIndex, imgIContainer* aSubImage) { mSubImages.ReplaceObjectAt(aSubImage, aIndex); } imgIContainer* CachedBorderImageData::GetSubImage(uint8_t aIndex) { imgIContainer* subImage = nullptr; if (aIndex < mSubImages.Count()) subImage = mSubImages[aIndex]; return subImage; } // -------------------- // nsStyleImage // nsStyleImage::nsStyleImage() : mType(eStyleImageType_Null) , mCropRect(nullptr) { MOZ_COUNT_CTOR(nsStyleImage); } nsStyleImage::~nsStyleImage() { MOZ_COUNT_DTOR(nsStyleImage); if (mType != eStyleImageType_Null) { SetNull(); } } nsStyleImage::nsStyleImage(const nsStyleImage& aOther) : mType(eStyleImageType_Null) , mCropRect(nullptr) { // We need our own copy constructor because we don't want // to copy the reference count MOZ_COUNT_CTOR(nsStyleImage); DoCopy(aOther); } nsStyleImage& nsStyleImage::operator=(const nsStyleImage& aOther) { if (this != &aOther) { DoCopy(aOther); } return *this; } void nsStyleImage::DoCopy(const nsStyleImage& aOther) { SetNull(); if (aOther.mType == eStyleImageType_Image) { SetImageRequest(do_AddRef(aOther.mImage)); } else if (aOther.mType == eStyleImageType_Gradient) { SetGradientData(aOther.mGradient); } else if (aOther.mType == eStyleImageType_Element) { SetElementId(aOther.mElementId); } UniquePtr cropRectCopy; if (aOther.mCropRect) { cropRectCopy = MakeUnique(*aOther.mCropRect.get()); } SetCropRect(Move(cropRectCopy)); } void nsStyleImage::SetNull() { if (mType == eStyleImageType_Gradient) { mGradient->Release(); } else if (mType == eStyleImageType_Image) { NS_RELEASE(mImage); } else if (mType == eStyleImageType_Element) { free(mElementId); } mType = eStyleImageType_Null; mCropRect = nullptr; } void nsStyleImage::SetImageRequest(already_AddRefed aImage) { RefPtr image = aImage; if (mType != eStyleImageType_Null) { SetNull(); } if (image) { mImage = image.forget().take(); mType = eStyleImageType_Image; } if (mCachedBIData) { mCachedBIData->PurgeCachedImages(); } } void nsStyleImage::SetGradientData(nsStyleGradient* aGradient) { if (aGradient) { aGradient->AddRef(); } if (mType != eStyleImageType_Null) { SetNull(); } if (aGradient) { mGradient = aGradient; mType = eStyleImageType_Gradient; } } void nsStyleImage::SetElementId(const char16_t* aElementId) { if (mType != eStyleImageType_Null) { SetNull(); } if (aElementId) { mElementId = NS_strdup(aElementId); mType = eStyleImageType_Element; } } void nsStyleImage::SetCropRect(UniquePtr aCropRect) { mCropRect = Move(aCropRect); } static int32_t ConvertToPixelCoord(const nsStyleCoord& aCoord, int32_t aPercentScale) { double pixelValue; switch (aCoord.GetUnit()) { case eStyleUnit_Percent: pixelValue = aCoord.GetPercentValue() * aPercentScale; break; case eStyleUnit_Factor: pixelValue = aCoord.GetFactorValue(); break; default: NS_NOTREACHED("unexpected unit for image crop rect"); return 0; } MOZ_ASSERT(pixelValue >= 0, "we ensured non-negative while parsing"); pixelValue = std::min(pixelValue, double(INT32_MAX)); // avoid overflow return NS_lround(pixelValue); } bool nsStyleImage::ComputeActualCropRect(nsIntRect& aActualCropRect, bool* aIsEntireImage) const { if (mType != eStyleImageType_Image) { return false; } imgRequestProxy* req = GetImageData(); if (!req) { return false; } nsCOMPtr imageContainer; req->GetImage(getter_AddRefs(imageContainer)); if (!imageContainer) { return false; } nsIntSize imageSize; imageContainer->GetWidth(&imageSize.width); imageContainer->GetHeight(&imageSize.height); if (imageSize.width <= 0 || imageSize.height <= 0) { return false; } int32_t left = ConvertToPixelCoord(mCropRect->GetLeft(), imageSize.width); int32_t top = ConvertToPixelCoord(mCropRect->GetTop(), imageSize.height); int32_t right = ConvertToPixelCoord(mCropRect->GetRight(), imageSize.width); int32_t bottom = ConvertToPixelCoord(mCropRect->GetBottom(), imageSize.height); // IntersectRect() returns an empty rect if we get negative width or height nsIntRect cropRect(left, top, right - left, bottom - top); nsIntRect imageRect(nsIntPoint(0, 0), imageSize); aActualCropRect.IntersectRect(imageRect, cropRect); if (aIsEntireImage) { *aIsEntireImage = aActualCropRect.IsEqualInterior(imageRect); } return true; } nsresult nsStyleImage::StartDecoding() const { if (mType == eStyleImageType_Image) { imgRequestProxy* req = GetImageData(); if (!req) { return NS_ERROR_FAILURE; } return req->StartDecoding(); } return NS_OK; } bool nsStyleImage::IsOpaque() const { if (!IsComplete()) { return false; } if (mType == eStyleImageType_Gradient) { return mGradient->IsOpaque(); } if (mType == eStyleImageType_Element) { return false; } MOZ_ASSERT(mType == eStyleImageType_Image, "unexpected image type"); MOZ_ASSERT(GetImageData(), "should've returned earlier above"); nsCOMPtr imageContainer; GetImageData()->GetImage(getter_AddRefs(imageContainer)); MOZ_ASSERT(imageContainer, "IsComplete() said image container is ready"); // Check if the crop region of the image is opaque. if (imageContainer->WillDrawOpaqueNow()) { if (!mCropRect) { return true; } // Must make sure if mCropRect contains at least a pixel. // XXX Is this optimization worth it? Maybe I should just return false. nsIntRect actualCropRect; bool rv = ComputeActualCropRect(actualCropRect); NS_ASSERTION(rv, "ComputeActualCropRect() can not fail here"); return rv && !actualCropRect.IsEmpty(); } return false; } bool nsStyleImage::IsComplete() const { switch (mType) { case eStyleImageType_Null: return false; case eStyleImageType_Gradient: case eStyleImageType_Element: return true; case eStyleImageType_Image: { imgRequestProxy* req = GetImageData(); 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); } default: NS_NOTREACHED("unexpected image type"); return false; } } bool nsStyleImage::IsLoaded() const { switch (mType) { case eStyleImageType_Null: return false; case eStyleImageType_Gradient: case eStyleImageType_Element: return true; case eStyleImageType_Image: { imgRequestProxy* req = GetImageData(); if (!req) { return false; } uint32_t status = imgIRequest::STATUS_ERROR; return NS_SUCCEEDED(req->GetImageStatus(&status)) && !(status & imgIRequest::STATUS_ERROR) && (status & imgIRequest::STATUS_LOAD_COMPLETE); } default: NS_NOTREACHED("unexpected image type"); return false; } } static inline bool EqualRects(const UniquePtr& aRect1, const UniquePtr& aRect2) { return aRect1 == aRect2 || /* handles null== null, and optimize */ (aRect1 && aRect2 && *aRect1 == *aRect2); } bool nsStyleImage::operator==(const nsStyleImage& aOther) const { if (mType != aOther.mType) { return false; } if (!EqualRects(mCropRect, aOther.mCropRect)) { return false; } if (mType == eStyleImageType_Image) { return DefinitelyEqualImages(mImage, aOther.mImage); } if (mType == eStyleImageType_Gradient) { return *mGradient == *aOther.mGradient; } if (mType == eStyleImageType_Element) { return NS_strcmp(mElementId, aOther.mElementId) == 0; } return true; } void nsStyleImage::PurgeCacheForViewportChange( const mozilla::Maybe& aSVGViewportSize, const bool aHasIntrinsicRatio) const { EnsureCachedBIData(); // If we're redrawing with a different viewport-size than we used for our // cached subimages, then we can't trust that our subimages are valid; // any percent sizes/positions in our SVG doc may be different now. Purge! // (We don't have to purge if the SVG document has an intrinsic ratio, // though, because the actual size of elements in SVG documant's coordinate // axis are fixed in this case.) if (aSVGViewportSize != mCachedBIData->GetCachedSVGViewportSize() && !aHasIntrinsicRatio) { mCachedBIData->PurgeCachedImages(); mCachedBIData->SetCachedSVGViewportSize(aSVGViewportSize); } } // -------------------- // 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::WITH_SINGLE_INITIAL_ELEMENT) { MOZ_COUNT_CTOR(nsStyleImageLayers); // 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) // deep copy { MOZ_COUNT_CTOR(nsStyleImageLayers); // If the deep copy of mLayers failed, truncate the counts. uint32_t count = mLayers.Length(); if (count != aSource.mLayers.Length()) { NS_WARNING("truncating counts due to out-of-memory"); mAttachmentCount = std::max(mAttachmentCount, count); mClipCount = std::max(mClipCount, count); mOriginCount = std::max(mOriginCount, count); mRepeatCount = std::max(mRepeatCount, count); mPositionXCount = std::max(mPositionXCount, count); mPositionYCount = std::max(mPositionYCount, count); mImageCount = std::max(mImageCount, count); mSizeCount = std::max(mSizeCount, count); mMaskModeCount = std::max(mMaskModeCount, count); mBlendModeCount = std::max(mBlendModeCount, count); mCompositeCount = std::max(mCompositeCount, count); } } nsChangeHint nsStyleImageLayers::CalcDifference(const nsStyleImageLayers& aNewLayers, nsStyleImageLayers::LayerType aType) const { nsChangeHint hint = nsChangeHint(0); const nsStyleImageLayers& moreLayers = mImageCount > aNewLayers.mImageCount ? *this : aNewLayers; const nsStyleImageLayers& lessLayers = mImageCount > aNewLayers.mImageCount ? aNewLayers : *this; NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, moreLayers) { if (i < lessLayers.mImageCount) { nsChangeHint layerDifference = moreLayers.mLayers[i].CalcDifference(lessLayers.mLayers[i]); hint |= layerDifference; if (layerDifference && ((moreLayers.mLayers[i].mImage.GetType() == eStyleImageType_Element) || (lessLayers.mLayers[i].mImage.GetType() == eStyleImageType_Element))) { hint |= nsChangeHint_UpdateEffects | nsChangeHint_RepaintFrame; } } else { hint |= nsChangeHint_RepaintFrame; if (moreLayers.mLayers[i].mImage.GetType() == eStyleImageType_Element) { hint |= nsChangeHint_UpdateEffects | nsChangeHint_RepaintFrame; } } } if (aType == nsStyleImageLayers::LayerType::Mask && mImageCount != aNewLayers.mImageCount) { hint |= nsChangeHint_UpdateEffects; } if (hint) { return hint; } 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; } bool nsStyleImageLayers::HasLayerWithImage() const { for (uint32_t i = 0; i < mImageCount; i++) { // mLayers[i].mSourceURI can be nullptr if mask-image prop value is // or // mLayers[i].mImage can be empty if mask-image prop value is a reference // to SVG mask element. // So we need to test both mSourceURI and mImage. if ((mLayers[i].mSourceURI && mLayers[i].mSourceURI->GetURI()) || !mLayers[i].mImage.IsEmpty()) { return true; } } return false; } 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; uint32_t count = mLayers.Length(); if (count != aOther.mLayers.Length()) { NS_WARNING("truncating counts due to out-of-memory"); mAttachmentCount = std::max(mAttachmentCount, count); mClipCount = std::max(mClipCount, count); mOriginCount = std::max(mOriginCount, count); mRepeatCount = std::max(mRepeatCount, count); mPositionXCount = std::max(mPositionXCount, count); mPositionYCount = std::max(mPositionYCount, count); mImageCount = std::max(mImageCount, count); mSizeCount = std::max(mSizeCount, count); mMaskModeCount = std::max(mMaskModeCount, count); mBlendModeCount = std::max(mBlendModeCount, count); mCompositeCount = std::max(mCompositeCount, count); } return *this; } bool nsStyleImageLayers::IsInitialPositionForLayerType(Position aPosition, LayerType aType) { if (aPosition.mXPosition.mPercent == 0.0f && aPosition.mXPosition.mLength == 0 && aPosition.mXPosition.mHasPercent && aPosition.mYPosition.mPercent == 0.0f && aPosition.mYPosition.mLength == 0 && aPosition.mYPosition.mHasPercent) { return true; } return false; } void Position::SetInitialPercentValues(float aPercentVal) { mXPosition.mPercent = aPercentVal; mXPosition.mLength = 0; mXPosition.mHasPercent = true; mYPosition.mPercent = aPercentVal; mYPosition.mLength = 0; mYPosition.mHasPercent = true; } void Position::SetInitialZeroValues() { mXPosition.mPercent = 0; mXPosition.mLength = 0; mXPosition.mHasPercent = false; mYPosition.mPercent = 0; mYPosition.mLength = 0; mYPosition.mHasPercent = false; } bool nsStyleImageLayers::Size::DependsOnPositioningAreaSize(const nsStyleImage& aImage) const { MOZ_ASSERT(aImage.GetType() != eStyleImageType_Null, "caller should have handled this"); // If either dimension contains a non-zero percentage, rendering for that // dimension straightforwardly depends on frame size. if ((mWidthType == eLengthPercentage && mWidth.mPercent != 0.0f) || (mHeightType == eLengthPercentage && mHeight.mPercent != 0.0f)) { return true; } // So too for contain and cover. if (mWidthType == eContain || mWidthType == eCover) { return true; } // If both dimensions are fixed lengths, there's no dependency. if (mWidthType == eLengthPercentage && mHeightType == eLengthPercentage) { return false; } MOZ_ASSERT((mWidthType == eLengthPercentage && mHeightType == eAuto) || (mWidthType == eAuto && mHeightType == eLengthPercentage) || (mWidthType == eAuto && mHeightType == eAuto), "logic error"); nsStyleImageType type = aImage.GetType(); // 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 (type == eStyleImageType_Gradient) { 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 (type == eStyleImageType_Element) { return true; } if (type == eStyleImageType_Image) { nsCOMPtr imgContainer; if (imgRequestProxy* req = aImage.GetImageData()) { req->GetImage(getter_AddRefs(imgContainer)); } if (imgContainer) { CSSIntSize imageSize; AspectRatio imageRatio; bool hasWidth, hasHeight; nsLayoutUtils::ComputeSizeForDrawing(imgContainer, 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 mWidthType == mHeightType; } // Otherwise, rendering depends on frame size when the image dimensions // and background-size don't complement each other. return !(hasWidth && mHeightType == eLengthPercentage) && !(hasHeight && mWidthType == eLengthPercentage); } } else { NS_NOTREACHED("missed an enum value"); } // Passed the gauntlet: no dependency. return false; } void nsStyleImageLayers::Size::SetInitialValues() { mWidthType = mHeightType = eAuto; } bool nsStyleImageLayers::Size::operator==(const Size& aOther) const { MOZ_ASSERT(mWidthType < eDimensionType_COUNT, "bad mWidthType for this"); MOZ_ASSERT(mHeightType < eDimensionType_COUNT, "bad mHeightType for this"); MOZ_ASSERT(aOther.mWidthType < eDimensionType_COUNT, "bad mWidthType for aOther"); MOZ_ASSERT(aOther.mHeightType < eDimensionType_COUNT, "bad mHeightType for aOther"); return mWidthType == aOther.mWidthType && mHeightType == aOther.mHeightType && (mWidthType != eLengthPercentage || mWidth == aOther.mWidth) && (mHeightType != eLengthPercentage || mHeight == aOther.mHeight); } nsStyleImageLayers::Layer::Layer() : mClip(StyleGeometryBox::Border) , mAttachment(NS_STYLE_IMAGELAYER_ATTACHMENT_SCROLL) , mBlendMode(NS_STYLE_BLEND_NORMAL) , mComposite(NS_STYLE_MASK_COMPOSITE_ADD) , mMaskMode(NS_STYLE_MASK_MODE_MATCH_SOURCE) { mImage.SetNull(); mSize.SetInitialValues(); } nsStyleImageLayers::Layer::~Layer() { } void nsStyleImageLayers::Layer::Initialize(nsStyleImageLayers::LayerType aType) { mRepeat.SetInitialValues(); mPosition.SetInitialPercentValues(0.0f); if (aType == LayerType::Background) { mOrigin = StyleGeometryBox::Padding; } else { MOZ_ASSERT(aType == LayerType::Mask, "unsupported layer type."); mOrigin = StyleGeometryBox::Border; } } bool nsStyleImageLayers::Layer::RenderingMightDependOnPositioningAreaSizeChange() const { // Do we even have an image? if (mImage.IsEmpty()) { return false; } return mPosition.DependsOnPositioningAreaSize() || mSize.DependsOnPositioningAreaSize(mImage) || 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 && DefinitelyEqualURIs(mSourceURI, aOther.mSourceURI); } nsChangeHint nsStyleImageLayers::Layer::CalcDifference(const nsStyleImageLayers::Layer& aNewLayer) const { nsChangeHint hint = nsChangeHint(0); if (!DefinitelyEqualURIs(mSourceURI, aNewLayer.mSourceURI)) { hint |= nsChangeHint_RepaintFrame | nsChangeHint_UpdateEffects; // If Layer::mSourceURI links to a SVG mask, it has a fragment. Not vice // versa. Here are examples of URI contains a fragment, two of them link // to a SVG mask: // mask:url(a.svg#maskID); // The fragment of this URI is an ID of a mask // // element in a.svg. // mask:url(#localMaskID); // The fragment of this URI is an ID of a mask // // element in local document. // mask:url(b.svg#viewBoxID); // The fragment of this URI is an ID of a // // viewbox defined in b.svg. // That is, if mSourceURI has a fragment, it may link to a SVG mask; If // not, it "must" not link to a SVG mask. bool maybeSVGMask = false; if (mSourceURI) { if (mSourceURI->IsLocalRef()) { maybeSVGMask = true; } else if (mSourceURI->GetURI()) { mSourceURI->GetURI()->GetHasRef(&maybeSVGMask); } } if (!maybeSVGMask) { if (aNewLayer.mSourceURI) { if (aNewLayer.mSourceURI->IsLocalRef()) { maybeSVGMask = true; } else if (aNewLayer.mSourceURI->GetURI()) { aNewLayer.mSourceURI->GetURI()->GetHasRef(&maybeSVGMask); } } } // Return nsChangeHint_UpdateOverflow if either URI might link to an SVG // mask. if (maybeSVGMask) { // Mask changes require that we update the PreEffectsBBoxProperty, // which is done during overflow computation. hint |= nsChangeHint_UpdateOverflow; } } 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(StyleStructContext aContext) : mImage(nsStyleImageLayers::LayerType::Background) , mBackgroundColor(NS_RGBA(0, 0, 0, 0)) { MOZ_COUNT_CTOR(nsStyleBackground); } nsStyleBackground::nsStyleBackground(const nsStyleBackground& aSource) : mImage(aSource.mImage) , mBackgroundColor(aSource.mBackgroundColor) { MOZ_COUNT_CTOR(nsStyleBackground); } nsStyleBackground::~nsStyleBackground() { MOZ_COUNT_DTOR(nsStyleBackground); } void nsStyleBackground::Destroy(nsPresContext* aContext) { this->~nsStyleBackground(); aContext->PresShell()-> FreeByObjectID(eArenaObjectID_nsStyleBackground, this); } void nsStyleBackground::FinishStyle(nsPresContext* aPresContext) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(aPresContext->StyleSet()->IsServo()); mImage.ResolveImages(aPresContext); } 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 == NS_STYLE_IMAGELAYER_ATTACHMENT_FIXED && !layer.mImage.IsEmpty() && !nsLayoutUtils::IsTransformed(aFrame)) { return true; } } return false; } bool nsStyleBackground::IsTransparent() const { return BottomLayer().mImage.IsEmpty() && mImage.mImageCount == 1 && NS_GET_A(mBackgroundColor) == 0; } void nsTimingFunction::AssignFromKeyword(int32_t aTimingFunctionType) { switch (aTimingFunctionType) { case NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START: mType = Type::StepStart; mSteps = 1; return; default: MOZ_FALLTHROUGH_ASSERT("aTimingFunctionType must be a keyword value"); case NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END: mType = Type::StepEnd; mSteps = 1; return; case NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE: case NS_STYLE_TRANSITION_TIMING_FUNCTION_LINEAR: case NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_IN: case NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_OUT: case NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_IN_OUT: mType = static_cast(aTimingFunctionType); break; } static_assert(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE == 0 && NS_STYLE_TRANSITION_TIMING_FUNCTION_LINEAR == 1 && NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_IN == 2 && NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_OUT == 3 && NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_IN_OUT == 4, "transition timing function constants not as expected"); static const float timingFunctionValues[5][4] = { { 0.25f, 0.10f, 0.25f, 1.00f }, // ease { 0.00f, 0.00f, 1.00f, 1.00f }, // linear { 0.42f, 0.00f, 1.00f, 1.00f }, // ease-in { 0.00f, 0.00f, 0.58f, 1.00f }, // ease-out { 0.42f, 0.00f, 0.58f, 1.00f } // ease-in-out }; MOZ_ASSERT(0 <= aTimingFunctionType && aTimingFunctionType < 5, "keyword out of range"); mFunc.mX1 = timingFunctionValues[aTimingFunctionType][0]; mFunc.mY1 = timingFunctionValues[aTimingFunctionType][1]; mFunc.mX2 = timingFunctionValues[aTimingFunctionType][2]; mFunc.mY2 = timingFunctionValues[aTimingFunctionType][3]; } StyleTransition::StyleTransition(const StyleTransition& aCopy) : mTimingFunction(aCopy.mTimingFunction) , mDuration(aCopy.mDuration) , mDelay(aCopy.mDelay) , mProperty(aCopy.mProperty) , mUnknownProperty(aCopy.mUnknownProperty) { } void StyleTransition::SetInitialValues() { mTimingFunction = nsTimingFunction(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE); mDuration = 0.0; mDelay = 0.0; mProperty = eCSSPropertyExtra_all_properties; } void StyleTransition::SetUnknownProperty(nsCSSPropertyID aProperty, const nsAString& aPropertyString) { MOZ_ASSERT(nsCSSProps::LookupProperty(aPropertyString, CSSEnabledState::eForAllContent) == aProperty, "property and property string should match"); MOZ_ASSERT(aProperty == eCSSProperty_UNKNOWN || aProperty == eCSSPropertyExtra_variable, "should be either unknown or custom property"); mProperty = aProperty; mUnknownProperty = NS_Atomize(aPropertyString); } bool StyleTransition::operator==(const StyleTransition& aOther) const { return mTimingFunction == aOther.mTimingFunction && mDuration == aOther.mDuration && mDelay == aOther.mDelay && mProperty == aOther.mProperty && (mProperty != eCSSProperty_UNKNOWN || mUnknownProperty == aOther.mUnknownProperty); } StyleAnimation::StyleAnimation(const StyleAnimation& aCopy) : mTimingFunction(aCopy.mTimingFunction) , mDuration(aCopy.mDuration) , mDelay(aCopy.mDelay) , mName(aCopy.mName) , mDirection(aCopy.mDirection) , mFillMode(aCopy.mFillMode) , mPlayState(aCopy.mPlayState) , mIterationCount(aCopy.mIterationCount) { } void StyleAnimation::SetInitialValues() { mTimingFunction = nsTimingFunction(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE); mDuration = 0.0; mDelay = 0.0; mName = EmptyString(); mDirection = dom::PlaybackDirection::Normal; mFillMode = dom::FillMode::None; mPlayState = NS_STYLE_ANIMATION_PLAY_STATE_RUNNING; mIterationCount = 1.0f; } 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; } // -------------------- // nsStyleDisplay // nsStyleDisplay::nsStyleDisplay(StyleStructContext aContext) : mDisplay(StyleDisplay::Inline) , mOriginalDisplay(StyleDisplay::Inline) , mContain(NS_STYLE_CONTAIN_NONE) , mAppearance(NS_THEME_NONE) , mPosition(NS_STYLE_POSITION_STATIC) , mFloat(StyleFloat::None) , mOriginalFloat(StyleFloat::None) , mBreakType(StyleClear::None) , mBreakInside(NS_STYLE_PAGE_BREAK_AUTO) , mBreakBefore(false) , mBreakAfter(false) , mOverflowX(NS_STYLE_OVERFLOW_VISIBLE) , mOverflowY(NS_STYLE_OVERFLOW_VISIBLE) , mOverflowClipBox(NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX) , mResize(NS_STYLE_RESIZE_NONE) , mOrient(StyleOrient::Inline) , mIsolation(NS_STYLE_ISOLATION_AUTO) , mTopLayer(NS_STYLE_TOP_LAYER_NONE) , mWillChangeBitField(0) , mTouchAction(NS_STYLE_TOUCH_ACTION_AUTO) , mScrollBehavior(NS_STYLE_SCROLL_BEHAVIOR_AUTO) , mScrollSnapTypeX(NS_STYLE_SCROLL_SNAP_TYPE_NONE) , mScrollSnapTypeY(NS_STYLE_SCROLL_SNAP_TYPE_NONE) , mScrollSnapPointsX(eStyleUnit_None) , mScrollSnapPointsY(eStyleUnit_None) , mBackfaceVisibility(NS_STYLE_BACKFACE_VISIBILITY_VISIBLE) , mTransformStyle(NS_STYLE_TRANSFORM_STYLE_FLAT) , mTransformBox(NS_STYLE_TRANSFORM_BOX_BORDER_BOX) , mSpecifiedTransform(nullptr) , mTransformOrigin{ {0.5f, eStyleUnit_Percent}, // Transform is centered on origin {0.5f, eStyleUnit_Percent}, {0, nsStyleCoord::CoordConstructor} } , mChildPerspective(eStyleUnit_None) , mPerspectiveOrigin{ {0.5f, eStyleUnit_Percent}, {0.5f, eStyleUnit_Percent} } , mVerticalAlign(NS_STYLE_VERTICAL_ALIGN_BASELINE, eStyleUnit_Enumerated) , mTransitions(nsStyleAutoArray::WITH_SINGLE_INITIAL_ELEMENT) , mTransitionTimingFunctionCount(1) , mTransitionDurationCount(1) , mTransitionDelayCount(1) , mTransitionPropertyCount(1) , mAnimations(nsStyleAutoArray::WITH_SINGLE_INITIAL_ELEMENT) , mAnimationTimingFunctionCount(1) , mAnimationDurationCount(1) , mAnimationDelayCount(1) , mAnimationNameCount(1) , mAnimationDirectionCount(1) , mAnimationFillModeCount(1) , mAnimationPlayStateCount(1) , mAnimationIterationCountCount(1) { MOZ_COUNT_CTOR(nsStyleDisplay); // Initial value for mScrollSnapDestination is "0px 0px" mScrollSnapDestination.SetInitialZeroValues(); mTransitions[0].SetInitialValues(); mAnimations[0].SetInitialValues(); } nsStyleDisplay::nsStyleDisplay(const nsStyleDisplay& aSource) : mBinding(aSource.mBinding) , mDisplay(aSource.mDisplay) , mOriginalDisplay(aSource.mOriginalDisplay) , mContain(aSource.mContain) , mAppearance(aSource.mAppearance) , mPosition(aSource.mPosition) , mFloat(aSource.mFloat) , mOriginalFloat(aSource.mOriginalFloat) , mBreakType(aSource.mBreakType) , mBreakInside(aSource.mBreakInside) , mBreakBefore(aSource.mBreakBefore) , mBreakAfter(aSource.mBreakAfter) , mOverflowX(aSource.mOverflowX) , mOverflowY(aSource.mOverflowY) , mOverflowClipBox(aSource.mOverflowClipBox) , mResize(aSource.mResize) , mOrient(aSource.mOrient) , mIsolation(aSource.mIsolation) , mTopLayer(aSource.mTopLayer) , mWillChangeBitField(aSource.mWillChangeBitField) , mWillChange(aSource.mWillChange) , mTouchAction(aSource.mTouchAction) , mScrollBehavior(aSource.mScrollBehavior) , mScrollSnapTypeX(aSource.mScrollSnapTypeX) , mScrollSnapTypeY(aSource.mScrollSnapTypeY) , mScrollSnapPointsX(aSource.mScrollSnapPointsX) , mScrollSnapPointsY(aSource.mScrollSnapPointsY) , mScrollSnapDestination(aSource.mScrollSnapDestination) , mScrollSnapCoordinate(aSource.mScrollSnapCoordinate) , mBackfaceVisibility(aSource.mBackfaceVisibility) , mTransformStyle(aSource.mTransformStyle) , mTransformBox(aSource.mTransformBox) , mSpecifiedTransform(aSource.mSpecifiedTransform) , mTransformOrigin{ aSource.mTransformOrigin[0], aSource.mTransformOrigin[1], aSource.mTransformOrigin[2] } , mChildPerspective(aSource.mChildPerspective) , mPerspectiveOrigin{ aSource.mPerspectiveOrigin[0], aSource.mPerspectiveOrigin[1] } , mVerticalAlign(aSource.mVerticalAlign) , mTransitions(aSource.mTransitions) , mTransitionTimingFunctionCount(aSource.mTransitionTimingFunctionCount) , mTransitionDurationCount(aSource.mTransitionDurationCount) , mTransitionDelayCount(aSource.mTransitionDelayCount) , mTransitionPropertyCount(aSource.mTransitionPropertyCount) , mAnimations(aSource.mAnimations) , mAnimationTimingFunctionCount(aSource.mAnimationTimingFunctionCount) , mAnimationDurationCount(aSource.mAnimationDurationCount) , mAnimationDelayCount(aSource.mAnimationDelayCount) , mAnimationNameCount(aSource.mAnimationNameCount) , mAnimationDirectionCount(aSource.mAnimationDirectionCount) , mAnimationFillModeCount(aSource.mAnimationFillModeCount) , mAnimationPlayStateCount(aSource.mAnimationPlayStateCount) , mAnimationIterationCountCount(aSource.mAnimationIterationCountCount) , mShapeOutside(aSource.mShapeOutside) { MOZ_COUNT_CTOR(nsStyleDisplay); } nsChangeHint nsStyleDisplay::CalcDifference(const nsStyleDisplay& aNewData) const { nsChangeHint hint = nsChangeHint(0); if (!DefinitelyEqualURIsAndPrincipal(mBinding, aNewData.mBinding) || mPosition != aNewData.mPosition || mDisplay != aNewData.mDisplay || mContain != aNewData.mContain || (mFloat == StyleFloat::None) != (aNewData.mFloat == StyleFloat::None) || mScrollBehavior != aNewData.mScrollBehavior || mScrollSnapTypeX != aNewData.mScrollSnapTypeX || mScrollSnapTypeY != aNewData.mScrollSnapTypeY || mScrollSnapPointsX != aNewData.mScrollSnapPointsX || mScrollSnapPointsY != aNewData.mScrollSnapPointsY || mScrollSnapDestination != aNewData.mScrollSnapDestination || mTopLayer != aNewData.mTopLayer || mResize != aNewData.mResize) { hint |= nsChangeHint_ReconstructFrame; } if (mOverflowX != aNewData.mOverflowX || mOverflowY != aNewData.mOverflowY) { hint |= nsChangeHint_ScrollbarChange; } /* Note: When mScrollBehavior, mScrollSnapTypeX, mScrollSnapTypeY, * mScrollSnapPointsX, mScrollSnapPointsY, or mScrollSnapDestination are * changed, nsChangeHint_NeutralChange is not sufficient to enter * nsCSSFrameConstructor::PropagateScrollToViewport. By using the same hint * as used when the overflow css property changes, * nsChangeHint_ReconstructFrame, PropagateScrollToViewport will be called. * * The scroll-behavior css property is not expected to change often (the * CSSOM-View DOM methods are likely to be used in those cases); however, * if this does become common perhaps a faster-path might be worth while. */ if ((mAppearance == NS_THEME_TEXTFIELD && aNewData.mAppearance != NS_THEME_TEXTFIELD) || (mAppearance != NS_THEME_TEXTFIELD && aNewData.mAppearance == NS_THEME_TEXTFIELD)) { // This is for where we allow authors to specify a // |-moz-appearance:textfield| to get a control without a spinner. (The // spinner is present for |-moz-appearance:number-input| but also other // values such as 'none'.) We need to reframe since we want to use // nsTextControlFrame instead of nsNumberControlFrame if the author // specifies 'textfield'. return nsChangeHint_ReconstructFrame; } if (mFloat != aNewData.mFloat) { // Changing which side we float on doesn't affect descendants directly hint |= nsChangeHint_AllReflowHints & ~(nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow); } if (mVerticalAlign != aNewData.mVerticalAlign) { // 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. if (mBreakType != aNewData.mBreakType || mBreakInside != aNewData.mBreakInside || mBreakBefore != aNewData.mBreakBefore || mBreakAfter != aNewData.mBreakAfter || mAppearance != aNewData.mAppearance || mOrient != aNewData.mOrient || mOverflowClipBox != aNewData.mOverflowClipBox) { 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()) { // We do not need to apply nsChangeHint_UpdateTransformLayer since // nsChangeHint_RepaintFrame will forcibly invalidate the frame area and // ensure layers are rebuilt (or removed). hint |= nsChangeHint_UpdateContainingBlock | nsChangeHint_AddOrRemoveTransform | nsChangeHint_UpdateOverflow | nsChangeHint_RepaintFrame; } 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 = nsChangeHint(0); if (!mSpecifiedTransform != !aNewData.mSpecifiedTransform || (mSpecifiedTransform && *mSpecifiedTransform != *aNewData.mSpecifiedTransform)) { transformHint |= nsChangeHint_UpdateTransformLayer; if (mSpecifiedTransform && aNewData.mSpecifiedTransform) { transformHint |= nsChangeHint_UpdatePostTransformOverflow; } else { transformHint |= nsChangeHint_UpdateOverflow; } } const nsChangeHint kUpdateOverflowAndRepaintHint = nsChangeHint_UpdateOverflow | nsChangeHint_RepaintFrame; for (uint8_t index = 0; index < 3; ++index) { if (mTransformOrigin[index] != aNewData.mTransformOrigin[index]) { transformHint |= nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdatePostTransformOverflow; break; } } for (uint8_t index = 0; index < 2; ++index) { if (mPerspectiveOrigin[index] != aNewData.mPerspectiveOrigin[index]) { transformHint |= kUpdateOverflowAndRepaintHint; break; } } if (HasPerspectiveStyle() != aNewData.HasPerspectiveStyle()) { // A change from/to being a containing block for position:fixed. hint |= nsChangeHint_UpdateContainingBlock; } if (mChildPerspective != aNewData.mChildPerspective || mTransformStyle != aNewData.mTransformStyle || mTransformBox != aNewData.mTransformBox) { transformHint |= kUpdateOverflowAndRepaintHint; } if (mBackfaceVisibility != aNewData.mBackfaceVisibility) { transformHint |= nsChangeHint_RepaintFrame; } if (transformHint) { if (HasTransformStyle()) { hint |= transformHint; } else { hint |= nsChangeHint_NeutralChange; } } } // Note that the HasTransformStyle() != aNewData.HasTransformStyle() // test above handles relevant changes in the // NS_STYLE_WILL_CHANGE_TRANSFORM bit, which in turn handles frame // reconstruction for changes in the containing block of // fixed-positioned elements. uint8_t willChangeBitsChanged = mWillChangeBitField ^ aNewData.mWillChangeBitField; if (willChangeBitsChanged & (NS_STYLE_WILL_CHANGE_STACKING_CONTEXT | NS_STYLE_WILL_CHANGE_SCROLL | NS_STYLE_WILL_CHANGE_OPACITY)) { hint |= nsChangeHint_RepaintFrame; } if (willChangeBitsChanged & NS_STYLE_WILL_CHANGE_FIXPOS_CB) { 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; } // 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 style context change anyway. // Note: Likewise, for animation-*, the animation manager gets // notified about every new style context 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. if (!hint && (mOriginalDisplay != aNewData.mOriginalDisplay || mOriginalFloat != aNewData.mOriginalFloat || 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 || mScrollSnapCoordinate != aNewData.mScrollSnapCoordinate || mShapeOutside != aNewData.mShapeOutside)) { hint |= nsChangeHint_NeutralChange; } return hint; } // -------------------- // nsStyleVisibility // nsStyleVisibility::nsStyleVisibility(StyleStructContext aContext) : mDirection(aContext.GetBidi() == IBMBIDI_TEXTDIRECTION_RTL ? NS_STYLE_DIRECTION_RTL : NS_STYLE_DIRECTION_LTR) , mVisible(NS_STYLE_VISIBILITY_VISIBLE) , mImageRendering(NS_STYLE_IMAGE_RENDERING_AUTO) , mWritingMode(NS_STYLE_WRITING_MODE_HORIZONTAL_TB) , mTextOrientation(NS_STYLE_TEXT_ORIENTATION_MIXED) , mColorAdjust(NS_STYLE_COLOR_ADJUST_ECONOMY) { MOZ_COUNT_CTOR(nsStyleVisibility); } nsStyleVisibility::nsStyleVisibility(const nsStyleVisibility& aSource) : mImageOrientation(aSource.mImageOrientation) , mDirection(aSource.mDirection) , mVisible(aSource.mVisible) , mImageRendering(aSource.mImageRendering) , mWritingMode(aSource.mWritingMode) , mTextOrientation(aSource.mTextOrientation) , mColorAdjust(aSource.mColorAdjust) { 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). hint |= nsChangeHint_ReconstructFrame; } else { if ((mImageOrientation != aNewData.mImageOrientation)) { hint |= nsChangeHint_AllReflowHints | nsChangeHint_RepaintFrame; } if (mVisible != aNewData.mVisible) { if ((NS_STYLE_VISIBILITY_COLLAPSE == mVisible) || (NS_STYLE_VISIBILITY_COLLAPSE == aNewData.mVisible)) { hint |= NS_STYLE_HINT_REFLOW; } else { hint |= NS_STYLE_HINT_VISUAL; } } if (mTextOrientation != aNewData.mTextOrientation) { hint |= NS_STYLE_HINT_REFLOW; } if (mImageRendering != aNewData.mImageRendering) { hint |= nsChangeHint_RepaintFrame; } if (mColorAdjust != aNewData.mColorAdjust) { // color-adjust only affects media where dynamic changes can't happen. hint |= nsChangeHint_NeutralChange; } } return hint; } nsStyleContentData::~nsStyleContentData() { MOZ_COUNT_DTOR(nsStyleContentData); MOZ_ASSERT(!mImageTracked, "nsStyleContentData being destroyed while still tracking image!"); if (mType == eStyleContentType_Image) { NS_IF_RELEASE(mContent.mImage); } else if (mType == eStyleContentType_Counter || mType == eStyleContentType_Counters) { mContent.mCounters->Release(); } else if (mContent.mString) { free(mContent.mString); } } nsStyleContentData::nsStyleContentData(const nsStyleContentData& aOther) : mType(aOther.mType) #ifdef DEBUG , mImageTracked(false) #endif { MOZ_COUNT_CTOR(nsStyleContentData); if (mType == eStyleContentType_Image) { mContent.mImage = aOther.mContent.mImage; NS_IF_ADDREF(mContent.mImage); } else if (mType == eStyleContentType_Counter || mType == eStyleContentType_Counters) { mContent.mCounters = aOther.mContent.mCounters; mContent.mCounters->AddRef(); } else if (aOther.mContent.mString) { mContent.mString = NS_strdup(aOther.mContent.mString); } else { mContent.mString = nullptr; } } nsStyleContentData& nsStyleContentData::operator=(const nsStyleContentData& aOther) { if (this == &aOther) { return *this; } this->~nsStyleContentData(); new (this) nsStyleContentData(aOther); return *this; } bool nsStyleContentData::operator==(const nsStyleContentData& aOther) const { if (mType != aOther.mType) { return false; } if (mType == eStyleContentType_Image) { if (!mContent.mImage || !aOther.mContent.mImage) { return mContent.mImage == aOther.mContent.mImage; } bool eq; nsCOMPtr thisURI, otherURI; mContent.mImage->GetURI(getter_AddRefs(thisURI)); aOther.mContent.mImage->GetURI(getter_AddRefs(otherURI)); return thisURI == otherURI || // handles null==null (thisURI && otherURI && NS_SUCCEEDED(thisURI->Equals(otherURI, &eq)) && eq); } if (mType == eStyleContentType_Counter || mType == eStyleContentType_Counters) { return *mContent.mCounters == *aOther.mContent.mCounters; } return safe_strcmp(mContent.mString, aOther.mContent.mString) == 0; } void nsStyleContentData::TrackImage(ImageTracker* aImageTracker) { // Sanity MOZ_ASSERT(!mImageTracked, "Already tracking image!"); MOZ_ASSERT(mType == eStyleContentType_Image, "Trying to do image tracking on non-image!"); MOZ_ASSERT(mContent.mImage, "Can't track image when there isn't one!"); aImageTracker->Add(mContent.mImage); // Mark state #ifdef DEBUG mImageTracked = true; #endif } void nsStyleContentData::UntrackImage(ImageTracker* aImageTracker) { // Sanity MOZ_ASSERT(mImageTracked, "Image not tracked!"); MOZ_ASSERT(mType == eStyleContentType_Image, "Trying to do image tracking on non-image!"); MOZ_ASSERT(mContent.mImage, "Can't untrack image when there isn't one!"); aImageTracker->Remove(mContent.mImage); // Mark state #ifdef DEBUG mImageTracked = false; #endif } //----------------------- // nsStyleContent // nsStyleContent::nsStyleContent(StyleStructContext aContext) { MOZ_COUNT_CTOR(nsStyleContent); } nsStyleContent::~nsStyleContent() { MOZ_COUNT_DTOR(nsStyleContent); } void nsStyleContent::Destroy(nsPresContext* aContext) { // Unregister any images we might have with the document. for (auto& content : mContents) { if (content.mType == eStyleContentType_Image && content.mContent.mImage) { content.UntrackImage(aContext->Document()->ImageTracker()); } } this->~nsStyleContent(); aContext->PresShell()->FreeByObjectID(eArenaObjectID_nsStyleContent, this); } nsStyleContent::nsStyleContent(const nsStyleContent& aSource) : mContents(aSource.mContents) , mIncrements(aSource.mIncrements) , mResets(aSource.mResets) { MOZ_COUNT_CTOR(nsStyleContent); } nsChangeHint nsStyleContent::CalcDifference(const nsStyleContent& aNewData) const { // In ElementRestyler::Restyle we assume that if there's no existing // ::before or ::after and we don't have to restyle children of the // node then we can't end up with a ::before or ::after due to the // restyle of the node itself. That's not quite true, but the only // exception to the above is when the 'content' property of the node // changes and the pseudo-element inherits the changed value. Since // the code here triggers a frame change on the node in that case, // the optimization in ElementRestyler::Restyle is ok. But if we ever // change this code to not reconstruct frames on changes to the // 'content' property, then we will need to revisit the optimization // in ElementRestyler::Restyle. // 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 (mContents != aNewData.mContents || mIncrements != aNewData.mIncrements || mResets != aNewData.mResets) { return nsChangeHint_ReconstructFrame; } return nsChangeHint(0); } // -------------------- // nsStyleTextReset // nsStyleTextReset::nsStyleTextReset(StyleStructContext aContext) : mTextDecorationLine(NS_STYLE_TEXT_DECORATION_LINE_NONE) , mTextDecorationStyle(NS_STYLE_TEXT_DECORATION_STYLE_SOLID) , mUnicodeBidi(NS_STYLE_UNICODE_BIDI_NORMAL) , mInitialLetterSink(0) , mInitialLetterSize(0.0f) , mTextDecorationColor(StyleComplexColor::CurrentColor()) { MOZ_COUNT_CTOR(nsStyleTextReset); } nsStyleTextReset::nsStyleTextReset(const nsStyleTextReset& aSource) { MOZ_COUNT_CTOR(nsStyleTextReset); *this = aSource; } nsStyleTextReset::~nsStyleTextReset() { MOZ_COUNT_DTOR(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) { // 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); } // Returns true if the given shadow-arrays are equal. static bool AreShadowArraysEqual(nsCSSShadowArray* lhs, nsCSSShadowArray* rhs) { if (lhs == rhs) { return true; } if (!lhs || !rhs || lhs->Length() != rhs->Length()) { return false; } for (uint32_t i = 0; i < lhs->Length(); ++i) { if (*lhs->ShadowAt(i) != *rhs->ShadowAt(i)) { return false; } } return true; } // -------------------- // nsStyleText // nsStyleText::nsStyleText(StyleStructContext aContext) : mTextAlign(NS_STYLE_TEXT_ALIGN_START) , mTextAlignLast(NS_STYLE_TEXT_ALIGN_AUTO) , mTextAlignTrue(false) , mTextAlignLastTrue(false) , mTextJustify(StyleTextJustify::Auto) , mTextTransform(NS_STYLE_TEXT_TRANSFORM_NONE) , mWhiteSpace(NS_STYLE_WHITESPACE_NORMAL) , mWordBreak(NS_STYLE_WORDBREAK_NORMAL) , mOverflowWrap(NS_STYLE_OVERFLOWWRAP_NORMAL) , mHyphens(NS_STYLE_HYPHENS_MANUAL) , mRubyAlign(NS_STYLE_RUBY_ALIGN_SPACE_AROUND) , mRubyPosition(NS_STYLE_RUBY_POSITION_OVER) , mTextSizeAdjust(NS_STYLE_TEXT_SIZE_ADJUST_AUTO) , mTextCombineUpright(NS_STYLE_TEXT_COMBINE_UPRIGHT_NONE) , mControlCharacterVisibility(nsCSSParser::ControlCharVisibilityDefault()) , mTextEmphasisStyle(NS_STYLE_TEXT_EMPHASIS_STYLE_NONE) , mTextRendering(NS_STYLE_TEXT_RENDERING_AUTO) , mTextEmphasisColor(StyleComplexColor::CurrentColor()) , mWebkitTextFillColor(StyleComplexColor::CurrentColor()) , mWebkitTextStrokeColor(StyleComplexColor::CurrentColor()) , mTabSize(float(NS_STYLE_TABSIZE_INITIAL), eStyleUnit_Factor) , mWordSpacing(0, nsStyleCoord::CoordConstructor) , mLetterSpacing(eStyleUnit_Normal) , mLineHeight(eStyleUnit_Normal) , mTextIndent(0, nsStyleCoord::CoordConstructor) , mWebkitTextStrokeWidth(0, nsStyleCoord::CoordConstructor) , mTextShadow(nullptr) { MOZ_COUNT_CTOR(nsStyleText); nsCOMPtr language = aContext.GetContentLanguage(); mTextEmphasisPosition = language && nsStyleUtil::MatchesLanguagePrefix(language, u"zh") ? NS_STYLE_TEXT_EMPHASIS_POSITION_DEFAULT_ZH : NS_STYLE_TEXT_EMPHASIS_POSITION_DEFAULT; } nsStyleText::nsStyleText(const nsStyleText& aSource) : mTextAlign(aSource.mTextAlign) , mTextAlignLast(aSource.mTextAlignLast) , mTextAlignTrue(false) , mTextAlignLastTrue(false) , mTextJustify(aSource.mTextJustify) , mTextTransform(aSource.mTextTransform) , mWhiteSpace(aSource.mWhiteSpace) , mWordBreak(aSource.mWordBreak) , mOverflowWrap(aSource.mOverflowWrap) , mHyphens(aSource.mHyphens) , mRubyAlign(aSource.mRubyAlign) , mRubyPosition(aSource.mRubyPosition) , mTextSizeAdjust(aSource.mTextSizeAdjust) , mTextCombineUpright(aSource.mTextCombineUpright) , mControlCharacterVisibility(aSource.mControlCharacterVisibility) , mTextEmphasisPosition(aSource.mTextEmphasisPosition) , mTextEmphasisStyle(aSource.mTextEmphasisStyle) , mTextRendering(aSource.mTextRendering) , mTextEmphasisColor(aSource.mTextEmphasisColor) , mWebkitTextFillColor(aSource.mWebkitTextFillColor) , mWebkitTextStrokeColor(aSource.mWebkitTextStrokeColor) , mTabSize(aSource.mTabSize) , mWordSpacing(aSource.mWordSpacing) , mLetterSpacing(aSource.mLetterSpacing) , mLineHeight(aSource.mLineHeight) , mTextIndent(aSource.mTextIndent) , mWebkitTextStrokeWidth(aSource.mWebkitTextStrokeWidth) , mTextShadow(aSource.mTextShadow) , mTextEmphasisStyleString(aSource.mTextEmphasisStyleString) { MOZ_COUNT_CTOR(nsStyleText); } nsStyleText::~nsStyleText() { MOZ_COUNT_DTOR(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 || mControlCharacterVisibility != aNewData.mControlCharacterVisibility) { return nsChangeHint_ReconstructFrame; } if ((mTextAlign != aNewData.mTextAlign) || (mTextAlignLast != aNewData.mTextAlignLast) || (mTextAlignTrue != aNewData.mTextAlignTrue) || (mTextAlignLastTrue != aNewData.mTextAlignLastTrue) || (mTextTransform != aNewData.mTextTransform) || (mWhiteSpace != aNewData.mWhiteSpace) || (mWordBreak != aNewData.mWordBreak) || (mOverflowWrap != aNewData.mOverflowWrap) || (mHyphens != aNewData.mHyphens) || (mRubyAlign != aNewData.mRubyAlign) || (mRubyPosition != aNewData.mRubyPosition) || (mTextSizeAdjust != aNewData.mTextSizeAdjust) || (mLetterSpacing != aNewData.mLetterSpacing) || (mLineHeight != aNewData.mLineHeight) || (mTextJustify != aNewData.mTextJustify) || (mTextIndent != aNewData.mTextIndent) || (mWordSpacing != aNewData.mWordSpacing) || (mTabSize != aNewData.mTabSize)) { return NS_STYLE_HINT_REFLOW; } if (HasTextEmphasis() != aNewData.HasTextEmphasis() || (HasTextEmphasis() && 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_NeedDirtyReflow | // XXX remove me: bug 876085 nsChangeHint_RepaintFrame; } if (!AreShadowArraysEqual(mTextShadow, aNewData.mTextShadow) || mTextEmphasisStyle != aNewData.mTextEmphasisStyle || mTextEmphasisStyleString != aNewData.mTextEmphasisStyleString || mWebkitTextStrokeWidth != aNewData.mWebkitTextStrokeWidth) { hint |= nsChangeHint_UpdateSubtreeOverflow | nsChangeHint_SchedulePaint | nsChangeHint_RepaintFrame; // We don't add any other hints below. return hint; } if (mTextEmphasisColor != aNewData.mTextEmphasisColor || mWebkitTextFillColor != aNewData.mWebkitTextFillColor || mWebkitTextStrokeColor != aNewData.mWebkitTextStrokeColor) { hint |= nsChangeHint_SchedulePaint | nsChangeHint_RepaintFrame; } if (hint) { return hint; } if (mTextEmphasisPosition != aNewData.mTextEmphasisPosition) { return nsChangeHint_NeutralChange; } return nsChangeHint(0); } LogicalSide nsStyleText::TextEmphasisSide(WritingMode aWM) const { MOZ_ASSERT( (!(mTextEmphasisPosition & NS_STYLE_TEXT_EMPHASIS_POSITION_LEFT) != !(mTextEmphasisPosition & NS_STYLE_TEXT_EMPHASIS_POSITION_RIGHT)) && (!(mTextEmphasisPosition & NS_STYLE_TEXT_EMPHASIS_POSITION_OVER) != !(mTextEmphasisPosition & NS_STYLE_TEXT_EMPHASIS_POSITION_UNDER))); mozilla::Side side = aWM.IsVertical() ? (mTextEmphasisPosition & NS_STYLE_TEXT_EMPHASIS_POSITION_LEFT ? eSideLeft : eSideRight) : (mTextEmphasisPosition & NS_STYLE_TEXT_EMPHASIS_POSITION_OVER ? eSideTop : eSideBottom); LogicalSide result = aWM.LogicalSideForPhysicalSide(side); MOZ_ASSERT(IsBlock(result)); return result; } //----------------------- // nsStyleUserInterface // nsCursorImage::nsCursorImage() : mHaveHotspot(false) , mHotspotX(0.0f) , mHotspotY(0.0f) { } nsCursorImage::nsCursorImage(const nsCursorImage& aOther) : mHaveHotspot(aOther.mHaveHotspot) , mHotspotX(aOther.mHotspotX) , mHotspotY(aOther.mHotspotY) { SetImage(aOther.GetImage()); } nsCursorImage::~nsCursorImage() { SetImage(nullptr); } nsCursorImage& nsCursorImage::operator=(const nsCursorImage& aOther) { if (this != &aOther) { mHaveHotspot = aOther.mHaveHotspot; mHotspotX = aOther.mHotspotX; mHotspotY = aOther.mHotspotY; SetImage(aOther.GetImage()); } return *this; } bool nsCursorImage::operator==(const nsCursorImage& aOther) const { NS_ASSERTION(mHaveHotspot || (mHotspotX == 0 && mHotspotY == 0), "expected mHotspot{X,Y} to be 0 when mHaveHotspot is false"); NS_ASSERTION(aOther.mHaveHotspot || (aOther.mHotspotX == 0 && aOther.mHotspotY == 0), "expected mHotspot{X,Y} to be 0 when mHaveHotspot is false"); return mHaveHotspot == aOther.mHaveHotspot && mHotspotX == aOther.mHotspotX && mHotspotY == aOther.mHotspotY && EqualImages(mImage, aOther.mImage); } nsStyleUserInterface::nsStyleUserInterface(StyleStructContext aContext) : mUserInput(StyleUserInput::Auto) , mUserModify(StyleUserModify::ReadOnly) , mUserFocus(StyleUserFocus::None) , mPointerEvents(NS_STYLE_POINTER_EVENTS_AUTO) , mCursor(NS_STYLE_CURSOR_AUTO) , mCaretColor(StyleComplexColor::Auto()) , mScrollbarWidth(StyleScrollbarWidth::Auto) { MOZ_COUNT_CTOR(nsStyleUserInterface); } nsStyleUserInterface::nsStyleUserInterface(const nsStyleUserInterface& aSource) : mUserInput(aSource.mUserInput) , mUserModify(aSource.mUserModify) , mUserFocus(aSource.mUserFocus) , mPointerEvents(aSource.mPointerEvents) , mCursor(aSource.mCursor) , mCursorImages(aSource.mCursorImages) , mCaretColor(aSource.mCaretColor) , mScrollbarWidth(aSource.mScrollbarWidth) { MOZ_COUNT_CTOR(nsStyleUserInterface); } nsStyleUserInterface::~nsStyleUserInterface() { MOZ_COUNT_DTOR(nsStyleUserInterface); } nsChangeHint nsStyleUserInterface::CalcDifference(const nsStyleUserInterface& aNewData) const { nsChangeHint hint = nsChangeHint(0); if (mCursor != aNewData.mCursor) { hint |= nsChangeHint_UpdateCursor; } // We could do better. But it wouldn't be worth it, URL-specified cursors are // rare. if (mCursorImages != aNewData.mCursorImages) { hint |= nsChangeHint_UpdateCursor; } if (mPointerEvents != aNewData.mPointerEvents) { // nsSVGPathGeometryFrame's mRect depends on stroke _and_ on the value // of pointer-events. See nsSVGPathGeometryFrame::ReflowSVG's use of // GetHitTestFlags. (Only a reflow, no visual change.) hint |= nsChangeHint_NeedReflow | nsChangeHint_NeedDirtyReflow; // XXX remove me: bug 876085 } if (mUserModify != aNewData.mUserModify) { hint |= NS_STYLE_HINT_VISUAL; } if (mUserInput != aNewData.mUserInput) { if (StyleUserInput::None == mUserInput || StyleUserInput::None == aNewData.mUserInput) { hint |= nsChangeHint_ReconstructFrame; } else { hint |= nsChangeHint_NeutralChange; } } if (mUserFocus != aNewData.mUserFocus) { hint |= nsChangeHint_NeutralChange; } if (mCaretColor != aNewData.mCaretColor) { 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; } return hint; } //----------------------- // nsStyleUIReset // nsStyleUIReset::nsStyleUIReset(StyleStructContext aContext) : mUserSelect(StyleUserSelect::Auto) , mForceBrokenImageIcon(0) , mIMEMode(NS_STYLE_IME_MODE_AUTO) , mWindowDragging(StyleWindowDragging::Default) , mWindowShadow(NS_STYLE_WINDOW_SHADOW_DEFAULT) { MOZ_COUNT_CTOR(nsStyleUIReset); } nsStyleUIReset::nsStyleUIReset(const nsStyleUIReset& aSource) : mUserSelect(aSource.mUserSelect) , mForceBrokenImageIcon(aSource.mForceBrokenImageIcon) , mIMEMode(aSource.mIMEMode) , mWindowDragging(aSource.mWindowDragging) , mWindowShadow(aSource.mWindowShadow) { MOZ_COUNT_CTOR(nsStyleUIReset); } nsStyleUIReset::~nsStyleUIReset() { MOZ_COUNT_DTOR(nsStyleUIReset); } nsChangeHint nsStyleUIReset::CalcDifference(const nsStyleUIReset& aNewData) const { // ignore mIMEMode if (mForceBrokenImageIcon != aNewData.mForceBrokenImageIcon) { return nsChangeHint_ReconstructFrame; } 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. return NS_STYLE_HINT_REFLOW; } if (mUserSelect != aNewData.mUserSelect) { return NS_STYLE_HINT_VISUAL; } if (mWindowDragging != aNewData.mWindowDragging) { return nsChangeHint_SchedulePaint; } return nsChangeHint(0); } //----------------------- // nsStyleVariables // nsStyleVariables::nsStyleVariables(StyleStructContext aContext) { MOZ_COUNT_CTOR(nsStyleVariables); } nsStyleVariables::nsStyleVariables(const nsStyleVariables& aSource) : mVariables(aSource.mVariables) { MOZ_COUNT_CTOR(nsStyleVariables); } nsStyleVariables::~nsStyleVariables() { MOZ_COUNT_DTOR(nsStyleVariables); } nsChangeHint nsStyleVariables::CalcDifference(const nsStyleVariables& aNewData) const { return nsChangeHint(0); } //----------------------- // nsStyleEffects // nsStyleEffects::nsStyleEffects(StyleStructContext aContext) : mBoxShadow(nullptr) , mClip(0, 0, 0, 0) , mOpacity(1.0f) , mClipFlags(NS_STYLE_CLIP_AUTO) , mMixBlendMode(NS_STYLE_BLEND_NORMAL) { MOZ_COUNT_CTOR(nsStyleEffects); } nsStyleEffects::nsStyleEffects(const nsStyleEffects& aSource) : mFilters(aSource.mFilters) , mBoxShadow(aSource.mBoxShadow) , mClip(aSource.mClip) , mOpacity(aSource.mOpacity) , mClipFlags(aSource.mClipFlags) , mMixBlendMode(aSource.mMixBlendMode) { MOZ_COUNT_CTOR(nsStyleEffects); } nsStyleEffects::~nsStyleEffects() { MOZ_COUNT_DTOR(nsStyleEffects); } nsChangeHint nsStyleEffects::CalcDifference(const nsStyleEffects& aNewData) const { nsChangeHint hint = nsChangeHint(0); if (!AreShadowArraysEqual(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 (mClipFlags != aNewData.mClipFlags) { hint |= nsChangeHint_AllReflowHints | nsChangeHint_RepaintFrame; } if (!mClip.IsEqualInterior(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) { // 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 { hint |= nsChangeHint_UpdateOpacityLayer; 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 (!hint && !mClip.IsEqualEdges(aNewData.mClip)) { hint |= nsChangeHint_NeutralChange; } return hint; }