/* -*- 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/. */ /* Utilities for animation of computed style values */ #include "mozilla/ArrayUtils.h" #include "mozilla/MathAlgorithms.h" #include "mozilla/RuleNodeCacheConditions.h" #include "mozilla/StyleAnimationValue.h" #include "mozilla/Tuple.h" #include "mozilla/UniquePtr.h" #include "nsStyleTransformMatrix.h" #include "nsAutoPtr.h" #include "nsCOMArray.h" #include "nsIStyleRule.h" #include "mozilla/css/StyleRule.h" #include "nsString.h" #include "nsStyleContext.h" #include "nsStyleSet.h" #include "nsComputedDOMStyle.h" #include "nsCSSParser.h" #include "nsCSSPseudoElements.h" #include "mozilla/css/Declaration.h" #include "mozilla/dom/Element.h" #include "mozilla/FloatingPoint.h" #include "mozilla/Likely.h" #include "mozilla/ServoBindings.h" // RawServoDeclarationBlock #include "gfxMatrix.h" #include "gfxQuaternion.h" #include "nsIDocument.h" #include "nsIFrame.h" #include "gfx2DGlue.h" using namespace mozilla; using namespace mozilla::css; using namespace mozilla::gfx; using nsStyleTransformMatrix::Decompose2DMatrix; using nsStyleTransformMatrix::Decompose3DMatrix; using nsStyleTransformMatrix::ShearType; // HELPER METHODS // -------------- /* * Given two units, this method returns a common unit that they can both be * converted into, if possible. This is intended to facilitate * interpolation, distance-computation, and addition between "similar" units. * * The ordering of the arguments should not affect the output of this method. * * If there's no sensible common unit, this method returns eUnit_Null. * * @param aFirstUnit One unit to resolve. * @param aFirstUnit The other unit to resolve. * @return A "common" unit that both source units can be converted into, or * eUnit_Null if that's not possible. */ static StyleAnimationValue::Unit GetCommonUnit(nsCSSPropertyID aProperty, StyleAnimationValue::Unit aFirstUnit, StyleAnimationValue::Unit aSecondUnit) { if (aFirstUnit != aSecondUnit) { if (nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_STORES_CALC) && (aFirstUnit == StyleAnimationValue::eUnit_Coord || aFirstUnit == StyleAnimationValue::eUnit_Percent || aFirstUnit == StyleAnimationValue::eUnit_Calc) && (aSecondUnit == StyleAnimationValue::eUnit_Coord || aSecondUnit == StyleAnimationValue::eUnit_Percent || aSecondUnit == StyleAnimationValue::eUnit_Calc)) { // We can use calc() as the common unit. return StyleAnimationValue::eUnit_Calc; } if ((aFirstUnit == StyleAnimationValue::eUnit_Color || aFirstUnit == StyleAnimationValue::eUnit_CurrentColor || aFirstUnit == StyleAnimationValue::eUnit_ComplexColor) && (aSecondUnit == StyleAnimationValue::eUnit_Color || aSecondUnit == StyleAnimationValue::eUnit_CurrentColor || aSecondUnit == StyleAnimationValue::eUnit_ComplexColor)) { // We can use complex color as the common unit. return StyleAnimationValue::eUnit_ComplexColor; } return StyleAnimationValue::eUnit_Null; } return aFirstUnit; } static nsCSSUnit GetCommonUnit(nsCSSPropertyID aProperty, nsCSSUnit aFirstUnit, nsCSSUnit aSecondUnit) { if (aFirstUnit != aSecondUnit) { if (nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_STORES_CALC) && (aFirstUnit == eCSSUnit_Pixel || aFirstUnit == eCSSUnit_Percent || aFirstUnit == eCSSUnit_Calc) && (aSecondUnit == eCSSUnit_Pixel || aSecondUnit == eCSSUnit_Percent || aSecondUnit == eCSSUnit_Calc)) { // We can use calc() as the common unit. return eCSSUnit_Calc; } return eCSSUnit_Null; } return aFirstUnit; } static nsCSSKeyword ToPrimitive(nsCSSKeyword aKeyword) { switch (aKeyword) { case eCSSKeyword_translatex: case eCSSKeyword_translatey: case eCSSKeyword_translatez: case eCSSKeyword_translate: return eCSSKeyword_translate3d; case eCSSKeyword_scalex: case eCSSKeyword_scaley: case eCSSKeyword_scalez: case eCSSKeyword_scale: return eCSSKeyword_scale3d; default: return aKeyword; } } static bool TransformFunctionsMatch(nsCSSKeyword func1, nsCSSKeyword func2) { return ToPrimitive(func1) == ToPrimitive(func2); } static already_AddRefed<nsCSSValue::Array> AppendFunction(nsCSSKeyword aTransformFunction) { uint32_t nargs; switch (aTransformFunction) { case eCSSKeyword_matrix3d: nargs = 16; break; case eCSSKeyword_matrix: nargs = 6; break; case eCSSKeyword_rotate3d: nargs = 4; break; case eCSSKeyword_interpolatematrix: case eCSSKeyword_translate3d: case eCSSKeyword_scale3d: nargs = 3; break; case eCSSKeyword_translate: case eCSSKeyword_skew: case eCSSKeyword_scale: nargs = 2; break; default: NS_ERROR("must be a transform function"); MOZ_FALLTHROUGH; case eCSSKeyword_translatex: case eCSSKeyword_translatey: case eCSSKeyword_translatez: case eCSSKeyword_scalex: case eCSSKeyword_scaley: case eCSSKeyword_scalez: case eCSSKeyword_skewx: case eCSSKeyword_skewy: case eCSSKeyword_rotate: case eCSSKeyword_rotatex: case eCSSKeyword_rotatey: case eCSSKeyword_rotatez: case eCSSKeyword_perspective: nargs = 1; break; } RefPtr<nsCSSValue::Array> arr = nsCSSValue::Array::Create(nargs + 1); arr->Item(0).SetIntValue(aTransformFunction, eCSSUnit_Enumerated); return arr.forget(); } static already_AddRefed<nsCSSValue::Array> ToPrimitive(nsCSSValue::Array* aArray) { nsCSSKeyword tfunc = nsStyleTransformMatrix::TransformFunctionOf(aArray); nsCSSKeyword primitive = ToPrimitive(tfunc); RefPtr<nsCSSValue::Array> arr = AppendFunction(primitive); // FIXME: This would produce fewer calc() expressions if the // zero were of compatible type (length vs. percent) when // needed. nsCSSValue zero(0.0f, eCSSUnit_Pixel); nsCSSValue one(1.0f, eCSSUnit_Number); switch(tfunc) { case eCSSKeyword_translate: { MOZ_ASSERT(aArray->Count() == 2 || aArray->Count() == 3, "unexpected count"); arr->Item(1) = aArray->Item(1); arr->Item(2) = aArray->Count() == 3 ? aArray->Item(2) : zero; arr->Item(3) = zero; break; } case eCSSKeyword_translatex: { MOZ_ASSERT(aArray->Count() == 2, "unexpected count"); arr->Item(1) = aArray->Item(1); arr->Item(2) = zero; arr->Item(3) = zero; break; } case eCSSKeyword_translatey: { MOZ_ASSERT(aArray->Count() == 2, "unexpected count"); arr->Item(1) = zero; arr->Item(2) = aArray->Item(1); arr->Item(3) = zero; break; } case eCSSKeyword_translatez: { MOZ_ASSERT(aArray->Count() == 2, "unexpected count"); arr->Item(1) = zero; arr->Item(2) = zero; arr->Item(3) = aArray->Item(1); break; } case eCSSKeyword_scale: { MOZ_ASSERT(aArray->Count() == 2 || aArray->Count() == 3, "unexpected count"); arr->Item(1) = aArray->Item(1); arr->Item(2) = aArray->Count() == 3 ? aArray->Item(2) : aArray->Item(1); arr->Item(3) = one; break; } case eCSSKeyword_scalex: { MOZ_ASSERT(aArray->Count() == 2, "unexpected count"); arr->Item(1) = aArray->Item(1); arr->Item(2) = one; arr->Item(3) = one; break; } case eCSSKeyword_scaley: { MOZ_ASSERT(aArray->Count() == 2, "unexpected count"); arr->Item(1) = one; arr->Item(2) = aArray->Item(1); arr->Item(3) = one; break; } case eCSSKeyword_scalez: { MOZ_ASSERT(aArray->Count() == 2, "unexpected count"); arr->Item(1) = one; arr->Item(2) = one; arr->Item(3) = aArray->Item(1); break; } default: arr = aArray; } return arr.forget(); } static void AppendCSSShadowValue(const nsCSSShadowItem *aShadow, nsCSSValueList **&aResultTail) { MOZ_ASSERT(aShadow, "shadow expected"); // X, Y, Radius, Spread, Color, Inset RefPtr<nsCSSValue::Array> arr = nsCSSValue::Array::Create(6); arr->Item(0).SetIntegerCoordValue(aShadow->mXOffset); arr->Item(1).SetIntegerCoordValue(aShadow->mYOffset); arr->Item(2).SetIntegerCoordValue(aShadow->mRadius); // NOTE: This code sometimes stores mSpread: 0 even when // the parser would be required to leave it null. arr->Item(3).SetIntegerCoordValue(aShadow->mSpread); if (aShadow->mHasColor) { arr->Item(4).SetColorValue(aShadow->mColor); } if (aShadow->mInset) { arr->Item(5).SetIntValue(uint8_t(StyleBoxShadowType::Inset), eCSSUnit_Enumerated); } nsCSSValueList *resultItem = new nsCSSValueList; resultItem->mValue.SetArrayValue(arr, eCSSUnit_Array); *aResultTail = resultItem; aResultTail = &resultItem->mNext; } // Like nsStyleCoord::CalcValue, but with length in float pixels instead // of nscoord. struct PixelCalcValue { float mLength, mPercent; bool mHasPercent; }; // Requires a canonical calc() value that we generated. static PixelCalcValue ExtractCalcValueInternal(const nsCSSValue& aValue) { MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Calc, "unexpected unit"); nsCSSValue::Array *arr = aValue.GetArrayValue(); MOZ_ASSERT(arr->Count() == 1, "unexpected length"); const nsCSSValue &topval = arr->Item(0); PixelCalcValue result; if (topval.GetUnit() == eCSSUnit_Pixel) { result.mLength = topval.GetFloatValue(); result.mPercent = 0.0f; result.mHasPercent = false; } else { MOZ_ASSERT(topval.GetUnit() == eCSSUnit_Calc_Plus, "unexpected unit"); nsCSSValue::Array *arr2 = topval.GetArrayValue(); const nsCSSValue &len = arr2->Item(0); const nsCSSValue &pct = arr2->Item(1); MOZ_ASSERT(len.GetUnit() == eCSSUnit_Pixel, "unexpected unit"); MOZ_ASSERT(pct.GetUnit() == eCSSUnit_Percent, "unexpected unit"); result.mLength = len.GetFloatValue(); result.mPercent = pct.GetPercentValue(); result.mHasPercent = true; } return result; } // Requires a canonical calc() value that we generated. static PixelCalcValue ExtractCalcValue(const StyleAnimationValue& aValue) { PixelCalcValue result; if (aValue.GetUnit() == StyleAnimationValue::eUnit_Coord) { result.mLength = nsPresContext::AppUnitsToFloatCSSPixels(aValue.GetCoordValue()); result.mPercent = 0.0f; result.mHasPercent = false; return result; } if (aValue.GetUnit() == StyleAnimationValue::eUnit_Percent) { result.mLength = 0.0f; result.mPercent = aValue.GetPercentValue(); result.mHasPercent = true; return result; } MOZ_ASSERT(aValue.GetUnit() == StyleAnimationValue::eUnit_Calc, "unexpected unit"); nsCSSValue *val = aValue.GetCSSValueValue(); return ExtractCalcValueInternal(*val); } static PixelCalcValue ExtractCalcValue(const nsCSSValue& aValue) { PixelCalcValue result; if (aValue.GetUnit() == eCSSUnit_Pixel) { result.mLength = aValue.GetFloatValue(); result.mPercent = 0.0f; result.mHasPercent = false; return result; } if (aValue.GetUnit() == eCSSUnit_Percent) { result.mLength = 0.0f; result.mPercent = aValue.GetPercentValue(); result.mHasPercent = true; return result; } return ExtractCalcValueInternal(aValue); } static void CalcValueToCSSValue(const nsStyleCoord::CalcValue* aCalc, nsCSSValue& aValue) { aValue.SetCalcValue(aCalc); } static void CalcValueToCSSValue(const PixelCalcValue& aCalc, nsCSSValue& aValue) { RefPtr<nsCSSValue::Array> arr = nsCSSValue::Array::Create(1); if (!aCalc.mHasPercent) { arr->Item(0).SetFloatValue(aCalc.mLength, eCSSUnit_Pixel); } else { nsCSSValue::Array *arr2 = nsCSSValue::Array::Create(2); arr->Item(0).SetArrayValue(arr2, eCSSUnit_Calc_Plus); arr2->Item(0).SetFloatValue(aCalc.mLength, eCSSUnit_Pixel); arr2->Item(1).SetPercentValue(aCalc.mPercent); } aValue.SetArrayValue(arr, eCSSUnit_Calc); } double CalcPositionSquareDistance(const nsCSSValue& aPos1, const nsCSSValue& aPos2) { NS_ASSERTION(aPos1.GetUnit() == eCSSUnit_Array && aPos2.GetUnit() == eCSSUnit_Array, "Expected two arrays"); PixelCalcValue calcVal[4]; nsCSSValue::Array* posArray = aPos1.GetArrayValue(); MOZ_ASSERT(posArray->Count() == 4, "Invalid position value"); NS_ASSERTION(posArray->Item(0).GetUnit() == eCSSUnit_Null && posArray->Item(2).GetUnit() == eCSSUnit_Null, "Invalid list used"); for (int i = 0; i < 2; ++i) { MOZ_ASSERT(posArray->Item(i*2+1).GetUnit() != eCSSUnit_Null, "Invalid position value"); calcVal[i] = ExtractCalcValue(posArray->Item(i*2+1)); } posArray = aPos2.GetArrayValue(); MOZ_ASSERT(posArray->Count() == 4, "Invalid position value"); NS_ASSERTION(posArray->Item(0).GetUnit() == eCSSUnit_Null && posArray->Item(2).GetUnit() == eCSSUnit_Null, "Invalid list used"); for (int i = 0; i < 2; ++i) { MOZ_ASSERT(posArray->Item(i*2+1).GetUnit() != eCSSUnit_Null, "Invalid position value"); calcVal[i+2] = ExtractCalcValue(posArray->Item(i*2+1)); } double squareDistance = 0.0; for (int i = 0; i < 2; ++i) { float difflen = calcVal[i+2].mLength - calcVal[i].mLength; float diffpct = calcVal[i+2].mPercent - calcVal[i].mPercent; squareDistance += difflen * difflen + diffpct * diffpct; } return squareDistance; } static PixelCalcValue CalcBackgroundCoord(const nsCSSValue& aCoord) { NS_ASSERTION(aCoord.GetUnit() == eCSSUnit_Array, "Expected array"); nsCSSValue::Array* array = aCoord.GetArrayValue(); MOZ_ASSERT(array->Count() == 2 && array->Item(0).GetUnit() == eCSSUnit_Null && array->Item(1).GetUnit() != eCSSUnit_Null, "Invalid position value"); return ExtractCalcValue(array->Item(1)); } double CalcPositionCoordSquareDistance(const nsCSSValue& aPos1, const nsCSSValue& aPos2) { PixelCalcValue calcVal1 = CalcBackgroundCoord(aPos1); PixelCalcValue calcVal2 = CalcBackgroundCoord(aPos2); float difflen = calcVal2.mLength - calcVal1.mLength; float diffpct = calcVal2.mPercent - calcVal1.mPercent; return difflen * difflen + diffpct * diffpct; } // Ensure that a float/double value isn't NaN by returning zero instead // (NaN doesn't have a sign) as a general restriction for floating point // values in RestrictValue. template<typename T> MOZ_ALWAYS_INLINE T EnsureNotNan(T aValue) { return aValue; } template<> MOZ_ALWAYS_INLINE float EnsureNotNan(float aValue) { // This would benefit from a MOZ_FLOAT_IS_NaN if we had one. return MOZ_LIKELY(!mozilla::IsNaN(aValue)) ? aValue : 0; } template<> MOZ_ALWAYS_INLINE double EnsureNotNan(double aValue) { return MOZ_LIKELY(!mozilla::IsNaN(aValue)) ? aValue : 0; } template <typename T> T RestrictValue(uint32_t aRestrictions, T aValue) { T result = EnsureNotNan(aValue); switch (aRestrictions) { case 0: break; case CSS_PROPERTY_VALUE_NONNEGATIVE: if (result < 0) { result = 0; } break; case CSS_PROPERTY_VALUE_AT_LEAST_ONE: if (result < 1) { result = 1; } break; default: MOZ_ASSERT(false, "bad value restriction"); break; } return result; } template <typename T> T RestrictValue(nsCSSPropertyID aProperty, T aValue) { return RestrictValue(nsCSSProps::ValueRestrictions(aProperty), aValue); } static void AddCSSValueAngle(double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult) { if (aValue1.GetUnit() == aValue2.GetUnit()) { // To avoid floating point error, if the units match, maintain the unit. aResult.SetFloatValue( EnsureNotNan(aCoeff1 * aValue1.GetFloatValue() + aCoeff2 * aValue2.GetFloatValue()), aValue1.GetUnit()); } else { aResult.SetFloatValue( EnsureNotNan(aCoeff1 * aValue1.GetAngleValueInRadians() + aCoeff2 * aValue2.GetAngleValueInRadians()), eCSSUnit_Radian); } } static inline void AddCSSValuePercent(double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult, uint32_t aValueRestrictions = 0) { MOZ_ASSERT(aValue1.GetUnit() == eCSSUnit_Percent, "unexpected unit"); MOZ_ASSERT(aValue2.GetUnit() == eCSSUnit_Percent, "unexpected unit"); aResult.SetPercentValue(RestrictValue(aValueRestrictions, aCoeff1 * aValue1.GetPercentValue() + aCoeff2 * aValue2.GetPercentValue())); } // Add two canonical-form calc values (eUnit_Calc) to make another // canonical-form calc value. static void AddCSSValueCanonicalCalc(double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult) { PixelCalcValue v1 = ExtractCalcValue(aValue1); PixelCalcValue v2 = ExtractCalcValue(aValue2); PixelCalcValue result; result.mLength = aCoeff1 * v1.mLength + aCoeff2 * v2.mLength; result.mPercent = aCoeff1 * v1.mPercent + aCoeff2 * v2.mPercent; result.mHasPercent = v1.mHasPercent || v2.mHasPercent; MOZ_ASSERT(result.mHasPercent || result.mPercent == 0.0f, "can't have a nonzero percentage part without having percentages"); CalcValueToCSSValue(result, aResult); } static inline void AddCSSValuePixel(double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult, uint32_t aValueRestrictions = 0) { MOZ_ASSERT(aValue1.GetUnit() == eCSSUnit_Pixel, "unexpected unit"); MOZ_ASSERT(aValue2.GetUnit() == eCSSUnit_Pixel, "unexpected unit"); aResult.SetFloatValue(RestrictValue(aValueRestrictions, aCoeff1 * aValue1.GetFloatValue() + aCoeff2 * aValue2.GetFloatValue()), eCSSUnit_Pixel); } static bool AddCSSValuePixelPercentCalc(const uint32_t aValueRestrictions, const nsCSSUnit aCommonUnit, double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult) { switch (aCommonUnit) { case eCSSUnit_Pixel: AddCSSValuePixel(aCoeff1, aValue1, aCoeff2, aValue2, aResult, aValueRestrictions); break; case eCSSUnit_Percent: AddCSSValuePercent(aCoeff1, aValue1, aCoeff2, aValue2, aResult, aValueRestrictions); break; case eCSSUnit_Calc: AddCSSValueCanonicalCalc(aCoeff1, aValue1, aCoeff2, aValue2, aResult); break; default: return false; } return true; } static void AddTransformTranslate(double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult) { // Only three possible units: eCSSUnit_Pixel, eCSSUnit_Percent, or // eCSSUnit_Calc. MOZ_ASSERT(aValue1.GetUnit() == eCSSUnit_Percent || aValue1.GetUnit() == eCSSUnit_Pixel || aValue1.IsCalcUnit(), "unexpected unit"); MOZ_ASSERT(aValue2.GetUnit() == eCSSUnit_Percent || aValue2.GetUnit() == eCSSUnit_Pixel || aValue2.IsCalcUnit(), "unexpected unit"); AddCSSValuePixelPercentCalc(0, (aValue1.GetUnit() != aValue2.GetUnit() || aValue1.IsCalcUnit()) ? eCSSUnit_Calc : aValue1.GetUnit(), aCoeff1, aValue1, aCoeff2, aValue2, aResult); } // CLASS METHODS // ------------- static RGBAColorData ExtractColor(const nsCSSValue& aValue) { MOZ_ASSERT(aValue.IsNumericColorUnit(), "The unit should be color"); // PercentageRGBColor and PercentageRGBAColor component value might be // greater than 1.0 in case when the color value is accumulated, so we // can't use nsCSSValue::GetColorValue() here because that function // clamps its values. if (aValue.GetUnit() == eCSSUnit_PercentageRGBColor || aValue.GetUnit() == eCSSUnit_PercentageRGBAColor) { nsCSSValueFloatColor* floatColor = aValue.GetFloatColorValue(); return { floatColor->Comp1(), floatColor->Comp2(), floatColor->Comp3(), floatColor->Alpha() }; } return RGBAColorData(aValue.GetColorValue()); } static RGBAColorData ExtractColor(const StyleAnimationValue& aValue) { MOZ_ASSERT(aValue.GetUnit() == StyleAnimationValue::eUnit_Color); nsCSSValue* value = aValue.GetCSSValueValue(); MOZ_ASSERT(value, "CSS value must be valid"); return ExtractColor(*value); } static ComplexColorData ExtractComplexColor(const StyleAnimationValue& aValue) { switch (aValue.GetUnit()) { case StyleAnimationValue::eUnit_Color: return ComplexColorData(ExtractColor(aValue), 0.0f); case StyleAnimationValue::eUnit_CurrentColor: return ComplexColorData({0, 0, 0, 0}, 1.0f); case StyleAnimationValue::eUnit_ComplexColor: return ComplexColorData(aValue.GetComplexColorData()); default: MOZ_ASSERT_UNREACHABLE("Unknown unit"); return ComplexColorData({0, 0, 0, 0}, 0.0f); } } double StyleAnimationValue::ComputeColorDistance(const RGBAColorData& aStartColor, const RGBAColorData& aEndColor) { // http://www.w3.org/TR/smil-animation/#animateColorElement says // that we should use Euclidean RGB cube distance. However, we // have to extend that to RGBA. For now, we'll just use the // Euclidean distance in the (part of the) 4-cube of premultiplied // colors. double startA = aStartColor.mA; double startR = aStartColor.mR * startA; double startG = aStartColor.mG * startA; double startB = aStartColor.mB * startA; double endA = aEndColor.mA; double endR = aEndColor.mR * endA; double endG = aEndColor.mG * endA; double endB = aEndColor.mB * endA; double diffA = startA - endA; double diffR = startR - endR; double diffG = startG - endG; double diffB = startB - endB; return sqrt(diffA * diffA + diffR * diffR + diffG * diffG + diffB * diffB); } enum class Restrictions { Enable, Disable }; static already_AddRefed<nsCSSValue::Array> AddShapeFunction(nsCSSPropertyID aProperty, double aCoeff1, const nsCSSValue::Array* aArray1, double aCoeff2, const nsCSSValue::Array* aArray2, Restrictions aRestriction = Restrictions::Enable); static double ComputeShapeDistance(nsCSSPropertyID aProperty, const nsCSSValue::Array* aArray1, const nsCSSValue::Array* aArray2) { // Use AddShapeFunction to get the difference between two shape functions. RefPtr<nsCSSValue::Array> diffShape = AddShapeFunction(aProperty, 1.0, aArray2, -1.0, aArray1, Restrictions::Disable); if (!diffShape) { return 0.0; } // A helper function to convert a calc() diff value into a double distance. auto pixelCalcDistance = [](const PixelCalcValue& aValue) { MOZ_ASSERT(aValue.mHasPercent || aValue.mPercent == 0.0f, "can't have a nonzero percentage part without having percentages"); return aValue.mLength * aValue.mLength + aValue.mPercent * aValue.mPercent; }; double squareDistance = 0.0; const nsCSSValue::Array* func = diffShape->Item(0).GetArrayValue(); nsCSSKeyword shapeFuncName = func->Item(0).GetKeywordValue(); switch (shapeFuncName) { case eCSSKeyword_ellipse: case eCSSKeyword_circle: { // Skip the first element which is the function keyword. // Also, skip the last element which is an array for <position> const size_t len = func->Count(); for (size_t i = 1; i < len - 1; ++i) { squareDistance += pixelCalcDistance(ExtractCalcValue(func->Item(i))); } // Only iterate over elements 1 and 3. The <position> is 'uncomputed' to // only those elements. See also the comment in SetPositionValue. for (size_t i = 1; i < 4; i += 2) { const nsCSSValue& value = func->Item(len - 1).GetArrayValue()->Item(i); squareDistance += pixelCalcDistance(ExtractCalcValue(value)); } break; } case eCSSKeyword_polygon: { // Don't care about the first element which is the function keyword, and // the second element which is the fill rule. const nsCSSValuePairList* list = func->Item(2).GetPairListValue(); do { squareDistance += pixelCalcDistance(ExtractCalcValue(list->mXValue)) + pixelCalcDistance(ExtractCalcValue(list->mYValue)); list = list->mNext; } while (list); break; } case eCSSKeyword_inset: { // Items 1-4 are respectively the top, right, bottom and left offsets // from the reference box. for (size_t i = 1; i <= 4; ++i) { const nsCSSValue& value = func->Item(i); squareDistance += pixelCalcDistance(ExtractCalcValue(value)); } // Item 5 contains the radii of the rounded corners for the inset // rectangle. const nsCSSValue::Array* array = func->Item(5).GetArrayValue(); const size_t len = array->Count(); for (size_t i = 0; i < len; ++i) { const nsCSSValuePair& pair = array->Item(i).GetPairValue(); squareDistance += pixelCalcDistance(ExtractCalcValue(pair.mXValue)) + pixelCalcDistance(ExtractCalcValue(pair.mYValue)); } break; } default: MOZ_ASSERT_UNREACHABLE("Unknown shape type"); } return sqrt(squareDistance); } static nsCSSValueList* AddTransformLists(double aCoeff1, const nsCSSValueList* aList1, double aCoeff2, const nsCSSValueList* aList2); static double ComputeTransform2DMatrixDistance(const Matrix& aMatrix1, const Matrix& aMatrix2) { Point3D scale1(1, 1, 1); Point3D translate1; gfxQuaternion rotate1; nsStyleTransformMatrix::ShearArray shear1{0.0f, 0.0f, 0.0f}; Decompose2DMatrix(aMatrix1, scale1, shear1, rotate1, translate1); Point3D scale2(1, 1, 1); Point3D translate2; gfxQuaternion rotate2; nsStyleTransformMatrix::ShearArray shear2{0.0f, 0.0f, 0.0f}; Decompose2DMatrix(aMatrix2, scale2, shear2, rotate2, translate2); // Note: // 1. Shear factor is the tangent value of shear angle, so we need to // call atan() to get the angle. For 2D transform, we only have XYSHEAR. // 2. The quaternion vector of the decomposed 2d matrix is got by // "gfxQuaternion(0, 0, sin(rotate/2), cos(rotate/2))" // ^^^^^^^^^^^^^ ^^^^^^^^^^^^^ // z w // Therefore, we can get the rotate angle by 2 * atan2f(z, w). // // However, we can also get the rotate angle by the inner product of // two quaternion vectors, just as what we do for eCSSKeyword_rotate3d. // e.g. // rotate3d(0, 0, 1, 60deg) => rotate3d(0, 0, 1, 120deg); // quaternion 1: (0, 0, sin(30deg), cos(30deg)) = (0, 0, 1/2, sqrt(3)/2) // quaternion 2: (0, 0, sin(60deg), cos(60deg)) = (0, 0, sqrt(3)/2, 1/2) // inner product: sqrt(3)/4 + sqrt(3)/4 = sqrt(3)/2 // Finally, the rotate angle: 2 * acos(sqrt(3)/2) = 60deg // // I think doing atan() may be faster than doing inner product together // with acos(), so let's adopt atan2f(). const Point3D diffTranslate = translate2 - translate1; const Point3D diffScale = scale2 - scale1; const double diffShear = atan(shear2[ShearType::XYSHEAR]) - atan(shear1[ShearType::XYSHEAR]); const double diffRotate = 2.0 * (atan2f(rotate2.z, rotate2.w) - atan2f(rotate1.z, rotate1.w)); // Returns the sum of squares because we will take a square root in // ComputeTransformListDistance. return diffTranslate.DotProduct(diffTranslate) + diffScale.DotProduct(diffScale) + diffRotate * diffRotate + diffShear * diffShear; } static double ComputeTransform3DMatrixDistance(const Matrix4x4& aMatrix1, const Matrix4x4& aMatrix2) { Point3D scale1(1, 1, 1); Point3D translate1; Point4D perspective1(0, 0, 0, 1); gfxQuaternion rotate1; nsStyleTransformMatrix::ShearArray shear1{0.0f, 0.0f, 0.0f}; Decompose3DMatrix(aMatrix1, scale1, shear1, rotate1, translate1, perspective1); Point3D scale2(1, 1, 1); Point3D translate2; Point4D perspective2(0, 0, 0, 1); gfxQuaternion rotate2; nsStyleTransformMatrix::ShearArray shear2{0.0f, 0.0f, 0.0f}; Decompose3DMatrix(aMatrix2, scale2, shear2, rotate2, translate2, perspective2); // Note: // 1. Shear factor is the tangent value of shear angle, so we need to // call atan() to get the angle. // 2. We use the same way to get the rotate angle of two quaternion vectors as // what we do for rotate3d. const Point3D diffTranslate = translate2 - translate1; const Point3D diffScale = scale2 - scale1; const Point3D diffShear(atan(shear2[ShearType::XYSHEAR]) - atan(shear1[ShearType::XYSHEAR]), atan(shear2[ShearType::XZSHEAR]) - atan(shear1[ShearType::XZSHEAR]), atan(shear2[ShearType::YZSHEAR]) - atan(shear1[ShearType::YZSHEAR])); const Point4D diffPerspective = perspective2 - perspective1; const double dot = clamped(rotate1.DotProduct(rotate2), -1.0, 1.0); const double diffRotate = 2.0 * acos(dot); // Returns the sum of squares because we will take a square root in // ComputeTransformListDistance. return diffTranslate.DotProduct(diffTranslate) + diffScale.DotProduct(diffScale) + diffPerspective.DotProduct(diffPerspective) + diffShear.DotProduct(diffShear) + diffRotate * diffRotate; } static double ComputeTransformDistance(nsCSSValue::Array* aArray1, nsCSSValue::Array* aArray2) { MOZ_ASSERT(aArray1, "aArray1 should be non-null."); MOZ_ASSERT(aArray2, "aArray2 should be non-null."); // Normalize translate and scale functions to equivalent "translate3d" and // "scale3d" functions. RefPtr<nsCSSValue::Array> a1 = ToPrimitive(aArray1), a2 = ToPrimitive(aArray2); nsCSSKeyword tfunc = nsStyleTransformMatrix::TransformFunctionOf(a1); MOZ_ASSERT(nsStyleTransformMatrix::TransformFunctionOf(a2) == tfunc); double distance = 0.0; switch (tfunc) { case eCSSKeyword_translate3d: { MOZ_ASSERT(a1->Count() == 4, "unexpected count"); MOZ_ASSERT(a2->Count() == 4, "unexpected count"); nsCSSValue x, y, z; AddTransformTranslate(1.0, a2->Item(1), -1.0, a1->Item(1), x); AddTransformTranslate(1.0, a2->Item(2), -1.0, a1->Item(2), y); AddTransformTranslate(1.0, a2->Item(3), -1.0, a1->Item(3), z); // Drop percent part because we only compute distance by computed values. double c1 = ExtractCalcValue(x).mLength; double c2 = ExtractCalcValue(y).mLength; double c3 = z.GetFloatValue(); distance = c1 * c1 + c2 * c2 + c3 * c3; break; } case eCSSKeyword_scale3d: { MOZ_ASSERT(a1->Count() == 4, "unexpected count"); MOZ_ASSERT(a2->Count() == 4, "unexpected count"); auto ComputeScaleDiff = [](const nsCSSValue& aValue1, const nsCSSValue& aValue2) { float v1 = aValue1.GetFloatValue(); float v2 = aValue2.GetFloatValue(); return EnsureNotNan(v2 - v1); }; double c1 = ComputeScaleDiff(a1->Item(1), a2->Item(1)); double c2 = ComputeScaleDiff(a1->Item(2), a2->Item(2)); double c3 = ComputeScaleDiff(a1->Item(3), a2->Item(3)); distance = c1 * c1 + c2 * c2 + c3 * c3; break; } case eCSSKeyword_skew: { MOZ_ASSERT(a1->Count() == 2 || a1->Count() == 3, "unexpected count"); MOZ_ASSERT(a2->Count() == 2 || a2->Count() == 3, "unexpected count"); const nsCSSValue zero(0.0f, eCSSUnit_Radian); nsCSSValue x, y; AddCSSValueAngle(1.0, a2->Item(1), -1.0, a1->Item(1), x); AddCSSValueAngle(1.0, a2->Count() == 3 ? a2->Item(2) : zero, -1.0, a1->Count() == 3 ? a1->Item(2) : zero, y); distance = x.GetAngleValueInRadians() * x.GetAngleValueInRadians() + y.GetAngleValueInRadians() * y.GetAngleValueInRadians(); break; } case eCSSKeyword_skewx: case eCSSKeyword_skewy: case eCSSKeyword_rotate: case eCSSKeyword_rotatex: case eCSSKeyword_rotatey: case eCSSKeyword_rotatez: { MOZ_ASSERT(a1->Count() == 2, "unexpected count"); MOZ_ASSERT(a2->Count() == 2, "unexpected count"); nsCSSValue angle; AddCSSValueAngle(1.0, a2->Item(1), -1.0, a1->Item(1), angle); distance = angle.GetAngleValueInRadians() * angle.GetAngleValueInRadians(); break; } case eCSSKeyword_rotate3d: { MOZ_ASSERT(a1->Count() == 5, "unexpected count"); MOZ_ASSERT(a2->Count() == 5, "unexpected count"); Point3D vector1(a1->Item(1).GetFloatValue(), a1->Item(2).GetFloatValue(), a1->Item(3).GetFloatValue()); vector1.Normalize(); Point3D vector2(a2->Item(1).GetFloatValue(), a2->Item(2).GetFloatValue(), a2->Item(3).GetFloatValue()); vector2.Normalize(); if (vector1 == vector2) { // Handle rotate3d with matched (normalized) vectors. nsCSSValue angle; AddCSSValueAngle(1.0, a2->Item(4), -1.0, a1->Item(4), angle); distance = angle.GetAngleValueInRadians() * angle.GetAngleValueInRadians(); } else { // Use quaternion vectors to get the angle difference. Both q1 and q2 // are unit vectors, so we can get their angle difference by // cos(theta/2) = (q1 dot q2) / (|q1| * |q2|) = q1 dot q2. gfxQuaternion q1(vector1, a1->Item(4).GetAngleValueInRadians()); gfxQuaternion q2(vector2, a2->Item(4).GetAngleValueInRadians()); distance = 2.0 * acos(clamped(q1.DotProduct(q2), -1.0, 1.0)); distance = distance * distance; } break; } case eCSSKeyword_perspective: { MOZ_ASSERT(a1->Count() == 2, "unexpected count"); MOZ_ASSERT(a2->Count() == 2, "unexpected count"); // We convert a perspective function into an equivalent matrix3d, and // then do matrix decomposition to get the distance. // Why don't we just subtract one perspective depth from the other? // I think it's better to follow the logic of our interpolation, // which does linear interpolation between two decomposed perspective // vectors. // e.g. // Do interpolation between perspective(100px) and perspective(1000px). // 1) Convert them into matrix3d, and then do matrix decomposition: // perspective vector 1: perspective(0, 0, -1/100, 1); // perspective vector 2: perspective(0, 0, -1/1000, 1); // 2) Do linear interpolation between these two vectors. // Therefore, we use the same rule to get the distance as what we do for // matrix3d. using nsStyleTransformMatrix::ApplyPerspectiveToMatrix; Matrix4x4 m1; ApplyPerspectiveToMatrix(m1, a1->Item(1).GetFloatValue()); Matrix4x4 m2; ApplyPerspectiveToMatrix(m2, a2->Item(1).GetFloatValue()); distance = ComputeTransform3DMatrixDistance(m1, m2); break; } case eCSSKeyword_matrix: { MOZ_ASSERT(a1->Count() == 7, "unexpected count"); MOZ_ASSERT(a2->Count() == 7, "unexpected count"); distance = ComputeTransform2DMatrixDistance( nsStyleTransformMatrix::CSSValueArrayTo2DMatrix(a1), nsStyleTransformMatrix::CSSValueArrayTo2DMatrix(a2)); break; } case eCSSKeyword_matrix3d: { MOZ_ASSERT(a1->Count() == 17, "unexpected count"); MOZ_ASSERT(a2->Count() == 17, "unexpected count"); distance = ComputeTransform3DMatrixDistance( nsStyleTransformMatrix::CSSValueArrayTo3DMatrix(a1), nsStyleTransformMatrix::CSSValueArrayTo3DMatrix(a2)); break; } case eCSSKeyword_interpolatematrix: default: MOZ_ASSERT_UNREACHABLE("Unsupported transform function"); break; } return distance; } static double ComputeTransformListDistance(const nsCSSValueList* aList1, const nsCSSValueList* aList2) { MOZ_ASSERT(aList1, "aList1 should be non-null."); MOZ_ASSERT(aList2, "aList2 should be non-null."); double distance = 0.0; do { distance += ComputeTransformDistance(aList1->mValue.GetArrayValue(), aList2->mValue.GetArrayValue()); aList1 = aList1->mNext; aList2 = aList2->mNext; MOZ_ASSERT(!aList1 == !aList2, "aList1 and aList2 should have the same length."); } while (aList1); return sqrt(distance); } static double ComputeMismatchedTransfromListDistance(const nsCSSValueList* aList1, const nsCSSValueList* aList2, nsStyleContext* aStyleContext) { // We need nsStyleContext and nsPresContext to compute calc() values while // processing the translate part of transforms. if (!aStyleContext) { return 0.0; } RuleNodeCacheConditions dontCare; bool dontCareBool; nsStyleTransformMatrix::TransformReferenceBox emptyRefBox; Matrix4x4 m1 = nsStyleTransformMatrix::ReadTransforms( aList1, aStyleContext, aStyleContext->PresContext(), dontCare, emptyRefBox, nsPresContext::AppUnitsPerCSSPixel(), &dontCareBool); Matrix4x4 m2 = nsStyleTransformMatrix::ReadTransforms( aList2, aStyleContext, aStyleContext->PresContext(), dontCare, emptyRefBox, nsPresContext::AppUnitsPerCSSPixel(), &dontCareBool); return sqrt(ComputeTransform3DMatrixDistance(m1, m2)); } bool StyleAnimationValue::ComputeDistance(nsCSSPropertyID aProperty, const StyleAnimationValue& aStartValue, const StyleAnimationValue& aEndValue, nsStyleContext* aStyleContext, double& aDistance) { Unit commonUnit = GetCommonUnit(aProperty, aStartValue.GetUnit(), aEndValue.GetUnit()); switch (commonUnit) { case eUnit_Null: case eUnit_Auto: case eUnit_None: case eUnit_Normal: case eUnit_UnparsedString: case eUnit_URL: case eUnit_DiscreteCSSValue: return false; case eUnit_Enumerated: switch (aProperty) { case eCSSProperty_font_stretch: { // just like eUnit_Integer. int32_t startInt = aStartValue.GetIntValue(); int32_t endInt = aEndValue.GetIntValue(); aDistance = Abs(endInt - startInt); return true; } default: return false; } case eUnit_Visibility: { int32_t startEnum = aStartValue.GetIntValue(); int32_t endEnum = aEndValue.GetIntValue(); if (startEnum == endEnum) { aDistance = 0; return true; } if ((startEnum == NS_STYLE_VISIBILITY_VISIBLE) == (endEnum == NS_STYLE_VISIBILITY_VISIBLE)) { return false; } aDistance = 1; return true; } case eUnit_Integer: { int32_t startInt = aStartValue.GetIntValue(); int32_t endInt = aEndValue.GetIntValue(); aDistance = Abs(double(endInt) - double(startInt)); return true; } case eUnit_Coord: { nscoord startCoord = aStartValue.GetCoordValue(); nscoord endCoord = aEndValue.GetCoordValue(); aDistance = Abs(double(endCoord) - double(startCoord)); return true; } case eUnit_Percent: { float startPct = aStartValue.GetPercentValue(); float endPct = aEndValue.GetPercentValue(); aDistance = Abs(double(endPct) - double(startPct)); return true; } case eUnit_Float: { float startFloat = aStartValue.GetFloatValue(); float endFloat = aEndValue.GetFloatValue(); aDistance = Abs(double(endFloat) - double(startFloat)); return true; } case eUnit_Color: { aDistance = ComputeColorDistance(ExtractColor(aStartValue), ExtractColor(aEndValue)); return true; } case eUnit_CurrentColor: { aDistance = 0; return true; } case eUnit_ComplexColor: { ComplexColorData color1 = ExtractComplexColor(aStartValue); ComplexColorData color2 = ExtractComplexColor(aEndValue); // Common case is interpolating between a color and a currentcolor if (color1.IsNumericColor() && color2.IsCurrentColor()) { double dist = ComputeColorDistance(color1.mColor, NS_RGBA(0, 0, 0, 0)); aDistance = sqrt(dist * dist + 1); return true; } if (color1.IsCurrentColor() && color2.IsNumericColor()) { double dist = ComputeColorDistance(NS_RGBA(0, 0, 0, 0), color2.mColor); aDistance = sqrt(dist * dist + 1); return true; } // If we ever reach here, we may want to use the code in // bug 1299741 comment 79 to compute it. MOZ_ASSERT_UNREACHABLE("We shouldn't get here as we only call " "ComputeDistance on pre-interpolation values"); aDistance = 0.0; return true; } case eUnit_Calc: { PixelCalcValue v1 = ExtractCalcValue(aStartValue); PixelCalcValue v2 = ExtractCalcValue(aEndValue); float difflen = v2.mLength - v1.mLength; float diffpct = v2.mPercent - v1.mPercent; aDistance = sqrt(difflen * difflen + diffpct * diffpct); return true; } case eUnit_ObjectPosition: { const nsCSSValue* position1 = aStartValue.GetCSSValueValue(); const nsCSSValue* position2 = aEndValue.GetCSSValueValue(); double squareDistance = CalcPositionSquareDistance(*position1, *position2); aDistance = sqrt(squareDistance); return true; } case eUnit_CSSValuePair: { const nsCSSValuePair *pair1 = aStartValue.GetCSSValuePairValue(); const nsCSSValuePair *pair2 = aEndValue.GetCSSValuePairValue(); nsCSSUnit unit[2]; unit[0] = GetCommonUnit(aProperty, pair1->mXValue.GetUnit(), pair2->mXValue.GetUnit()); unit[1] = GetCommonUnit(aProperty, pair1->mYValue.GetUnit(), pair2->mYValue.GetUnit()); if (unit[0] == eCSSUnit_Null || unit[1] == eCSSUnit_Null || unit[0] == eCSSUnit_URL || unit[0] == eCSSUnit_Enumerated) { return false; } double squareDistance = 0.0; static nsCSSValue nsCSSValuePair::* const pairValues[2] = { &nsCSSValuePair::mXValue, &nsCSSValuePair::mYValue }; for (uint32_t i = 0; i < 2; ++i) { nsCSSValue nsCSSValuePair::*member = pairValues[i]; double diffsquared; switch (unit[i]) { case eCSSUnit_Pixel: { float diff = (pair1->*member).GetFloatValue() - (pair2->*member).GetFloatValue(); diffsquared = diff * diff; break; } case eCSSUnit_Percent: { float diff = (pair1->*member).GetPercentValue() - (pair2->*member).GetPercentValue(); diffsquared = diff * diff; break; } case eCSSUnit_Calc: { PixelCalcValue v1 = ExtractCalcValue(pair1->*member); PixelCalcValue v2 = ExtractCalcValue(pair2->*member); float difflen = v2.mLength - v1.mLength; float diffpct = v2.mPercent - v1.mPercent; diffsquared = difflen * difflen + diffpct * diffpct; break; } default: MOZ_ASSERT(false, "unexpected unit"); return false; } squareDistance += diffsquared; } aDistance = sqrt(squareDistance); return true; } case eUnit_CSSValueTriplet: { const nsCSSValueTriplet *triplet1 = aStartValue.GetCSSValueTripletValue(); const nsCSSValueTriplet *triplet2 = aEndValue.GetCSSValueTripletValue(); nsCSSUnit unit[3]; unit[0] = GetCommonUnit(aProperty, triplet1->mXValue.GetUnit(), triplet2->mXValue.GetUnit()); unit[1] = GetCommonUnit(aProperty, triplet1->mYValue.GetUnit(), triplet2->mYValue.GetUnit()); unit[2] = GetCommonUnit(aProperty, triplet1->mZValue.GetUnit(), triplet2->mZValue.GetUnit()); if (unit[0] == eCSSUnit_Null || unit[1] == eCSSUnit_Null || unit[2] == eCSSUnit_Null) { return false; } double squareDistance = 0.0; static nsCSSValue nsCSSValueTriplet::* const pairValues[3] = { &nsCSSValueTriplet::mXValue, &nsCSSValueTriplet::mYValue, &nsCSSValueTriplet::mZValue }; for (uint32_t i = 0; i < 3; ++i) { nsCSSValue nsCSSValueTriplet::*member = pairValues[i]; double diffsquared; switch (unit[i]) { case eCSSUnit_Pixel: { float diff = (triplet1->*member).GetFloatValue() - (triplet2->*member).GetFloatValue(); diffsquared = diff * diff; break; } case eCSSUnit_Percent: { float diff = (triplet1->*member).GetPercentValue() - (triplet2->*member).GetPercentValue(); diffsquared = diff * diff; break; } case eCSSUnit_Calc: { PixelCalcValue v1 = ExtractCalcValue(triplet1->*member); PixelCalcValue v2 = ExtractCalcValue(triplet2->*member); float difflen = v2.mLength - v1.mLength; float diffpct = v2.mPercent - v1.mPercent; diffsquared = difflen * difflen + diffpct * diffpct; break; } case eCSSUnit_Null: diffsquared = 0; break; default: MOZ_ASSERT(false, "unexpected unit"); return false; } squareDistance += diffsquared; } aDistance = sqrt(squareDistance); return true; } case eUnit_CSSRect: { const nsCSSRect *rect1 = aStartValue.GetCSSRectValue(); const nsCSSRect *rect2 = aEndValue.GetCSSRectValue(); if (rect1->mTop.GetUnit() != rect2->mTop.GetUnit() || rect1->mRight.GetUnit() != rect2->mRight.GetUnit() || rect1->mBottom.GetUnit() != rect2->mBottom.GetUnit() || rect1->mLeft.GetUnit() != rect2->mLeft.GetUnit()) { // At least until we have calc() return false; } double squareDistance = 0.0; for (uint32_t i = 0; i < ArrayLength(nsCSSRect::sides); ++i) { nsCSSValue nsCSSRect::*member = nsCSSRect::sides[i]; MOZ_ASSERT((rect1->*member).GetUnit() == (rect2->*member).GetUnit(), "should have returned above"); double diff; switch ((rect1->*member).GetUnit()) { case eCSSUnit_Pixel: diff = (rect1->*member).GetFloatValue() - (rect2->*member).GetFloatValue(); break; case eCSSUnit_Auto: diff = 0; break; default: MOZ_ASSERT(false, "unexpected unit"); return false; } squareDistance += diff * diff; } aDistance = sqrt(squareDistance); return true; } case eUnit_Dasharray: { // NOTE: This produces results on substantially different scales // for length values and percentage values, which might even be // mixed in the same property value. This means the result isn't // particularly useful for paced animation. // Call AddWeighted to make us lists of the same length. StyleAnimationValue normValue1, normValue2; if (!AddWeighted(aProperty, 1.0, aStartValue, 0.0, aEndValue, normValue1) || !AddWeighted(aProperty, 0.0, aStartValue, 1.0, aEndValue, normValue2)) { return false; } double squareDistance = 0.0; const nsCSSValueList *list1 = normValue1.GetCSSValueListValue(); const nsCSSValueList *list2 = normValue2.GetCSSValueListValue(); MOZ_ASSERT(!list1 == !list2, "lists should be same length"); while (list1) { const nsCSSValue &val1 = list1->mValue; const nsCSSValue &val2 = list2->mValue; MOZ_ASSERT(val1.GetUnit() == val2.GetUnit(), "unit match should be assured by AddWeighted"); double diff; switch (val1.GetUnit()) { case eCSSUnit_Percent: diff = val1.GetPercentValue() - val2.GetPercentValue(); break; case eCSSUnit_Number: diff = val1.GetFloatValue() - val2.GetFloatValue(); break; default: MOZ_ASSERT(false, "unexpected unit"); return false; } squareDistance += diff * diff; list1 = list1->mNext; list2 = list2->mNext; MOZ_ASSERT(!list1 == !list2, "lists should be same length"); } aDistance = sqrt(squareDistance); return true; } case eUnit_Shadow: { // Call AddWeighted to make us lists of the same length. StyleAnimationValue normValue1, normValue2; if (!AddWeighted(aProperty, 1.0, aStartValue, 0.0, aEndValue, normValue1) || !AddWeighted(aProperty, 0.0, aStartValue, 1.0, aEndValue, normValue2)) { return false; } const nsCSSValueList *shadow1 = normValue1.GetCSSValueListValue(); const nsCSSValueList *shadow2 = normValue2.GetCSSValueListValue(); double squareDistance = 0.0; MOZ_ASSERT(!shadow1 == !shadow2, "lists should be same length"); while (shadow1) { nsCSSValue::Array *array1 = shadow1->mValue.GetArrayValue(); nsCSSValue::Array *array2 = shadow2->mValue.GetArrayValue(); for (size_t i = 0; i < 4; ++i) { MOZ_ASSERT(array1->Item(i).GetUnit() == eCSSUnit_Pixel, "unexpected unit"); MOZ_ASSERT(array2->Item(i).GetUnit() == eCSSUnit_Pixel, "unexpected unit"); double diff = array1->Item(i).GetFloatValue() - array2->Item(i).GetFloatValue(); squareDistance += diff * diff; } const nsCSSValue &color1 = array1->Item(4); const nsCSSValue &color2 = array2->Item(4); #ifdef DEBUG { const nsCSSValue &inset1 = array1->Item(5); const nsCSSValue &inset2 = array2->Item(5); // There are only two possible states of the inset value: // (1) GetUnit() == eCSSUnit_Null // (2) GetUnit() == eCSSUnit_Enumerated && // GetIntValue() == NS_STYLE_BOX_SHADOW_INSET MOZ_ASSERT(((color1.IsNumericColorUnit() && color2.IsNumericColorUnit()) || (color1.GetUnit() == color2.GetUnit())) && inset1 == inset2, "AddWeighted should have failed"); } #endif if (color1.GetUnit() != eCSSUnit_Null) { double colorDistance = ComputeColorDistance(color1.GetColorValue(), color2.GetColorValue()); squareDistance += colorDistance * colorDistance; } shadow1 = shadow1->mNext; shadow2 = shadow2->mNext; MOZ_ASSERT(!shadow1 == !shadow2, "lists should be same length"); } aDistance = sqrt(squareDistance); return true; } case eUnit_Shape: aDistance = ComputeShapeDistance(aProperty, aStartValue.GetCSSValueArrayValue(), aEndValue.GetCSSValueArrayValue()); return true; case eUnit_Filter: // Bug 1286151: Support paced animations for filter function // interpolation. return false; case eUnit_Transform: { // FIXME: We don't have an official spec to define the distance of // two transform lists, but paced spacing (defined in Web Animations API) // needs this, so we implement this according to the concept of the // interpolation of two transform lists. // Issue: https://www.w3.org/TR/web-animations-1/#issue-789f9fd1 const nsCSSValueList* list1 = aStartValue.GetCSSValueSharedListValue()->mHead; const nsCSSValueList* list2 = aEndValue.GetCSSValueSharedListValue()->mHead; MOZ_ASSERT(list1); MOZ_ASSERT(list2); if (list1->mValue.GetUnit() == eCSSUnit_None && list2->mValue.GetUnit() == eCSSUnit_None) { // Both none, nothing happens. aDistance = 0.0; } else if (list1->mValue.GetUnit() == eCSSUnit_None) { nsAutoPtr<nsCSSValueList> none(AddTransformLists(0, list2, 0, list2)); aDistance = ComputeTransformListDistance(none, list2); } else if (list2->mValue.GetUnit() == eCSSUnit_None) { nsAutoPtr<nsCSSValueList> none(AddTransformLists(0, list1, 0, list1)); aDistance = ComputeTransformListDistance(list1, none); } else { const nsCSSValueList *item1 = list1, *item2 = list2; do { nsCSSKeyword func1 = nsStyleTransformMatrix::TransformFunctionOf( item1->mValue.GetArrayValue()); nsCSSKeyword func2 = nsStyleTransformMatrix::TransformFunctionOf( item2->mValue.GetArrayValue()); if (!TransformFunctionsMatch(func1, func2)) { break; } item1 = item1->mNext; item2 = item2->mNext; } while (item1 && item2); if (item1 || item2) { // Either the transform function types don't match or // the lengths don't match. aDistance = ComputeMismatchedTransfromListDistance(list1, list2, aStyleContext); } else { aDistance = ComputeTransformListDistance(list1, list2); } } return true; } case eUnit_BackgroundPositionCoord: { const nsCSSValueList *position1 = aStartValue.GetCSSValueListValue(); const nsCSSValueList *position2 = aEndValue.GetCSSValueListValue(); double squareDistance = 0.0; MOZ_ASSERT(!position1 == !position2, "lists should be same length"); while (position1 && position2) { squareDistance += CalcPositionCoordSquareDistance(position1->mValue, position2->mValue); position1 = position1->mNext; position2 = position2->mNext; } // fail if lists differ in length. if (position1 || position2) { return false; } aDistance = sqrt(squareDistance); return true; } case eUnit_CSSValuePairList: { const nsCSSValuePairList *list1 = aStartValue.GetCSSValuePairListValue(); const nsCSSValuePairList *list2 = aEndValue.GetCSSValuePairListValue(); double squareDistance = 0.0; do { static nsCSSValue nsCSSValuePairList::* const pairListValues[] = { &nsCSSValuePairList::mXValue, &nsCSSValuePairList::mYValue, }; for (uint32_t i = 0; i < ArrayLength(pairListValues); ++i) { const nsCSSValue &v1 = list1->*(pairListValues[i]); const nsCSSValue &v2 = list2->*(pairListValues[i]); nsCSSUnit unit = GetCommonUnit(aProperty, v1.GetUnit(), v2.GetUnit()); if (unit == eCSSUnit_Null) { return false; } double diffsquared = 0.0; switch (unit) { case eCSSUnit_Pixel: { float diff = v1.GetFloatValue() - v2.GetFloatValue(); diffsquared = diff * diff; break; } case eCSSUnit_Percent: { float diff = v1.GetPercentValue() - v2.GetPercentValue(); diffsquared = diff * diff; break; } case eCSSUnit_Calc: { PixelCalcValue val1 = ExtractCalcValue(v1); PixelCalcValue val2 = ExtractCalcValue(v2); float difflen = val2.mLength - val1.mLength; float diffpct = val2.mPercent - val1.mPercent; diffsquared = difflen * difflen + diffpct * diffpct; break; } default: if (v1 != v2) { return false; } break; } squareDistance += diffsquared; } list1 = list1->mNext; list2 = list2->mNext; } while (list1 && list2); if (list1 || list2) { // We can't interpolate lists of different lengths. return false; } aDistance = sqrt(squareDistance); return true; } } MOZ_ASSERT(false, "Can't compute distance using the given common unit"); return false; } static inline void AddCSSValueNumber(double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult, uint32_t aValueRestrictions = 0) { MOZ_ASSERT(aValue1.GetUnit() == eCSSUnit_Number, "unexpected unit"); MOZ_ASSERT(aValue2.GetUnit() == eCSSUnit_Number, "unexpected unit"); aResult.SetFloatValue(RestrictValue(aValueRestrictions, aCoeff1 * aValue1.GetFloatValue() + aCoeff2 * aValue2.GetFloatValue()), eCSSUnit_Number); } static inline float GetNumberOrPercent(const nsCSSValue &aValue) { nsCSSUnit unit = aValue.GetUnit(); MOZ_ASSERT(unit == eCSSUnit_Number || unit == eCSSUnit_Percent, "unexpected unit"); return (unit == eCSSUnit_Number) ? aValue.GetFloatValue() : aValue.GetPercentValue(); } static inline void AddCSSValuePercentNumber(const uint32_t aValueRestrictions, double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult, float aInitialVal) { float n1 = GetNumberOrPercent(aValue1); float n2 = GetNumberOrPercent(aValue2); // Rather than interpolating aValue1 and aValue2 directly, we // interpolate their *distances from aInitialVal* (the initial value, // which is either 1 or 0 for "filter" functions). This matters in // cases where aInitialVal is nonzero and the coefficients don't add // up to 1. For example, if initialVal is 1, aCoeff1 is 0.5, and // aCoeff2 is 0, then we'll return the value halfway between 1 and // aValue1, rather than the value halfway between 0 and aValue1. // Note that we do something similar in AddTransformScale(). float result = (n1 - aInitialVal) * aCoeff1 + (n2 - aInitialVal) * aCoeff2; aResult.SetFloatValue(RestrictValue(aValueRestrictions, result + aInitialVal), eCSSUnit_Number); } enum class ColorAdditionType { Clamped, // Clamp each color channel after adding. Unclamped // Do not clamp color channels after adding. }; // Unclamped AddWeightedColors. static RGBAColorData AddWeightedColors(double aCoeff1, const RGBAColorData& aValue1, double aCoeff2, const RGBAColorData& aValue2) { float factor1 = aValue1.mA * aCoeff1; float factor2 = aValue2.mA * aCoeff2; float resultA = factor1 + factor2; if (resultA <= 0.0) { return {0, 0, 0, 0}; } if (resultA > 1.0) { resultA = 1.0; } float resultFactor = 1.0f / resultA; return RGBAColorData( (aValue1.mR * factor1 + aValue2.mR * factor2) * resultFactor, (aValue1.mG * factor1 + aValue2.mG * factor2) * resultFactor, (aValue1.mB * factor1 + aValue2.mB * factor2) * resultFactor, resultA); } // Multiplies |aValue| color by |aDilutionRation|. static nscolor DiluteColor(const RGBAColorData& aValue, double aDilutionRatio) { MOZ_ASSERT(aDilutionRatio >= 0.0 && aDilutionRatio <= 1.0, "Dilution ratio should be in [0, 1]"); float resultA = aValue.mA * aDilutionRatio; return resultA <= 0.0 ? NS_RGBA(0, 0, 0, 0) : aValue.WithAlpha(resultA).ToColor(); } // Clamped AddWeightedColors. static nscolor AddWeightedColorsAndClamp(double aCoeff1, const RGBAColorData& aValue1, double aCoeff2, const RGBAColorData& aValue2) { // We are using AddWeighted() with a zero aCoeff2 for colors to // pretend AddWeighted() against transparent color, i.e. rgba(0, 0, 0, 0). // But unpremultiplication in AddWeightedColors() does not work well // for such cases, so we use another function named DiluteColor() which // has a similar logic to AddWeightedColors(). return aCoeff2 == 0.0 ? DiluteColor(aValue1, aCoeff1) : AddWeightedColors(aCoeff1, aValue1, aCoeff2, aValue2).ToColor(); } void AppendToCSSValueList(UniquePtr<nsCSSValueList>& aHead, UniquePtr<nsCSSValueList>&& aValueToAppend, nsCSSValueList** aTail) { MOZ_ASSERT(!aHead == !*aTail, "Can't have head w/o tail, & vice versa"); if (!aHead) { aHead = Move(aValueToAppend); *aTail = aHead.get(); } else { (*aTail) = (*aTail)->mNext = aValueToAppend.release(); } } static UniquePtr<nsCSSValueList> AddWeightedShadowItems(double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, ColorAdditionType aColorAdditionType) { // X, Y, Radius, Spread, Color, Inset MOZ_ASSERT(aValue1.GetUnit() == eCSSUnit_Array, "wrong unit"); MOZ_ASSERT(aValue2.GetUnit() == eCSSUnit_Array, "wrong unit"); nsCSSValue::Array *array1 = aValue1.GetArrayValue(); nsCSSValue::Array *array2 = aValue2.GetArrayValue(); RefPtr<nsCSSValue::Array> resultArray = nsCSSValue::Array::Create(6); for (size_t i = 0; i < 4; ++i) { AddCSSValuePixel(aCoeff1, array1->Item(i), aCoeff2, array2->Item(i), resultArray->Item(i), // blur radius must be nonnegative (i == 2) ? CSS_PROPERTY_VALUE_NONNEGATIVE : 0); } const nsCSSValue& colorValue1 = array1->Item(4); const nsCSSValue& colorValue2 = array2->Item(4); const nsCSSValue& inset1 = array1->Item(5); const nsCSSValue& inset2 = array2->Item(5); if ((colorValue1.GetUnit() != colorValue2.GetUnit() && (!colorValue1.IsNumericColorUnit() || !colorValue2.IsNumericColorUnit())) || inset1.GetUnit() != inset2.GetUnit()) { // We don't know how to animate between color and no-color, or // between inset and not-inset. // NOTE: In case when both colors' units are eCSSUnit_Null, that means // neither color value was specified, so we can interpolate. return nullptr; } if (colorValue1.GetUnit() != eCSSUnit_Null) { RGBAColorData color1 = ExtractColor(colorValue1); RGBAColorData color2 = ExtractColor(colorValue2); if (aColorAdditionType == ColorAdditionType::Clamped) { resultArray->Item(4).SetColorValue( AddWeightedColorsAndClamp(aCoeff1, color1, aCoeff2, color2)); } else { resultArray->Item(4).SetRGBAColorValue( AddWeightedColors(aCoeff1, color1, aCoeff2, color2)); } } MOZ_ASSERT(inset1 == inset2, "should match"); resultArray->Item(5) = inset1; auto resultItem = MakeUnique<nsCSSValueList>(); resultItem->mValue.SetArrayValue(resultArray, eCSSUnit_Array); return resultItem; } static void AddTransformScale(double aCoeff1, const nsCSSValue &aValue1, double aCoeff2, const nsCSSValue &aValue2, nsCSSValue &aResult) { // Handle scale, and the two matrix components where identity is 1, by // subtracting 1, multiplying by the coefficients, and then adding 1 // back. This gets the right AddWeighted behavior and gets us the // interpolation-against-identity behavior for free. MOZ_ASSERT(aValue1.GetUnit() == eCSSUnit_Number, "unexpected unit"); MOZ_ASSERT(aValue2.GetUnit() == eCSSUnit_Number, "unexpected unit"); float v1 = aValue1.GetFloatValue() - 1.0f, v2 = aValue2.GetFloatValue() - 1.0f; float result = v1 * aCoeff1 + v2 * aCoeff2; aResult.SetFloatValue(EnsureNotNan(result + 1.0f), eCSSUnit_Number); } /* static */ already_AddRefed<nsCSSValue::Array> StyleAnimationValue::AppendTransformFunction(nsCSSKeyword aTransformFunction, nsCSSValueList**& aListTail) { RefPtr<nsCSSValue::Array> arr = AppendFunction(aTransformFunction); nsCSSValueList *item = new nsCSSValueList; item->mValue.SetArrayValue(arr, eCSSUnit_Function); *aListTail = item; aListTail = &item->mNext; return arr.forget(); } template<typename T> T InterpolateNumerically(const T& aOne, const T& aTwo, double aCoeff) { return aOne + (aTwo - aOne) * aCoeff; } /* static */ Matrix4x4 StyleAnimationValue::InterpolateTransformMatrix(const Matrix4x4 &aMatrix1, const Matrix4x4 &aMatrix2, double aProgress) { // Decompose both matrices // TODO: What do we do if one of these returns false (singular matrix) Point3D scale1(1, 1, 1), translate1; Point4D perspective1(0, 0, 0, 1); gfxQuaternion rotate1; nsStyleTransformMatrix::ShearArray shear1{0.0f, 0.0f, 0.0f}; Point3D scale2(1, 1, 1), translate2; Point4D perspective2(0, 0, 0, 1); gfxQuaternion rotate2; nsStyleTransformMatrix::ShearArray shear2{0.0f, 0.0f, 0.0f}; Matrix matrix2d1, matrix2d2; if (aMatrix1.Is2D(&matrix2d1) && aMatrix2.Is2D(&matrix2d2)) { Decompose2DMatrix(matrix2d1, scale1, shear1, rotate1, translate1); Decompose2DMatrix(matrix2d2, scale2, shear2, rotate2, translate2); } else { Decompose3DMatrix(aMatrix1, scale1, shear1, rotate1, translate1, perspective1); Decompose3DMatrix(aMatrix2, scale2, shear2, rotate2, translate2, perspective2); } // Interpolate each of the pieces Matrix4x4 result; Point4D perspective = InterpolateNumerically(perspective1, perspective2, aProgress); result.SetTransposedVector(3, perspective); Point3D translate = InterpolateNumerically(translate1, translate2, aProgress); result.PreTranslate(translate.x, translate.y, translate.z); gfxQuaternion q3 = rotate1.Slerp(rotate2, aProgress); Matrix4x4 rotate = q3.ToMatrix(); if (!rotate.IsIdentity()) { result = rotate * result; } // TODO: Would it be better to interpolate these as angles? // How do we convert back to angles? float yzshear = InterpolateNumerically(shear1[ShearType::YZSHEAR], shear2[ShearType::YZSHEAR], aProgress); if (yzshear != 0.0) { result.SkewYZ(yzshear); } float xzshear = InterpolateNumerically(shear1[ShearType::XZSHEAR], shear2[ShearType::XZSHEAR], aProgress); if (xzshear != 0.0) { result.SkewXZ(xzshear); } float xyshear = InterpolateNumerically(shear1[ShearType::XYSHEAR], shear2[ShearType::XYSHEAR], aProgress); if (xyshear != 0.0) { result.SkewXY(xyshear); } Point3D scale = InterpolateNumerically(scale1, scale2, aProgress); if (scale != Point3D(1.0, 1.0, 1.0)) { result.PreScale(scale.x, scale.y, scale.z); } return result; } static nsCSSValueList* AddDifferentTransformLists(double aCoeff1, const nsCSSValueList* aList1, double aCoeff2, const nsCSSValueList* aList2) { nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); RefPtr<nsCSSValue::Array> arr; arr = StyleAnimationValue::AppendTransformFunction(eCSSKeyword_interpolatematrix, resultTail); // FIXME: We should change the other transform code to also only // take a single progress value, as having values that don't // sum to 1 doesn't make sense for these. if (aList1 == aList2) { arr->Item(1).Reset(); } else { aList1->CloneInto(arr->Item(1).SetListValue()); } aList2->CloneInto(arr->Item(2).SetListValue()); arr->Item(3).SetPercentValue(aCoeff2); return result.forget(); } static UniquePtr<nsCSSValueList> AddWeightedFilterFunctionImpl(double aCoeff1, const nsCSSValueList* aList1, double aCoeff2, const nsCSSValueList* aList2, ColorAdditionType aColorAdditionType) { // AddWeightedFilterFunction should be our only caller, and it should ensure // that both args are non-null. MOZ_ASSERT(aList1, "expected filter list"); MOZ_ASSERT(aList2, "expected filter list"); MOZ_ASSERT(aList1->mValue.GetUnit() == eCSSUnit_Function, "expected function"); MOZ_ASSERT(aList2->mValue.GetUnit() == eCSSUnit_Function, "expected function"); RefPtr<nsCSSValue::Array> a1 = aList1->mValue.GetArrayValue(), a2 = aList2->mValue.GetArrayValue(); nsCSSKeyword filterFunction = a1->Item(0).GetKeywordValue(); if (filterFunction != a2->Item(0).GetKeywordValue()) { return nullptr; // Can't add two filters of different types. } auto resultList = MakeUnique<nsCSSValueList>(); nsCSSValue::Array* result = resultList->mValue.InitFunction(filterFunction, 1); // "hue-rotate" is the only filter-function that accepts negative values, and // we don't use this "restrictions" variable in its clause below. const uint32_t restrictions = CSS_PROPERTY_VALUE_NONNEGATIVE; const nsCSSValue& funcArg1 = a1->Item(1); const nsCSSValue& funcArg2 = a2->Item(1); nsCSSValue& resultArg = result->Item(1); float initialVal = 1.0f; switch (filterFunction) { case eCSSKeyword_blur: { nsCSSUnit unit; if (funcArg1.GetUnit() == funcArg2.GetUnit()) { unit = funcArg1.GetUnit(); } else { // If units differ, we'll just combine them with calc(). unit = eCSSUnit_Calc; } if (!AddCSSValuePixelPercentCalc(restrictions, unit, aCoeff1, funcArg1, aCoeff2, funcArg2, resultArg)) { return nullptr; } break; } case eCSSKeyword_grayscale: case eCSSKeyword_invert: case eCSSKeyword_sepia: initialVal = 0.0f; MOZ_FALLTHROUGH; case eCSSKeyword_brightness: case eCSSKeyword_contrast: case eCSSKeyword_opacity: case eCSSKeyword_saturate: AddCSSValuePercentNumber(restrictions, aCoeff1, funcArg1, aCoeff2, funcArg2, resultArg, initialVal); break; case eCSSKeyword_hue_rotate: AddCSSValueAngle(aCoeff1, funcArg1, aCoeff2, funcArg2, resultArg); break; case eCSSKeyword_drop_shadow: { MOZ_ASSERT(!funcArg1.GetListValue()->mNext && !funcArg2.GetListValue()->mNext, "drop-shadow filter func doesn't support lists"); UniquePtr<nsCSSValueList> shadowValue = AddWeightedShadowItems(aCoeff1, funcArg1.GetListValue()->mValue, aCoeff2, funcArg2.GetListValue()->mValue, aColorAdditionType); if (!shadowValue) { return nullptr; } resultArg.AdoptListValue(Move(shadowValue)); break; } default: MOZ_ASSERT(false, "unknown filter function"); return nullptr; } return resultList; } static UniquePtr<nsCSSValueList> AddWeightedFilterFunction(double aCoeff1, const nsCSSValueList* aList1, double aCoeff2, const nsCSSValueList* aList2, ColorAdditionType aColorAdditionType) { MOZ_ASSERT(aList1 || aList2, "one function list item must not be null"); // Note that one of our arguments could be null, indicating that // it's the initial value. Rather than adding special null-handling // logic, we just check for null values and replace them with // 0 * the other value. That way, AddWeightedFilterFunctionImpl can assume // its args are non-null. if (!aList1) { return AddWeightedFilterFunctionImpl(aCoeff2, aList2, 0, aList2, aColorAdditionType); } if (!aList2) { return AddWeightedFilterFunctionImpl(aCoeff1, aList1, 0, aList1, aColorAdditionType); } return AddWeightedFilterFunctionImpl(aCoeff1, aList1, aCoeff2, aList2, aColorAdditionType); } static inline uint32_t ShapeArgumentCount(nsCSSKeyword aShapeFunction) { switch (aShapeFunction) { case eCSSKeyword_circle: return 2; // radius and center point case eCSSKeyword_polygon: return 2; // fill rule and a list of points case eCSSKeyword_ellipse: return 3; // two radii and center point case eCSSKeyword_inset: return 5; // four edge offsets and a list of corner radii default: MOZ_ASSERT_UNREACHABLE("Unknown shape type"); return 0; } } static void AddPositions(double aCoeff1, const nsCSSValue& aPos1, double aCoeff2, const nsCSSValue& aPos2, nsCSSValue& aResultPos) { MOZ_ASSERT(aPos1.GetUnit() == eCSSUnit_Array && aPos2.GetUnit() == eCSSUnit_Array, "Args should be CSS <position>s, encoded as arrays"); const nsCSSValue::Array* posArray1 = aPos1.GetArrayValue(); const nsCSSValue::Array* posArray2 = aPos2.GetArrayValue(); MOZ_ASSERT(posArray1->Count() == 4 && posArray2->Count() == 4, "CSSParserImpl::ParsePositionValue creates an array of length " "4 - how did we get here?"); nsCSSValue::Array* resultPosArray = nsCSSValue::Array::Create(4); aResultPos.SetArrayValue(resultPosArray, eCSSUnit_Array); // Only iterate over elements 1 and 3. The <position> is 'uncomputed' to // only those elements. See also the comment in SetPositionValue. for (size_t i = 1; i < 4; i += 2) { const nsCSSValue& v1 = posArray1->Item(i); const nsCSSValue& v2 = posArray2->Item(i); nsCSSValue& vr = resultPosArray->Item(i); AddCSSValueCanonicalCalc(aCoeff1, v1, aCoeff2, v2, vr); } } static Maybe<nsCSSValuePair> AddCSSValuePair(nsCSSPropertyID aProperty, uint32_t aRestrictions, double aCoeff1, const nsCSSValuePair* aPair1, double aCoeff2, const nsCSSValuePair* aPair2) { MOZ_ASSERT(aPair1, "expected pair"); MOZ_ASSERT(aPair2, "expected pair"); Maybe<nsCSSValuePair> result; nsCSSUnit unit[2]; unit[0] = GetCommonUnit(aProperty, aPair1->mXValue.GetUnit(), aPair2->mXValue.GetUnit()); unit[1] = GetCommonUnit(aProperty, aPair1->mYValue.GetUnit(), aPair2->mYValue.GetUnit()); if (unit[0] == eCSSUnit_Null || unit[1] == eCSSUnit_Null || unit[0] == eCSSUnit_URL || unit[0] == eCSSUnit_Enumerated) { return result; // Nothing() (returning |result| for RVO) } result.emplace(); static nsCSSValue nsCSSValuePair::* const pairValues[2] = { &nsCSSValuePair::mXValue, &nsCSSValuePair::mYValue }; for (uint32_t i = 0; i < 2; ++i) { nsCSSValue nsCSSValuePair::*member = pairValues[i]; if (!AddCSSValuePixelPercentCalc(aRestrictions, unit[i], aCoeff1, aPair1->*member, aCoeff2, aPair2->*member, result.ref().*member) ) { MOZ_ASSERT(false, "unexpected unit"); result.reset(); return result; // Nothing() (returning |result| for RVO) } } return result; } static UniquePtr<nsCSSValuePairList> AddCSSValuePairList(nsCSSPropertyID aProperty, double aCoeff1, const nsCSSValuePairList* aList1, double aCoeff2, const nsCSSValuePairList* aList2) { MOZ_ASSERT(aList1, "Can't add a null list"); MOZ_ASSERT(aList2, "Can't add a null list"); auto result = MakeUnique<nsCSSValuePairList>(); nsCSSValuePairList* resultPtr = result.get(); do { static nsCSSValue nsCSSValuePairList::* const pairListValues[] = { &nsCSSValuePairList::mXValue, &nsCSSValuePairList::mYValue, }; uint32_t restrictions = nsCSSProps::ValueRestrictions(aProperty); for (uint32_t i = 0; i < ArrayLength(pairListValues); ++i) { const nsCSSValue& v1 = aList1->*(pairListValues[i]); const nsCSSValue& v2 = aList2->*(pairListValues[i]); nsCSSValue& vr = resultPtr->*(pairListValues[i]); nsCSSUnit unit = GetCommonUnit(aProperty, v1.GetUnit(), v2.GetUnit()); if (unit == eCSSUnit_Null) { return nullptr; } if (!AddCSSValuePixelPercentCalc(restrictions, unit, aCoeff1, v1, aCoeff2, v2, vr)) { if (v1 != v2) { return nullptr; } vr = v1; } } aList1 = aList1->mNext; aList2 = aList2->mNext; if (!aList1 || !aList2) { break; } resultPtr->mNext = new nsCSSValuePairList; resultPtr = resultPtr->mNext; } while (aList1 && aList2); if (aList1 || aList2) { return nullptr; // We can't interpolate lists of different lengths } return result; } static already_AddRefed<nsCSSValue::Array> AddShapeFunction(nsCSSPropertyID aProperty, double aCoeff1, const nsCSSValue::Array* aArray1, double aCoeff2, const nsCSSValue::Array* aArray2, Restrictions aRestriction) { MOZ_ASSERT(aArray1 && aArray1->Count() == 2, "expected shape function"); MOZ_ASSERT(aArray2 && aArray2->Count() == 2, "expected shape function"); MOZ_ASSERT(aArray1->Item(0).GetUnit() == eCSSUnit_Function, "expected function"); MOZ_ASSERT(aArray2->Item(0).GetUnit() == eCSSUnit_Function, "expected function"); MOZ_ASSERT(aArray1->Item(1).GetUnit() == eCSSUnit_Enumerated, "expected geometry-box"); MOZ_ASSERT(aArray2->Item(1).GetUnit() == eCSSUnit_Enumerated, "expected geometry-box"); if (aArray1->Item(1).GetIntValue() != aArray2->Item(1).GetIntValue()) { return nullptr; // Both shapes must use the same reference box. } const nsCSSValue::Array* func1 = aArray1->Item(0).GetArrayValue(); const nsCSSValue::Array* func2 = aArray2->Item(0).GetArrayValue(); nsCSSKeyword shapeFuncName = func1->Item(0).GetKeywordValue(); if (shapeFuncName != func2->Item(0).GetKeywordValue()) { return nullptr; // Can't add two shapes of different types. } RefPtr<nsCSSValue::Array> result = nsCSSValue::Array::Create(2); nsCSSValue::Array* resultFuncArgs = result->Item(0).InitFunction(shapeFuncName, ShapeArgumentCount(shapeFuncName)); switch (shapeFuncName) { case eCSSKeyword_ellipse: // Add ellipses' |ry| values (but fail if we encounter an enum): if (!AddCSSValuePixelPercentCalc(aRestriction == Restrictions::Enable ? CSS_PROPERTY_VALUE_NONNEGATIVE : 0, GetCommonUnit(aProperty, func1->Item(2).GetUnit(), func2->Item(2).GetUnit()), aCoeff1, func1->Item(2), aCoeff2, func2->Item(2), resultFuncArgs->Item(2))) { return nullptr; } MOZ_FALLTHROUGH; // to handle rx and center point case eCSSKeyword_circle: { // Add circles' |r| (or ellipses' |rx|) values: if (!AddCSSValuePixelPercentCalc(aRestriction == Restrictions::Enable ? CSS_PROPERTY_VALUE_NONNEGATIVE : 0, GetCommonUnit(aProperty, func1->Item(1).GetUnit(), func2->Item(1).GetUnit()), aCoeff1, func1->Item(1), aCoeff2, func2->Item(1), resultFuncArgs->Item(1))) { return nullptr; } // Add center points (defined as a <position>). size_t posIndex = shapeFuncName == eCSSKeyword_circle ? 2 : 3; AddPositions(aCoeff1, func1->Item(posIndex), aCoeff2, func2->Item(posIndex), resultFuncArgs->Item(posIndex)); break; } case eCSSKeyword_polygon: { // Add polygons' corresponding points (if the fill rule matches): int32_t fillRule = func1->Item(1).GetIntValue(); if (fillRule != func2->Item(1).GetIntValue()) { return nullptr; // can't interpolate between different fill rules } resultFuncArgs->Item(1).SetIntValue(fillRule, eCSSUnit_Enumerated); const nsCSSValuePairList* points1 = func1->Item(2).GetPairListValue(); const nsCSSValuePairList* points2 = func2->Item(2).GetPairListValue(); UniquePtr<nsCSSValuePairList> resultPoints = AddCSSValuePairList(aProperty, aCoeff1, points1, aCoeff2, points2); if (!resultPoints) { return nullptr; } resultFuncArgs->Item(2).AdoptPairListValue(Move(resultPoints)); break; } case eCSSKeyword_inset: { MOZ_ASSERT(func1->Count() == 6 && func2->Count() == 6, "Update for CSSParserImpl::ParseInsetFunction changes"); // Items 1-4 are respectively the top, right, bottom and left offsets // from the reference box. for (size_t i = 1; i <= 4; ++i) { if (!AddCSSValuePixelPercentCalc(aRestriction == Restrictions::Enable ? CSS_PROPERTY_VALUE_NONNEGATIVE : 0, GetCommonUnit(aProperty, func1->Item(i).GetUnit(), func2->Item(i).GetUnit()), aCoeff1, func1->Item(i), aCoeff2, func2->Item(i), resultFuncArgs->Item(i))) { return nullptr; } } // Item 5 contains the radii of the rounded corners for the inset // rectangle. MOZ_ASSERT(func1->Item(5).GetUnit() == eCSSUnit_Array && func2->Item(5).GetUnit() == eCSSUnit_Array, "Expected two arrays"); const nsCSSValue::Array* radii1 = func1->Item(5).GetArrayValue(); const nsCSSValue::Array* radii2 = func2->Item(5).GetArrayValue(); MOZ_ASSERT(radii1->Count() == 4 && radii2->Count() == 4); nsCSSValue::Array* resultRadii = nsCSSValue::Array::Create(4); resultFuncArgs->Item(5).SetArrayValue(resultRadii, eCSSUnit_Array); // We use an arbitrary border-radius property here to get the appropriate // restrictions for radii since this is a <border-radius> value. uint32_t restrictions = aRestriction == Restrictions::Enable ? nsCSSProps::ValueRestrictions(eCSSProperty_border_top_left_radius) : 0; for (size_t i = 0; i < 4; ++i) { const nsCSSValuePair& pair1 = radii1->Item(i).GetPairValue(); const nsCSSValuePair& pair2 = radii2->Item(i).GetPairValue(); const Maybe<nsCSSValuePair> pairResult = AddCSSValuePair(aProperty, restrictions, aCoeff1, &pair1, aCoeff2, &pair2); if (!pairResult) { return nullptr; } resultRadii->Item(i).SetPairValue(pairResult.ptr()); } break; } default: MOZ_ASSERT_UNREACHABLE("Unknown shape type"); return nullptr; } // set the geometry-box value result->Item(1).SetIntValue(aArray1->Item(1).GetIntValue(), eCSSUnit_Enumerated); return result.forget(); } static nsCSSValueList* AddTransformLists(double aCoeff1, const nsCSSValueList* aList1, double aCoeff2, const nsCSSValueList* aList2) { nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); do { RefPtr<nsCSSValue::Array> a1 = ToPrimitive(aList1->mValue.GetArrayValue()), a2 = ToPrimitive(aList2->mValue.GetArrayValue()); MOZ_ASSERT( TransformFunctionsMatch(nsStyleTransformMatrix::TransformFunctionOf(a1), nsStyleTransformMatrix::TransformFunctionOf(a2)), "transform function mismatch"); MOZ_ASSERT(!*resultTail, "resultTail isn't pointing to the tail (may leak)"); nsCSSKeyword tfunc = nsStyleTransformMatrix::TransformFunctionOf(a1); RefPtr<nsCSSValue::Array> arr; if (tfunc != eCSSKeyword_matrix && tfunc != eCSSKeyword_matrix3d && tfunc != eCSSKeyword_interpolatematrix && tfunc != eCSSKeyword_rotate3d && tfunc != eCSSKeyword_perspective) { arr = StyleAnimationValue::AppendTransformFunction(tfunc, resultTail); } switch (tfunc) { case eCSSKeyword_translate3d: { MOZ_ASSERT(a1->Count() == 4, "unexpected count"); MOZ_ASSERT(a2->Count() == 4, "unexpected count"); AddTransformTranslate(aCoeff1, a1->Item(1), aCoeff2, a2->Item(1), arr->Item(1)); AddTransformTranslate(aCoeff1, a1->Item(2), aCoeff2, a2->Item(2), arr->Item(2)); AddTransformTranslate(aCoeff1, a1->Item(3), aCoeff2, a2->Item(3), arr->Item(3)); break; } case eCSSKeyword_scale3d: { MOZ_ASSERT(a1->Count() == 4, "unexpected count"); MOZ_ASSERT(a2->Count() == 4, "unexpected count"); AddTransformScale(aCoeff1, a1->Item(1), aCoeff2, a2->Item(1), arr->Item(1)); AddTransformScale(aCoeff1, a1->Item(2), aCoeff2, a2->Item(2), arr->Item(2)); AddTransformScale(aCoeff1, a1->Item(3), aCoeff2, a2->Item(3), arr->Item(3)); break; } // It would probably be nicer to animate skew in tangent space // rather than angle space. However, it's easy to specify // skews with infinite tangents, and behavior changes pretty // drastically when crossing such skews (since the direction of // animation flips), so interop is probably more important here. case eCSSKeyword_skew: { MOZ_ASSERT(a1->Count() == 2 || a1->Count() == 3, "unexpected count"); MOZ_ASSERT(a2->Count() == 2 || a2->Count() == 3, "unexpected count"); nsCSSValue zero(0.0f, eCSSUnit_Radian); // Add Y component of skew. AddCSSValueAngle(aCoeff1, a1->Count() == 3 ? a1->Item(2) : zero, aCoeff2, a2->Count() == 3 ? a2->Item(2) : zero, arr->Item(2)); // Add X component of skew (which can be merged with case below // in non-DEBUG). AddCSSValueAngle(aCoeff1, a1->Item(1), aCoeff2, a2->Item(1), arr->Item(1)); break; } case eCSSKeyword_skewx: case eCSSKeyword_skewy: case eCSSKeyword_rotate: case eCSSKeyword_rotatex: case eCSSKeyword_rotatey: case eCSSKeyword_rotatez: { MOZ_ASSERT(a1->Count() == 2, "unexpected count"); MOZ_ASSERT(a2->Count() == 2, "unexpected count"); AddCSSValueAngle(aCoeff1, a1->Item(1), aCoeff2, a2->Item(1), arr->Item(1)); break; } case eCSSKeyword_rotate3d: { Point3D vector1(a1->Item(1).GetFloatValue(), a1->Item(2).GetFloatValue(), a1->Item(3).GetFloatValue()); vector1.Normalize(); Point3D vector2(a2->Item(1).GetFloatValue(), a2->Item(2).GetFloatValue(), a2->Item(3).GetFloatValue()); vector2.Normalize(); // Handle rotate3d with matched (normalized) vectors, // otherwise fallthrough to the next switch statement // and do matrix decomposition. if (vector1 == vector2) { // We skipped appending a transform function above for rotate3d, // so do it now. arr = StyleAnimationValue::AppendTransformFunction(tfunc, resultTail); arr->Item(1).SetFloatValue(vector1.x, eCSSUnit_Number); arr->Item(2).SetFloatValue(vector1.y, eCSSUnit_Number); arr->Item(3).SetFloatValue(vector1.z, eCSSUnit_Number); AddCSSValueAngle(aCoeff1, a1->Item(4), aCoeff2, a2->Item(4), arr->Item(4)); break; } MOZ_FALLTHROUGH; } case eCSSKeyword_matrix: case eCSSKeyword_matrix3d: case eCSSKeyword_perspective: if (aCoeff1 == 0.0 && aCoeff2 == 0.0) { // Special case. If both coefficients are 0.0, we should apply an // identity transform function. arr = StyleAnimationValue::AppendTransformFunction(tfunc, resultTail); if (tfunc == eCSSKeyword_rotate3d) { arr->Item(1).SetFloatValue(0.0, eCSSUnit_Number); arr->Item(2).SetFloatValue(0.0, eCSSUnit_Number); arr->Item(3).SetFloatValue(1.0, eCSSUnit_Number); arr->Item(4).SetFloatValue(0.0, eCSSUnit_Radian); } else if (tfunc == eCSSKeyword_perspective) { // The parameter of the identity perspective function is // positive infinite. arr->Item(1).SetFloatValue(std::numeric_limits<float>::infinity(), eCSSUnit_Pixel); } else { nsStyleTransformMatrix::SetIdentityMatrix(arr); } break; } MOZ_FALLTHROUGH; case eCSSKeyword_interpolatematrix: { // FIXME: If the matrix contains only numbers then we could decompose // here. // Construct temporary lists with only this item in them. nsCSSValueList tempList1, tempList2; tempList1.mValue = aList1->mValue; tempList2.mValue = aList2->mValue; if (aList1 == aList2) { *resultTail = AddDifferentTransformLists(aCoeff1, &tempList1, aCoeff2, &tempList1); } else { *resultTail = AddDifferentTransformLists(aCoeff1, &tempList1, aCoeff2, &tempList2); } // Now advance resultTail to point to the new tail slot. while (*resultTail) { resultTail = &(*resultTail)->mNext; } break; } default: MOZ_ASSERT(false, "unknown transform function"); } aList1 = aList1->mNext; aList2 = aList2->mNext; } while (aList1); MOZ_ASSERT(!aList2, "list length mismatch"); MOZ_ASSERT(!*resultTail, "resultTail isn't pointing to the tail"); return result.forget(); } static void AddPositionCoords(double aCoeff1, const nsCSSValue& aPos1, double aCoeff2, const nsCSSValue& aPos2, nsCSSValue& aResultPos) { const nsCSSValue::Array* posArray1 = aPos1.GetArrayValue(); const nsCSSValue::Array* posArray2 = aPos2.GetArrayValue(); nsCSSValue::Array* resultPosArray = nsCSSValue::Array::Create(2); aResultPos.SetArrayValue(resultPosArray, eCSSUnit_Array); /* Only compute element 1. The <position-coord> is * 'uncomputed' to only that element. */ const nsCSSValue& v1 = posArray1->Item(1); const nsCSSValue& v2 = posArray2->Item(1); nsCSSValue& vr = resultPosArray->Item(1); AddCSSValueCanonicalCalc(aCoeff1, v1, aCoeff2, v2, vr); } static UniquePtr<nsCSSValueList> AddWeightedShadowList(double aCoeff1, const nsCSSValueList* aShadow1, double aCoeff2, const nsCSSValueList* aShadow2, ColorAdditionType aColorAdditionType) { // This is implemented according to: // http://dev.w3.org/csswg/css3-transitions/#animation-of-property-types- // and the third item in the summary of: // http://lists.w3.org/Archives/Public/www-style/2009Jul/0050.html UniquePtr<nsCSSValueList> result; nsCSSValueList* tail = nullptr; while (aShadow1 && aShadow2) { UniquePtr<nsCSSValueList> shadowValue = AddWeightedShadowItems(aCoeff1, aShadow1->mValue, aCoeff2, aShadow2->mValue, aColorAdditionType); if (!shadowValue) { return nullptr; } aShadow1 = aShadow1->mNext; aShadow2 = aShadow2->mNext; AppendToCSSValueList(result, Move(shadowValue), &tail); } if (aShadow1 || aShadow2) { const nsCSSValueList *longShadow; double longCoeff; if (aShadow1) { longShadow = aShadow1; longCoeff = aCoeff1; } else { longShadow = aShadow2; longCoeff = aCoeff2; } while (longShadow) { // Passing coefficients that add to less than 1 produces the // desired result of interpolating "0 0 0 transparent" with // the current shadow. UniquePtr<nsCSSValueList> shadowValue = AddWeightedShadowItems(longCoeff, longShadow->mValue, 0.0, longShadow->mValue, aColorAdditionType); if (!shadowValue) { return nullptr; } longShadow = longShadow->mNext; AppendToCSSValueList(result, Move(shadowValue), &tail); } } return result; } static UniquePtr<nsCSSValueList> AddWeightedFilterList(double aCoeff1, const nsCSSValueList* aList1, double aCoeff2, const nsCSSValueList* aList2, ColorAdditionType aColorAdditionType) { UniquePtr<nsCSSValueList> result; nsCSSValueList* tail = nullptr; while (aList1 || aList2) { if ((aList1 && aList1->mValue.GetUnit() != eCSSUnit_Function) || (aList2 && aList2->mValue.GetUnit() != eCSSUnit_Function)) { // If we don't have filter-functions, we must have filter-URLs, which // we can't add or interpolate. return nullptr; } UniquePtr<nsCSSValueList> resultFunction = AddWeightedFilterFunction(aCoeff1, aList1, aCoeff2, aList2, aColorAdditionType); if (!resultFunction) { // filter function mismatch return nullptr; } AppendToCSSValueList(result, Move(resultFunction), &tail); // move to next aList items if (aList1) { aList1 = aList1->mNext; } if (aList2) { aList2 = aList2->mNext; } } return result; } bool StyleAnimationValue::AddWeighted(nsCSSPropertyID aProperty, double aCoeff1, const StyleAnimationValue& aValue1, double aCoeff2, const StyleAnimationValue& aValue2, StyleAnimationValue& aResultValue) { Unit commonUnit = GetCommonUnit(aProperty, aValue1.GetUnit(), aValue2.GetUnit()); // Maybe need a followup method to convert the inputs into the common // unit-type, if they don't already match it. (Or would it make sense to do // that in GetCommonUnit? in which case maybe ConvertToCommonUnit would be // better.) switch (commonUnit) { case eUnit_Null: case eUnit_Auto: case eUnit_None: case eUnit_Normal: case eUnit_UnparsedString: case eUnit_URL: case eUnit_DiscreteCSSValue: return false; case eUnit_Enumerated: switch (aProperty) { case eCSSProperty_font_stretch: { // Animate just like eUnit_Integer. int32_t result = floor(aCoeff1 * double(aValue1.GetIntValue()) + aCoeff2 * double(aValue2.GetIntValue())); if (result < NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED) { result = NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED; } else if (result > NS_STYLE_FONT_STRETCH_ULTRA_EXPANDED) { result = NS_STYLE_FONT_STRETCH_ULTRA_EXPANDED; } aResultValue.SetIntValue(result, eUnit_Enumerated); return true; } default: return false; } case eUnit_Visibility: { int32_t enum1 = aValue1.GetIntValue(); int32_t enum2 = aValue2.GetIntValue(); if (enum1 == enum2) { aResultValue.SetIntValue(enum1, eUnit_Visibility); return true; } if ((enum1 == NS_STYLE_VISIBILITY_VISIBLE) == (enum2 == NS_STYLE_VISIBILITY_VISIBLE)) { return false; } int32_t val1 = enum1 == NS_STYLE_VISIBILITY_VISIBLE; int32_t val2 = enum2 == NS_STYLE_VISIBILITY_VISIBLE; double interp = aCoeff1 * val1 + aCoeff2 * val2; int32_t result = interp > 0.0 ? NS_STYLE_VISIBILITY_VISIBLE : (val1 ? enum2 : enum1); aResultValue.SetIntValue(result, eUnit_Visibility); return true; } case eUnit_Integer: { // http://dev.w3.org/csswg/css3-transitions/#animation-of-property-types- // says we should use floor int32_t result = floor(aCoeff1 * double(aValue1.GetIntValue()) + aCoeff2 * double(aValue2.GetIntValue())); if (aProperty == eCSSProperty_font_weight) { if (result < 100) { result = 100; } else if (result > 900) { result = 900; } result -= result % 100; } else { result = RestrictValue(aProperty, result); } aResultValue.SetIntValue(result, eUnit_Integer); return true; } case eUnit_Coord: { aResultValue.SetCoordValue(RestrictValue(aProperty, NSToCoordRound( aCoeff1 * aValue1.GetCoordValue() + aCoeff2 * aValue2.GetCoordValue()))); return true; } case eUnit_Percent: { aResultValue.SetPercentValue(RestrictValue(aProperty, aCoeff1 * aValue1.GetPercentValue() + aCoeff2 * aValue2.GetPercentValue())); return true; } case eUnit_Float: { aResultValue.SetFloatValue(RestrictValue(aProperty, aCoeff1 * aValue1.GetFloatValue() + aCoeff2 * aValue2.GetFloatValue())); return true; } case eUnit_Color: { RGBAColorData color1 = ExtractColor(aValue1); RGBAColorData color2 = ExtractColor(aValue2); auto resultColor = MakeUnique<nsCSSValue>(); resultColor->SetColorValue( AddWeightedColorsAndClamp(aCoeff1, color1, aCoeff2, color2)); aResultValue.SetAndAdoptCSSValueValue(resultColor.release(), eUnit_Color); return true; } case eUnit_CurrentColor: { aResultValue.SetCurrentColorValue(); return true; } case eUnit_ComplexColor: { ComplexColorData color1 = ExtractComplexColor(aValue1); ComplexColorData color2 = ExtractComplexColor(aValue2); RefPtr<ComplexColorValue> result = new ComplexColorValue; // Common case is interpolating between a color and a currentcolor. if (color1.IsNumericColor() && color2.IsCurrentColor()) { result->mColor = color1.mColor; result->mForegroundRatio = aCoeff2; } else if (color1.IsCurrentColor() && color2.IsNumericColor()) { result->mColor = color2.mColor; result->mForegroundRatio = aCoeff1; } else { float ratio1 = 1.0f - color1.mForegroundRatio; float ratio2 = 1.0f - color2.mForegroundRatio; float alpha1 = color1.mColor.mA * ratio1; float alpha2 = color2.mColor.mA * ratio2; RGBAColorData resultColor = AddWeightedColors(aCoeff1, color1.mColor.WithAlpha(alpha1), aCoeff2, color2.mColor.WithAlpha(alpha2)); float resultRatio = color1.mForegroundRatio * aCoeff1 + color2.mForegroundRatio * aCoeff2; float resultAlpha = resultColor.mA / (1.0f - resultRatio); result->mColor = resultColor.WithAlpha(resultAlpha); result->mForegroundRatio = resultRatio; } aResultValue.SetComplexColorValue(result.forget()); return true; } case eUnit_Calc: { PixelCalcValue v1 = ExtractCalcValue(aValue1); PixelCalcValue v2 = ExtractCalcValue(aValue2); double len = aCoeff1 * v1.mLength + aCoeff2 * v2.mLength; double pct = aCoeff1 * v1.mPercent + aCoeff2 * v2.mPercent; bool hasPct = (aCoeff1 != 0.0 && v1.mHasPercent) || (aCoeff2 != 0.0 && v2.mHasPercent); nsCSSValue *val = new nsCSSValue(); nsCSSValue::Array *arr = nsCSSValue::Array::Create(1); val->SetArrayValue(arr, eCSSUnit_Calc); if (hasPct) { nsCSSValue::Array *arr2 = nsCSSValue::Array::Create(2); arr2->Item(0).SetFloatValue(len, eCSSUnit_Pixel); arr2->Item(1).SetPercentValue(pct); arr->Item(0).SetArrayValue(arr2, eCSSUnit_Calc_Plus); } else { arr->Item(0).SetFloatValue(len, eCSSUnit_Pixel); } aResultValue.SetAndAdoptCSSValueValue(val, eUnit_Calc); return true; } case eUnit_ObjectPosition: { const nsCSSValue* position1 = aValue1.GetCSSValueValue(); const nsCSSValue* position2 = aValue2.GetCSSValueValue(); nsAutoPtr<nsCSSValue> result(new nsCSSValue); AddPositions(aCoeff1, *position1, aCoeff2, *position2, *result); aResultValue.SetAndAdoptCSSValueValue(result.forget(), eUnit_ObjectPosition); return true; } case eUnit_CSSValuePair: { uint32_t restrictions = nsCSSProps::ValueRestrictions(aProperty); Maybe<nsCSSValuePair> result = AddCSSValuePair(aProperty, restrictions, aCoeff1, aValue1.GetCSSValuePairValue(), aCoeff2, aValue2.GetCSSValuePairValue()); if (!result) { return false; } // We need a heap allocated object to adopt here: auto heapResult = MakeUnique<nsCSSValuePair>(*result); aResultValue.SetAndAdoptCSSValuePairValue(heapResult.release(), eUnit_CSSValuePair); return true; } case eUnit_CSSValueTriplet: { nsCSSValueTriplet triplet1(*aValue1.GetCSSValueTripletValue()); nsCSSValueTriplet triplet2(*aValue2.GetCSSValueTripletValue()); nsCSSUnit unit[3]; unit[0] = GetCommonUnit(aProperty, triplet1.mXValue.GetUnit(), triplet2.mXValue.GetUnit()); unit[1] = GetCommonUnit(aProperty, triplet1.mYValue.GetUnit(), triplet2.mYValue.GetUnit()); unit[2] = GetCommonUnit(aProperty, triplet1.mZValue.GetUnit(), triplet2.mZValue.GetUnit()); if (unit[0] == eCSSUnit_Null || unit[1] == eCSSUnit_Null || unit[2] == eCSSUnit_Null) { return false; } nsAutoPtr<nsCSSValueTriplet> result(new nsCSSValueTriplet); static nsCSSValue nsCSSValueTriplet::* const tripletValues[3] = { &nsCSSValueTriplet::mXValue, &nsCSSValueTriplet::mYValue, &nsCSSValueTriplet::mZValue }; uint32_t restrictions = nsCSSProps::ValueRestrictions(aProperty); for (uint32_t i = 0; i < 3; ++i) { nsCSSValue nsCSSValueTriplet::*member = tripletValues[i]; if (!AddCSSValuePixelPercentCalc(restrictions, unit[i], aCoeff1, &triplet1->*member, aCoeff2, &triplet2->*member, result->*member) ) { MOZ_ASSERT(false, "unexpected unit"); return false; } } aResultValue.SetAndAdoptCSSValueTripletValue(result.forget(), eUnit_CSSValueTriplet); return true; } case eUnit_CSSRect: { MOZ_ASSERT(nsCSSProps::ValueRestrictions(aProperty) == 0, "must add code for handling value restrictions"); const nsCSSRect *rect1 = aValue1.GetCSSRectValue(); const nsCSSRect *rect2 = aValue2.GetCSSRectValue(); if (rect1->mTop.GetUnit() != rect2->mTop.GetUnit() || rect1->mRight.GetUnit() != rect2->mRight.GetUnit() || rect1->mBottom.GetUnit() != rect2->mBottom.GetUnit() || rect1->mLeft.GetUnit() != rect2->mLeft.GetUnit()) { // At least until we have calc() return false; } nsAutoPtr<nsCSSRect> result(new nsCSSRect); for (uint32_t i = 0; i < ArrayLength(nsCSSRect::sides); ++i) { nsCSSValue nsCSSRect::*member = nsCSSRect::sides[i]; MOZ_ASSERT((rect1->*member).GetUnit() == (rect2->*member).GetUnit(), "should have returned above"); switch ((rect1->*member).GetUnit()) { case eCSSUnit_Pixel: AddCSSValuePixel(aCoeff1, rect1->*member, aCoeff2, rect2->*member, result->*member); break; case eCSSUnit_Auto: if (float(aCoeff1 + aCoeff2) != 1.0f) { // Interpolating between two auto values makes sense; // adding in other ratios does not. return false; } (result->*member).SetAutoValue(); break; default: MOZ_ASSERT(false, "unexpected unit"); return false; } } aResultValue.SetAndAdoptCSSRectValue(result.forget(), eUnit_CSSRect); return true; } case eUnit_Dasharray: { const nsCSSValueList *list1 = aValue1.GetCSSValueListValue(); const nsCSSValueList *list2 = aValue2.GetCSSValueListValue(); uint32_t len1 = 0, len2 = 0; for (const nsCSSValueList *v = list1; v; v = v->mNext) { ++len1; } for (const nsCSSValueList *v = list2; v; v = v->mNext) { ++len2; } MOZ_ASSERT(len1 > 0 && len2 > 0, "unexpected length"); nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); for (uint32_t i = 0, i_end = EuclidLCM<uint32_t>(len1, len2); i != i_end; ++i) { const nsCSSValue &v1 = list1->mValue; const nsCSSValue &v2 = list2->mValue; MOZ_ASSERT(v1.GetUnit() == eCSSUnit_Number || v1.GetUnit() == eCSSUnit_Percent, "unexpected"); MOZ_ASSERT(v2.GetUnit() == eCSSUnit_Number || v2.GetUnit() == eCSSUnit_Percent, "unexpected"); if (v1.GetUnit() != v2.GetUnit()) { // Can't animate between lengths and percentages (until calc()). return false; } nsCSSValueList *item = new nsCSSValueList; *resultTail = item; resultTail = &item->mNext; if (v1.GetUnit() == eCSSUnit_Number) { AddCSSValueNumber(aCoeff1, v1, aCoeff2, v2, item->mValue, CSS_PROPERTY_VALUE_NONNEGATIVE); } else { AddCSSValuePercent(aCoeff1, v1, aCoeff2, v2, item->mValue, CSS_PROPERTY_VALUE_NONNEGATIVE); } list1 = list1->mNext; if (!list1) { list1 = aValue1.GetCSSValueListValue(); } list2 = list2->mNext; if (!list2) { list2 = aValue2.GetCSSValueListValue(); } } aResultValue.SetAndAdoptCSSValueListValue(result.forget(), eUnit_Dasharray); return true; } case eUnit_Shadow: { UniquePtr<nsCSSValueList> result = AddWeightedShadowList(aCoeff1, aValue1.GetCSSValueListValue(), aCoeff2, aValue2.GetCSSValueListValue(), ColorAdditionType::Clamped); if (!result) { return false; } aResultValue.SetAndAdoptCSSValueListValue(result.release(), eUnit_Shadow); return true; } case eUnit_Shape: { RefPtr<nsCSSValue::Array> result = AddShapeFunction(aProperty, aCoeff1, aValue1.GetCSSValueArrayValue(), aCoeff2, aValue2.GetCSSValueArrayValue()); if (!result) { return false; } aResultValue.SetCSSValueArrayValue(result, eUnit_Shape); return true; } case eUnit_Filter: { UniquePtr<nsCSSValueList> result = AddWeightedFilterList(aCoeff1, aValue1.GetCSSValueListValue(), aCoeff2, aValue2.GetCSSValueListValue(), ColorAdditionType::Clamped); if (!result) { return false; } aResultValue.SetAndAdoptCSSValueListValue(result.release(), eUnit_Filter); return true; } case eUnit_Transform: { const nsCSSValueList* list1 = aValue1.GetCSSValueSharedListValue()->mHead; const nsCSSValueList* list2 = aValue2.GetCSSValueSharedListValue()->mHead; MOZ_ASSERT(list1); MOZ_ASSERT(list2); // We want to avoid the matrix decomposition when we can, since // avoiding it can produce better results both for compound // transforms and for skew and skewY (see below). We can do this // in two cases: // (1) if one of the transforms is 'none' // (2) if the lists have the same length and the transform // functions match nsAutoPtr<nsCSSValueList> result; if (list1->mValue.GetUnit() == eCSSUnit_None) { if (list2->mValue.GetUnit() == eCSSUnit_None) { result = new nsCSSValueList; if (result) { result->mValue.SetNoneValue(); } } else { result = AddTransformLists(0, list2, aCoeff2, list2); } } else { if (list2->mValue.GetUnit() == eCSSUnit_None) { result = AddTransformLists(0, list1, aCoeff1, list1); } else { bool match = true; { const nsCSSValueList *item1 = list1, *item2 = list2; do { nsCSSKeyword func1 = nsStyleTransformMatrix::TransformFunctionOf( item1->mValue.GetArrayValue()); nsCSSKeyword func2 = nsStyleTransformMatrix::TransformFunctionOf( item2->mValue.GetArrayValue()); if (!TransformFunctionsMatch(func1, func2)) { break; } item1 = item1->mNext; item2 = item2->mNext; } while (item1 && item2); if (item1 || item2) { // Either |break| above or length mismatch. match = false; } } if (match) { result = AddTransformLists(aCoeff1, list1, aCoeff2, list2); } else { result = AddDifferentTransformLists(aCoeff1, list1, aCoeff2, list2); } } } aResultValue.SetTransformValue(new nsCSSValueSharedList(result.forget())); return true; } case eUnit_BackgroundPositionCoord: { const nsCSSValueList *position1 = aValue1.GetCSSValueListValue(); const nsCSSValueList *position2 = aValue2.GetCSSValueListValue(); nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); while (position1 && position2) { nsCSSValueList *item = new nsCSSValueList; *resultTail = item; resultTail = &item->mNext; AddPositionCoords(aCoeff1, position1->mValue, aCoeff2, position2->mValue, item->mValue); position1 = position1->mNext; position2 = position2->mNext; } // Check for different lengths if (position1 || position2) { return false; } aResultValue.SetAndAdoptCSSValueListValue(result.forget(), eUnit_BackgroundPositionCoord); return true; } case eUnit_CSSValuePairList: { const nsCSSValuePairList *list1 = aValue1.GetCSSValuePairListValue(); const nsCSSValuePairList *list2 = aValue2.GetCSSValuePairListValue(); UniquePtr<nsCSSValuePairList> result = AddCSSValuePairList(aProperty, aCoeff1, list1, aCoeff2, list2); if (!result) { return false; } aResultValue.SetAndAdoptCSSValuePairListValue(result.release()); return true; } } MOZ_ASSERT(false, "Can't interpolate using the given common unit"); return false; } bool StyleAnimationValue::Accumulate(nsCSSPropertyID aProperty, StyleAnimationValue& aDest, const StyleAnimationValue& aValueToAccumulate, uint64_t aCount) { Unit commonUnit = GetCommonUnit(aProperty, aDest.GetUnit(), aValueToAccumulate.GetUnit()); switch (commonUnit) { case eUnit_Filter: { UniquePtr<nsCSSValueList> result = AddWeightedFilterList(1.0, aDest.GetCSSValueListValue(), aCount, aValueToAccumulate.GetCSSValueListValue(), ColorAdditionType::Unclamped); if (!result) { return false; } aDest.SetAndAdoptCSSValueListValue(result.release(), eUnit_Filter); return true; } case eUnit_Shadow: { UniquePtr<nsCSSValueList> result = AddWeightedShadowList(1.0, aDest.GetCSSValueListValue(), aCount, aValueToAccumulate.GetCSSValueListValue(), ColorAdditionType::Unclamped); if (!result) { return false; } aDest.SetAndAdoptCSSValueListValue(result.release(), eUnit_Shadow); return true; } case eUnit_Color: { RGBAColorData color1 = ExtractColor(aDest); RGBAColorData color2 = ExtractColor(aValueToAccumulate); auto resultColor = MakeUnique<nsCSSValue>(); resultColor->SetRGBAColorValue( AddWeightedColors(1.0, color1, aCount, color2)); aDest.SetAndAdoptCSSValueValue(resultColor.release(), eUnit_Color); return true; } default: return Add(aProperty, aDest, aValueToAccumulate, aCount); } MOZ_ASSERT_UNREACHABLE("Can't accumulate using the given common unit"); return false; } already_AddRefed<css::StyleRule> BuildStyleRule(nsCSSPropertyID aProperty, dom::Element* aTargetElement, const nsAString& aSpecifiedValue, bool aUseSVGMode) { // Set up an empty CSS Declaration RefPtr<css::Declaration> declaration(new css::Declaration()); declaration->InitializeEmpty(); bool changed; // ignored, but needed as outparam for ParseProperty nsIDocument* doc = aTargetElement->OwnerDoc(); nsCOMPtr<nsIURI> baseURI = aTargetElement->GetBaseURI(); nsCSSParser parser(doc->CSSLoader()); nsCSSPropertyID propertyToCheck = nsCSSProps::IsShorthand(aProperty) ? nsCSSProps::SubpropertyEntryFor(aProperty)[0] : aProperty; // Get a parser, parse the property, and check for CSS parsing errors. // If this fails, we bail out and delete the declaration. parser.ParseProperty(aProperty, aSpecifiedValue, doc->GetDocumentURI(), baseURI, aTargetElement->NodePrincipal(), declaration, &changed, false, aUseSVGMode); // check whether property parsed without CSS parsing errors if (!declaration->HasNonImportantValueFor(propertyToCheck)) { return nullptr; } RefPtr<css::StyleRule> rule = new css::StyleRule(nullptr, declaration, 0, 0); return rule.forget(); } already_AddRefed<css::StyleRule> BuildStyleRule(nsCSSPropertyID aProperty, dom::Element* aTargetElement, const nsCSSValue& aSpecifiedValue, bool aUseSVGMode) { MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty), "Should be a longhand property"); // Check if longhand failed to parse correctly. if (aSpecifiedValue.GetUnit() == eCSSUnit_Null) { return nullptr; } // Set up an empty CSS Declaration RefPtr<css::Declaration> declaration(new css::Declaration()); declaration->InitializeEmpty(); // Add our longhand value nsCSSExpandedDataBlock block; declaration->ExpandTo(&block); block.AddLonghandProperty(aProperty, aSpecifiedValue); declaration->ValueAppended(aProperty); declaration->CompressFrom(&block); RefPtr<css::StyleRule> rule = new css::StyleRule(nullptr, declaration, 0, 0); return rule.forget(); } static bool ComputeValuesFromStyleContext( nsCSSPropertyID aProperty, CSSEnabledState aEnabledState, nsStyleContext* aStyleContext, nsTArray<PropertyStyleAnimationValuePair>& aValues) { // Extract computed value of our property (or all longhand components, if // aProperty is a shorthand) from the temporary style context if (nsCSSProps::IsShorthand(aProperty)) { CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(p, aProperty, aEnabledState) { if (nsCSSProps::kAnimTypeTable[*p] == eStyleAnimType_None) { // Skip non-animatable component longhands. continue; } PropertyStyleAnimationValuePair* pair = aValues.AppendElement(); pair->mProperty = *p; if (!StyleAnimationValue::ExtractComputedValue(*p, aStyleContext, pair->mValue)) { return false; } } return true; } PropertyStyleAnimationValuePair* pair = aValues.AppendElement(); pair->mProperty = aProperty; return StyleAnimationValue::ExtractComputedValue(aProperty, aStyleContext, pair->mValue); } static bool ComputeValuesFromStyleRule(nsCSSPropertyID aProperty, CSSEnabledState aEnabledState, nsStyleContext* aStyleContext, css::StyleRule* aStyleRule, nsTArray<PropertyStyleAnimationValuePair>& aValues, bool* aIsContextSensitive) { MOZ_ASSERT(aStyleContext); if (!nsCSSProps::IsEnabled(aProperty, aEnabledState)) { return false; } MOZ_ASSERT(aStyleContext->PresContext()->StyleSet()->IsGecko(), "ServoStyleSet should not use StyleAnimationValue for animations"); nsStyleSet* styleSet = aStyleContext->PresContext()->StyleSet()->AsGecko(); RefPtr<nsStyleContext> tmpStyleContext; if (aIsContextSensitive) { MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty), "to correctly set aIsContextSensitive for shorthand properties, " "this code must be adjusted"); nsCOMArray<nsIStyleRule> ruleArray; ruleArray.AppendObject(styleSet->InitialStyleRule()); css::Declaration* declaration = aStyleRule->GetDeclaration(); ruleArray.AppendObject(declaration); declaration->SetImmutable(); tmpStyleContext = styleSet->ResolveStyleByAddingRules(aStyleContext, ruleArray); if (!tmpStyleContext) { return false; } // Force walk of rule tree nsStyleStructID sid = nsCSSProps::kSIDTable[aProperty]; tmpStyleContext->StyleData(sid); // The rule node will have unconditional cached style data if the value is // not context-sensitive. So if there's nothing cached, it's not context // sensitive. *aIsContextSensitive = !tmpStyleContext->RuleNode()->NodeHasCachedUnconditionalData(sid); } // If we're not concerned whether the property is context sensitive then just // add the rule to a new temporary style context alongside the target // element's style context. // Also, if we previously discovered that this property IS context-sensitive // then we need to throw the temporary style context out since the property's // value may have been biased by the 'initial' values supplied. if (!aIsContextSensitive || *aIsContextSensitive) { nsCOMArray<nsIStyleRule> ruleArray; css::Declaration* declaration = aStyleRule->GetDeclaration(); ruleArray.AppendObject(declaration); declaration->SetImmutable(); tmpStyleContext = styleSet->ResolveStyleByAddingRules(aStyleContext, ruleArray); if (!tmpStyleContext) { return false; } } return ComputeValuesFromStyleContext(aProperty, aEnabledState, tmpStyleContext, aValues); } /* static */ bool StyleAnimationValue::ComputeValue(nsCSSPropertyID aProperty, dom::Element* aTargetElement, nsStyleContext* aStyleContext, const nsAString& aSpecifiedValue, bool aUseSVGMode, StyleAnimationValue& aComputedValue, bool* aIsContextSensitive) { MOZ_ASSERT(aTargetElement, "null target element"); // Parse specified value into a temporary css::StyleRule // Note: BuildStyleRule needs an element's OwnerDoc, BaseURI, and Principal. // If it is a pseudo element, use its parent element's OwnerDoc, BaseURI, // and Principal. RefPtr<css::StyleRule> styleRule = BuildStyleRule(aProperty, aTargetElement, aSpecifiedValue, aUseSVGMode); if (!styleRule) { return false; } if (nsCSSProps::IsShorthand(aProperty) || nsCSSProps::kAnimTypeTable[aProperty] == eStyleAnimType_None) { // Just capture the specified value aComputedValue.SetUnparsedStringValue(nsString(aSpecifiedValue)); if (aIsContextSensitive) { // Since we're just returning the string as-is, aComputedValue isn't going // to change depending on the context *aIsContextSensitive = false; } return true; } AutoTArray<PropertyStyleAnimationValuePair,1> values; bool ok = ComputeValuesFromStyleRule(aProperty, CSSEnabledState::eIgnoreEnabledState, aStyleContext, styleRule, values, aIsContextSensitive); if (!ok) { return false; } MOZ_ASSERT(values.Length() == 1); MOZ_ASSERT(values[0].mProperty == aProperty); aComputedValue = values[0].mValue; return true; } template <class T> bool ComputeValuesFromSpecifiedValue( nsCSSPropertyID aProperty, CSSEnabledState aEnabledState, dom::Element* aTargetElement, nsStyleContext* aStyleContext, T& aSpecifiedValue, bool aUseSVGMode, nsTArray<PropertyStyleAnimationValuePair>& aResult) { MOZ_ASSERT(aTargetElement, "null target element"); // Parse specified value into a temporary css::StyleRule // Note: BuildStyleRule needs an element's OwnerDoc, BaseURI, and Principal. // If it is a pseudo element, use its parent element's OwnerDoc, BaseURI, // and Principal. RefPtr<css::StyleRule> styleRule = BuildStyleRule(aProperty, aTargetElement, aSpecifiedValue, aUseSVGMode); if (!styleRule) { return false; } aResult.Clear(); return ComputeValuesFromStyleRule(aProperty, aEnabledState, aStyleContext, styleRule, aResult, /* aIsContextSensitive */ nullptr); } /* static */ bool StyleAnimationValue::ComputeValues( nsCSSPropertyID aProperty, CSSEnabledState aEnabledState, dom::Element* aTargetElement, nsStyleContext* aStyleContext, const nsAString& aSpecifiedValue, bool aUseSVGMode, nsTArray<PropertyStyleAnimationValuePair>& aResult) { return ComputeValuesFromSpecifiedValue(aProperty, aEnabledState, aTargetElement, aStyleContext, aSpecifiedValue, aUseSVGMode, aResult); } /* static */ bool StyleAnimationValue::ComputeValues( nsCSSPropertyID aProperty, CSSEnabledState aEnabledState, dom::Element* aTargetElement, nsStyleContext* aStyleContext, const nsCSSValue& aSpecifiedValue, bool aUseSVGMode, nsTArray<PropertyStyleAnimationValuePair>& aResult) { return ComputeValuesFromSpecifiedValue(aProperty, aEnabledState, aTargetElement, aStyleContext, aSpecifiedValue, aUseSVGMode, aResult); } /* static */ bool StyleAnimationValue::ComputeValues( nsCSSPropertyID aProperty, CSSEnabledState aEnabledState, nsStyleContext* aStyleContext, const RawServoDeclarationBlock& aDeclarations, nsTArray<PropertyStyleAnimationValuePair>& aValues) { MOZ_ASSERT(aStyleContext->PresContext()->StyleSet()->IsServo(), "Should be using ServoStyleSet if we have a" " RawServoDeclarationBlock"); if (!nsCSSProps::IsEnabled(aProperty, aEnabledState)) { return false; } const ServoComputedValues* previousStyle = aStyleContext->StyleSource().AsServoComputedValues(); // FIXME: Servo bindings don't yet represent const-ness so we just // cast it away for now. auto declarations = const_cast<RawServoDeclarationBlock*>(&aDeclarations); RefPtr<ServoComputedValues> computedValues = Servo_RestyleWithAddedDeclaration(declarations, previousStyle).Consume(); if (!computedValues) { return false; } RefPtr<nsStyleContext> tmpStyleContext = NS_NewStyleContext(aStyleContext, aStyleContext->PresContext(), aStyleContext->GetPseudo(), aStyleContext->GetPseudoType(), computedValues.forget(), false /* skipFixup */); return ComputeValuesFromStyleContext(aProperty, aEnabledState, tmpStyleContext, aValues); } bool StyleAnimationValue::UncomputeValue(nsCSSPropertyID aProperty, const StyleAnimationValue& aComputedValue, nsCSSValue& aSpecifiedValue) { Unit unit = aComputedValue.GetUnit(); switch (unit) { case eUnit_Normal: aSpecifiedValue.SetNormalValue(); break; case eUnit_Auto: aSpecifiedValue.SetAutoValue(); break; case eUnit_None: aSpecifiedValue.SetNoneValue(); break; case eUnit_Enumerated: case eUnit_Visibility: aSpecifiedValue. SetIntValue(aComputedValue.GetIntValue(), eCSSUnit_Enumerated); break; case eUnit_Integer: aSpecifiedValue. SetIntValue(aComputedValue.GetIntValue(), eCSSUnit_Integer); break; case eUnit_Coord: aSpecifiedValue.SetIntegerCoordValue(aComputedValue.GetCoordValue()); break; case eUnit_Percent: aSpecifiedValue.SetPercentValue(aComputedValue.GetPercentValue()); break; case eUnit_Float: aSpecifiedValue. SetFloatValue(aComputedValue.GetFloatValue(), eCSSUnit_Number); break; case eUnit_CurrentColor: aSpecifiedValue.SetIntValue(NS_COLOR_CURRENTCOLOR, eCSSUnit_EnumColor); break; case eUnit_Calc: case eUnit_Color: case eUnit_ObjectPosition: case eUnit_URL: case eUnit_DiscreteCSSValue: { nsCSSValue* val = aComputedValue.GetCSSValueValue(); // Sanity-check that the underlying unit in the nsCSSValue is what we // expect for our StyleAnimationValue::Unit: MOZ_ASSERT((unit == eUnit_Calc && val->GetUnit() == eCSSUnit_Calc) || (unit == eUnit_Color && nsCSSValue::IsNumericColorUnit(val->GetUnit())) || (unit == eUnit_ObjectPosition && val->GetUnit() == eCSSUnit_Array) || (unit == eUnit_URL && val->GetUnit() == eCSSUnit_URL) || unit == eUnit_DiscreteCSSValue, "unexpected unit"); aSpecifiedValue = *val; break; } case eUnit_ComplexColor: { aSpecifiedValue.SetComplexColorValue( do_AddRef(aComputedValue.mValue.mComplexColor)); break; } case eUnit_CSSValuePair: { // Rule node processing expects pair values to be collapsed to a // single value if both halves would be equal, for most but not // all properties. At present, all animatable properties that // use pairs do expect collapsing. const nsCSSValuePair* pair = aComputedValue.GetCSSValuePairValue(); if (pair->mXValue == pair->mYValue) { aSpecifiedValue = pair->mXValue; } else { aSpecifiedValue.SetPairValue(pair); } } break; case eUnit_CSSValueTriplet: { // Rule node processing expects triplet values to be collapsed to a // single value if both halves would be equal, for most but not // all properties. At present, all animatable properties that // use pairs do expect collapsing. const nsCSSValueTriplet* triplet = aComputedValue.GetCSSValueTripletValue(); if (triplet->mXValue == triplet->mYValue && triplet->mYValue == triplet->mZValue) { aSpecifiedValue = triplet->mXValue; } else { aSpecifiedValue.SetTripletValue(triplet); } } break; case eUnit_CSSRect: { nsCSSRect& rect = aSpecifiedValue.SetRectValue(); rect = *aComputedValue.GetCSSRectValue(); } break; case eUnit_Dasharray: case eUnit_Shadow: case eUnit_Filter: case eUnit_BackgroundPositionCoord: { nsCSSValueList* computedList = aComputedValue.GetCSSValueListValue(); if (computedList) { aSpecifiedValue.SetDependentListValue(computedList); } else { aSpecifiedValue.SetNoneValue(); } } break; case eUnit_Shape: { nsCSSValue::Array* computedArray = aComputedValue.GetCSSValueArrayValue(); aSpecifiedValue.SetArrayValue(computedArray, eCSSUnit_Array); break; } case eUnit_Transform: aSpecifiedValue. SetSharedListValue(aComputedValue.GetCSSValueSharedListValue()); break; case eUnit_CSSValuePairList: aSpecifiedValue. SetDependentPairListValue(aComputedValue.GetCSSValuePairListValue()); break; default: return false; } return true; } bool StyleAnimationValue::UncomputeValue(nsCSSPropertyID aProperty, StyleAnimationValue&& aComputedValue, nsCSSValue& aSpecifiedValue) { Unit unit = aComputedValue.GetUnit(); switch (unit) { case eUnit_Dasharray: case eUnit_Shadow: case eUnit_Filter: case eUnit_BackgroundPositionCoord: { UniquePtr<nsCSSValueList> computedList = aComputedValue.TakeCSSValueListValue(); if (computedList) { aSpecifiedValue.AdoptListValue(Move(computedList)); } else { aSpecifiedValue.SetNoneValue(); } } break; case eUnit_CSSValuePairList: { UniquePtr<nsCSSValuePairList> computedList = aComputedValue.TakeCSSValuePairListValue(); MOZ_ASSERT(computedList, "Pair list should never be null"); aSpecifiedValue.AdoptPairListValue(Move(computedList)); } break; default: return UncomputeValue(aProperty, aComputedValue, aSpecifiedValue); } return true; } bool StyleAnimationValue::UncomputeValue(nsCSSPropertyID aProperty, const StyleAnimationValue& aComputedValue, nsAString& aSpecifiedValue) { aSpecifiedValue.Truncate(); // Clear outparam, if it's not already empty if (aComputedValue.GetUnit() == eUnit_UnparsedString) { aComputedValue.GetStringValue(aSpecifiedValue); return true; } nsCSSValue val; if (!StyleAnimationValue::UncomputeValue(aProperty, aComputedValue, val)) { return false; } val.AppendToString(aProperty, aSpecifiedValue, nsCSSValue::eNormalized); return true; } template<typename T> inline const T& StyleDataAtOffset(const void* aStyleStruct, ptrdiff_t aOffset) { return *reinterpret_cast<const T*>( reinterpret_cast<const uint8_t*>(aStyleStruct) + aOffset); } static bool StyleCoordToValue(const nsStyleCoord& aCoord, StyleAnimationValue& aValue) { switch (aCoord.GetUnit()) { case eStyleUnit_Normal: aValue.SetNormalValue(); break; case eStyleUnit_Auto: aValue.SetAutoValue(); break; case eStyleUnit_None: aValue.SetNoneValue(); break; case eStyleUnit_Percent: aValue.SetPercentValue(aCoord.GetPercentValue()); break; case eStyleUnit_Factor: aValue.SetFloatValue(aCoord.GetFactorValue()); break; case eStyleUnit_Coord: aValue.SetCoordValue(aCoord.GetCoordValue()); break; case eStyleUnit_Enumerated: aValue.SetIntValue(aCoord.GetIntValue(), StyleAnimationValue::eUnit_Enumerated); break; case eStyleUnit_Integer: aValue.SetIntValue(aCoord.GetIntValue(), StyleAnimationValue::eUnit_Integer); break; case eStyleUnit_Calc: { nsAutoPtr<nsCSSValue> val(new nsCSSValue); CalcValueToCSSValue(aCoord.GetCalcValue(), *val); aValue.SetAndAdoptCSSValueValue(val.forget(), StyleAnimationValue::eUnit_Calc); break; } default: return false; } return true; } static bool StyleCoordToCSSValue(const nsStyleCoord& aCoord, nsCSSValue& aCSSValue) { switch (aCoord.GetUnit()) { case eStyleUnit_Coord: aCSSValue.SetIntegerCoordValue(aCoord.GetCoordValue()); break; case eStyleUnit_Factor: aCSSValue.SetFloatValue(aCoord.GetFactorValue(), eCSSUnit_Number); break; case eStyleUnit_Percent: aCSSValue.SetPercentValue(aCoord.GetPercentValue()); break; case eStyleUnit_Calc: CalcValueToCSSValue(aCoord.GetCalcValue(), aCSSValue); break; case eStyleUnit_Degree: aCSSValue.SetFloatValue(aCoord.GetAngleValue(), eCSSUnit_Degree); break; case eStyleUnit_Grad: aCSSValue.SetFloatValue(aCoord.GetAngleValue(), eCSSUnit_Grad); break; case eStyleUnit_Radian: aCSSValue.SetFloatValue(aCoord.GetAngleValue(), eCSSUnit_Radian); break; case eStyleUnit_Turn: aCSSValue.SetFloatValue(aCoord.GetAngleValue(), eCSSUnit_Turn); break; default: MOZ_ASSERT(false, "unexpected unit"); return false; } return true; } static void SetPositionValue(const Position& aPos, nsCSSValue& aCSSValue) { RefPtr<nsCSSValue::Array> posArray = nsCSSValue::Array::Create(4); aCSSValue.SetArrayValue(posArray.get(), eCSSUnit_Array); // NOTE: Array entries #0 and #2 here are intentionally left untouched, with // eCSSUnit_Null. The purpose of these entries in our specified-style // <position> representation is to store edge names. But for values // extracted from computed style (which is what we're dealing with here), // we'll just have a normalized "x,y" position, with no edge names needed. nsCSSValue& xValue = posArray->Item(1); nsCSSValue& yValue = posArray->Item(3); CalcValueToCSSValue(&aPos.mXPosition, xValue); CalcValueToCSSValue(&aPos.mYPosition, yValue); } static void SetPositionCoordValue(const Position::Coord& aPosCoord, nsCSSValue& aCSSValue) { RefPtr<nsCSSValue::Array> posArray = nsCSSValue::Array::Create(2); aCSSValue.SetArrayValue(posArray.get(), eCSSUnit_Array); // NOTE: Array entry #0 here is intentionally left untouched, with // eCSSUnit_Null. The purpose of this entry in our specified-style // <position-coord> representation is to store edge names. But for values // extracted from computed style (which is what we're dealing with here), // we'll just have a normalized "x"/"y" position, with no edge names needed. nsCSSValue& value = posArray->Item(1); CalcValueToCSSValue(&aPosCoord, value); } /* * Assign |aOutput = aInput|, except with any non-pixel lengths * replaced with the equivalent in pixels, and any non-canonical calc() * expressions replaced with canonical ones. */ static void SubstitutePixelValues(nsStyleContext* aStyleContext, const nsCSSValue& aInput, nsCSSValue& aOutput) { if (aInput.IsCalcUnit()) { RuleNodeCacheConditions conditions; nsRuleNode::ComputedCalc c = nsRuleNode::SpecifiedCalcToComputedCalc(aInput, aStyleContext, aStyleContext->PresContext(), conditions); nsStyleCoord::CalcValue c2; c2.mLength = c.mLength; c2.mPercent = c.mPercent; c2.mHasPercent = true; // doesn't matter for transform translate CalcValueToCSSValue(&c2, aOutput); } else if (aInput.UnitHasArrayValue()) { const nsCSSValue::Array *inputArray = aInput.GetArrayValue(); RefPtr<nsCSSValue::Array> outputArray = nsCSSValue::Array::Create(inputArray->Count()); for (size_t i = 0, i_end = inputArray->Count(); i < i_end; ++i) { SubstitutePixelValues(aStyleContext, inputArray->Item(i), outputArray->Item(i)); } aOutput.SetArrayValue(outputArray, aInput.GetUnit()); } else if (aInput.IsLengthUnit() && aInput.GetUnit() != eCSSUnit_Pixel) { RuleNodeCacheConditions conditions; nscoord len = nsRuleNode::CalcLength(aInput, aStyleContext, aStyleContext->PresContext(), conditions); aOutput.SetFloatValue(nsPresContext::AppUnitsToFloatCSSPixels(len), eCSSUnit_Pixel); } else { aOutput = aInput; } } static void ExtractImageLayerPositionXList(const nsStyleImageLayers& aLayer, StyleAnimationValue& aComputedValue) { MOZ_ASSERT(aLayer.mPositionXCount > 0, "unexpected count"); nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); for (uint32_t i = 0, i_end = aLayer.mPositionXCount; i != i_end; ++i) { nsCSSValueList *item = new nsCSSValueList; *resultTail = item; resultTail = &item->mNext; SetPositionCoordValue(aLayer.mLayers[i].mPosition.mXPosition, item->mValue); } aComputedValue.SetAndAdoptCSSValueListValue(result.forget(), StyleAnimationValue::eUnit_BackgroundPositionCoord); } static void ExtractImageLayerPositionYList(const nsStyleImageLayers& aLayer, StyleAnimationValue& aComputedValue) { MOZ_ASSERT(aLayer.mPositionYCount > 0, "unexpected count"); nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); for (uint32_t i = 0, i_end = aLayer.mPositionYCount; i != i_end; ++i) { nsCSSValueList *item = new nsCSSValueList; *resultTail = item; resultTail = &item->mNext; SetPositionCoordValue(aLayer.mLayers[i].mPosition.mYPosition, item->mValue); } aComputedValue.SetAndAdoptCSSValueListValue(result.forget(), StyleAnimationValue::eUnit_BackgroundPositionCoord); } static void ExtractImageLayerSizePairList(const nsStyleImageLayers& aLayer, StyleAnimationValue& aComputedValue) { MOZ_ASSERT(aLayer.mSizeCount > 0, "unexpected count"); nsAutoPtr<nsCSSValuePairList> result; nsCSSValuePairList **resultTail = getter_Transfers(result); for (uint32_t i = 0, i_end = aLayer.mSizeCount; i != i_end; ++i) { nsCSSValuePairList *item = new nsCSSValuePairList; *resultTail = item; resultTail = &item->mNext; const nsStyleImageLayers::Size &size = aLayer.mLayers[i].mSize; switch (size.mWidthType) { case nsStyleImageLayers::Size::eContain: case nsStyleImageLayers::Size::eCover: item->mXValue.SetIntValue(size.mWidthType, eCSSUnit_Enumerated); break; case nsStyleImageLayers::Size::eAuto: item->mXValue.SetAutoValue(); break; case nsStyleImageLayers::Size::eLengthPercentage: // XXXbz is there a good reason we can't just // CalcValueToCSSValue(&size.mWidth, item->mXValue) here? if (!size.mWidth.mHasPercent && // negative values must have come from calc() size.mWidth.mLength >= 0) { MOZ_ASSERT(size.mWidth.mPercent == 0.0f, "Shouldn't have mPercent"); item->mXValue.SetIntegerCoordValue(size.mWidth.mLength); } else if (size.mWidth.mLength == 0 && // negative values must have come from calc() size.mWidth.mPercent >= 0.0f) { item->mXValue.SetPercentValue(size.mWidth.mPercent); } else { CalcValueToCSSValue(&size.mWidth, item->mXValue); } break; } switch (size.mHeightType) { case nsStyleImageLayers::Size::eContain: case nsStyleImageLayers::Size::eCover: // leave it null break; case nsStyleImageLayers::Size::eAuto: item->mYValue.SetAutoValue(); break; case nsStyleImageLayers::Size::eLengthPercentage: // XXXbz is there a good reason we can't just // CalcValueToCSSValue(&size.mHeight, item->mYValue) here? if (!size.mHeight.mHasPercent && // negative values must have come from calc() size.mHeight.mLength >= 0) { MOZ_ASSERT(size.mHeight.mPercent == 0.0f, "Shouldn't have mPercent"); item->mYValue.SetIntegerCoordValue(size.mHeight.mLength); } else if (size.mHeight.mLength == 0 && // negative values must have come from calc() size.mHeight.mPercent >= 0.0f) { item->mYValue.SetPercentValue(size.mHeight.mPercent); } else { CalcValueToCSSValue(&size.mHeight, item->mYValue); } break; } } aComputedValue.SetAndAdoptCSSValuePairListValue(result.forget()); } static bool StyleClipBasicShapeToCSSArray(const StyleClipPath& aClipPath, nsCSSValue::Array* aResult) { MOZ_ASSERT(aResult->Count() == 2, "Expected array to be presized for a function and the sizing-box"); const StyleBasicShape* shape = aClipPath.GetBasicShape(); nsCSSKeyword functionName = shape->GetShapeTypeName(); RefPtr<nsCSSValue::Array> functionArray; switch (shape->GetShapeType()) { case StyleBasicShapeType::Circle: case StyleBasicShapeType::Ellipse: { const nsTArray<nsStyleCoord>& coords = shape->Coordinates(); MOZ_ASSERT(coords.Length() == ShapeArgumentCount(functionName) - 1, "Unexpected radii count"); // The "+1" is for the center point: functionArray = aResult->Item(0).InitFunction(functionName, coords.Length() + 1); for (size_t i = 0; i < coords.Length(); ++i) { if (coords[i].GetUnit() == eStyleUnit_Enumerated) { functionArray->Item(i + 1).SetIntValue(coords[i].GetIntValue(), eCSSUnit_Enumerated); } else if (!StyleCoordToCSSValue(coords[i], functionArray->Item(i + 1))) { return false; } } // Set functionArray's last item to the circle or ellipse's center point: SetPositionValue(shape->GetPosition(), functionArray->Item(functionArray->Count() - 1)); break; } case StyleBasicShapeType::Polygon: { functionArray = aResult->Item(0).InitFunction(functionName, ShapeArgumentCount(functionName)); functionArray->Item(1).SetIntValue(shape->GetFillRule(), eCSSUnit_Enumerated); nsCSSValuePairList* list = functionArray->Item(2).SetPairListValue(); const nsTArray<nsStyleCoord>& coords = shape->Coordinates(); MOZ_ASSERT((coords.Length() % 2) == 0); for (size_t i = 0; i < coords.Length(); i += 2) { if (i > 0) { list->mNext = new nsCSSValuePairList; list = list->mNext; } if (!StyleCoordToCSSValue(coords[i], list->mXValue) || !StyleCoordToCSSValue(coords[i + 1], list->mYValue)) { return false; } } break; } case StyleBasicShapeType::Inset: { const nsTArray<nsStyleCoord>& coords = shape->Coordinates(); MOZ_ASSERT(coords.Length() == ShapeArgumentCount(functionName) - 1, "Unexpected offset count"); functionArray = aResult->Item(0).InitFunction(functionName, coords.Length() + 1); for (size_t i = 0; i < coords.Length(); ++i) { if (!StyleCoordToCSSValue(coords[i], functionArray->Item(i + 1))) { return false; } } RefPtr<nsCSSValue::Array> radiusArray = nsCSSValue::Array::Create(4); const nsStyleCorners& radii = shape->GetRadius(); NS_FOR_CSS_FULL_CORNERS(corner) { auto pair = MakeUnique<nsCSSValuePair>(); if (!StyleCoordToCSSValue(radii.Get(NS_FULL_TO_HALF_CORNER(corner, false)), pair->mXValue) || !StyleCoordToCSSValue(radii.Get(NS_FULL_TO_HALF_CORNER(corner, true)), pair->mYValue)) { return false; } radiusArray->Item(corner).SetPairValue(pair.get()); } // Set the last item in functionArray to the radius array: functionArray->Item(functionArray->Count() - 1). SetArrayValue(radiusArray, eCSSUnit_Array); break; } default: MOZ_ASSERT_UNREACHABLE("Unknown shape type"); return false; } aResult->Item(1).SetIntValue(aClipPath.GetReferenceBox(), eCSSUnit_Enumerated); return true; } bool StyleAnimationValue::ExtractComputedValue(nsCSSPropertyID aProperty, nsStyleContext* aStyleContext, StyleAnimationValue& aComputedValue) { MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands, "bad property"); const void* styleStruct = aStyleContext->StyleData(nsCSSProps::kSIDTable[aProperty]); ptrdiff_t ssOffset = nsCSSProps::kStyleStructOffsetTable[aProperty]; nsStyleAnimType animType = nsCSSProps::kAnimTypeTable[aProperty]; MOZ_ASSERT(0 <= ssOffset || animType == eStyleAnimType_Custom || animType == eStyleAnimType_Discrete, "all animation types other than Custom and Discrete must " \ "specify a style struct offset to extract values from"); switch (animType) { case eStyleAnimType_Custom: switch (aProperty) { // For border-width, ignore the border-image business (which // only exists until we update our implementation to the current // spec) and use GetComputedBorder #define BORDER_WIDTH_CASE(prop_, side_) \ case prop_: \ aComputedValue.SetCoordValue( \ static_cast<const nsStyleBorder*>(styleStruct)-> \ GetComputedBorder().side_); \ break; BORDER_WIDTH_CASE(eCSSProperty_border_bottom_width, bottom) BORDER_WIDTH_CASE(eCSSProperty_border_left_width, left) BORDER_WIDTH_CASE(eCSSProperty_border_right_width, right) BORDER_WIDTH_CASE(eCSSProperty_border_top_width, top) #undef BORDER_WIDTH_CASE case eCSSProperty_column_rule_width: aComputedValue.SetCoordValue( static_cast<const nsStyleColumn*>(styleStruct)-> GetComputedColumnRuleWidth()); break; case eCSSProperty_column_count: { const nsStyleColumn *styleColumn = static_cast<const nsStyleColumn*>(styleStruct); if (styleColumn->mColumnCount == NS_STYLE_COLUMN_COUNT_AUTO) { aComputedValue.SetAutoValue(); } else { aComputedValue.SetIntValue(styleColumn->mColumnCount, eUnit_Integer); } break; } case eCSSProperty_order: { const nsStylePosition *stylePosition = static_cast<const nsStylePosition*>(styleStruct); aComputedValue.SetIntValue(stylePosition->mOrder, eUnit_Integer); break; } case eCSSProperty_border_spacing: { const nsStyleTableBorder *styleTableBorder = static_cast<const nsStyleTableBorder*>(styleStruct); nsAutoPtr<nsCSSValuePair> pair(new nsCSSValuePair); pair->mXValue.SetIntegerCoordValue(styleTableBorder->mBorderSpacingCol); pair->mYValue.SetIntegerCoordValue(styleTableBorder->mBorderSpacingRow); aComputedValue.SetAndAdoptCSSValuePairValue(pair.forget(), eUnit_CSSValuePair); break; } case eCSSProperty_transform_origin: { const nsStyleDisplay *styleDisplay = static_cast<const nsStyleDisplay*>(styleStruct); nsAutoPtr<nsCSSValueTriplet> triplet(new nsCSSValueTriplet); if (!StyleCoordToCSSValue(styleDisplay->mTransformOrigin[0], triplet->mXValue) || !StyleCoordToCSSValue(styleDisplay->mTransformOrigin[1], triplet->mYValue) || !StyleCoordToCSSValue(styleDisplay->mTransformOrigin[2], triplet->mZValue)) { return false; } aComputedValue.SetAndAdoptCSSValueTripletValue(triplet.forget(), eUnit_CSSValueTriplet); break; } case eCSSProperty_perspective_origin: { const nsStyleDisplay *styleDisplay = static_cast<const nsStyleDisplay*>(styleStruct); nsAutoPtr<nsCSSValuePair> pair(new nsCSSValuePair); if (!StyleCoordToCSSValue(styleDisplay->mPerspectiveOrigin[0], pair->mXValue) || !StyleCoordToCSSValue(styleDisplay->mPerspectiveOrigin[1], pair->mYValue)) { return false; } aComputedValue.SetAndAdoptCSSValuePairValue(pair.forget(), eUnit_CSSValuePair); break; } case eCSSProperty_stroke_dasharray: { const nsStyleSVG *svg = static_cast<const nsStyleSVG*>(styleStruct); if (!svg->mStrokeDasharray.IsEmpty()) { nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); for (uint32_t i = 0, i_end = svg->mStrokeDasharray.Length(); i != i_end; ++i) { nsCSSValueList *item = new nsCSSValueList; *resultTail = item; resultTail = &item->mNext; const nsStyleCoord &coord = svg->mStrokeDasharray[i]; nsCSSValue &value = item->mValue; switch (coord.GetUnit()) { case eStyleUnit_Coord: // Number means the same thing as length; we want to // animate them the same way. Normalize both to number // since it has more accuracy (float vs nscoord). value.SetFloatValue(nsPresContext:: AppUnitsToFloatCSSPixels(coord.GetCoordValue()), eCSSUnit_Number); break; case eStyleUnit_Factor: value.SetFloatValue(coord.GetFactorValue(), eCSSUnit_Number); break; case eStyleUnit_Percent: value.SetPercentValue(coord.GetPercentValue()); break; default: MOZ_ASSERT(false, "unexpected unit"); return false; } } aComputedValue.SetAndAdoptCSSValueListValue(result.forget(), eUnit_Dasharray); } else if (svg->StrokeDasharrayFromObject()) { // An empty dasharray with StrokeDasharrayFromObject() == true // corresponds to the "context-value" keyword. aComputedValue.SetIntValue(NS_STYLE_STROKE_PROP_CONTEXT_VALUE, eUnit_Enumerated); } else { // Otherwise, an empty dasharray corresponds to the "none" keyword. aComputedValue.SetNoneValue(); } break; } case eCSSProperty_font_stretch: { int16_t stretch = static_cast<const nsStyleFont*>(styleStruct)->mFont.stretch; static_assert(NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED == -4 && NS_STYLE_FONT_STRETCH_ULTRA_EXPANDED == 4, "font stretch constants not as expected"); if (stretch < NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED || stretch > NS_STYLE_FONT_STRETCH_ULTRA_EXPANDED) { return false; } aComputedValue.SetIntValue(stretch, eUnit_Enumerated); return true; } case eCSSProperty_font_weight: { uint16_t weight = static_cast<const nsStyleFont*>(styleStruct)->mFont.weight; if (weight % 100 != 0) { return false; } aComputedValue.SetIntValue(weight, eUnit_Integer); return true; } case eCSSProperty_image_region: { const nsStyleList *list = static_cast<const nsStyleList*>(styleStruct); const nsRect &srect = list->mImageRegion; if (srect.IsEmpty()) { aComputedValue.SetAutoValue(); break; } nsCSSRect *vrect = new nsCSSRect; vrect->mLeft.SetIntegerCoordValue(srect.x); vrect->mTop.SetIntegerCoordValue(srect.y); vrect->mRight.SetIntegerCoordValue(srect.XMost()); vrect->mBottom.SetIntegerCoordValue(srect.YMost()); aComputedValue.SetAndAdoptCSSRectValue(vrect, eUnit_CSSRect); break; } case eCSSProperty_clip: { const nsStyleEffects* effects = static_cast<const nsStyleEffects*>(styleStruct); if (!(effects->mClipFlags & NS_STYLE_CLIP_RECT)) { aComputedValue.SetAutoValue(); } else { nsCSSRect *vrect = new nsCSSRect; const nsRect &srect = effects->mClip; if (effects->mClipFlags & NS_STYLE_CLIP_TOP_AUTO) { vrect->mTop.SetAutoValue(); } else { vrect->mTop.SetIntegerCoordValue(srect.y); } if (effects->mClipFlags & NS_STYLE_CLIP_RIGHT_AUTO) { vrect->mRight.SetAutoValue(); } else { vrect->mRight.SetIntegerCoordValue(srect.XMost()); } if (effects->mClipFlags & NS_STYLE_CLIP_BOTTOM_AUTO) { vrect->mBottom.SetAutoValue(); } else { vrect->mBottom.SetIntegerCoordValue(srect.YMost()); } if (effects->mClipFlags & NS_STYLE_CLIP_LEFT_AUTO) { vrect->mLeft.SetAutoValue(); } else { vrect->mLeft.SetIntegerCoordValue(srect.x); } aComputedValue.SetAndAdoptCSSRectValue(vrect, eUnit_CSSRect); } break; } case eCSSProperty_object_position: { const nsStylePosition* stylePos = static_cast<const nsStylePosition*>(styleStruct); nsAutoPtr<nsCSSValue> val(new nsCSSValue); SetPositionValue(stylePos->mObjectPosition, *val); aComputedValue.SetAndAdoptCSSValueValue(val.forget(), eUnit_ObjectPosition); break; } case eCSSProperty_background_position_x: { const nsStyleImageLayers& layers = static_cast<const nsStyleBackground*>(styleStruct)->mImage; ExtractImageLayerPositionXList(layers, aComputedValue); break; } case eCSSProperty_background_position_y: { const nsStyleImageLayers& layers = static_cast<const nsStyleBackground*>(styleStruct)->mImage; ExtractImageLayerPositionYList(layers, aComputedValue); break; } #ifdef MOZ_ENABLE_MASK_AS_SHORTHAND case eCSSProperty_mask_position_x: { const nsStyleImageLayers& layers = static_cast<const nsStyleSVGReset*>(styleStruct)->mMask; ExtractImageLayerPositionXList(layers, aComputedValue); break; } case eCSSProperty_mask_position_y: { const nsStyleImageLayers& layers = static_cast<const nsStyleSVGReset*>(styleStruct)->mMask; ExtractImageLayerPositionYList(layers, aComputedValue); break; } #endif case eCSSProperty_background_size: { const nsStyleImageLayers& layers = static_cast<const nsStyleBackground*>(styleStruct)->mImage; ExtractImageLayerSizePairList(layers, aComputedValue); break; } #ifdef MOZ_ENABLE_MASK_AS_SHORTHAND case eCSSProperty_mask_size: { const nsStyleImageLayers& layers = static_cast<const nsStyleSVGReset*>(styleStruct)->mMask; ExtractImageLayerSizePairList(layers, aComputedValue); break; } #endif case eCSSProperty_clip_path: { const nsStyleSVGReset* svgReset = static_cast<const nsStyleSVGReset*>(styleStruct); const StyleClipPath& clipPath = svgReset->mClipPath; const StyleShapeSourceType type = clipPath.GetType(); if (type == StyleShapeSourceType::URL) { auto result = MakeUnique<nsCSSValue>(); result->SetURLValue(clipPath.GetURL()); aComputedValue.SetAndAdoptCSSValueValue(result.release(), eUnit_URL); } else if (type == StyleShapeSourceType::Box) { aComputedValue.SetIntValue(clipPath.GetReferenceBox(), eUnit_Enumerated); } else if (type == StyleShapeSourceType::Shape) { RefPtr<nsCSSValue::Array> result = nsCSSValue::Array::Create(2); if (!StyleClipBasicShapeToCSSArray(clipPath, result)) { return false; } aComputedValue.SetCSSValueArrayValue(result, eUnit_Shape); } else { MOZ_ASSERT(type == StyleShapeSourceType::None, "unknown type"); aComputedValue.SetNoneValue(); } break; } case eCSSProperty_filter: { const nsStyleEffects* effects = static_cast<const nsStyleEffects*>(styleStruct); const nsTArray<nsStyleFilter>& filters = effects->mFilters; nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); for (uint32_t i = 0; i < filters.Length(); ++i) { nsCSSValueList *item = new nsCSSValueList; *resultTail = item; resultTail = &item->mNext; const nsStyleFilter& filter = filters[i]; int32_t type = filter.GetType(); if (type == NS_STYLE_FILTER_URL) { item->mValue.SetURLValue(filter.GetURL()); } else { nsCSSKeyword functionName = nsCSSProps::ValueToKeywordEnum(type, nsCSSProps::kFilterFunctionKTable); nsCSSValue::Array* filterArray = item->mValue.InitFunction(functionName, 1); if (type >= NS_STYLE_FILTER_BLUR && type <= NS_STYLE_FILTER_HUE_ROTATE) { if (!StyleCoordToCSSValue( filter.GetFilterParameter(), filterArray->Item(1))) { return false; } } else if (type == NS_STYLE_FILTER_DROP_SHADOW) { nsCSSValueList* shadowResult = filterArray->Item(1).SetListValue(); nsAutoPtr<nsCSSValueList> tmpShadowValue; nsCSSValueList **tmpShadowResultTail = getter_Transfers(tmpShadowValue); nsCSSShadowArray* shadowArray = filter.GetDropShadow(); MOZ_ASSERT(shadowArray->Length() == 1, "expected exactly one shadow"); AppendCSSShadowValue(shadowArray->ShadowAt(0), tmpShadowResultTail); *shadowResult = *tmpShadowValue; } else { // We checked all possible nsStyleFilter types but // NS_STYLE_FILTER_NULL before. We should never enter this path. NS_NOTREACHED("no other filter functions defined"); return false; } } } aComputedValue.SetAndAdoptCSSValueListValue(result.forget(), eUnit_Filter); break; } case eCSSProperty_transform: { const nsStyleDisplay *display = static_cast<const nsStyleDisplay*>(styleStruct); nsAutoPtr<nsCSSValueList> result; if (display->mSpecifiedTransform) { // Clone, and convert all lengths (not percents) to pixels. nsCSSValueList **resultTail = getter_Transfers(result); for (const nsCSSValueList *l = display->mSpecifiedTransform->mHead; l; l = l->mNext) { nsCSSValueList *clone = new nsCSSValueList; *resultTail = clone; resultTail = &clone->mNext; SubstitutePixelValues(aStyleContext, l->mValue, clone->mValue); } } else { result = new nsCSSValueList(); result->mValue.SetNoneValue(); } aComputedValue.SetTransformValue( new nsCSSValueSharedList(result.forget())); break; } default: MOZ_ASSERT(false, "missing property implementation"); return false; }; return true; case eStyleAnimType_Coord: { const nsStyleCoord& coord = StyleDataAtOffset<nsStyleCoord>(styleStruct, ssOffset); if (nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_NUMBERS_ARE_PIXELS) && coord.GetUnit() == eStyleUnit_Coord) { // For SVG properties where number means the same thing as length, // we want to animate them the same way. Normalize both to number // since it has more accuracy (float vs nscoord). aComputedValue.SetFloatValue(nsPresContext:: AppUnitsToFloatCSSPixels(coord.GetCoordValue())); return true; } return StyleCoordToValue(coord, aComputedValue); } case eStyleAnimType_Sides_Top: case eStyleAnimType_Sides_Right: case eStyleAnimType_Sides_Bottom: case eStyleAnimType_Sides_Left: { static_assert( NS_SIDE_TOP == eStyleAnimType_Sides_Top -eStyleAnimType_Sides_Top && NS_SIDE_RIGHT == eStyleAnimType_Sides_Right -eStyleAnimType_Sides_Top && NS_SIDE_BOTTOM == eStyleAnimType_Sides_Bottom-eStyleAnimType_Sides_Top && NS_SIDE_LEFT == eStyleAnimType_Sides_Left -eStyleAnimType_Sides_Top, "box side constants out of sync with animation side constants"); const nsStyleCoord &coord = StyleDataAtOffset<nsStyleSides>(styleStruct, ssOffset). Get(mozilla::css::Side(animType - eStyleAnimType_Sides_Top)); return StyleCoordToValue(coord, aComputedValue); } case eStyleAnimType_Corner_TopLeft: case eStyleAnimType_Corner_TopRight: case eStyleAnimType_Corner_BottomRight: case eStyleAnimType_Corner_BottomLeft: { static_assert( NS_CORNER_TOP_LEFT == eStyleAnimType_Corner_TopLeft - eStyleAnimType_Corner_TopLeft && NS_CORNER_TOP_RIGHT == eStyleAnimType_Corner_TopRight - eStyleAnimType_Corner_TopLeft && NS_CORNER_BOTTOM_RIGHT == eStyleAnimType_Corner_BottomRight - eStyleAnimType_Corner_TopLeft && NS_CORNER_BOTTOM_LEFT == eStyleAnimType_Corner_BottomLeft - eStyleAnimType_Corner_TopLeft, "box corner constants out of sync with animation corner constants"); const nsStyleCorners& corners = StyleDataAtOffset<nsStyleCorners>(styleStruct, ssOffset); uint8_t fullCorner = animType - eStyleAnimType_Corner_TopLeft; const nsStyleCoord &horiz = corners.Get(NS_FULL_TO_HALF_CORNER(fullCorner, false)); const nsStyleCoord &vert = corners.Get(NS_FULL_TO_HALF_CORNER(fullCorner, true)); nsAutoPtr<nsCSSValuePair> pair(new nsCSSValuePair); if (!StyleCoordToCSSValue(horiz, pair->mXValue) || !StyleCoordToCSSValue(vert, pair->mYValue)) { return false; } aComputedValue.SetAndAdoptCSSValuePairValue(pair.forget(), eUnit_CSSValuePair); return true; } case eStyleAnimType_nscoord: aComputedValue.SetCoordValue( StyleDataAtOffset<nscoord>(styleStruct, ssOffset)); return true; case eStyleAnimType_float: aComputedValue.SetFloatValue( StyleDataAtOffset<float>(styleStruct, ssOffset)); if (aProperty == eCSSProperty_font_size_adjust && aComputedValue.GetFloatValue() == -1.0f) { // In nsStyleFont, we set mFont.sizeAdjust to -1.0 to represent // font-size-adjust: none. Here, we have to treat this as a keyword // instead of a float value, to make sure we don't end up doing // interpolation with it. aComputedValue.SetNoneValue(); } return true; case eStyleAnimType_Color: aComputedValue.SetColorValue( StyleDataAtOffset<nscolor>(styleStruct, ssOffset)); return true; case eStyleAnimType_ComplexColor: { aComputedValue.SetComplexColorValue( StyleDataAtOffset<StyleComplexColor>(styleStruct, ssOffset)); return true; } case eStyleAnimType_PaintServer: { const nsStyleSVGPaint& paint = StyleDataAtOffset<nsStyleSVGPaint>(styleStruct, ssOffset); switch (paint.Type()) { case eStyleSVGPaintType_Color: aComputedValue.SetColorValue(paint.GetColor()); return true; case eStyleSVGPaintType_Server: { css::URLValue* url = paint.GetPaintServer(); if (!url) { NS_WARNING("Null paint server"); return false; } nsAutoPtr<nsCSSValuePair> pair(new nsCSSValuePair); pair->mXValue.SetURLValue(url); pair->mYValue.SetColorValue(paint.GetFallbackColor()); aComputedValue.SetAndAdoptCSSValuePairValue(pair.forget(), eUnit_CSSValuePair); return true; } case eStyleSVGPaintType_ContextFill: case eStyleSVGPaintType_ContextStroke: { nsAutoPtr<nsCSSValuePair> pair(new nsCSSValuePair); pair->mXValue.SetIntValue(paint.Type() == eStyleSVGPaintType_ContextFill ? NS_COLOR_CONTEXT_FILL : NS_COLOR_CONTEXT_STROKE, eCSSUnit_Enumerated); pair->mYValue.SetColorValue(paint.GetFallbackColor()); aComputedValue.SetAndAdoptCSSValuePairValue(pair.forget(), eUnit_CSSValuePair); return true; } default: MOZ_ASSERT(paint.Type() == eStyleSVGPaintType_None, "Unexpected SVG paint type"); aComputedValue.SetNoneValue(); return true; } } case eStyleAnimType_Shadow: { const nsCSSShadowArray* shadowArray = StyleDataAtOffset<RefPtr<nsCSSShadowArray>>(styleStruct, ssOffset); if (!shadowArray) { aComputedValue.SetAndAdoptCSSValueListValue(nullptr, eUnit_Shadow); return true; } nsAutoPtr<nsCSSValueList> result; nsCSSValueList **resultTail = getter_Transfers(result); for (uint32_t i = 0, i_end = shadowArray->Length(); i < i_end; ++i) { AppendCSSShadowValue(shadowArray->ShadowAt(i), resultTail); } aComputedValue.SetAndAdoptCSSValueListValue(result.forget(), eUnit_Shadow); return true; } case eStyleAnimType_Discrete: { if (aProperty == eCSSProperty_visibility) { aComputedValue.SetIntValue( static_cast<const nsStyleVisibility*>(styleStruct)->mVisible, eUnit_Visibility); return true; } auto cssValue = MakeUnique<nsCSSValue>(eCSSUnit_Unset); aStyleContext->RuleNode()->GetDiscretelyAnimatedCSSValue(aProperty, cssValue.get()); aComputedValue.SetAndAdoptCSSValueValue(cssValue.release(), eUnit_DiscreteCSSValue); return true; } case eStyleAnimType_None: NS_NOTREACHED("shouldn't use on non-animatable properties"); } return false; } gfxSize StyleAnimationValue::GetScaleValue(const nsIFrame* aForFrame) const { MOZ_ASSERT(aForFrame); MOZ_ASSERT(GetUnit() == StyleAnimationValue::eUnit_Transform); nsCSSValueSharedList* list = GetCSSValueSharedListValue(); MOZ_ASSERT(list->mHead); RuleNodeCacheConditions dontCare; bool dontCareBool; nsStyleTransformMatrix::TransformReferenceBox refBox(aForFrame); Matrix4x4 transform = nsStyleTransformMatrix::ReadTransforms( list->mHead, aForFrame->StyleContext(), aForFrame->PresContext(), dontCare, refBox, aForFrame->PresContext()->AppUnitsPerDevPixel(), &dontCareBool); Matrix transform2d; bool canDraw2D = transform.CanDraw2D(&transform2d); if (!canDraw2D) { return gfxSize(); } return ThebesMatrix(transform2d).ScaleFactors(true); } StyleAnimationValue::StyleAnimationValue(int32_t aInt, Unit aUnit, IntegerConstructorType) { NS_ASSERTION(IsIntUnit(aUnit), "unit must be of integer type"); mUnit = aUnit; mValue.mInt = aInt; } StyleAnimationValue::StyleAnimationValue(nscoord aLength, CoordConstructorType) { mUnit = eUnit_Coord; mValue.mCoord = aLength; } StyleAnimationValue::StyleAnimationValue(float aPercent, PercentConstructorType) { mUnit = eUnit_Percent; mValue.mFloat = aPercent; MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); } StyleAnimationValue::StyleAnimationValue(float aFloat, FloatConstructorType) { mUnit = eUnit_Float; mValue.mFloat = aFloat; MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); } StyleAnimationValue::StyleAnimationValue(nscolor aColor, ColorConstructorType) { mUnit = eUnit_Color; mValue.mCSSValue = new nsCSSValue(); mValue.mCSSValue->SetColorValue(aColor); } StyleAnimationValue& StyleAnimationValue::operator=(const StyleAnimationValue& aOther) { if (this == &aOther) { return *this; } FreeValue(); mUnit = aOther.mUnit; switch (mUnit) { case eUnit_Null: case eUnit_Normal: case eUnit_Auto: case eUnit_None: case eUnit_CurrentColor: break; case eUnit_Enumerated: case eUnit_Visibility: case eUnit_Integer: mValue.mInt = aOther.mValue.mInt; break; case eUnit_Coord: mValue.mCoord = aOther.mValue.mCoord; break; case eUnit_Percent: case eUnit_Float: mValue.mFloat = aOther.mValue.mFloat; MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); break; case eUnit_Calc: case eUnit_Color: case eUnit_ObjectPosition: case eUnit_URL: case eUnit_DiscreteCSSValue: MOZ_ASSERT(IsCSSValueUnit(mUnit), "This clause is for handling nsCSSValue-backed units"); MOZ_ASSERT(aOther.mValue.mCSSValue, "values may not be null"); mValue.mCSSValue = new nsCSSValue(*aOther.mValue.mCSSValue); break; case eUnit_CSSValuePair: MOZ_ASSERT(aOther.mValue.mCSSValuePair, "value pairs may not be null"); mValue.mCSSValuePair = new nsCSSValuePair(*aOther.mValue.mCSSValuePair); break; case eUnit_CSSValueTriplet: MOZ_ASSERT(aOther.mValue.mCSSValueTriplet, "value triplets may not be null"); mValue.mCSSValueTriplet = new nsCSSValueTriplet(*aOther.mValue.mCSSValueTriplet); break; case eUnit_CSSRect: MOZ_ASSERT(aOther.mValue.mCSSRect, "rects may not be null"); mValue.mCSSRect = new nsCSSRect(*aOther.mValue.mCSSRect); break; case eUnit_Dasharray: case eUnit_Shadow: case eUnit_Filter: case eUnit_BackgroundPositionCoord: MOZ_ASSERT(mUnit == eUnit_Shadow || mUnit == eUnit_Filter || aOther.mValue.mCSSValueList, "value lists other than shadows and filters may not be null"); if (aOther.mValue.mCSSValueList) { mValue.mCSSValueList = aOther.mValue.mCSSValueList->Clone(); } else { mValue.mCSSValueList = nullptr; } break; case eUnit_Shape: MOZ_ASSERT(aOther.mValue.mCSSValueArray, "value arrays may not be null"); mValue.mCSSValueArray = aOther.mValue.mCSSValueArray; mValue.mCSSValueArray->AddRef(); break; case eUnit_Transform: mValue.mCSSValueSharedList = aOther.mValue.mCSSValueSharedList; mValue.mCSSValueSharedList->AddRef(); break; case eUnit_CSSValuePairList: MOZ_ASSERT(aOther.mValue.mCSSValuePairList, "value pair lists may not be null"); mValue.mCSSValuePairList = aOther.mValue.mCSSValuePairList->Clone(); break; case eUnit_UnparsedString: MOZ_ASSERT(aOther.mValue.mString, "expecting non-null string"); mValue.mString = aOther.mValue.mString; mValue.mString->AddRef(); break; case eUnit_ComplexColor: MOZ_ASSERT(aOther.mValue.mComplexColor); mValue.mComplexColor = aOther.mValue.mComplexColor; mValue.mComplexColor->AddRef(); break; } return *this; } void StyleAnimationValue::SetNormalValue() { FreeValue(); mUnit = eUnit_Normal; } void StyleAnimationValue::SetAutoValue() { FreeValue(); mUnit = eUnit_Auto; } void StyleAnimationValue::SetNoneValue() { FreeValue(); mUnit = eUnit_None; } void StyleAnimationValue::SetIntValue(int32_t aInt, Unit aUnit) { NS_ASSERTION(IsIntUnit(aUnit), "unit must be of integer type"); FreeValue(); mUnit = aUnit; mValue.mInt = aInt; } void StyleAnimationValue::SetCoordValue(nscoord aLength) { FreeValue(); mUnit = eUnit_Coord; mValue.mCoord = aLength; } void StyleAnimationValue::SetPercentValue(float aPercent) { FreeValue(); mUnit = eUnit_Percent; mValue.mFloat = aPercent; MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); } void StyleAnimationValue::SetFloatValue(float aFloat) { FreeValue(); mUnit = eUnit_Float; mValue.mFloat = aFloat; MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat)); } void StyleAnimationValue::SetColorValue(nscolor aColor) { FreeValue(); mUnit = eUnit_Color; mValue.mCSSValue = new nsCSSValue(); mValue.mCSSValue->SetColorValue(aColor); } void StyleAnimationValue::SetCurrentColorValue() { FreeValue(); mUnit = eUnit_CurrentColor; } void StyleAnimationValue::SetComplexColorValue(const StyleComplexColor& aColor) { if (aColor.IsCurrentColor()) { SetCurrentColorValue(); } else if (aColor.IsNumericColor()) { SetColorValue(aColor.mColor); } else { SetComplexColorValue(do_AddRef(new ComplexColorValue(aColor))); } } void StyleAnimationValue::SetComplexColorValue( already_AddRefed<ComplexColorValue> aValue) { FreeValue(); mUnit = eUnit_ComplexColor; mValue.mComplexColor = aValue.take(); } void StyleAnimationValue::SetUnparsedStringValue(const nsString& aString) { FreeValue(); mUnit = eUnit_UnparsedString; mValue.mString = nsCSSValue::BufferFromString(aString).take(); } void StyleAnimationValue::SetAndAdoptCSSValueValue(nsCSSValue *aValue, Unit aUnit) { FreeValue(); MOZ_ASSERT(IsCSSValueUnit(aUnit), "bad unit"); MOZ_ASSERT(aValue != nullptr, "values may not be null"); mUnit = aUnit; mValue.mCSSValue = aValue; // take ownership } void StyleAnimationValue::SetAndAdoptCSSValuePairValue(nsCSSValuePair *aValuePair, Unit aUnit) { FreeValue(); MOZ_ASSERT(IsCSSValuePairUnit(aUnit), "bad unit"); MOZ_ASSERT(aValuePair != nullptr, "value pairs may not be null"); mUnit = aUnit; mValue.mCSSValuePair = aValuePair; // take ownership } void StyleAnimationValue::SetAndAdoptCSSValueTripletValue( nsCSSValueTriplet *aValueTriplet, Unit aUnit) { FreeValue(); MOZ_ASSERT(IsCSSValueTripletUnit(aUnit), "bad unit"); MOZ_ASSERT(aValueTriplet != nullptr, "value pairs may not be null"); mUnit = aUnit; mValue.mCSSValueTriplet = aValueTriplet; // take ownership } void StyleAnimationValue::SetAndAdoptCSSRectValue(nsCSSRect *aRect, Unit aUnit) { FreeValue(); MOZ_ASSERT(IsCSSRectUnit(aUnit), "bad unit"); MOZ_ASSERT(aRect != nullptr, "value pairs may not be null"); mUnit = aUnit; mValue.mCSSRect = aRect; // take ownership } void StyleAnimationValue::SetCSSValueArrayValue(nsCSSValue::Array* aValue, Unit aUnit) { FreeValue(); MOZ_ASSERT(IsCSSValueArrayUnit(aUnit), "bad unit"); MOZ_ASSERT(aValue != nullptr, "not currently expecting any arrays to be null"); mUnit = aUnit; mValue.mCSSValueArray = aValue; mValue.mCSSValueArray->AddRef(); } void StyleAnimationValue::SetAndAdoptCSSValueListValue(nsCSSValueList *aValueList, Unit aUnit) { FreeValue(); MOZ_ASSERT(IsCSSValueListUnit(aUnit), "bad unit"); MOZ_ASSERT(aUnit == eUnit_Shadow || aUnit == eUnit_Filter || aValueList != nullptr, "value lists other than shadows and filters may not be null"); mUnit = aUnit; mValue.mCSSValueList = aValueList; // take ownership } void StyleAnimationValue::SetTransformValue(nsCSSValueSharedList* aList) { FreeValue(); mUnit = eUnit_Transform; mValue.mCSSValueSharedList = aList; mValue.mCSSValueSharedList->AddRef(); } void StyleAnimationValue::SetAndAdoptCSSValuePairListValue( nsCSSValuePairList *aValuePairList) { FreeValue(); MOZ_ASSERT(aValuePairList, "may not be null"); mUnit = eUnit_CSSValuePairList; mValue.mCSSValuePairList = aValuePairList; // take ownership } void StyleAnimationValue::FreeValue() { if (IsCSSValueUnit(mUnit)) { delete mValue.mCSSValue; } else if (IsCSSValueListUnit(mUnit)) { delete mValue.mCSSValueList; } else if (IsCSSValueSharedListValue(mUnit)) { mValue.mCSSValueSharedList->Release(); } else if (IsCSSValuePairUnit(mUnit)) { delete mValue.mCSSValuePair; } else if (IsCSSValueTripletUnit(mUnit)) { delete mValue.mCSSValueTriplet; } else if (IsCSSRectUnit(mUnit)) { delete mValue.mCSSRect; } else if (IsCSSValuePairListUnit(mUnit)) { delete mValue.mCSSValuePairList; } else if (IsCSSValueArrayUnit(mUnit)) { mValue.mCSSValueArray->Release(); } else if (IsStringUnit(mUnit)) { MOZ_ASSERT(mValue.mString, "expecting non-null string"); mValue.mString->Release(); } else if (mUnit == eUnit_ComplexColor) { mValue.mComplexColor->Release(); } } bool StyleAnimationValue::operator==(const StyleAnimationValue& aOther) const { if (mUnit != aOther.mUnit) { return false; } switch (mUnit) { case eUnit_Null: case eUnit_Normal: case eUnit_Auto: case eUnit_None: case eUnit_CurrentColor: return true; case eUnit_Enumerated: case eUnit_Visibility: case eUnit_Integer: return mValue.mInt == aOther.mValue.mInt; case eUnit_Coord: return mValue.mCoord == aOther.mValue.mCoord; case eUnit_Percent: case eUnit_Float: return mValue.mFloat == aOther.mValue.mFloat; case eUnit_Calc: case eUnit_Color: case eUnit_ObjectPosition: case eUnit_URL: case eUnit_DiscreteCSSValue: MOZ_ASSERT(IsCSSValueUnit(mUnit), "This clause is for handling nsCSSValue-backed units"); return *mValue.mCSSValue == *aOther.mValue.mCSSValue; case eUnit_CSSValuePair: return *mValue.mCSSValuePair == *aOther.mValue.mCSSValuePair; case eUnit_CSSValueTriplet: return *mValue.mCSSValueTriplet == *aOther.mValue.mCSSValueTriplet; case eUnit_CSSRect: return *mValue.mCSSRect == *aOther.mValue.mCSSRect; case eUnit_Dasharray: case eUnit_Shadow: case eUnit_Filter: case eUnit_BackgroundPositionCoord: return nsCSSValueList::Equal(mValue.mCSSValueList, aOther.mValue.mCSSValueList); case eUnit_Shape: return *mValue.mCSSValueArray == *aOther.mValue.mCSSValueArray; case eUnit_Transform: return *mValue.mCSSValueSharedList == *aOther.mValue.mCSSValueSharedList; case eUnit_CSSValuePairList: return nsCSSValuePairList::Equal(mValue.mCSSValuePairList, aOther.mValue.mCSSValuePairList); case eUnit_UnparsedString: return (NS_strcmp(GetStringBufferValue(), aOther.GetStringBufferValue()) == 0); case eUnit_ComplexColor: return *mValue.mComplexColor == *aOther.mValue.mComplexColor; } NS_NOTREACHED("incomplete case"); return false; }