Refactoring: Move StyledMarkupSerializer::m_reversedPrecedingMarkup to StyledMarkupAccumulator

Source/core/editing/StyledMarkupSerializer.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 29 matching lines @@
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/markup.h"
 #include "core/html/HTMLBodyElement.h"
 #include "core/html/HTMLElement.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 namespace {
 
-const String& styleNodeCloseTag(bool isBlock)
-{
-    DEFINE_STATIC_LOCAL(const String, divClose, ("</div>"));
-    DEFINE_STATIC_LOCAL(const String, styleSpanClose, ("</span>"));
-    return isBlock ? divClose : styleSpanClose;
-}
-
 template<typename PositionType>
 TextOffset toTextOffset(const PositionType& position)
 {
     if (position.isNull())
         return TextOffset();
 
     if (!position.containerNode()->isTextNode())
         return TextOffset();
 
     return TextOffset(toText(position.containerNode()), position.offsetInContainerNode());
 }
 
 } // namespace
 
 using namespace HTMLNames;
 
 static Position toPositionInDOMTree(const Position& position)
 {
     return position;
 }
 
 template<typename Strategy>
 StyledMarkupSerializer<Strategy>::StyledMarkupSerializer(EAbsoluteURLs shouldResolveURLs, EAnnotateForInterchange shouldAnnotate, const PositionType& start, const PositionType& end, Node* highestNodeToBeSerialized, ConvertBlocksToInlines convertBlocksToInlines)
-    : m_markupAccumulator(shouldResolveURLs, toTextOffset(start.parentAnchoredEquivalent()), toTextOffset(end.parentAnchoredEquivalent()), start.document(), shouldAnnotate, highestNodeToBeSerialized)
+    : m_markupAccumulator(shouldResolveURLs, toTextOffset(start.parentAnchoredEquivalent()), toTextOffset(end.parentAnchoredEquivalent()), start.document(), shouldAnnotate, highestNodeToBeSerialized, convertBlocksToInlines)
     , m_start(start)
     , m_end(end)
     , m_shouldAnnotate(shouldAnnotate)
     , m_highestNodeToBeSerialized(highestNodeToBeSerialized)
-    , m_convertBlocksToInlines(convertBlocksToInlines)
 {
 }
 
 static bool needInterchangeNewlineAfter(const VisiblePosition& v)
 {
     VisiblePosition next = v.next();
     Node* upstreamNode = next.deepEquivalent().upstream().deprecatedNode();
     Node* downstreamNode = v.deepEquivalent().downstream().deprecatedNode();
     // Add an interchange newline if a paragraph break is selected and a br won't already be added to the markup to represent it.
     return isEndOfParagraph(v) && isStartOfParagraph(next) && !(isHTMLBRElement(*upstreamNode) && upstreamNode == downstreamNode);
@@ skipping 56 matching lines @@
         ASSERT(commonAncestor);
         HTMLBodyElement* body = toHTMLBodyElement(enclosingElementWithTag(firstPositionInNode(commonAncestor), bodyTag));
         HTMLBodyElement* fullySelectedRoot = nullptr;
         // FIXME: Do this for all fully selected blocks, not just the body.
         if (body && areSameRanges(body, m_start, m_end))
             fullySelectedRoot = body;
 
         // Also include all of the ancestors of lastClosed up to this special ancestor.
         // FIXME: What is ancestor?
         for (ContainerNode* ancestor = Strategy::parent(*lastClosed); ancestor; ancestor = Strategy::parent(*ancestor)) {
-            if (ancestor == fullySelectedRoot && !convertBlocksToInlines()) {
+            if (ancestor == fullySelectedRoot && !m_markupAccumulator.convertBlocksToInlines()) {
                 RefPtrWillBeRawPtr<EditingStyle> fullySelectedRootStyle = styleFromMatchedRulesAndInlineDecl(fullySelectedRoot);
 
                 // Bring the background attribute over, but not as an attribute because a background attribute on a div
                 // appears to have no effect.
                 if ((!fullySelectedRootStyle || !fullySelectedRootStyle->style() || !fullySelectedRootStyle->style()->getPropertyCSSValue(CSSPropertyBackgroundImage))
                     && fullySelectedRoot->hasAttribute(backgroundAttr))
                     fullySelectedRootStyle->style()->setProperty(CSSPropertyBackgroundImage, "url('" + fullySelectedRoot->getAttribute(backgroundAttr) + "')");
 
                 if (fullySelectedRootStyle->style()) {
                     // Reset the CSS properties to avoid an assertion error in addStyleMarkup().
                     // This assertion is caused at least when we select all text of a <body> element whose
                     // 'text-decoration' property is "inherit", and copy it.
                     if (!propertyMissingOrEqualToNone(fullySelectedRootStyle->style(), CSSPropertyTextDecoration))
                         fullySelectedRootStyle->style()->setProperty(CSSPropertyTextDecoration, CSSValueNone);
                     if (!propertyMissingOrEqualToNone(fullySelectedRootStyle->style(), CSSPropertyWebkitTextDecorationsInEffect))
                         fullySelectedRootStyle->style()->setProperty(CSSPropertyWebkitTextDecorationsInEffect, CSSValueNone);
-                    wrapWithStyleNode(fullySelectedRootStyle->style(), true);
+                    m_markupAccumulator.wrapWithStyleNode(fullySelectedRootStyle->style(), true);
                 }
             } else {
                 // Since this node and all the other ancestors are not in the selection we want to set RangeFullySelectsNode to DoesNotFullySelectNode
                 // so that styles that affect the exterior of the node are not included.
-                wrapWithNode(*ancestor, StyledMarkupAccumulator::DoesNotFullySelectNode);
+                m_markupAccumulator.wrapWithNode(*ancestor, StyledMarkupAccumulator::DoesNotFullySelectNode);
             }
 
             if (ancestor == m_highestNodeToBeSerialized)
                 break;
         }
     }
 
     // FIXME: The interchange newline should be placed in the block that it's in, not after all of the content, unconditionally.
     if (m_shouldAnnotate == AnnotateForInterchange && needInterchangeNewlineAt(visibleEnd))
         m_markupAccumulator.appendString(interchangeNewlineString);
 
-    return takeResults();
+    return m_markupAccumulator.takeResults();
 }
 
 template<typename Strategy>
