Refactoring: Change some functions in MarkupFormatter static

Source/core/editing/MarkupAccumulator.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 63 matching lines @@
 void MarkupAccumulator::appendStartMarkup(StringBuilder& result, Node& node, Namespaces* namespaces)
 {
     switch (node.nodeType()) {
     case Node::TEXT_NODE:
         appendText(result, toText(node));
         break;
     case Node::COMMENT_NODE:
         MarkupFormatter::appendComment(result, toComment(node).data());
         break;
     case Node::DOCUMENT_NODE:
-        appendXMLDeclaration(result, toDocument(node));
+        MarkupFormatter::appendXMLDeclaration(result, toDocument(node));
         break;
     case Node::DOCUMENT_FRAGMENT_NODE:
         break;
     case Node::DOCUMENT_TYPE_NODE:
-        appendDocumentType(result, toDocumentType(node));
+        MarkupFormatter::appendDocumentType(result, toDocumentType(node));
         break;
     case Node::PROCESSING_INSTRUCTION_NODE:
-        appendProcessingInstruction(result, toProcessingInstruction(node).target(), toProcessingInstruction(node).data());
+        MarkupFormatter::appendProcessingInstruction(result, toProcessingInstruction(node).target(), toProcessingInstruction(node).data());
         break;
     case Node::ELEMENT_NODE:
         appendElement(result, toElement(node), namespaces);
         break;
     case Node::CDATA_SECTION_NODE:
-        appendCDATASection(result, toCDATASection(node).data());
+        MarkupFormatter::appendCDATASection(result, toCDATASection(node).data());
         break;
     case Node::ATTRIBUTE_NODE:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 static bool elementCannotHaveEndTag(const Node& node)
 {
     if (!node.isHTMLElement())
         return false;
 
     // FIXME: ieForbidsInsertHTML may not be the right function to call here
     // ieForbidsInsertHTML is used to disallow setting innerHTML/outerHTML
     // or createContextualFragment.  It does not necessarily align with
     // which elements should be serialized w/o end tags.
     return toHTMLElement(node).ieForbidsInsertHTML();
 }
 
 void MarkupAccumulator::appendEndMarkup(StringBuilder& result, const Element& element)
 {
     m_formatter.appendEndMarkup(result, element);
 }
 
 void MarkupAccumulator::concatenateMarkup(StringBuilder& result) const
 {
     result.append(m_markup);
 }
 
-void MarkupAccumulator::appendAttributeValue(StringBuilder& result, const String& attribute, bool documentIsHTML)
-{
-    m_formatter.appendAttributeValue(result, attribute, documentIsHTML);
-}
-
 void MarkupAccumulator::appendCustomAttributes(StringBuilder&, const Element&, Namespaces*)
 {
 }
 
-void MarkupAccumulator::appendNamespace(StringBuilder& result, const AtomicString& prefix, const AtomicString& namespaceURI, Namespaces& namespaces)
-{
-    m_formatter.appendNamespace(result, prefix, namespaceURI, namespaces);
-}
-
 void MarkupAccumulator::appendText(StringBuilder& result, Text& text)
 {
     m_formatter.appendText(result, text);
 }
 
-void MarkupAccumulator::appendXMLDeclaration(StringBuilder& result, const Document& document)
-{
-    m_formatter.appendXMLDeclaration(result, document);
-}
-
-void MarkupAccumulator::appendDocumentType(StringBuilder& result, const DocumentType& n)
-{
-    m_formatter.appendDocumentType(result, n);
-}
-
-void MarkupAccumulator::appendProcessingInstruction(StringBuilder& result, const String& target, const String& data)
-{
-    m_formatter.appendProcessingInstruction(result, target, data);
-}
-
 bool MarkupAccumulator::shouldIgnoreAttribute(const Attribute& attribute)
 {
     return false;
 }
 
 void MarkupAccumulator::appendElement(StringBuilder& result, Element& element, Namespaces* namespaces)
 {
     appendOpenTag(result, element, namespaces);
 
     AttributeCollection attributes = element.attributes();
@@ skipping 16 matching lines @@
 void MarkupAccumulator::appendCloseTag(StringBuilder& result, const Element& element)
 {
     m_formatter.appendCloseTag(result, element);
 }
 
 void MarkupAccumulator::appendAttribute(StringBuilder& result, const Element& element, const Attribute& attribute, Namespaces* namespaces)
 {
     m_formatter.appendAttribute(result, element, attribute, namespaces);
 }
 
-void MarkupAccumulator::appendCDATASection(StringBuilder& result, const String& section)
-{
-    m_formatter.appendCDATASection(result, section);
-}
-
-bool MarkupAccumulator::shouldAddNamespaceElement(const Element& element, Namespaces& namespaces) const
-{
-    return m_formatter.shouldAddNamespaceElement(element, namespaces);
-}
-
-bool MarkupAccumulator::shouldAddNamespaceAttribute(const Attribute& attribute, const Element& element) const
-{
-    return m_formatter.shouldAddNamespaceAttribute(attribute, element);
-}
-
 EntityMask MarkupAccumulator::entityMaskForText(const Text& text) const
 {
     return m_formatter.entityMaskForText(text);
 }
 
-bool MarkupAccumulator::shouldSelfClose(const Element& element) const
-{
-    return m_formatter.shouldSelfClose(element);
-}
-
 bool MarkupAccumulator::serializeAsHTMLDocument(const Node& node) const
 {
     return m_formatter.serializeAsHTMLDocument(node);
 }
 
 template<typename Strategy>
 static void serializeNodesWithNamespaces(MarkupAccumulator& accumulator, Node& targetNode, EChildrenOnly childrenOnly, const Namespaces* namespaces)
 {
     Namespaces namespaceHash;
     if (namespaces)
@@ skipping 23 matching lines @@
         namespaces = &namespaceHash;
     }
 
     serializeNodesWithNamespaces<Strategy>(accumulator, targetNode, childrenOnly, namespaces);
     return accumulator.toString();
 }
 
 template String serializeNodes<EditingStrategy>(MarkupAccumulator&, Node&, EChildrenOnly);
 
 }