/* static */ bool
HTMLImageElement::SelectSourceForTagWithAttrs(nsIDocument *aDocument,
bool aIsSourceTag,
const nsAString& aSrcAttr,
const nsAString& aSrcsetAttr,
const nsAString& aSizesAttr,
const nsAString& aTypeAttr,
const nsAString& aMediaAttr,
nsAString& aResult)
{
MOZ_ASSERT(aIsSourceTag || (aTypeAttr.IsEmpty() && aMediaAttr.IsEmpty()),
"Passing type or media attrs makes no sense without aIsSourceTag");
MOZ_ASSERT(!aIsSourceTag || aSrcAttr.IsEmpty(),
"Passing aSrcAttr makes no sense with aIsSourceTag set");
bool pictureEnabled = HTMLPictureElement::IsPictureEnabled();
if (aIsSourceTag && !pictureEnabled) {
return false;
}
if (!IsSrcsetEnabled() || aSrcsetAttr.IsEmpty()) {
if (!aIsSourceTag) {
// For an <img> with no srcset, we would always select the src attr.
aResult.Assign(aSrcAttr);
return true;
}
// Otherwise, a <source> without srcset is never selected
return false;
}
// Would not consider source tags with unsupported media or type
if (aIsSourceTag &&
((!aMediaAttr.IsVoid() &&
!HTMLSourceElement::WouldMatchMediaForDocument(aMediaAttr, aDocument)) ||
(!aTypeAttr.IsVoid() &&
!SupportedPictureSourceType(aTypeAttr)))) {
return false;
}
// Using srcset or picture <source>, build a responsive selector for this tag.
RefPtr<ResponsiveImageSelector> sel =
new ResponsiveImageSelector(aDocument);
sel->SetCandidatesFromSourceSet(aSrcsetAttr);
if (pictureEnabled && !aSizesAttr.IsEmpty()) {
sel->SetSizesFromDescriptor(aSizesAttr);
}
if (!aIsSourceTag) {
sel->SetDefaultSource(aSrcAttr);
}
if (sel->GetSelectedImageURLSpec(aResult)) {
return true;
}
if (!aIsSourceTag) {
// <img> tag with no match would definitively load nothing.
aResult.Truncate();
return true;
}
// <source> tags with no match would leave source yet-undetermined.
return false;
}
void
SVGScriptElement::GetScriptCharset(nsAString& charset)
{
charset.Truncate();
}
void
nsSVGInteger::GetBaseValueString(nsAString & aValueAsString)
{
aValueAsString.Truncate();
aValueAsString.AppendInt(mBaseVal);
}
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;
mValue.mURI->GetSpec(specUTF8);
tmpStr.AssignLiteral("url(");
nsStyleUtil::AppendEscapedCSSString(NS_ConvertUTF8toUTF16(specUTF8),
tmpStr);
tmpStr.AppendLiteral(")");
} 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.Assign(NS_LITERAL_STRING("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_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(NS_LITERAL_STRING(")"));
break;
}
case CSS_S :
{
nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
tmpStr.AppendLiteral("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;
}
NS_IMETHODIMP
nsXULListboxAccessible::GetRowDescription(PRInt32 aRow, nsAString& aDescription)
{
aDescription.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsHelperMimeType::GetDescription(nsAString& aDescription)
{
aDescription.Truncate();
return NS_OK;
}
NS_IMETHODIMP
ApplicationAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
{
aName.Truncate();
return NS_ERROR_INVALID_ARG;
}
/* readonly attribute DOMString adapterDriverDate; */
NS_IMETHODIMP
GfxInfo::GetAdapterDriverDate(nsAString & aAdapterDriverDate)
{
aAdapterDriverDate.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsHTMLURIRefObject::GetNextURI(nsAString & aURI)
{
NS_ENSURE_TRUE(mNode, NS_ERROR_NOT_INITIALIZED);
nsAutoString tagName;
nsresult rv = mNode->GetNodeName(tagName);
NS_ENSURE_SUCCESS(rv, rv);
// Loop over attribute list:
if (!mAttributes)
{
nsCOMPtr<nsIDOMElement> element (do_QueryInterface(mNode));
NS_ENSURE_TRUE(element, NS_ERROR_INVALID_ARG);
mCurAttrIndex = 0;
element->GetAttributes(getter_AddRefs(mAttributes));
NS_ENSURE_TRUE(mAttributes, NS_ERROR_NOT_INITIALIZED);
rv = mAttributes->GetLength(&mAttributeCnt);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(mAttributeCnt, NS_ERROR_FAILURE);
mCurAttrIndex = 0;
}
#ifdef DEBUG_akkana
printf("Looking at tag '%s'\n",
NS_LossyConvertUTF16toASCII(tagName).get());
#endif
while (mCurAttrIndex < mAttributeCnt)
{
nsCOMPtr<nsIDOMAttr> attrNode;
rv = mAttributes->Item(mCurAttrIndex++, getter_AddRefs(attrNode));
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_ARG_POINTER(attrNode);
nsString curAttr;
rv = attrNode->GetName(curAttr);
NS_ENSURE_SUCCESS(rv, rv);
// href >> A, AREA, BASE, LINK
#ifdef DEBUG_akkana
printf("Trying to match attribute '%s'\n",
NS_LossyConvertUTF16toASCII(curAttr).get());
#endif
if (MATCHES(curAttr, "href"))
{
if (!MATCHES(tagName, "a") && !MATCHES(tagName, "area")
&& !MATCHES(tagName, "base") && !MATCHES(tagName, "link"))
continue;
rv = attrNode->GetValue(aURI);
NS_ENSURE_SUCCESS(rv, rv);
nsString uri (aURI);
// href pointing to a named anchor doesn't count
if (aURI.First() != char16_t('#'))
return NS_OK;
aURI.Truncate();
return NS_ERROR_INVALID_ARG;
}
// src >> FRAME, IFRAME, IMG, INPUT, SCRIPT
else if (MATCHES(curAttr, "src"))
{
if (!MATCHES(tagName, "img")
&& !MATCHES(tagName, "frame") && !MATCHES(tagName, "iframe")
&& !MATCHES(tagName, "input") && !MATCHES(tagName, "script"))
continue;
return attrNode->GetValue(aURI);
}
//<META http-equiv="refresh" content="3,http://www.acme.com/intro.html">
else if (MATCHES(curAttr, "content"))
{
if (!MATCHES(tagName, "meta"))
continue;
}
// longdesc >> FRAME, IFRAME, IMG
else if (MATCHES(curAttr, "longdesc"))
{
if (!MATCHES(tagName, "img")
&& !MATCHES(tagName, "frame") && !MATCHES(tagName, "iframe"))
continue;
}
// usemap >> IMG, INPUT, OBJECT
else if (MATCHES(curAttr, "usemap"))
{
if (!MATCHES(tagName, "img")
&& !MATCHES(tagName, "input") && !MATCHES(tagName, "object"))
continue;
}
// action >> FORM
else if (MATCHES(curAttr, "action"))
{
if (!MATCHES(tagName, "form"))
continue;
}
// background >> BODY
else if (MATCHES(curAttr, "background"))
{
if (!MATCHES(tagName, "body"))
continue;
}
// codebase >> OBJECT, APPLET
else if (MATCHES(curAttr, "codebase"))
{
if (!MATCHES(tagName, "meta"))
continue;
}
// classid >> OBJECT
else if (MATCHES(curAttr, "classid"))
{
if (!MATCHES(tagName, "object"))
continue;
}
// data >> OBJECT
else if (MATCHES(curAttr, "data"))
{
if (!MATCHES(tagName, "object"))
continue;
}
// cite >> BLOCKQUOTE, DEL, INS, Q
else if (MATCHES(curAttr, "cite"))
{
if (!MATCHES(tagName, "blockquote") && !MATCHES(tagName, "q")
&& !MATCHES(tagName, "del") && !MATCHES(tagName, "ins"))
continue;
}
// profile >> HEAD
else if (MATCHES(curAttr, "profile"))
{
if (!MATCHES(tagName, "head"))
continue;
}
// archive attribute on APPLET; warning, it contains a list of URIs.
else if (MATCHES(curAttr, "archive"))
{
if (!MATCHES(tagName, "applet"))
continue;
}
}
// Return a code to indicate that there are no more,
// to distinguish that case from real errors.
return NS_ERROR_NOT_AVAILABLE;
}
void
CopyUTF8toUTF16( const char* aSource, nsAString& aDest )
{
aDest.Truncate();
AppendUTF8toUTF16(aSource, aDest);
}
/* readonly attribute DOMString adapterRAM; */
NS_IMETHODIMP
GfxInfo::GetAdapterRAM(nsAString & aAdapterRAM)
{
aAdapterRAM.Truncate();
return NS_OK;
}
void
CopyASCIItoUTF16( const nsACString& aSource, nsAString& aDest )
{
aDest.Truncate();
AppendASCIItoUTF16(aSource, aDest);
}
nsresult
nsHTMLEditor::CheckPositionedElementBGandFG(nsIDOMElement * aElement,
nsAString & aReturn)
{
// we are going to outline the positioned element and bring it to the
// front to overlap any other element intersecting with it. But
// first, let's see what's the background and foreground colors of the
// positioned element.
// if background-image computed value is 'none,
// If the background color is 'auto' and R G B values of the foreground are
// each above #d0, use a black background
// If the background color is 'auto' and at least one of R G B values of
// the foreground is below #d0, use a white background
// Otherwise don't change background/foreground
aReturn.Truncate();
nsAutoString bgImageStr;
nsresult res =
mHTMLCSSUtils->GetComputedProperty(aElement,
nsEditProperty::cssBackgroundImage,
bgImageStr);
NS_ENSURE_SUCCESS(res, res);
if (bgImageStr.EqualsLiteral("none")) {
nsAutoString bgColorStr;
res =
mHTMLCSSUtils->GetComputedProperty(aElement,
nsEditProperty::cssBackgroundColor,
bgColorStr);
NS_ENSURE_SUCCESS(res, res);
if (bgColorStr.EqualsLiteral("transparent")) {
nsCOMPtr<nsIDOMWindow> window;
res = mHTMLCSSUtils->GetDefaultViewCSS(aElement, getter_AddRefs(window));
NS_ENSURE_SUCCESS(res, res);
nsCOMPtr<nsIDOMCSSStyleDeclaration> cssDecl;
res = window->GetComputedStyle(aElement, EmptyString(), getter_AddRefs(cssDecl));
NS_ENSURE_SUCCESS(res, res);
// from these declarations, get the one we want and that one only
nsCOMPtr<nsIDOMCSSValue> colorCssValue;
res = cssDecl->GetPropertyCSSValue(NS_LITERAL_STRING("color"), getter_AddRefs(colorCssValue));
NS_ENSURE_SUCCESS(res, res);
PRUint16 type;
res = colorCssValue->GetCssValueType(&type);
NS_ENSURE_SUCCESS(res, res);
if (nsIDOMCSSValue::CSS_PRIMITIVE_VALUE == type) {
nsCOMPtr<nsIDOMCSSPrimitiveValue> val = do_QueryInterface(colorCssValue);
res = val->GetPrimitiveType(&type);
NS_ENSURE_SUCCESS(res, res);
if (nsIDOMCSSPrimitiveValue::CSS_RGBCOLOR == type) {
nsCOMPtr<nsIDOMRGBColor> rgbColor;
res = val->GetRGBColorValue(getter_AddRefs(rgbColor));
NS_ENSURE_SUCCESS(res, res);
nsCOMPtr<nsIDOMCSSPrimitiveValue> red, green, blue;
float r, g, b;
res = rgbColor->GetRed(getter_AddRefs(red));
NS_ENSURE_SUCCESS(res, res);
res = rgbColor->GetGreen(getter_AddRefs(green));
NS_ENSURE_SUCCESS(res, res);
res = rgbColor->GetBlue(getter_AddRefs(blue));
NS_ENSURE_SUCCESS(res, res);
res = red->GetFloatValue(nsIDOMCSSPrimitiveValue::CSS_NUMBER, &r);
NS_ENSURE_SUCCESS(res, res);
res = green->GetFloatValue(nsIDOMCSSPrimitiveValue::CSS_NUMBER, &g);
NS_ENSURE_SUCCESS(res, res);
res = blue->GetFloatValue(nsIDOMCSSPrimitiveValue::CSS_NUMBER, &b);
NS_ENSURE_SUCCESS(res, res);
if (r >= BLACK_BG_RGB_TRIGGER &&
g >= BLACK_BG_RGB_TRIGGER &&
b >= BLACK_BG_RGB_TRIGGER)
aReturn.AssignLiteral("black");
else
aReturn.AssignLiteral("white");
return NS_OK;
}
}
}
}
return NS_OK;
}
void
URL::GetHostname(nsAString& aHostname, ErrorResult& aRv) const
{
aHostname.Truncate();
nsContentUtils::GetHostOrIPv6WithBrackets(mURI, aHostname);
}
nsresult
nsXULContentUtils::GetTextForNode(nsIRDFNode* aNode, nsAString& aResult)
{
if (! aNode) {
aResult.Truncate();
return NS_OK;
}
nsresult rv;
// Literals are the most common, so try these first.
nsCOMPtr<nsIRDFLiteral> literal = do_QueryInterface(aNode);
if (literal) {
const char16_t* p;
rv = literal->GetValueConst(&p);
if (NS_FAILED(rv)) return rv;
aResult = p;
return NS_OK;
}
nsCOMPtr<nsIRDFDate> dateLiteral = do_QueryInterface(aNode);
if (dateLiteral) {
PRTime value;
rv = dateLiteral->GetValue(&value);
if (NS_FAILED(rv)) return rv;
nsAutoString str;
rv = gFormat->FormatPRTime(nullptr /* nsILocale* locale */,
kDateFormatShort,
kTimeFormatSeconds,
value,
str);
aResult.Assign(str);
if (NS_FAILED(rv)) return rv;
return NS_OK;
}
nsCOMPtr<nsIRDFInt> intLiteral = do_QueryInterface(aNode);
if (intLiteral) {
int32_t value;
rv = intLiteral->GetValue(&value);
if (NS_FAILED(rv)) return rv;
aResult.Truncate();
nsAutoString intStr;
intStr.AppendInt(value, 10);
aResult.Append(intStr);
return NS_OK;
}
nsCOMPtr<nsIRDFResource> resource = do_QueryInterface(aNode);
if (resource) {
const char* p;
rv = resource->GetValueConst(&p);
if (NS_FAILED(rv)) return rv;
CopyUTF8toUTF16(p, aResult);
return NS_OK;
}
NS_ERROR("not a resource or a literal");
return NS_ERROR_UNEXPECTED;
}
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);
}
// We can reach this during parallel style traversal. If that happens,
// don't cache the string. The TLS overhead should't hurt us here, since
// main thread consumers will subsequently use the cache, and
// off-main-thread consumers only reach this in the rare case of selector
// matching on the "style" attribute.
if (!ServoStyleSet::IsInServoTraversal()) {
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;
}
}
}
// RFC 3454
//
// 1) Map -- For each character in the input, check if it has a mapping
// and, if so, replace it with its mapping. This is described in section 3.
//
// 2) Normalize -- Possibly normalize the result of step 1 using Unicode
// normalization. This is described in section 4.
//
// 3) Prohibit -- Check for any characters that are not allowed in the
// output. If any are found, return an error. This is described in section
// 5.
//
// 4) Check bidi -- Possibly check for right-to-left characters, and if any
// are found, make sure that the whole string satisfies the requirements
// for bidirectional strings. If the string does not satisfy the requirements
// for bidirectional strings, return an error. This is described in section 6.
//
// 5) Check unassigned code points -- If allowUnassigned is false, check for
// any unassigned Unicode points and if any are found return an error.
// This is described in section 7.
//
nsresult nsIDNService::stringPrep(const nsAString& in, nsAString& out,
stringPrepFlag flag)
{
#ifdef IDNA2008
return IDNA2008StringPrep(in, out, flag);
#else
if (!mNamePrepHandle || !mNormalizer)
return NS_ERROR_FAILURE;
uint32_t ucs4Buf[kMaxDNSNodeLen + 1];
uint32_t ucs4Len;
nsresult rv = utf16ToUcs4(in, ucs4Buf, kMaxDNSNodeLen, &ucs4Len);
NS_ENSURE_SUCCESS(rv, rv);
// map
idn_result_t idn_err;
uint32_t namePrepBuf[kMaxDNSNodeLen * 3]; // map up to three characters
idn_err = idn_nameprep_map(mNamePrepHandle, (const uint32_t *) ucs4Buf,
(uint32_t *) namePrepBuf, kMaxDNSNodeLen * 3);
NS_ENSURE_TRUE(idn_err == idn_success, NS_ERROR_FAILURE);
nsAutoString namePrepStr;
ucs4toUtf16(namePrepBuf, namePrepStr);
if (namePrepStr.Length() >= kMaxDNSNodeLen)
return NS_ERROR_FAILURE;
// normalize
nsAutoString normlizedStr;
rv = mNormalizer->NormalizeUnicodeNFKC(namePrepStr, normlizedStr);
if (normlizedStr.Length() >= kMaxDNSNodeLen)
return NS_ERROR_FAILURE;
// set the result string
out.Assign(normlizedStr);
if (flag == eStringPrepIgnoreErrors) {
return NS_OK;
}
// prohibit
const uint32_t *found = nullptr;
idn_err = idn_nameprep_isprohibited(mNamePrepHandle,
(const uint32_t *) ucs4Buf, &found);
if (idn_err != idn_success || found) {
rv = NS_ERROR_FAILURE;
} else {
// check bidi
idn_err = idn_nameprep_isvalidbidi(mNamePrepHandle,
(const uint32_t *) ucs4Buf, &found);
if (idn_err != idn_success || found) {
rv = NS_ERROR_FAILURE;
} else if (flag == eStringPrepForUI) {
// check unassigned code points
idn_err = idn_nameprep_isunassigned(mNamePrepHandle,
(const uint32_t *) ucs4Buf, &found);
if (idn_err != idn_success || found) {
rv = NS_ERROR_FAILURE;
}
}
}
if (flag == eStringPrepForDNS && NS_FAILED(rv)) {
out.Truncate();
}
return rv;
#endif
}
nsresult
nsHTMLEditor::CheckPositionedElementBGandFG(nsIDOMElement * aElement,
nsAString & aReturn)
{
// we are going to outline the positioned element and bring it to the
// front to overlap any other element intersecting with it. But
// first, let's see what's the background and foreground colors of the
// positioned element.
// if background-image computed value is 'none,
// If the background color is 'auto' and R G B values of the foreground are
// each above #d0, use a black background
// If the background color is 'auto' and at least one of R G B values of
// the foreground is below #d0, use a white background
// Otherwise don't change background/foreground
aReturn.Truncate();
nsAutoString bgImageStr;
nsresult res =
mHTMLCSSUtils->GetComputedProperty(aElement, nsGkAtoms::background_image,
bgImageStr);
NS_ENSURE_SUCCESS(res, res);
if (bgImageStr.EqualsLiteral("none")) {
nsAutoString bgColorStr;
res =
mHTMLCSSUtils->GetComputedProperty(aElement, nsGkAtoms::backgroundColor,
bgColorStr);
NS_ENSURE_SUCCESS(res, res);
if (bgColorStr.EqualsLiteral("transparent")) {
nsRefPtr<nsComputedDOMStyle> cssDecl =
mHTMLCSSUtils->GetComputedStyle(aElement);
NS_ENSURE_STATE(cssDecl);
// from these declarations, get the one we want and that one only
ErrorResult error;
nsRefPtr<dom::CSSValue> cssVal = cssDecl->GetPropertyCSSValue(NS_LITERAL_STRING("color"), error);
NS_ENSURE_SUCCESS(error.ErrorCode(), error.ErrorCode());
nsROCSSPrimitiveValue* val = cssVal->AsPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_FAILURE);
if (nsIDOMCSSPrimitiveValue::CSS_RGBCOLOR == val->PrimitiveType()) {
nsDOMCSSRGBColor* rgbVal = val->GetRGBColorValue(error);
NS_ENSURE_SUCCESS(error.ErrorCode(), error.ErrorCode());
float r = rgbVal->Red()->
GetFloatValue(nsIDOMCSSPrimitiveValue::CSS_NUMBER, error);
NS_ENSURE_SUCCESS(error.ErrorCode(), error.ErrorCode());
float g = rgbVal->Green()->
GetFloatValue(nsIDOMCSSPrimitiveValue::CSS_NUMBER, error);
NS_ENSURE_SUCCESS(error.ErrorCode(), error.ErrorCode());
float b = rgbVal->Blue()->
GetFloatValue(nsIDOMCSSPrimitiveValue::CSS_NUMBER, error);
NS_ENSURE_SUCCESS(error.ErrorCode(), error.ErrorCode());
if (r >= BLACK_BG_RGB_TRIGGER &&
g >= BLACK_BG_RGB_TRIGGER &&
b >= BLACK_BG_RGB_TRIGGER)
aReturn.AssignLiteral("black");
else
aReturn.AssignLiteral("white");
return NS_OK;
}
}
}
return NS_OK;
}
NS_IMETHODIMP
nsHelperMimeType::GetSuffixes(nsAString& aSuffixes)
{
aSuffixes.Truncate();
return NS_OK;
}
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(PRUnichar) - 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 eCSSStyleRule:
{
aResult.Truncate();
MiscContainer *container = GetMiscContainer();
css::Declaration *decl =
container->mValue.mCSSStyleRule->GetDeclaration();
if (decl) {
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;
}
}
}
NS_IMETHODIMP
ApplicationAccessible::GetLanguage(nsAString& aLanguage)
{
aLanguage.Truncate();
return NS_OK;
}
NS_IMETHODIMP
HTMLURIRefObject::GetNextURI(nsAString& aURI)
{
NS_ENSURE_TRUE(mNode, NS_ERROR_NOT_INITIALIZED);
nsCOMPtr<dom::Element> element = do_QueryInterface(mNode);
NS_ENSURE_TRUE(element, NS_ERROR_INVALID_ARG);
// Loop over attribute list:
if (!mAttrsInited) {
mAttrsInited = true;
mAttributeCnt = element->GetAttrCount();
NS_ENSURE_TRUE(mAttributeCnt, NS_ERROR_FAILURE);
mCurAttrIndex = 0;
}
while (mCurAttrIndex < mAttributeCnt) {
BorrowedAttrInfo attrInfo = element->GetAttrInfoAt(mCurAttrIndex++);
NS_ENSURE_ARG_POINTER(attrInfo.mName);
// href >> A, AREA, BASE, LINK
if (attrInfo.mName->Equals(nsGkAtoms::href)) {
if (!element->IsAnyOfHTMLElements(nsGkAtoms::a,
nsGkAtoms::area,
nsGkAtoms::base,
nsGkAtoms::link)) {
continue;
}
attrInfo.mValue->ToString(aURI);
// href pointing to a named anchor doesn't count
if (StringBeginsWith(aURI, NS_LITERAL_STRING("#"))) {
aURI.Truncate();
return NS_ERROR_INVALID_ARG;
}
return NS_OK;
}
// src >> FRAME, IFRAME, IMG, INPUT, SCRIPT
else if (attrInfo.mName->Equals(nsGkAtoms::src)) {
if (!element->IsAnyOfHTMLElements(nsGkAtoms::img,
nsGkAtoms::frame,
nsGkAtoms::iframe,
nsGkAtoms::input,
nsGkAtoms::script)) {
continue;
}
attrInfo.mValue->ToString(aURI);
return NS_OK;
}
//<META http-equiv="refresh" content="3,http://www.acme.com/intro.html">
else if (attrInfo.mName->Equals(nsGkAtoms::content)) {
if (!element->IsHTMLElement(nsGkAtoms::meta)) {
continue;
}
// XXXbz And if it is?
}
// longdesc >> FRAME, IFRAME, IMG
else if (attrInfo.mName->Equals(nsGkAtoms::longdesc)) {
if (!element->IsAnyOfHTMLElements(nsGkAtoms::img,
nsGkAtoms::frame,
nsGkAtoms::iframe)) {
continue;
}
// XXXbz And if it is?
}
// usemap >> IMG, INPUT, OBJECT
else if (attrInfo.mName->Equals(nsGkAtoms::usemap)) {
if (!element->IsAnyOfHTMLElements(nsGkAtoms::img,
nsGkAtoms::input,
nsGkAtoms::object)) {
continue;
}
}
// action >> FORM
else if (attrInfo.mName->Equals(nsGkAtoms::action)) {
if (!element->IsHTMLElement(nsGkAtoms::form)) {
continue;
}
// XXXbz And if it is?
}
// background >> BODY
else if (attrInfo.mName->Equals(nsGkAtoms::background)) {
if (!element->IsHTMLElement(nsGkAtoms::body)) {
continue;
}
// XXXbz And if it is?
}
// codebase >> OBJECT
else if (attrInfo.mName->Equals(nsGkAtoms::codebase)) {
if (!element->IsHTMLElement(nsGkAtoms::object)) {
continue;
}
// XXXbz And if it is?
}
// classid >> OBJECT
else if (attrInfo.mName->Equals(nsGkAtoms::classid)) {
if (!element->IsHTMLElement(nsGkAtoms::object)) {
continue;
}
// XXXbz And if it is?
}
// data >> OBJECT
else if (attrInfo.mName->Equals(nsGkAtoms::data)) {
if (!element->IsHTMLElement(nsGkAtoms::object)) {
continue;
}
// XXXbz And if it is?
}
// cite >> BLOCKQUOTE, DEL, INS, Q
else if (attrInfo.mName->Equals(nsGkAtoms::cite)) {
if (!element->IsAnyOfHTMLElements(nsGkAtoms::blockquote,
nsGkAtoms::q,
nsGkAtoms::del,
nsGkAtoms::ins)) {
continue;
}
// XXXbz And if it is?
}
// profile >> HEAD
else if (attrInfo.mName->Equals(nsGkAtoms::profile)) {
if (!element->IsHTMLElement(nsGkAtoms::head)) {
continue;
}
// XXXbz And if it is?
}
}
// Return a code to indicate that there are no more,
// to distinguish that case from real errors.
return NS_ERROR_NOT_AVAILABLE;
}
NS_INTERFACE_MAP_END
// 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);
tmpStr.AppendFloat(val);
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) {
nsCAutoString specUTF8;
mValue.mURI->GetSpec(specUTF8);
tmpStr.AssignLiteral("url(");
nsStyleUtil::AppendEscapedCSSString(NS_ConvertUTF8toUTF16(specUTF8),
tmpStr);
tmpStr.AppendLiteral(")");
} else {
// XXXldb Any better ideas? It's good to have something that
// doesn't parse so that things round-trip "correctly".
tmpStr.Assign(NS_LITERAL_STRING("url(invalid-url:)"));
}
break;
}
case CSS_ATTR :
{
tmpStr.AppendLiteral("attr(");
tmpStr.Append(mValue.mString);
tmpStr.Append(PRUnichar(')'));
break;
}
case CSS_PERCENTAGE :
{
tmpStr.AppendFloat(mValue.mFloat * 100);
tmpStr.Append(PRUnichar('%'));
break;
}
case CSS_NUMBER :
{
tmpStr.AppendFloat(mValue.mFloat);
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");
NS_NAMED_LITERAL_STRING(comma, ", ");
nsCOMPtr<nsIDOMCSSPrimitiveValue> colorCSSValue;
nsAutoString colorValue;
if (mValue.mColor->HasAlpha())
tmpStr.AssignLiteral("rgba(");
else
tmpStr.AssignLiteral("rgb(");
// get the red component
result = mValue.mColor->GetRed(getter_AddRefs(colorCSSValue));
if (NS_FAILED(result))
break;
result = colorCSSValue->GetCssText(colorValue);
if (NS_FAILED(result))
break;
tmpStr.Append(colorValue + comma);
// get the green component
result = mValue.mColor->GetGreen(getter_AddRefs(colorCSSValue));
if (NS_FAILED(result))
break;
result = colorCSSValue->GetCssText(colorValue);
if (NS_FAILED(result))
break;
tmpStr.Append(colorValue + comma);
// get the blue component
result = mValue.mColor->GetBlue(getter_AddRefs(colorCSSValue));
if (NS_FAILED(result))
break;
result = colorCSSValue->GetCssText(colorValue);
if (NS_FAILED(result))
break;
tmpStr.Append(colorValue);
if (mValue.mColor->HasAlpha()) {
// get the alpha component
result = mValue.mColor->GetAlpha(getter_AddRefs(colorCSSValue));
if (NS_FAILED(result))
break;
result = colorCSSValue->GetCssText(colorValue);
if (NS_FAILED(result))
break;
tmpStr.Append(comma + colorValue);
}
tmpStr.Append(NS_LITERAL_STRING(")"));
break;
}
case CSS_S :
{
tmpStr.AppendFloat(mValue.mFloat);
tmpStr.AppendLiteral("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_DEG :
case CSS_RAD :
case CSS_GRAD :
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;
}
NS_IMETHODIMP
nsXFormsChoicesAccessible::GetValue(nsAString& aValue)
{
aValue.Truncate();
return NS_OK;
}
void
HTMLSelectOptGroupAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName)
{
aName.Truncate();
}
nsresult
nsXHTMLContentSerializer::EscapeURI(nsIContent* aContent, const nsAString& aURI, nsAString& aEscapedURI)
{
// URL escape %xx cannot be used in JS.
// No escaping if the scheme is 'javascript'.
if (IsJavaScript(aContent, nsGkAtoms::href, kNameSpaceID_None, aURI)) {
aEscapedURI = aURI;
return NS_OK;
}
// nsITextToSubURI does charset convert plus uri escape
// This is needed to convert to a document charset which is needed to support existing browsers.
// But we eventually want to use UTF-8 instead of a document charset, then the code would be much simpler.
// See HTML 4.01 spec, "Appendix B.2.1 Non-ASCII characters in URI attribute values"
nsCOMPtr<nsITextToSubURI> textToSubURI;
nsAutoString uri(aURI); // in order to use FindCharInSet()
nsresult rv = NS_OK;
if (!mCharset.IsEmpty() && !IsASCII(uri)) {
textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
}
int32_t start = 0;
int32_t end;
nsAutoString part;
nsXPIDLCString escapedURI;
aEscapedURI.Truncate(0);
// Loop and escape parts by avoiding escaping reserved characters
// (and '%', '#', as well as '[' and ']' for IPv6 address literals).
while ((end = uri.FindCharInSet("%#;/?:@&=+$,[]", start)) != -1) {
part = Substring(aURI, start, (end-start));
if (textToSubURI && !IsASCII(part)) {
rv = textToSubURI->ConvertAndEscape(mCharset.get(), part.get(), getter_Copies(escapedURI));
NS_ENSURE_SUCCESS(rv, rv);
} else if (NS_WARN_IF(!NS_Escape(NS_ConvertUTF16toUTF8(part), escapedURI,
url_Path))) {
return NS_ERROR_OUT_OF_MEMORY;
}
AppendASCIItoUTF16(escapedURI, aEscapedURI);
// Append a reserved character without escaping.
part = Substring(aURI, end, 1);
aEscapedURI.Append(part);
start = end + 1;
}
if (start < (int32_t) aURI.Length()) {
// Escape the remaining part.
part = Substring(aURI, start, aURI.Length()-start);
if (textToSubURI) {
rv = textToSubURI->ConvertAndEscape(mCharset.get(), part.get(), getter_Copies(escapedURI));
NS_ENSURE_SUCCESS(rv, rv);
} else if (NS_WARN_IF(!NS_Escape(NS_ConvertUTF16toUTF8(part), escapedURI,
url_Path))) {
return NS_ERROR_OUT_OF_MEMORY;
}
AppendASCIItoUTF16(escapedURI, aEscapedURI);
}
return rv;
}
NS_IMETHODIMP
Navigator::GetVendorSub(nsAString& aVendorSub)
{
aVendorSub.Truncate();
return NS_OK;
}
nsresult
nsFormControlFrame::GetFormProperty(nsIAtom* aName, nsAString& aValue) const
{
aValue.Truncate();
return NS_OK;
}
NS_IMETHODIMP
TabParent::GetTooltipText(nsAString & aTooltipText)
{
aTooltipText.Truncate();
return NS_OK;
}
bool
nsTreeSanitizer::SanitizeStyleSheet(const nsAString& aOriginal,
nsAString& aSanitized,
nsIDocument* aDocument,
nsIURI* aBaseURI)
{
nsresult rv;
aSanitized.Truncate();
// aSanitized will hold the permitted CSS text.
// -moz-binding is blacklisted.
bool didSanitize = false;
// Create a sheet to hold the parsed CSS
nsRefPtr<nsCSSStyleSheet> sheet;
rv = NS_NewCSSStyleSheet(getter_AddRefs(sheet));
NS_ENSURE_SUCCESS(rv, true);
sheet->SetURIs(aDocument->GetDocumentURI(), nsnull, aBaseURI);
sheet->SetPrincipal(aDocument->NodePrincipal());
// Create the CSS parser, and parse the CSS text.
nsCSSParser parser(nsnull, sheet);
rv = parser.ParseSheet(aOriginal, aDocument->GetDocumentURI(), aBaseURI,
aDocument->NodePrincipal(), 0, false);
NS_ENSURE_SUCCESS(rv, true);
// Mark the sheet as complete.
NS_ABORT_IF_FALSE(!sheet->IsModified(),
"should not get marked modified during parsing");
sheet->SetComplete();
// Loop through all the rules found in the CSS text
PRInt32 ruleCount = sheet->StyleRuleCount();
for (PRInt32 i = 0; i < ruleCount; ++i) {
nsRefPtr<mozilla::css::Rule> rule;
rv = sheet->GetStyleRuleAt(i, *getter_AddRefs(rule));
if (NS_FAILED(rv))
continue; NS_ASSERTION(rule, "We should have a rule by now");
switch (rule->GetType()) {
default:
didSanitize = true;
// Ignore these rule types.
break;
case mozilla::css::Rule::NAMESPACE_RULE:
case mozilla::css::Rule::FONT_FACE_RULE: {
// Append @namespace and @font-face rules verbatim.
nsAutoString cssText;
nsCOMPtr<nsIDOMCSSRule> styleRule = do_QueryInterface(rule);
if (styleRule) {
rv = styleRule->GetCssText(cssText);
if (NS_SUCCEEDED(rv)) {
aSanitized.Append(cssText);
}
}
break;
}
case mozilla::css::Rule::STYLE_RULE: {
// For style rules, we will just look for and remove the
// -moz-binding properties.
nsRefPtr<mozilla::css::StyleRule> styleRule = do_QueryObject(rule);
NS_ASSERTION(styleRule, "Must be a style rule");
nsAutoString decl;
bool sanitized = SanitizeStyleRule(styleRule, decl);
didSanitize = sanitized || didSanitize;
if (!sanitized) {
styleRule->GetCssText(decl);
}
aSanitized.Append(decl);
}
}
}
return didSanitize;
}
