tor-browser

nsXMLContentSerializer.cpp (62953B)

---

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
* nsIContentSerializer implementation that can be used with an
* nsIDocumentEncoder to convert an XML DOM to an XML string that
* could be parsed into more or less the original DOM.
*/

#include "nsXMLContentSerializer.h"

#include "mozilla/Encoding.h"
#include "mozilla/Sprintf.h"
#include "mozilla/dom/CharacterDataBuffer.h"
#include "mozilla/dom/Comment.h"
#include "mozilla/dom/CustomElementRegistry.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/DocumentType.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/ProcessingInstruction.h"
#include "mozilla/dom/Text.h"
#include "mozilla/intl/Segmenter.h"
#include "nsAttrName.h"
#include "nsCRT.h"
#include "nsContentUtils.h"
#include "nsElementTable.h"
#include "nsGkAtoms.h"
#include "nsIContent.h"
#include "nsIContentInlines.h"
#include "nsIDocumentEncoder.h"
#include "nsNameSpaceManager.h"
#include "nsParserConstants.h"
#include "nsString.h"
#include "nsUnicharUtils.h"

using namespace mozilla;
using namespace mozilla::dom;

#define kXMLNS "xmlns"

// to be readable, we assume that an indented line contains
// at least this number of characters (arbitrary value here).
// This is a limit for the indentation.
#define MIN_INDENTED_LINE_LENGTH 15

// the string used to indent.
#define INDENT_STRING "  "
#define INDENT_STRING_LENGTH 2

nsresult NS_NewXMLContentSerializer(nsIContentSerializer** aSerializer) {
 RefPtr<nsXMLContentSerializer> it = new nsXMLContentSerializer();
 it.forget(aSerializer);
 return NS_OK;
}

nsXMLContentSerializer::nsXMLContentSerializer()
   : mPrefixIndex(0),
     mColPos(0),
     mIndentOverflow(0),
     mIsIndentationAddedOnCurrentLine(false),
     mInAttribute(false),
     mAddNewlineForRootNode(false),
     mAddSpace(false),
     mMayIgnoreLineBreakSequence(false),
     mBodyOnly(false),
     mInBody(0) {}

nsXMLContentSerializer::~nsXMLContentSerializer() = default;

NS_IMPL_ISUPPORTS(nsXMLContentSerializer, nsIContentSerializer)

NS_IMETHODIMP
nsXMLContentSerializer::Init(uint32_t aFlags, uint32_t aWrapColumn,
                            const Encoding* aEncoding, bool aIsCopying,
                            bool aRewriteEncodingDeclaration,
                            bool* aNeedsPreformatScanning,
                            nsAString& aOutput) {
 *aNeedsPreformatScanning = false;
 mPrefixIndex = 0;
 mColPos = 0;
 mIndentOverflow = 0;
 mIsIndentationAddedOnCurrentLine = false;
 mInAttribute = false;
 mAddNewlineForRootNode = false;
 mAddSpace = false;
 mMayIgnoreLineBreakSequence = false;
 mBodyOnly = false;
 mInBody = 0;

 if (aEncoding) {
   aEncoding->Name(mCharset);
 }
 mFlags = aFlags;

 // Set the line break character:
 if ((mFlags & nsIDocumentEncoder::OutputCRLineBreak) &&
     (mFlags & nsIDocumentEncoder::OutputLFLineBreak)) {  // Windows
   mLineBreak.AssignLiteral("\r\n");
 } else if (mFlags & nsIDocumentEncoder::OutputCRLineBreak) {  // Mac
   mLineBreak.Assign('\r');
 } else if (mFlags & nsIDocumentEncoder::OutputLFLineBreak) {  // Unix/DOM
   mLineBreak.Assign('\n');
 } else {
   mLineBreak.AssignLiteral(NS_LINEBREAK);  // Platform/default
 }

 mDoRaw = !!(mFlags & nsIDocumentEncoder::OutputRaw);

 mDoFormat = (mFlags & nsIDocumentEncoder::OutputFormatted && !mDoRaw);

 mDoWrap = (mFlags & nsIDocumentEncoder::OutputWrap && !mDoRaw);

 mAllowLineBreaking =
     !(mFlags & nsIDocumentEncoder::OutputDisallowLineBreaking);

 if (!aWrapColumn) {
   mMaxColumn = 72;
 } else {
   mMaxColumn = aWrapColumn;
 }

 mOutput = &aOutput;
 mPreLevel = 0;
 mIsIndentationAddedOnCurrentLine = false;
 return NS_OK;
}

nsresult nsXMLContentSerializer::AppendTextData(Text* aText,
                                               int32_t aStartOffset,
                                               int32_t aEndOffset,
                                               nsAString& aStr,
                                               bool aTranslateEntities) {
 const CharacterDataBuffer* characterDataBuffer = nullptr;
 if (!aText || !(characterDataBuffer = aText->GetCharacterDataBuffer())) {
   return NS_ERROR_FAILURE;
 }

 int32_t fragLength = characterDataBuffer->GetLength();
 int32_t endoffset =
     (aEndOffset == -1) ? fragLength : std::min(aEndOffset, fragLength);
 int32_t length = endoffset - aStartOffset;

 NS_ASSERTION(aStartOffset >= 0, "Negative start offset for text fragment!");
 NS_ASSERTION(aStartOffset <= endoffset,
              "A start offset is beyond the end of the text fragment!");

 if (length <= 0) {
   // XXX Zero is a legal value, maybe non-zero values should be an
   // error.
   return NS_OK;
 }

 if (characterDataBuffer->Is2b()) {
   const char16_t* strStart = characterDataBuffer->Get2b() + aStartOffset;
   if (aTranslateEntities) {
     NS_ENSURE_TRUE(AppendAndTranslateEntities(
                        Substring(strStart, strStart + length), aStr),
                    NS_ERROR_OUT_OF_MEMORY);
   } else {
     NS_ENSURE_TRUE(aStr.Append(Substring(strStart, strStart + length),
                                mozilla::fallible),
                    NS_ERROR_OUT_OF_MEMORY);
   }
 } else {
   nsAutoString utf16;
   if (!CopyASCIItoUTF16(
           Span(characterDataBuffer->Get1b() + aStartOffset, length), utf16,
           mozilla::fallible_t())) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   if (aTranslateEntities) {
     NS_ENSURE_TRUE(AppendAndTranslateEntities(utf16, aStr),
                    NS_ERROR_OUT_OF_MEMORY);
   } else {
     NS_ENSURE_TRUE(aStr.Append(utf16, mozilla::fallible),
                    NS_ERROR_OUT_OF_MEMORY);
   }
 }

 return NS_OK;
}