-void StyledMarkupSerializer<Strategy>::wrapWithNode(ContainerNode& node, typename StyledMarkupAccumulator::RangeFullySelectsNode rangeFullySelectsNode)
-{
-    StringBuilder markup;
-    if (node.isElementNode())
-        m_markupAccumulator.appendElement(markup, toElement(node), convertBlocksToInlines() && isBlock(&node), rangeFullySelectsNode);
-    else
-        m_markupAccumulator.appendStartMarkup(markup, node);
-    m_reversedPrecedingMarkup.append(markup.toString());
-    if (node.isElementNode())
-        m_markupAccumulator.appendEndTag(toElement(node));
-}
-
-template<typename Strategy>
-void StyledMarkupSerializer<Strategy>::wrapWithStyleNode(StylePropertySet* style, bool isBlock)
-{
-    StringBuilder openTag;
-    m_markupAccumulator.appendStyleNodeOpenTag(openTag, style, isBlock);
-    m_reversedPrecedingMarkup.append(openTag.toString());
-    m_markupAccumulator.appendString(styleNodeCloseTag(isBlock));
-}
-
-template<typename Strategy>
-String StyledMarkupSerializer<Strategy>::takeResults()
-{
-    StringBuilder result;
-    result.reserveCapacity(MarkupAccumulator::totalLength(m_reversedPrecedingMarkup) + m_markupAccumulator.length());
-
-    for (size_t i = m_reversedPrecedingMarkup.size(); i > 0; --i)
-        result.append(m_reversedPrecedingMarkup[i - 1]);
-
-    m_markupAccumulator.concatenateMarkup(result);
-
-    // We remove '\0' characters because they are not visibly rendered to the user.
-    return result.toString().replace(0, "");
-}
-
-template<typename Strategy>
 Node* StyledMarkupSerializer<Strategy>::serializeNodes(Node* startNode, Node* pastEnd)
 {
     if (!m_markupAccumulator.highestNodeToBeSerialized()) {
         Node* lastClosed = traverseNodesForSerialization(startNode, pastEnd, NodeTraversalMode::DoNotEmitString);
         m_markupAccumulator.setHighestNodeToBeSerialized(lastClosed);
     }
 
     Node* highestNodeToBeSerialized = m_markupAccumulator.highestNodeToBeSerialized();
     if (highestNodeToBeSerialized && Strategy::parent(*highestNodeToBeSerialized)) {
         bool shouldAnnotate = m_shouldAnnotate == AnnotateForInterchange;
@@ skipping 72 matching lines @@
         ASSERT(n);
         Node* lastAncestorClosedOrSelf = Strategy::isDescendantOf(*n, *lastClosed) ? lastClosed : n;
         for (ContainerNode* parent = Strategy::parent(*lastAncestorClosedOrSelf); parent && parent != nextParent; parent = Strategy::parent(*parent)) {
             // All ancestors that aren't in the ancestorsToClose list should either be a) unrendered:
             if (!parent->layoutObject())
                 continue;
             // or b) ancestors that we never encountered during a pre-order traversal starting at startNode:
             ASSERT(startNode);
             ASSERT(Strategy::isDescendantOf(*startNode, *parent));
             if (shouldEmit)
-                wrapWithNode(*parent);
+                m_markupAccumulator.wrapWithNode(*parent);
             lastClosed = parent;
         }
     }
 
     return lastClosed;
 }
 
 template class StyledMarkupSerializer<EditingStrategy>;
 
 } // namespace blink