Refactoring: Have StyledMarkupAccumulator use MarkupFormatter

Source/core/editing/StyledMarkupAccumulator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009, 2010, 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011 Igalia S.L.
  * Copyright (C) 2011 Motorola Mobility. 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
@@ skipping 33 matching lines @@
     DEFINE_STATIC_LOCAL(const String, divClose, ("</div>"));
     DEFINE_STATIC_LOCAL(const String, styleSpanClose, ("</span>"));
     return isBlock ? divClose : styleSpanClose;
 }
 
 } // namespace
 
 using namespace HTMLNames;
 
 StyledMarkupAccumulator::StyledMarkupAccumulator(EAbsoluteURLs shouldResolveURLs, const TextOffset& start, const TextOffset& end, const PassRefPtrWillBeRawPtr<Document> document, EAnnotateForInterchange shouldAnnotate, Node* highestNodeToBeSerialized, ConvertBlocksToInlines convertBlocksToInlines)
-    : m_accumulator(shouldResolveURLs)
+    : m_formatter(shouldResolveURLs)
     , m_start(start)
     , m_end(end)
     , m_document(document)
     , m_shouldAnnotate(shouldAnnotate)
     , m_convertBlocksToInlines(convertBlocksToInlines)
     , m_highestNodeToBeSerialized(highestNodeToBeSerialized)
 {
 }
 
 void StyledMarkupAccumulator::appendString(const String& str)
 {
-    m_accumulator.appendString(str);
+    m_result.append(str);
 }
 
 void StyledMarkupAccumulator::appendStartTag(Node& node)
 {
-    StringBuilder out;
-    appendStartMarkup(out, node);
-    appendString(out.toString());
+    appendStartMarkup(m_result, node);
 }
 
 void StyledMarkupAccumulator::appendEndTag(const Element& element)
 {
-    StringBuilder out;
-    appendEndMarkup(out, element);
-    appendString(out.toString());
+    appendEndMarkup(m_result, element);
 }
 
 void StyledMarkupAccumulator::appendStartMarkup(StringBuilder& result, Node& node)
 {
     switch (node.nodeType()) {
     case Node::TEXT_NODE:
         appendText(result, toText(node));
         break;
     case Node::ELEMENT_NODE:
         appendElement(result, toElement(node));
         break;
     default:
-        m_accumulator.appendStartMarkup(result, node, nullptr);
+        m_formatter.appendStartMarkup(result, node, nullptr);
         break;
     }
 }
 
 void StyledMarkupAccumulator::appendEndMarkup(StringBuilder& result, const Element& element)
 {
-    m_accumulator.appendEndMarkup(result, element);
+    m_formatter.appendEndMarkup(result, element);
 }
 
 void StyledMarkupAccumulator::appendText(StringBuilder& out, Text& text)
 {
     const bool parentIsTextarea = text.parentElement() && text.parentElement()->tagQName() == textareaTag;
     const bool wrappingSpan = shouldApplyWrappingStyle(text) && !parentIsTextarea;
     if (wrappingSpan) {
         RefPtrWillBeRawPtr<EditingStyle> wrappingStyle = m_wrappingStyle->copy();
         // FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance
         // Make sure spans are inline style in paste side e.g. span { display: block }.
@@ skipping 11 matching lines @@
         if (m_end.isNotNull()) {
             if (text == m_end.text())
                 length = m_end.offset();
         }
         if (m_start.isNotNull()) {
             if (text == m_start.text()) {
                 start = m_start.offset();
                 length -= start;
             }
         }
-        MarkupFormatter::appendCharactersReplacingEntities(out, str, start, length, m_accumulator.entityMaskForText(text));
+        MarkupFormatter::appendCharactersReplacingEntities(out, str, start, length, m_formatter.entityMaskForText(text));
     } else {
         const bool useRenderedText = !enclosingElementWithTag(firstPositionInNode(&text), selectTag);
         String content = useRenderedText ? renderedText(text) : stringValueForRange(text);
         StringBuilder buffer;
         MarkupFormatter::appendCharactersReplacingEntities(buffer, content, 0, content.length(), EntityMaskInPCDATA);
         out.append(convertHTMLTextToInterchangeFormat(buffer.toString(), text));
     }
 
     if (wrappingSpan)
         out.append(styleNodeCloseTag(false));
 }
 
 void StyledMarkupAccumulator::appendElement(StringBuilder& out, Element& element)
 {
     appendElement(out, element, false, DoesFullySelectNode);
 }
 
 void StyledMarkupAccumulator::appendElement(StringBuilder& out, Element& element, bool addDisplayInline, StyledMarkupAccumulator::RangeFullySelectsNode rangeFullySelectsNode)
 {
     const bool documentIsHTML = element.document().isHTMLDocument();
-    m_accumulator.appendOpenTag(out, element, 0);
+    m_formatter.appendOpenTag(out, element, 0);
 
     const bool shouldAnnotateOrForceInline = element.isHTMLElement() && (shouldAnnotate() || addDisplayInline);
     const bool shouldOverrideStyleAttr = shouldAnnotateOrForceInline || shouldApplyWrappingStyle(element);
 
     AttributeCollection attributes = element.attributes();
     for (const auto& attribute : attributes) {
         // We'll handle the style attribute separately, below.
         if (attribute.name() == styleAttr && shouldOverrideStyleAttr)
             continue;
-        m_accumulator.appendAttribute(out, element, attribute, nullptr);
+        m_formatter.appendAttribute(out, element, attribute, nullptr);
     }
 
     if (shouldOverrideStyleAttr) {
         RefPtrWillBeRawPtr<EditingStyle> newInlineStyle = nullptr;
 
         if (shouldApplyWrappingStyle(element)) {
             newInlineStyle = m_wrappingStyle->copy();
             newInlineStyle->removePropertiesInElementDefaultStyle(&element);
             newInlineStyle->removeStyleConflictingWithStyleOfElement(&element);
         } else {
@@ skipping 16 matching lines @@
                 newInlineStyle->style()->removeProperty(CSSPropertyFloat);
         }
 
         if (!newInlineStyle->isEmpty()) {
             out.appendLiteral(" style=\"");
             MarkupFormatter::appendAttributeValue(out, newInlineStyle->style()->asText(), documentIsHTML);
             out.append('\"');
         }
     }
 
-    m_accumulator.appendCloseTag(out, element);
+    m_formatter.appendCloseTag(out, element);
 }
 
 void StyledMarkupAccumulator::appendStyleNodeOpenTag(StringBuilder& out, StylePropertySet* style, bool isBlock)
 {
     // wrappingStyleForSerialization should have removed -webkit-text-decorations-in-effect
     ASSERT(propertyMissingOrEqualToNone(style, CSSPropertyWebkitTextDecorationsInEffect));
     if (isBlock)
         out.appendLiteral("<div style=\"");
     else
         out.appendLiteral("<span style=\"");
@@ skipping 18 matching lines @@
 {
     StringBuilder openTag;
     appendStyleNodeOpenTag(openTag, style, isBlock);
     m_reversedPrecedingMarkup.append(openTag.toString());
     appendString(styleNodeCloseTag(isBlock));
 }
 
 String StyledMarkupAccumulator::takeResults()
 {
     StringBuilder result;
-    result.reserveCapacity(MarkupFormatter::totalLength(m_reversedPrecedingMarkup) + m_accumulator.length());
+    result.reserveCapacity(MarkupFormatter::totalLength(m_reversedPrecedingMarkup) + m_result.length());
 
     for (size_t i = m_reversedPrecedingMarkup.size(); i > 0; --i)
         result.append(m_reversedPrecedingMarkup[i - 1]);
 
-    m_accumulator.concatenateMarkup(result);
+    result.append(m_result);
 
     // We remove '\0' characters because they are not visibly rendered to the user.
     return result.toString().replace(0, "");
 }
 
 String StyledMarkupAccumulator::renderedText(Text& textNode)
 {
     int startOffset = 0;
     int endOffset = textNode.length();
     if (m_start.text() == textNode)
@@ skipping 22 matching lines @@
     return m_highestNodeToBeSerialized && m_highestNodeToBeSerialized->parentNode() == node.parentNode()
         && m_wrappingStyle && m_wrappingStyle->style();
 }
 
 bool StyledMarkupAccumulator::shouldAnnotate() const
 {
     return m_shouldAnnotate == AnnotateForInterchange;
 }
 
 } // namespace blink