summaryrefslogtreecommitdiffstats
path: root/layout/style/nsROCSSPrimitiveValue.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/style/nsROCSSPrimitiveValue.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/style/nsROCSSPrimitiveValue.cpp')
-rw-r--r--layout/style/nsROCSSPrimitiveValue.cpp722
1 files changed, 722 insertions, 0 deletions
diff --git a/layout/style/nsROCSSPrimitiveValue.cpp b/layout/style/nsROCSSPrimitiveValue.cpp
new file mode 100644
index 000000000..cbc715eb2
--- /dev/null
+++ b/layout/style/nsROCSSPrimitiveValue.cpp
@@ -0,0 +1,722 @@
+/* -*- 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/. */
+
+/* DOM object representing values in DOM computed style */
+
+#include "nsROCSSPrimitiveValue.h"
+
+#include "mozilla/dom/CSSPrimitiveValueBinding.h"
+#include "nsPresContext.h"
+#include "nsStyleUtil.h"
+#include "nsDOMCSSRGBColor.h"
+#include "nsDOMCSSRect.h"
+#include "nsIURI.h"
+#include "nsError.h"
+
+using namespace mozilla;
+
+nsROCSSPrimitiveValue::nsROCSSPrimitiveValue()
+ : CSSValue(), mType(CSS_PX)
+{
+ mValue.mAppUnits = 0;
+}
+
+
+nsROCSSPrimitiveValue::~nsROCSSPrimitiveValue()
+{
+ Reset();
+}
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsROCSSPrimitiveValue)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsROCSSPrimitiveValue)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsROCSSPrimitiveValue)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsIDOMCSSPrimitiveValue)
+ NS_INTERFACE_MAP_ENTRY(nsIDOMCSSValue)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, CSSValue)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsROCSSPrimitiveValue)
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(nsROCSSPrimitiveValue)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsROCSSPrimitiveValue)
+ if (tmp->mType == CSS_URI) {
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mURI)
+ } else if (tmp->mType == CSS_RGBCOLOR) {
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mColor)
+ } else if (tmp->mType == CSS_RECT) {
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mRect)
+ }
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsROCSSPrimitiveValue)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ tmp->Reset();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+JSObject*
+nsROCSSPrimitiveValue::WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto)
+{
+ return dom::CSSPrimitiveValueBinding::Wrap(cx, this, aGivenProto);
+}
+
+// nsIDOMCSSValue
+
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::GetCssText(nsAString& aCssText)
+{
+ nsAutoString tmpStr;
+ aCssText.Truncate();
+ nsresult result = NS_OK;
+
+ switch (mType) {
+ case CSS_PX :
+ {
+ float val = nsPresContext::AppUnitsToFloatCSSPixels(mValue.mAppUnits);
+ nsStyleUtil::AppendCSSNumber(val, tmpStr);
+ tmpStr.AppendLiteral("px");
+ break;
+ }
+ case CSS_IDENT :
+ {
+ AppendUTF8toUTF16(nsCSSKeywords::GetStringValue(mValue.mKeyword),
+ tmpStr);
+ break;
+ }
+ case CSS_STRING :
+ case CSS_COUNTER : /* FIXME: COUNTER should use an object */
+ {
+ tmpStr.Append(mValue.mString);
+ break;
+ }
+ case CSS_URI :
+ {
+ if (mValue.mURI) {
+ nsAutoCString specUTF8;
+ nsresult rv = mValue.mURI->GetSpec(specUTF8);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ tmpStr.AssignLiteral("url(");
+ nsStyleUtil::AppendEscapedCSSString(NS_ConvertUTF8toUTF16(specUTF8),
+ tmpStr);
+ tmpStr.Append(')');
+ } else {
+ // http://dev.w3.org/csswg/css3-values/#attr defines
+ // 'about:invalid' as the default value for url attributes,
+ // so let's also use it here as the default computed value
+ // for invalid URLs.
+ tmpStr.AssignLiteral(u"url(about:invalid)");
+ }
+ break;
+ }
+ case CSS_ATTR :
+ {
+ tmpStr.AppendLiteral("attr(");
+ tmpStr.Append(mValue.mString);
+ tmpStr.Append(char16_t(')'));
+ break;
+ }
+ case CSS_PERCENTAGE :
+ {
+ nsStyleUtil::AppendCSSNumber(mValue.mFloat * 100, tmpStr);
+ tmpStr.Append(char16_t('%'));
+ break;
+ }
+ case CSS_NUMBER :
+ {
+ nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
+ break;
+ }
+ case CSS_NUMBER_INT32 :
+ {
+ tmpStr.AppendInt(mValue.mInt32);
+ break;
+ }
+ case CSS_NUMBER_UINT32 :
+ {
+ tmpStr.AppendInt(mValue.mUint32);
+ break;
+ }
+ case CSS_DEG :
+ {
+ nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
+ tmpStr.AppendLiteral("deg");
+ break;
+ }
+ case CSS_GRAD :
+ {
+ nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
+ tmpStr.AppendLiteral("grad");
+ break;
+ }
+ case CSS_RAD :
+ {
+ nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
+ tmpStr.AppendLiteral("rad");
+ break;
+ }
+ case CSS_TURN :
+ {
+ nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
+ tmpStr.AppendLiteral("turn");
+ break;
+ }
+ case CSS_RECT :
+ {
+ NS_ASSERTION(mValue.mRect, "mValue.mRect should never be null");
+ NS_NAMED_LITERAL_STRING(comma, ", ");
+ nsCOMPtr<nsIDOMCSSPrimitiveValue> sideCSSValue;
+ nsAutoString sideValue;
+ tmpStr.AssignLiteral("rect(");
+ // get the top
+ result = mValue.mRect->GetTop(getter_AddRefs(sideCSSValue));
+ if (NS_FAILED(result))
+ break;
+ result = sideCSSValue->GetCssText(sideValue);
+ if (NS_FAILED(result))
+ break;
+ tmpStr.Append(sideValue + comma);
+ // get the right
+ result = mValue.mRect->GetRight(getter_AddRefs(sideCSSValue));
+ if (NS_FAILED(result))
+ break;
+ result = sideCSSValue->GetCssText(sideValue);
+ if (NS_FAILED(result))
+ break;
+ tmpStr.Append(sideValue + comma);
+ // get the bottom
+ result = mValue.mRect->GetBottom(getter_AddRefs(sideCSSValue));
+ if (NS_FAILED(result))
+ break;
+ result = sideCSSValue->GetCssText(sideValue);
+ if (NS_FAILED(result))
+ break;
+ tmpStr.Append(sideValue + comma);
+ // get the left
+ result = mValue.mRect->GetLeft(getter_AddRefs(sideCSSValue));
+ if (NS_FAILED(result))
+ break;
+ result = sideCSSValue->GetCssText(sideValue);
+ if (NS_FAILED(result))
+ break;
+ tmpStr.Append(sideValue + NS_LITERAL_STRING(")"));
+ break;
+ }
+ case CSS_RGBCOLOR :
+ {
+ NS_ASSERTION(mValue.mColor, "mValue.mColor should never be null");
+ ErrorResult error;
+ NS_NAMED_LITERAL_STRING(comma, ", ");
+ nsAutoString colorValue;
+ if (mValue.mColor->HasAlpha())
+ tmpStr.AssignLiteral("rgba(");
+ else
+ tmpStr.AssignLiteral("rgb(");
+
+ // get the red component
+ mValue.mColor->Red()->GetCssText(colorValue, error);
+ if (error.Failed())
+ break;
+ tmpStr.Append(colorValue + comma);
+
+ // get the green component
+ mValue.mColor->Green()->GetCssText(colorValue, error);
+ if (error.Failed())
+ break;
+ tmpStr.Append(colorValue + comma);
+
+ // get the blue component
+ mValue.mColor->Blue()->GetCssText(colorValue, error);
+ if (error.Failed())
+ break;
+ tmpStr.Append(colorValue);
+
+ if (mValue.mColor->HasAlpha()) {
+ // get the alpha component
+ mValue.mColor->Alpha()->GetCssText(colorValue, error);
+ if (error.Failed())
+ break;
+ tmpStr.Append(comma + colorValue);
+ }
+
+ tmpStr.Append(')');
+
+ break;
+ }
+ case CSS_S :
+ {
+ nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
+ tmpStr.Append('s');
+ break;
+ }
+ case CSS_CM :
+ case CSS_MM :
+ case CSS_IN :
+ case CSS_PT :
+ case CSS_PC :
+ case CSS_UNKNOWN :
+ case CSS_EMS :
+ case CSS_EXS :
+ case CSS_MS :
+ case CSS_HZ :
+ case CSS_KHZ :
+ case CSS_DIMENSION :
+ NS_ERROR("We have a bogus value set. This should not happen");
+ return NS_ERROR_DOM_INVALID_ACCESS_ERR;
+ }
+
+ if (NS_SUCCEEDED(result)) {
+ aCssText.Assign(tmpStr);
+ }
+
+ return NS_OK;
+}
+
+void
+nsROCSSPrimitiveValue::GetCssText(nsString& aText, ErrorResult& aRv)
+{
+ aRv = GetCssText(aText);
+}
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::SetCssText(const nsAString& aCssText)
+{
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+}
+
+void
+nsROCSSPrimitiveValue::SetCssText(const nsAString& aText, ErrorResult& aRv)
+{
+ aRv = SetCssText(aText);
+}
+
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::GetCssValueType(uint16_t* aValueType)
+{
+ NS_ENSURE_ARG_POINTER(aValueType);
+ *aValueType = nsIDOMCSSValue::CSS_PRIMITIVE_VALUE;
+ return NS_OK;
+}
+
+uint16_t
+nsROCSSPrimitiveValue::CssValueType() const
+{
+ return nsIDOMCSSValue::CSS_PRIMITIVE_VALUE;
+}
+
+
+// nsIDOMCSSPrimitiveValue
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::GetPrimitiveType(uint16_t* aPrimitiveType)
+{
+ NS_ENSURE_ARG_POINTER(aPrimitiveType);
+ *aPrimitiveType = PrimitiveType();
+
+ return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::SetFloatValue(uint16_t aUnitType, float aFloatValue)
+{
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+}
+
+void
+nsROCSSPrimitiveValue::SetFloatValue(uint16_t aType, float aVal,
+ ErrorResult& aRv)
+{
+ aRv = SetFloatValue(aType, aVal);
+}
+
+float
+nsROCSSPrimitiveValue::GetFloatValue(uint16_t aUnitType, ErrorResult& aRv)
+{
+ switch(aUnitType) {
+ case CSS_PX :
+ if (mType == CSS_PX) {
+ return nsPresContext::AppUnitsToFloatCSSPixels(mValue.mAppUnits);
+ }
+
+ break;
+ case CSS_CM :
+ if (mType == CSS_PX) {
+ return mValue.mAppUnits * CM_PER_INCH_FLOAT /
+ nsPresContext::AppUnitsPerCSSInch();
+ }
+
+ break;
+ case CSS_MM :
+ if (mType == CSS_PX) {
+ return mValue.mAppUnits * MM_PER_INCH_FLOAT /
+ nsPresContext::AppUnitsPerCSSInch();
+ }
+
+ break;
+ case CSS_IN :
+ if (mType == CSS_PX) {
+ return mValue.mAppUnits / nsPresContext::AppUnitsPerCSSInch();
+ }
+
+ break;
+ case CSS_PT :
+ if (mType == CSS_PX) {
+ return mValue.mAppUnits * POINTS_PER_INCH_FLOAT /
+ nsPresContext::AppUnitsPerCSSInch();
+ }
+
+ break;
+ case CSS_PC :
+ if (mType == CSS_PX) {
+ return mValue.mAppUnits * 6.0f /
+ nsPresContext::AppUnitsPerCSSInch();
+ }
+
+ break;
+ case CSS_PERCENTAGE :
+ if (mType == CSS_PERCENTAGE) {
+ return mValue.mFloat * 100;
+ }
+
+ break;
+ case CSS_NUMBER :
+ if (mType == CSS_NUMBER) {
+ return mValue.mFloat;
+ }
+ if (mType == CSS_NUMBER_INT32) {
+ return mValue.mInt32;
+ }
+ if (mType == CSS_NUMBER_UINT32) {
+ return mValue.mUint32;
+ }
+
+ break;
+ case CSS_UNKNOWN :
+ case CSS_EMS :
+ case CSS_EXS :
+ case CSS_DEG :
+ case CSS_RAD :
+ case CSS_GRAD :
+ case CSS_MS :
+ case CSS_S :
+ case CSS_HZ :
+ case CSS_KHZ :
+ case CSS_DIMENSION :
+ case CSS_STRING :
+ case CSS_URI :
+ case CSS_IDENT :
+ case CSS_ATTR :
+ case CSS_COUNTER :
+ case CSS_RECT :
+ case CSS_RGBCOLOR :
+ break;
+ }
+
+ aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
+ return 0;
+}
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::GetFloatValue(uint16_t aType, float *aVal)
+{
+ ErrorResult rv;
+ *aVal = GetFloatValue(aType, rv);
+ return rv.StealNSResult();
+}
+
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::SetStringValue(uint16_t aStringType,
+ const nsAString& aStringValue)
+{
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+}
+
+void
+nsROCSSPrimitiveValue::SetStringValue(uint16_t aType, const nsAString& aString,
+ mozilla::ErrorResult& aRv)
+{
+ aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
+}
+
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::GetStringValue(nsAString& aReturn)
+{
+ switch (mType) {
+ case CSS_IDENT:
+ CopyUTF8toUTF16(nsCSSKeywords::GetStringValue(mValue.mKeyword), aReturn);
+ break;
+ case CSS_STRING:
+ case CSS_ATTR:
+ aReturn.Assign(mValue.mString);
+ break;
+ case CSS_URI: {
+ nsAutoCString spec;
+ if (mValue.mURI) {
+ nsresult rv = mValue.mURI->GetSpec(spec);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ CopyUTF8toUTF16(spec, aReturn);
+ break;
+ }
+ default:
+ aReturn.Truncate();
+ return NS_ERROR_DOM_INVALID_ACCESS_ERR;
+ }
+ return NS_OK;
+}
+
+void
+nsROCSSPrimitiveValue::GetStringValue(nsString& aString, ErrorResult& aRv)
+{
+ aRv = GetStringValue(aString);
+}
+
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::GetCounterValue(nsIDOMCounter** aReturn)
+{
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+}
+
+already_AddRefed<nsIDOMCounter>
+nsROCSSPrimitiveValue::GetCounterValue(ErrorResult& aRv)
+{
+ aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
+ return nullptr;
+}
+
+nsDOMCSSRect*
+nsROCSSPrimitiveValue::GetRectValue(ErrorResult& aRv)
+{
+ if (mType != CSS_RECT) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
+ return nullptr;
+ }
+
+ NS_ASSERTION(mValue.mRect, "mValue.mRect should never be null");
+ return mValue.mRect;
+}
+
+NS_IMETHODIMP
+nsROCSSPrimitiveValue::GetRectValue(nsIDOMRect** aRect)
+{
+ ErrorResult error;
+ NS_IF_ADDREF(*aRect = GetRectValue(error));
+ return error.StealNSResult();
+}
+
+nsDOMCSSRGBColor*
+nsROCSSPrimitiveValue::GetRGBColorValue(ErrorResult& aRv)
+{
+ if (mType != CSS_RGBCOLOR) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
+ return nullptr;
+ }
+
+ NS_ASSERTION(mValue.mColor, "mValue.mColor should never be null");
+ return mValue.mColor;
+}
+
+void
+nsROCSSPrimitiveValue::SetNumber(float aValue)
+{
+ Reset();
+ mValue.mFloat = aValue;
+ mType = CSS_NUMBER;
+}
+
+void
+nsROCSSPrimitiveValue::SetNumber(int32_t aValue)
+{
+ Reset();
+ mValue.mInt32 = aValue;
+ mType = CSS_NUMBER_INT32;
+}
+
+void
+nsROCSSPrimitiveValue::SetNumber(uint32_t aValue)
+{
+ Reset();
+ mValue.mUint32 = aValue;
+ mType = CSS_NUMBER_UINT32;
+}
+
+void
+nsROCSSPrimitiveValue::SetPercent(float aValue)
+{
+ Reset();
+ mValue.mFloat = aValue;
+ mType = CSS_PERCENTAGE;
+}
+
+void
+nsROCSSPrimitiveValue::SetDegree(float aValue)
+{
+ Reset();
+ mValue.mFloat = aValue;
+ mType = CSS_DEG;
+}
+
+void
+nsROCSSPrimitiveValue::SetGrad(float aValue)
+{
+ Reset();
+ mValue.mFloat = aValue;
+ mType = CSS_GRAD;
+}
+
+void
+nsROCSSPrimitiveValue::SetRadian(float aValue)
+{
+ Reset();
+ mValue.mFloat = aValue;
+ mType = CSS_RAD;
+}
+
+void
+nsROCSSPrimitiveValue::SetTurn(float aValue)
+{
+ Reset();
+ mValue.mFloat = aValue;
+ mType = CSS_TURN;
+}
+
+void
+nsROCSSPrimitiveValue::SetAppUnits(nscoord aValue)
+{
+ Reset();
+ mValue.mAppUnits = aValue;
+ mType = CSS_PX;
+}
+
+void
+nsROCSSPrimitiveValue::SetAppUnits(float aValue)
+{
+ SetAppUnits(NSToCoordRound(aValue));
+}
+
+void
+nsROCSSPrimitiveValue::SetIdent(nsCSSKeyword aKeyword)
+{
+ NS_PRECONDITION(aKeyword != eCSSKeyword_UNKNOWN &&
+ 0 <= aKeyword && aKeyword < eCSSKeyword_COUNT,
+ "bad keyword");
+ Reset();
+ mValue.mKeyword = aKeyword;
+ mType = CSS_IDENT;
+}
+
+// FIXME: CSS_STRING should imply a string with "" and a need for escaping.
+void
+nsROCSSPrimitiveValue::SetString(const nsACString& aString, uint16_t aType)
+{
+ Reset();
+ mValue.mString = ToNewUnicode(aString);
+ if (mValue.mString) {
+ mType = aType;
+ } else {
+ // XXXcaa We should probably let the caller know we are out of memory
+ mType = CSS_UNKNOWN;
+ }
+}
+
+// FIXME: CSS_STRING should imply a string with "" and a need for escaping.
+void
+nsROCSSPrimitiveValue::SetString(const nsAString& aString, uint16_t aType)
+{
+ Reset();
+ mValue.mString = ToNewUnicode(aString);
+ if (mValue.mString) {
+ mType = aType;
+ } else {
+ // XXXcaa We should probably let the caller know we are out of memory
+ mType = CSS_UNKNOWN;
+ }
+}
+
+void
+nsROCSSPrimitiveValue::SetURI(nsIURI *aURI)
+{
+ Reset();
+ mValue.mURI = aURI;
+ NS_IF_ADDREF(mValue.mURI);
+ mType = CSS_URI;
+}
+
+void
+nsROCSSPrimitiveValue::SetColor(nsDOMCSSRGBColor* aColor)
+{
+ NS_PRECONDITION(aColor, "Null RGBColor being set!");
+ Reset();
+ mValue.mColor = aColor;
+ if (mValue.mColor) {
+ NS_ADDREF(mValue.mColor);
+ mType = CSS_RGBCOLOR;
+ }
+ else {
+ mType = CSS_UNKNOWN;
+ }
+}
+
+void
+nsROCSSPrimitiveValue::SetRect(nsDOMCSSRect* aRect)
+{
+ NS_PRECONDITION(aRect, "Null rect being set!");
+ Reset();
+ mValue.mRect = aRect;
+ if (mValue.mRect) {
+ NS_ADDREF(mValue.mRect);
+ mType = CSS_RECT;
+ }
+ else {
+ mType = CSS_UNKNOWN;
+ }
+}
+
+void
+nsROCSSPrimitiveValue::SetTime(float aValue)
+{
+ Reset();
+ mValue.mFloat = aValue;
+ mType = CSS_S;
+}
+
+void
+nsROCSSPrimitiveValue::Reset()
+{
+ switch (mType) {
+ case CSS_IDENT:
+ break;
+ case CSS_STRING:
+ case CSS_ATTR:
+ case CSS_COUNTER: // FIXME: Counter should use an object
+ NS_ASSERTION(mValue.mString, "Null string should never happen");
+ free(mValue.mString);
+ mValue.mString = nullptr;
+ break;
+ case CSS_URI:
+ NS_IF_RELEASE(mValue.mURI);
+ break;
+ case CSS_RECT:
+ NS_ASSERTION(mValue.mRect, "Null Rect should never happen");
+ NS_RELEASE(mValue.mRect);
+ break;
+ case CSS_RGBCOLOR:
+ NS_ASSERTION(mValue.mColor, "Null RGBColor should never happen");
+ NS_RELEASE(mValue.mColor);
+ break;
+ }
+
+ mType = CSS_UNKNOWN;
+}