diff -r 000000000000 -r 6474c204b198 layout/style/nsCSSValue.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/layout/style/nsCSSValue.cpp Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,2421 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=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/. */ + +/* representation of simple property values within CSS declarations */ + +#include "nsCSSValue.h" + +#include "mozilla/Likely.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/css/ImageLoader.h" +#include "CSSCalc.h" +#include "gfxFontConstants.h" +#include "imgIRequest.h" +#include "imgRequestProxy.h" +#include "nsIDocument.h" +#include "nsIPrincipal.h" +#include "nsCSSProps.h" +#include "nsCSSStyleSheet.h" +#include "nsNetUtil.h" +#include "nsPresContext.h" +#include "nsStyleUtil.h" +#include "nsDeviceContext.h" + +using namespace mozilla; + +nsCSSValue::nsCSSValue(int32_t aValue, nsCSSUnit aUnit) + : mUnit(aUnit) +{ + NS_ABORT_IF_FALSE(aUnit == eCSSUnit_Integer || aUnit == eCSSUnit_Enumerated || + aUnit == eCSSUnit_EnumColor, "not an int value"); + if (aUnit == eCSSUnit_Integer || aUnit == eCSSUnit_Enumerated || + aUnit == eCSSUnit_EnumColor) { + mValue.mInt = aValue; + } + else { + mUnit = eCSSUnit_Null; + mValue.mInt = 0; + } +} + +nsCSSValue::nsCSSValue(float aValue, nsCSSUnit aUnit) + : mUnit(aUnit) +{ + NS_ABORT_IF_FALSE(eCSSUnit_Percent <= aUnit, "not a float value"); + if (eCSSUnit_Percent <= aUnit) { + mValue.mFloat = aValue; + MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); + } + else { + mUnit = eCSSUnit_Null; + mValue.mInt = 0; + } +} + +nsCSSValue::nsCSSValue(const nsString& aValue, nsCSSUnit aUnit) + : mUnit(aUnit) +{ + NS_ABORT_IF_FALSE(UnitHasStringValue(), "not a string value"); + if (UnitHasStringValue()) { + mValue.mString = BufferFromString(aValue).take(); + } + else { + mUnit = eCSSUnit_Null; + mValue.mInt = 0; + } +} + +nsCSSValue::nsCSSValue(nsCSSValue::Array* aValue, nsCSSUnit aUnit) + : mUnit(aUnit) +{ + NS_ABORT_IF_FALSE(UnitHasArrayValue(), "bad unit"); + mValue.mArray = aValue; + mValue.mArray->AddRef(); +} + +nsCSSValue::nsCSSValue(mozilla::css::URLValue* aValue) + : mUnit(eCSSUnit_URL) +{ + mValue.mURL = aValue; + mValue.mURL->AddRef(); +} + +nsCSSValue::nsCSSValue(mozilla::css::ImageValue* aValue) + : mUnit(eCSSUnit_Image) +{ + mValue.mImage = aValue; + mValue.mImage->AddRef(); +} + +nsCSSValue::nsCSSValue(nsCSSValueGradient* aValue) + : mUnit(eCSSUnit_Gradient) +{ + mValue.mGradient = aValue; + mValue.mGradient->AddRef(); +} + +nsCSSValue::nsCSSValue(nsCSSValueTokenStream* aValue) + : mUnit(eCSSUnit_TokenStream) +{ + mValue.mTokenStream = aValue; + mValue.mTokenStream->AddRef(); +} + +nsCSSValue::nsCSSValue(mozilla::css::GridTemplateAreasValue* aValue) + : mUnit(eCSSUnit_GridTemplateAreas) +{ + mValue.mGridTemplateAreas = aValue; + mValue.mGridTemplateAreas->AddRef(); +} + +nsCSSValue::nsCSSValue(const nsCSSValue& aCopy) + : mUnit(aCopy.mUnit) +{ + if (mUnit <= eCSSUnit_DummyInherit) { + // nothing to do, but put this important case first + } + else if (eCSSUnit_Percent <= mUnit) { + mValue.mFloat = aCopy.mValue.mFloat; + MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); + } + else if (UnitHasStringValue()) { + mValue.mString = aCopy.mValue.mString; + mValue.mString->AddRef(); + } + else if (eCSSUnit_Integer <= mUnit && mUnit <= eCSSUnit_EnumColor) { + mValue.mInt = aCopy.mValue.mInt; + } + else if (IsIntegerColorUnit()) { + mValue.mColor = aCopy.mValue.mColor; + } + else if (IsFloatColorUnit()) { + mValue.mFloatColor = aCopy.mValue.mFloatColor; + mValue.mFloatColor->AddRef(); + } + else if (UnitHasArrayValue()) { + mValue.mArray = aCopy.mValue.mArray; + mValue.mArray->AddRef(); + } + else if (eCSSUnit_URL == mUnit) { + mValue.mURL = aCopy.mValue.mURL; + mValue.mURL->AddRef(); + } + else if (eCSSUnit_Image == mUnit) { + mValue.mImage = aCopy.mValue.mImage; + mValue.mImage->AddRef(); + } + else if (eCSSUnit_Gradient == mUnit) { + mValue.mGradient = aCopy.mValue.mGradient; + mValue.mGradient->AddRef(); + } + else if (eCSSUnit_TokenStream == mUnit) { + mValue.mTokenStream = aCopy.mValue.mTokenStream; + mValue.mTokenStream->AddRef(); + } + else if (eCSSUnit_Pair == mUnit) { + mValue.mPair = aCopy.mValue.mPair; + mValue.mPair->AddRef(); + } + else if (eCSSUnit_Triplet == mUnit) { + mValue.mTriplet = aCopy.mValue.mTriplet; + mValue.mTriplet->AddRef(); + } + else if (eCSSUnit_Rect == mUnit) { + mValue.mRect = aCopy.mValue.mRect; + mValue.mRect->AddRef(); + } + else if (eCSSUnit_List == mUnit) { + mValue.mList = aCopy.mValue.mList; + mValue.mList->AddRef(); + } + else if (eCSSUnit_ListDep == mUnit) { + mValue.mListDependent = aCopy.mValue.mListDependent; + } + else if (eCSSUnit_SharedList == mUnit) { + mValue.mSharedList = aCopy.mValue.mSharedList; + mValue.mSharedList->AddRef(); + } + else if (eCSSUnit_PairList == mUnit) { + mValue.mPairList = aCopy.mValue.mPairList; + mValue.mPairList->AddRef(); + } + else if (eCSSUnit_PairListDep == mUnit) { + mValue.mPairListDependent = aCopy.mValue.mPairListDependent; + } + else if (eCSSUnit_GridTemplateAreas == mUnit) { + mValue.mGridTemplateAreas = aCopy.mValue.mGridTemplateAreas; + mValue.mGridTemplateAreas->AddRef(); + } + else { + NS_ABORT_IF_FALSE(false, "unknown unit"); + } +} + +nsCSSValue& nsCSSValue::operator=(const nsCSSValue& aCopy) +{ + if (this != &aCopy) { + Reset(); + new (this) nsCSSValue(aCopy); + } + return *this; +} + +bool nsCSSValue::operator==(const nsCSSValue& aOther) const +{ + NS_ABORT_IF_FALSE(mUnit != eCSSUnit_ListDep && + aOther.mUnit != eCSSUnit_ListDep && + mUnit != eCSSUnit_PairListDep && + aOther.mUnit != eCSSUnit_PairListDep, + "don't use operator== with dependent lists"); + + if (mUnit == aOther.mUnit) { + if (mUnit <= eCSSUnit_DummyInherit) { + return true; + } + else if (UnitHasStringValue()) { + return (NS_strcmp(GetBufferValue(mValue.mString), + GetBufferValue(aOther.mValue.mString)) == 0); + } + else if ((eCSSUnit_Integer <= mUnit) && (mUnit <= eCSSUnit_EnumColor)) { + return mValue.mInt == aOther.mValue.mInt; + } + else if (IsIntegerColorUnit()) { + return mValue.mColor == aOther.mValue.mColor; + } + else if (IsFloatColorUnit()) { + return *mValue.mFloatColor == *aOther.mValue.mFloatColor; + } + else if (UnitHasArrayValue()) { + return *mValue.mArray == *aOther.mValue.mArray; + } + else if (eCSSUnit_URL == mUnit) { + return *mValue.mURL == *aOther.mValue.mURL; + } + else if (eCSSUnit_Image == mUnit) { + return *mValue.mImage == *aOther.mValue.mImage; + } + else if (eCSSUnit_Gradient == mUnit) { + return *mValue.mGradient == *aOther.mValue.mGradient; + } + else if (eCSSUnit_TokenStream == mUnit) { + return *mValue.mTokenStream == *aOther.mValue.mTokenStream; + } + else if (eCSSUnit_Pair == mUnit) { + return *mValue.mPair == *aOther.mValue.mPair; + } + else if (eCSSUnit_Triplet == mUnit) { + return *mValue.mTriplet == *aOther.mValue.mTriplet; + } + else if (eCSSUnit_Rect == mUnit) { + return *mValue.mRect == *aOther.mValue.mRect; + } + else if (eCSSUnit_List == mUnit) { + return *mValue.mList == *aOther.mValue.mList; + } + else if (eCSSUnit_SharedList == mUnit) { + return *mValue.mSharedList == *aOther.mValue.mSharedList; + } + else if (eCSSUnit_PairList == mUnit) { + return *mValue.mPairList == *aOther.mValue.mPairList; + } + else if (eCSSUnit_GridTemplateAreas == mUnit) { + return *mValue.mGridTemplateAreas == *aOther.mValue.mGridTemplateAreas; + } + else { + return mValue.mFloat == aOther.mValue.mFloat; + } + } + return false; +} + +double nsCSSValue::GetAngleValueInRadians() const +{ + double angle = GetFloatValue(); + + switch (GetUnit()) { + case eCSSUnit_Radian: return angle; + case eCSSUnit_Turn: return angle * 2 * M_PI; + case eCSSUnit_Degree: return angle * M_PI / 180.0; + case eCSSUnit_Grad: return angle * M_PI / 200.0; + + default: + NS_ABORT_IF_FALSE(false, "unrecognized angular unit"); + return 0.0; + } +} + +imgRequestProxy* nsCSSValue::GetImageValue(nsIDocument* aDocument) const +{ + NS_ABORT_IF_FALSE(mUnit == eCSSUnit_Image, "not an Image value"); + return mValue.mImage->mRequests.GetWeak(aDocument); +} + +nscoord nsCSSValue::GetFixedLength(nsPresContext* aPresContext) const +{ + NS_ABORT_IF_FALSE(mUnit == eCSSUnit_PhysicalMillimeter, + "not a fixed length unit"); + + float inches = mValue.mFloat / MM_PER_INCH_FLOAT; + return NSToCoordFloorClamped(inches * + float(aPresContext->DeviceContext()->AppUnitsPerPhysicalInch())); +} + +nscoord nsCSSValue::GetPixelLength() const +{ + NS_ABORT_IF_FALSE(IsPixelLengthUnit(), "not a fixed length unit"); + + double scaleFactor; + switch (mUnit) { + case eCSSUnit_Pixel: return nsPresContext::CSSPixelsToAppUnits(mValue.mFloat); + case eCSSUnit_Pica: scaleFactor = 16.0; break; + case eCSSUnit_Point: scaleFactor = 4/3.0; break; + case eCSSUnit_Inch: scaleFactor = 96.0; break; + case eCSSUnit_Millimeter: scaleFactor = 96/25.4; break; + case eCSSUnit_Centimeter: scaleFactor = 96/2.54; break; + default: + NS_ERROR("should never get here"); + return 0; + } + return nsPresContext::CSSPixelsToAppUnits(float(mValue.mFloat*scaleFactor)); +} + +void nsCSSValue::DoReset() +{ + if (UnitHasStringValue()) { + mValue.mString->Release(); + } else if (IsFloatColorUnit()) { + mValue.mFloatColor->Release(); + } else if (UnitHasArrayValue()) { + mValue.mArray->Release(); + } else if (eCSSUnit_URL == mUnit) { + mValue.mURL->Release(); + } else if (eCSSUnit_Image == mUnit) { + mValue.mImage->Release(); + } else if (eCSSUnit_Gradient == mUnit) { + mValue.mGradient->Release(); + } else if (eCSSUnit_TokenStream == mUnit) { + mValue.mTokenStream->Release(); + } else if (eCSSUnit_Pair == mUnit) { + mValue.mPair->Release(); + } else if (eCSSUnit_Triplet == mUnit) { + mValue.mTriplet->Release(); + } else if (eCSSUnit_Rect == mUnit) { + mValue.mRect->Release(); + } else if (eCSSUnit_List == mUnit) { + mValue.mList->Release(); + } else if (eCSSUnit_SharedList == mUnit) { + mValue.mSharedList->Release(); + } else if (eCSSUnit_PairList == mUnit) { + mValue.mPairList->Release(); + } else if (eCSSUnit_GridTemplateAreas == mUnit) { + mValue.mGridTemplateAreas->Release(); + } + mUnit = eCSSUnit_Null; +} + +void nsCSSValue::SetIntValue(int32_t aValue, nsCSSUnit aUnit) +{ + NS_ABORT_IF_FALSE(aUnit == eCSSUnit_Integer || aUnit == eCSSUnit_Enumerated || + aUnit == eCSSUnit_EnumColor, "not an int value"); + Reset(); + if (aUnit == eCSSUnit_Integer || aUnit == eCSSUnit_Enumerated || + aUnit == eCSSUnit_EnumColor) { + mUnit = aUnit; + mValue.mInt = aValue; + } +} + +void nsCSSValue::SetPercentValue(float aValue) +{ + Reset(); + mUnit = eCSSUnit_Percent; + mValue.mFloat = aValue; + MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); +} + +void nsCSSValue::SetFloatValue(float aValue, nsCSSUnit aUnit) +{ + NS_ABORT_IF_FALSE(eCSSUnit_Number <= aUnit, "not a float value"); + Reset(); + if (eCSSUnit_Number <= aUnit) { + mUnit = aUnit; + mValue.mFloat = aValue; + MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); + } +} + +void nsCSSValue::SetStringValue(const nsString& aValue, + nsCSSUnit aUnit) +{ + Reset(); + mUnit = aUnit; + NS_ABORT_IF_FALSE(UnitHasStringValue(), "not a string unit"); + if (UnitHasStringValue()) { + mValue.mString = BufferFromString(aValue).take(); + } else + mUnit = eCSSUnit_Null; +} + +void nsCSSValue::SetColorValue(nscolor aValue) +{ + SetIntegerColorValue(aValue, eCSSUnit_RGBAColor); +} + +void nsCSSValue::SetIntegerColorValue(nscolor aValue, nsCSSUnit aUnit) +{ + Reset(); + mUnit = aUnit; + NS_ABORT_IF_FALSE(IsIntegerColorUnit(), "bad unit"); + mValue.mColor = aValue; +} + +void nsCSSValue::SetFloatColorValue(float aComponent1, + float aComponent2, + float aComponent3, + float aAlpha, + nsCSSUnit aUnit) +{ + Reset(); + mUnit = aUnit; + NS_ABORT_IF_FALSE(IsFloatColorUnit(), "bad unit"); + mValue.mFloatColor = + new nsCSSValueFloatColor(aComponent1, aComponent2, aComponent3, aAlpha); + mValue.mFloatColor->AddRef(); +} + +void nsCSSValue::SetArrayValue(nsCSSValue::Array* aValue, nsCSSUnit aUnit) +{ + Reset(); + mUnit = aUnit; + NS_ABORT_IF_FALSE(UnitHasArrayValue(), "bad unit"); + mValue.mArray = aValue; + mValue.mArray->AddRef(); +} + +void nsCSSValue::SetURLValue(mozilla::css::URLValue* aValue) +{ + Reset(); + mUnit = eCSSUnit_URL; + mValue.mURL = aValue; + mValue.mURL->AddRef(); +} + +void nsCSSValue::SetImageValue(mozilla::css::ImageValue* aValue) +{ + Reset(); + mUnit = eCSSUnit_Image; + mValue.mImage = aValue; + mValue.mImage->AddRef(); +} + +void nsCSSValue::SetGradientValue(nsCSSValueGradient* aValue) +{ + Reset(); + mUnit = eCSSUnit_Gradient; + mValue.mGradient = aValue; + mValue.mGradient->AddRef(); +} + +void nsCSSValue::SetTokenStreamValue(nsCSSValueTokenStream* aValue) +{ + Reset(); + mUnit = eCSSUnit_TokenStream; + mValue.mTokenStream = aValue; + mValue.mTokenStream->AddRef(); +} + +void nsCSSValue::SetGridTemplateAreas(mozilla::css::GridTemplateAreasValue* aValue) +{ + Reset(); + mUnit = eCSSUnit_GridTemplateAreas; + mValue.mGridTemplateAreas = aValue; + mValue.mGridTemplateAreas->AddRef(); +} + +void nsCSSValue::SetPairValue(const nsCSSValuePair* aValue) +{ + // pairs should not be used for null/inherit/initial values + NS_ABORT_IF_FALSE(aValue && + aValue->mXValue.GetUnit() != eCSSUnit_Null && + aValue->mYValue.GetUnit() != eCSSUnit_Null && + aValue->mXValue.GetUnit() != eCSSUnit_Inherit && + aValue->mYValue.GetUnit() != eCSSUnit_Inherit && + aValue->mXValue.GetUnit() != eCSSUnit_Initial && + aValue->mYValue.GetUnit() != eCSSUnit_Initial && + aValue->mXValue.GetUnit() != eCSSUnit_Unset && + aValue->mYValue.GetUnit() != eCSSUnit_Unset, + "missing or inappropriate pair value"); + Reset(); + mUnit = eCSSUnit_Pair; + mValue.mPair = new nsCSSValuePair_heap(aValue->mXValue, aValue->mYValue); + mValue.mPair->AddRef(); +} + +void nsCSSValue::SetPairValue(const nsCSSValue& xValue, + const nsCSSValue& yValue) +{ + NS_ABORT_IF_FALSE(xValue.GetUnit() != eCSSUnit_Null && + yValue.GetUnit() != eCSSUnit_Null && + xValue.GetUnit() != eCSSUnit_Inherit && + yValue.GetUnit() != eCSSUnit_Inherit && + xValue.GetUnit() != eCSSUnit_Initial && + yValue.GetUnit() != eCSSUnit_Initial && + xValue.GetUnit() != eCSSUnit_Unset && + yValue.GetUnit() != eCSSUnit_Unset, + "inappropriate pair value"); + Reset(); + mUnit = eCSSUnit_Pair; + mValue.mPair = new nsCSSValuePair_heap(xValue, yValue); + mValue.mPair->AddRef(); +} + +void nsCSSValue::SetTripletValue(const nsCSSValueTriplet* aValue) +{ + // triplet should not be used for null/inherit/initial values + NS_ABORT_IF_FALSE(aValue && + aValue->mXValue.GetUnit() != eCSSUnit_Null && + aValue->mYValue.GetUnit() != eCSSUnit_Null && + aValue->mZValue.GetUnit() != eCSSUnit_Null && + aValue->mXValue.GetUnit() != eCSSUnit_Inherit && + aValue->mYValue.GetUnit() != eCSSUnit_Inherit && + aValue->mZValue.GetUnit() != eCSSUnit_Inherit && + aValue->mXValue.GetUnit() != eCSSUnit_Initial && + aValue->mYValue.GetUnit() != eCSSUnit_Initial && + aValue->mZValue.GetUnit() != eCSSUnit_Initial && + aValue->mXValue.GetUnit() != eCSSUnit_Unset && + aValue->mYValue.GetUnit() != eCSSUnit_Unset && + aValue->mZValue.GetUnit() != eCSSUnit_Unset, + "missing or inappropriate triplet value"); + Reset(); + mUnit = eCSSUnit_Triplet; + mValue.mTriplet = new nsCSSValueTriplet_heap(aValue->mXValue, aValue->mYValue, aValue->mZValue); + mValue.mTriplet->AddRef(); +} + +void nsCSSValue::SetTripletValue(const nsCSSValue& xValue, + const nsCSSValue& yValue, + const nsCSSValue& zValue) +{ + // Only allow Null for the z component + NS_ABORT_IF_FALSE(xValue.GetUnit() != eCSSUnit_Null && + yValue.GetUnit() != eCSSUnit_Null && + xValue.GetUnit() != eCSSUnit_Inherit && + yValue.GetUnit() != eCSSUnit_Inherit && + zValue.GetUnit() != eCSSUnit_Inherit && + xValue.GetUnit() != eCSSUnit_Initial && + yValue.GetUnit() != eCSSUnit_Initial && + zValue.GetUnit() != eCSSUnit_Initial && + xValue.GetUnit() != eCSSUnit_Unset && + yValue.GetUnit() != eCSSUnit_Unset && + zValue.GetUnit() != eCSSUnit_Unset, + "inappropriate triplet value"); + Reset(); + mUnit = eCSSUnit_Triplet; + mValue.mTriplet = new nsCSSValueTriplet_heap(xValue, yValue, zValue); + mValue.mTriplet->AddRef(); +} + +nsCSSRect& nsCSSValue::SetRectValue() +{ + Reset(); + mUnit = eCSSUnit_Rect; + mValue.mRect = new nsCSSRect_heap; + mValue.mRect->AddRef(); + return *mValue.mRect; +} + +nsCSSValueList* nsCSSValue::SetListValue() +{ + Reset(); + mUnit = eCSSUnit_List; + mValue.mList = new nsCSSValueList_heap; + mValue.mList->AddRef(); + return mValue.mList; +} + +void nsCSSValue::SetSharedListValue(nsCSSValueSharedList* aList) +{ + Reset(); + mUnit = eCSSUnit_SharedList; + mValue.mSharedList = aList; + mValue.mSharedList->AddRef(); +} + +void nsCSSValue::SetDependentListValue(nsCSSValueList* aList) +{ + Reset(); + if (aList) { + mUnit = eCSSUnit_ListDep; + mValue.mListDependent = aList; + } +} + +nsCSSValuePairList* nsCSSValue::SetPairListValue() +{ + Reset(); + mUnit = eCSSUnit_PairList; + mValue.mPairList = new nsCSSValuePairList_heap; + mValue.mPairList->AddRef(); + return mValue.mPairList; +} + +void nsCSSValue::SetDependentPairListValue(nsCSSValuePairList* aList) +{ + Reset(); + if (aList) { + mUnit = eCSSUnit_PairListDep; + mValue.mPairListDependent = aList; + } +} + +void nsCSSValue::SetAutoValue() +{ + Reset(); + mUnit = eCSSUnit_Auto; +} + +void nsCSSValue::SetInheritValue() +{ + Reset(); + mUnit = eCSSUnit_Inherit; +} + +void nsCSSValue::SetInitialValue() +{ + Reset(); + mUnit = eCSSUnit_Initial; +} + +void nsCSSValue::SetUnsetValue() +{ + Reset(); + mUnit = eCSSUnit_Unset; +} + +void nsCSSValue::SetNoneValue() +{ + Reset(); + mUnit = eCSSUnit_None; +} + +void nsCSSValue::SetAllValue() +{ + Reset(); + mUnit = eCSSUnit_All; +} + +void nsCSSValue::SetNormalValue() +{ + Reset(); + mUnit = eCSSUnit_Normal; +} + +void nsCSSValue::SetSystemFontValue() +{ + Reset(); + mUnit = eCSSUnit_System_Font; +} + +void nsCSSValue::SetDummyValue() +{ + Reset(); + mUnit = eCSSUnit_Dummy; +} + +void nsCSSValue::SetDummyInheritValue() +{ + Reset(); + mUnit = eCSSUnit_DummyInherit; +} + +void nsCSSValue::StartImageLoad(nsIDocument* aDocument) const +{ + NS_ABORT_IF_FALSE(eCSSUnit_URL == mUnit, "Not a URL value!"); + mozilla::css::ImageValue* image = + new mozilla::css::ImageValue(mValue.mURL->GetURI(), + mValue.mURL->mString, + mValue.mURL->mReferrer, + mValue.mURL->mOriginPrincipal, + aDocument); + + nsCSSValue* writable = const_cast(this); + writable->SetImageValue(image); +} + +nscolor nsCSSValue::GetColorValue() const +{ + NS_ABORT_IF_FALSE(IsNumericColorUnit(), "not a color value"); + if (IsFloatColorUnit()) { + return mValue.mFloatColor->GetColorValue(mUnit); + } + return mValue.mColor; +} + +bool nsCSSValue::IsNonTransparentColor() const +{ + // We have the value in the form it was specified in at this point, so we + // have to look for both the keyword 'transparent' and its equivalent in + // rgba notation. + nsDependentString buf; + return + (IsIntegerColorUnit() && NS_GET_A(GetColorValue()) > 0) || + (IsFloatColorUnit() && mValue.mFloatColor->IsNonTransparentColor()) || + (mUnit == eCSSUnit_Ident && + !nsGkAtoms::transparent->Equals(GetStringValue(buf))) || + (mUnit == eCSSUnit_EnumColor); +} + +nsCSSValue::Array* +nsCSSValue::InitFunction(nsCSSKeyword aFunctionId, uint32_t aNumArgs) +{ + nsRefPtr func = Array::Create(aNumArgs + 1); + func->Item(0).SetIntValue(aFunctionId, eCSSUnit_Enumerated); + SetArrayValue(func, eCSSUnit_Function); + return func; +} + +bool +nsCSSValue::EqualsFunction(nsCSSKeyword aFunctionId) const +{ + if (mUnit != eCSSUnit_Function) { + return false; + } + + nsCSSValue::Array* func = mValue.mArray; + NS_ABORT_IF_FALSE(func && func->Count() >= 1 && + func->Item(0).GetUnit() == eCSSUnit_Enumerated, + "illegally structured function value"); + + nsCSSKeyword thisFunctionId = func->Item(0).GetKeywordValue(); + return thisFunctionId == aFunctionId; +} + +// static +already_AddRefed +nsCSSValue::BufferFromString(const nsString& aValue) +{ + nsRefPtr buffer = nsStringBuffer::FromString(aValue); + if (buffer) { + return buffer.forget(); + } + + nsString::size_type length = aValue.Length(); + + // NOTE: Alloc prouduces a new, already-addref'd (refcnt = 1) buffer. + // NOTE: String buffer allocation is currently fallible. + buffer = nsStringBuffer::Alloc((length + 1) * sizeof(char16_t)); + if (MOZ_UNLIKELY(!buffer)) { + NS_RUNTIMEABORT("out of memory"); + } + + char16_t* data = static_cast(buffer->Data()); + nsCharTraits::copy(data, aValue.get(), length); + // Null-terminate. + data[length] = 0; + return buffer.forget(); +} + +namespace { + +struct CSSValueSerializeCalcOps { + CSSValueSerializeCalcOps(nsCSSProperty aProperty, nsAString& aResult, + nsCSSValue::Serialization aSerialization) + : mProperty(aProperty), + mResult(aResult), + mValueSerialization(aSerialization) + { + } + + typedef nsCSSValue input_type; + typedef nsCSSValue::Array input_array_type; + + static nsCSSUnit GetUnit(const input_type& aValue) { + return aValue.GetUnit(); + } + + void Append(const char* aString) + { + mResult.AppendASCII(aString); + } + + void AppendLeafValue(const input_type& aValue) + { + NS_ABORT_IF_FALSE(aValue.GetUnit() == eCSSUnit_Percent || + aValue.IsLengthUnit(), "unexpected unit"); + aValue.AppendToString(mProperty, mResult, mValueSerialization); + } + + void AppendNumber(const input_type& aValue) + { + NS_ABORT_IF_FALSE(aValue.GetUnit() == eCSSUnit_Number, "unexpected unit"); + aValue.AppendToString(mProperty, mResult, mValueSerialization); + } + +private: + nsCSSProperty mProperty; + nsAString &mResult; + nsCSSValue::Serialization mValueSerialization; +}; + +} // anonymous namespace + +void +nsCSSValue::AppendToString(nsCSSProperty aProperty, nsAString& aResult, + Serialization aSerialization) const +{ + // eCSSProperty_UNKNOWN gets used for some recursive calls below. + NS_ABORT_IF_FALSE((0 <= aProperty && + aProperty <= eCSSProperty_COUNT_no_shorthands) || + aProperty == eCSSProperty_UNKNOWN, + "property ID out of range"); + + nsCSSUnit unit = GetUnit(); + if (unit == eCSSUnit_Null) { + return; + } + + if (eCSSUnit_String <= unit && unit <= eCSSUnit_Attr) { + if (unit == eCSSUnit_Attr) { + aResult.AppendLiteral("attr("); + } + nsAutoString buffer; + GetStringValue(buffer); + if (unit == eCSSUnit_String) { + nsStyleUtil::AppendEscapedCSSString(buffer, aResult); + } else if (unit == eCSSUnit_Families) { + // XXX We really need to do *some* escaping. + aResult.Append(buffer); + } else { + nsStyleUtil::AppendEscapedCSSIdent(buffer, aResult); + } + } + else if (eCSSUnit_Array <= unit && unit <= eCSSUnit_Steps) { + switch (unit) { + case eCSSUnit_Counter: aResult.AppendLiteral("counter("); break; + case eCSSUnit_Counters: aResult.AppendLiteral("counters("); break; + case eCSSUnit_Cubic_Bezier: aResult.AppendLiteral("cubic-bezier("); break; + case eCSSUnit_Steps: aResult.AppendLiteral("steps("); break; + default: break; + } + + nsCSSValue::Array *array = GetArrayValue(); + bool mark = false; + for (size_t i = 0, i_end = array->Count(); i < i_end; ++i) { + if (mark && array->Item(i).GetUnit() != eCSSUnit_Null) { + if (unit == eCSSUnit_Array && + eCSSProperty_transition_timing_function != aProperty) + aResult.AppendLiteral(" "); + else + aResult.AppendLiteral(", "); + } + if (unit == eCSSUnit_Steps && i == 1) { + NS_ABORT_IF_FALSE(array->Item(i).GetUnit() == eCSSUnit_Enumerated && + (array->Item(i).GetIntValue() == + NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START || + array->Item(i).GetIntValue() == + NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END), + "unexpected value"); + if (array->Item(i).GetIntValue() == + NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START) { + aResult.AppendLiteral("start"); + } else { + aResult.AppendLiteral("end"); + } + continue; + } + nsCSSProperty prop = + ((eCSSUnit_Counter <= unit && unit <= eCSSUnit_Counters) && + i == array->Count() - 1) + ? eCSSProperty_list_style_type : aProperty; + if (array->Item(i).GetUnit() != eCSSUnit_Null) { + array->Item(i).AppendToString(prop, aResult, aSerialization); + mark = true; + } + } + if (eCSSUnit_Array == unit && + aProperty == eCSSProperty_transition_timing_function) { + aResult.AppendLiteral(")"); + } + } + /* Although Function is backed by an Array, we'll handle it separately + * because it's a bit quirky. + */ + else if (eCSSUnit_Function == unit) { + const nsCSSValue::Array* array = GetArrayValue(); + NS_ABORT_IF_FALSE(array->Count() >= 1, + "Functions must have at least one element for the name."); + + /* Append the function name. */ + const nsCSSValue& functionName = array->Item(0); + if (functionName.GetUnit() == eCSSUnit_Enumerated) { + // We assume that the first argument is always of nsCSSKeyword type. + const nsCSSKeyword functionId = functionName.GetKeywordValue(); + NS_ConvertASCIItoUTF16 ident(nsCSSKeywords::GetStringValue(functionId)); + // Bug 721136: Normalize the identifier to lowercase, except that things + // like scaleX should have the last character capitalized. This matches + // what other browsers do. + switch (functionId) { + case eCSSKeyword_rotatex: + case eCSSKeyword_scalex: + case eCSSKeyword_skewx: + case eCSSKeyword_translatex: + ident.Replace(ident.Length() - 1, 1, char16_t('X')); + break; + + case eCSSKeyword_rotatey: + case eCSSKeyword_scaley: + case eCSSKeyword_skewy: + case eCSSKeyword_translatey: + ident.Replace(ident.Length() - 1, 1, char16_t('Y')); + break; + + case eCSSKeyword_rotatez: + case eCSSKeyword_scalez: + case eCSSKeyword_translatez: + ident.Replace(ident.Length() - 1, 1, char16_t('Z')); + break; + + default: + break; + } + nsStyleUtil::AppendEscapedCSSIdent(ident, aResult); + } else { + MOZ_ASSERT(false, "should no longer have non-enumerated functions"); + } + aResult.AppendLiteral("("); + + /* Now, step through the function contents, writing each of them as we go. */ + for (size_t index = 1; index < array->Count(); ++index) { + array->Item(index).AppendToString(aProperty, aResult, + aSerialization); + + /* If we're not at the final element, append a comma. */ + if (index + 1 != array->Count()) + aResult.AppendLiteral(", "); + } + + /* Finally, append the closing parenthesis. */ + aResult.AppendLiteral(")"); + } + else if (IsCalcUnit()) { + NS_ABORT_IF_FALSE(GetUnit() == eCSSUnit_Calc, "unexpected unit"); + CSSValueSerializeCalcOps ops(aProperty, aResult, aSerialization); + css::SerializeCalc(*this, ops); + } + else if (eCSSUnit_Integer == unit) { + aResult.AppendInt(GetIntValue(), 10); + } + else if (eCSSUnit_Enumerated == unit) { + int32_t intValue = GetIntValue(); + switch(aProperty) { + + + case eCSSProperty_text_combine_upright: + if (intValue <= NS_STYLE_TEXT_COMBINE_UPRIGHT_ALL) { + AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue), + aResult); + } else if (intValue == NS_STYLE_TEXT_COMBINE_UPRIGHT_DIGITS_2) { + aResult.AppendLiteral("digits 2"); + } else if (intValue == NS_STYLE_TEXT_COMBINE_UPRIGHT_DIGITS_3) { + aResult.AppendLiteral("digits 3"); + } else { + aResult.AppendLiteral("digits 4"); + } + break; + + case eCSSProperty_text_decoration_line: + if (NS_STYLE_TEXT_DECORATION_LINE_NONE == intValue) { + AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue), + aResult); + } else { + // Ignore the "override all" internal value. + // (It doesn't have a string representation.) + intValue &= ~NS_STYLE_TEXT_DECORATION_LINE_OVERRIDE_ALL; + nsStyleUtil::AppendBitmaskCSSValue( + aProperty, intValue, + NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE, + NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS, + aResult); + } + break; + + case eCSSProperty_marks: + if (intValue == NS_STYLE_PAGE_MARKS_NONE) { + AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue), + aResult); + } else { + nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue, + NS_STYLE_PAGE_MARKS_CROP, + NS_STYLE_PAGE_MARKS_REGISTER, + aResult); + } + break; + + case eCSSProperty_paint_order: + static_assert + (NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8, + "SVGStyleStruct::mPaintOrder and the following cast not big enough"); + nsStyleUtil::AppendPaintOrderValue(static_cast(GetIntValue()), + aResult); + break; + + case eCSSProperty_font_synthesis: + nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue, + NS_FONT_SYNTHESIS_WEIGHT, + NS_FONT_SYNTHESIS_STYLE, + aResult); + break; + + case eCSSProperty_font_variant_east_asian: + nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue, + NS_FONT_VARIANT_EAST_ASIAN_JIS78, + NS_FONT_VARIANT_EAST_ASIAN_RUBY, + aResult); + break; + + case eCSSProperty_font_variant_ligatures: + nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue, + NS_FONT_VARIANT_LIGATURES_NONE, + NS_FONT_VARIANT_LIGATURES_NO_CONTEXTUAL, + aResult); + break; + + case eCSSProperty_font_variant_numeric: + nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue, + NS_FONT_VARIANT_NUMERIC_LINING, + NS_FONT_VARIANT_NUMERIC_ORDINAL, + aResult); + break; + + case eCSSProperty_grid_auto_flow: + nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue, + NS_STYLE_GRID_AUTO_FLOW_NONE, + NS_STYLE_GRID_AUTO_FLOW_DENSE, + aResult); + break; + + case eCSSProperty_grid_auto_position: + case eCSSProperty_grid_column_start: + case eCSSProperty_grid_column_end: + case eCSSProperty_grid_row_start: + case eCSSProperty_grid_row_end: + // "span" is the only enumerated-unit value for these properties + aResult.AppendLiteral("span"); + break; + + case eCSSProperty_touch_action: + nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue, + NS_STYLE_TOUCH_ACTION_NONE, + NS_STYLE_TOUCH_ACTION_MANIPULATION, + aResult); + break; + + default: + const nsAFlatCString& name = nsCSSProps::LookupPropertyValue(aProperty, intValue); + AppendASCIItoUTF16(name, aResult); + break; + } + } + else if (eCSSUnit_EnumColor == unit) { + // we can lookup the property in the ColorTable and then + // get a string mapping the name + nsAutoCString str; + if (nsCSSProps::GetColorName(GetIntValue(), str)){ + AppendASCIItoUTF16(str, aResult); + } else { + NS_ABORT_IF_FALSE(false, "bad color value"); + } + } + else if (IsNumericColorUnit(unit)) { + if (aSerialization == eNormalized || + unit == eCSSUnit_RGBColor || + unit == eCSSUnit_RGBAColor) { + nscolor color = GetColorValue(); + if (aSerialization == eNormalized && + color == NS_RGBA(0, 0, 0, 0)) { + // Use the strictest match for 'transparent' so we do correct + // round-tripping of all other rgba() values. + aResult.AppendLiteral("transparent"); + } else { + uint8_t a = NS_GET_A(color); + bool showAlpha = + (aSerialization == eNormalized && a < 255) || + (aSerialization == eAuthorSpecified && + unit == eCSSUnit_RGBAColor); + if (showAlpha) { + aResult.AppendLiteral("rgba("); + } else { + aResult.AppendLiteral("rgb("); + } + + NS_NAMED_LITERAL_STRING(comma, ", "); + + aResult.AppendInt(NS_GET_R(color), 10); + aResult.Append(comma); + aResult.AppendInt(NS_GET_G(color), 10); + aResult.Append(comma); + aResult.AppendInt(NS_GET_B(color), 10); + if (showAlpha) { + aResult.Append(comma); + aResult.AppendFloat(nsStyleUtil::ColorComponentToFloat(a)); + } + aResult.Append(char16_t(')')); + } + } else if (eCSSUnit_HexColor == unit) { + nscolor color = GetColorValue(); + aResult.Append('#'); + aResult.AppendPrintf("%02x", NS_GET_R(color)); + aResult.AppendPrintf("%02x", NS_GET_G(color)); + aResult.AppendPrintf("%02x", NS_GET_B(color)); + } else if (eCSSUnit_ShortHexColor == unit) { + nscolor color = GetColorValue(); + aResult.Append('#'); + aResult.AppendInt(NS_GET_R(color) / 0x11, 16); + aResult.AppendInt(NS_GET_G(color) / 0x11, 16); + aResult.AppendInt(NS_GET_B(color) / 0x11, 16); + } else { + MOZ_ASSERT(IsFloatColorUnit()); + mValue.mFloatColor->AppendToString(unit, aResult); + } + } + else if (eCSSUnit_URL == unit || eCSSUnit_Image == unit) { + aResult.Append(NS_LITERAL_STRING("url(")); + nsStyleUtil::AppendEscapedCSSString( + nsDependentString(GetOriginalURLValue()), aResult); + aResult.Append(NS_LITERAL_STRING(")")); + } + else if (eCSSUnit_Element == unit) { + aResult.Append(NS_LITERAL_STRING("-moz-element(#")); + nsAutoString tmpStr; + GetStringValue(tmpStr); + nsStyleUtil::AppendEscapedCSSIdent(tmpStr, aResult); + aResult.Append(NS_LITERAL_STRING(")")); + } + else if (eCSSUnit_Percent == unit) { + aResult.AppendFloat(GetPercentValue() * 100.0f); + } + else if (eCSSUnit_Percent < unit) { // length unit + aResult.AppendFloat(GetFloatValue()); + } + else if (eCSSUnit_Gradient == unit) { + nsCSSValueGradient* gradient = GetGradientValue(); + + if (gradient->mIsLegacySyntax) { + aResult.AppendLiteral("-moz-"); + } + if (gradient->mIsRepeating) { + aResult.AppendLiteral("repeating-"); + } + if (gradient->mIsRadial) { + aResult.AppendLiteral("radial-gradient("); + } else { + aResult.AppendLiteral("linear-gradient("); + } + + bool needSep = false; + if (gradient->mIsRadial && !gradient->mIsLegacySyntax) { + if (!gradient->mIsExplicitSize) { + if (gradient->GetRadialShape().GetUnit() != eCSSUnit_None) { + NS_ABORT_IF_FALSE(gradient->GetRadialShape().GetUnit() == + eCSSUnit_Enumerated, + "bad unit for radial gradient shape"); + int32_t intValue = gradient->GetRadialShape().GetIntValue(); + NS_ABORT_IF_FALSE(intValue != NS_STYLE_GRADIENT_SHAPE_LINEAR, + "radial gradient with linear shape?!"); + AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue, + nsCSSProps::kRadialGradientShapeKTable), + aResult); + needSep = true; + } + + if (gradient->GetRadialSize().GetUnit() != eCSSUnit_None) { + if (needSep) { + aResult.AppendLiteral(" "); + } + NS_ABORT_IF_FALSE(gradient->GetRadialSize().GetUnit() == + eCSSUnit_Enumerated, + "bad unit for radial gradient size"); + int32_t intValue = gradient->GetRadialSize().GetIntValue(); + AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue, + nsCSSProps::kRadialGradientSizeKTable), + aResult); + needSep = true; + } + } else { + NS_ABORT_IF_FALSE(gradient->GetRadiusX().GetUnit() != eCSSUnit_None, + "bad unit for radial gradient explicit size"); + gradient->GetRadiusX().AppendToString(aProperty, aResult, + aSerialization); + if (gradient->GetRadiusY().GetUnit() != eCSSUnit_None) { + aResult.AppendLiteral(" "); + gradient->GetRadiusY().AppendToString(aProperty, aResult, + aSerialization); + } + needSep = true; + } + } + if (!gradient->mIsRadial && !gradient->mIsLegacySyntax) { + if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None || + gradient->mBgPos.mYValue.GetUnit() != eCSSUnit_None) { + MOZ_ASSERT(gradient->mAngle.GetUnit() == eCSSUnit_None); + NS_ABORT_IF_FALSE(gradient->mBgPos.mXValue.GetUnit() == eCSSUnit_Enumerated && + gradient->mBgPos.mYValue.GetUnit() == eCSSUnit_Enumerated, + "unexpected unit"); + aResult.AppendLiteral("to"); + if (!(gradient->mBgPos.mXValue.GetIntValue() & NS_STYLE_BG_POSITION_CENTER)) { + aResult.AppendLiteral(" "); + gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position, + aResult, aSerialization); + } + if (!(gradient->mBgPos.mYValue.GetIntValue() & NS_STYLE_BG_POSITION_CENTER)) { + aResult.AppendLiteral(" "); + gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position, + aResult, aSerialization); + } + needSep = true; + } else if (gradient->mAngle.GetUnit() != eCSSUnit_None) { + gradient->mAngle.AppendToString(aProperty, aResult, aSerialization); + needSep = true; + } + } else if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None || + gradient->mBgPos.mYValue.GetUnit() != eCSSUnit_None || + gradient->mAngle.GetUnit() != eCSSUnit_None) { + if (needSep) { + aResult.AppendLiteral(" "); + } + if (gradient->mIsRadial && !gradient->mIsLegacySyntax) { + aResult.AppendLiteral("at "); + } + if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) { + gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position, + aResult, aSerialization); + aResult.AppendLiteral(" "); + } + if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) { + gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position, + aResult, aSerialization); + aResult.AppendLiteral(" "); + } + if (gradient->mAngle.GetUnit() != eCSSUnit_None) { + NS_ABORT_IF_FALSE(gradient->mIsLegacySyntax, + "angle is allowed only for legacy syntax"); + gradient->mAngle.AppendToString(aProperty, aResult, aSerialization); + } + needSep = true; + } + + if (gradient->mIsRadial && gradient->mIsLegacySyntax && + (gradient->GetRadialShape().GetUnit() != eCSSUnit_None || + gradient->GetRadialSize().GetUnit() != eCSSUnit_None)) { + MOZ_ASSERT(!gradient->mIsExplicitSize); + if (needSep) { + aResult.AppendLiteral(", "); + } + if (gradient->GetRadialShape().GetUnit() != eCSSUnit_None) { + NS_ABORT_IF_FALSE(gradient->GetRadialShape().GetUnit() == + eCSSUnit_Enumerated, + "bad unit for radial gradient shape"); + int32_t intValue = gradient->GetRadialShape().GetIntValue(); + NS_ABORT_IF_FALSE(intValue != NS_STYLE_GRADIENT_SHAPE_LINEAR, + "radial gradient with linear shape?!"); + AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue, + nsCSSProps::kRadialGradientShapeKTable), + aResult); + aResult.AppendLiteral(" "); + } + + if (gradient->GetRadialSize().GetUnit() != eCSSUnit_None) { + NS_ABORT_IF_FALSE(gradient->GetRadialSize().GetUnit() == + eCSSUnit_Enumerated, + "bad unit for radial gradient size"); + int32_t intValue = gradient->GetRadialSize().GetIntValue(); + AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue, + nsCSSProps::kRadialGradientSizeKTable), + aResult); + } + needSep = true; + } + if (needSep) { + aResult.AppendLiteral(", "); + } + + for (uint32_t i = 0 ;;) { + gradient->mStops[i].mColor.AppendToString(aProperty, aResult, + aSerialization); + if (gradient->mStops[i].mLocation.GetUnit() != eCSSUnit_None) { + aResult.AppendLiteral(" "); + gradient->mStops[i].mLocation.AppendToString(aProperty, aResult, + aSerialization); + } + if (++i == gradient->mStops.Length()) { + break; + } + aResult.AppendLiteral(", "); + } + + aResult.AppendLiteral(")"); + } else if (eCSSUnit_TokenStream == unit) { + nsCSSProperty shorthand = mValue.mTokenStream->mShorthandPropertyID; + if (shorthand == eCSSProperty_UNKNOWN || + nsCSSProps::PropHasFlags(shorthand, CSS_PROPERTY_IS_ALIAS) || + aProperty == eCSSProperty__x_system_font) { + // We treat serialization of aliases like '-moz-transform' as a special + // case, since it really wants to be serialized as if it were a longhand + // even though it is implemented as a shorthand. + aResult.Append(mValue.mTokenStream->mTokenStream); + } + } else if (eCSSUnit_Pair == unit) { + if (eCSSProperty_font_variant_alternates == aProperty) { + int32_t intValue = GetPairValue().mXValue.GetIntValue(); + nsAutoString out; + + // simple, enumerated values + nsStyleUtil::AppendBitmaskCSSValue(aProperty, + intValue & NS_FONT_VARIANT_ALTERNATES_ENUMERATED_MASK, + NS_FONT_VARIANT_ALTERNATES_HISTORICAL, + NS_FONT_VARIANT_ALTERNATES_HISTORICAL, + out); + + // functional values + const nsCSSValueList *list = GetPairValue().mYValue.GetListValue(); + nsAutoTArray altValues; + + nsStyleUtil::ComputeFunctionalAlternates(list, altValues); + nsStyleUtil::SerializeFunctionalAlternates(altValues, out); + aResult.Append(out); + } else if (eCSSProperty_grid_auto_position == aProperty) { + GetPairValue().mXValue.AppendToString(aProperty, aResult, aSerialization); + aResult.AppendLiteral(" / "); + GetPairValue().mYValue.AppendToString(aProperty, aResult, aSerialization); + } else { + GetPairValue().AppendToString(aProperty, aResult, aSerialization); + } + } else if (eCSSUnit_Triplet == unit) { + GetTripletValue().AppendToString(aProperty, aResult, aSerialization); + } else if (eCSSUnit_Rect == unit) { + GetRectValue().AppendToString(aProperty, aResult, aSerialization); + } else if (eCSSUnit_List == unit || eCSSUnit_ListDep == unit) { + GetListValue()->AppendToString(aProperty, aResult, aSerialization); + } else if (eCSSUnit_SharedList == unit) { + GetSharedListValue()->AppendToString(aProperty, aResult, aSerialization); + } else if (eCSSUnit_PairList == unit || eCSSUnit_PairListDep == unit) { + switch (aProperty) { + case eCSSProperty_font_feature_settings: + nsStyleUtil::AppendFontFeatureSettings(*this, aResult); + break; + default: + GetPairListValue()->AppendToString(aProperty, aResult, aSerialization); + break; + } + } else if (eCSSUnit_GridTemplateAreas == unit) { + const mozilla::css::GridTemplateAreasValue* areas = GetGridTemplateAreas(); + MOZ_ASSERT(!areas->mTemplates.IsEmpty(), + "Unexpected empty array in GridTemplateAreasValue"); + nsStyleUtil::AppendEscapedCSSString(areas->mTemplates[0], aResult); + for (uint32_t i = 1; i < areas->mTemplates.Length(); i++) { + aResult.Append(char16_t(' ')); + nsStyleUtil::AppendEscapedCSSString(areas->mTemplates[i], aResult); + } + } + + switch (unit) { + case eCSSUnit_Null: break; + case eCSSUnit_Auto: aResult.AppendLiteral("auto"); break; + case eCSSUnit_Inherit: aResult.AppendLiteral("inherit"); break; + case eCSSUnit_Initial: aResult.AppendLiteral("initial"); break; + case eCSSUnit_Unset: aResult.AppendLiteral("unset"); break; + case eCSSUnit_None: aResult.AppendLiteral("none"); break; + case eCSSUnit_Normal: aResult.AppendLiteral("normal"); break; + case eCSSUnit_System_Font: aResult.AppendLiteral("-moz-use-system-font"); break; + case eCSSUnit_All: aResult.AppendLiteral("all"); break; + case eCSSUnit_Dummy: + case eCSSUnit_DummyInherit: + NS_ABORT_IF_FALSE(false, "should never serialize"); + break; + + case eCSSUnit_String: break; + case eCSSUnit_Ident: break; + case eCSSUnit_Families: break; + case eCSSUnit_URL: break; + case eCSSUnit_Image: break; + case eCSSUnit_Element: break; + case eCSSUnit_Array: break; + case eCSSUnit_Attr: + case eCSSUnit_Cubic_Bezier: + case eCSSUnit_Steps: + case eCSSUnit_Counter: + case eCSSUnit_Counters: aResult.Append(char16_t(')')); break; + case eCSSUnit_Local_Font: break; + case eCSSUnit_Font_Format: break; + case eCSSUnit_Function: break; + case eCSSUnit_Calc: break; + case eCSSUnit_Calc_Plus: break; + case eCSSUnit_Calc_Minus: break; + case eCSSUnit_Calc_Times_L: break; + case eCSSUnit_Calc_Times_R: break; + case eCSSUnit_Calc_Divided: break; + case eCSSUnit_Integer: break; + case eCSSUnit_Enumerated: break; + case eCSSUnit_EnumColor: break; + case eCSSUnit_RGBColor: break; + case eCSSUnit_RGBAColor: break; + case eCSSUnit_HexColor: break; + case eCSSUnit_ShortHexColor: break; + case eCSSUnit_PercentageRGBColor: break; + case eCSSUnit_PercentageRGBAColor: break; + case eCSSUnit_HSLColor: break; + case eCSSUnit_HSLAColor: break; + case eCSSUnit_Percent: aResult.Append(char16_t('%')); break; + case eCSSUnit_Number: break; + case eCSSUnit_Gradient: break; + case eCSSUnit_TokenStream: break; + case eCSSUnit_Pair: break; + case eCSSUnit_Triplet: break; + case eCSSUnit_Rect: break; + case eCSSUnit_List: break; + case eCSSUnit_ListDep: break; + case eCSSUnit_SharedList: break; + case eCSSUnit_PairList: break; + case eCSSUnit_PairListDep: break; + case eCSSUnit_GridTemplateAreas: break; + + case eCSSUnit_Inch: aResult.AppendLiteral("in"); break; + case eCSSUnit_Millimeter: aResult.AppendLiteral("mm"); break; + case eCSSUnit_PhysicalMillimeter: aResult.AppendLiteral("mozmm"); break; + case eCSSUnit_Centimeter: aResult.AppendLiteral("cm"); break; + case eCSSUnit_Point: aResult.AppendLiteral("pt"); break; + case eCSSUnit_Pica: aResult.AppendLiteral("pc"); break; + + case eCSSUnit_ViewportWidth: aResult.AppendLiteral("vw"); break; + case eCSSUnit_ViewportHeight: aResult.AppendLiteral("vh"); break; + case eCSSUnit_ViewportMin: aResult.AppendLiteral("vmin"); break; + case eCSSUnit_ViewportMax: aResult.AppendLiteral("vmax"); break; + + case eCSSUnit_EM: aResult.AppendLiteral("em"); break; + case eCSSUnit_XHeight: aResult.AppendLiteral("ex"); break; + case eCSSUnit_Char: aResult.AppendLiteral("ch"); break; + case eCSSUnit_RootEM: aResult.AppendLiteral("rem"); break; + + case eCSSUnit_Pixel: aResult.AppendLiteral("px"); break; + + case eCSSUnit_Degree: aResult.AppendLiteral("deg"); break; + case eCSSUnit_Grad: aResult.AppendLiteral("grad"); break; + case eCSSUnit_Radian: aResult.AppendLiteral("rad"); break; + case eCSSUnit_Turn: aResult.AppendLiteral("turn"); break; + + case eCSSUnit_Hertz: aResult.AppendLiteral("Hz"); break; + case eCSSUnit_Kilohertz: aResult.AppendLiteral("kHz"); break; + + case eCSSUnit_Seconds: aResult.Append(char16_t('s')); break; + case eCSSUnit_Milliseconds: aResult.AppendLiteral("ms"); break; + + case eCSSUnit_FlexFraction: aResult.AppendLiteral("fr"); break; + } +} + +size_t +nsCSSValue::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = 0; + + switch (GetUnit()) { + // No value: nothing extra to measure. + case eCSSUnit_Null: + case eCSSUnit_Auto: + case eCSSUnit_Inherit: + case eCSSUnit_Initial: + case eCSSUnit_Unset: + case eCSSUnit_None: + case eCSSUnit_Normal: + case eCSSUnit_System_Font: + case eCSSUnit_All: + case eCSSUnit_Dummy: + case eCSSUnit_DummyInherit: + break; + + // String + case eCSSUnit_String: + case eCSSUnit_Ident: + case eCSSUnit_Families: + case eCSSUnit_Attr: + case eCSSUnit_Local_Font: + case eCSSUnit_Font_Format: + case eCSSUnit_Element: + n += mValue.mString->SizeOfIncludingThisIfUnshared(aMallocSizeOf); + break; + + // Array + case eCSSUnit_Array: + case eCSSUnit_Counter: + case eCSSUnit_Counters: + case eCSSUnit_Cubic_Bezier: + case eCSSUnit_Steps: + case eCSSUnit_Function: + case eCSSUnit_Calc: + case eCSSUnit_Calc_Plus: + case eCSSUnit_Calc_Minus: + case eCSSUnit_Calc_Times_L: + case eCSSUnit_Calc_Times_R: + case eCSSUnit_Calc_Divided: + break; + + // URL + case eCSSUnit_URL: + n += mValue.mURL->SizeOfIncludingThis(aMallocSizeOf); + break; + + // Image + case eCSSUnit_Image: + // Not yet measured. Measurement may be added later if DMD finds it + // worthwhile. + break; + + // Gradient + case eCSSUnit_Gradient: + n += mValue.mGradient->SizeOfIncludingThis(aMallocSizeOf); + break; + + // TokenStream + case eCSSUnit_TokenStream: + n += mValue.mTokenStream->SizeOfIncludingThis(aMallocSizeOf); + break; + + // Pair + case eCSSUnit_Pair: + n += mValue.mPair->SizeOfIncludingThis(aMallocSizeOf); + break; + + // Triplet + case eCSSUnit_Triplet: + n += mValue.mTriplet->SizeOfIncludingThis(aMallocSizeOf); + break; + + // Rect + case eCSSUnit_Rect: + n += mValue.mRect->SizeOfIncludingThis(aMallocSizeOf); + break; + + // List + case eCSSUnit_List: + n += mValue.mList->SizeOfIncludingThis(aMallocSizeOf); + break; + + // ListDep: not measured because it's non-owning. + case eCSSUnit_ListDep: + break; + + // SharedList + case eCSSUnit_SharedList: + // Makes more sense not to measure, since it most cases the list + // will be shared. + break; + + // PairList + case eCSSUnit_PairList: + n += mValue.mPairList->SizeOfIncludingThis(aMallocSizeOf); + break; + + // PairListDep: not measured because it's non-owning. + case eCSSUnit_PairListDep: + break; + + // GridTemplateAreas + case eCSSUnit_GridTemplateAreas: + n += mValue.mGridTemplateAreas->SizeOfIncludingThis(aMallocSizeOf); + break; + + // Int: nothing extra to measure. + case eCSSUnit_Integer: + case eCSSUnit_Enumerated: + case eCSSUnit_EnumColor: + break; + + // Integer Color: nothing extra to measure. + case eCSSUnit_RGBColor: + case eCSSUnit_RGBAColor: + case eCSSUnit_HexColor: + case eCSSUnit_ShortHexColor: + break; + + // Float Color + case eCSSUnit_PercentageRGBColor: + case eCSSUnit_PercentageRGBAColor: + case eCSSUnit_HSLColor: + case eCSSUnit_HSLAColor: + n += mValue.mFloatColor->SizeOfIncludingThis(aMallocSizeOf); + break; + + // Float: nothing extra to measure. + case eCSSUnit_Percent: + case eCSSUnit_Number: + case eCSSUnit_PhysicalMillimeter: + case eCSSUnit_ViewportWidth: + case eCSSUnit_ViewportHeight: + case eCSSUnit_ViewportMin: + case eCSSUnit_ViewportMax: + case eCSSUnit_EM: + case eCSSUnit_XHeight: + case eCSSUnit_Char: + case eCSSUnit_RootEM: + case eCSSUnit_Point: + case eCSSUnit_Inch: + case eCSSUnit_Millimeter: + case eCSSUnit_Centimeter: + case eCSSUnit_Pica: + case eCSSUnit_Pixel: + case eCSSUnit_Degree: + case eCSSUnit_Grad: + case eCSSUnit_Turn: + case eCSSUnit_Radian: + case eCSSUnit_Hertz: + case eCSSUnit_Kilohertz: + case eCSSUnit_Seconds: + case eCSSUnit_Milliseconds: + case eCSSUnit_FlexFraction: + break; + + default: + NS_ABORT_IF_FALSE(false, "bad nsCSSUnit"); + break; + } + + return n; +} + +// --- nsCSSValueList ----------------- + +nsCSSValueList::~nsCSSValueList() +{ + MOZ_COUNT_DTOR(nsCSSValueList); + NS_CSS_DELETE_LIST_MEMBER(nsCSSValueList, this, mNext); +} + +nsCSSValueList* +nsCSSValueList::Clone() const +{ + nsCSSValueList* result = new nsCSSValueList(*this); + nsCSSValueList* dest = result; + const nsCSSValueList* src = this->mNext; + while (src) { + dest->mNext = new nsCSSValueList(*src); + dest = dest->mNext; + src = src->mNext; + } + return result; +} + +void +nsCSSValueList::CloneInto(nsCSSValueList* aList) const +{ + NS_ASSERTION(!aList->mNext, "Must be an empty list!"); + aList->mValue = mValue; + aList->mNext = mNext ? mNext->Clone() : nullptr; +} + +static void +AppendValueListToString(const nsCSSValueList* val, + nsCSSProperty aProperty, nsAString& aResult, + nsCSSValue::Serialization aSerialization) +{ + for (;;) { + val->mValue.AppendToString(aProperty, aResult, aSerialization); + val = val->mNext; + if (!val) + break; + + if (nsCSSProps::PropHasFlags(aProperty, + CSS_PROPERTY_VALUE_LIST_USES_COMMAS)) + aResult.Append(char16_t(',')); + aResult.Append(char16_t(' ')); + } +} + +static void +AppendGridTemplateToString(const nsCSSValueList* val, + nsCSSProperty aProperty, nsAString& aResult, + nsCSSValue::Serialization aSerialization) +{ + // This is called for the "list" that's the top-level value of the property. + bool isSubgrid = false; + for (;;) { + bool addSpaceSeparator = true; + nsCSSUnit unit = val->mValue.GetUnit(); + + if (unit == eCSSUnit_Enumerated && + val->mValue.GetIntValue() == NS_STYLE_GRID_TEMPLATE_SUBGRID) { + isSubgrid = true; + aResult.AppendLiteral("subgrid"); + + } else if (unit == eCSSUnit_Null) { + // Empty or omitted . + if (isSubgrid) { + aResult.AppendLiteral("()"); + } else { + // Serializes to nothing. + addSpaceSeparator = false; // Avoid a double space. + } + + } else if (unit == eCSSUnit_List || unit == eCSSUnit_ListDep) { + // Non-empty + aResult.AppendLiteral("("); + AppendValueListToString(val->mValue.GetListValue(), aProperty, + aResult, aSerialization); + aResult.AppendLiteral(")"); + + } else { + // + val->mValue.AppendToString(aProperty, aResult, aSerialization); + if (!isSubgrid && + val->mNext && + val->mNext->mValue.GetUnit() == eCSSUnit_Null && + !val->mNext->mNext) { + // Break out of the loop early to avoid a trailing space. + break; + } + } + + val = val->mNext; + if (!val) { + break; + } + + if (addSpaceSeparator) { + aResult.Append(char16_t(' ')); + } + } +} + +void +nsCSSValueList::AppendToString(nsCSSProperty aProperty, nsAString& aResult, + nsCSSValue::Serialization aSerialization) const +{ + if (aProperty == eCSSProperty_grid_template_columns || + aProperty == eCSSProperty_grid_template_rows) { + AppendGridTemplateToString(this, aProperty, aResult, aSerialization); + } else { + AppendValueListToString(this, aProperty, aResult, aSerialization); + } +} + +bool +nsCSSValueList::operator==(const nsCSSValueList& aOther) const +{ + if (this == &aOther) + return true; + + const nsCSSValueList *p1 = this, *p2 = &aOther; + for ( ; p1 && p2; p1 = p1->mNext, p2 = p2->mNext) { + if (p1->mValue != p2->mValue) + return false; + } + return !p1 && !p2; // true if same length, false otherwise +} + +size_t +nsCSSValueList::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = 0; + const nsCSSValueList* v = this; + while (v) { + n += aMallocSizeOf(v); + n += v->mValue.SizeOfExcludingThis(aMallocSizeOf); + v = v->mNext; + } + return n; +} + +size_t +nsCSSValueList_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + n += mValue.SizeOfExcludingThis(aMallocSizeOf); + n += mNext ? mNext->SizeOfIncludingThis(aMallocSizeOf) : 0; + return n; +} + +// --- nsCSSValueSharedList ----------------- + +nsCSSValueSharedList::~nsCSSValueSharedList() +{ + MOZ_COUNT_DTOR(nsCSSValueSharedList); + if (mHead) { + NS_CSS_DELETE_LIST_MEMBER(nsCSSValueList, mHead, mNext); + delete mHead; + } +} + +void +nsCSSValueSharedList::AppendToString(nsCSSProperty aProperty, nsAString& aResult, + nsCSSValue::Serialization aSerialization) const +{ + if (mHead) { + mHead->AppendToString(aProperty, aResult, aSerialization); + } +} + +bool +nsCSSValueSharedList::operator==(const nsCSSValueSharedList& aOther) const +{ + return !mHead == !aOther.mHead && + (!mHead || *mHead == *aOther.mHead); +} + +size_t +nsCSSValueSharedList::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = 0; + n += aMallocSizeOf(this); + n += mHead->SizeOfIncludingThis(aMallocSizeOf); + return n; +} + +// --- nsCSSRect ----------------- + +nsCSSRect::nsCSSRect(void) +{ + MOZ_COUNT_CTOR(nsCSSRect); +} + +nsCSSRect::nsCSSRect(const nsCSSRect& aCopy) + : mTop(aCopy.mTop), + mRight(aCopy.mRight), + mBottom(aCopy.mBottom), + mLeft(aCopy.mLeft) +{ + MOZ_COUNT_CTOR(nsCSSRect); +} + +nsCSSRect::~nsCSSRect() +{ + MOZ_COUNT_DTOR(nsCSSRect); +} + +void +nsCSSRect::AppendToString(nsCSSProperty aProperty, nsAString& aResult, + nsCSSValue::Serialization aSerialization) const +{ + NS_ABORT_IF_FALSE(mTop.GetUnit() != eCSSUnit_Null && + mTop.GetUnit() != eCSSUnit_Inherit && + mTop.GetUnit() != eCSSUnit_Initial && + mTop.GetUnit() != eCSSUnit_Unset, + "parser should have used a bare value"); + + if (eCSSProperty_border_image_slice == aProperty || + eCSSProperty_border_image_width == aProperty || + eCSSProperty_border_image_outset == aProperty) { + NS_NAMED_LITERAL_STRING(space, " "); + + mTop.AppendToString(aProperty, aResult, aSerialization); + aResult.Append(space); + mRight.AppendToString(aProperty, aResult, aSerialization); + aResult.Append(space); + mBottom.AppendToString(aProperty, aResult, aSerialization); + aResult.Append(space); + mLeft.AppendToString(aProperty, aResult, aSerialization); + } else { + NS_NAMED_LITERAL_STRING(comma, ", "); + + aResult.AppendLiteral("rect("); + mTop.AppendToString(aProperty, aResult, aSerialization); + aResult.Append(comma); + mRight.AppendToString(aProperty, aResult, aSerialization); + aResult.Append(comma); + mBottom.AppendToString(aProperty, aResult, aSerialization); + aResult.Append(comma); + mLeft.AppendToString(aProperty, aResult, aSerialization); + aResult.Append(char16_t(')')); + } +} + +void nsCSSRect::SetAllSidesTo(const nsCSSValue& aValue) +{ + mTop = aValue; + mRight = aValue; + mBottom = aValue; + mLeft = aValue; +} + +size_t +nsCSSRect_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + n += mTop .SizeOfExcludingThis(aMallocSizeOf); + n += mRight .SizeOfExcludingThis(aMallocSizeOf); + n += mBottom.SizeOfExcludingThis(aMallocSizeOf); + n += mLeft .SizeOfExcludingThis(aMallocSizeOf); + return n; +} + +static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 && + NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3, + "box side constants not top/right/bottom/left == 0/1/2/3"); + +/* static */ const nsCSSRect::side_type nsCSSRect::sides[4] = { + &nsCSSRect::mTop, + &nsCSSRect::mRight, + &nsCSSRect::mBottom, + &nsCSSRect::mLeft, +}; + +// --- nsCSSValuePair ----------------- + +void +nsCSSValuePair::AppendToString(nsCSSProperty aProperty, + nsAString& aResult, + nsCSSValue::Serialization aSerialization) const +{ + mXValue.AppendToString(aProperty, aResult, aSerialization); + if (mYValue.GetUnit() != eCSSUnit_Null) { + aResult.Append(char16_t(' ')); + mYValue.AppendToString(aProperty, aResult, aSerialization); + } +} + +size_t +nsCSSValuePair::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = 0; + n += mXValue.SizeOfExcludingThis(aMallocSizeOf); + n += mYValue.SizeOfExcludingThis(aMallocSizeOf); + return n; +} + +size_t +nsCSSValuePair_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + n += mXValue.SizeOfExcludingThis(aMallocSizeOf); + n += mYValue.SizeOfExcludingThis(aMallocSizeOf); + return n; +} + +// --- nsCSSValueTriplet ----------------- + +void +nsCSSValueTriplet::AppendToString(nsCSSProperty aProperty, + nsAString& aResult, + nsCSSValue::Serialization aSerialization) const +{ + mXValue.AppendToString(aProperty, aResult, aSerialization); + if (mYValue.GetUnit() != eCSSUnit_Null) { + aResult.Append(char16_t(' ')); + mYValue.AppendToString(aProperty, aResult, aSerialization); + if (mZValue.GetUnit() != eCSSUnit_Null) { + aResult.Append(char16_t(' ')); + mZValue.AppendToString(aProperty, aResult, aSerialization); + } + } +} + +size_t +nsCSSValueTriplet_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + n += mXValue.SizeOfExcludingThis(aMallocSizeOf); + n += mYValue.SizeOfExcludingThis(aMallocSizeOf); + n += mZValue.SizeOfExcludingThis(aMallocSizeOf); + return n; +} + +// --- nsCSSValuePairList ----------------- + +nsCSSValuePairList::~nsCSSValuePairList() +{ + MOZ_COUNT_DTOR(nsCSSValuePairList); + NS_CSS_DELETE_LIST_MEMBER(nsCSSValuePairList, this, mNext); +} + +nsCSSValuePairList* +nsCSSValuePairList::Clone() const +{ + nsCSSValuePairList* result = new nsCSSValuePairList(*this); + nsCSSValuePairList* dest = result; + const nsCSSValuePairList* src = this->mNext; + while (src) { + dest->mNext = new nsCSSValuePairList(*src); + dest = dest->mNext; + src = src->mNext; + } + return result; +} + +void +nsCSSValuePairList::AppendToString(nsCSSProperty aProperty, + nsAString& aResult, + nsCSSValue::Serialization aSerialization) const +{ + const nsCSSValuePairList* item = this; + for (;;) { + NS_ABORT_IF_FALSE(item->mXValue.GetUnit() != eCSSUnit_Null, + "unexpected null unit"); + item->mXValue.AppendToString(aProperty, aResult, aSerialization); + if (item->mXValue.GetUnit() != eCSSUnit_Inherit && + item->mXValue.GetUnit() != eCSSUnit_Initial && + item->mXValue.GetUnit() != eCSSUnit_Unset && + item->mYValue.GetUnit() != eCSSUnit_Null) { + aResult.Append(char16_t(' ')); + item->mYValue.AppendToString(aProperty, aResult, aSerialization); + } + item = item->mNext; + if (!item) + break; + + if (nsCSSProps::PropHasFlags(aProperty, + CSS_PROPERTY_VALUE_LIST_USES_COMMAS)) + aResult.Append(char16_t(',')); + aResult.Append(char16_t(' ')); + } +} + +bool +nsCSSValuePairList::operator==(const nsCSSValuePairList& aOther) const +{ + if (this == &aOther) + return true; + + const nsCSSValuePairList *p1 = this, *p2 = &aOther; + for ( ; p1 && p2; p1 = p1->mNext, p2 = p2->mNext) { + if (p1->mXValue != p2->mXValue || + p1->mYValue != p2->mYValue) + return false; + } + return !p1 && !p2; // true if same length, false otherwise +} + +size_t +nsCSSValuePairList::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = 0; + const nsCSSValuePairList* v = this; + while (v) { + n += aMallocSizeOf(v); + n += v->mXValue.SizeOfExcludingThis(aMallocSizeOf); + n += v->mYValue.SizeOfExcludingThis(aMallocSizeOf); + v = v->mNext; + } + return n; +} + +size_t +nsCSSValuePairList_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + n += mXValue.SizeOfExcludingThis(aMallocSizeOf); + n += mYValue.SizeOfExcludingThis(aMallocSizeOf); + n += mNext ? mNext->SizeOfIncludingThis(aMallocSizeOf) : 0; + return n; +} + +size_t +nsCSSValue::Array::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + for (size_t i = 0; i < mCount; i++) { + n += mArray[i].SizeOfExcludingThis(aMallocSizeOf); + } + return n; +} + +css::URLValue::URLValue(nsIURI* aURI, nsStringBuffer* aString, + nsIURI* aReferrer, nsIPrincipal* aOriginPrincipal) + : mURI(aURI), + mString(aString), + mReferrer(aReferrer), + mOriginPrincipal(aOriginPrincipal), + mURIResolved(true) +{ + NS_ABORT_IF_FALSE(aOriginPrincipal, "Must have an origin principal"); + mString->AddRef(); +} + +css::URLValue::URLValue(nsStringBuffer* aString, nsIURI* aBaseURI, + nsIURI* aReferrer, nsIPrincipal* aOriginPrincipal) + : mURI(aBaseURI), + mString(aString), + mReferrer(aReferrer), + mOriginPrincipal(aOriginPrincipal), + mURIResolved(false) +{ + NS_ABORT_IF_FALSE(aOriginPrincipal, "Must have an origin principal"); + mString->AddRef(); +} + +css::URLValue::~URLValue() +{ + mString->Release(); +} + +bool +css::URLValue::operator==(const URLValue& aOther) const +{ + bool eq; + return NS_strcmp(nsCSSValue::GetBufferValue(mString), + nsCSSValue::GetBufferValue(aOther.mString)) == 0 && + (GetURI() == aOther.GetURI() || // handles null == null + (mURI && aOther.mURI && + NS_SUCCEEDED(mURI->Equals(aOther.mURI, &eq)) && + eq)) && + (mOriginPrincipal == aOther.mOriginPrincipal || + (NS_SUCCEEDED(mOriginPrincipal->Equals(aOther.mOriginPrincipal, + &eq)) && eq)); +} + +bool +css::URLValue::URIEquals(const URLValue& aOther) const +{ + NS_ABORT_IF_FALSE(mURIResolved && aOther.mURIResolved, + "How do you know the URIs aren't null?"); + bool eq; + // Worth comparing GetURI() to aOther.GetURI() and mOriginPrincipal to + // aOther.mOriginPrincipal, because in the (probably common) case when this + // value was one of the ones that in fact did not change this will be our + // fast path to equality + return (mURI == aOther.mURI || + (NS_SUCCEEDED(mURI->Equals(aOther.mURI, &eq)) && eq)) && + (mOriginPrincipal == aOther.mOriginPrincipal || + (NS_SUCCEEDED(mOriginPrincipal->Equals(aOther.mOriginPrincipal, + &eq)) && eq)); +} + +nsIURI* +css::URLValue::GetURI() const +{ + if (!mURIResolved) { + mURIResolved = true; + // Be careful to not null out mURI before we've passed it as the base URI + nsCOMPtr newURI; + NS_NewURI(getter_AddRefs(newURI), + NS_ConvertUTF16toUTF8(nsCSSValue::GetBufferValue(mString)), + nullptr, mURI); + newURI.swap(mURI); + } + + return mURI; +} + +size_t +css::URLValue::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + + // This string is unshared. + n += mString->SizeOfIncludingThisMustBeUnshared(aMallocSizeOf); + + // Measurement of the following members may be added later if DMD finds it is + // worthwhile: + // - mURI + // - mReferrer + // - mOriginPrincipal + + return n; +} + + +css::ImageValue::ImageValue(nsIURI* aURI, nsStringBuffer* aString, + nsIURI* aReferrer, nsIPrincipal* aOriginPrincipal, + nsIDocument* aDocument) + : URLValue(aURI, aString, aReferrer, aOriginPrincipal) +{ + // NB: If aDocument is not the original document, we may not be able to load + // images from aDocument. Instead we do the image load from the original doc + // and clone it to aDocument. + nsIDocument* loadingDoc = aDocument->GetOriginalDocument(); + if (!loadingDoc) { + loadingDoc = aDocument; + } + + loadingDoc->StyleImageLoader()->LoadImage(aURI, aOriginPrincipal, aReferrer, + this); + + if (loadingDoc != aDocument) { + aDocument->StyleImageLoader()->MaybeRegisterCSSImage(this); + } +} + +static PLDHashOperator +ClearRequestHashtable(nsISupports* aKey, nsRefPtr& aValue, + void* aClosure) +{ + mozilla::css::ImageValue* image = + static_cast(aClosure); + nsIDocument* doc = static_cast(aKey); + +#ifdef DEBUG + { + nsCOMPtr slowDoc = do_QueryInterface(aKey); + MOZ_ASSERT(slowDoc == doc); + } +#endif + + if (doc) { + doc->StyleImageLoader()->DeregisterCSSImage(image); + } + + if (aValue) { + aValue->CancelAndForgetObserver(NS_BINDING_ABORTED); + } + + return PL_DHASH_REMOVE; +} + +css::ImageValue::~ImageValue() +{ + mRequests.Enumerate(&ClearRequestHashtable, this); +} + +nsCSSValueGradientStop::nsCSSValueGradientStop() + : mLocation(eCSSUnit_None), + mColor(eCSSUnit_Null) +{ + MOZ_COUNT_CTOR(nsCSSValueGradientStop); +} + +nsCSSValueGradientStop::nsCSSValueGradientStop(const nsCSSValueGradientStop& aOther) + : mLocation(aOther.mLocation), + mColor(aOther.mColor) +{ + MOZ_COUNT_CTOR(nsCSSValueGradientStop); +} + +nsCSSValueGradientStop::~nsCSSValueGradientStop() +{ + MOZ_COUNT_DTOR(nsCSSValueGradientStop); +} + +size_t +nsCSSValueGradientStop::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = 0; + n += mLocation.SizeOfExcludingThis(aMallocSizeOf); + n += mColor .SizeOfExcludingThis(aMallocSizeOf); + return n; +} + +nsCSSValueGradient::nsCSSValueGradient(bool aIsRadial, + bool aIsRepeating) + : mIsRadial(aIsRadial), + mIsRepeating(aIsRepeating), + mIsLegacySyntax(false), + mIsExplicitSize(false), + mBgPos(eCSSUnit_None), + mAngle(eCSSUnit_None) +{ + mRadialValues[0].SetNoneValue(); + mRadialValues[1].SetNoneValue(); +} + +size_t +nsCSSValueGradient::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + n += mBgPos.SizeOfExcludingThis(aMallocSizeOf); + n += mAngle.SizeOfExcludingThis(aMallocSizeOf); + n += mRadialValues[0].SizeOfExcludingThis(aMallocSizeOf); + n += mRadialValues[1].SizeOfExcludingThis(aMallocSizeOf); + n += mStops.SizeOfExcludingThis(aMallocSizeOf); + for (uint32_t i = 0; i < mStops.Length(); i++) { + n += mStops[i].SizeOfExcludingThis(aMallocSizeOf); + } + return n; +} + +// --- nsCSSValueTokenStream ------------ + +nsCSSValueTokenStream::nsCSSValueTokenStream() + : mPropertyID(eCSSProperty_UNKNOWN) + , mShorthandPropertyID(eCSSProperty_UNKNOWN) +{ + MOZ_COUNT_CTOR(nsCSSValueTokenStream); +} + +nsCSSValueTokenStream::~nsCSSValueTokenStream() +{ + MOZ_COUNT_DTOR(nsCSSValueTokenStream); +} + +size_t +nsCSSValueTokenStream::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + n += mTokenStream.SizeOfExcludingThisIfUnshared(aMallocSizeOf); + return n; +} + +// --- nsCSSValueFloatColor ------------- + +bool +nsCSSValueFloatColor::operator==(nsCSSValueFloatColor& aOther) const +{ + return mComponent1 == aOther.mComponent1 && + mComponent2 == aOther.mComponent2 && + mComponent3 == aOther.mComponent3 && + mAlpha == aOther.mAlpha; +} + +nscolor +nsCSSValueFloatColor::GetColorValue(nsCSSUnit aUnit) const +{ + MOZ_ASSERT(nsCSSValue::IsFloatColorUnit(aUnit), "unexpected unit"); + + if (aUnit == eCSSUnit_PercentageRGBColor || + aUnit == eCSSUnit_PercentageRGBAColor) { + return NS_RGBA(NSToIntRound(mComponent1 * 255.0f), + NSToIntRound(mComponent2 * 255.0f), + NSToIntRound(mComponent3 * 255.0f), + NSToIntRound(mAlpha * 255.0f)); + } + + // HSL color + MOZ_ASSERT(aUnit == eCSSUnit_HSLColor || + aUnit == eCSSUnit_HSLAColor); + nscolor hsl = NS_HSL2RGB(mComponent1, mComponent2, mComponent3); + return NS_RGBA(NS_GET_R(hsl), + NS_GET_G(hsl), + NS_GET_B(hsl), + NSToIntRound(mAlpha * 255.0f)); +} + +bool +nsCSSValueFloatColor::IsNonTransparentColor() const +{ + return mAlpha > 0.0f; +} + +void +nsCSSValueFloatColor::AppendToString(nsCSSUnit aUnit, nsAString& aResult) const +{ + MOZ_ASSERT(nsCSSValue::IsFloatColorUnit(aUnit), "unexpected unit"); + + bool hasAlpha = aUnit == eCSSUnit_PercentageRGBAColor || + aUnit == eCSSUnit_HSLAColor; + bool isHSL = aUnit == eCSSUnit_HSLColor || + aUnit == eCSSUnit_HSLAColor; + + if (isHSL) { + aResult.AppendLiteral("hsl"); + } else { + aResult.AppendLiteral("rgb"); + } + if (hasAlpha) { + aResult.AppendLiteral("a("); + } else { + aResult.Append('('); + } + if (isHSL) { + aResult.AppendFloat(mComponent1 * 360.0f); + aResult.AppendLiteral(", "); + } else { + aResult.AppendFloat(mComponent1 * 100.0f); + aResult.AppendLiteral("%, "); + } + aResult.AppendFloat(mComponent2 * 100.0f); + aResult.AppendLiteral("%, "); + aResult.AppendFloat(mComponent3 * 100.0f); + if (hasAlpha) { + aResult.AppendLiteral("%, "); + aResult.AppendFloat(mAlpha); + aResult.Append(')'); + } else { + aResult.AppendLiteral("%)"); + } +} + +size_t +nsCSSValueFloatColor::SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = aMallocSizeOf(this); + return n; +} + +// --- nsCSSCornerSizes ----------------- + +nsCSSCornerSizes::nsCSSCornerSizes(void) +{ + MOZ_COUNT_CTOR(nsCSSCornerSizes); +} + +nsCSSCornerSizes::nsCSSCornerSizes(const nsCSSCornerSizes& aCopy) + : mTopLeft(aCopy.mTopLeft), + mTopRight(aCopy.mTopRight), + mBottomRight(aCopy.mBottomRight), + mBottomLeft(aCopy.mBottomLeft) +{ + MOZ_COUNT_CTOR(nsCSSCornerSizes); +} + +nsCSSCornerSizes::~nsCSSCornerSizes() +{ + MOZ_COUNT_DTOR(nsCSSCornerSizes); +} + +void +nsCSSCornerSizes::Reset() +{ + NS_FOR_CSS_FULL_CORNERS(corner) { + this->GetCorner(corner).Reset(); + } +} + +static_assert(NS_CORNER_TOP_LEFT == 0 && NS_CORNER_TOP_RIGHT == 1 && + NS_CORNER_BOTTOM_RIGHT == 2 && NS_CORNER_BOTTOM_LEFT == 3, + "box corner constants not tl/tr/br/bl == 0/1/2/3"); + +/* static */ const nsCSSCornerSizes::corner_type +nsCSSCornerSizes::corners[4] = { + &nsCSSCornerSizes::mTopLeft, + &nsCSSCornerSizes::mTopRight, + &nsCSSCornerSizes::mBottomRight, + &nsCSSCornerSizes::mBottomLeft, +}; + +size_t +mozilla::css::GridTemplateAreasValue::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const +{ + size_t n = mNamedAreas.SizeOfExcludingThis(aMallocSizeOf); + n += mTemplates.SizeOfIncludingThis(aMallocSizeOf); + return n; +}