diff options
Diffstat (limited to 'layout/style/nsStyleStruct.cpp')
| -rw-r--r-- | layout/style/nsStyleStruct.cpp | 4261 |
1 files changed, 4261 insertions, 0 deletions
diff --git a/layout/style/nsStyleStruct.cpp b/layout/style/nsStyleStruct.cpp new file mode 100644 index 000000000..2f12d6201 --- /dev/null +++ b/layout/style/nsStyleStruct.cpp @@ -0,0 +1,4261 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * structs that contain the data provided by 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 <algorithm> + +using namespace mozilla; + +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<nsIURI> 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<nsIAppShellService> appShell(do_GetService("@mozilla.org/appshell/appShellService;1")); + MOZ_ASSERT(appShell); + nsCOMPtr<mozIDOMWindowProxy> win; + appShell->GetHiddenDOMWindow(getter_AddRefs(win)); + return nsLayoutUtils::GetDeviceContextForScreenInfo(static_cast<nsPIDOMWindowOuter*>(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<nsIAtom> +nsStyleFont::GetLanguage(StyleStructContext aContext) +{ + RefPtr<nsIAtom> 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<nsStyleQuoteValues> +nsStyleList::sInitialQuotes; + +StaticRefPtr<nsStyleQuoteValues> +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) + , mColumnGap(eStyleUnit_Normal) + , 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) + , mColumnGap(aSource.mColumnGap) + , 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 || + mColumnGap != aNewData.mColumnGap || + 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; + MOZ_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) + , 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) + , mGridColumnGap(nscoord(0), nsStyleCoord::CoordConstructor) + , mGridRowGap(nscoord(0), nsStyleCoord::CoordConstructor) +{ + 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) + , 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) + , mGridColumnGap(aSource.mGridColumnGap) + , mGridRowGap(aSource.mGridRowGap) +{ + 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 || + mGridColumnGap != aNewData.mGridColumnGap || + mGridRowGap != aNewData.mGridRowGap) { + 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) { + // Block-size changes can affect descendant intrinsic sizes due to + // replaced elements with percentage bsizes in descendants which + // also have percentage bsizes. This is handled via + // nsChangeHint_UpdateComputedBSize which clears intrinsic sizes + // for frames that have such replaced elements. + hint |= nsChangeHint_NeedReflow | + nsChangeHint_UpdateComputedBSize | + nsChangeHint_ReflowChangesSizeOrPosition; + } + + if (isVertical ? heightChanged : widthChanged) { + // None of our inline-size differences can affect descendant + // intrinsic sizes and none of them need to force children to + // reflow. + hint |= nsChangeHint_AllReflowHints & + ~(nsChangeHint_ClearDescendantIntrinsics | + nsChangeHint_NeedDirtyReflow); + } + } 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<imgRequestProxy> aRequestProxy, + already_AddRefed<css::ImageValue> aImageValue, + already_AddRefed<ImageTracker> 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<imgRequestProxy> mRequestProxy; + RefPtr<css::ImageValue> mImageValue; + RefPtr<ImageTracker> 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<PtrHolder<nsIURI>> aBaseURI, + already_AddRefed<PtrHolder<nsIURI>> aReferrer, + already_AddRefed<PtrHolder<nsIPrincipal>> 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<StyleImageRequestCleanupTask> 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<nsSize>& aSVGViewportSize) +{ + mCachedSVGViewportSize = aSVGViewportSize; +} + +const mozilla::Maybe<nsSize>& +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<nsStyleSides> cropRectCopy; + if (aOther.mCropRect) { + cropRectCopy = MakeUnique<nsStyleSides>(*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<nsStyleImageRequest> aImage) +{ + RefPtr<nsStyleImageRequest> 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<nsStyleSides> 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<imgIContainer> 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<imgIContainer> 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<nsStyleSides>& aRect1, const UniquePtr<nsStyleSides>& 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<nsSize>& 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 +}; + +#ifdef MOZ_ENABLE_MASK_AS_SHORTHAND +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 +}; +#endif + +nsStyleImageLayers::nsStyleImageLayers(nsStyleImageLayers::LayerType aType) + : mAttachmentCount(1) + , mClipCount(1) + , mOriginCount(1) + , mRepeatCount(1) + , mPositionXCount(1) + , mPositionYCount(1) + , mImageCount(1) + , mSizeCount(1) + , mMaskModeCount(1) + , mBlendModeCount(1) + , mCompositeCount(1) + , mLayers(nsStyleAutoArray<Layer>::WITH_SINGLE_INITIAL_ELEMENT) +{ + 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 + // <element-reference> or <gradient> + // 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<imgIContainer> imgContainer; + if (imgRequestProxy* req = aImage.GetImageData()) { + req->GetImage(getter_AddRefs(imgContainer)); + } + if (imgContainer) { + CSSIntSize imageSize; + nsSize 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 != nsSize(0, 0)) { + 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(NS_STYLE_IMAGELAYER_CLIP_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 = NS_STYLE_IMAGELAYER_ORIGIN_PADDING; + } else { + MOZ_ASSERT(aType == LayerType::Mask, "unsupported layer type."); + mOrigin = NS_STYLE_IMAGELAYER_ORIGIN_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<Type>(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<StyleTransition>::WITH_SINGLE_INITIAL_ELEMENT) + , mTransitionTimingFunctionCount(1) + , mTransitionDurationCount(1) + , mTransitionDelayCount(1) + , mTransitionPropertyCount(1) + , mAnimations(nsStyleAutoArray<StyleAnimation>::WITH_SINGLE_INITIAL_ELEMENT) + , mAnimationTimingFunctionCount(1) + , mAnimationDurationCount(1) + , mAnimationDelayCount(1) + , mAnimationNameCount(1) + , mAnimationDirectionCount(1) + , mAnimationFillModeCount(1) + , mAnimationPlayStateCount(1) + , mAnimationIterationCountCount(1) +{ + 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) + || mOverflowX != aNewData.mOverflowX + || mOverflowY != aNewData.mOverflowY + || 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; + } + + /* 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 <input type=number> 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<nsIURI> 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) + , 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) + , mTabSize(NS_STYLE_TABSIZE_INITIAL) + , mTextEmphasisColor(StyleComplexColor::CurrentColor()) + , mWebkitTextFillColor(StyleComplexColor::CurrentColor()) + , mWebkitTextStrokeColor(StyleComplexColor::CurrentColor()) + , 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<nsIAtom> 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) + , 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) + , mTabSize(aSource.mTabSize) + , mTextEmphasisColor(aSource.mTextEmphasisColor) + , mWebkitTextFillColor(aSource.mWebkitTextFillColor) + , mWebkitTextStrokeColor(aSource.mWebkitTextStrokeColor) + , 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) || + (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) +{ + 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) +{ + 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; + } + + 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; +} |