/* -*- 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/. */ /* * A struct that represents the value (type and actual data) of an * attribute. */ #include "mozilla/DebugOnly.h" #include "mozilla/HashFunctions.h" #include "nsAttrValue.h" #include "nsAttrValueInlines.h" #include "nsIAtom.h" #include "nsUnicharUtils.h" #include "mozilla/MemoryReporting.h" #include "mozilla/ServoBindingTypes.h" #include "mozilla/DeclarationBlockInlines.h" #include "nsContentUtils.h" #include "nsReadableUtils.h" #include "prprf.h" #include "nsHTMLCSSStyleSheet.h" #include "nsCSSParser.h" #include "nsStyledElement.h" #include "nsIURI.h" #include "nsIDocument.h" #include <algorithm> #ifdef LoadImage // Undefine LoadImage to prevent naming conflict with Windows. #undef LoadImage #endif using namespace mozilla; #define MISC_STR_PTR(_cont) \ reinterpret_cast<void*>((_cont)->mStringBits & NS_ATTRVALUE_POINTERVALUE_MASK) bool MiscContainer::GetString(nsAString& aString) const { void* ptr = MISC_STR_PTR(this); if (!ptr) { return false; } if (static_cast<nsAttrValue::ValueBaseType>(mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == nsAttrValue::eStringBase) { nsStringBuffer* buffer = static_cast<nsStringBuffer*>(ptr); if (!buffer) { return false; } buffer->ToString(buffer->StorageSize() / sizeof(char16_t) - 1, aString); return true; } nsIAtom* atom = static_cast<nsIAtom*>(ptr); if (!atom) { return false; } atom->ToString(aString); return true; } void MiscContainer::Cache() { // Not implemented for anything else yet. if (mType != nsAttrValue::eCSSDeclaration) { MOZ_ASSERT_UNREACHABLE("unexpected cached nsAttrValue type"); return; } MOZ_ASSERT(IsRefCounted()); MOZ_ASSERT(mValue.mRefCount > 0); MOZ_ASSERT(!mValue.mCached); nsHTMLCSSStyleSheet* sheet = mValue.mCSSDeclaration->GetHTMLCSSStyleSheet(); if (!sheet) { return; } nsString str; bool gotString = GetString(str); if (!gotString) { return; } sheet->CacheStyleAttr(str, this); mValue.mCached = 1; // This has to be immutable once it goes into the cache. mValue.mCSSDeclaration->SetImmutable(); } void MiscContainer::Evict() { // Not implemented for anything else yet. if (mType != nsAttrValue::eCSSDeclaration) { MOZ_ASSERT_UNREACHABLE("unexpected cached nsAttrValue type"); return; } MOZ_ASSERT(IsRefCounted()); MOZ_ASSERT(mValue.mRefCount == 0); if (!mValue.mCached) { return; } nsHTMLCSSStyleSheet* sheet = mValue.mCSSDeclaration->GetHTMLCSSStyleSheet(); MOZ_ASSERT(sheet); nsString str; DebugOnly<bool> gotString = GetString(str); MOZ_ASSERT(gotString); sheet->EvictStyleAttr(str, this); mValue.mCached = 0; } nsTArray<const nsAttrValue::EnumTable*>* nsAttrValue::sEnumTableArray = nullptr; nsAttrValue::nsAttrValue() : mBits(0) { } nsAttrValue::nsAttrValue(const nsAttrValue& aOther) : mBits(0) { SetTo(aOther); } nsAttrValue::nsAttrValue(const nsAString& aValue) : mBits(0) { SetTo(aValue); } nsAttrValue::nsAttrValue(nsIAtom* aValue) : mBits(0) { SetTo(aValue); } nsAttrValue::nsAttrValue(already_AddRefed<DeclarationBlock> aValue, const nsAString* aSerialized) : mBits(0) { SetTo(Move(aValue), aSerialized); } nsAttrValue::nsAttrValue(const nsIntMargin& aValue) : mBits(0) { SetTo(aValue); } nsAttrValue::~nsAttrValue() { ResetIfSet(); } /* static */ nsresult nsAttrValue::Init() { NS_ASSERTION(!sEnumTableArray, "nsAttrValue already initialized"); sEnumTableArray = new nsTArray<const EnumTable*>; return NS_OK; } /* static */ void nsAttrValue::Shutdown() { delete sEnumTableArray; sEnumTableArray = nullptr; } nsAttrValue::ValueType nsAttrValue::Type() const { switch (BaseType()) { case eIntegerBase: { return static_cast<ValueType>(mBits & NS_ATTRVALUE_INTEGERTYPE_MASK); } case eOtherBase: { return GetMiscContainer()->mType; } default: { return static_cast<ValueType>(static_cast<uint16_t>(BaseType())); } } } void nsAttrValue::Reset() { switch(BaseType()) { case eStringBase: { nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr()); if (str) { str->Release(); } break; } case eOtherBase: { MiscContainer* cont = GetMiscContainer(); if (cont->IsRefCounted() && cont->mValue.mRefCount > 1) { NS_RELEASE(cont); break; } delete ClearMiscContainer(); break; } case eAtomBase: { nsIAtom* atom = GetAtomValue(); NS_RELEASE(atom); break; } case eIntegerBase: { break; } } mBits = 0; } void nsAttrValue::SetTo(const nsAttrValue& aOther) { if (this == &aOther) { return; } switch (aOther.BaseType()) { case eStringBase: { ResetIfSet(); nsStringBuffer* str = static_cast<nsStringBuffer*>(aOther.GetPtr()); if (str) { str->AddRef(); SetPtrValueAndType(str, eStringBase); } return; } case eOtherBase: { break; } case eAtomBase: { ResetIfSet(); nsIAtom* atom = aOther.GetAtomValue(); NS_ADDREF(atom); SetPtrValueAndType(atom, eAtomBase); return; } case eIntegerBase: { ResetIfSet(); mBits = aOther.mBits; return; } } MiscContainer* otherCont = aOther.GetMiscContainer(); if (otherCont->IsRefCounted()) { delete ClearMiscContainer(); NS_ADDREF(otherCont); SetPtrValueAndType(otherCont, eOtherBase); return; } MiscContainer* cont = EnsureEmptyMiscContainer(); switch (otherCont->mType) { case eInteger: { cont->mValue.mInteger = otherCont->mValue.mInteger; break; } case eEnum: { cont->mValue.mEnumValue = otherCont->mValue.mEnumValue; break; } case ePercent: { cont->mValue.mPercent = otherCont->mValue.mPercent; break; } case eColor: { cont->mValue.mColor = otherCont->mValue.mColor; break; } case eCSSDeclaration: { MOZ_CRASH("These should be refcounted!"); } case eURL: { NS_ADDREF(cont->mValue.mURL = otherCont->mValue.mURL); break; } case eImage: { NS_ADDREF(cont->mValue.mImage = otherCont->mValue.mImage); break; } case eAtomArray: { if (!EnsureEmptyAtomArray() || !GetAtomArrayValue()->AppendElements(*otherCont->mValue.mAtomArray)) { Reset(); return; } break; } case eDoubleValue: { cont->mDoubleValue = otherCont->mDoubleValue; break; } case eIntMarginValue: { if (otherCont->mValue.mIntMargin) cont->mValue.mIntMargin = new nsIntMargin(*otherCont->mValue.mIntMargin); break; } default: { if (IsSVGType(otherCont->mType)) { // All SVG types are just pointers to classes and will therefore have // the same size so it doesn't really matter which one we assign cont->mValue.mSVGAngle = otherCont->mValue.mSVGAngle; } else { NS_NOTREACHED("unknown type stored in MiscContainer"); } break; } } void* otherPtr = MISC_STR_PTR(otherCont); if (otherPtr) { if (static_cast<ValueBaseType>(otherCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == eStringBase) { static_cast<nsStringBuffer*>(otherPtr)->AddRef(); } else { static_cast<nsIAtom*>(otherPtr)->AddRef(); } cont->mStringBits = otherCont->mStringBits; } // Note, set mType after switch-case, otherwise EnsureEmptyAtomArray doesn't // work correctly. cont->mType = otherCont->mType; } void nsAttrValue::SetTo(const nsAString& aValue) { ResetIfSet(); nsStringBuffer* buf = GetStringBuffer(aValue).take(); if (buf) { SetPtrValueAndType(buf, eStringBase); } } void nsAttrValue::SetTo(nsIAtom* aValue) { ResetIfSet(); if (aValue) { NS_ADDREF(aValue); SetPtrValueAndType(aValue, eAtomBase); } } void nsAttrValue::SetTo(int16_t aInt) { ResetIfSet(); SetIntValueAndType(aInt, eInteger, nullptr); } void nsAttrValue::SetTo(int32_t aInt, const nsAString* aSerialized) { ResetIfSet(); SetIntValueAndType(aInt, eInteger, aSerialized); } void nsAttrValue::SetTo(double aValue, const nsAString* aSerialized) { MiscContainer* cont = EnsureEmptyMiscContainer(); cont->mDoubleValue = aValue; cont->mType = eDoubleValue; SetMiscAtomOrString(aSerialized); } void nsAttrValue::SetTo(already_AddRefed<DeclarationBlock> aValue, const nsAString* aSerialized) { MiscContainer* cont = EnsureEmptyMiscContainer(); MOZ_ASSERT(cont->mValue.mRefCount == 0); cont->mValue.mCSSDeclaration = aValue.take(); cont->mType = eCSSDeclaration; NS_ADDREF(cont); SetMiscAtomOrString(aSerialized); MOZ_ASSERT(cont->mValue.mRefCount == 1); } void nsAttrValue::SetTo(css::URLValue* aValue, const nsAString* aSerialized) { MiscContainer* cont = EnsureEmptyMiscContainer(); NS_ADDREF(cont->mValue.mURL = aValue); cont->mType = eURL; SetMiscAtomOrString(aSerialized); } void nsAttrValue::SetTo(const nsIntMargin& aValue) { MiscContainer* cont = EnsureEmptyMiscContainer(); cont->mValue.mIntMargin = new nsIntMargin(aValue); cont->mType = eIntMarginValue; } void nsAttrValue::SetToSerialized(const nsAttrValue& aOther) { if (aOther.Type() != nsAttrValue::eString && aOther.Type() != nsAttrValue::eAtom) { nsAutoString val; aOther.ToString(val); SetTo(val); } else { SetTo(aOther); } } void nsAttrValue::SetTo(const nsSVGAngle& aValue, const nsAString* aSerialized) { SetSVGType(eSVGAngle, &aValue, aSerialized); } void nsAttrValue::SetTo(const nsSVGIntegerPair& aValue, const nsAString* aSerialized) { SetSVGType(eSVGIntegerPair, &aValue, aSerialized); } void nsAttrValue::SetTo(const nsSVGLength2& aValue, const nsAString* aSerialized) { SetSVGType(eSVGLength, &aValue, aSerialized); } void nsAttrValue::SetTo(const SVGLengthList& aValue, const nsAString* aSerialized) { // While an empty string will parse as a length list, there's no need to store // it (and SetMiscAtomOrString will assert if we try) if (aSerialized && aSerialized->IsEmpty()) { aSerialized = nullptr; } SetSVGType(eSVGLengthList, &aValue, aSerialized); } void nsAttrValue::SetTo(const SVGNumberList& aValue, const nsAString* aSerialized) { // While an empty string will parse as a number list, there's no need to store // it (and SetMiscAtomOrString will assert if we try) if (aSerialized && aSerialized->IsEmpty()) { aSerialized = nullptr; } SetSVGType(eSVGNumberList, &aValue, aSerialized); } void nsAttrValue::SetTo(const nsSVGNumberPair& aValue, const nsAString* aSerialized) { SetSVGType(eSVGNumberPair, &aValue, aSerialized); } void nsAttrValue::SetTo(const SVGPathData& aValue, const nsAString* aSerialized) { // While an empty string will parse as path data, there's no need to store it // (and SetMiscAtomOrString will assert if we try) if (aSerialized && aSerialized->IsEmpty()) { aSerialized = nullptr; } SetSVGType(eSVGPathData, &aValue, aSerialized); } void nsAttrValue::SetTo(const SVGPointList& aValue, const nsAString* aSerialized) { // While an empty string will parse as a point list, there's no need to store // it (and SetMiscAtomOrString will assert if we try) if (aSerialized && aSerialized->IsEmpty()) { aSerialized = nullptr; } SetSVGType(eSVGPointList, &aValue, aSerialized); } void nsAttrValue::SetTo(const SVGAnimatedPreserveAspectRatio& aValue, const nsAString* aSerialized) { SetSVGType(eSVGPreserveAspectRatio, &aValue, aSerialized); } void nsAttrValue::SetTo(const SVGStringList& aValue, const nsAString* aSerialized) { // While an empty string will parse as a string list, there's no need to store // it (and SetMiscAtomOrString will assert if we try) if (aSerialized && aSerialized->IsEmpty()) { aSerialized = nullptr; } SetSVGType(eSVGStringList, &aValue, aSerialized); } void nsAttrValue::SetTo(const SVGTransformList& aValue, const nsAString* aSerialized) { // While an empty string will parse as a transform list, there's no need to // store it (and SetMiscAtomOrString will assert if we try) if (aSerialized && aSerialized->IsEmpty()) { aSerialized = nullptr; } SetSVGType(eSVGTransformList, &aValue, aSerialized); } void nsAttrValue::SetTo(const nsSVGViewBox& aValue, const nsAString* aSerialized) { SetSVGType(eSVGViewBox, &aValue, aSerialized); } void nsAttrValue::SwapValueWith(nsAttrValue& aOther) { uintptr_t tmp = aOther.mBits; aOther.mBits = mBits; mBits = tmp; } void nsAttrValue::ToString(nsAString& aResult) const { MiscContainer* cont = nullptr; if (BaseType() == eOtherBase) { cont = GetMiscContainer(); if (cont->GetString(aResult)) { return; } } switch(Type()) { case eString: { nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr()); if (str) { str->ToString(str->StorageSize()/sizeof(char16_t) - 1, aResult); } else { aResult.Truncate(); } break; } case eAtom: { nsIAtom *atom = static_cast<nsIAtom*>(GetPtr()); atom->ToString(aResult); break; } case eInteger: { nsAutoString intStr; intStr.AppendInt(GetIntegerValue()); aResult = intStr; break; } #ifdef DEBUG case eColor: { NS_NOTREACHED("color attribute without string data"); aResult.Truncate(); break; } #endif case eEnum: { GetEnumString(aResult, false); break; } case ePercent: { nsAutoString intStr; intStr.AppendInt(cont ? cont->mValue.mPercent : GetIntInternal()); aResult = intStr + NS_LITERAL_STRING("%"); break; } case eCSSDeclaration: { aResult.Truncate(); MiscContainer *container = GetMiscContainer(); if (DeclarationBlock* decl = container->mValue.mCSSDeclaration) { decl->ToString(aResult); } const_cast<nsAttrValue*>(this)->SetMiscAtomOrString(&aResult); break; } case eDoubleValue: { aResult.Truncate(); aResult.AppendFloat(GetDoubleValue()); break; } case eSVGAngle: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGAngle, aResult); break; } case eSVGIntegerPair: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGIntegerPair, aResult); break; } case eSVGLength: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGLength, aResult); break; } case eSVGLengthList: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGLengthList, aResult); break; } case eSVGNumberList: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGNumberList, aResult); break; } case eSVGNumberPair: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGNumberPair, aResult); break; } case eSVGPathData: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGPathData, aResult); break; } case eSVGPointList: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGPointList, aResult); break; } case eSVGPreserveAspectRatio: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGPreserveAspectRatio, aResult); break; } case eSVGStringList: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGStringList, aResult); break; } case eSVGTransformList: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGTransformList, aResult); break; } case eSVGViewBox: { SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGViewBox, aResult); break; } default: { aResult.Truncate(); break; } } } already_AddRefed<nsIAtom> nsAttrValue::GetAsAtom() const { switch (Type()) { case eString: return NS_Atomize(GetStringValue()); case eAtom: { nsCOMPtr<nsIAtom> atom = GetAtomValue(); return atom.forget(); } default: { nsAutoString val; ToString(val); return NS_Atomize(val); } } } const nsCheapString nsAttrValue::GetStringValue() const { NS_PRECONDITION(Type() == eString, "wrong type"); return nsCheapString(static_cast<nsStringBuffer*>(GetPtr())); } bool nsAttrValue::GetColorValue(nscolor& aColor) const { if (Type() != eColor) { // Unparseable value, treat as unset. NS_ASSERTION(Type() == eString, "unexpected type for color-valued attr"); return false; } aColor = GetMiscContainer()->mValue.mColor; return true; } void nsAttrValue::GetEnumString(nsAString& aResult, bool aRealTag) const { NS_PRECONDITION(Type() == eEnum, "wrong type"); uint32_t allEnumBits = (BaseType() == eIntegerBase) ? static_cast<uint32_t>(GetIntInternal()) : GetMiscContainer()->mValue.mEnumValue; int16_t val = allEnumBits >> NS_ATTRVALUE_ENUMTABLEINDEX_BITS; const EnumTable* table = sEnumTableArray-> ElementAt(allEnumBits & NS_ATTRVALUE_ENUMTABLEINDEX_MASK); while (table->tag) { if (table->value == val) { aResult.AssignASCII(table->tag); if (!aRealTag && allEnumBits & NS_ATTRVALUE_ENUMTABLE_VALUE_NEEDS_TO_UPPER) { nsContentUtils::ASCIIToUpper(aResult); } return; } table++; } NS_NOTREACHED("couldn't find value in EnumTable"); } uint32_t nsAttrValue::GetAtomCount() const { ValueType type = Type(); if (type == eAtom) { return 1; } if (type == eAtomArray) { return GetAtomArrayValue()->Length(); } return 0; } nsIAtom* nsAttrValue::AtomAt(int32_t aIndex) const { NS_PRECONDITION(aIndex >= 0, "Index must not be negative"); NS_PRECONDITION(GetAtomCount() > uint32_t(aIndex), "aIndex out of range"); if (BaseType() == eAtomBase) { return GetAtomValue(); } NS_ASSERTION(Type() == eAtomArray, "GetAtomCount must be confused"); return GetAtomArrayValue()->ElementAt(aIndex); } uint32_t nsAttrValue::HashValue() const { switch(BaseType()) { case eStringBase: { nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr()); if (str) { uint32_t len = str->StorageSize()/sizeof(char16_t) - 1; return HashString(static_cast<char16_t*>(str->Data()), len); } return 0; } case eOtherBase: { break; } case eAtomBase: case eIntegerBase: { // mBits and uint32_t might have different size. This should silence // any warnings or compile-errors. This is what the implementation of // NS_PTR_TO_INT32 does to take care of the same problem. return mBits - 0; } } MiscContainer* cont = GetMiscContainer(); if (static_cast<ValueBaseType>(cont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == eAtomBase) { return cont->mStringBits - 0; } switch (cont->mType) { case eInteger: { return cont->mValue.mInteger; } case eEnum: { return cont->mValue.mEnumValue; } case ePercent: { return cont->mValue.mPercent; } case eColor: { return cont->mValue.mColor; } case eCSSDeclaration: { return NS_PTR_TO_INT32(cont->mValue.mCSSDeclaration); } // Intentionally identical, so that loading the image does not change the // hash code. case eURL: case eImage: { nsString str; ToString(str); return HashString(str); } case eAtomArray: { uint32_t hash = 0; uint32_t count = cont->mValue.mAtomArray->Length(); for (nsCOMPtr<nsIAtom> *cur = cont->mValue.mAtomArray->Elements(), *end = cur + count; cur != end; ++cur) { hash = AddToHash(hash, cur->get()); } return hash; } case eDoubleValue: { // XXX this is crappy, but oh well return cont->mDoubleValue; } case eIntMarginValue: { return NS_PTR_TO_INT32(cont->mValue.mIntMargin); } default: { if (IsSVGType(cont->mType)) { // All SVG types are just pointers to classes so we can treat them alike return NS_PTR_TO_INT32(cont->mValue.mSVGAngle); } NS_NOTREACHED("unknown type stored in MiscContainer"); return 0; } } } bool nsAttrValue::Equals(const nsAttrValue& aOther) const { if (BaseType() != aOther.BaseType()) { return false; } switch(BaseType()) { case eStringBase: { return GetStringValue().Equals(aOther.GetStringValue()); } case eOtherBase: { break; } case eAtomBase: case eIntegerBase: { return mBits == aOther.mBits; } } MiscContainer* thisCont = GetMiscContainer(); MiscContainer* otherCont = aOther.GetMiscContainer(); if (thisCont == otherCont) { return true; } if (thisCont->mType != otherCont->mType) { return false; } bool needsStringComparison = false; switch (thisCont->mType) { case eInteger: { if (thisCont->mValue.mInteger == otherCont->mValue.mInteger) { needsStringComparison = true; } break; } case eEnum: { if (thisCont->mValue.mEnumValue == otherCont->mValue.mEnumValue) { needsStringComparison = true; } break; } case ePercent: { if (thisCont->mValue.mPercent == otherCont->mValue.mPercent) { needsStringComparison = true; } break; } case eColor: { if (thisCont->mValue.mColor == otherCont->mValue.mColor) { needsStringComparison = true; } break; } case eCSSDeclaration: { return thisCont->mValue.mCSSDeclaration == otherCont->mValue.mCSSDeclaration; } case eURL: { return thisCont->mValue.mURL == otherCont->mValue.mURL; } case eImage: { return thisCont->mValue.mImage == otherCont->mValue.mImage; } case eAtomArray: { // For classlists we could be insensitive to order, however // classlists are never mapped attributes so they are never compared. if (!(*thisCont->mValue.mAtomArray == *otherCont->mValue.mAtomArray)) { return false; } needsStringComparison = true; break; } case eDoubleValue: { return thisCont->mDoubleValue == otherCont->mDoubleValue; } case eIntMarginValue: { return thisCont->mValue.mIntMargin == otherCont->mValue.mIntMargin; } default: { if (IsSVGType(thisCont->mType)) { // Currently this method is never called for nsAttrValue objects that // point to SVG data types. // If that changes then we probably want to add methods to the // corresponding SVG types to compare their base values. // As a shortcut, however, we can begin by comparing the pointers. MOZ_ASSERT(false, "Comparing nsAttrValues that point to SVG data"); return false; } NS_NOTREACHED("unknown type stored in MiscContainer"); return false; } } if (needsStringComparison) { if (thisCont->mStringBits == otherCont->mStringBits) { return true; } if ((static_cast<ValueBaseType>(thisCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == eStringBase) && (static_cast<ValueBaseType>(otherCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == eStringBase)) { return nsCheapString(reinterpret_cast<nsStringBuffer*>(thisCont->mStringBits)).Equals( nsCheapString(reinterpret_cast<nsStringBuffer*>(otherCont->mStringBits))); } } return false; } bool nsAttrValue::Equals(const nsAString& aValue, nsCaseTreatment aCaseSensitive) const { switch (BaseType()) { case eStringBase: { nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr()); if (str) { nsDependentString dep(static_cast<char16_t*>(str->Data()), str->StorageSize()/sizeof(char16_t) - 1); return aCaseSensitive == eCaseMatters ? aValue.Equals(dep) : nsContentUtils::EqualsIgnoreASCIICase(aValue, dep); } return aValue.IsEmpty(); } case eAtomBase: if (aCaseSensitive == eCaseMatters) { return static_cast<nsIAtom*>(GetPtr())->Equals(aValue); } return nsContentUtils::EqualsIgnoreASCIICase( nsDependentAtomString(static_cast<nsIAtom*>(GetPtr())), aValue); default: break; } nsAutoString val; ToString(val); return aCaseSensitive == eCaseMatters ? val.Equals(aValue) : nsContentUtils::EqualsIgnoreASCIICase(val, aValue); } bool nsAttrValue::Equals(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const { if (aCaseSensitive != eCaseMatters) { // Need a better way to handle this! nsAutoString value; aValue->ToString(value); return Equals(value, aCaseSensitive); } switch (BaseType()) { case eStringBase: { nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr()); if (str) { nsDependentString dep(static_cast<char16_t*>(str->Data()), str->StorageSize()/sizeof(char16_t) - 1); return aValue->Equals(dep); } return aValue == nsGkAtoms::_empty; } case eAtomBase: { return static_cast<nsIAtom*>(GetPtr()) == aValue; } default: break; } nsAutoString val; ToString(val); return aValue->Equals(val); } bool nsAttrValue::EqualsAsStrings(const nsAttrValue& aOther) const { if (Type() == aOther.Type()) { return Equals(aOther); } // We need to serialize at least one nsAttrValue before passing to // Equals(const nsAString&), but we can avoid unnecessarily serializing both // by checking if one is already of a string type. bool thisIsString = (BaseType() == eStringBase || BaseType() == eAtomBase); const nsAttrValue& lhs = thisIsString ? *this : aOther; const nsAttrValue& rhs = thisIsString ? aOther : *this; switch (rhs.BaseType()) { case eAtomBase: return lhs.Equals(rhs.GetAtomValue(), eCaseMatters); case eStringBase: return lhs.Equals(rhs.GetStringValue(), eCaseMatters); default: { nsAutoString val; rhs.ToString(val); return lhs.Equals(val, eCaseMatters); } } } bool nsAttrValue::Contains(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const { switch (BaseType()) { case eAtomBase: { nsIAtom* atom = GetAtomValue(); if (aCaseSensitive == eCaseMatters) { return aValue == atom; } // For performance reasons, don't do a full on unicode case insensitive // string comparison. This is only used for quirks mode anyway. return nsContentUtils::EqualsIgnoreASCIICase(nsDependentAtomString(aValue), nsDependentAtomString(atom)); } default: { if (Type() == eAtomArray) { AtomArray* array = GetAtomArrayValue(); if (aCaseSensitive == eCaseMatters) { return array->Contains(aValue); } nsDependentAtomString val1(aValue); for (nsCOMPtr<nsIAtom> *cur = array->Elements(), *end = cur + array->Length(); cur != end; ++cur) { // For performance reasons, don't do a full on unicode case // insensitive string comparison. This is only used for quirks mode // anyway. if (nsContentUtils::EqualsIgnoreASCIICase(val1, nsDependentAtomString(*cur))) { return true; } } } } } return false; } struct AtomArrayStringComparator { bool Equals(nsIAtom* atom, const nsAString& string) const { return atom->Equals(string); } }; bool nsAttrValue::Contains(const nsAString& aValue) const { switch (BaseType()) { case eAtomBase: { nsIAtom* atom = GetAtomValue(); return atom->Equals(aValue); } default: { if (Type() == eAtomArray) { AtomArray* array = GetAtomArrayValue(); return array->Contains(aValue, AtomArrayStringComparator()); } } } return false; } void nsAttrValue::ParseAtom(const nsAString& aValue) { ResetIfSet(); nsCOMPtr<nsIAtom> atom = NS_Atomize(aValue); if (atom) { SetPtrValueAndType(atom.forget().take(), eAtomBase); } } void nsAttrValue::ParseAtomArray(const nsAString& aValue) { nsAString::const_iterator iter, end; aValue.BeginReading(iter); aValue.EndReading(end); bool hasSpace = false; // skip initial whitespace while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) { hasSpace = true; ++iter; } if (iter == end) { SetTo(aValue); return; } nsAString::const_iterator start(iter); // get first - and often only - atom do { ++iter; } while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter)); nsCOMPtr<nsIAtom> classAtom = NS_Atomize(Substring(start, iter)); if (!classAtom) { Reset(); return; } // skip whitespace while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) { hasSpace = true; ++iter; } if (iter == end && !hasSpace) { // we only found one classname and there was no whitespace so // don't bother storing a list ResetIfSet(); nsIAtom* atom = nullptr; classAtom.swap(atom); SetPtrValueAndType(atom, eAtomBase); return; } if (!EnsureEmptyAtomArray()) { return; } AtomArray* array = GetAtomArrayValue(); if (!array->AppendElement(classAtom)) { Reset(); return; } // parse the rest of the classnames while (iter != end) { start = iter; do { ++iter; } while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter)); classAtom = NS_Atomize(Substring(start, iter)); if (!array->AppendElement(classAtom)) { Reset(); return; } // skip whitespace while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) { ++iter; } } SetMiscAtomOrString(&aValue); return; } void nsAttrValue::ParseStringOrAtom(const nsAString& aValue) { uint32_t len = aValue.Length(); // Don't bother with atoms if it's an empty string since // we can store those efficently anyway. if (len && len <= NS_ATTRVALUE_MAX_STRINGLENGTH_ATOM) { ParseAtom(aValue); } else { SetTo(aValue); } } void nsAttrValue::SetIntValueAndType(int32_t aValue, ValueType aType, const nsAString* aStringValue) { if (aStringValue || aValue > NS_ATTRVALUE_INTEGERTYPE_MAXVALUE || aValue < NS_ATTRVALUE_INTEGERTYPE_MINVALUE) { MiscContainer* cont = EnsureEmptyMiscContainer(); switch (aType) { case eInteger: { cont->mValue.mInteger = aValue; break; } case ePercent: { cont->mValue.mPercent = aValue; break; } case eEnum: { cont->mValue.mEnumValue = aValue; break; } default: { NS_NOTREACHED("unknown integer type"); break; } } cont->mType = aType; SetMiscAtomOrString(aStringValue); } else { NS_ASSERTION(!mBits, "Reset before calling SetIntValueAndType!"); mBits = (aValue * NS_ATTRVALUE_INTEGERTYPE_MULTIPLIER) | aType; } } int16_t nsAttrValue::GetEnumTableIndex(const EnumTable* aTable) { int16_t index = sEnumTableArray->IndexOf(aTable); if (index < 0) { index = sEnumTableArray->Length(); NS_ASSERTION(index <= NS_ATTRVALUE_ENUMTABLEINDEX_MAXVALUE, "too many enum tables"); sEnumTableArray->AppendElement(aTable); } return index; } int32_t nsAttrValue::EnumTableEntryToValue(const EnumTable* aEnumTable, const EnumTable* aTableEntry) { int16_t index = GetEnumTableIndex(aEnumTable); int32_t value = (aTableEntry->value << NS_ATTRVALUE_ENUMTABLEINDEX_BITS) + index; return value; } bool nsAttrValue::ParseEnumValue(const nsAString& aValue, const EnumTable* aTable, bool aCaseSensitive, const EnumTable* aDefaultValue) { ResetIfSet(); const EnumTable* tableEntry = aTable; while (tableEntry->tag) { if (aCaseSensitive ? aValue.EqualsASCII(tableEntry->tag) : aValue.LowerCaseEqualsASCII(tableEntry->tag)) { int32_t value = EnumTableEntryToValue(aTable, tableEntry); bool equals = aCaseSensitive || aValue.EqualsASCII(tableEntry->tag); if (!equals) { nsAutoString tag; tag.AssignASCII(tableEntry->tag); nsContentUtils::ASCIIToUpper(tag); if ((equals = tag.Equals(aValue))) { value |= NS_ATTRVALUE_ENUMTABLE_VALUE_NEEDS_TO_UPPER; } } SetIntValueAndType(value, eEnum, equals ? nullptr : &aValue); NS_ASSERTION(GetEnumValue() == tableEntry->value, "failed to store enum properly"); return true; } tableEntry++; } if (aDefaultValue) { NS_PRECONDITION(aTable <= aDefaultValue && aDefaultValue < tableEntry, "aDefaultValue not inside aTable?"); SetIntValueAndType(EnumTableEntryToValue(aTable, aDefaultValue), eEnum, &aValue); return true; } return false; } bool nsAttrValue::ParseSpecialIntValue(const nsAString& aString) { ResetIfSet(); nsAutoString tmp(aString); nsContentUtils::ParseHTMLIntegerResultFlags result; int32_t originalVal = nsContentUtils::ParseHTMLInteger(aString, &result); if (result & nsContentUtils::eParseHTMLInteger_Error) { return false; } bool isPercent = result & nsContentUtils::eParseHTMLInteger_IsPercent; int32_t val = std::max(originalVal, 0); bool nonStrict = val != originalVal || (result & nsContentUtils::eParseHTMLInteger_NonStandard) || (result & nsContentUtils::eParseHTMLInteger_DidNotConsumeAllInput); // % (percent) if (isPercent || tmp.RFindChar('%') >= 0) { isPercent = true; } SetIntValueAndType(val, isPercent ? ePercent : eInteger, nonStrict ? &aString : nullptr); return true; } bool nsAttrValue::ParseIntWithBounds(const nsAString& aString, int32_t aMin, int32_t aMax) { NS_PRECONDITION(aMin < aMax, "bad boundaries"); ResetIfSet(); nsContentUtils::ParseHTMLIntegerResultFlags result; int32_t originalVal = nsContentUtils::ParseHTMLInteger(aString, &result); if (result & nsContentUtils::eParseHTMLInteger_Error) { return false; } int32_t val = std::max(originalVal, aMin); val = std::min(val, aMax); bool nonStrict = (val != originalVal) || (result & nsContentUtils::eParseHTMLInteger_IsPercent) || (result & nsContentUtils::eParseHTMLInteger_NonStandard) || (result & nsContentUtils::eParseHTMLInteger_DidNotConsumeAllInput); SetIntValueAndType(val, eInteger, nonStrict ? &aString : nullptr); return true; } void nsAttrValue::ParseIntWithFallback(const nsAString& aString, int32_t aDefault, int32_t aMax) { ResetIfSet(); nsContentUtils::ParseHTMLIntegerResultFlags result; int32_t val = nsContentUtils::ParseHTMLInteger(aString, &result); bool nonStrict = false; if ((result & nsContentUtils::eParseHTMLInteger_Error) || val < 1) { val = aDefault; nonStrict = true; } if (val > aMax) { val = aMax; nonStrict = true; } if ((result & nsContentUtils::eParseHTMLInteger_IsPercent) || (result & nsContentUtils::eParseHTMLInteger_NonStandard) || (result & nsContentUtils::eParseHTMLInteger_DidNotConsumeAllInput)) { nonStrict = true; } SetIntValueAndType(val, eInteger, nonStrict ? &aString : nullptr); } bool nsAttrValue::ParseNonNegativeIntValue(const nsAString& aString) { ResetIfSet(); nsContentUtils::ParseHTMLIntegerResultFlags result; int32_t originalVal = nsContentUtils::ParseHTMLInteger(aString, &result); if ((result & nsContentUtils::eParseHTMLInteger_Error) || originalVal < 0) { return false; } bool nonStrict = (result & nsContentUtils::eParseHTMLInteger_IsPercent) || (result & nsContentUtils::eParseHTMLInteger_NonStandard) || (result & nsContentUtils::eParseHTMLInteger_DidNotConsumeAllInput); SetIntValueAndType(originalVal, eInteger, nonStrict ? &aString : nullptr); return true; } bool nsAttrValue::ParsePositiveIntValue(const nsAString& aString) { ResetIfSet(); nsContentUtils::ParseHTMLIntegerResultFlags result; int32_t originalVal = nsContentUtils::ParseHTMLInteger(aString, &result); if ((result & nsContentUtils::eParseHTMLInteger_Error) || originalVal <= 0) { return false; } bool nonStrict = (result & nsContentUtils::eParseHTMLInteger_IsPercent) || (result & nsContentUtils::eParseHTMLInteger_NonStandard) || (result & nsContentUtils::eParseHTMLInteger_DidNotConsumeAllInput); SetIntValueAndType(originalVal, eInteger, nonStrict ? &aString : nullptr); return true; } void nsAttrValue::SetColorValue(nscolor aColor, const nsAString& aString) { nsStringBuffer* buf = GetStringBuffer(aString).take(); if (!buf) { return; } MiscContainer* cont = EnsureEmptyMiscContainer(); cont->mValue.mColor = aColor; cont->mType = eColor; // Save the literal string we were passed for round-tripping. cont->mStringBits = reinterpret_cast<uintptr_t>(buf) | eStringBase; } bool nsAttrValue::ParseColor(const nsAString& aString) { ResetIfSet(); // FIXME (partially, at least): HTML5's algorithm says we shouldn't do // the whitespace compression, trimming, or the test for emptiness. // (I'm a little skeptical that we shouldn't do the whitespace // trimming; WebKit also does it.) nsAutoString colorStr(aString); colorStr.CompressWhitespace(true, true); if (colorStr.IsEmpty()) { return false; } nscolor color; // No color names begin with a '#'; in standards mode, all acceptable // numeric colors do. if (colorStr.First() == '#') { nsDependentString withoutHash(colorStr.get() + 1, colorStr.Length() - 1); if (NS_HexToRGBA(withoutHash, nsHexColorType::NoAlpha, &color)) { SetColorValue(color, aString); return true; } } else { if (NS_ColorNameToRGB(colorStr, &color)) { SetColorValue(color, aString); return true; } } // FIXME (maybe): HTML5 says we should handle system colors. This // means we probably need another storage type, since we'd need to // handle dynamic changes. However, I think this is a bad idea: // http://lists.whatwg.org/pipermail/whatwg-whatwg.org/2010-May/026449.html // Use NS_LooseHexToRGB as a fallback if nothing above worked. if (NS_LooseHexToRGB(colorStr, &color)) { SetColorValue(color, aString); return true; } return false; } bool nsAttrValue::ParseDoubleValue(const nsAString& aString) { ResetIfSet(); nsresult ec; double val = PromiseFlatString(aString).ToDouble(&ec); if (NS_FAILED(ec)) { return false; } MiscContainer* cont = EnsureEmptyMiscContainer(); cont->mDoubleValue = val; cont->mType = eDoubleValue; nsAutoString serializedFloat; serializedFloat.AppendFloat(val); SetMiscAtomOrString(serializedFloat.Equals(aString) ? nullptr : &aString); return true; } bool nsAttrValue::ParseIntMarginValue(const nsAString& aString) { ResetIfSet(); nsIntMargin margins; if (!nsContentUtils::ParseIntMarginValue(aString, margins)) return false; MiscContainer* cont = EnsureEmptyMiscContainer(); cont->mValue.mIntMargin = new nsIntMargin(margins); cont->mType = eIntMarginValue; SetMiscAtomOrString(&aString); return true; } void nsAttrValue::LoadImage(nsIDocument* aDocument) { NS_ASSERTION(Type() == eURL, "wrong type"); #ifdef DEBUG { nsString val; ToString(val); NS_ASSERTION(!val.IsEmpty(), "How did we end up with an empty string for eURL"); } #endif MiscContainer* cont = GetMiscContainer(); mozilla::css::URLValue* url = cont->mValue.mURL; mozilla::css::ImageValue* image = new css::ImageValue(url->GetURI(), url->mString, url->mBaseURI, url->mReferrer, url->mOriginPrincipal, aDocument); NS_ADDREF(image); cont->mValue.mImage = image; NS_RELEASE(url); cont->mType = eImage; } bool nsAttrValue::ParseStyleAttribute(const nsAString& aString, nsStyledElement* aElement) { nsIDocument* ownerDoc = aElement->OwnerDoc(); nsHTMLCSSStyleSheet* sheet = ownerDoc->GetInlineStyleSheet(); nsCOMPtr<nsIURI> baseURI = aElement->GetBaseURI(); nsIURI* docURI = ownerDoc->GetDocumentURI(); NS_ASSERTION(aElement->NodePrincipal() == ownerDoc->NodePrincipal(), "This is unexpected"); // If the (immutable) document URI does not match the element's base URI // (the common case is that they do match) do not cache the rule. This is // because the results of the CSS parser are dependent on these URIs, and we // do not want to have to account for the URIs in the hash lookup. bool cachingAllowed = sheet && baseURI == docURI; if (cachingAllowed) { MiscContainer* cont = sheet->LookupStyleAttr(aString); if (cont) { // Set our MiscContainer to the cached one. NS_ADDREF(cont); SetPtrValueAndType(cont, eOtherBase); return true; } } RefPtr<DeclarationBlock> decl; if (ownerDoc->GetStyleBackendType() == StyleBackendType::Servo) { decl = ServoDeclarationBlock::FromCssText(aString); } else { css::Loader* cssLoader = ownerDoc->CSSLoader(); nsCSSParser cssParser(cssLoader); decl = cssParser.ParseStyleAttribute(aString, docURI, baseURI, aElement->NodePrincipal()); } if (!decl) { return false; } decl->SetHTMLCSSStyleSheet(sheet); SetTo(decl.forget(), &aString); if (cachingAllowed) { MiscContainer* cont = GetMiscContainer(); cont->Cache(); } return true; } void nsAttrValue::SetMiscAtomOrString(const nsAString* aValue) { NS_ASSERTION(GetMiscContainer(), "Must have MiscContainer!"); NS_ASSERTION(!GetMiscContainer()->mStringBits, "Trying to re-set atom or string!"); if (aValue) { uint32_t len = aValue->Length(); // * We're allowing eCSSDeclaration attributes to store empty // strings as it can be beneficial to store an empty style // attribute as a parsed rule. // * We're allowing enumerated values because sometimes the empty // string corresponds to a particular enumerated value, especially // for enumerated values that are not limited enumerated. // Add other types as needed. NS_ASSERTION(len || Type() == eCSSDeclaration || Type() == eEnum, "Empty string?"); MiscContainer* cont = GetMiscContainer(); if (len <= NS_ATTRVALUE_MAX_STRINGLENGTH_ATOM) { nsCOMPtr<nsIAtom> atom = NS_Atomize(*aValue); if (atom) { cont->mStringBits = reinterpret_cast<uintptr_t>(atom.forget().take()) | eAtomBase; } } else { nsStringBuffer* buf = GetStringBuffer(*aValue).take(); if (buf) { cont->mStringBits = reinterpret_cast<uintptr_t>(buf) | eStringBase; } } } } void nsAttrValue::ResetMiscAtomOrString() { MiscContainer* cont = GetMiscContainer(); void* ptr = MISC_STR_PTR(cont); if (ptr) { if (static_cast<ValueBaseType>(cont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == eStringBase) { static_cast<nsStringBuffer*>(ptr)->Release(); } else { static_cast<nsIAtom*>(ptr)->Release(); } cont->mStringBits = 0; } } void nsAttrValue::SetSVGType(ValueType aType, const void* aValue, const nsAString* aSerialized) { MOZ_ASSERT(IsSVGType(aType), "Not an SVG type"); MiscContainer* cont = EnsureEmptyMiscContainer(); // All SVG types are just pointers to classes so just setting any of them // will do. We'll lose type-safety but the signature of the calling // function should ensure we don't get anything unexpected, and once we // stick aValue in a union we lose type information anyway. cont->mValue.mSVGAngle = static_cast<const nsSVGAngle*>(aValue); cont->mType = aType; SetMiscAtomOrString(aSerialized); } MiscContainer* nsAttrValue::ClearMiscContainer() { MiscContainer* cont = nullptr; if (BaseType() == eOtherBase) { cont = GetMiscContainer(); if (cont->IsRefCounted() && cont->mValue.mRefCount > 1) { // This MiscContainer is shared, we need a new one. NS_RELEASE(cont); cont = new MiscContainer; SetPtrValueAndType(cont, eOtherBase); } else { switch (cont->mType) { case eCSSDeclaration: { MOZ_ASSERT(cont->mValue.mRefCount == 1); cont->Release(); cont->Evict(); NS_RELEASE(cont->mValue.mCSSDeclaration); break; } case eURL: { NS_RELEASE(cont->mValue.mURL); break; } case eImage: { NS_RELEASE(cont->mValue.mImage); break; } case eAtomArray: { delete cont->mValue.mAtomArray; break; } case eIntMarginValue: { delete cont->mValue.mIntMargin; break; } default: { break; } } } ResetMiscAtomOrString(); } else { ResetIfSet(); } return cont; } MiscContainer* nsAttrValue::EnsureEmptyMiscContainer() { MiscContainer* cont = ClearMiscContainer(); if (cont) { MOZ_ASSERT(BaseType() == eOtherBase); ResetMiscAtomOrString(); cont = GetMiscContainer(); } else { cont = new MiscContainer; SetPtrValueAndType(cont, eOtherBase); } return cont; } bool nsAttrValue::EnsureEmptyAtomArray() { if (Type() == eAtomArray) { ResetMiscAtomOrString(); GetAtomArrayValue()->Clear(); return true; } MiscContainer* cont = EnsureEmptyMiscContainer(); cont->mValue.mAtomArray = new AtomArray; cont->mType = eAtomArray; return true; } already_AddRefed<nsStringBuffer> nsAttrValue::GetStringBuffer(const nsAString& aValue) const { uint32_t len = aValue.Length(); if (!len) { return nullptr; } RefPtr<nsStringBuffer> buf = nsStringBuffer::FromString(aValue); if (buf && (buf->StorageSize()/sizeof(char16_t) - 1) == len) { return buf.forget(); } buf = nsStringBuffer::Alloc((len + 1) * sizeof(char16_t)); if (!buf) { return nullptr; } char16_t *data = static_cast<char16_t*>(buf->Data()); CopyUnicodeTo(aValue, 0, data, len); data[len] = char16_t(0); return buf.forget(); } size_t nsAttrValue::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const { size_t n = 0; switch (BaseType()) { case eStringBase: { nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr()); n += str ? str->SizeOfIncludingThisIfUnshared(aMallocSizeOf) : 0; break; } case eOtherBase: { MiscContainer* container = GetMiscContainer(); if (!container) { break; } if (container->IsRefCounted() && container->mValue.mRefCount > 1) { // We don't report this MiscContainer at all in order to avoid // twice-reporting it. // TODO DMD, bug 1027551 - figure out how to report this ref-counted // object just once. break; } n += aMallocSizeOf(container); void* otherPtr = MISC_STR_PTR(container); // We only count the size of the object pointed by otherPtr if it's a // string. When it's an atom, it's counted separatly. if (otherPtr && static_cast<ValueBaseType>(container->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == eStringBase) { nsStringBuffer* str = static_cast<nsStringBuffer*>(otherPtr); n += str ? str->SizeOfIncludingThisIfUnshared(aMallocSizeOf) : 0; } if (Type() == eCSSDeclaration && container->mValue.mCSSDeclaration) { // TODO: mCSSDeclaration might be owned by another object which // would make us count them twice, bug 677493. // Bug 1281964: For ServoDeclarationBlock if we do measure we'll // need a way to call the Servo heap_size_of function. //n += container->mCSSDeclaration->SizeOfIncludingThis(aMallocSizeOf); } else if (Type() == eAtomArray && container->mValue.mAtomArray) { // Don't measure each nsIAtom, they are measured separatly. n += container->mValue.mAtomArray->ShallowSizeOfIncludingThis(aMallocSizeOf); } break; } case eAtomBase: // Atoms are counted separately. case eIntegerBase: // The value is in mBits, nothing to do. break; } return n; }