nsresult
rdf_MakeAbsoluteURI(const nsString& aBaseURI, nsString& aURI)
{
nsresult rv;
nsAutoString result;
if (!rdf_RequiresAbsoluteURI(aURI))
return NS_OK;
nsCOMPtr<nsIURI> base;
rv = NS_NewURI(getter_AddRefs(base), aBaseURI);
if (NS_FAILED(rv)) return rv;
rv = NS_MakeAbsoluteURI(result, aURI, base);
if (NS_SUCCEEDED(rv)) {
aURI = result;
}
else {
// There are some ugly URIs (e.g., "NC:Foo") that netlib can't
// parse. If NS_MakeAbsoluteURL fails, then just punt and
// assume that aURI was already absolute.
}
return NS_OK;
}
/**
* Resolves the given href argument, using the given documentBase
* if necessary.
* The new resolved href will be appended to the given dest String
**/
void URIUtils::resolveHref(const nsAString& href, const nsAString& base,
nsAString& dest) {
if (base.IsEmpty()) {
dest.Append(href);
return;
}
if (href.IsEmpty()) {
dest.Append(base);
return;
}
#ifndef TX_EXE
nsCOMPtr<nsIURI> pURL;
nsAutoString resultHref;
nsresult result = NS_NewURI(getter_AddRefs(pURL), base);
if (NS_SUCCEEDED(result)) {
NS_MakeAbsoluteURI(resultHref, href, pURL);
dest.Append(resultHref);
}
#else
nsAutoString documentBase;
getDocumentBase(PromiseFlatString(base), documentBase);
//-- join document base + href
if (!documentBase.IsEmpty()) {
dest.Append(documentBase);
if (documentBase.CharAt(documentBase.Length()-1) != HREF_PATH_SEP)
dest.Append(PRUnichar(HREF_PATH_SEP));
}
dest.Append(href);
#endif
} //-- resolveHref
nsresult
nsSVGImageElement::LoadSVGImage(PRBool aForce, PRBool aNotify)
{
// resolve href attribute
nsCOMPtr<nsIURI> baseURI = GetBaseURI();
nsAutoString href;
mStringAttributes[HREF].GetAnimValue(href, this);
href.Trim(" \t\n\r");
if (baseURI && !href.IsEmpty())
NS_MakeAbsoluteURI(href, href, baseURI);
return LoadImage(href, aForce, aNotify);
}
nsresult
rdf_MakeAbsoluteURI(nsIURI* aBase, nsCString& aURI)
{
nsresult rv;
nsXPIDLCString result;
rv = NS_MakeAbsoluteURI(getter_Copies(result), aURI.get(), aBase);
if (NS_SUCCEEDED(rv)) {
aURI.Assign(result);
}
else {
// There are some ugly URIs (e.g., "NC:Foo") that netlib can't
// parse. If NS_MakeAbsoluteURL fails, then just punt and
// assume that aURI was already absolute.
}
return NS_OK;
}
nsresult
rdf_MakeAbsoluteURI(nsIURI* aBase, nsString& aURI)
{
nsresult rv;
if (!rdf_RequiresAbsoluteURI(aURI))
return NS_OK;
nsAutoString result;
rv = NS_MakeAbsoluteURI(result, aURI, aBase);
if (NS_SUCCEEDED(rv)) {
aURI = result;
}
else {
// There are some ugly URIs (e.g., "NC:Foo") that netlib can't
// parse. If NS_MakeAbsoluteURL fails, then just punt and
// assume that aURI was already absolute.
}
return NS_OK;
}
void
nsHTMLContentSerializer::SerializeAttributes(nsIContent* aContent,
nsIDOMElement *aOriginalElement,
nsAString& aTagPrefix,
const nsAString& aTagNamespaceURI,
nsIAtom* aTagName,
nsAString& aStr)
{
PRInt32 count = aContent->GetAttrCount();
if (!count)
return;
nsresult rv;
nsAutoString nameStr, valueStr;
NS_NAMED_LITERAL_STRING(_mozStr, "_moz");
// HTML5 parser stored them in the order they were parsed so we want to
// loop forward in that case.
nsIDocument* doc = aContent->GetOwnerDocument();
PRBool caseSensitive = doc && doc->IsCaseSensitive();
PRBool loopForward = PR_FALSE;
if (!caseSensitive) {
nsCOMPtr<nsIHTMLDocument> htmlDoc(do_QueryInterface(doc));
if (htmlDoc) {
loopForward = nsHtml5Module::sEnabled;
}
}
PRInt32 index, limit, step;
if (loopForward) {
index = 0;
limit = count;
step = 1;
}
else {
// Loop backward over the attributes, since the order they are stored in is
// the opposite of the order they were parsed in (see bug 213347 for reason).
index = count - 1;
limit = -1;
step = -1;
}
for (; index != limit; index += step) {
const nsAttrName* name = aContent->GetAttrNameAt(index);
PRInt32 namespaceID = name->NamespaceID();
nsIAtom* attrName = name->LocalName();
// Filter out any attribute starting with [-|_]moz
const char* sharedName;
attrName->GetUTF8String(&sharedName);
if ((('_' == *sharedName) || ('-' == *sharedName)) &&
!nsCRT::strncmp(sharedName+1, kMozStr, PRUint32(sizeof(kMozStr)-1))) {
continue;
}
aContent->GetAttr(namespaceID, attrName, valueStr);
//
// Filter out special case of <br type="_moz"> or <br _moz*>,
// used by the editor. Bug 16988. Yuck.
//
if (aTagName == nsGkAtoms::br && attrName == nsGkAtoms::type &&
StringBeginsWith(valueStr, _mozStr)) {
continue;
}
if (mIsCopying && mIsFirstChildOfOL && (aTagName == nsGkAtoms::li) &&
(attrName == nsGkAtoms::value)){
// This is handled separately in SerializeLIValueAttribute()
continue;
}
PRBool isJS = IsJavaScript(aContent, attrName, namespaceID, valueStr);
if (((attrName == nsGkAtoms::href) ||
(attrName == nsGkAtoms::src))) {
// Make all links absolute when converting only the selection:
if (mFlags & nsIDocumentEncoder::OutputAbsoluteLinks) {
// Would be nice to handle OBJECT and APPLET tags,
// but that gets more complicated since we have to
// search the tag list for CODEBASE as well.
// For now, just leave them relative.
nsCOMPtr<nsIURI> uri = aContent->GetBaseURI();
if (uri) {
nsAutoString absURI;
rv = NS_MakeAbsoluteURI(absURI, valueStr, uri);
if (NS_SUCCEEDED(rv)) {
valueStr = absURI;
}
}
}
// Need to escape URI.
nsAutoString tempURI(valueStr);
if (!isJS && NS_FAILED(EscapeURI(aContent, tempURI, valueStr)))
valueStr = tempURI;
}
if (mRewriteEncodingDeclaration && aTagName == nsGkAtoms::meta &&
attrName == nsGkAtoms::content) {
// If we're serializing a <meta http-equiv="content-type">,
// use the proper value, rather than what's in the document.
nsAutoString header;
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
if (header.LowerCaseEqualsLiteral("content-type")) {
valueStr = NS_LITERAL_STRING("text/html; charset=") +
NS_ConvertASCIItoUTF16(mCharset);
}
}
attrName->ToString(nameStr);
// Expand shorthand attribute.
if (IsShorthandAttr(attrName, aTagName) && valueStr.IsEmpty()) {
valueStr = nameStr;
}
SerializeAttr(EmptyString(), nameStr, valueStr, aStr, !isJS);
}
}
bool
nsXHTMLContentSerializer::SerializeAttributes(nsIContent* aContent,
nsIContent *aOriginalElement,
nsAString& aTagPrefix,
const nsAString& aTagNamespaceURI,
nsIAtom* aTagName,
nsAString& aStr,
uint32_t aSkipAttr,
bool aAddNSAttr)
{
nsresult rv;
uint32_t index, count;
nsAutoString prefixStr, uriStr, valueStr;
nsAutoString xmlnsStr;
xmlnsStr.AssignLiteral(kXMLNS);
int32_t contentNamespaceID = aContent->GetNameSpaceID();
// this method is not called by nsHTMLContentSerializer
// so we don't have to check HTML element, just XHTML
if (mIsCopying && kNameSpaceID_XHTML == contentNamespaceID) {
// Need to keep track of OL and LI elements in order to get ordinal number
// for the LI.
if (aTagName == nsGkAtoms::ol) {
// We are copying and current node is an OL;
// Store its start attribute value in olState->startVal.
nsAutoString start;
int32_t startAttrVal = 0;
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::start, start);
if (!start.IsEmpty()) {
nsresult rv = NS_OK;
startAttrVal = start.ToInteger(&rv);
//If OL has "start" attribute, first LI element has to start with that value
//Therefore subtracting 1 as all the LI elements are incrementing it before using it;
//In failure of ToInteger(), default StartAttrValue to 0.
if (NS_SUCCEEDED(rv))
--startAttrVal;
else
startAttrVal = 0;
}
olState state (startAttrVal, true);
mOLStateStack.AppendElement(state);
}
else if (aTagName == nsGkAtoms::li) {
mIsFirstChildOfOL = IsFirstChildOfOL(aOriginalElement);
if (mIsFirstChildOfOL) {
// If OL is parent of this LI, serialize attributes in different manner.
NS_ENSURE_TRUE(SerializeLIValueAttribute(aContent, aStr), false);
}
}
}
// If we had to add a new namespace declaration, serialize
// and push it on the namespace stack
if (aAddNSAttr) {
if (aTagPrefix.IsEmpty()) {
// Serialize default namespace decl
NS_ENSURE_TRUE(SerializeAttr(EmptyString(), xmlnsStr,
aTagNamespaceURI,
aStr, true), false);
} else {
// Serialize namespace decl
NS_ENSURE_TRUE(SerializeAttr(xmlnsStr, aTagPrefix,
aTagNamespaceURI,
aStr, true), false);
}
PushNameSpaceDecl(aTagPrefix, aTagNamespaceURI, aOriginalElement);
}
NS_NAMED_LITERAL_STRING(_mozStr, "_moz");
count = aContent->GetAttrCount();
// Now serialize each of the attributes
// XXX Unfortunately we need a namespace manager to get
// attribute URIs.
for (index = 0; index < count; index++) {
if (aSkipAttr == index) {
continue;
}
mozilla::dom::BorrowedAttrInfo info = aContent->GetAttrInfoAt(index);
const nsAttrName* name = info.mName;
int32_t namespaceID = name->NamespaceID();
nsIAtom* attrName = name->LocalName();
nsIAtom* attrPrefix = name->GetPrefix();
// Filter out any attribute starting with [-|_]moz
nsDependentAtomString attrNameStr(attrName);
if (StringBeginsWith(attrNameStr, NS_LITERAL_STRING("_moz")) ||
StringBeginsWith(attrNameStr, NS_LITERAL_STRING("-moz"))) {
continue;
}
if (attrPrefix) {
attrPrefix->ToString(prefixStr);
}
else {
prefixStr.Truncate();
}
bool addNSAttr = false;
if (kNameSpaceID_XMLNS != namespaceID) {
nsContentUtils::NameSpaceManager()->GetNameSpaceURI(namespaceID, uriStr);
addNSAttr = ConfirmPrefix(prefixStr, uriStr, aOriginalElement, true);
}
info.mValue->ToString(valueStr);
nsDependentAtomString nameStr(attrName);
bool isJS = false;
if (kNameSpaceID_XHTML == contentNamespaceID) {
//
// Filter out special case of <br type="_moz"> or <br _moz*>,
// used by the editor. Bug 16988. Yuck.
//
if (namespaceID == kNameSpaceID_None && aTagName == nsGkAtoms::br && attrName == nsGkAtoms::type
&& StringBeginsWith(valueStr, _mozStr)) {
continue;
}
if (mIsCopying && mIsFirstChildOfOL && (aTagName == nsGkAtoms::li)
&& (attrName == nsGkAtoms::value)) {
// This is handled separately in SerializeLIValueAttribute()
continue;
}
isJS = IsJavaScript(aContent, attrName, namespaceID, valueStr);
if (namespaceID == kNameSpaceID_None &&
((attrName == nsGkAtoms::href) ||
(attrName == nsGkAtoms::src))) {
// Make all links absolute when converting only the selection:
if (mFlags & nsIDocumentEncoder::OutputAbsoluteLinks) {
// Would be nice to handle OBJECT tags,
// but that gets more complicated since we have to
// search the tag list for CODEBASE as well.
// For now, just leave them relative.
nsCOMPtr<nsIURI> uri = aContent->GetBaseURI();
if (uri) {
nsAutoString absURI;
rv = NS_MakeAbsoluteURI(absURI, valueStr, uri);
if (NS_SUCCEEDED(rv)) {
valueStr = absURI;
}
}
}
}
if (mRewriteEncodingDeclaration && aTagName == nsGkAtoms::meta &&
attrName == nsGkAtoms::content) {
// If we're serializing a <meta http-equiv="content-type">,
// use the proper value, rather than what's in the document.
nsAutoString header;
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
if (header.LowerCaseEqualsLiteral("content-type")) {
valueStr = NS_LITERAL_STRING("text/html; charset=") +
NS_ConvertASCIItoUTF16(mCharset);
}
}
// Expand shorthand attribute.
if (namespaceID == kNameSpaceID_None && IsShorthandAttr(attrName, aTagName) && valueStr.IsEmpty()) {
valueStr = nameStr;
}
}
else {
isJS = IsJavaScript(aContent, attrName, namespaceID, valueStr);
}
NS_ENSURE_TRUE(SerializeAttr(prefixStr, nameStr, valueStr, aStr, !isJS), false);
if (addNSAttr) {
NS_ASSERTION(!prefixStr.IsEmpty(),
"Namespaced attributes must have a prefix");
NS_ENSURE_TRUE(SerializeAttr(xmlnsStr, prefixStr, uriStr, aStr, true), false);
PushNameSpaceDecl(prefixStr, uriStr, aOriginalElement);
}
}
return true;
}
void
nsHTMLContentSerializer::SerializeAttributes(nsIContent* aContent,
nsIAtom* aTagName,
nsAString& aStr)
{
nsresult rv;
PRUint32 index, count;
nsAutoString nameStr, valueStr;
count = aContent->GetAttrCount();
NS_NAMED_LITERAL_STRING(_mozStr, "_moz");
// Loop backward over the attributes, since the order they are stored in is
// the opposite of the order they were parsed in (see bug 213347 for reason).
// index is unsigned, hence index >= 0 is always true.
for (index = count; index > 0; ) {
--index;
const nsAttrName* name = aContent->GetAttrNameAt(index);
PRInt32 namespaceID = name->NamespaceID();
nsIAtom* attrName = name->LocalName();
// Filter out any attribute starting with [-|_]moz
const char* sharedName;
attrName->GetUTF8String(&sharedName);
if ((('_' == *sharedName) || ('-' == *sharedName)) &&
!nsCRT::strncmp(sharedName+1, kMozStr, PRUint32(sizeof(kMozStr)-1))) {
continue;
}
aContent->GetAttr(namespaceID, attrName, valueStr);
//
// Filter out special case of <br type="_moz"> or <br _moz*>,
// used by the editor. Bug 16988. Yuck.
//
if (aTagName == nsGkAtoms::br && attrName == nsGkAtoms::type &&
StringBeginsWith(valueStr, _mozStr)) {
continue;
}
if (mIsCopying && mIsFirstChildOfOL && (aTagName == nsGkAtoms::li) &&
(attrName == nsGkAtoms::value)) {
// This is handled separately in SerializeLIValueAttribute()
continue;
}
PRBool isJS = IsJavaScript(attrName, valueStr);
if (((attrName == nsGkAtoms::href) ||
(attrName == nsGkAtoms::src))) {
// Make all links absolute when converting only the selection:
if (mFlags & nsIDocumentEncoder::OutputAbsoluteLinks) {
// Would be nice to handle OBJECT and APPLET tags,
// but that gets more complicated since we have to
// search the tag list for CODEBASE as well.
// For now, just leave them relative.
nsCOMPtr<nsIURI> uri = aContent->GetBaseURI();
if (uri) {
nsAutoString absURI;
rv = NS_MakeAbsoluteURI(absURI, valueStr, uri);
if (NS_SUCCEEDED(rv)) {
valueStr = absURI;
}
}
}
// Need to escape URI.
nsAutoString tempURI(valueStr);
if (!isJS && NS_FAILED(EscapeURI(tempURI, valueStr)))
valueStr = tempURI;
}
if (mIsWholeDocument && aTagName == nsGkAtoms::meta &&
attrName == nsGkAtoms::content) {
// If we're serializing a <meta http-equiv="content-type">,
// use the proper value, rather than what's in the document.
nsAutoString header;
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
if (header.LowerCaseEqualsLiteral("content-type")) {
valueStr = NS_LITERAL_STRING("text/html; charset=") +
NS_ConvertASCIItoUTF16(mCharset);
}
}
attrName->ToString(nameStr);
/*If we already crossed the MaxColumn limit or
* if this attr name-value pair(including a space,=,opening and closing quotes) is greater than MaxColumn limit
* then start the attribute from a new line.
*/
if (mDoFormat
&& (mColPos >= mMaxColumn
|| ((PRInt32)(mColPos + nameStr.Length() +
valueStr.Length() + 4) > mMaxColumn))) {
aStr.Append(mLineBreak);
mColPos = 0;
}
// Expand shorthand attribute.
if (IsShorthandAttr(attrName, aTagName) && valueStr.IsEmpty()) {
valueStr = nameStr;
}
SerializeAttr(EmptyString(), nameStr, valueStr, aStr, !isJS);
}
}
nsresult
nsPolicyReference::ProcessPolicyReferenceFile(nsIDOMDocument* aDocument,
char** aPolicyLocation)
{
NS_ENSURE_ARG_POINTER(aDocument);
NS_ENSURE_ARG_POINTER(aPolicyLocation);
nsCOMPtr<nsIDOMElement> domElement;
aDocument->GetDocumentElement(getter_AddRefs(domElement));
nsCOMPtr<nsIDOMNode> root(do_QueryInterface(domElement));
NS_ENSURE_TRUE(root, NS_ERROR_UNEXPECTED);
nsAutoString name;
root->GetNodeName(name);
nsresult result = NS_OK;
// The root element MUST be META
mError = name.EqualsLiteral("META")
? POLICY_LOAD_SUCCESS : POLICY_SYNTAX_ERROR;
if (mError != POLICY_LOAD_SUCCESS)
return result;
nsCOMPtr<nsIDOMNodeList> policyReferencesElement;
aDocument->GetElementsByTagName(NS_LITERAL_STRING("POLICY-REFERENCES"),
getter_AddRefs(policyReferencesElement));
NS_ENSURE_TRUE(policyReferencesElement, NS_ERROR_UNEXPECTED);
PRUint32 count;
policyReferencesElement->GetLength(&count);
// There MUST be exactly |one| POLICY-REFERENCES element
mError = (count == 1) ? POLICY_LOAD_SUCCESS : POLICY_SYNTAX_ERROR;
if (mError != POLICY_LOAD_SUCCESS)
return result;
nsCOMPtr<nsIDOMNodeList> expiryElement;
aDocument->GetElementsByTagName(NS_LITERAL_STRING("EXPIRY"),
getter_AddRefs(expiryElement));
result = ProcessExpiryElement(expiryElement);
NS_ENSURE_SUCCESS(result, result);
if (mError != POLICY_LOAD_SUCCESS)
return result;
nsCOMPtr<nsIDOMNodeList> policyRefElement;
aDocument->GetElementsByTagName(NS_LITERAL_STRING("POLICY-REF"),
getter_AddRefs(policyRefElement));
nsAutoString policyLocation;
result = ProcessPolicyRefElement(aDocument, policyRefElement, policyLocation);
NS_ENSURE_SUCCESS(result, result);
if (mError != POLICY_LOAD_SUCCESS || policyLocation.IsEmpty())
return result;
nsAutoString absURI;
if (mFlags & IS_LINKED_URI) {
result = NS_MakeAbsoluteURI(absURI, policyLocation, mLinkedURI);
NS_ENSURE_SUCCESS(result, result);
}
else {
// Make sure that the fragment identifier belongs to the current host.
if (policyLocation.First() == '#') {
policyLocation = PromiseFlatString(NS_LITERAL_STRING("p3p.xml") + policyLocation);
}
if (mFlags & IS_MAIN_URI) {
nsCOMPtr<nsIURI> tmpURI= mMainURI;
tmpURI->SetPath(NS_LITERAL_CSTRING(kW3C));
result = NS_MakeAbsoluteURI(absURI, policyLocation, tmpURI);
NS_ENSURE_SUCCESS(result, result);
}
else {
// it is ok to do this because we won't be needing current uri beyond this.
mCurrentURI->SetPath(NS_LITERAL_CSTRING(kW3C));
result = NS_MakeAbsoluteURI(absURI, policyLocation, mCurrentURI);
NS_ENSURE_SUCCESS(result, result);
}
}
*aPolicyLocation = ToNewCString(absURI);
NS_ENSURE_TRUE(*aPolicyLocation, NS_ERROR_OUT_OF_MEMORY);
return result;
}