mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
e92873c895
This patch ensures that we check ShouldMaintainPreLevel() before attempting to modify or read mPreLevel in order to avoid wasting time to compute mPreLevel for elements without frames needlessly. Computing this value for such elements can incur expensive style calculations.
1017 lines
30 KiB
C++
1017 lines
30 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 sw=2 et 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/. */
|
|
|
|
/*
|
|
* nsIContentSerializer implementation that can be used with an
|
|
* nsIDocumentEncoder to convert an XHTML (not HTML!) DOM to an XHTML
|
|
* string that could be parsed into more or less the original DOM.
|
|
*/
|
|
|
|
#include "nsXHTMLContentSerializer.h"
|
|
|
|
#include "nsIDOMElement.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "nsString.h"
|
|
#include "nsUnicharUtils.h"
|
|
#include "nsXPIDLString.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsIDocumentEncoder.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsIURI.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsEscape.h"
|
|
#include "nsITextToSubURI.h"
|
|
#include "nsCRT.h"
|
|
#include "nsIParserService.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsLWBrkCIID.h"
|
|
#include "nsIScriptElement.h"
|
|
#include "nsAttrName.h"
|
|
#include "nsParserConstants.h"
|
|
#include "nsComputedDOMStyle.h"
|
|
#include "mozilla/dom/Element.h"
|
|
|
|
static const int32_t kLongLineLen = 128;
|
|
|
|
#define kXMLNS "xmlns"
|
|
|
|
nsresult NS_NewXHTMLContentSerializer(nsIContentSerializer** aSerializer)
|
|
{
|
|
nsXHTMLContentSerializer* it = new nsXHTMLContentSerializer();
|
|
if (!it) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
return CallQueryInterface(it, aSerializer);
|
|
}
|
|
|
|
nsXHTMLContentSerializer::nsXHTMLContentSerializer()
|
|
: mIsHTMLSerializer(false)
|
|
{
|
|
}
|
|
|
|
nsXHTMLContentSerializer::~nsXHTMLContentSerializer()
|
|
{
|
|
NS_ASSERTION(mOLStateStack.IsEmpty(), "Expected OL State stack to be empty");
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXHTMLContentSerializer::Init(uint32_t aFlags, uint32_t aWrapColumn,
|
|
const char* aCharSet, bool aIsCopying,
|
|
bool aRewriteEncodingDeclaration)
|
|
{
|
|
// The previous version of the HTML serializer did implicit wrapping
|
|
// when there is no flags, so we keep wrapping in order to keep
|
|
// compatibility with the existing calling code
|
|
// XXXLJ perhaps should we remove this default settings later ?
|
|
if (aFlags & nsIDocumentEncoder::OutputFormatted ) {
|
|
aFlags = aFlags | nsIDocumentEncoder::OutputWrap;
|
|
}
|
|
|
|
nsresult rv;
|
|
rv = nsXMLContentSerializer::Init(aFlags, aWrapColumn, aCharSet, aIsCopying, aRewriteEncodingDeclaration);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mRewriteEncodingDeclaration = aRewriteEncodingDeclaration;
|
|
mIsCopying = aIsCopying;
|
|
mIsFirstChildOfOL = false;
|
|
mInBody = 0;
|
|
mDisableEntityEncoding = 0;
|
|
mBodyOnly = (mFlags & nsIDocumentEncoder::OutputBodyOnly) ? true
|
|
: false;
|
|
|
|
// set up entity converter if we are going to need it
|
|
if (mFlags & nsIDocumentEncoder::OutputEncodeW3CEntities) {
|
|
mEntityConverter = do_CreateInstance(NS_ENTITYCONVERTER_CONTRACTID);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
// See if the string has any lines longer than longLineLen:
|
|
// if so, we presume formatting is wonky (e.g. the node has been edited)
|
|
// and we'd better rewrap the whole text node.
|
|
bool
|
|
nsXHTMLContentSerializer::HasLongLines(const nsString& text, int32_t& aLastNewlineOffset)
|
|
{
|
|
uint32_t start=0;
|
|
uint32_t theLen = text.Length();
|
|
bool rv = false;
|
|
aLastNewlineOffset = kNotFound;
|
|
for (start = 0; start < theLen; ) {
|
|
int32_t eol = text.FindChar('\n', start);
|
|
if (eol < 0) {
|
|
eol = text.Length();
|
|
}
|
|
else {
|
|
aLastNewlineOffset = eol;
|
|
}
|
|
if (int32_t(eol - start) > kLongLineLen)
|
|
rv = true;
|
|
start = eol + 1;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXHTMLContentSerializer::AppendText(nsIContent* aText,
|
|
int32_t aStartOffset,
|
|
int32_t aEndOffset,
|
|
nsAString& aStr)
|
|
{
|
|
NS_ENSURE_ARG(aText);
|
|
|
|
nsAutoString data;
|
|
nsresult rv;
|
|
|
|
rv = AppendTextData(aText, aStartOffset, aEndOffset, data, true);
|
|
if (NS_FAILED(rv))
|
|
return NS_ERROR_FAILURE;
|
|
|
|
if (mDoRaw || PreLevel() > 0) {
|
|
AppendToStringConvertLF(data, aStr);
|
|
}
|
|
else if (mDoFormat) {
|
|
AppendToStringFormatedWrapped(data, aStr);
|
|
}
|
|
else if (mDoWrap) {
|
|
AppendToStringWrapped(data, aStr);
|
|
}
|
|
else {
|
|
int32_t lastNewlineOffset = kNotFound;
|
|
if (HasLongLines(data, lastNewlineOffset)) {
|
|
// We have long lines, rewrap
|
|
mDoWrap = true;
|
|
AppendToStringWrapped(data, aStr);
|
|
mDoWrap = false;
|
|
}
|
|
else {
|
|
AppendToStringConvertLF(data, aStr);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
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 {
|
|
escapedURI.Adopt(nsEscape(NS_ConvertUTF16toUTF8(part).get(), url_Path));
|
|
}
|
|
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 {
|
|
escapedURI.Adopt(nsEscape(NS_ConvertUTF16toUTF8(part).get(), url_Path));
|
|
}
|
|
AppendASCIItoUTF16(escapedURI, aEscapedURI);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
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.
|
|
SerializeLIValueAttribute(aContent, aStr);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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
|
|
SerializeAttr(EmptyString(), xmlnsStr, aTagNamespaceURI, aStr, true);
|
|
} else {
|
|
// Serialize namespace decl
|
|
SerializeAttr(xmlnsStr, aTagPrefix, aTagNamespaceURI, aStr, true);
|
|
}
|
|
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;
|
|
}
|
|
|
|
const nsAttrName* name = aContent->GetAttrNameAt(index);
|
|
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);
|
|
}
|
|
|
|
aContent->GetAttr(namespaceID, attrName, 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 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);
|
|
}
|
|
}
|
|
|
|
// Expand shorthand attribute.
|
|
if (namespaceID == kNameSpaceID_None && IsShorthandAttr(attrName, aTagName) && valueStr.IsEmpty()) {
|
|
valueStr = nameStr;
|
|
}
|
|
}
|
|
else {
|
|
isJS = IsJavaScript(aContent, attrName, namespaceID, valueStr);
|
|
}
|
|
|
|
SerializeAttr(prefixStr, nameStr, valueStr, aStr, !isJS);
|
|
|
|
if (addNSAttr) {
|
|
NS_ASSERTION(!prefixStr.IsEmpty(),
|
|
"Namespaced attributes must have a prefix");
|
|
SerializeAttr(xmlnsStr, prefixStr, uriStr, aStr, true);
|
|
PushNameSpaceDecl(prefixStr, uriStr, aOriginalElement);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
nsXHTMLContentSerializer::AppendEndOfElementStart(nsIContent *aOriginalElement,
|
|
nsIAtom * aName,
|
|
int32_t aNamespaceID,
|
|
nsAString& aStr)
|
|
{
|
|
// this method is not called by nsHTMLContentSerializer
|
|
// so we don't have to check HTML element, just XHTML
|
|
NS_ASSERTION(!mIsHTMLSerializer, "nsHTMLContentSerializer shouldn't call this method !");
|
|
|
|
if (kNameSpaceID_XHTML != aNamespaceID) {
|
|
nsXMLContentSerializer::AppendEndOfElementStart(aOriginalElement, aName,
|
|
aNamespaceID, aStr);
|
|
return;
|
|
}
|
|
|
|
nsIContent* content = aOriginalElement;
|
|
|
|
// for non empty elements, even if they are not a container, we always
|
|
// serialize their content, because the XHTML element could contain non XHTML
|
|
// nodes useful in some context, like in an XSLT stylesheet
|
|
if (HasNoChildren(content)) {
|
|
|
|
nsIParserService* parserService = nsContentUtils::GetParserService();
|
|
|
|
if (parserService) {
|
|
bool isContainer;
|
|
parserService->
|
|
IsContainer(parserService->HTMLCaseSensitiveAtomTagToId(aName),
|
|
isContainer);
|
|
if (!isContainer) {
|
|
// for backward compatibility with HTML 4 user agents
|
|
// only non-container HTML elements can be closed immediatly,
|
|
// and a space is added before />
|
|
AppendToString(NS_LITERAL_STRING(" />"), aStr);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
AppendToString(kGreaterThan, aStr);
|
|
}
|
|
|
|
void
|
|
nsXHTMLContentSerializer::AfterElementStart(nsIContent * aContent,
|
|
nsIContent *aOriginalElement,
|
|
nsAString& aStr)
|
|
{
|
|
nsIAtom *name = aContent->Tag();
|
|
if (aContent->GetNameSpaceID() == kNameSpaceID_XHTML &&
|
|
mRewriteEncodingDeclaration &&
|
|
name == nsGkAtoms::head) {
|
|
|
|
// Check if there already are any content-type meta children.
|
|
// If there are, they will be modified to use the correct charset.
|
|
// If there aren't, we'll insert one here.
|
|
bool hasMeta = false;
|
|
for (nsIContent* child = aContent->GetFirstChild();
|
|
child;
|
|
child = child->GetNextSibling()) {
|
|
if (child->IsHTML(nsGkAtoms::meta) &&
|
|
child->HasAttr(kNameSpaceID_None, nsGkAtoms::content)) {
|
|
nsAutoString header;
|
|
child->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
|
|
|
|
if (header.LowerCaseEqualsLiteral("content-type")) {
|
|
hasMeta = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!hasMeta) {
|
|
AppendNewLineToString(aStr);
|
|
if (mDoFormat) {
|
|
AppendIndentation(aStr);
|
|
}
|
|
AppendToString(NS_LITERAL_STRING("<meta http-equiv=\"content-type\""),
|
|
aStr);
|
|
AppendToString(NS_LITERAL_STRING(" content=\"text/html; charset="), aStr);
|
|
AppendToString(NS_ConvertASCIItoUTF16(mCharset), aStr);
|
|
if (mIsHTMLSerializer)
|
|
AppendToString(NS_LITERAL_STRING("\">"), aStr);
|
|
else
|
|
AppendToString(NS_LITERAL_STRING("\" />"), aStr);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsXHTMLContentSerializer::AfterElementEnd(nsIContent * aContent,
|
|
nsAString& aStr)
|
|
{
|
|
NS_ASSERTION(!mIsHTMLSerializer, "nsHTMLContentSerializer shouldn't call this method !");
|
|
|
|
int32_t namespaceID = aContent->GetNameSpaceID();
|
|
nsIAtom *name = aContent->Tag();
|
|
|
|
// this method is not called by nsHTMLContentSerializer
|
|
// so we don't have to check HTML element, just XHTML
|
|
if (kNameSpaceID_XHTML == namespaceID && name == nsGkAtoms::body) {
|
|
--mInBody;
|
|
}
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsXHTMLContentSerializer::AppendDocumentStart(nsIDocument *aDocument,
|
|
nsAString& aStr)
|
|
{
|
|
if (!mBodyOnly)
|
|
return nsXMLContentSerializer::AppendDocumentStart(aDocument, aStr);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::CheckElementStart(nsIContent * aContent,
|
|
bool & aForceFormat,
|
|
nsAString& aStr)
|
|
{
|
|
// The _moz_dirty attribute is emitted by the editor to
|
|
// indicate that this element should be pretty printed
|
|
// even if we're not in pretty printing mode
|
|
aForceFormat = !(mFlags & nsIDocumentEncoder::OutputIgnoreMozDirty) &&
|
|
aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::mozdirty);
|
|
|
|
nsIAtom *name = aContent->Tag();
|
|
int32_t namespaceID = aContent->GetNameSpaceID();
|
|
|
|
if (namespaceID == kNameSpaceID_XHTML) {
|
|
if (name == nsGkAtoms::br &&
|
|
(mFlags & nsIDocumentEncoder::OutputNoFormattingInPre) &&
|
|
PreLevel() > 0) {
|
|
AppendNewLineToString(aStr);
|
|
return false;
|
|
}
|
|
|
|
if (name == nsGkAtoms::body) {
|
|
++mInBody;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::CheckElementEnd(nsIContent * aContent,
|
|
bool & aForceFormat,
|
|
nsAString& aStr)
|
|
{
|
|
NS_ASSERTION(!mIsHTMLSerializer, "nsHTMLContentSerializer shouldn't call this method !");
|
|
|
|
aForceFormat = !(mFlags & nsIDocumentEncoder::OutputIgnoreMozDirty) &&
|
|
aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::mozdirty);
|
|
|
|
nsIAtom *name = aContent->Tag();
|
|
int32_t namespaceID = aContent->GetNameSpaceID();
|
|
|
|
// this method is not called by nsHTMLContentSerializer
|
|
// so we don't have to check HTML element, just XHTML
|
|
if (namespaceID == kNameSpaceID_XHTML) {
|
|
if (mIsCopying && name == nsGkAtoms::ol) {
|
|
NS_ASSERTION((!mOLStateStack.IsEmpty()), "Cannot have an empty OL Stack");
|
|
/* Though at this point we must always have an state to be deleted as all
|
|
the OL opening tags are supposed to push an olState object to the stack*/
|
|
if (!mOLStateStack.IsEmpty()) {
|
|
mOLStateStack.RemoveElementAt(mOLStateStack.Length() -1);
|
|
}
|
|
}
|
|
|
|
if (HasNoChildren(aContent)) {
|
|
nsIParserService* parserService = nsContentUtils::GetParserService();
|
|
|
|
if (parserService) {
|
|
bool isContainer;
|
|
|
|
parserService->
|
|
IsContainer(parserService->HTMLCaseSensitiveAtomTagToId(name),
|
|
isContainer);
|
|
if (!isContainer) {
|
|
// non-container HTML elements are already closed,
|
|
// see AppendEndOfElementStart
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// for backward compatibility with old HTML user agents,
|
|
// empty elements should have an ending tag, so we mustn't call
|
|
// nsXMLContentSerializer::CheckElementEnd
|
|
return true;
|
|
}
|
|
|
|
bool dummyFormat;
|
|
return nsXMLContentSerializer::CheckElementEnd(aContent, dummyFormat, aStr);
|
|
}
|
|
|
|
void
|
|
nsXHTMLContentSerializer::AppendAndTranslateEntities(const nsAString& aStr,
|
|
nsAString& aOutputStr)
|
|
{
|
|
if (mBodyOnly && !mInBody) {
|
|
return;
|
|
}
|
|
|
|
if (mDisableEntityEncoding) {
|
|
aOutputStr.Append(aStr);
|
|
return;
|
|
}
|
|
|
|
nsXMLContentSerializer::AppendAndTranslateEntities(aStr, aOutputStr);
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::IsShorthandAttr(const nsIAtom* aAttrName,
|
|
const nsIAtom* aElementName)
|
|
{
|
|
// checked
|
|
if ((aAttrName == nsGkAtoms::checked) &&
|
|
(aElementName == nsGkAtoms::input)) {
|
|
return true;
|
|
}
|
|
|
|
// compact
|
|
if ((aAttrName == nsGkAtoms::compact) &&
|
|
(aElementName == nsGkAtoms::dir ||
|
|
aElementName == nsGkAtoms::dl ||
|
|
aElementName == nsGkAtoms::menu ||
|
|
aElementName == nsGkAtoms::ol ||
|
|
aElementName == nsGkAtoms::ul)) {
|
|
return true;
|
|
}
|
|
|
|
// declare
|
|
if ((aAttrName == nsGkAtoms::declare) &&
|
|
(aElementName == nsGkAtoms::object)) {
|
|
return true;
|
|
}
|
|
|
|
// defer
|
|
if ((aAttrName == nsGkAtoms::defer) &&
|
|
(aElementName == nsGkAtoms::script)) {
|
|
return true;
|
|
}
|
|
|
|
// disabled
|
|
if ((aAttrName == nsGkAtoms::disabled) &&
|
|
(aElementName == nsGkAtoms::button ||
|
|
aElementName == nsGkAtoms::input ||
|
|
aElementName == nsGkAtoms::optgroup ||
|
|
aElementName == nsGkAtoms::option ||
|
|
aElementName == nsGkAtoms::select ||
|
|
aElementName == nsGkAtoms::textarea)) {
|
|
return true;
|
|
}
|
|
|
|
// ismap
|
|
if ((aAttrName == nsGkAtoms::ismap) &&
|
|
(aElementName == nsGkAtoms::img ||
|
|
aElementName == nsGkAtoms::input)) {
|
|
return true;
|
|
}
|
|
|
|
// multiple
|
|
if ((aAttrName == nsGkAtoms::multiple) &&
|
|
(aElementName == nsGkAtoms::select)) {
|
|
return true;
|
|
}
|
|
|
|
// noresize
|
|
if ((aAttrName == nsGkAtoms::noresize) &&
|
|
(aElementName == nsGkAtoms::frame)) {
|
|
return true;
|
|
}
|
|
|
|
// noshade
|
|
if ((aAttrName == nsGkAtoms::noshade) &&
|
|
(aElementName == nsGkAtoms::hr)) {
|
|
return true;
|
|
}
|
|
|
|
// nowrap
|
|
if ((aAttrName == nsGkAtoms::nowrap) &&
|
|
(aElementName == nsGkAtoms::td ||
|
|
aElementName == nsGkAtoms::th)) {
|
|
return true;
|
|
}
|
|
|
|
// readonly
|
|
if ((aAttrName == nsGkAtoms::readonly) &&
|
|
(aElementName == nsGkAtoms::input ||
|
|
aElementName == nsGkAtoms::textarea)) {
|
|
return true;
|
|
}
|
|
|
|
// selected
|
|
if ((aAttrName == nsGkAtoms::selected) &&
|
|
(aElementName == nsGkAtoms::option)) {
|
|
return true;
|
|
}
|
|
|
|
// autoplay and controls
|
|
if ((aElementName == nsGkAtoms::video || aElementName == nsGkAtoms::audio) &&
|
|
(aAttrName == nsGkAtoms::autoplay || aAttrName == nsGkAtoms::muted ||
|
|
aAttrName == nsGkAtoms::controls)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::LineBreakBeforeOpen(int32_t aNamespaceID, nsIAtom* aName)
|
|
{
|
|
|
|
if (aNamespaceID != kNameSpaceID_XHTML) {
|
|
return mAddSpace;
|
|
}
|
|
|
|
if (aName == nsGkAtoms::title ||
|
|
aName == nsGkAtoms::meta ||
|
|
aName == nsGkAtoms::link ||
|
|
aName == nsGkAtoms::style ||
|
|
aName == nsGkAtoms::select ||
|
|
aName == nsGkAtoms::option ||
|
|
aName == nsGkAtoms::script ||
|
|
aName == nsGkAtoms::html) {
|
|
return true;
|
|
}
|
|
else {
|
|
nsIParserService* parserService = nsContentUtils::GetParserService();
|
|
|
|
if (parserService) {
|
|
bool res;
|
|
parserService->
|
|
IsBlock(parserService->HTMLCaseSensitiveAtomTagToId(aName), res);
|
|
return res;
|
|
}
|
|
}
|
|
|
|
return mAddSpace;
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::LineBreakAfterOpen(int32_t aNamespaceID, nsIAtom* aName)
|
|
{
|
|
|
|
if (aNamespaceID != kNameSpaceID_XHTML) {
|
|
return false;
|
|
}
|
|
|
|
if ((aName == nsGkAtoms::html) ||
|
|
(aName == nsGkAtoms::head) ||
|
|
(aName == nsGkAtoms::body) ||
|
|
(aName == nsGkAtoms::ul) ||
|
|
(aName == nsGkAtoms::ol) ||
|
|
(aName == nsGkAtoms::dl) ||
|
|
(aName == nsGkAtoms::table) ||
|
|
(aName == nsGkAtoms::tbody) ||
|
|
(aName == nsGkAtoms::tr) ||
|
|
(aName == nsGkAtoms::br) ||
|
|
(aName == nsGkAtoms::meta) ||
|
|
(aName == nsGkAtoms::link) ||
|
|
(aName == nsGkAtoms::script) ||
|
|
(aName == nsGkAtoms::select) ||
|
|
(aName == nsGkAtoms::map) ||
|
|
(aName == nsGkAtoms::area) ||
|
|
(aName == nsGkAtoms::style)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::LineBreakBeforeClose(int32_t aNamespaceID, nsIAtom* aName)
|
|
{
|
|
|
|
if (aNamespaceID != kNameSpaceID_XHTML) {
|
|
return false;
|
|
}
|
|
|
|
if ((aName == nsGkAtoms::html) ||
|
|
(aName == nsGkAtoms::head) ||
|
|
(aName == nsGkAtoms::body) ||
|
|
(aName == nsGkAtoms::ul) ||
|
|
(aName == nsGkAtoms::ol) ||
|
|
(aName == nsGkAtoms::dl) ||
|
|
(aName == nsGkAtoms::select) ||
|
|
(aName == nsGkAtoms::table) ||
|
|
(aName == nsGkAtoms::tbody)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::LineBreakAfterClose(int32_t aNamespaceID, nsIAtom* aName)
|
|
{
|
|
|
|
if (aNamespaceID != kNameSpaceID_XHTML) {
|
|
return false;
|
|
}
|
|
|
|
if ((aName == nsGkAtoms::html) ||
|
|
(aName == nsGkAtoms::head) ||
|
|
(aName == nsGkAtoms::body) ||
|
|
(aName == nsGkAtoms::tr) ||
|
|
(aName == nsGkAtoms::th) ||
|
|
(aName == nsGkAtoms::td) ||
|
|
(aName == nsGkAtoms::pre) ||
|
|
(aName == nsGkAtoms::title) ||
|
|
(aName == nsGkAtoms::li) ||
|
|
(aName == nsGkAtoms::dt) ||
|
|
(aName == nsGkAtoms::dd) ||
|
|
(aName == nsGkAtoms::blockquote) ||
|
|
(aName == nsGkAtoms::select) ||
|
|
(aName == nsGkAtoms::option) ||
|
|
(aName == nsGkAtoms::p) ||
|
|
(aName == nsGkAtoms::map) ||
|
|
(aName == nsGkAtoms::div)) {
|
|
return true;
|
|
}
|
|
else {
|
|
nsIParserService* parserService = nsContentUtils::GetParserService();
|
|
|
|
if (parserService) {
|
|
bool res;
|
|
parserService->
|
|
IsBlock(parserService->HTMLCaseSensitiveAtomTagToId(aName), res);
|
|
return res;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void
|
|
nsXHTMLContentSerializer::MaybeEnterInPreContent(nsIContent* aNode)
|
|
{
|
|
if (!ShouldMaintainPreLevel() ||
|
|
aNode->GetNameSpaceID() != kNameSpaceID_XHTML) {
|
|
return;
|
|
}
|
|
|
|
nsIAtom *name = aNode->Tag();
|
|
|
|
if (IsElementPreformatted(aNode) ||
|
|
name == nsGkAtoms::script ||
|
|
name == nsGkAtoms::style ||
|
|
name == nsGkAtoms::noscript ||
|
|
name == nsGkAtoms::noframes
|
|
) {
|
|
PreLevel()++;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsXHTMLContentSerializer::MaybeLeaveFromPreContent(nsIContent* aNode)
|
|
{
|
|
if (!ShouldMaintainPreLevel() ||
|
|
aNode->GetNameSpaceID() != kNameSpaceID_XHTML) {
|
|
return;
|
|
}
|
|
|
|
nsIAtom *name = aNode->Tag();
|
|
if (IsElementPreformatted(aNode) ||
|
|
name == nsGkAtoms::script ||
|
|
name == nsGkAtoms::style ||
|
|
name == nsGkAtoms::noscript ||
|
|
name == nsGkAtoms::noframes
|
|
) {
|
|
--PreLevel();
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::IsElementPreformatted(nsIContent* aNode)
|
|
{
|
|
MOZ_ASSERT(ShouldMaintainPreLevel(), "We should not be calling this needlessly");
|
|
|
|
if (!aNode->IsElement()) {
|
|
return false;
|
|
}
|
|
nsRefPtr<nsStyleContext> styleContext =
|
|
nsComputedDOMStyle::GetStyleContextForElementNoFlush(aNode->AsElement(),
|
|
nullptr, nullptr);
|
|
if (styleContext) {
|
|
const nsStyleText* textStyle = styleContext->StyleText();
|
|
return textStyle->WhiteSpaceOrNewlineIsSignificant();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
nsXHTMLContentSerializer::SerializeLIValueAttribute(nsIContent* aElement,
|
|
nsAString& aStr)
|
|
{
|
|
// We are copying and we are at the "first" LI node of OL in selected range.
|
|
// It may not be the first LI child of OL but it's first in the selected range.
|
|
// Note that we get into this condition only once per a OL.
|
|
bool found = false;
|
|
nsCOMPtr<nsIDOMNode> currNode = do_QueryInterface(aElement);
|
|
nsAutoString valueStr;
|
|
|
|
olState state (0, false);
|
|
|
|
if (!mOLStateStack.IsEmpty()) {
|
|
state = mOLStateStack[mOLStateStack.Length()-1];
|
|
// isFirstListItem should be true only before the serialization of the
|
|
// first item in the list.
|
|
state.isFirstListItem = false;
|
|
mOLStateStack[mOLStateStack.Length()-1] = state;
|
|
}
|
|
|
|
int32_t startVal = state.startVal;
|
|
int32_t offset = 0;
|
|
|
|
// Traverse previous siblings until we find one with "value" attribute.
|
|
// offset keeps track of how many previous siblings we had tocurrNode traverse.
|
|
while (currNode && !found) {
|
|
nsCOMPtr<nsIDOMElement> currElement = do_QueryInterface(currNode);
|
|
// currElement may be null if it were a text node.
|
|
if (currElement) {
|
|
nsAutoString tagName;
|
|
currElement->GetTagName(tagName);
|
|
if (tagName.LowerCaseEqualsLiteral("li")) {
|
|
currElement->GetAttribute(NS_LITERAL_STRING("value"), valueStr);
|
|
if (valueStr.IsEmpty())
|
|
offset++;
|
|
else {
|
|
found = true;
|
|
nsresult rv = NS_OK;
|
|
startVal = valueStr.ToInteger(&rv);
|
|
}
|
|
}
|
|
}
|
|
nsCOMPtr<nsIDOMNode> tmp;
|
|
currNode->GetPreviousSibling(getter_AddRefs(tmp));
|
|
currNode.swap(tmp);
|
|
}
|
|
// If LI was not having "value", Set the "value" attribute for it.
|
|
// Note that We are at the first LI in the selected range of OL.
|
|
if (offset == 0 && found) {
|
|
// offset = 0 => LI itself has the value attribute and we did not need to traverse back.
|
|
// Just serialize value attribute like other tags.
|
|
SerializeAttr(EmptyString(), NS_LITERAL_STRING("value"), valueStr, aStr, false);
|
|
}
|
|
else if (offset == 1 && !found) {
|
|
/*(offset = 1 && !found) means either LI is the first child node of OL
|
|
and LI is not having "value" attribute.
|
|
In that case we would not like to set "value" attribute to reduce the changes.
|
|
*/
|
|
//do nothing...
|
|
}
|
|
else if (offset > 0) {
|
|
// Set value attribute.
|
|
nsAutoString valueStr;
|
|
|
|
//As serializer needs to use this valueAttr we are creating here,
|
|
valueStr.AppendInt(startVal + offset);
|
|
SerializeAttr(EmptyString(), NS_LITERAL_STRING("value"), valueStr, aStr, false);
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::IsFirstChildOfOL(nsIContent* aElement)
|
|
{
|
|
nsCOMPtr<nsIDOMNode> node = do_QueryInterface(aElement);
|
|
nsAutoString parentName;
|
|
|
|
nsCOMPtr<nsIDOMNode> parentNode;
|
|
node->GetParentNode(getter_AddRefs(parentNode));
|
|
if (parentNode)
|
|
parentNode->GetNodeName(parentName);
|
|
else
|
|
return false;
|
|
|
|
if (parentName.LowerCaseEqualsLiteral("ol")) {
|
|
|
|
if (!mOLStateStack.IsEmpty()) {
|
|
olState state = mOLStateStack[mOLStateStack.Length()-1];
|
|
if (state.isFirstListItem)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
nsXHTMLContentSerializer::HasNoChildren(nsIContent * aContent) {
|
|
|
|
for (nsIContent* child = aContent->GetFirstChild();
|
|
child;
|
|
child = child->GetNextSibling()) {
|
|
|
|
if (!child->IsNodeOfType(nsINode::eTEXT))
|
|
return false;
|
|
|
|
if (child->TextLength())
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|