PRBool nsHTMLFontElement::ParseAttribute(PRInt32 aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::size) { nsAutoString tmp(aValue); tmp.CompressWhitespace(PR_TRUE, PR_TRUE); PRUnichar ch = tmp.IsEmpty() ? 0 : tmp.First(); if ((ch == '+' || ch == '-') && aResult.ParseEnumValue(aValue, kRelFontSizeTable)) { return PR_TRUE; } return aResult.ParseIntValue(aValue); } if (aAttribute == nsGkAtoms::pointSize || aAttribute == nsGkAtoms::fontWeight) { return aResult.ParseIntValue(aValue); } if (aAttribute == nsGkAtoms::color) { return aResult.ParseColor(aValue, GetOwnerDoc()); } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
bool HTMLButtonElement::ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::type) { // XXX ARG!! This is major evilness. ParseAttribute // shouldn't set members. Override SetAttr instead bool success = aResult.ParseEnumValue(aValue, kButtonTypeTable, false); if (success) { mType = aResult.GetEnumValue(); } else { mType = kButtonDefaultType->value; } return success; } if (aAttribute == nsGkAtoms::formmethod) { return aResult.ParseEnumValue(aValue, kFormMethodTable, false); } if (aAttribute == nsGkAtoms::formenctype) { return aResult.ParseEnumValue(aValue, kFormEnctypeTable, false); } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
void nsStyledElementNotElementCSSInlineStyle::ParseStyleAttribute(const nsAString& aValue, nsAttrValue& aResult, bool aForceInDataDoc) { nsIDocument* doc = OwnerDoc(); bool isNativeAnon = IsInNativeAnonymousSubtree(); if (!isNativeAnon && !nsStyleUtil::CSPAllowsInlineStyle(nullptr, NodePrincipal(), doc->GetDocumentURI(), 0, aValue, nullptr)) return; if (aForceInDataDoc || !doc->IsLoadedAsData() || doc->IsStaticDocument()) { bool isCSS = true; // assume CSS until proven otherwise if (!isNativeAnon) { // native anonymous content always assumes CSS nsAutoString styleType; doc->GetHeaderData(nsGkAtoms::headerContentStyleType, styleType); if (!styleType.IsEmpty()) { static const char textCssStr[] = "text/css"; isCSS = (styleType.EqualsIgnoreCase(textCssStr, sizeof(textCssStr) - 1)); } } if (isCSS && aResult.ParseStyleAttribute(aValue, this)) { return; } } aResult.SetTo(aValue); }
bool nsMathMLElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute, const nsAString& aValue, nsIPrincipal* aMaybeScriptedPrincipal, nsAttrValue& aResult) { MOZ_ASSERT(IsMathMLElement()); if (aNamespaceID == kNameSpaceID_None) { if (mNodeInfo->Equals(nsGkAtoms::math) && aAttribute == nsGkAtoms::mode) { WarnDeprecated(nsGkAtoms::mode->GetUTF16String(), nsGkAtoms::display->GetUTF16String(), OwnerDoc()); } if (aAttribute == nsGkAtoms::color) { WarnDeprecated(nsGkAtoms::color->GetUTF16String(), nsGkAtoms::mathcolor_->GetUTF16String(), OwnerDoc()); } if (aAttribute == nsGkAtoms::color || aAttribute == nsGkAtoms::mathcolor_ || aAttribute == nsGkAtoms::background || aAttribute == nsGkAtoms::mathbackground_) { return aResult.ParseColor(aValue); } if (mNodeInfo->Equals(nsGkAtoms::mtd_)) { if (aAttribute == nsGkAtoms::columnspan_) { aResult.ParseClampedNonNegativeInt(aValue, 1, 1, MAX_COLSPAN); return true; } if (aAttribute == nsGkAtoms::rowspan) { aResult.ParseClampedNonNegativeInt(aValue, 1, 0, MAX_ROWSPAN); return true; } } } return nsMathMLElementBase::ParseAttribute(aNamespaceID, aAttribute, aValue, aMaybeScriptedPrincipal, aResult); }
bool HTMLBodyElement::ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::bgcolor || aAttribute == nsGkAtoms::text || aAttribute == nsGkAtoms::link || aAttribute == nsGkAtoms::alink || aAttribute == nsGkAtoms::vlink) { return aResult.ParseColor(aValue); } if (aAttribute == nsGkAtoms::marginwidth || aAttribute == nsGkAtoms::marginheight || aAttribute == nsGkAtoms::topmargin || aAttribute == nsGkAtoms::bottommargin || aAttribute == nsGkAtoms::leftmargin || aAttribute == nsGkAtoms::rightmargin) { return aResult.ParseIntWithBounds(aValue, 0); } } return nsGenericHTMLElement::ParseBackgroundAttribute(aNamespaceID, aAttribute, aValue, aResult) || nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
PRBool nsHTMLIFrameElement::ParseAttribute(PRInt32 aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::marginwidth) { return aResult.ParseSpecialIntValue(aValue, PR_TRUE); } if (aAttribute == nsGkAtoms::marginheight) { return aResult.ParseSpecialIntValue(aValue, PR_TRUE); } if (aAttribute == nsGkAtoms::width) { return aResult.ParseSpecialIntValue(aValue, PR_TRUE); } if (aAttribute == nsGkAtoms::height) { return aResult.ParseSpecialIntValue(aValue, PR_TRUE); } if (aAttribute == nsGkAtoms::frameborder) { return ParseFrameborderValue(aValue, aResult); } if (aAttribute == nsGkAtoms::scrolling) { return ParseScrollingValue(aValue, aResult); } if (aAttribute == nsGkAtoms::align) { return ParseAlignValue(aValue, aResult); } } return nsGenericHTMLFrameElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
bool HTMLLinkElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute, const nsAString& aValue, nsIPrincipal* aMaybeScriptedPrincipal, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::crossorigin) { ParseCORSValue(aValue, aResult); return true; } if (aAttribute == nsGkAtoms::as) { ParseAsValue(aValue, aResult); return true; } if (aAttribute == nsGkAtoms::sizes) { aResult.ParseAtomArray(aValue); return true; } if (aAttribute == nsGkAtoms::integrity) { aResult.ParseStringOrAtom(aValue); return true; } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aMaybeScriptedPrincipal, aResult); }
PRBool nsHTMLDivElement::ParseAttribute(PRInt32 aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (mNodeInfo->Equals(nsGkAtoms::marquee)) { if ((aAttribute == nsGkAtoms::width) || (aAttribute == nsGkAtoms::height)) { return aResult.ParseSpecialIntValue(aValue, PR_TRUE); } if (aAttribute == nsGkAtoms::bgcolor) { return aResult.ParseColor(aValue, GetOwnerDoc()); } if ((aAttribute == nsGkAtoms::hspace) || (aAttribute == nsGkAtoms::vspace)) { return aResult.ParseIntWithBounds(aValue, 0); } } if (mNodeInfo->Equals(nsGkAtoms::div) && aAttribute == nsGkAtoms::align) { return ParseDivAlignValue(aValue, aResult); } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
PRBool nsHTMLTableSectionElement::ParseAttribute(PRInt32 aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { /* ignore these attributes, stored simply as strings ch */ if (aAttribute == nsGkAtoms::charoff) { return aResult.ParseIntWithBounds(aValue, 0); } if (aAttribute == nsGkAtoms::height) { return aResult.ParseSpecialIntValue(aValue, PR_TRUE); } if (aAttribute == nsGkAtoms::align) { return ParseTableCellHAlignValue(aValue, aResult); } if (aAttribute == nsGkAtoms::bgcolor) { return aResult.ParseColor(aValue, GetOwnerDoc()); } if (aAttribute == nsGkAtoms::valign) { return ParseTableVAlignValue(aValue, aResult); } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
bool nsHTMLMenuItemElement::ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::type) { bool success = aResult.ParseEnumValue(aValue, kMenuItemTypeTable, false); if (success) { mType = aResult.GetEnumValue(); } else { mType = kMenuItemDefaultType->value; } return success; } if (aAttribute == nsGkAtoms::radiogroup) { aResult.ParseAtom(aValue); return true; } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
bool nsStyledElementNotElementCSSInlineStyle::ParseAttribute(PRInt32 aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::style) { SetMayHaveStyle(); ParseStyleAttribute(aValue, aResult, false); return true; } if (aAttribute == nsGkAtoms::_class) { SetFlags(NODE_MAY_HAVE_CLASS); aResult.ParseAtomArray(aValue); return true; } if (aAttribute == nsGkAtoms::id) { // Store id as an atom. id="" means that the element has no id, // not that it has an emptystring as the id. RemoveFromIdTable(); if (aValue.IsEmpty()) { ClearHasID(); return false; } aResult.ParseAtom(aValue); SetHasID(); AddToIdTable(aResult.GetAtomValue()); return true; } } return nsStyledElementBase::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
bool nsHTMLTableColElement::ParseAttribute(PRInt32 aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { /* ignore these attributes, stored simply as strings ch */ if (aAttribute == nsGkAtoms::charoff) { return aResult.ParseSpecialIntValue(aValue); } if (aAttribute == nsGkAtoms::span) { /* protection from unrealistic large colspan values */ return aResult.ParseIntWithBounds(aValue, 1, MAX_COLSPAN); } if (aAttribute == nsGkAtoms::width) { return aResult.ParseSpecialIntValue(aValue); } if (aAttribute == nsGkAtoms::align) { return ParseTableCellHAlignValue(aValue, aResult); } if (aAttribute == nsGkAtoms::valign) { return ParseTableVAlignValue(aValue, aResult); } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
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 nsRuleData::SetBackgroundImage(nsAttrValue& aValue) { nsCSSValue* backImage = ValueForBackgroundImage(); // If the value is an image, or it is a URL and we attempted a load, // put it in the style tree. if (aValue.Type() == nsAttrValue::eURL) { aValue.LoadImage(mDocument); } if (aValue.Type() == nsAttrValue::eImage) { nsCSSValueList* list = backImage->SetListValue(); list->mValue.SetImageValue(aValue.GetImageValue()); } }
PRBool nsHTMLPreElement::ParseAttribute(nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aAttribute == nsHTMLAtoms::cols) { return aResult.ParseIntWithBounds(aValue, 0); } if (aAttribute == nsHTMLAtoms::width) { return aResult.ParseIntWithBounds(aValue, 0); } return nsGenericHTMLElement::ParseAttribute(aAttribute, aValue, aResult); }
PRBool nsHTMLLIElement::ParseAttribute(nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aAttribute == nsHTMLAtoms::type) { return aResult.ParseEnumValue(aValue, kOrderedListItemTypeTable, PR_TRUE) || aResult.ParseEnumValue(aValue, kUnorderedListItemTypeTable); } if (aAttribute == nsHTMLAtoms::value) { return aResult.ParseIntWithBounds(aValue, 0); } return nsGenericHTMLElement::ParseAttribute(aAttribute, aValue, aResult); }
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); } } }
void DOMSVGTests::GetAttrValue(PRUint8 aAttrEnum, nsAttrValue& aValue) const { MOZ_ASSERT(aAttrEnum < ArrayLength(sStringListNames), "aAttrEnum out of range"); aValue.SetTo(*GetOrCreateStringListAttribute(aAttrEnum), nullptr); }
nsresult nsAttrAndChildArray::RemoveAttrAt(uint32_t aPos, nsAttrValue& aValue) { NS_ASSERTION(aPos < AttrCount(), "out-of-bounds"); uint32_t nonmapped = NonMappedAttrCount(); if (aPos < nonmapped) { ATTRS(mImpl)[aPos].mValue.SwapValueWith(aValue); ATTRS(mImpl)[aPos].~InternalAttr(); uint32_t slotCount = AttrSlotCount(); memmove(&ATTRS(mImpl)[aPos], &ATTRS(mImpl)[aPos + 1], (slotCount - aPos - 1) * sizeof(InternalAttr)); memset(&ATTRS(mImpl)[slotCount - 1], 0, sizeof(InternalAttr)); return NS_OK; } if (MappedAttrCount() == 1) { // We're removing the last mapped attribute. Can't swap in this // case; have to copy. aValue.SetTo(*mImpl->mMappedAttrs->AttrAt(0)); NS_RELEASE(mImpl->mMappedAttrs); return NS_OK; } RefPtr<nsMappedAttributes> mapped = GetModifiableMapped(nullptr, nullptr, false); mapped->RemoveAttrAt(aPos - nonmapped, aValue); return MakeMappedUnique(mapped); }
nsresult nsSMILAnimationFunction::SetKeySplines(const nsAString& aKeySplines, nsAttrValue& aResult) { mKeySplines.Clear(); aResult.SetTo(aKeySplines); nsTArray<double> keySplines; nsresult rv = nsSMILParserUtils::ParseKeySplines(aKeySplines, keySplines); if (keySplines.Length() < 1 || keySplines.Length() % 4) rv = NS_ERROR_FAILURE; if (NS_SUCCEEDED(rv)) { mKeySplines.SetCapacity(keySplines.Length() % 4); for (PRUint32 i = 0; i < keySplines.Length() && NS_SUCCEEDED(rv); i += 4) { if (!mKeySplines.AppendElement(nsSMILKeySpline(keySplines[i], keySplines[i+1], keySplines[i+2], keySplines[i+3]))) { rv = NS_ERROR_OUT_OF_MEMORY; } } } mHasChanged = PR_TRUE; return rv; }
bool HTMLTrackElement::ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { // Map html attribute string values to TextTrackKind enums. static const nsAttrValue::EnumTable kKindTable[] = { { "subtitles", static_cast<int16_t>(TextTrackKind::Subtitles) }, { "captions", static_cast<int16_t>(TextTrackKind::Captions) }, { "descriptions", static_cast<int16_t>(TextTrackKind::Descriptions) }, { "chapters", static_cast<int16_t>(TextTrackKind::Chapters) }, { "metadata", static_cast<int16_t>(TextTrackKind::Metadata) }, { 0 } }; if (aNamespaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::kind) { // Case-insensitive lookup, with the first element as the default. return aResult.ParseEnumValue(aValue, kKindTable, false, kKindTable); } // Otherwise call the generic implementation. return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
nsresult SVGMotionSMILAnimationFunction::SetRotate(const nsAString& aRotate, nsAttrValue& aResult) { mHasChanged = true; aResult.SetTo(aRotate); if (aRotate.EqualsLiteral("auto")) { mRotateType = eRotateType_Auto; } else if (aRotate.EqualsLiteral("auto-reverse")) { mRotateType = eRotateType_AutoReverse; } else { mRotateType = eRotateType_Explicit; uint16_t angleUnit; if (!SVGOrient::GetValueFromString(aRotate, mRotateAngle, &angleUnit)) { mRotateAngle = 0.0f; // set default rotate angle // XXX report to console? return NS_ERROR_DOM_SYNTAX_ERR; } // Convert to radian units, if we're not already in radians. if (angleUnit != SVG_ANGLETYPE_RAD) { mRotateAngle *= SVGOrient::GetDegreesPerUnit(angleUnit) / SVGOrient::GetDegreesPerUnit(SVG_ANGLETYPE_RAD); } } return NS_OK; }
bool SVGMotionSMILAnimationFunction::SetAttr(nsAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult, nsresult* aParseResult) { // Handle motion-specific attrs if (aAttribute == nsGkAtoms::keyPoints) { nsresult rv = SetKeyPoints(aValue, aResult); if (aParseResult) { *aParseResult = rv; } } else if (aAttribute == nsGkAtoms::rotate) { nsresult rv = SetRotate(aValue, aResult); if (aParseResult) { *aParseResult = rv; } } else if (aAttribute == nsGkAtoms::path || aAttribute == nsGkAtoms::by || aAttribute == nsGkAtoms::from || aAttribute == nsGkAtoms::to || aAttribute == nsGkAtoms::values) { aResult.SetTo(aValue); MarkStaleIfAttributeAffectsPath(aAttribute); if (aParseResult) { *aParseResult = NS_OK; } } else { // Defer to superclass method return SMILAnimationFunction::SetAttr(aAttribute, aValue, aResult, aParseResult); } return true; }
bool nsMathMLElement::ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (Tag() == nsGkAtoms::math && aAttribute == nsGkAtoms::mode) { WarnDeprecated(nsGkAtoms::mode->GetUTF16String(), nsGkAtoms::display->GetUTF16String(), OwnerDoc()); } if (aAttribute == nsGkAtoms::color) { WarnDeprecated(nsGkAtoms::color->GetUTF16String(), nsGkAtoms::mathcolor_->GetUTF16String(), OwnerDoc()); } if (aAttribute == nsGkAtoms::color || aAttribute == nsGkAtoms::mathcolor_ || aAttribute == nsGkAtoms::background || aAttribute == nsGkAtoms::mathbackground_) { return aResult.ParseColor(aValue); } } return nsMathMLElementBase::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
nsresult SVGMotionSMILAnimationFunction::SetRotate(const nsAString& aRotate, nsAttrValue& aResult) { mHasChanged = true; aResult.SetTo(aRotate); if (aRotate.EqualsLiteral("auto")) { mRotateType = eRotateType_Auto; } else if (aRotate.EqualsLiteral("auto-reverse")) { mRotateType = eRotateType_AutoReverse; } else { mRotateType = eRotateType_Explicit; // Parse numeric angle string, with the help of a temp nsSVGAngle. nsSVGAngle svgAngle; svgAngle.Init(); nsresult rv = svgAngle.SetBaseValueString(aRotate, nullptr, false); if (NS_FAILED(rv)) { // Parse error mRotateAngle = 0.0f; // set default rotate angle // XXX report to console? return rv; } mRotateAngle = svgAngle.GetBaseValInSpecifiedUnits(); // Convert to radian units, if we're not already in radians. uint8_t angleUnit = svgAngle.GetBaseValueUnit(); if (angleUnit != SVG_ANGLETYPE_RAD) { mRotateAngle *= nsSVGAngle::GetDegreesPerUnit(angleUnit) / nsSVGAngle::GetDegreesPerUnit(SVG_ANGLETYPE_RAD); } } return NS_OK; }
void SVGTests::GetAttrValue(uint8_t aAttrEnum, nsAttrValue& aValue) const { MOZ_ASSERT(aAttrEnum < ArrayLength(sStringListNames), "aAttrEnum out of range"); aValue.SetTo(mStringListAttributes[aAttrEnum], nullptr); }
PRBool nsHTMLTextAreaElement::ParseAttribute(PRInt32 aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::cols) { return aResult.ParseIntWithBounds(aValue, 0); } if (aAttribute == nsGkAtoms::rows) { return aResult.ParseIntWithBounds(aValue, 0); } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
void nsStyledElement::ParseStyleAttribute(nsIContent* aContent, const nsAString& aValue, nsAttrValue& aResult, PRBool aForceInDataDoc) { nsresult result = NS_OK; nsIDocument* doc = aContent->GetOwnerDoc(); if (doc && (aForceInDataDoc || !doc->IsLoadedAsData())) { PRBool isCSS = PR_TRUE; // assume CSS until proven otherwise if (!aContent->IsInNativeAnonymousSubtree()) { // native anonymous content // always assumes CSS nsAutoString styleType; doc->GetHeaderData(nsGkAtoms::headerContentStyleType, styleType); if (!styleType.IsEmpty()) { static const char textCssStr[] = "text/css"; isCSS = (styleType.EqualsIgnoreCase(textCssStr, sizeof(textCssStr) - 1)); } } if (isCSS) { nsICSSLoader* cssLoader = doc->CSSLoader(); nsCOMPtr<nsICSSParser> cssParser; result = cssLoader->GetParserFor(nsnull, getter_AddRefs(cssParser)); if (cssParser) { nsCOMPtr<nsIURI> baseURI = aContent->GetBaseURI(); nsCOMPtr<nsICSSStyleRule> rule; result = cssParser->ParseStyleAttribute(aValue, doc->GetDocumentURI(), baseURI, aContent->NodePrincipal(), getter_AddRefs(rule)); cssLoader->RecycleParser(cssParser); if (rule) { aResult.SetTo(rule); return; } } } } aResult.SetTo(aValue); }
bool HTMLTextAreaElement::ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) { if (aNamespaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::maxlength) { return aResult.ParseNonNegativeIntValue(aValue); } else if (aAttribute == nsGkAtoms::cols || aAttribute == nsGkAtoms::rows) { return aResult.ParsePositiveIntValue(aValue); } } return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue, aResult); }
nsresult nsSMILAnimationFunction::SetCalcMode(const nsAString& aCalcMode, nsAttrValue& aResult) { mHasChanged = PR_TRUE; PRBool parseResult = aResult.ParseEnumValue(aCalcMode, sCalcModeTable, PR_TRUE); SetCalcModeErrorFlag(!parseResult); return parseResult ? NS_OK : NS_ERROR_FAILURE; }