third_party/blink/renderer/core/editing/serializers/markup_formatter.cc - chromium/src - Git at Google

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "third_party/blink/renderer/core/editing/serializers/markup_formatter.h"

 #include "base/stl_util.h"
 #include "third_party/blink/renderer/core/dom/cdata_section.h"
 #include "third_party/blink/renderer/core/dom/comment.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/dom/document_fragment.h"
 #include "third_party/blink/renderer/core/dom/document_type.h"
 #include "third_party/blink/renderer/core/dom/processing_instruction.h"
 #include "third_party/blink/renderer/core/editing/editing_utilities.h"
 #include "third_party/blink/renderer/core/editing/editor.h"
 #include "third_party/blink/renderer/core/html/html_element.h"
 #include "third_party/blink/renderer/core/html/html_template_element.h"
 #include "third_party/blink/renderer/core/html_names.h"
 #include "third_party/blink/renderer/core/xlink_names.h"
 #include "third_party/blink/renderer/core/xml_names.h"
 #include "third_party/blink/renderer/core/xmlns_names.h"
 #include "third_party/blink/renderer/platform/weborigin/kurl.h"
 #include "third_party/blink/renderer/platform/wtf/text/character_names.h"

 namespace blink {

 using namespace html_names;

 struct EntityDescription {
   UChar entity;
   const CString& reference;
   EntityMask mask;
 };

 template <typename CharType>
 static inline void AppendCharactersReplacingEntitiesInternal(
     StringBuilder& result,
     CharType* text,
     unsigned length,
     const EntityDescription entity_maps[],
     unsigned entity_maps_count,
     EntityMask entity_mask) {
   unsigned position_after_last_entity = 0;
   for (unsigned i = 0; i < length; ++i) {
     for (unsigned entity_index = 0; entity_index < entity_maps_count;
          ++entity_index) {
       if (text[i] == entity_maps[entity_index].entity &&
           entity_maps[entity_index].mask & entity_mask) {
         result.Append(text + position_after_last_entity,
                       i - position_after_last_entity);
         const CString& replacement = entity_maps[entity_index].reference;
         result.Append(replacement.data(), replacement.length());
         position_after_last_entity = i + 1;
         break;
       }
     }
   }
   result.Append(text + position_after_last_entity,
                 length - position_after_last_entity);
 }

 void MarkupFormatter::AppendCharactersReplacingEntities(
     StringBuilder& result,
     const String& source,
     unsigned offset,
     unsigned length,
     EntityMask entity_mask) {
   DEFINE_STATIC_LOCAL(const CString, amp_reference, ("&amp;"));
   DEFINE_STATIC_LOCAL(const CString, lt_reference, ("&lt;"));
   DEFINE_STATIC_LOCAL(const CString, gt_reference, ("&gt;"));
   DEFINE_STATIC_LOCAL(const CString, quot_reference, ("&quot;"));
   DEFINE_STATIC_LOCAL(const CString, nbsp_reference, ("&nbsp;"));
   DEFINE_STATIC_LOCAL(const CString, tab_reference, ("&#9;"));
   DEFINE_STATIC_LOCAL(const CString, line_feed_reference, ("&#10;"));
   DEFINE_STATIC_LOCAL(const CString, carriage_return_reference, ("&#13;"));

   static const EntityDescription kEntityMaps[] = {
       {'&', amp_reference, kEntityAmp},
       {'<', lt_reference, kEntityLt},
       {'>', gt_reference, kEntityGt},
       {'"', quot_reference, kEntityQuot},
       {kNoBreakSpaceCharacter, nbsp_reference, kEntityNbsp},
       {'\t', tab_reference, kEntityTab},
       {'\n', line_feed_reference, kEntityLineFeed},
       {'\r', carriage_return_reference, kEntityCarriageReturn},
   };

   if (!(offset + length))
     return;

   DCHECK_LE(offset + length, source.length());
   if (source.Is8Bit()) {
     AppendCharactersReplacingEntitiesInternal(
         result, source.Characters8() + offset, length, kEntityMaps,
         base::size(kEntityMaps), entity_mask);
   } else {
     AppendCharactersReplacingEntitiesInternal(
         result, source.Characters16() + offset, length, kEntityMaps,
         base::size(kEntityMaps), entity_mask);
   }
 }

 MarkupFormatter::MarkupFormatter(EAbsoluteURLs resolve_urls_method,
                                  SerializationType serialization_type)
     : resolve_urls_method_(resolve_urls_method),
       serialization_type_(serialization_type) {}

 MarkupFormatter::~MarkupFormatter() = default;

 String MarkupFormatter::ResolveURLIfNeeded(const Element& element,
                                            const String& url_string) const {
   switch (resolve_urls_method_) {
     case kResolveAllURLs:
       return element.GetDocument().CompleteURL(url_string).GetString();

     case kResolveNonLocalURLs:
       if (!element.GetDocument().Url().IsLocalFile())
         return element.GetDocument().CompleteURL(url_string).GetString();
       break;

     case kDoNotResolveURLs:
       break;
   }
   return url_string;
 }

 void MarkupFormatter::AppendStartMarkup(StringBuilder& result,
                                         const Node& node,
                                         Namespaces* namespaces) {
   switch (node.getNodeType()) {
     case Node::kTextNode:
       NOTREACHED();
       break;
     case Node::kCommentNode:
       AppendComment(result, ToComment(node).data());
       break;
     case Node::kDocumentNode:
       AppendXMLDeclaration(result, To<Document>(node));
       break;
     case Node::kDocumentFragmentNode:
       break;
     case Node::kDocumentTypeNode:
       AppendDocumentType(result, ToDocumentType(node));
       break;
     case Node::kProcessingInstructionNode:
       AppendProcessingInstruction(result,
                                   ToProcessingInstruction(node).target(),
                                   ToProcessingInstruction(node).data());
       break;
     case Node::kElementNode:
       NOTREACHED();
       break;
     case Node::kCdataSectionNode:
       AppendCDATASection(result, ToCDATASection(node).data());
       break;
     case Node::kAttributeNode:
       NOTREACHED();
       break;
   }
 }

 void MarkupFormatter::AppendEndMarkup(StringBuilder& result,
                                       const Element& element) {
   if (ShouldSelfClose(element) ||
       (!element.HasChildren() && ElementCannotHaveEndTag(element)))
     return;

   result.Append("</");
   result.Append(element.TagQName().ToString());
   result.Append('>');
 }

 void MarkupFormatter::AppendAttributeValue(StringBuilder& result,
                                            const String& attribute,
                                            bool document_is_html) {
   AppendCharactersReplacingEntities(result, attribute, 0, attribute.length(),
                                     document_is_html
                                         ? kEntityMaskInHTMLAttributeValue
                                         : kEntityMaskInAttributeValue);
 }

 void MarkupFormatter::AppendQuotedURLAttributeValue(
     StringBuilder& result,
     const Element& element,
     const Attribute& attribute) {
   DCHECK(element.IsURLAttribute(attribute)) << element;
   String resolved_url_string = ResolveURLIfNeeded(element, attribute.Value());
   UChar quote_char = '"';
   if (ProtocolIsJavaScript(resolved_url_string)) {
     // minimal escaping for javascript urls
     if (resolved_url_string.Contains('&'))
       resolved_url_string.Replace('&', "&amp;");

     if (resolved_url_string.Contains('"')) {
       if (resolved_url_string.Contains('\''))
         resolved_url_string.Replace('"', "&quot;");
       else
         quote_char = '\'';
     }
     result.Append(quote_char);
     result.Append(resolved_url_string);
     result.Append(quote_char);
     return;
   }

   // FIXME: This does not fully match other browsers. Firefox percent-escapes
   // non-ASCII characters for innerHTML.
   result.Append(quote_char);
   AppendAttributeValue(result, resolved_url_string, false);
   result.Append(quote_char);
 }

 void MarkupFormatter::AppendNamespace(StringBuilder& result,
                                       const AtomicString& prefix,
                                       const AtomicString& namespace_uri,
                                       Namespaces& namespaces) {
   const AtomicString& lookup_key = (!prefix) ? g_empty_atom : prefix;
   AtomicString found_uri = namespaces.at(lookup_key);
   if (!EqualIgnoringNullity(found_uri, namespace_uri)) {
     namespaces.Set(lookup_key, namespace_uri);
     result.Append(' ');
     result.Append(g_xmlns_atom.GetString());
     if (!prefix.IsEmpty()) {
       result.Append(':');
       result.Append(prefix);
     }

     result.Append("=\"");
     AppendAttributeValue(result, namespace_uri, false);
     result.Append('"');
   }
 }

 void MarkupFormatter::AppendText(StringBuilder& result, Text& text) {
   const String& str = text.data();
   AppendCharactersReplacingEntities(result, str, 0, str.length(),
                                     EntityMaskForText(text));
 }

 void MarkupFormatter::AppendComment(StringBuilder& result,
                                     const String& comment) {
   // FIXME: Comment content is not escaped, but XMLSerializer (and possibly
   // other callers) should raise an exception if it includes "-->".
   result.Append("<!--");
   result.Append(comment);
   result.Append("-->");
 }

 void MarkupFormatter::AppendXMLDeclaration(StringBuilder& result,
                                            const Document& document) {
   if (!document.HasXMLDeclaration())
     return;

   result.Append("<?xml version=\"");
   result.Append(document.xmlVersion());
   const String& encoding = document.xmlEncoding();
   if (!encoding.IsEmpty()) {
     result.Append("\" encoding=\"");
     result.Append(encoding);
   }
   if (document.XmlStandaloneStatus() != Document::kStandaloneUnspecified) {
     result.Append("\" standalone=\"");
     if (document.xmlStandalone())
       result.Append("yes");
     else
       result.Append("no");
   }

   result.Append("\"?>");
 }

 void MarkupFormatter::AppendDocumentType(StringBuilder& result,
                                          const DocumentType& n) {
   if (n.name().IsEmpty())
     return;

   result.Append("<!DOCTYPE ");
   result.Append(n.name());
   if (!n.publicId().IsEmpty()) {
     result.Append(" PUBLIC \"");
     result.Append(n.publicId());
     result.Append('"');
     if (!n.systemId().IsEmpty()) {
       result.Append(" \"");
       result.Append(n.systemId());
       result.Append('"');
     }
   } else if (!n.systemId().IsEmpty()) {
     result.Append(" SYSTEM \"");
     result.Append(n.systemId());
     result.Append('"');
   }
   result.Append('>');
 }

 void MarkupFormatter::AppendProcessingInstruction(StringBuilder& result,
                                                   const String& target,
                                                   const String& data) {
   // FIXME: PI data is not escaped, but XMLSerializer (and possibly other
   // callers) this should raise an exception if it includes "?>".
   result.Append("<?");
   result.Append(target);
   result.Append(' ');
   result.Append(data);
   result.Append("?>");
 }

 void MarkupFormatter::AppendOpenTag(StringBuilder& result,
                                     const Element& element,
                                     Namespaces* namespaces) {
   result.Append('<');
   result.Append(element.TagQName().ToString());
   if (!SerializeAsHTMLDocument(element) && namespaces &&
       ShouldAddNamespaceElement(element, *namespaces))
     AppendNamespace(result, element.prefix(), element.namespaceURI(),
                     *namespaces);
 }

 void MarkupFormatter::AppendCloseTag(StringBuilder& result,
                                      const Element& element) {
   if (ShouldSelfClose(element)) {
     if (element.IsHTMLElement())
       result.Append(' ');  // XHTML 1.0 <-> HTML compatibility.
     result.Append('/');
   }
   result.Append('>');
 }

 void MarkupFormatter::AppendAttribute(StringBuilder& result,
                                       const Element& element,
                                       const Attribute& attribute,
                                       Namespaces* namespaces) {
   bool document_is_html = SerializeAsHTMLDocument(element);

   if (document_is_html) {
     // https://html.spec.whatwg.org/multipage/parsing.html#attribute's-serialised-name
     QualifiedName prefixed_name = attribute.GetName();
     if (attribute.NamespaceURI() == xmlns_names::kNamespaceURI) {
       if (!attribute.Prefix() && attribute.LocalName() != g_xmlns_atom)
         prefixed_name.SetPrefix(g_xmlns_atom);
     } else if (attribute.NamespaceURI() == xml_names::kNamespaceURI) {
       prefixed_name.SetPrefix(g_xml_atom);
     } else if (attribute.NamespaceURI() == xlink_names::kNamespaceURI) {
       prefixed_name.SetPrefix(g_xlink_atom);
     }
     result.Append(' ');
     result.Append(prefixed_name.ToString());
   } else {
     // https://w3c.github.io/DOM-Parsing/#serializing-an-element-s-attributes

     // 3.3. Let attribute namespace be the value of attr's namespaceURI value.
     const AtomicString& attribute_namespace = attribute.NamespaceURI();

     // 3.4. Let candidate prefix be null.
     AtomicString candidate_prefix;

     // 3.5. If attribute namespace is not null, then run these sub-steps:

     // 3.5.1. Let candidate prefix be the result of retrieving a preferred
     // prefix string from map given namespace attribute namespace with preferred
     // prefix being attr's prefix value.
     // TODO(tkent): Implement it. crbug.com/906807
     candidate_prefix = attribute.Prefix();

     // 3.5.2. If the value of attribute namespace is the XMLNS namespace, then
     // run these steps:
     if (attribute_namespace == xmlns_names::kNamespaceURI) {
       if (!attribute.Prefix() && attribute.LocalName() != g_xmlns_atom)
         candidate_prefix = g_xmlns_atom;
       // Account for the namespace attribute we're about to append.
       if (namespaces) {
         const AtomicString& lookup_key =
             (!attribute.Prefix()) ? g_empty_atom : attribute.LocalName();
         namespaces->Set(lookup_key, attribute.Value());
       }
     } else if (attribute_namespace == xml_names::kNamespaceURI) {
       if (!candidate_prefix)
         candidate_prefix = g_xml_atom;
     } else {
       if (attribute_namespace == xlink_names::kNamespaceURI) {
         if (!candidate_prefix)
           candidate_prefix = g_xlink_atom;
       }

       // 3.5.3. Otherwise, the attribute namespace in not the XMLNS namespace.
       // Run these steps:
       if (namespaces && ShouldAddNamespaceAttribute(attribute, element)) {
         if (!candidate_prefix) {
           // This behavior is in process of being standardized. See
           // crbug.com/248044 and
           // https://www.w3.org/Bugs/Public/show_bug.cgi?id=24208
           String prefix_prefix("ns", 2u);
           for (unsigned i = attribute_namespace.Impl()->ExistingHash();; ++i) {
             AtomicString new_prefix(String(prefix_prefix + String::Number(i)));
             AtomicString found_uri = namespaces->at(new_prefix);
             if (found_uri == attribute_namespace || found_uri == g_null_atom) {
               // We already generated a prefix for this namespace.
               candidate_prefix = new_prefix;
               break;
             }
           }
         }
         // 3.5.3.2. Append the following to result, in the order listed:
         DCHECK(candidate_prefix);
         AppendNamespace(result, candidate_prefix, attribute_namespace,
                         *namespaces);
       }
     }
     // 3.6. Append a " " (U+0020 SPACE) to result.
     result.Append(' ');
     // 3.7. If candidate prefix is not null, then append to result the
     // concatenation of candidate prefix with ":" (U+003A COLON).
     if (candidate_prefix) {
       result.Append(candidate_prefix);
       result.Append(':');
     }
     // 3.9.1. The value of attr's localName;
     result.Append(attribute.LocalName());
   }

   result.Append('=');

   if (element.IsURLAttribute(attribute)) {
     AppendQuotedURLAttributeValue(result, element, attribute);
   } else {
     result.Append('"');
     AppendAttributeValue(result, attribute.Value(), document_is_html);
     result.Append('"');
   }
 }

 void MarkupFormatter::AppendCDATASection(StringBuilder& result,
                                          const String& section) {
   // FIXME: CDATA content is not escaped, but XMLSerializer (and possibly other
   // callers) should raise an exception if it includes "]]>".
   result.Append("<![CDATA[");
   result.Append(section);
   result.Append("]]>");
 }

 bool MarkupFormatter::ShouldAddNamespaceElement(const Element& element,
                                                 Namespaces& namespaces) const {
   // Don't add namespace attribute if it is already defined for this elem.
   const AtomicString& prefix = element.prefix();
   if (prefix.IsEmpty()) {
     if (element.hasAttribute(g_xmlns_atom)) {
       namespaces.Set(g_empty_atom, element.namespaceURI());
       return false;
     }
     return true;
   }

   return !element.hasAttribute(WTF::g_xmlns_with_colon + prefix);
 }

 bool MarkupFormatter::ShouldAddNamespaceAttribute(
     const Attribute& attribute,
     const Element& element) const {
   // xmlns and xmlns:prefix attributes should be handled by another branch in
   // appendAttribute.
   DCHECK_NE(attribute.NamespaceURI(), xmlns_names::kNamespaceURI);

   // Attributes are in the null namespace by default.
   if (!attribute.NamespaceURI())
     return false;

   // Attributes without a prefix will need one generated for them, and an xmlns
   // attribute for that prefix.
   if (!attribute.Prefix())
     return true;

   return !element.hasAttribute(WTF::g_xmlns_with_colon + attribute.Prefix());
 }

 EntityMask MarkupFormatter::EntityMaskForText(const Text& text) const {
   if (!SerializeAsHTMLDocument(text))
     return kEntityMaskInPCDATA;

   // TODO(hajimehoshi): We need to switch EditingStrategy.
   const QualifiedName* parent_name = nullptr;
   if (text.parentElement())
     parent_name = &(text.parentElement())->TagQName();

   if (parent_name &&
       (*parent_name == kScriptTag || *parent_name == kStyleTag ||
        *parent_name == kXmpTag || *parent_name == kIFrameTag ||
        *parent_name == kPlaintextTag || *parent_name == kNoembedTag ||
        *parent_name == kNoframesTag ||
        (*parent_name == kNoscriptTag && text.GetDocument().GetFrame() &&
         text.GetDocument().CanExecuteScripts(kNotAboutToExecuteScript))))
     return kEntityMaskInCDATA;
   return kEntityMaskInHTMLPCDATA;
 }

 // Rules of self-closure
 // 1. No elements in HTML documents use the self-closing syntax.
 // 2. Elements w/ children never self-close because they use a separate end tag.
 // 3. HTML elements which do not listed in spec will close with a
 // separate end tag.
 // 4. Other elements self-close.
 bool MarkupFormatter::ShouldSelfClose(const Element& element) const {
   if (SerializeAsHTMLDocument(element))
     return false;
   if (element.HasChildren())
     return false;
   if (element.IsHTMLElement() && !ElementCannotHaveEndTag(element))
     return false;
   return true;
 }

 bool MarkupFormatter::SerializeAsHTMLDocument(const Node& node) const {
   if (serialization_type_ == SerializationType::kForcedXML)
     return false;
   return node.GetDocument().IsHTMLDocument();
 }

 }  // namespace blink
	/*
	* Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights
	* reserved.
	* Copyright (C) 2009, 2010 Google Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "third_party/blink/renderer/core/editing/serializers/markup_formatter.h"

	#include "base/stl_util.h"
	#include "third_party/blink/renderer/core/dom/cdata_section.h"
	#include "third_party/blink/renderer/core/dom/comment.h"
	#include "third_party/blink/renderer/core/dom/document.h"
	#include "third_party/blink/renderer/core/dom/document_fragment.h"
	#include "third_party/blink/renderer/core/dom/document_type.h"
	#include "third_party/blink/renderer/core/dom/processing_instruction.h"
	#include "third_party/blink/renderer/core/editing/editing_utilities.h"
	#include "third_party/blink/renderer/core/editing/editor.h"
	#include "third_party/blink/renderer/core/html/html_element.h"
	#include "third_party/blink/renderer/core/html/html_template_element.h"
	#include "third_party/blink/renderer/core/html_names.h"
	#include "third_party/blink/renderer/core/xlink_names.h"
	#include "third_party/blink/renderer/core/xml_names.h"
	#include "third_party/blink/renderer/core/xmlns_names.h"
	#include "third_party/blink/renderer/platform/weborigin/kurl.h"
	#include "third_party/blink/renderer/platform/wtf/text/character_names.h"

	namespace blink {

	using namespace html_names;

	struct EntityDescription {
	UChar entity;
	const CString& reference;
	EntityMask mask;
	};

	template <typename CharType>
	static inline void AppendCharactersReplacingEntitiesInternal(
	StringBuilder& result,
	CharType* text,
	unsigned length,
	const EntityDescription entity_maps[],
	unsigned entity_maps_count,
	EntityMask entity_mask) {
	unsigned position_after_last_entity = 0;
	for (unsigned i = 0; i < length; ++i) {
	for (unsigned entity_index = 0; entity_index < entity_maps_count;
	++entity_index) {
	if (text[i] == entity_maps[entity_index].entity &&
	entity_maps[entity_index].mask & entity_mask) {
	result.Append(text + position_after_last_entity,
	i - position_after_last_entity);
	const CString& replacement = entity_maps[entity_index].reference;
	result.Append(replacement.data(), replacement.length());
	position_after_last_entity = i + 1;
	break;
	}
	}
	}
	result.Append(text + position_after_last_entity,
	length - position_after_last_entity);
	}

	void MarkupFormatter::AppendCharactersReplacingEntities(
	StringBuilder& result,
	const String& source,
	unsigned offset,
	unsigned length,
	EntityMask entity_mask) {
	DEFINE_STATIC_LOCAL(const CString, amp_reference, ("&"));
	DEFINE_STATIC_LOCAL(const CString, lt_reference, ("<"));
	DEFINE_STATIC_LOCAL(const CString, gt_reference, (">"));
	DEFINE_STATIC_LOCAL(const CString, quot_reference, ("""));
	DEFINE_STATIC_LOCAL(const CString, nbsp_reference, (" "));
	DEFINE_STATIC_LOCAL(const CString, tab_reference, (" "));
	DEFINE_STATIC_LOCAL(const CString, line_feed_reference, (" "));
	DEFINE_STATIC_LOCAL(const CString, carriage_return_reference, (" "));

	static const EntityDescription kEntityMaps[] = {
	{'&', amp_reference, kEntityAmp},
	{'<', lt_reference, kEntityLt},
	{'>', gt_reference, kEntityGt},
	{'"', quot_reference, kEntityQuot},
	{kNoBreakSpaceCharacter, nbsp_reference, kEntityNbsp},
	{'\t', tab_reference, kEntityTab},
	{'\n', line_feed_reference, kEntityLineFeed},
	{'\r', carriage_return_reference, kEntityCarriageReturn},
	};

	if (!(offset + length))
	return;

	DCHECK_LE(offset + length, source.length());
	if (source.Is8Bit()) {
	AppendCharactersReplacingEntitiesInternal(
	result, source.Characters8() + offset, length, kEntityMaps,
	base::size(kEntityMaps), entity_mask);
	} else {
	AppendCharactersReplacingEntitiesInternal(
	result, source.Characters16() + offset, length, kEntityMaps,
	base::size(kEntityMaps), entity_mask);
	}
	}

	MarkupFormatter::MarkupFormatter(EAbsoluteURLs resolve_urls_method,
	SerializationType serialization_type)
	: resolve_urls_method_(resolve_urls_method),
	serialization_type_(serialization_type) {}

	MarkupFormatter::~MarkupFormatter() = default;

	String MarkupFormatter::ResolveURLIfNeeded(const Element& element,
	const String& url_string) const {
	switch (resolve_urls_method_) {
	case kResolveAllURLs:
	return element.GetDocument().CompleteURL(url_string).GetString();

	case kResolveNonLocalURLs:
	if (!element.GetDocument().Url().IsLocalFile())
	return element.GetDocument().CompleteURL(url_string).GetString();
	break;

	case kDoNotResolveURLs:
	break;
	}
	return url_string;
	}

	void MarkupFormatter::AppendStartMarkup(StringBuilder& result,
	const Node& node,
	Namespaces* namespaces) {
	switch (node.getNodeType()) {
	case Node::kTextNode:
	NOTREACHED();
	break;
	case Node::kCommentNode:
	AppendComment(result, ToComment(node).data());
	break;
	case Node::kDocumentNode:
	AppendXMLDeclaration(result, To<Document>(node));
	break;
	case Node::kDocumentFragmentNode:
	break;
	case Node::kDocumentTypeNode:
	AppendDocumentType(result, ToDocumentType(node));
	break;
	case Node::kProcessingInstructionNode:
	AppendProcessingInstruction(result,
	ToProcessingInstruction(node).target(),
	ToProcessingInstruction(node).data());
	break;
	case Node::kElementNode:
	NOTREACHED();
	break;
	case Node::kCdataSectionNode:
	AppendCDATASection(result, ToCDATASection(node).data());
	break;
	case Node::kAttributeNode:
	NOTREACHED();
	break;
	}
	}

	void MarkupFormatter::AppendEndMarkup(StringBuilder& result,
	const Element& element) {
	if (ShouldSelfClose(element) \|\|
	(!element.HasChildren() && ElementCannotHaveEndTag(element)))
	return;

	result.Append("</");
	result.Append(element.TagQName().ToString());
	result.Append('>');
	}

	void MarkupFormatter::AppendAttributeValue(StringBuilder& result,
	const String& attribute,
	bool document_is_html) {
	AppendCharactersReplacingEntities(result, attribute, 0, attribute.length(),
	document_is_html
	? kEntityMaskInHTMLAttributeValue
	: kEntityMaskInAttributeValue);
	}

	void MarkupFormatter::AppendQuotedURLAttributeValue(
	StringBuilder& result,
	const Element& element,
	const Attribute& attribute) {
	DCHECK(element.IsURLAttribute(attribute)) << element;
	String resolved_url_string = ResolveURLIfNeeded(element, attribute.Value());
	UChar quote_char = '"';
	if (ProtocolIsJavaScript(resolved_url_string)) {
	// minimal escaping for javascript urls
	if (resolved_url_string.Contains('&'))
	resolved_url_string.Replace('&', "&");

	if (resolved_url_string.Contains('"')) {
	if (resolved_url_string.Contains('\''))
	resolved_url_string.Replace('"', """);
	else
	quote_char = '\'';
	}
	result.Append(quote_char);
	result.Append(resolved_url_string);
	result.Append(quote_char);
	return;
	}

	// FIXME: This does not fully match other browsers. Firefox percent-escapes
	// non-ASCII characters for innerHTML.
	result.Append(quote_char);
	AppendAttributeValue(result, resolved_url_string, false);
	result.Append(quote_char);
	}

	void MarkupFormatter::AppendNamespace(StringBuilder& result,
	const AtomicString& prefix,
	const AtomicString& namespace_uri,
	Namespaces& namespaces) {
	const AtomicString& lookup_key = (!prefix) ? g_empty_atom : prefix;
	AtomicString found_uri = namespaces.at(lookup_key);
	if (!EqualIgnoringNullity(found_uri, namespace_uri)) {
	namespaces.Set(lookup_key, namespace_uri);
	result.Append(' ');
	result.Append(g_xmlns_atom.GetString());
	if (!prefix.IsEmpty()) {
	result.Append(':');
	result.Append(prefix);
	}

	result.Append("=\"");
	AppendAttributeValue(result, namespace_uri, false);
	result.Append('"');
	}
	}

	void MarkupFormatter::AppendText(StringBuilder& result, Text& text) {
	const String& str = text.data();
	AppendCharactersReplacingEntities(result, str, 0, str.length(),
	EntityMaskForText(text));
	}

	void MarkupFormatter::AppendComment(StringBuilder& result,
	const String& comment) {
	// FIXME: Comment content is not escaped, but XMLSerializer (and possibly
	// other callers) should raise an exception if it includes "-->".
	result.Append("<!--");
	result.Append(comment);
	result.Append("-->");
	}

	void MarkupFormatter::AppendXMLDeclaration(StringBuilder& result,
	const Document& document) {
	if (!document.HasXMLDeclaration())
	return;

	result.Append("<?xml version=\"");
	result.Append(document.xmlVersion());
	const String& encoding = document.xmlEncoding();
	if (!encoding.IsEmpty()) {
	result.Append("\" encoding=\"");
	result.Append(encoding);
	}
	if (document.XmlStandaloneStatus() != Document::kStandaloneUnspecified) {
	result.Append("\" standalone=\"");
	if (document.xmlStandalone())
	result.Append("yes");
	else
	result.Append("no");
	}

	result.Append("\"?>");
	}

	void MarkupFormatter::AppendDocumentType(StringBuilder& result,
	const DocumentType& n) {
	if (n.name().IsEmpty())
	return;

	result.Append("<!DOCTYPE ");
	result.Append(n.name());
	if (!n.publicId().IsEmpty()) {
	result.Append(" PUBLIC \"");
	result.Append(n.publicId());
	result.Append('"');
	if (!n.systemId().IsEmpty()) {
	result.Append(" \"");
	result.Append(n.systemId());
	result.Append('"');
	}
	} else if (!n.systemId().IsEmpty()) {
	result.Append(" SYSTEM \"");
	result.Append(n.systemId());
	result.Append('"');
	}
	result.Append('>');
	}

	void MarkupFormatter::AppendProcessingInstruction(StringBuilder& result,
	const String& target,
	const String& data) {
	// FIXME: PI data is not escaped, but XMLSerializer (and possibly other
	// callers) this should raise an exception if it includes "?>".
	result.Append("<?");
	result.Append(target);
	result.Append(' ');
	result.Append(data);
	result.Append("?>");
	}

	void MarkupFormatter::AppendOpenTag(StringBuilder& result,
	const Element& element,
	Namespaces* namespaces) {
	result.Append('<');
	result.Append(element.TagQName().ToString());
	if (!SerializeAsHTMLDocument(element) && namespaces &&
	ShouldAddNamespaceElement(element, *namespaces))
	AppendNamespace(result, element.prefix(), element.namespaceURI(),
	*namespaces);
	}

	void MarkupFormatter::AppendCloseTag(StringBuilder& result,
	const Element& element) {
	if (ShouldSelfClose(element)) {
	if (element.IsHTMLElement())
	result.Append(' '); // XHTML 1.0 <-> HTML compatibility.
	result.Append('/');
	}
	result.Append('>');
	}

	void MarkupFormatter::AppendAttribute(StringBuilder& result,
	const Element& element,
	const Attribute& attribute,
	Namespaces* namespaces) {
	bool document_is_html = SerializeAsHTMLDocument(element);

	if (document_is_html) {
	// https://html.spec.whatwg.org/multipage/parsing.html#attribute's-serialised-name
	QualifiedName prefixed_name = attribute.GetName();
	if (attribute.NamespaceURI() == xmlns_names::kNamespaceURI) {
	if (!attribute.Prefix() && attribute.LocalName() != g_xmlns_atom)
	prefixed_name.SetPrefix(g_xmlns_atom);
	} else if (attribute.NamespaceURI() == xml_names::kNamespaceURI) {
	prefixed_name.SetPrefix(g_xml_atom);
	} else if (attribute.NamespaceURI() == xlink_names::kNamespaceURI) {
	prefixed_name.SetPrefix(g_xlink_atom);
	}
	result.Append(' ');
	result.Append(prefixed_name.ToString());
	} else {
	// https://w3c.github.io/DOM-Parsing/#serializing-an-element-s-attributes

	// 3.3. Let attribute namespace be the value of attr's namespaceURI value.
	const AtomicString& attribute_namespace = attribute.NamespaceURI();

	// 3.4. Let candidate prefix be null.
	AtomicString candidate_prefix;

	// 3.5. If attribute namespace is not null, then run these sub-steps:

	// 3.5.1. Let candidate prefix be the result of retrieving a preferred
	// prefix string from map given namespace attribute namespace with preferred
	// prefix being attr's prefix value.
	// TODO(tkent): Implement it. crbug.com/906807
	candidate_prefix = attribute.Prefix();

	// 3.5.2. If the value of attribute namespace is the XMLNS namespace, then
	// run these steps:
	if (attribute_namespace == xmlns_names::kNamespaceURI) {
	if (!attribute.Prefix() && attribute.LocalName() != g_xmlns_atom)
	candidate_prefix = g_xmlns_atom;
	// Account for the namespace attribute we're about to append.
	if (namespaces) {
	const AtomicString& lookup_key =
	(!attribute.Prefix()) ? g_empty_atom : attribute.LocalName();
	namespaces->Set(lookup_key, attribute.Value());
	}
	} else if (attribute_namespace == xml_names::kNamespaceURI) {
	if (!candidate_prefix)
	candidate_prefix = g_xml_atom;
	} else {
	if (attribute_namespace == xlink_names::kNamespaceURI) {
	if (!candidate_prefix)
	candidate_prefix = g_xlink_atom;
	}

	// 3.5.3. Otherwise, the attribute namespace in not the XMLNS namespace.
	// Run these steps:
	if (namespaces && ShouldAddNamespaceAttribute(attribute, element)) {
	if (!candidate_prefix) {
	// This behavior is in process of being standardized. See
	// crbug.com/248044 and
	// https://www.w3.org/Bugs/Public/show_bug.cgi?id=24208
	String prefix_prefix("ns", 2u);
	for (unsigned i = attribute_namespace.Impl()->ExistingHash();; ++i) {
	AtomicString new_prefix(String(prefix_prefix + String::Number(i)));
	AtomicString found_uri = namespaces->at(new_prefix);
	if (found_uri == attribute_namespace \|\| found_uri == g_null_atom) {
	// We already generated a prefix for this namespace.
	candidate_prefix = new_prefix;
	break;
	}
	}
	}
	// 3.5.3.2. Append the following to result, in the order listed:
	DCHECK(candidate_prefix);
	AppendNamespace(result, candidate_prefix, attribute_namespace,
	*namespaces);
	}
	}
	// 3.6. Append a " " (U+0020 SPACE) to result.
	result.Append(' ');
	// 3.7. If candidate prefix is not null, then append to result the
	// concatenation of candidate prefix with ":" (U+003A COLON).
	if (candidate_prefix) {
	result.Append(candidate_prefix);
	result.Append(':');
	}
	// 3.9.1. The value of attr's localName;
	result.Append(attribute.LocalName());
	}

	result.Append('=');

	if (element.IsURLAttribute(attribute)) {
	AppendQuotedURLAttributeValue(result, element, attribute);
	} else {
	result.Append('"');
	AppendAttributeValue(result, attribute.Value(), document_is_html);
	result.Append('"');
	}
	}

	void MarkupFormatter::AppendCDATASection(StringBuilder& result,
	const String& section) {
	// FIXME: CDATA content is not escaped, but XMLSerializer (and possibly other
	// callers) should raise an exception if it includes "]]>".
	result.Append("<![CDATA[");
	result.Append(section);
	result.Append("]]>");
	}

	bool MarkupFormatter::ShouldAddNamespaceElement(const Element& element,
	Namespaces& namespaces) const {
	// Don't add namespace attribute if it is already defined for this elem.
	const AtomicString& prefix = element.prefix();
	if (prefix.IsEmpty()) {
	if (element.hasAttribute(g_xmlns_atom)) {
	namespaces.Set(g_empty_atom, element.namespaceURI());
	return false;
	}
	return true;
	}

	return !element.hasAttribute(WTF::g_xmlns_with_colon + prefix);
	}

	bool MarkupFormatter::ShouldAddNamespaceAttribute(
	const Attribute& attribute,
	const Element& element) const {
	// xmlns and xmlns:prefix attributes should be handled by another branch in
	// appendAttribute.
	DCHECK_NE(attribute.NamespaceURI(), xmlns_names::kNamespaceURI);

	// Attributes are in the null namespace by default.
	if (!attribute.NamespaceURI())
	return false;

	// Attributes without a prefix will need one generated for them, and an xmlns
	// attribute for that prefix.
	if (!attribute.Prefix())
	return true;

	return !element.hasAttribute(WTF::g_xmlns_with_colon + attribute.Prefix());
	}

	EntityMask MarkupFormatter::EntityMaskForText(const Text& text) const {
	if (!SerializeAsHTMLDocument(text))
	return kEntityMaskInPCDATA;

	// TODO(hajimehoshi): We need to switch EditingStrategy.
	const QualifiedName* parent_name = nullptr;
	if (text.parentElement())
	parent_name = &(text.parentElement())->TagQName();

	if (parent_name &&
	(parent_name == kScriptTag \|\| parent_name == kStyleTag \|\|
	parent_name == kXmpTag \|\| parent_name == kIFrameTag \|\|
	parent_name == kPlaintextTag \|\| parent_name == kNoembedTag \|\|
	*parent_name == kNoframesTag \|\|
	(*parent_name == kNoscriptTag && text.GetDocument().GetFrame() &&
	text.GetDocument().CanExecuteScripts(kNotAboutToExecuteScript))))
	return kEntityMaskInCDATA;
	return kEntityMaskInHTMLPCDATA;
	}

	// Rules of self-closure
	// 1. No elements in HTML documents use the self-closing syntax.
	// 2. Elements w/ children never self-close because they use a separate end tag.
	// 3. HTML elements which do not listed in spec will close with a
	// separate end tag.
	// 4. Other elements self-close.
	bool MarkupFormatter::ShouldSelfClose(const Element& element) const {
	if (SerializeAsHTMLDocument(element))
	return false;
	if (element.HasChildren())
	return false;
	if (element.IsHTMLElement() && !ElementCannotHaveEndTag(element))
	return false;
	return true;
	}

	bool MarkupFormatter::SerializeAsHTMLDocument(const Node& node) const {
	if (serialization_type_ == SerializationType::kForcedXML)
	return false;
	return node.GetDocument().IsHTMLDocument();
	}

	} // namespace blink