Remove StringBuilder::appendLiteral.

third_party/WebKit/Source/core/editing/serializers/MarkupFormatter.cpp

 /*
  * 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
@@ skipping 160 matching lines @@
     // or createContextualFragment.  It does not necessarily align with
     // which elements should be serialized w/o end tags.
     return toHTMLElement(node).ieForbidsInsertHTML();
 }
 
 void MarkupFormatter::appendEndMarkup(StringBuilder& result, const Element& element)
 {
     if (shouldSelfClose(element) || (!element.hasChildren() && elementCannotHaveEndTag(element)))
         return;
 
-    result.appendLiteral("</");
+    result.append("</");
     result.append(element.tagQName().toString());
     result.append('>');
 }
 
 void MarkupFormatter::appendAttributeValue(StringBuilder& result, const String& attribute, bool documentIsHTML)
 {
     appendCharactersReplacingEntities(result, attribute, 0, attribute.length(),
         documentIsHTML ? EntityMaskInHTMLAttributeValue : EntityMaskInAttributeValue);
 }
 
@@ skipping 35 matching lines @@
     AtomicString foundURI = namespaces.get(lookupKey);
     if (foundURI != namespaceURI) {
         namespaces.set(lookupKey, namespaceURI);
         result.append(' ');
         result.append(xmlnsAtom.getString());
         if (!prefix.isEmpty()) {
             result.append(':');
             result.append(prefix);
         }
 
-        result.appendLiteral("=\"");
+        result.append("=\"");
         appendAttributeValue(result, namespaceURI, 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.appendLiteral("<!--");
+    result.append("<!--");
     result.append(comment);
-    result.appendLiteral("-->");
+    result.append("-->");
 }
 
 void MarkupFormatter::appendXMLDeclaration(StringBuilder& result, const Document& document)
 {
     if (!document.hasXMLDeclaration())
         return;
 
-    result.appendLiteral("<?xml version=\"");
+    result.append("<?xml version=\"");
     result.append(document.xmlVersion());
     const String& encoding = document.xmlEncoding();
     if (!encoding.isEmpty()) {
-        result.appendLiteral("\" encoding=\"");
+        result.append("\" encoding=\"");
         result.append(encoding);
     }
     if (document.xmlStandaloneStatus() != Document::StandaloneUnspecified) {
-        result.appendLiteral("\" standalone=\"");
+        result.append("\" standalone=\"");
         if (document.xmlStandalone())
-            result.appendLiteral("yes");
+            result.append("yes");
         else
-            result.appendLiteral("no");
+            result.append("no");
     }
 
-    result.appendLiteral("\"?>");
+    result.append("\"?>");
 }
 
 void MarkupFormatter::appendDocumentType(StringBuilder& result, const DocumentType& n)
 {
     if (n.name().isEmpty())
         return;
 
-    result.appendLiteral("<!DOCTYPE ");
+    result.append("<!DOCTYPE ");
     result.append(n.name());
     if (!n.publicId().isEmpty()) {
-        result.appendLiteral(" PUBLIC \"");
+        result.append(" PUBLIC \"");
         result.append(n.publicId());
         result.append('"');
         if (!n.systemId().isEmpty()) {
-            result.appendLiteral(" \"");
+            result.append(" \"");
             result.append(n.systemId());
             result.append('"');
         }
     } else if (!n.systemId().isEmpty()) {
-        result.appendLiteral(" SYSTEM \"");
+        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.appendLiteral("<?");
+    result.append("<?");
     result.append(target);
     result.append(' ');
     result.append(data);
-    result.appendLiteral("?>");
+    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);
 }
 
@@ skipping 68 matching lines @@
     } else {
         result.append('"');
         appendAttributeValue(result, attribute.value(), documentIsHTML);
         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.appendLiteral("<![CDATA[");
+    result.append("<![CDATA[");
     result.append(section);
-    result.appendLiteral("]]>");
+    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(xmlnsAtom)) {
             namespaces.set(emptyAtom, element.namespaceURI());
             return false;
@@ skipping 52 matching lines @@
 }
 
 bool MarkupFormatter::serializeAsHTMLDocument(const Node& node) const
 {
     if (m_serializationType == SerializationType::ForcedXML)
         return false;
     return node.document().isHTMLDocument();
 }
 
 } // namespace blink