NS_IMETHODIMP
nsXMLContentSerializer::AppendText(Text* aText, int32_t aStartOffset,
                                  int32_t aEndOffset) {
 NS_ENSURE_ARG(aText);
 NS_ENSURE_STATE(mOutput);

 nsAutoString data;
 nsresult rv;

 rv = AppendTextData(aText, aStartOffset, aEndOffset, data, true);
 if (NS_FAILED(rv)) return NS_ERROR_FAILURE;

 if (mDoRaw || PreLevel() > 0) {
   NS_ENSURE_TRUE(AppendToStringConvertLF(data, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else if (mDoFormat) {
   NS_ENSURE_TRUE(AppendToStringFormatedWrapped(data, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else if (mDoWrap) {
   NS_ENSURE_TRUE(AppendToStringWrapped(data, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else {
   NS_ENSURE_TRUE(AppendToStringConvertLF(data, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 }

 return NS_OK;
}

NS_IMETHODIMP
nsXMLContentSerializer::AppendCDATASection(Text* aCDATASection,
                                          int32_t aStartOffset,
                                          int32_t aEndOffset) {
 NS_ENSURE_ARG(aCDATASection);
 NS_ENSURE_STATE(mOutput);
 MOZ_ASSERT(aCDATASection->NodeType() == nsINode::CDATA_SECTION_NODE);

 nsresult rv;

 constexpr auto cdata = u"<![CDATA["_ns;

 if (mDoRaw || PreLevel() > 0) {
   NS_ENSURE_TRUE(AppendToString(cdata, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 } else if (mDoFormat) {
   NS_ENSURE_TRUE(AppendToStringFormatedWrapped(cdata, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else if (mDoWrap) {
   NS_ENSURE_TRUE(AppendToStringWrapped(cdata, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else {
   NS_ENSURE_TRUE(AppendToString(cdata, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 }

 nsAutoString data;
 rv = AppendTextData(aCDATASection, aStartOffset, aEndOffset, data, false);
 if (NS_FAILED(rv)) return NS_ERROR_FAILURE;

 NS_ENSURE_TRUE(AppendToStringConvertLF(data, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);

 NS_ENSURE_TRUE(AppendToString(u"]]>"_ns, *mOutput), NS_ERROR_OUT_OF_MEMORY);

 return NS_OK;
}

NS_IMETHODIMP
nsXMLContentSerializer::AppendProcessingInstruction(ProcessingInstruction* aPI,
                                                   int32_t aStartOffset,
                                                   int32_t aEndOffset) {
 NS_ENSURE_STATE(mOutput);

 nsAutoString target, data, start;

 NS_ENSURE_TRUE(MaybeAddNewlineForRootNode(*mOutput), NS_ERROR_OUT_OF_MEMORY);

 aPI->GetTarget(target);

 aPI->GetData(data);

 NS_ENSURE_TRUE(start.AppendLiteral("<?", mozilla::fallible),
                NS_ERROR_OUT_OF_MEMORY);
 NS_ENSURE_TRUE(start.Append(target, mozilla::fallible),
                NS_ERROR_OUT_OF_MEMORY);

 if (mDoRaw || PreLevel() > 0) {
   NS_ENSURE_TRUE(AppendToString(start, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 } else if (mDoFormat) {
   if (mAddSpace) {
     NS_ENSURE_TRUE(AppendNewLineToString(*mOutput), NS_ERROR_OUT_OF_MEMORY);
   }
   NS_ENSURE_TRUE(AppendToStringFormatedWrapped(start, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else if (mDoWrap) {
   NS_ENSURE_TRUE(AppendToStringWrapped(start, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else {
   NS_ENSURE_TRUE(AppendToString(start, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 }

 if (!data.IsEmpty()) {
   NS_ENSURE_TRUE(AppendToString(char16_t(' '), *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
   NS_ENSURE_TRUE(AppendToStringConvertLF(data, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 }
 NS_ENSURE_TRUE(AppendToString(u"?>"_ns, *mOutput), NS_ERROR_OUT_OF_MEMORY);

 MaybeFlagNewlineForRootNode(aPI);

 return NS_OK;
}

NS_IMETHODIMP
nsXMLContentSerializer::AppendComment(Comment* aComment, int32_t aStartOffset,
                                     int32_t aEndOffset) {
 NS_ENSURE_STATE(mOutput);

 nsAutoString data;
 aComment->GetData(data);

 int32_t dataLength = data.Length();
 if (aStartOffset || (aEndOffset != -1 && aEndOffset < dataLength)) {
   int32_t length =
       (aEndOffset == -1) ? dataLength : std::min(aEndOffset, dataLength);
   length -= aStartOffset;

   nsAutoString frag;
   if (length > 0) {
     data.Mid(frag, aStartOffset, length);
   }
   data.Assign(frag);
 }

 NS_ENSURE_TRUE(MaybeAddNewlineForRootNode(*mOutput), NS_ERROR_OUT_OF_MEMORY);

 constexpr auto startComment = u"<!--"_ns;

 if (mDoRaw || PreLevel() > 0) {
   NS_ENSURE_TRUE(AppendToString(startComment, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else if (mDoFormat) {
   if (mAddSpace) {
     NS_ENSURE_TRUE(AppendNewLineToString(*mOutput), NS_ERROR_OUT_OF_MEMORY);
   }
   NS_ENSURE_TRUE(AppendToStringFormatedWrapped(startComment, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else if (mDoWrap) {
   NS_ENSURE_TRUE(AppendToStringWrapped(startComment, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 } else {
   NS_ENSURE_TRUE(AppendToString(startComment, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 }

 // Even if mDoformat, we don't format the content because it
 // could have been preformated by the author
 NS_ENSURE_TRUE(AppendToStringConvertLF(data, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);
 NS_ENSURE_TRUE(AppendToString(u"-->"_ns, *mOutput), NS_ERROR_OUT_OF_MEMORY);

 MaybeFlagNewlineForRootNode(aComment);

 return NS_OK;
}

NS_IMETHODIMP
nsXMLContentSerializer::AppendDoctype(DocumentType* aDocType) {
 NS_ENSURE_STATE(mOutput);

 nsAutoString name, publicId, systemId;
 aDocType->GetName(name);
 aDocType->GetPublicId(publicId);
 aDocType->GetSystemId(systemId);

 NS_ENSURE_TRUE(MaybeAddNewlineForRootNode(*mOutput), NS_ERROR_OUT_OF_MEMORY);

 NS_ENSURE_TRUE(AppendToString(u"<!DOCTYPE "_ns, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);
 NS_ENSURE_TRUE(AppendToString(name, *mOutput), NS_ERROR_OUT_OF_MEMORY);

 char16_t quote;
 if (!publicId.IsEmpty()) {
   NS_ENSURE_TRUE(AppendToString(u" PUBLIC "_ns, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
   if (publicId.FindChar(char16_t('"')) == -1) {
     quote = char16_t('"');
   } else {
     quote = char16_t('\'');
   }
   NS_ENSURE_TRUE(AppendToString(quote, *mOutput), NS_ERROR_OUT_OF_MEMORY);
   NS_ENSURE_TRUE(AppendToString(publicId, *mOutput), NS_ERROR_OUT_OF_MEMORY);
   NS_ENSURE_TRUE(AppendToString(quote, *mOutput), NS_ERROR_OUT_OF_MEMORY);

   if (!systemId.IsEmpty()) {
     NS_ENSURE_TRUE(AppendToString(char16_t(' '), *mOutput),
                    NS_ERROR_OUT_OF_MEMORY);
     if (systemId.FindChar(char16_t('"')) == -1) {
       quote = char16_t('"');
     } else {
       quote = char16_t('\'');
     }
     NS_ENSURE_TRUE(AppendToString(quote, *mOutput), NS_ERROR_OUT_OF_MEMORY);
     NS_ENSURE_TRUE(AppendToString(systemId, *mOutput),
                    NS_ERROR_OUT_OF_MEMORY);
     NS_ENSURE_TRUE(AppendToString(quote, *mOutput), NS_ERROR_OUT_OF_MEMORY);
   }
 } else if (!systemId.IsEmpty()) {
   if (systemId.FindChar(char16_t('"')) == -1) {
     quote = char16_t('"');
   } else {
     quote = char16_t('\'');
   }
   NS_ENSURE_TRUE(AppendToString(u" SYSTEM "_ns, *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
   NS_ENSURE_TRUE(AppendToString(quote, *mOutput), NS_ERROR_OUT_OF_MEMORY);
   NS_ENSURE_TRUE(AppendToString(systemId, *mOutput), NS_ERROR_OUT_OF_MEMORY);
   NS_ENSURE_TRUE(AppendToString(quote, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 }

 NS_ENSURE_TRUE(AppendToString(kGreaterThan, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);
 MaybeFlagNewlineForRootNode(aDocType);

 return NS_OK;
}

nsresult nsXMLContentSerializer::PushNameSpaceDecl(const nsAString& aPrefix,
                                                  const nsAString& aURI,
                                                  nsIContent* aOwner) {
 NameSpaceDecl* decl = mNameSpaceStack.AppendElement();
 if (!decl) return NS_ERROR_OUT_OF_MEMORY;

 decl->mPrefix.Assign(aPrefix);
 decl->mURI.Assign(aURI);
 // Don't addref - this weak reference will be removed when
 // we pop the stack
 decl->mOwner = aOwner;
 return NS_OK;
}

void nsXMLContentSerializer::PopNameSpaceDeclsFor(nsIContent* aOwner) {
 int32_t index, count;

 count = mNameSpaceStack.Length();
 for (index = count - 1; index >= 0; index--) {
   if (mNameSpaceStack[index].mOwner != aOwner) {
     break;
   }
   mNameSpaceStack.RemoveLastElement();
 }
}

bool nsXMLContentSerializer::ConfirmPrefix(nsAString& aPrefix,
                                          const nsAString& aURI,
                                          nsIContent* aElement,
                                          bool aIsAttribute) {
 if (aPrefix.EqualsLiteral(kXMLNS)) {
   return false;
 }

 if (aURI.EqualsLiteral("http://www.w3.org/XML/1998/namespace")) {
   // The prefix must be xml for this namespace. We don't need to declare it,
   // so always just set the prefix to xml.
   aPrefix.AssignLiteral("xml");

   return false;
 }

 bool mustHavePrefix;
 if (aIsAttribute) {
   if (aURI.IsEmpty()) {
     // Attribute in the null namespace.  This just shouldn't have a prefix.
     // And there's no need to push any namespace decls
     aPrefix.Truncate();
     return false;
   }

   // Attribute not in the null namespace -- must have a prefix
   mustHavePrefix = true;
 } else {
   // Not an attribute, so doesn't _have_ to have a prefix
   mustHavePrefix = false;
 }

 // Keep track of the closest prefix that's bound to aURI and whether we've
 // found such a thing.  closestURIMatch holds the prefix, and uriMatch
 // indicates whether we actually have one.
 nsAutoString closestURIMatch;
 bool uriMatch = false;

 // Also keep track of whether we've seen aPrefix already.  If we have, that
 // means that it's already bound to a URI different from aURI, so even if we
 // later (so in a more outer scope) see it bound to aURI we can't reuse it.
 bool haveSeenOurPrefix = false;

 int32_t count = mNameSpaceStack.Length();
 int32_t index = count - 1;
 while (index >= 0) {
   NameSpaceDecl& decl = mNameSpaceStack.ElementAt(index);
   // Check if we've found a prefix match
   if (aPrefix.Equals(decl.mPrefix)) {
     // If the URIs match and aPrefix is not bound to any other URI, we can
     // use aPrefix
     if (!haveSeenOurPrefix && aURI.Equals(decl.mURI)) {
       // Just use our uriMatch stuff.  That will deal with an empty aPrefix
       // the right way.  We can break out of the loop now, though.
       uriMatch = true;
       closestURIMatch = aPrefix;
       break;
     }

     haveSeenOurPrefix = true;

     // If they don't, and either:
     // 1) We have a prefix (so we'd be redeclaring this prefix to point to a
     //    different namespace) or
     // 2) We're looking at an existing default namespace decl on aElement (so
     //    we can't create a new default namespace decl for this URI)
     // then generate a new prefix.  Note that we do NOT generate new prefixes
     // if we happen to have aPrefix == decl->mPrefix == "" and mismatching
     // URIs when |decl| doesn't have aElement as its owner.  In that case we
     // can simply push the new namespace URI as the default namespace for
     // aElement.
     if (!aPrefix.IsEmpty() || decl.mOwner == aElement) {
       NS_ASSERTION(!aURI.IsEmpty(),
                    "Not allowed to add a xmlns attribute with an empty "
                    "namespace name unless it declares the default "
                    "namespace.");

       GenerateNewPrefix(aPrefix);
       // Now we need to validate our new prefix/uri combination; check it
       // against the full namespace stack again.  Note that just restarting
       // the while loop is ok, since we haven't changed aURI, so the
       // closestURIMatch and uriMatch state is not affected.
       index = count - 1;
       haveSeenOurPrefix = false;
       continue;
     }
   }

   // If we've found a URI match, then record the first one
   if (!uriMatch && aURI.Equals(decl.mURI)) {
     // Need to check that decl->mPrefix is not declared anywhere closer to
     // us.  If it is, we can't use it.
     bool prefixOK = true;
     int32_t index2;
     for (index2 = count - 1; index2 > index && prefixOK; --index2) {
       prefixOK = (mNameSpaceStack[index2].mPrefix != decl.mPrefix);
     }

     if (prefixOK) {
       uriMatch = true;
       closestURIMatch.Assign(decl.mPrefix);
     }
   }

   --index;
 }

 // At this point the following invariants hold:
 // 1) The prefix in closestURIMatch is mapped to aURI in our scope if
 //    uriMatch is set.
 // 2) There is nothing on the namespace stack that has aPrefix as the prefix
 //    and a _different_ URI, except for the case aPrefix.IsEmpty (and
 //    possible default namespaces on ancestors)

 // So if uriMatch is set it's OK to use the closestURIMatch prefix.  The one
 // exception is when closestURIMatch is actually empty (default namespace
 // decl) and we must have a prefix.
 if (uriMatch && (!mustHavePrefix || !closestURIMatch.IsEmpty())) {
   aPrefix.Assign(closestURIMatch);
   return false;
 }

 if (aPrefix.IsEmpty()) {
   // At this point, aPrefix is empty (which means we never had a prefix to
   // start with).  If we must have a prefix, just generate a new prefix and
   // then send it back through the namespace stack checks to make sure it's
   // OK.
   if (mustHavePrefix) {
     GenerateNewPrefix(aPrefix);
     return ConfirmPrefix(aPrefix, aURI, aElement, aIsAttribute);
   }

   // One final special case.  If aPrefix is empty and we never saw an empty
   // prefix (default namespace decl) on the namespace stack and we're in the
   // null namespace there is no reason to output an |xmlns=""| here.  It just
   // makes the output less readable.
   if (!haveSeenOurPrefix && aURI.IsEmpty()) {
     return false;
   }
 }

 // Now just set aURI as the new default namespace URI.  Indicate that we need
 // to create a namespace decl for the final prefix
 return true;
}

void nsXMLContentSerializer::GenerateNewPrefix(nsAString& aPrefix) {
 aPrefix.Assign('a');
 aPrefix.AppendInt(mPrefixIndex++);
}

bool nsXMLContentSerializer::SerializeAttr(const nsAString& aPrefix,
                                          const nsAString& aName,
                                          const nsAString& aValue,
                                          nsAString& aStr,
                                          bool aDoEscapeEntities) {
 // Because this method can short-circuit AppendToString for raw output, we
 // need to make sure that we're not inappropriately serializing attributes
 // from outside the body
 if (mBodyOnly && !mInBody) {
   return true;
 }

 nsAutoString attrString_;
 // For innerHTML we can do faster appending without
 // temporary strings.
 bool rawAppend = mDoRaw && aDoEscapeEntities;
 nsAString& attrString = (rawAppend) ? aStr : attrString_;

 NS_ENSURE_TRUE(attrString.Append(char16_t(' '), mozilla::fallible), false);
 if (!aPrefix.IsEmpty()) {
   NS_ENSURE_TRUE(attrString.Append(aPrefix, mozilla::fallible), false);
   NS_ENSURE_TRUE(attrString.Append(char16_t(':'), mozilla::fallible), false);
 }
 NS_ENSURE_TRUE(attrString.Append(aName, mozilla::fallible), false);

 if (aDoEscapeEntities) {
   // if problem characters are turned into character entity references
   // then there will be no problem with the value delimiter characters
   NS_ENSURE_TRUE(attrString.AppendLiteral("=\"", mozilla::fallible), false);

   mInAttribute = true;
   bool result = AppendAndTranslateEntities(aValue, attrString);
   mInAttribute = false;
   NS_ENSURE_TRUE(result, false);

   NS_ENSURE_TRUE(attrString.Append(char16_t('"'), mozilla::fallible), false);
   if (rawAppend) {
     return true;
   }
 } else {
   // Depending on whether the attribute value contains quotes or apostrophes
   // we need to select the delimiter character and escape characters using
   // character entity references, ignoring the value of aDoEscapeEntities.
   // See http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.3.2.2 for
   // the standard on character entity references in values.  We also have to
   // make sure to escape any '&' characters.

   bool bIncludesSingle = false;
   bool bIncludesDouble = false;
   nsAString::const_iterator iCurr, iEnd;
   aValue.BeginReading(iCurr);
   aValue.EndReading(iEnd);
   for (; iCurr != iEnd; ++iCurr) {
     if (*iCurr == char16_t('\'')) {
       bIncludesSingle = true;
       if (bIncludesDouble) {
         break;
       }
     } else if (*iCurr == char16_t('"')) {
       bIncludesDouble = true;
       if (bIncludesSingle) {
         break;
       }
     }
   }

   // Delimiter and escaping is according to the following table
   //    bIncludesDouble   bIncludesSingle   Delimiter    Escape Double Quote
   //    FALSE             FALSE             "            FALSE
   //    FALSE             TRUE              "            FALSE
   //    TRUE              FALSE             '            FALSE
   //    TRUE              TRUE              "            TRUE
   char16_t cDelimiter =
       (bIncludesDouble && !bIncludesSingle) ? char16_t('\'') : char16_t('"');
   NS_ENSURE_TRUE(attrString.Append(char16_t('='), mozilla::fallible), false);
   NS_ENSURE_TRUE(attrString.Append(cDelimiter, mozilla::fallible), false);
   nsAutoString sValue(aValue);
   NS_ENSURE_TRUE(
       sValue.ReplaceSubstring(u"&"_ns, u"&amp;"_ns, mozilla::fallible),
       false);
   if (bIncludesDouble && bIncludesSingle) {
     NS_ENSURE_TRUE(
         sValue.ReplaceSubstring(u"\""_ns, u"&quot;"_ns, mozilla::fallible),
         false);
   }
   NS_ENSURE_TRUE(attrString.Append(sValue, mozilla::fallible), false);
   NS_ENSURE_TRUE(attrString.Append(cDelimiter, mozilla::fallible), false);
 }

 if (mDoWrap && mColPos + attrString.Length() > mMaxColumn) {
   // Attr would cause us to overrun the max width, so begin a new line.
   NS_ENSURE_TRUE(AppendNewLineToString(aStr), false);

   // Chomp the leading space.
   nsDependentSubstring chomped(attrString, 1);
   if (mDoFormat && mIndent.Length() + chomped.Length() <= mMaxColumn) {
     NS_ENSURE_TRUE(AppendIndentation(aStr), false);
   }
   NS_ENSURE_TRUE(AppendToStringConvertLF(chomped, aStr), false);
 } else {
   NS_ENSURE_TRUE(AppendToStringConvertLF(attrString, aStr), false);
 }

 return true;
}

uint32_t nsXMLContentSerializer::ScanNamespaceDeclarations(
   Element* aElement, Element* aOriginalElement,
   const nsAString& aTagNamespaceURI) {
 uint32_t index, count;
 nsAutoString uriStr, valueStr;

 count = aElement->GetAttrCount();

 // First scan for namespace declarations, pushing each on the stack
 uint32_t skipAttr = count;
 for (index = 0; index < count; index++) {
   const BorrowedAttrInfo info = aElement->GetAttrInfoAt(index);
   const nsAttrName* name = info.mName;

   int32_t namespaceID = name->NamespaceID();
   nsAtom* attrName = name->LocalName();

   if (namespaceID == kNameSpaceID_XMLNS ||
       // Also push on the stack attrs named "xmlns" in the null
       // namespace... because once we serialize those out they'll look like
       // namespace decls.  :(
       // XXXbz what if we have both "xmlns" in the null namespace and "xmlns"
       // in the xmlns namespace?
       (namespaceID == kNameSpaceID_None && attrName == nsGkAtoms::xmlns)) {
     info.mValue->ToString(uriStr);

     if (!name->GetPrefix()) {
       if (aTagNamespaceURI.IsEmpty() && !uriStr.IsEmpty()) {
         // If the element is in no namespace we need to add a xmlns
         // attribute to declare that. That xmlns attribute must not have a
         // prefix (see http://www.w3.org/TR/REC-xml-names/#dt-prefix), ie it
         // must declare the default namespace. We just found an xmlns
         // attribute that declares the default namespace to something
         // non-empty. We're going to ignore this attribute, for children we
         // will detect that we need to add it again and attributes aren't
         // affected by the default namespace.
         skipAttr = index;
       } else {
         // Default NS attribute does not have prefix (and the name is "xmlns")
         PushNameSpaceDecl(u""_ns, uriStr, aOriginalElement);
       }
     } else {
       PushNameSpaceDecl(nsDependentAtomString(attrName), uriStr,
                         aOriginalElement);
     }
   }
 }
 return skipAttr;
}

bool nsXMLContentSerializer::IsJavaScript(nsIContent* aContent,
                                         nsAtom* aAttrNameAtom,
                                         int32_t aAttrNamespaceID,
                                         const nsAString& aValueString) {
 bool isHtml = aContent->IsHTMLElement();
 bool isXul = aContent->IsXULElement();
 bool isSvg = aContent->IsSVGElement();

 if (aAttrNamespaceID == kNameSpaceID_None && (isHtml || isXul || isSvg) &&
     (aAttrNameAtom == nsGkAtoms::href || aAttrNameAtom == nsGkAtoms::src)) {
   static const char kJavaScript[] = "javascript";
   int32_t pos = aValueString.FindChar(':');
   if (pos < (int32_t)(sizeof kJavaScript - 1)) return false;
   nsAutoString scheme(Substring(aValueString, 0, pos));
   scheme.StripWhitespace();
   if ((scheme.Length() == (sizeof kJavaScript - 1)) &&
       scheme.EqualsIgnoreCase(kJavaScript))
     return true;
   else
     return false;
 }

 return aContent->IsEventAttributeName(aAttrNameAtom);
}

bool nsXMLContentSerializer::SerializeAttributes(
   Element* aElement, Element* aOriginalElement, nsAString& aTagPrefix,
   const nsAString& aTagNamespaceURI, nsAtom* aTagName, nsAString& aStr,
   uint32_t aSkipAttr, bool aAddNSAttr) {
 nsAutoString prefixStr, uriStr, valueStr;
 nsAutoString xmlnsStr;
 xmlnsStr.AssignLiteral(kXMLNS);
 uint32_t index, count;

 MaybeSerializeIsValue(aElement, 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
     NS_ENSURE_TRUE(
         SerializeAttr(u""_ns, xmlnsStr, aTagNamespaceURI, aStr, true), false);
   } else {
     // Serialize namespace decl
     NS_ENSURE_TRUE(
         SerializeAttr(xmlnsStr, aTagPrefix, aTagNamespaceURI, aStr, true),
         false);
   }
   PushNameSpaceDecl(aTagPrefix, aTagNamespaceURI, aOriginalElement);
 }

 count = aElement->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 = aElement->GetAttrNameAt(index);
   int32_t namespaceID = name->NamespaceID();
   nsAtom* attrName = name->LocalName();
   nsAtom* attrPrefix = name->GetPrefix();

   // Filter out any attribute starting with [-|_]moz
   nsDependentAtomString attrNameStr(attrName);
   if (StringBeginsWith(attrNameStr, u"_moz"_ns) ||
       StringBeginsWith(attrNameStr, u"-moz"_ns)) {
     continue;
   }

   if (attrPrefix) {
     attrPrefix->ToString(prefixStr);
   } else {
     prefixStr.Truncate();
   }

   bool addNSAttr = false;
   if (kNameSpaceID_XMLNS != namespaceID) {
     nsNameSpaceManager::GetInstance()->GetNameSpaceURI(namespaceID, uriStr);
     addNSAttr = ConfirmPrefix(prefixStr, uriStr, aOriginalElement, true);
   }

   aElement->GetAttr(namespaceID, attrName, valueStr);

   nsDependentAtomString nameStr(attrName);
   bool isJS = IsJavaScript(aElement, 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;
}

NS_IMETHODIMP
nsXMLContentSerializer::AppendElementStart(Element* aElement,
                                          Element* aOriginalElement) {
 NS_ENSURE_ARG(aElement);
 NS_ENSURE_STATE(mOutput);

 bool forceFormat = false;
 nsresult rv = NS_OK;
 if (!CheckElementStart(aElement, forceFormat, *mOutput, rv)) {
   // When we go to AppendElementEnd for this element, we're going to
   // MaybeLeaveFromPreContent().  So make sure to MaybeEnterInPreContent()
   // now, so our PreLevel() doesn't get confused.
   MaybeEnterInPreContent(aElement);
   return rv;
 }

 NS_ENSURE_SUCCESS(rv, rv);

 nsAutoString tagPrefix, tagLocalName, tagNamespaceURI;
 aElement->NodeInfo()->GetPrefix(tagPrefix);
 aElement->NodeInfo()->GetName(tagLocalName);
 aElement->NodeInfo()->GetNamespaceURI(tagNamespaceURI);

 uint32_t skipAttr =
     ScanNamespaceDeclarations(aElement, aOriginalElement, tagNamespaceURI);

 nsAtom* name = aElement->NodeInfo()->NameAtom();
 bool lineBreakBeforeOpen =
     LineBreakBeforeOpen(aElement->GetNameSpaceID(), name);

 if ((mDoFormat || forceFormat) && !mDoRaw && !PreLevel()) {
   if (mColPos && lineBreakBeforeOpen) {
     NS_ENSURE_TRUE(AppendNewLineToString(*mOutput), NS_ERROR_OUT_OF_MEMORY);
   } else {
     NS_ENSURE_TRUE(MaybeAddNewlineForRootNode(*mOutput),
                    NS_ERROR_OUT_OF_MEMORY);
   }
   if (!mColPos) {
     NS_ENSURE_TRUE(AppendIndentation(*mOutput), NS_ERROR_OUT_OF_MEMORY);
   } else if (mAddSpace) {
     NS_ENSURE_TRUE(AppendToString(char16_t(' '), *mOutput),
                    NS_ERROR_OUT_OF_MEMORY);
     mAddSpace = false;
   }
 } else if (mAddSpace) {
   NS_ENSURE_TRUE(AppendToString(char16_t(' '), *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
   mAddSpace = false;
 } else {
   NS_ENSURE_TRUE(MaybeAddNewlineForRootNode(*mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
 }

 // Always reset to avoid false newlines in case MaybeAddNewlineForRootNode
 // wasn't called
 mAddNewlineForRootNode = false;

 bool addNSAttr;
 addNSAttr =
     ConfirmPrefix(tagPrefix, tagNamespaceURI, aOriginalElement, false);

 // Serialize the qualified name of the element
 NS_ENSURE_TRUE(AppendToString(kLessThan, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 if (!tagPrefix.IsEmpty()) {
   NS_ENSURE_TRUE(AppendToString(tagPrefix, *mOutput), NS_ERROR_OUT_OF_MEMORY);
   NS_ENSURE_TRUE(AppendToString(u":"_ns, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 }
 NS_ENSURE_TRUE(AppendToString(tagLocalName, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);

 MaybeEnterInPreContent(aElement);

 if ((mDoFormat || forceFormat) && !mDoRaw && !PreLevel()) {
   NS_ENSURE_TRUE(IncrIndentation(name), NS_ERROR_OUT_OF_MEMORY);
 }

 NS_ENSURE_TRUE(
     SerializeAttributes(aElement, aOriginalElement, tagPrefix,
                         tagNamespaceURI, name, *mOutput, skipAttr, addNSAttr),
     NS_ERROR_OUT_OF_MEMORY);

 NS_ENSURE_TRUE(AppendEndOfElementStart(aElement, aOriginalElement, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);

 if ((mDoFormat || forceFormat) && !mDoRaw && !PreLevel() &&
     LineBreakAfterOpen(aElement->GetNameSpaceID(), name)) {
   NS_ENSURE_TRUE(AppendNewLineToString(*mOutput), NS_ERROR_OUT_OF_MEMORY);
 }

 NS_ENSURE_TRUE(AfterElementStart(aElement, aOriginalElement, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);

 return NS_OK;
}

// aElement is the actual element we're outputting.  aOriginalElement is the one
// in the original DOM, which is the one we have to test for kids.
static bool ElementNeedsSeparateEndTag(Element* aElement,
                                      Element* aOriginalElement) {
 if (aOriginalElement->GetChildCount()) {
   // We have kids, so we need a separate end tag.  This needs to be checked on
   // aOriginalElement because that's the one that's actually in the DOM and
   // might have kids.
   return true;
 }

 if (!aElement->IsHTMLElement()) {
   // Empty non-HTML elements can just skip a separate end tag.
   return false;
 }

 // HTML container tags should have a separate end tag even if empty, per spec.
 // See
 // https://w3c.github.io/DOM-Parsing/#dfn-concept-xml-serialization-algorithm
 nsAtom* localName = aElement->NodeInfo()->NameAtom();
 bool isHTMLContainer = nsHTMLElement::IsContainer(
     nsHTMLTags::CaseSensitiveAtomTagToId(localName));
 return isHTMLContainer;
}

bool nsXMLContentSerializer::AppendEndOfElementStart(Element* aElement,
                                                    Element* aOriginalElement,
                                                    nsAString& aStr) {
 if (ElementNeedsSeparateEndTag(aElement, aOriginalElement)) {
   return AppendToString(kGreaterThan, aStr);
 }

 // We don't need a separate end tag.  For HTML elements (which at this point
 // must be non-containers), append a space before the '/', per spec.  See
 // https://w3c.github.io/DOM-Parsing/#dfn-concept-xml-serialization-algorithm
 if (aOriginalElement->IsHTMLElement()) {
   if (!AppendToString(kSpace, aStr)) {
     return false;
   }
 }

 return AppendToString(u"/>"_ns, aStr);
}

NS_IMETHODIMP
nsXMLContentSerializer::AppendElementEnd(Element* aElement,
                                        Element* aOriginalElement) {
 NS_ENSURE_ARG(aElement);
 NS_ENSURE_STATE(mOutput);

 nsIContent* content = aElement;

 bool forceFormat = false, outputElementEnd;
 outputElementEnd =
     CheckElementEnd(aElement, aOriginalElement, forceFormat, *mOutput);

 nsAtom* name = content->NodeInfo()->NameAtom();

 if ((mDoFormat || forceFormat) && !mDoRaw && !PreLevel()) {
   DecrIndentation(name);
 }

 if (!outputElementEnd) {
   // Keep this in sync with the cleanup at the end of this method.
   PopNameSpaceDeclsFor(aElement);
   MaybeLeaveFromPreContent(content);
   MaybeFlagNewlineForRootNode(aElement);
   AfterElementEnd(content, *mOutput);
   return NS_OK;
 }

 nsAutoString tagPrefix, tagLocalName, tagNamespaceURI;

 aElement->NodeInfo()->GetPrefix(tagPrefix);
 aElement->NodeInfo()->GetName(tagLocalName);
 aElement->NodeInfo()->GetNamespaceURI(tagNamespaceURI);

#ifdef DEBUG
 bool debugNeedToPushNamespace =
#endif
     ConfirmPrefix(tagPrefix, tagNamespaceURI, aElement, false);
 NS_ASSERTION(!debugNeedToPushNamespace,
              "Can't push namespaces in closing tag!");

 if ((mDoFormat || forceFormat) && !mDoRaw && !PreLevel()) {
   bool lineBreakBeforeClose =
       LineBreakBeforeClose(content->GetNameSpaceID(), name);

   if (mColPos && lineBreakBeforeClose) {
     NS_ENSURE_TRUE(AppendNewLineToString(*mOutput), NS_ERROR_OUT_OF_MEMORY);
   }
   if (!mColPos) {
     NS_ENSURE_TRUE(AppendIndentation(*mOutput), NS_ERROR_OUT_OF_MEMORY);
   } else if (mAddSpace) {
     NS_ENSURE_TRUE(AppendToString(char16_t(' '), *mOutput),
                    NS_ERROR_OUT_OF_MEMORY);
     mAddSpace = false;
   }
 } else if (mAddSpace) {
   NS_ENSURE_TRUE(AppendToString(char16_t(' '), *mOutput),
                  NS_ERROR_OUT_OF_MEMORY);
   mAddSpace = false;
 }

 NS_ENSURE_TRUE(AppendToString(kEndTag, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 if (!tagPrefix.IsEmpty()) {
   NS_ENSURE_TRUE(AppendToString(tagPrefix, *mOutput), NS_ERROR_OUT_OF_MEMORY);
   NS_ENSURE_TRUE(AppendToString(u":"_ns, *mOutput), NS_ERROR_OUT_OF_MEMORY);
 }
 NS_ENSURE_TRUE(AppendToString(tagLocalName, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);
 NS_ENSURE_TRUE(AppendToString(kGreaterThan, *mOutput),
                NS_ERROR_OUT_OF_MEMORY);

 // Keep what follows in sync with the cleanup in the !outputElementEnd case.
 PopNameSpaceDeclsFor(aElement);

 MaybeLeaveFromPreContent(content);

 if ((mDoFormat || forceFormat) && !mDoRaw && !PreLevel() &&
     LineBreakAfterClose(content->GetNameSpaceID(), name)) {
   NS_ENSURE_TRUE(AppendNewLineToString(*mOutput), NS_ERROR_OUT_OF_MEMORY);
 } else {
   MaybeFlagNewlineForRootNode(aElement);
 }

 AfterElementEnd(content, *mOutput);

 return NS_OK;
}

NS_IMETHODIMP
nsXMLContentSerializer::Finish() {
 NS_ENSURE_STATE(mOutput);

 mOutput = nullptr;

 return NS_OK;
}

NS_IMETHODIMP
nsXMLContentSerializer::GetOutputLength(uint32_t& aLength) const {
 NS_ENSURE_STATE(mOutput);

 aLength = mOutput->Length();

 return NS_OK;
}

NS_IMETHODIMP
nsXMLContentSerializer::AppendDocumentStart(Document* aDocument) {
 NS_ENSURE_ARG_POINTER(aDocument);
 NS_ENSURE_STATE(mOutput);

 nsAutoString version, encoding, standalone;
 aDocument->GetXMLDeclaration(version, encoding, standalone);

 if (version.IsEmpty())
   return NS_OK;  // A declaration must have version, or there is no decl

 constexpr auto endQuote = u"\""_ns;

 *mOutput += u"<?xml version=\""_ns + version + endQuote;

 if (!mCharset.IsEmpty()) {
   *mOutput +=
       u" encoding=\""_ns + NS_ConvertASCIItoUTF16(mCharset) + endQuote;
 }
 // Otherwise just don't output an encoding attr.  Not that we expect
 // mCharset to ever be empty.
#ifdef DEBUG
 else {
   NS_WARNING("Empty mCharset?  How come?");
 }
#endif

 if (!standalone.IsEmpty()) {
   *mOutput += u" standalone=\""_ns + standalone + endQuote;
 }

 NS_ENSURE_TRUE(mOutput->AppendLiteral("?>", mozilla::fallible),
                NS_ERROR_OUT_OF_MEMORY);
 mAddNewlineForRootNode = true;

 return NS_OK;
}

bool nsXMLContentSerializer::CheckElementStart(Element*, bool& aForceFormat,
                                              nsAString& aStr,
                                              nsresult& aResult) {
 aResult = NS_OK;
 aForceFormat = false;
 return true;
}

bool nsXMLContentSerializer::CheckElementEnd(Element* aElement,
                                            Element* aOriginalElement,
                                            bool& aForceFormat,
                                            nsAString& aStr) {
 // We don't output a separate end tag for empty element
 aForceFormat = false;
 return ElementNeedsSeparateEndTag(aElement, aOriginalElement);
}

bool nsXMLContentSerializer::AppendToString(const char16_t aChar,
                                           nsAString& aOutputStr) {
 if (mBodyOnly && !mInBody) {
   return true;
 }
 mColPos += 1;
 return aOutputStr.Append(aChar, mozilla::fallible);
}

bool nsXMLContentSerializer::AppendToString(const nsAString& aStr,
                                           nsAString& aOutputStr) {
 if (mBodyOnly && !mInBody) {
   return true;
 }
 mColPos += aStr.Length();
 return aOutputStr.Append(aStr, mozilla::fallible);
}

#define _ 0

// This table indexes into kEntityStrings[].
const uint8_t nsXMLContentSerializer::kEntities[] = {
   // clang-format off
 _, _, _, _, _, _, _, _, _, _,
 _, _, _, _, _, _, _, _, _, _,
 _, _, _, _, _, _, _, _, _, _,
 _, _, _, _, _, _, _, _, 2, _,
 _, _, _, _, _, _, _, _, _, _,
 _, _, _, _, _, _, _, _, _, _,
 3, _, 4
   // clang-format on
};

// This table indexes into kEntityStrings[].
const uint8_t nsXMLContentSerializer::kAttrEntities[] = {
   // clang-format off
 _, _, _, _, _, _, _, _, _, 5,
 6, _, _, 7, _, _, _, _, _, _,
 _, _, _, _, _, _, _, _, _, _,
 _, _, _, _, 1, _, _, _, 2, _,
 _, _, _, _, _, _, _, _, _, _,
 _, _, _, _, _, _, _, _, _, _,
 3, _, 4
   // clang-format on
};

#undef _

const char* const nsXMLContentSerializer::kEntityStrings[] = {
   /* 0 */ nullptr,
   /* 1 */ "&quot;",
   /* 2 */ "&amp;",
   /* 3 */ "&lt;",
   /* 4 */ "&gt;",
   /* 5 */ "&#9;",
   /* 6 */ "&#xA;",
   /* 7 */ "&#xD;",
};

bool nsXMLContentSerializer::AppendAndTranslateEntities(const nsAString& aStr,
                                                       nsAString& aOutputStr) {
 if (mInAttribute) {
   return AppendAndTranslateEntities<kGTVal>(aStr, aOutputStr, kAttrEntities,
                                             kEntityStrings);
 }

 return AppendAndTranslateEntities<kGTVal>(aStr, aOutputStr, kEntities,
                                           kEntityStrings);
}

/* static */
bool nsXMLContentSerializer::AppendAndTranslateEntities(
   const nsAString& aStr, nsAString& aOutputStr, const uint8_t aEntityTable[],
   uint16_t aMaxTableIndex, const char* const aStringTable[]) {
 nsReadingIterator<char16_t> done_reading;
 aStr.EndReading(done_reading);

 // for each chunk of |aString|...
 uint32_t advanceLength = 0;
 nsReadingIterator<char16_t> iter;

 for (aStr.BeginReading(iter); iter != done_reading;
      iter.advance(int32_t(advanceLength))) {
   uint32_t fragmentLength = done_reading - iter;
   const char16_t* c = iter.get();
   const char16_t* fragmentStart = c;
   const char16_t* fragmentEnd = c + fragmentLength;
   const char* entityText = nullptr;

   advanceLength = 0;
   // for each character in this chunk, check if it
   // needs to be replaced
   for (; c < fragmentEnd; c++, advanceLength++) {
     char16_t val = *c;
     if ((val <= aMaxTableIndex) && aEntityTable[val]) {
       entityText = aStringTable[aEntityTable[val]];
       break;
     }
   }

   NS_ENSURE_TRUE(
       aOutputStr.Append(fragmentStart, advanceLength, mozilla::fallible),
       false);
   if (entityText) {
     NS_ENSURE_TRUE(AppendASCIItoUTF16(mozilla::MakeStringSpan(entityText),
                                       aOutputStr, mozilla::fallible),
                    false);
     advanceLength++;
   }
 }

 return true;
}

bool nsXMLContentSerializer::MaybeAddNewlineForRootNode(nsAString& aStr) {
 if (mAddNewlineForRootNode) {
   return AppendNewLineToString(aStr);
 }

 return true;
}

void nsXMLContentSerializer::MaybeFlagNewlineForRootNode(nsINode* aNode) {
 nsINode* parent = aNode->GetParentNode();
 if (parent) {
   mAddNewlineForRootNode = parent->IsDocument();
 }
}

void nsXMLContentSerializer::MaybeEnterInPreContent(nsIContent* aNode) {
 // support of the xml:space attribute
 nsAutoString space;
 if (ShouldMaintainPreLevel() && aNode->IsElement() &&
     aNode->AsElement()->GetAttr(kNameSpaceID_XML, nsGkAtoms::space, space) &&
     space.EqualsLiteral("preserve")) {
   ++PreLevel();
 }
}

void nsXMLContentSerializer::MaybeLeaveFromPreContent(nsIContent* aNode) {
 // support of the xml:space attribute
 nsAutoString space;
 if (ShouldMaintainPreLevel() && aNode->IsElement() &&
     aNode->AsElement()->GetAttr(kNameSpaceID_XML, nsGkAtoms::space, space) &&
     space.EqualsLiteral("preserve")) {
   --PreLevel();
 }
}

bool nsXMLContentSerializer::AppendNewLineToString(nsAString& aStr) {
 bool result = AppendToString(mLineBreak, aStr);
 mMayIgnoreLineBreakSequence = true;
 mColPos = 0;
 mAddSpace = false;
 mIsIndentationAddedOnCurrentLine = false;
 return result;
}

bool nsXMLContentSerializer::AppendIndentation(nsAString& aStr) {
 mIsIndentationAddedOnCurrentLine = true;
 bool result = AppendToString(mIndent, aStr);
 mAddSpace = false;
 mMayIgnoreLineBreakSequence = false;
 return result;
}

bool nsXMLContentSerializer::IncrIndentation(nsAtom* aName) {
 // we want to keep the source readable
 if (mDoWrap &&
     mIndent.Length() >= uint32_t(mMaxColumn) - MIN_INDENTED_LINE_LENGTH) {
   ++mIndentOverflow;
 } else {
   return mIndent.AppendLiteral(INDENT_STRING, mozilla::fallible);
 }

 return true;
}

void nsXMLContentSerializer::DecrIndentation(nsAtom* aName) {
 if (mIndentOverflow)
   --mIndentOverflow;
 else
   mIndent.Cut(0, INDENT_STRING_LENGTH);
}

bool nsXMLContentSerializer::LineBreakBeforeOpen(int32_t aNamespaceID,
                                                nsAtom* aName) {
 return mAddSpace;
}

bool nsXMLContentSerializer::LineBreakAfterOpen(int32_t aNamespaceID,
                                               nsAtom* aName) {
 return false;
}

bool nsXMLContentSerializer::LineBreakBeforeClose(int32_t aNamespaceID,
                                                 nsAtom* aName) {
 return mAddSpace;
}

bool nsXMLContentSerializer::LineBreakAfterClose(int32_t aNamespaceID,
                                                nsAtom* aName) {
 return false;
}

bool nsXMLContentSerializer::AppendToStringConvertLF(const nsAString& aStr,
                                                    nsAString& aOutputStr) {
 if (mBodyOnly && !mInBody) {
   return true;
 }

 if (mDoRaw) {
   NS_ENSURE_TRUE(AppendToString(aStr, aOutputStr), false);
 } else {
   // Convert line-endings to mLineBreak
   uint32_t start = 0;
   uint32_t theLen = aStr.Length();
   while (start < theLen) {
     int32_t eol = aStr.FindChar('\n', start);
     if (eol == kNotFound) {
       nsDependentSubstring dataSubstring(aStr, start, theLen - start);
       NS_ENSURE_TRUE(AppendToString(dataSubstring, aOutputStr), false);
       start = theLen;
       // if there was a line break before this substring
       // AppendNewLineToString was called, so we should reverse
       // this flag
       mMayIgnoreLineBreakSequence = false;
     } else {
       nsDependentSubstring dataSubstring(aStr, start, eol - start);
       NS_ENSURE_TRUE(AppendToString(dataSubstring, aOutputStr), false);
       NS_ENSURE_TRUE(AppendNewLineToString(aOutputStr), false);
       start = eol + 1;
     }
   }
 }

 return true;
}

bool nsXMLContentSerializer::AppendFormatedWrapped_WhitespaceSequence(
   nsAString::const_char_iterator& aPos,
   const nsAString::const_char_iterator aEnd,
   const nsAString::const_char_iterator aSequenceStart,
   bool& aMayIgnoreStartOfLineWhitespaceSequence, nsAString& aOutputStr) {
 // Handle the complete sequence of whitespace.
 // Continue to iterate until we find the first non-whitespace char.
 // Updates "aPos" to point to the first unhandled char.
 // Also updates the aMayIgnoreStartOfLineWhitespaceSequence flag,
 // as well as the other "global" state flags.

 bool sawBlankOrTab = false;
 bool leaveLoop = false;

 do {
   switch (*aPos) {
     case ' ':
     case '\t':
       sawBlankOrTab = true;
       [[fallthrough]];
     case '\n':
       ++aPos;
       // do not increase mColPos,
       // because we will reduce the whitespace to a single char
       break;
     default:
       leaveLoop = true;
       break;
   }
 } while (!leaveLoop && aPos < aEnd);

 if (mAddSpace) {
   // if we had previously been asked to add space,
   // our situation has not changed
 } else if (!sawBlankOrTab && mMayIgnoreLineBreakSequence) {
   // nothing to do in the case where line breaks have already been added
   // before the call of AppendToStringWrapped
   // and only if we found line break in the sequence
   mMayIgnoreLineBreakSequence = false;
 } else if (aMayIgnoreStartOfLineWhitespaceSequence) {
   // nothing to do
   aMayIgnoreStartOfLineWhitespaceSequence = false;
 } else {
   if (sawBlankOrTab) {
     if (mDoWrap && mColPos + 1 >= mMaxColumn) {
       // no much sense in delaying, we only have one slot left,
       // let's write a break now
       bool result = aOutputStr.Append(mLineBreak, mozilla::fallible);
       mColPos = 0;
       mIsIndentationAddedOnCurrentLine = false;
       mMayIgnoreLineBreakSequence = true;
       NS_ENSURE_TRUE(result, false);
     } else {
       // do not write out yet, we may write out either a space or a linebreak
       // let's delay writing it out until we know more
       mAddSpace = true;
       ++mColPos;  // eat a slot of available space
     }
   } else {
     // Asian text usually does not contain spaces, therefore we should not
     // transform a linebreak into a space.
     // Since we only saw linebreaks, but no spaces or tabs,
     // let's write a linebreak now.
     NS_ENSURE_TRUE(AppendNewLineToString(aOutputStr), false);
   }
 }

 return true;
}

bool nsXMLContentSerializer::AppendWrapped_NonWhitespaceSequence(
   nsAString::const_char_iterator& aPos,
   const nsAString::const_char_iterator aEnd,
   const nsAString::const_char_iterator aSequenceStart,
   bool& aMayIgnoreStartOfLineWhitespaceSequence,
   bool& aSequenceStartAfterAWhiteSpace, nsAString& aOutputStr) {
 mMayIgnoreLineBreakSequence = false;
 aMayIgnoreStartOfLineWhitespaceSequence = false;

 // Handle the complete sequence of non-whitespace in this block
 // Iterate until we find the first whitespace char or an aEnd condition
 // Updates "aPos" to point to the first unhandled char.
 // Also updates the aMayIgnoreStartOfLineWhitespaceSequence flag,
 // as well as the other "global" state flags.

 bool thisSequenceStartsAtBeginningOfLine = !mColPos;
 bool onceAgainBecauseWeAddedBreakInFront = false;
 bool foundWhitespaceInLoop;
 uint32_t length, colPos;

 do {
   if (mColPos) {
     colPos = mColPos;
   } else {
     if (mDoFormat && !mDoRaw && !PreLevel() &&
         !onceAgainBecauseWeAddedBreakInFront) {
       colPos = mIndent.Length();
     } else
       colPos = 0;
   }
   foundWhitespaceInLoop = false;
   length = 0;
   // we iterate until the next whitespace character
   // or until we reach the maximum of character per line
   // or until the end of the string to add.
   do {
     if (*aPos == ' ' || *aPos == '\t' || *aPos == '\n') {
       foundWhitespaceInLoop = true;
       break;
     }

     ++aPos;
     ++length;
   } while ((!mDoWrap || colPos + length < mMaxColumn) && aPos < aEnd);

   // in the case we don't reached the end of the string, but we reached the
   // maxcolumn, we see if there is a whitespace after the maxcolumn if yes,
   // then we can append directly the string instead of appending a new line
   // etc.
   if (*aPos == ' ' || *aPos == '\t' || *aPos == '\n') {
     foundWhitespaceInLoop = true;
   }

   if (aPos == aEnd || foundWhitespaceInLoop) {
     // there is enough room for the complete block we found
     if (mDoFormat && !mColPos) {
       NS_ENSURE_TRUE(AppendIndentation(aOutputStr), false);
     } else if (mAddSpace) {
       bool result = aOutputStr.Append(char16_t(' '), mozilla::fallible);
       mAddSpace = false;
       NS_ENSURE_TRUE(result, false);
     }

     mColPos += length;
     NS_ENSURE_TRUE(aOutputStr.Append(aSequenceStart, aPos - aSequenceStart,
                                      mozilla::fallible),
                    false);

     // We have not yet reached the max column, we will continue to
     // fill the current line in the next outer loop iteration
     // (this one in AppendToStringWrapped)
     // make sure we return in this outer loop
     onceAgainBecauseWeAddedBreakInFront = false;
   } else {  // we reach the max column
     if (!thisSequenceStartsAtBeginningOfLine &&
         (mAddSpace || (!mDoFormat && aSequenceStartAfterAWhiteSpace))) {
       // when !mDoFormat, mAddSpace is not used, mAddSpace is always false
       // so, in the case where mDoWrap && !mDoFormat, if we want to enter in
       // this condition...

       // We can avoid to wrap. We try to add the whole block
       // in an empty new line

       NS_ENSURE_TRUE(AppendNewLineToString(aOutputStr), false);
       aPos = aSequenceStart;
       thisSequenceStartsAtBeginningOfLine = true;
       onceAgainBecauseWeAddedBreakInFront = true;
     } else {
       // we must wrap
       onceAgainBecauseWeAddedBreakInFront = false;
       Maybe<uint32_t> wrapPosition;

       if (mAllowLineBreaking) {
         MOZ_ASSERT(aPos < aEnd,
                    "We shouldn't be here if aPos reaches the end of text!");

         // Search forward from aSequenceStart until we find the largest
         // wrap position less than or equal to aPos.
         Maybe<uint32_t> nextWrapPosition;
         Span<const char16_t> subSeq(aSequenceStart, aEnd);
         intl::LineBreakIteratorUtf16 lineBreakIter(subSeq);
         while (true) {
           nextWrapPosition = lineBreakIter.Next();
           MOZ_ASSERT(nextWrapPosition.isSome(),
                      "We should've exited the loop when reaching the end of "
                      "text in the previous iteration!");

           // Trim space at the tail. UAX#14 doesn't have break opportunity
           // for ASCII space at the tail.
           const Maybe<uint32_t> originalNextWrapPosition = nextWrapPosition;
           while (*nextWrapPosition > 0 &&
                  subSeq.at(*nextWrapPosition - 1) == 0x20) {
             nextWrapPosition = Some(*nextWrapPosition - 1);
           }
           if (*nextWrapPosition == 0) {
             // Restore the original nextWrapPosition.
             nextWrapPosition = originalNextWrapPosition;
           }

           if (aSequenceStart + *nextWrapPosition > aPos) {
             break;
           }
           wrapPosition = nextWrapPosition;
         }

         if (!wrapPosition) {
           // The wrap position found in the first iteration of the above loop
           // already exceeds aPos. We accept it as valid a wrap position only
           // if it is not end-of-text. If the line-breaker returned
           // end-of-text, we don't know that it is actually a good wrap
           // position, so ignore it and continue to use the fallback code
           // below.
           if (*nextWrapPosition < subSeq.Length()) {
             wrapPosition = nextWrapPosition;
           }
         }
       }

       if (wrapPosition) {
         if (!mColPos && mDoFormat) {
           NS_ENSURE_TRUE(AppendIndentation(aOutputStr), false);
         } else if (mAddSpace) {
           bool result = aOutputStr.Append(char16_t(' '), mozilla::fallible);
           mAddSpace = false;
           NS_ENSURE_TRUE(result, false);
         }
         NS_ENSURE_TRUE(aOutputStr.Append(aSequenceStart, *wrapPosition,
                                          mozilla::fallible),
                        false);

         NS_ENSURE_TRUE(AppendNewLineToString(aOutputStr), false);
         aPos = aSequenceStart + *wrapPosition;
         aMayIgnoreStartOfLineWhitespaceSequence = true;
       } else {
         // try some simple fallback logic
         // go forward up to the next whitespace position,
         // in the worst case this will be all the rest of the data

         // XXX(jfkthame) Should we (conditionally) output indentation here?
         // It makes for tidier-looking formatted output, at the cost of
         // exceeding the target width by a greater amount on such lines.
         // if (!mColPos && mDoFormat) {
         //   NS_ENSURE_TRUE(AppendIndentation(aOutputStr), false);
         //   mAddSpace = false;
         // }

         // we update the mColPos variable with the length of
         // the part already parsed.
         mColPos += length;

         // now try to find the next whitespace
         do {
           if (*aPos == ' ' || *aPos == '\t' || *aPos == '\n') {
             break;
           }

           ++aPos;
           ++mColPos;
         } while (aPos < aEnd);

         if (mAddSpace) {
           bool result = aOutputStr.Append(char16_t(' '), mozilla::fallible);
           mAddSpace = false;
           NS_ENSURE_TRUE(result, false);
         }
         NS_ENSURE_TRUE(
             aOutputStr.Append(aSequenceStart, aPos - aSequenceStart,
                               mozilla::fallible),
             false);
       }
     }
     aSequenceStartAfterAWhiteSpace = false;
   }
 } while (onceAgainBecauseWeAddedBreakInFront);

 return true;
}

bool nsXMLContentSerializer::AppendToStringFormatedWrapped(
   const nsAString& aStr, nsAString& aOutputStr) {
 if (mBodyOnly && !mInBody) {
   return true;
 }

 nsAString::const_char_iterator pos, end, sequenceStart;

 aStr.BeginReading(pos);
 aStr.EndReading(end);

 bool sequenceStartAfterAWhitespace = false;
 if (pos < end) {
   nsAString::const_char_iterator end2;
   aOutputStr.EndReading(end2);
   --end2;
   if (*end2 == ' ' || *end2 == '\n' || *end2 == '\t') {
     sequenceStartAfterAWhitespace = true;
   }
 }

 // if the current line already has text on it, such as a tag,
 // leading whitespace is significant
 bool mayIgnoreStartOfLineWhitespaceSequence =
     (!mColPos ||
      (mIsIndentationAddedOnCurrentLine && sequenceStartAfterAWhitespace &&
       uint32_t(mColPos) == mIndent.Length()));

 while (pos < end) {
   sequenceStart = pos;

   // if beginning of a whitespace sequence
   if (*pos == ' ' || *pos == '\n' || *pos == '\t') {
     NS_ENSURE_TRUE(AppendFormatedWrapped_WhitespaceSequence(
                        pos, end, sequenceStart,
                        mayIgnoreStartOfLineWhitespaceSequence, aOutputStr),
                    false);
   } else {  // any other non-whitespace char
     NS_ENSURE_TRUE(
         AppendWrapped_NonWhitespaceSequence(
             pos, end, sequenceStart, mayIgnoreStartOfLineWhitespaceSequence,
             sequenceStartAfterAWhitespace, aOutputStr),
         false);
   }
 }

 return true;
}

bool nsXMLContentSerializer::AppendWrapped_WhitespaceSequence(
   nsAString::const_char_iterator& aPos,
   const nsAString::const_char_iterator aEnd,
   const nsAString::const_char_iterator aSequenceStart,
   nsAString& aOutputStr) {
 // Handle the complete sequence of whitespace.
 // Continue to iterate until we find the first non-whitespace char.
 // Updates "aPos" to point to the first unhandled char.
 mAddSpace = false;
 mIsIndentationAddedOnCurrentLine = false;

 bool leaveLoop = false;
 nsAString::const_char_iterator lastPos = aPos;

 do {
   switch (*aPos) {
     case ' ':
     case '\t':
       // if there are too many spaces on a line, we wrap
       if (mColPos >= mMaxColumn) {
         if (lastPos != aPos) {
           NS_ENSURE_TRUE(
               aOutputStr.Append(lastPos, aPos - lastPos, mozilla::fallible),
               false);
         }
         NS_ENSURE_TRUE(AppendToString(mLineBreak, aOutputStr), false);
         mColPos = 0;
         lastPos = aPos;
       }

       ++mColPos;
       ++aPos;
       break;
     case '\n':
       if (lastPos != aPos) {
         NS_ENSURE_TRUE(
             aOutputStr.Append(lastPos, aPos - lastPos, mozilla::fallible),
             false);
       }
       NS_ENSURE_TRUE(AppendToString(mLineBreak, aOutputStr), false);
       mColPos = 0;
       ++aPos;
       lastPos = aPos;
       break;
     default:
       leaveLoop = true;
       break;
   }
 } while (!leaveLoop && aPos < aEnd);

 if (lastPos != aPos) {
   NS_ENSURE_TRUE(
       aOutputStr.Append(lastPos, aPos - lastPos, mozilla::fallible), false);
 }

 return true;
}

bool nsXMLContentSerializer::AppendToStringWrapped(const nsAString& aStr,
                                                  nsAString& aOutputStr) {
 if (mBodyOnly && !mInBody) {
   return true;
 }

 nsAString::const_char_iterator pos, end, sequenceStart;

 aStr.BeginReading(pos);
 aStr.EndReading(end);

 // not used in this case, but needed by AppendWrapped_NonWhitespaceSequence
 bool mayIgnoreStartOfLineWhitespaceSequence = false;
 mMayIgnoreLineBreakSequence = false;

 bool sequenceStartAfterAWhitespace = false;
 if (pos < end && !aOutputStr.IsEmpty()) {
   nsAString::const_char_iterator end2;
   aOutputStr.EndReading(end2);
   --end2;
   if (*end2 == ' ' || *end2 == '\n' || *end2 == '\t') {
     sequenceStartAfterAWhitespace = true;
   }
 }

 while (pos < end) {
   sequenceStart = pos;

   // if beginning of a whitespace sequence
   if (*pos == ' ' || *pos == '\n' || *pos == '\t') {
     sequenceStartAfterAWhitespace = true;
     NS_ENSURE_TRUE(
         AppendWrapped_WhitespaceSequence(pos, end, sequenceStart, aOutputStr),
         false);
   } else {  // any other non-whitespace char
     NS_ENSURE_TRUE(
         AppendWrapped_NonWhitespaceSequence(
             pos, end, sequenceStart, mayIgnoreStartOfLineWhitespaceSequence,
             sequenceStartAfterAWhitespace, aOutputStr),
         false);
   }
 }

 return true;
}

bool nsXMLContentSerializer::ShouldMaintainPreLevel() const {
 // Only attempt to maintain the pre level for consumers who care about it.
 return !mDoRaw || (mFlags & nsIDocumentEncoder::OutputNoFormattingInPre);
}

bool nsXMLContentSerializer::MaybeSerializeIsValue(Element* aElement,
                                                  nsAString& aStr) {
 CustomElementData* ceData = aElement->GetCustomElementData();
 if (ceData) {
   nsAtom* isAttr = ceData->GetIs(aElement);
   if (isAttr && !aElement->HasAttr(nsGkAtoms::is)) {
     NS_ENSURE_TRUE(aStr.AppendLiteral(" is=\"", mozilla::fallible), false);
     NS_ENSURE_TRUE(
         aStr.Append(nsDependentAtomString(isAttr), mozilla::fallible), false);
     NS_ENSURE_TRUE(aStr.AppendLiteral("\"", mozilla::fallible), false);
   }
 }

 return true;
}