diff options
Diffstat (limited to 'Source/WebCore/editing')
-rw-r--r-- | Source/WebCore/editing/MarkupAccumulator.cpp | 212 | ||||
-rw-r--r-- | Source/WebCore/editing/MarkupAccumulator.h | 39 | ||||
-rw-r--r-- | Source/WebCore/editing/markup.cpp | 48 |
3 files changed, 162 insertions, 137 deletions
diff --git a/Source/WebCore/editing/MarkupAccumulator.cpp b/Source/WebCore/editing/MarkupAccumulator.cpp index f4489c5..8ef0594 100644 --- a/Source/WebCore/editing/MarkupAccumulator.cpp +++ b/Source/WebCore/editing/MarkupAccumulator.cpp @@ -1,6 +1,7 @@ /* * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved. * Copyright (C) 2009, 2010 Google Inc. All rights reserved. + * Copyright (C) 2012, The Linux Foundation All rights reserved * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -43,34 +44,57 @@ namespace WebCore { using namespace HTMLNames; -void appendCharactersReplacingEntities(Vector<UChar>& out, const UChar* content, size_t length, EntityMask entityMask) +void appendCharactersReplacingEntities(StringBuilder& result, const UChar* content, size_t length, EntityMask entityMask) { - DEFINE_STATIC_LOCAL(const String, ampReference, ("&")); - DEFINE_STATIC_LOCAL(const String, ltReference, ("<")); - DEFINE_STATIC_LOCAL(const String, gtReference, (">")); - DEFINE_STATIC_LOCAL(const String, quotReference, (""")); - DEFINE_STATIC_LOCAL(const String, nbspReference, (" ")); - - static const EntityDescription entityMaps[] = { - { '&', ampReference, EntityAmp }, - { '<', ltReference, EntityLt }, - { '>', gtReference, EntityGt }, - { '"', quotReference, EntityQuot }, - { noBreakSpace, nbspReference, EntityNbsp }, - }; - size_t positionAfterLastEntity = 0; - for (size_t i = 0; i < length; ++i) { - for (size_t m = 0; m < WTF_ARRAY_LENGTH(entityMaps); ++m) { - if (content[i] == entityMaps[m].entity && entityMaps[m].mask & entityMask) { - out.append(content + positionAfterLastEntity, i - positionAfterLastEntity); - append(out, entityMaps[m].reference); + if (entityMask & EntityNbsp) { + for (size_t i = 0; i < length; ++i) { + UChar c = content[i]; + if (c == noBreakSpace) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append(" ", 6); + positionAfterLastEntity = i + 1; + } else if (c == '&' && EntityAmp & entityMask) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append("&", 5); + positionAfterLastEntity = i + 1; + } else if (c == '<' && EntityLt & entityMask) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append("<", 4); + positionAfterLastEntity = i + 1; + } else if (c == '>' && EntityGt & entityMask) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append(">", 4); + positionAfterLastEntity = i + 1; + } else if (c == '"' && EntityQuot & entityMask) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append(""", 6); + positionAfterLastEntity = i + 1; + } + } + }else if (entityMask) { + for (size_t i = 0; i < length; ++i) { + UChar c = content[i]; + if (c == '&' && EntityAmp & entityMask) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append("&", 5); + positionAfterLastEntity = i + 1; + } else if (c == '<' && EntityLt & entityMask) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append("<", 4); + positionAfterLastEntity = i + 1; + } else if (c == '>' && EntityGt & entityMask) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append(">", 4); + positionAfterLastEntity = i + 1; + } else if (c == '"' && EntityQuot & entityMask) { + result.append(content + positionAfterLastEntity, i - positionAfterLastEntity); + result.append(""", 6); positionAfterLastEntity = i + 1; - break; } } } - out.append(content + positionAfterLastEntity, length - positionAfterLastEntity); + result.append(content + positionAfterLastEntity, length - positionAfterLastEntity); } MarkupAccumulator::MarkupAccumulator(Vector<Node*>* nodes, EAbsoluteURLs shouldResolveURLs, const Range* range) @@ -86,11 +110,8 @@ MarkupAccumulator::~MarkupAccumulator() String MarkupAccumulator::serializeNodes(Node* node, Node* nodeToSkip, EChildrenOnly childrenOnly) { - Vector<UChar> out; serializeNodesWithNamespaces(node, nodeToSkip, childrenOnly, 0); - out.reserveInitialCapacity(length()); - concatenateMarkup(out); - return String::adopt(out); + return m_markup.toString(); } void MarkupAccumulator::serializeNodesWithNamespaces(Node* node, Node* nodeToSkip, EChildrenOnly childrenOnly, const Namespaces* namespaces) @@ -116,23 +137,19 @@ void MarkupAccumulator::serializeNodesWithNamespaces(Node* node, Node* nodeToSki void MarkupAccumulator::appendString(const String& string) { - m_succeedingMarkup.append(string); + m_markup.append(string); } void MarkupAccumulator::appendStartTag(Node* node, Namespaces* namespaces) { - Vector<UChar> markup; - appendStartMarkup(markup, node, namespaces); - appendString(String::adopt(markup)); + appendStartMarkup(m_markup, node, namespaces); if (m_nodes) m_nodes->append(node); } void MarkupAccumulator::appendEndTag(Node* node) { - Vector<UChar> markup; - appendEndMarkup(markup, node); - appendString(String::adopt(markup)); + appendEndMarkup(m_markup, node); } size_t MarkupAccumulator::totalLength(const Vector<String>& strings) @@ -143,35 +160,31 @@ size_t MarkupAccumulator::totalLength(const Vector<String>& strings) return length; } -// FIXME: This is a very inefficient way of accumulating the markup. -// We're converting results of appendStartMarkup and appendEndMarkup from Vector<UChar> to String -// and then back to Vector<UChar> and again to String here. -void MarkupAccumulator::concatenateMarkup(Vector<UChar>& out) +void MarkupAccumulator::concatenateMarkup(StringBuilder& result) { - for (size_t i = 0; i < m_succeedingMarkup.size(); ++i) - append(out, m_succeedingMarkup[i]); + result.append(m_markup); } -void MarkupAccumulator::appendAttributeValue(Vector<UChar>& result, const String& attribute, bool documentIsHTML) +void MarkupAccumulator::appendAttributeValue(StringBuilder& result, const String& attribute, bool documentIsHTML) { appendCharactersReplacingEntities(result, attribute.characters(), attribute.length(), documentIsHTML ? EntityMaskInHTMLAttributeValue : EntityMaskInAttributeValue); } -void MarkupAccumulator::appendQuotedURLAttributeValue(Vector<UChar>& result, const String& urlString) +void MarkupAccumulator::appendQuotedURLAttributeValue(StringBuilder& result, const String& urlString) { - UChar quoteChar = '\"'; + UChar quoteChar = '"'; String strippedURLString = urlString.stripWhiteSpace(); if (protocolIsJavaScript(strippedURLString)) { // minimal escaping for javascript urls if (strippedURLString.contains('"')) { if (strippedURLString.contains('\'')) - strippedURLString.replace('\"', """); + strippedURLString.replace('"', """); else quoteChar = '\''; } result.append(quoteChar); - append(result, strippedURLString); + result.append(strippedURLString); result.append(quoteChar); return; } @@ -182,7 +195,7 @@ void MarkupAccumulator::appendQuotedURLAttributeValue(Vector<UChar>& result, con result.append(quoteChar); } -void MarkupAccumulator::appendNodeValue(Vector<UChar>& out, const Node* node, const Range* range, EntityMask entityMask) +void MarkupAccumulator::appendNodeValue(StringBuilder& out, const Node* node, const Range* range, EntityMask entityMask) { String str = node->nodeValue(); const UChar* characters = str.characters(); @@ -229,7 +242,7 @@ bool MarkupAccumulator::shouldAddNamespaceAttribute(const Attribute& attribute, return true; } -void MarkupAccumulator::appendNamespace(Vector<UChar>& result, const AtomicString& prefix, const AtomicString& namespaceURI, Namespaces& namespaces) +void MarkupAccumulator::appendNamespace(StringBuilder& result, const AtomicString& prefix, const AtomicString& namespaceURI, Namespaces& namespaces) { namespaces.checkConsistency(); if (namespaceURI.isEmpty()) @@ -241,10 +254,10 @@ void MarkupAccumulator::appendNamespace(Vector<UChar>& result, const AtomicStrin if (foundNS != namespaceURI.impl()) { namespaces.set(pre, namespaceURI.impl()); result.append(' '); - append(result, xmlnsAtom.string()); + result.append(xmlnsAtom.string()); if (!prefix.isEmpty()) { result.append(':'); - append(result, prefix); + result.append(prefix); } result.append('='); @@ -259,66 +272,75 @@ EntityMask MarkupAccumulator::entityMaskForText(Text* text) const const QualifiedName* parentName = 0; if (text->parentElement()) parentName = &static_cast<Element*>(text->parentElement())->tagQName(); - + if (parentName && (*parentName == scriptTag || *parentName == styleTag || *parentName == xmpTag)) return EntityMaskInCDATA; return text->document()->isHTMLDocument() ? EntityMaskInHTMLPCDATA : EntityMaskInPCDATA; } -void MarkupAccumulator::appendText(Vector<UChar>& out, Text* text) +void MarkupAccumulator::appendText(StringBuilder& result, Text* text) { - appendNodeValue(out, text, m_range, entityMaskForText(text)); + appendNodeValue(result, text, m_range, entityMaskForText(text)); } -void MarkupAccumulator::appendComment(Vector<UChar>& out, const String& comment) +void MarkupAccumulator::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 "-->". - append(out, "<!--"); - append(out, comment); - append(out, "-->"); + static const char commentBegin[] = "<!--"; + result.append(commentBegin, sizeof(commentBegin) - 1); + result.append(comment); + static const char commentEnd[] = "-->"; + result.append(commentEnd, sizeof(commentEnd) - 1); } -void MarkupAccumulator::appendDocumentType(Vector<UChar>& result, const DocumentType* n) +void MarkupAccumulator::appendDocumentType(StringBuilder& result, const DocumentType* n) { if (n->name().isEmpty()) return; - append(result, "<!DOCTYPE "); - append(result, n->name()); + static const char doctypeString[] = "<!DOCTYPE "; + result.append(doctypeString, sizeof(doctypeString) - 1); + result.append(n->name()); if (!n->publicId().isEmpty()) { - append(result, " PUBLIC \""); - append(result, n->publicId()); - append(result, "\""); + static const char publicString[] = " PUBLIC \""; + result.append(publicString, sizeof(publicString) - 1); + result.append(n->publicId()); + result.append('"'); if (!n->systemId().isEmpty()) { - append(result, " \""); - append(result, n->systemId()); - append(result, "\""); + result.append(' '); + result.append('"'); + result.append(n->systemId()); + result.append('"'); } } else if (!n->systemId().isEmpty()) { - append(result, " SYSTEM \""); - append(result, n->systemId()); - append(result, "\""); + static const char systemString[] = " SYSTEM \""; + result.append(systemString, sizeof(systemString) - 1); + result.append(n->systemId()); + result.append('"'); } if (!n->internalSubset().isEmpty()) { - append(result, " ["); - append(result, n->internalSubset()); - append(result, "]"); + result.append(' '); + result.append('['); + result.append(n->internalSubset()); + result.append(']'); } - append(result, ">"); + result.append('>'); } -void MarkupAccumulator::appendProcessingInstruction(Vector<UChar>& out, const String& target, const String& data) +void MarkupAccumulator::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 "?>". - append(out, "<?"); - append(out, target); - append(out, " "); - append(out, data); - append(out, "?>"); + result.append('<'); + result.append('?'); + result.append(target); + result.append(' '); + result.append(data); + result.append('?'); + result.append('>'); } -void MarkupAccumulator::appendElement(Vector<UChar>& out, Element* element, Namespaces* namespaces) +void MarkupAccumulator::appendElement(StringBuilder& out, Element* element, Namespaces* namespaces) { appendOpenTag(out, element, namespaces); @@ -330,15 +352,15 @@ void MarkupAccumulator::appendElement(Vector<UChar>& out, Element* element, Name appendCloseTag(out, element); } -void MarkupAccumulator::appendOpenTag(Vector<UChar>& out, Element* element, Namespaces* namespaces) +void MarkupAccumulator::appendOpenTag(StringBuilder& out, Element* element, Namespaces* namespaces) { out.append('<'); - append(out, element->nodeNamePreservingCase()); + out.append(element->nodeNamePreservingCase()); if (!element->document()->isHTMLDocument() && namespaces && shouldAddNamespaceElement(element)) appendNamespace(out, element->prefix(), element->namespaceURI(), *namespaces); } -void MarkupAccumulator::appendCloseTag(Vector<UChar>& out, Element* element) +void MarkupAccumulator::appendCloseTag(StringBuilder& out, Element* element) { if (shouldSelfClose(element)) { if (element->isHTMLElement()) @@ -348,16 +370,16 @@ void MarkupAccumulator::appendCloseTag(Vector<UChar>& out, Element* element) out.append('>'); } -void MarkupAccumulator::appendAttribute(Vector<UChar>& out, Element* element, const Attribute& attribute, Namespaces* namespaces) +void MarkupAccumulator::appendAttribute(StringBuilder& out, Element* element, const Attribute& attribute, Namespaces* namespaces) { bool documentIsHTML = element->document()->isHTMLDocument(); out.append(' '); if (documentIsHTML) - append(out, attribute.name().localName()); + out.append(attribute.name().localName()); else - append(out, attribute.name().toString()); + out.append(attribute.name().toString()); out.append('='); @@ -369,24 +391,26 @@ void MarkupAccumulator::appendAttribute(Vector<UChar>& out, Element* element, co else appendQuotedURLAttributeValue(out, attribute.value()); } else { - out.append('\"'); + out.append('"'); appendAttributeValue(out, attribute.value(), documentIsHTML); - out.append('\"'); + out.append('"'); } if (!documentIsHTML && namespaces && shouldAddNamespaceAttribute(attribute, *namespaces)) appendNamespace(out, attribute.prefix(), attribute.namespaceURI(), *namespaces); } -void MarkupAccumulator::appendCDATASection(Vector<UChar>& out, const String& section) +void MarkupAccumulator::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 "]]>". - append(out, "<![CDATA["); - append(out, section); - append(out, "]]>"); + static const char cdataBegin[] = "<![CDATA["; + result.append(cdataBegin, sizeof(cdataBegin) - 1); + result.append(section); + static const char cdataEnd[] = "]]>"; + result.append(cdataEnd, sizeof(cdataEnd) - 1); } -void MarkupAccumulator::appendStartMarkup(Vector<UChar>& result, const Node* node, Namespaces* namespaces) +void MarkupAccumulator::appendStartMarkup(StringBuilder& result, const Node* node, Namespaces* namespaces) { if (namespaces) namespaces->checkConsistency(); @@ -443,7 +467,7 @@ bool MarkupAccumulator::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 @@ -451,14 +475,14 @@ bool MarkupAccumulator::elementCannotHaveEndTag(const Node* node) return static_cast<const HTMLElement*>(node)->ieForbidsInsertHTML(); } -void MarkupAccumulator::appendEndMarkup(Vector<UChar>& result, const Node* node) +void MarkupAccumulator::appendEndMarkup(StringBuilder& result, const Node* node) { if (!node->isElementNode() || shouldSelfClose(node) || (!node->hasChildNodes() && elementCannotHaveEndTag(node))) return; result.append('<'); result.append('/'); - append(result, static_cast<const Element*>(node)->nodeNamePreservingCase()); + result.append(static_cast<const Element*>(node)->nodeNamePreservingCase()); result.append('>'); } diff --git a/Source/WebCore/editing/MarkupAccumulator.h b/Source/WebCore/editing/MarkupAccumulator.h index 0bfc6e6..ba28288 100644 --- a/Source/WebCore/editing/MarkupAccumulator.h +++ b/Source/WebCore/editing/MarkupAccumulator.h @@ -30,6 +30,7 @@ #include "markup.h" #include <wtf/HashMap.h> #include <wtf/Vector.h> +#include <wtf/text/StringBuilder.h> namespace WebCore { @@ -76,28 +77,28 @@ protected: void appendStartTag(Node*, Namespaces* = 0); void appendEndTag(Node*); static size_t totalLength(const Vector<String>&); - size_t length() const { return totalLength(m_succeedingMarkup); } - void concatenateMarkup(Vector<UChar>& out); - void appendAttributeValue(Vector<UChar>& result, const String& attribute, bool documentIsHTML); - void appendQuotedURLAttributeValue(Vector<UChar>& result, const String& urlString); - void appendNodeValue(Vector<UChar>& out, const Node*, const Range*, EntityMask); + size_t length() const { return m_markup.length(); } + void concatenateMarkup(StringBuilder& out); + void appendAttributeValue(StringBuilder& result, const String& attribute, bool documentIsHTML); + void appendQuotedURLAttributeValue(StringBuilder& result, const String& urlString); + void appendNodeValue(StringBuilder& out, const Node*, const Range*, EntityMask); bool shouldAddNamespaceElement(const Element*); bool shouldAddNamespaceAttribute(const Attribute&, Namespaces&); - void appendNamespace(Vector<UChar>& result, const AtomicString& prefix, const AtomicString& namespaceURI, Namespaces&); + void appendNamespace(StringBuilder& result, const AtomicString& prefix, const AtomicString& namespaceURI, Namespaces&); EntityMask entityMaskForText(Text* text) const; - virtual void appendText(Vector<UChar>& out, Text*); - void appendComment(Vector<UChar>& out, const String& comment); - void appendDocumentType(Vector<UChar>& result, const DocumentType*); - void appendProcessingInstruction(Vector<UChar>& out, const String& target, const String& data); - virtual void appendElement(Vector<UChar>& out, Element*, Namespaces*); - void appendOpenTag(Vector<UChar>& out, Element* element, Namespaces*); - void appendCloseTag(Vector<UChar>& out, Element* element); - void appendAttribute(Vector<UChar>& out, Element* element, const Attribute&, Namespaces*); - void appendCDATASection(Vector<UChar>& out, const String& section); - void appendStartMarkup(Vector<UChar>& result, const Node*, Namespaces*); + virtual void appendText(StringBuilder& out, Text*); + void appendComment(StringBuilder& out, const String& comment); + void appendDocumentType(StringBuilder& result, const DocumentType*); + void appendProcessingInstruction(StringBuilder& out, const String& target, const String& data); + virtual void appendElement(StringBuilder& out, Element*, Namespaces*); + void appendOpenTag(StringBuilder& out, Element* element, Namespaces*); + void appendCloseTag(StringBuilder& out, Element* element); + void appendAttribute(StringBuilder& out, Element* element, const Attribute&, Namespaces*); + void appendCDATASection(StringBuilder& out, const String& section); + void appendStartMarkup(StringBuilder& result, const Node*, Namespaces*); bool shouldSelfClose(const Node*); bool elementCannotHaveEndTag(const Node* node); - void appendEndMarkup(Vector<UChar>& result, const Node*); + void appendEndMarkup(StringBuilder&, const Node*); bool shouldResolveURLs() { return m_shouldResolveURLs == AbsoluteURLs; } @@ -107,12 +108,12 @@ protected: private: void serializeNodesWithNamespaces(Node*, Node* nodeToSkip, EChildrenOnly, const Namespaces*); - Vector<String> m_succeedingMarkup; + StringBuilder m_markup; const bool m_shouldResolveURLs; }; // FIXME: This method should be integrated with MarkupAccumulator. -void appendCharactersReplacingEntities(Vector<UChar>& out, const UChar* content, size_t length, EntityMask entityMask); +void appendCharactersReplacingEntities(StringBuilder& out, const UChar* content, size_t length, EntityMask entityMask); } diff --git a/Source/WebCore/editing/markup.cpp b/Source/WebCore/editing/markup.cpp index 5ef3d7d..a02ff03 100644 --- a/Source/WebCore/editing/markup.cpp +++ b/Source/WebCore/editing/markup.cpp @@ -130,12 +130,12 @@ public: String takeResults(); private: - virtual void appendText(Vector<UChar>& out, Text*); + virtual void appendText(StringBuilder& out, Text*); String renderedText(const Node*, const Range*); String stringValueForRange(const Node*, const Range*); void removeExteriorStyles(CSSMutableStyleDeclaration*); - void appendElement(Vector<UChar>& out, Element* element, bool addDisplayInline, RangeFullySelectsNode); - void appendElement(Vector<UChar>& out, Element* element, Namespaces*) { appendElement(out, element, false, DoesFullySelectNode); } + void appendElement(StringBuilder& out, Element* element, bool addDisplayInline, RangeFullySelectsNode); + void appendElement(StringBuilder& out, Element* element, Namespaces*) { appendElement(out, element, false, DoesFullySelectNode); } bool shouldAnnotate() { return m_shouldAnnotate == AnnotateForInterchange; } @@ -145,12 +145,12 @@ private: void StyledMarkupAccumulator::wrapWithNode(Node* node, bool convertBlocksToInlines, RangeFullySelectsNode rangeFullySelectsNode) { - Vector<UChar> markup; + StringBuilder markup; if (node->isElementNode()) appendElement(markup, static_cast<Element*>(node), convertBlocksToInlines && isBlock(const_cast<Node*>(node)), rangeFullySelectsNode); else appendStartMarkup(markup, node, 0); - m_reversedPrecedingMarkup.append(String::adopt(markup)); + m_reversedPrecedingMarkup.append(markup.toString()); appendEndTag(node); if (m_nodes) m_nodes->append(node); @@ -165,30 +165,30 @@ void StyledMarkupAccumulator::wrapWithStyleNode(CSSStyleDeclaration* style, Docu DEFINE_STATIC_LOCAL(const String, divClose, ("</div>")); DEFINE_STATIC_LOCAL(const String, styleSpanOpen, ("<span class=\"" AppleStyleSpanClass "\" style=\"")); DEFINE_STATIC_LOCAL(const String, styleSpanClose, ("</span>")); - Vector<UChar> openTag; - append(openTag, isBlock ? divStyle : styleSpanOpen); + StringBuilder openTag; + openTag.append(isBlock ? divStyle : styleSpanOpen); appendAttributeValue(openTag, style->cssText(), document->isHTMLDocument()); openTag.append('\"'); openTag.append('>'); - m_reversedPrecedingMarkup.append(String::adopt(openTag)); + m_reversedPrecedingMarkup.append(openTag.toString()); appendString(isBlock ? divClose : styleSpanClose); } String StyledMarkupAccumulator::takeResults() { - Vector<UChar> result; - result.reserveInitialCapacity(totalLength(m_reversedPrecedingMarkup) + length()); + StringBuilder result; + result.reserveCapacity(totalLength(m_reversedPrecedingMarkup) + length()); for (size_t i = m_reversedPrecedingMarkup.size(); i > 0; --i) - append(result, m_reversedPrecedingMarkup[i - 1]); + result.append(m_reversedPrecedingMarkup[i - 1]); concatenateMarkup(result); // We remove '\0' characters because they are not visibly rendered to the user. - return String::adopt(result).replace(0, ""); + return result.toString().replace(0, ""); } -void StyledMarkupAccumulator::appendText(Vector<UChar>& out, Text* text) +void StyledMarkupAccumulator::appendText(StringBuilder& out, Text* text) { if (!shouldAnnotate() || (text->parentElement() && text->parentElement()->tagQName() == textareaTag)) { MarkupAccumulator::appendText(out, text); @@ -197,9 +197,9 @@ void StyledMarkupAccumulator::appendText(Vector<UChar>& out, Text* text) bool useRenderedText = !enclosingNodeWithTag(firstPositionInNode(text), selectTag); String content = useRenderedText ? renderedText(text, m_range) : stringValueForRange(text, m_range); - Vector<UChar> buffer; + StringBuilder buffer; appendCharactersReplacingEntities(buffer, content.characters(), content.length(), EntityMaskInPCDATA); - append(out, convertHTMLTextToInterchangeFormat(String::adopt(buffer), text)); + out.append(convertHTMLTextToInterchangeFormat(buffer.toString(), text)); } String StyledMarkupAccumulator::renderedText(const Node* node, const Range* range) @@ -252,7 +252,7 @@ static PassRefPtr<CSSMutableStyleDeclaration> styleFromMatchedRulesForElement(El return style.release(); } -void StyledMarkupAccumulator::appendElement(Vector<UChar>& out, Element* element, bool addDisplayInline, RangeFullySelectsNode rangeFullySelectsNode) +void StyledMarkupAccumulator::appendElement(StringBuilder& out, Element* element, bool addDisplayInline, RangeFullySelectsNode rangeFullySelectsNode) { bool documentIsHTML = element->document()->isHTMLDocument(); appendOpenTag(out, element, 0); @@ -303,7 +303,7 @@ void StyledMarkupAccumulator::appendElement(Vector<UChar>& out, Element* element removeExteriorStyles(style.get()); if (style->length() > 0) { DEFINE_STATIC_LOCAL(const String, stylePrefix, (" style=\"")); - append(out, stylePrefix); + out.append(stylePrefix); appendAttributeValue(out, style->cssText(), documentIsHTML); out.append('\"'); } @@ -819,7 +819,7 @@ PassRefPtr<DocumentFragment> createFragmentFromText(Range* context, const String if (s.isEmpty() && i + 1 == numLines) { // For last line, use the "magic BR" rather than a P. element = createBreakElement(document); - element->setAttribute(classAttr, AppleInterchangeNewline); + element->setAttribute(classAttr, AppleInterchangeNewline); } else { if (useClonesOfEnclosingBlock) element = block->cloneElementWithoutChildren(); @@ -905,13 +905,13 @@ String createFullMarkup(const Range* range) String urlToMarkup(const KURL& url, const String& title) { - Vector<UChar> markup; - append(markup, "<a href=\""); - append(markup, url.string()); - append(markup, "\">"); + StringBuilder markup; + markup.append("<a href=\""); + markup.append(url.string()); + markup.append("\">"); appendCharactersReplacingEntities(markup, title.characters(), title.length(), EntityMaskInPCDATA); - append(markup, "</a>"); - return String::adopt(markup); + markup.append("</a>"); + return markup.toString(); } } |