WTF_MAKE_NONCOPYABLE(ReplacementFragment);

ReplacementFragment(Document&, DocumentFragment*, const VisibleSelection&);

DocumentFragment* fragment() { return m_fragment.get(); }

Node* firstChild() const;

Node* lastChild() const;

bool isEmpty() const;

bool hasInterchangeNewlineAtStart() const { return m_hasInterchangeNewlineAtStart; }

bool hasInterchangeNewlineAtEnd() const { return m_hasInterchangeNewlineAtEnd; }

void removeNode(PassRefPtr<Node>);

void removeNodePreservingChildren(PassRefPtr<Node>);

PassRefPtr<StyledElement> insertFragmentForTestRendering(Node* rootEditableNode);

void removeUnrenderedNodes(Node*);

void restoreAndRemoveTestRenderingNodesToFragment(StyledElement*);

void removeInterchangeNodes(Node*);

void insertNodeBefore(PassRefPtr<Node> node, Node* refNode);

Document& document() { return *m_document; }

RefPtr<Document> m_document;

RefPtr<DocumentFragment> m_fragment;

bool m_hasInterchangeNewlineAtStart;

bool m_hasInterchangeNewlineAtEnd;

{

static NeverDestroyed<String> interchangeNewlineClassString(AppleInterchangeNewline);

return node && node->hasTagName(brTag) &&

static_cast<const Element *>(node)->getAttribute(classAttr) == interchangeNewlineClassString;

{

static NeverDestroyed<String> convertedSpaceSpanClassString(AppleConvertedSpace);

return node->isHTMLElement() &&

static_cast<const HTMLElement *>(node)->getAttribute(classAttr) == convertedSpaceSpanClassString;

{

// If we're already on a break, it's probably a placeholder and we shouldn't change our position.

if (editingIgnoresContent(pos.deprecatedNode()))

return pos;

// We also stop when changing block flow elements because even though the visual position is the

// same. E.g.,

// <div>foo^</div>^

// The two positions above are the same visual position, but we want to stay in the same block.

Node* enclosingBlockNode = enclosingBlock(pos.containerNode());

for (Position nextPosition = pos; nextPosition.containerNode() != enclosingBlockNode; pos = nextPosition) {

if (lineBreakExistsAtPosition(pos))

break;

if (pos.containerNode()->nonShadowBoundaryParentNode())

nextPosition = positionInParentAfterNode(pos.containerNode());

if (nextPosition == pos

|| enclosingBlock(nextPosition.containerNode()) != enclosingBlockNode

|| VisiblePosition(pos) != VisiblePosition(nextPosition))

break;

}

return pos;

: m_document(&document)

, m_fragment(fragment)

, m_hasInterchangeNewlineAtStart(false)

, m_hasInterchangeNewlineAtEnd(false)

{

if (!m_fragment)

return;

if (!m_fragment->firstChild())

return;

RefPtr<Element> editableRoot = selection.rootEditableElement();

ASSERT(editableRoot);

if (!editableRoot)

return;

Node* shadowAncestorNode = editableRoot->deprecatedShadowAncestorNode();

if (!editableRoot->getAttributeEventListener(eventNames().webkitBeforeTextInsertedEvent) &&

// FIXME: Remove these checks once textareas and textfields actually register an event handler.

!(shadowAncestorNode && shadowAncestorNode->renderer() && shadowAncestorNode->renderer()->isTextControl()) &&

editableRoot->hasRichlyEditableStyle()) {

removeInterchangeNodes(m_fragment.get());

return;

}

RefPtr<StyledElement> holder = insertFragmentForTestRendering(editableRoot.get());

if (!holder) {

removeInterchangeNodes(m_fragment.get());

return;

}

RefPtr<Range> range = VisibleSelection::selectionFromContentsOfNode(holder.get()).toNormalizedRange();

String text = plainText(range.get(), static_cast<TextIteratorBehavior>(TextIteratorEmitsOriginalText | TextIteratorIgnoresStyleVisibility));

removeInterchangeNodes(holder.get());

removeUnrenderedNodes(holder.get());

restoreAndRemoveTestRenderingNodesToFragment(holder.get());

// Give the root a chance to change the text.

Ref<BeforeTextInsertedEvent> event = BeforeTextInsertedEvent::create(text);

editableRoot->dispatchEvent(event);

if (text != event->text() || !editableRoot->hasRichlyEditableStyle()) {

restoreAndRemoveTestRenderingNodesToFragment(holder.get());

RefPtr<Range> range = selection.toNormalizedRange();

if (!range)

return;

m_fragment = createFragmentFromText(*range, event->text());

if (!m_fragment->firstChild())

return;

holder = insertFragmentForTestRendering(editableRoot.get());

removeInterchangeNodes(holder.get());

removeUnrenderedNodes(holder.get());

restoreAndRemoveTestRenderingNodesToFragment(holder.get());

}

{

if (!node)

return;

while (RefPtr<Node> n = node->firstChild()) {

removeNode(n);

insertNodeBefore(n.release(), node.get());

}

removeNode(node);

{

if (!node)

return;

ContainerNode* parent = node->nonShadowBoundaryParentNode();

if (!parent)

return;

parent->removeChild(*node, ASSERT_NO_EXCEPTION);

{

if (!node || !refNode)

return;

ContainerNode* parent = refNode->nonShadowBoundaryParentNode();

if (!parent)

return;

parent->insertBefore(*node, refNode, ASSERT_NO_EXCEPTION);

{

RefPtr<StyledElement> holder = createDefaultParagraphElement(document());

holder->appendChild(*m_fragment, ASSERT_NO_EXCEPTION);

rootEditableElement->appendChild(holder.get(), ASSERT_NO_EXCEPTION);

document().updateLayoutIgnorePendingStylesheets();

return holder.release();

{

if (!holder)

return;

while (RefPtr<Node> node = holder->firstChild()) {

holder->removeChild(*node, ASSERT_NO_EXCEPTION);

m_fragment->appendChild(*node, ASSERT_NO_EXCEPTION);

}

removeNode(holder);

{

Vector<RefPtr<Node>> unrendered;

for (Node* node = holder->firstChild(); node; node = NodeTraversal::next(*node, holder)) {

if (!isNodeRendered(node) && !isTableStructureNode(node))

unrendered.append(node);

}

for (auto& node : unrendered)

removeNode(node);

{

m_hasInterchangeNewlineAtStart = false;

m_hasInterchangeNewlineAtEnd = false;

// Interchange newlines at the "start" of the incoming fragment must be

// either the first node in the fragment or the first leaf in the fragment.

Node* node = container->firstChild();

while (node) {

if (isInterchangeNewlineNode(node)) {

m_hasInterchangeNewlineAtStart = true;

removeNode(node);

break;

}

node = node->firstChild();

}

if (!container->hasChildNodes())

return;

// Interchange newlines at the "end" of the incoming fragment must be

// either the last node in the fragment or the last leaf in the fragment.

node = container->lastChild();

while (node) {

if (isInterchangeNewlineNode(node)) {

m_hasInterchangeNewlineAtEnd = true;

removeNode(node);

break;

}

node = node->lastChild();

}

node = container->firstChild();

while (node) {

RefPtr<Node> next = NodeTraversal::next(*node);

if (isInterchangeConvertedSpaceSpan(node)) {

next = NodeTraversal::nextSkippingChildren(*node);

removeNodePreservingChildren(node);

}

node = next.get();

}

: CompositeEditCommand(document, editAction)

, m_selectReplacement(options & SelectReplacement)

, m_smartReplace(options & SmartReplace)

, m_matchStyle(options & MatchStyle)

, m_documentFragment(fragment)

, m_preventNesting(options & PreventNesting)

, m_movingParagraph(options & MovingParagraph)

, m_sanitizeFragment(options & SanitizeFragment)

, m_shouldMergeEnd(false)

, m_ignoreMailBlockquote(options & IgnoreMailBlockquote)

{

{

Position existing = endOfExistingContent.deepEquivalent();

Position inserted = endOfInsertedContent.deepEquivalent();

bool isInsideMailBlockquote = enclosingNodeOfType(inserted, isMailBlockquote, CanCrossEditingBoundary);

return isInsideMailBlockquote && (numEnclosingMailBlockquotes(existing) == numEnclosingMailBlockquotes(inserted));

{

if (m_movingParagraph)

return false;

VisiblePosition startOfInsertedContent(positionAtStartOfInsertedContent());

VisiblePosition prev = startOfInsertedContent.previous(CannotCrossEditingBoundary);

if (prev.isNull())

return false;

// When we have matching quote levels, its ok to merge more frequently.

// For a successful merge, we still need to make sure that the inserted content starts with the beginning of a paragraph.

// And we should only merge here if the selection start was inside a mail blockquote. This prevents against removing a

// blockquote from newly pasted quoted content that was pasted into an unquoted position. If that unquoted position happens

// to be right after another blockquote, we don't want to merge and risk stripping a valid block (and newline) from the pasted content.

if (isStartOfParagraph(startOfInsertedContent) && selectionStartWasInsideMailBlockquote && hasMatchingQuoteLevel(prev, positionAtEndOfInsertedContent()))

return true;

return !selectionStartWasStartOfParagraph

&& !fragmentHasInterchangeNewlineAtStart

&& isStartOfParagraph(startOfInsertedContent)

&& !startOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)

&& shouldMerge(startOfInsertedContent, prev);

{

VisiblePosition endOfInsertedContent(positionAtEndOfInsertedContent());

VisiblePosition next = endOfInsertedContent.next(CannotCrossEditingBoundary);

if (next.isNull())

return false;

return !selectionEndWasEndOfParagraph

&& isEndOfParagraph(endOfInsertedContent)

&& !endOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)

&& shouldMerge(endOfInsertedContent, next);

{

if (!a)

return false;

return a->hasTagName(h1Tag)

|| a->hasTagName(h2Tag)

|| a->hasTagName(h3Tag)

|| a->hasTagName(h4Tag)

|| a->hasTagName(h5Tag)

|| a->hasTagName(h6Tag);

{

if (source.isNull() || destination.isNull())

return false;

Node* sourceNode = source.deepEquivalent().deprecatedNode();

Node* destinationNode = destination.deepEquivalent().deprecatedNode();

Node* sourceBlock = enclosingBlock(sourceNode);

Node* destinationBlock = enclosingBlock(destinationNode);

return !enclosingNodeOfType(source.deepEquivalent(), &isMailPasteAsQuotationNode) &&

sourceBlock && (!sourceBlock->hasTagName(blockquoteTag) || isMailBlockquote(sourceBlock)) &&

enclosingListChild(sourceBlock) == enclosingListChild(destinationNode) &&

enclosingTableCell(source.deepEquivalent()) == enclosingTableCell(destination.deepEquivalent()) &&

(!isHeaderElement(sourceBlock) || haveSameTagName(sourceBlock, destinationBlock)) &&

// Don't merge to or from a position before or after a block because it would

// be a no-op and cause infinite recursion.

!isBlock(sourceNode) && !isBlock(destinationNode);

{

RefPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();

RefPtr<Node> next;

for (RefPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {

// FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance

next = NodeTraversal::next(*node);

if (!is<StyledElement>(*node))

continue;

StyledElement* element = downcast<StyledElement>(node.get());

const StyleProperties* inlineStyle = element->inlineStyle();

RefPtr<EditingStyle> newInlineStyle = EditingStyle::create(inlineStyle);

if (inlineStyle) {

if (is<HTMLElement>(*element)) {

Vector<QualifiedName> attributes;

HTMLElement& htmlElement = downcast<HTMLElement>(*element);

if (newInlineStyle->conflictsWithImplicitStyleOfElement(&htmlElement)) {

// e.g. <b style="font-weight: normal;"> is converted to <span style="font-weight: normal;">

node = replaceElementWithSpanPreservingChildrenAndAttributes(&htmlElement);

element = downcast<StyledElement>(node.get());

insertedNodes.didReplaceNode(&htmlElement, node.get());

} else if (newInlineStyle->extractConflictingImplicitStyleOfAttributes(&htmlElement, EditingStyle::PreserveWritingDirection, 0, attributes,

EditingStyle::DoNotExtractMatchingStyle)) {

// e.g. <font size="3" style="font-size: 20px;"> is converted to <font style="font-size: 20px;">

for (auto& attribute : attributes)

removeNodeAttribute(element, attribute);

}

}

ContainerNode* context = element->parentNode();

// If Mail wraps the fragment with a Paste as Quotation blockquote, or if you're pasting into a quoted region,

// styles from blockquoteNode are allowed to override those from the source document, see <rdar://problem/4930986> and <rdar://problem/5089327>.

Node* blockquoteNode = isMailPasteAsQuotationNode(context) ? context : enclosingNodeOfType(firstPositionInNode(context), isMailBlockquote, CanCrossEditingBoundary);

if (blockquoteNode)

newInlineStyle->removeStyleFromRulesAndContext(element, document().documentElement());

newInlineStyle->removeStyleFromRulesAndContext(element, context);

}

if (!inlineStyle || newInlineStyle->isEmpty()) {

if (isStyleSpanOrSpanWithOnlyStyleAttribute(element) || isEmptyFontTag(element, AllowNonEmptyStyleAttribute)) {

insertedNodes.willRemoveNodePreservingChildren(element);

removeNodePreservingChildren(element);

continue;

}

removeNodeAttribute(element, styleAttr);

} else if (newInlineStyle->style()->propertyCount() != inlineStyle->propertyCount())

setNodeAttribute(element, styleAttr, newInlineStyle->style()->asText());

// FIXME: Tolerate differences in id, class, and style attributes.

if (element->parentNode() && isNonTableCellHTMLBlockElement(element) && areIdenticalElements(element, element->parentNode())

&& VisiblePosition(firstPositionInNode(element->parentNode())) == VisiblePosition(firstPositionInNode(element))

&& VisiblePosition(lastPositionInNode(element->parentNode())) == VisiblePosition(lastPositionInNode(element))) {

insertedNodes.willRemoveNodePreservingChildren(element);

removeNodePreservingChildren(element);

continue;

}

if (element->parentNode() && element->parentNode()->hasRichlyEditableStyle())

removeNodeAttribute(element, contenteditableAttr);

// WebKit used to not add display: inline and float: none on copy.

// Keep this code around for backward compatibility

if (isLegacyAppleStyleSpan(element)) {

if (!element->firstChild()) {

insertedNodes.willRemoveNodePreservingChildren(element);

removeNodePreservingChildren(element);

continue;

}

// There are other styles that style rules can give to style spans,

// but these are the two important ones because they'll prevent

// inserted content from appearing in the right paragraph.

// FIXME: Hyatt is concerned that selectively using display:inline will give inconsistent

// results. We already know one issue because td elements ignore their display property

// in quirks mode (which Mail.app is always in). We should look for an alternative.

// Mutate using the CSSOM wrapper so we get the same event behavior as a script.

if (isBlock(element))

element->cssomStyle()->setPropertyInternal(CSSPropertyDisplay, "inline", false, IGNORE_EXCEPTION);

if (element->renderer() && element->renderer()->style().isFloating())

element->cssomStyle()->setPropertyInternal(CSSPropertyFloat, "none", false, IGNORE_EXCEPTION);

}

}

{

// https://dvcs.w3.org/hg/editing/raw-file/57abe6d3cb60/editing.html#prohibited-paragraph-child

static NeverDestroyed<HashSet<AtomicString>> elements;

if (elements.get().isEmpty()) {

elements.get().add(addressTag.localName());

elements.get().add(articleTag.localName());

elements.get().add(asideTag.localName());

elements.get().add(blockquoteTag.localName());

elements.get().add(captionTag.localName());

elements.get().add(centerTag.localName());

elements.get().add(colTag.localName());

elements.get().add(colgroupTag.localName());

elements.get().add(ddTag.localName());

elements.get().add(detailsTag.localName());

elements.get().add(dirTag.localName());

elements.get().add(divTag.localName());

elements.get().add(dlTag.localName());

elements.get().add(dtTag.localName());

elements.get().add(fieldsetTag.localName());

elements.get().add(figcaptionTag.localName());

elements.get().add(figureTag.localName());

elements.get().add(footerTag.localName());

elements.get().add(formTag.localName());

elements.get().add(h1Tag.localName());

elements.get().add(h2Tag.localName());

elements.get().add(h3Tag.localName());

elements.get().add(h4Tag.localName());

elements.get().add(h5Tag.localName());

elements.get().add(h6Tag.localName());

elements.get().add(headerTag.localName());

elements.get().add(hgroupTag.localName());

elements.get().add(hrTag.localName());

elements.get().add(liTag.localName());

elements.get().add(listingTag.localName());

elements.get().add(mainTag.localName()); // Missing in the specification.

elements.get().add(menuTag.localName());

elements.get().add(navTag.localName());

elements.get().add(olTag.localName());

elements.get().add(pTag.localName());

elements.get().add(plaintextTag.localName());

elements.get().add(preTag.localName());

elements.get().add(sectionTag.localName());

elements.get().add(summaryTag.localName());

elements.get().add(tableTag.localName());

elements.get().add(tbodyTag.localName());

elements.get().add(tdTag.localName());

elements.get().add(tfootTag.localName());

elements.get().add(thTag.localName());

elements.get().add(theadTag.localName());

elements.get().add(trTag.localName());

elements.get().add(ulTag.localName());

elements.get().add(xmpTag.localName());

}

return elements.get().contains(name);

{

RefPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();

RefPtr<Node> next;

for (RefPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {

next = NodeTraversal::next(*node);

if (!is<HTMLElement>(*node))

continue;

if (isProhibitedParagraphChild(downcast<HTMLElement>(*node).localName())) {

if (auto* paragraphElement = enclosingElementWithTag(positionInParentBeforeNode(node.get()), pTag)) {

auto* parent = paragraphElement->parentNode();

if (parent && parent->hasEditableStyle())

moveNodeOutOfAncestor(node, paragraphElement, insertedNodes);

}

}

if (isHeaderElement(node.get())) {

auto* headerElement = highestEnclosingNodeOfType(positionInParentBeforeNode(node.get()), isHeaderElement);

if (headerElement) {

if (headerElement->parentNode() && headerElement->parentNode()->isContentRichlyEditable())

moveNodeOutOfAncestor(node, headerElement, insertedNodes);

else {

HTMLElement* newSpanElement = replaceElementWithSpanPreservingChildrenAndAttributes(downcast<HTMLElement>(node.get()));

insertedNodes.didReplaceNode(node.get(), newSpanElement);

}

}

}

}

{

RefPtr<Node> node = prpNode;

RefPtr<Node> ancestor = prpAncestor;

VisiblePosition positionAtEndOfNode = lastPositionInOrAfterNode(node.get());

VisiblePosition lastPositionInParagraph = lastPositionInNode(ancestor.get());

if (positionAtEndOfNode == lastPositionInParagraph) {

removeNode(node);

if (ancestor->nextSibling())

insertNodeBefore(node, ancestor->nextSibling());

else

appendNode(node, ancestor->parentNode());

} else {

RefPtr<Node> nodeToSplitTo = splitTreeToNode(node.get(), ancestor.get(), true);

removeNode(node);

insertNodeBefore(node, nodeToSplitTo);

}

if (!ancestor->firstChild()) {

insertedNodes.willRemoveNode(ancestor.get());

removeNode(ancestor.release());

}

{

document().updateLayoutIgnorePendingStylesheets();

Node* lastLeafInserted = insertedNodes.lastLeafInserted();

if (is<Text>(lastLeafInserted) && !hasRenderedText(downcast<Text>(*lastLeafInserted))

&& !enclosingElementWithTag(firstPositionInOrBeforeNode(lastLeafInserted), selectTag)

&& !enclosingElementWithTag(firstPositionInOrBeforeNode(lastLeafInserted), scriptTag)) {

insertedNodes.willRemoveNode(lastLeafInserted);

removeNode(lastLeafInserted);

}

// We don't have to make sure that firstNodeInserted isn't inside a select or script element

// because it is a top level node in the fragment and the user can't insert into those elements.

Node* firstNodeInserted = insertedNodes.firstNodeInserted();

if (is<Text>(firstNodeInserted) && !hasRenderedText(downcast<Text>(*firstNodeInserted))) {

insertedNodes.willRemoveNode(firstNodeInserted);

removeNode(firstNodeInserted);

}

{

// FIXME: Why is this hack here? What's special about <select> tags?

auto* enclosingSelect = enclosingElementWithTag(m_endOfInsertedContent, selectTag);

return enclosingSelect ? lastPositionInOrAfterNode(enclosingSelect) : m_endOfInsertedContent;

{

if (fragment.isEmpty())

return;

Vector<Element*> toRemove;

auto it = descendantsOfType<Element>(*fragment.fragment()).begin();

auto end = descendantsOfType<Element>(*fragment.fragment()).end();

while (it != end) {

if (is<HTMLBaseElement>(*it) || is<HTMLLinkElement>(*it) || is<HTMLMetaElement>(*it) || is<HTMLStyleElement>(*it) || is<HTMLTitleElement>(*it)) {

toRemove.append(&*it);

it.traverseNextSkippingChildren();

continue;

}

++it;

}

for (auto& element : toRemove)

fragment.removeNode(element);

{

Node* topNode = fragment.firstChild();

// Handling the case where we are doing Paste as Quotation or pasting into quoted content is more complicated (see handleStyleSpans)

// and doesn't receive the optimization.

if (isMailPasteAsQuotationNode(topNode) || enclosingNodeOfType(firstPositionInOrBeforeNode(topNode), isMailBlockquote, CanCrossEditingBoundary))

return false;

// Either there are no style spans in the fragment or a WebKit client has added content to the fragment

// before inserting it. Look for and handle style spans after insertion.

if (!isLegacyAppleStyleSpan(topNode))

return false;

Node* wrappingStyleSpan = topNode;

RefPtr<EditingStyle> styleAtInsertionPos = EditingStyle::create(insertionPos.parentAnchoredEquivalent());

String styleText = styleAtInsertionPos->style()->asText();

// FIXME: This string comparison is a naive way of comparing two styles.

// We should be taking the diff and check that the diff is empty.

if (styleText != downcast<Element>(*wrappingStyleSpan).getAttribute(styleAttr))

return false;

fragment.removeNodePreservingChildren(wrappingStyleSpan);

return true;

{

HTMLElement* wrappingStyleSpan = nullptr;

// The style span that contains the source document's default style should be at

// the top of the fragment, but Mail sometimes adds a wrapper (for Paste As Quotation),

// so search for the top level style span instead of assuming it's at the top.

for (Node* node = insertedNodes.firstNodeInserted(); node; node = NodeTraversal::next(*node)) {

if (isLegacyAppleStyleSpan(node)) {

wrappingStyleSpan = downcast<HTMLElement>(node);

break;

}

}

// There might not be any style spans if we're pasting from another application or if

// we are here because of a document.execCommand("InsertHTML", ...) call.

if (!wrappingStyleSpan)

return;

RefPtr<EditingStyle> style = EditingStyle::create(wrappingStyleSpan->inlineStyle());

ContainerNode* context = wrappingStyleSpan->parentNode();

// If Mail wraps the fragment with a Paste as Quotation blockquote, or if you're pasting into a quoted region,

// styles from blockquoteNode are allowed to override those from the source document, see <rdar://problem/4930986> and <rdar://problem/5089327>.

Node* blockquoteNode = isMailPasteAsQuotationNode(context) ? context : enclosingNodeOfType(firstPositionInNode(context), isMailBlockquote, CanCrossEditingBoundary);

if (blockquoteNode)

context = document().documentElement();

// This operation requires that only editing styles to be removed from sourceDocumentStyle.

style->prepareToApplyAt(firstPositionInNode(context));

// Remove block properties in the span's style. This prevents properties that probably have no effect

// currently from affecting blocks later if the style is cloned for a new block element during a future

// editing operation.

// FIXME: They *can* have an effect currently if blocks beneath the style span aren't individually marked

// with block styles by the editing engine used to style them. WebKit doesn't do this, but others might.

style->removeBlockProperties();

if (style->isEmpty() || !wrappingStyleSpan->firstChild()) {

insertedNodes.willRemoveNodePreservingChildren(wrappingStyleSpan);

removeNodePreservingChildren(wrappingStyleSpan);

} else

setNodeAttribute(wrappingStyleSpan, styleAttr, style->style()->asText());

{

if (!m_shouldMergeEnd)

return;

VisiblePosition startOfInsertedContent(positionAtStartOfInsertedContent());

VisiblePosition endOfInsertedContent(positionAtEndOfInsertedContent());

// Bail to avoid infinite recursion.

if (m_movingParagraph) {

ASSERT_NOT_REACHED();

return;

}

// Merging two paragraphs will destroy the moved one's block styles. Always move the end of inserted forward

// to preserve the block style of the paragraph already in the document, unless the paragraph to move would

// include the what was the start of the selection that was pasted into, so that we preserve that paragraph's

// block styles.

bool mergeForward = !(inSameParagraph(startOfInsertedContent, endOfInsertedContent) && !isStartOfParagraph(startOfInsertedContent));

VisiblePosition destination = mergeForward ? endOfInsertedContent.next() : endOfInsertedContent;

VisiblePosition startOfParagraphToMove = mergeForward ? startOfParagraph(endOfInsertedContent) : endOfInsertedContent.next();

// Merging forward could result in deleting the destination anchor node.

// To avoid this, we add a placeholder node before the start of the paragraph.

if (endOfParagraph(startOfParagraphToMove) == destination) {

RefPtr<Node> placeholder = createBreakElement(document());

insertNodeBefore(placeholder, startOfParagraphToMove.deepEquivalent().deprecatedNode());

destination = VisiblePosition(positionBeforeNode(placeholder.get()));

}

moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination);

// Merging forward will remove m_endOfInsertedContent from the document.

if (mergeForward) {

if (m_startOfInsertedContent.isOrphan())

m_startOfInsertedContent = endingSelection().visibleStart().deepEquivalent();

m_endOfInsertedContent = endingSelection().visibleEnd().deepEquivalent();

// If we merged text nodes, m_endOfInsertedContent could be null. If this is the case, we use m_startOfInsertedContent.

if (m_endOfInsertedContent.isNull())

m_endOfInsertedContent = m_startOfInsertedContent;

}

{

// We don't want to skip over any block elements.

if (isBlock(node))

return false;

if (!node->isHTMLElement())

return false;

// We can skip over elements whose class attribute is

// one of our internal classes.

const HTMLElement* element = static_cast<const HTMLElement*>(node);

const AtomicString& classAttributeValue = element->getAttribute(classAttr);

if (classAttributeValue == AppleTabSpanClass

|| classAttributeValue == AppleConvertedSpace

|| classAttributeValue == ApplePasteAsQuotation)

return true;

return EditingStyle::elementIsStyledSpanOrHTMLEquivalent(element);

{

VisibleSelection selection = endingSelection();

ASSERT(selection.isCaretOrRange());

ASSERT(selection.start().deprecatedNode());

if (!selection.isNonOrphanedCaretOrRange() || !selection.start().deprecatedNode())

return;

if (!selection.rootEditableElement())

return;

// In plain text only regions, we create style-less fragments, so the inserted content will automatically

// match the style of the surrounding area and so we can avoid unnecessary work below for m_matchStyle.

if (!selection.isContentRichlyEditable())

m_matchStyle = false;

ReplacementFragment fragment(document(), m_documentFragment.get(), selection);

if (performTrivialReplace(fragment))

return;

// We can skip matching the style if the selection is plain text.

if ((selection.start().deprecatedNode()->renderer() && selection.start().deprecatedNode()->renderer()->style().userModify() == READ_WRITE_PLAINTEXT_ONLY)

&& (selection.end().deprecatedNode()->renderer() && selection.end().deprecatedNode()->renderer()->style().userModify() == READ_WRITE_PLAINTEXT_ONLY))

m_matchStyle = false;

if (m_matchStyle) {

m_insertionStyle = EditingStyle::create(selection.start());

m_insertionStyle->mergeTypingStyle(document());

}

VisiblePosition visibleStart = selection.visibleStart();

VisiblePosition visibleEnd = selection.visibleEnd();

bool selectionEndWasEndOfParagraph = isEndOfParagraph(visibleEnd);

bool selectionStartWasStartOfParagraph = isStartOfParagraph(visibleStart);

Node* startBlock = enclosingBlock(visibleStart.deepEquivalent().deprecatedNode());

Position insertionPos = selection.start();

bool shouldHandleMailBlockquote = enclosingNodeOfType(insertionPos, isMailBlockquote, CanCrossEditingBoundary) && !m_ignoreMailBlockquote;

bool selectionIsPlainText = !selection.isContentRichlyEditable();

Element* currentRoot = selection.rootEditableElement();

if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph && !shouldHandleMailBlockquote)

|| startBlock == currentRoot || isListItem(startBlock) || selectionIsPlainText)

m_preventNesting = false;

if (selection.isRange()) {

// When the end of the selection being pasted into is at the end of a paragraph, and that selection

// spans multiple blocks, not merging may leave an empty line.

// When the start of the selection being pasted into is at the start of a block, not merging

// will leave hanging block(s).

// Merge blocks if the start of the selection was in a Mail blockquote, since we handle

// that case specially to prevent nesting.

bool mergeBlocksAfterDelete = shouldHandleMailBlockquote || isEndOfParagraph(visibleEnd) || isStartOfBlock(visibleStart);

// FIXME: We should only expand to include fully selected special elements if we are copying a

// selection and pasting it on top of itself.

deleteSelection(false, mergeBlocksAfterDelete, true, false);

visibleStart = endingSelection().visibleStart();

if (fragment.hasInterchangeNewlineAtStart()) {

if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart)) {

if (!isEndOfEditableOrNonEditableContent(visibleStart))

setEndingSelection(visibleStart.next());

} else

insertParagraphSeparator();

}

insertionPos = endingSelection().start();

} else {

ASSERT(selection.isCaret());

if (fragment.hasInterchangeNewlineAtStart()) {

VisiblePosition next = visibleStart.next(CannotCrossEditingBoundary);

if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart) && next.isNotNull())

setEndingSelection(next);

else {

insertParagraphSeparator();

visibleStart = endingSelection().visibleStart();

}

}

// We split the current paragraph in two to avoid nesting the blocks from the fragment inside the current block.

// For example paste <div>foo</div><div>bar</div><div>baz</div> into <div>x^x</div>, where ^ is the caret.

// As long as the div styles are the same, visually you'd expect: <div>xbar</div><div>bar</div><div>bazx</div>,

// not <div>xbar<div>bar</div><div>bazx</div></div>.

// Don't do this if the selection started in a Mail blockquote.

if (m_preventNesting && !shouldHandleMailBlockquote && !isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart)) {

insertParagraphSeparator();

setEndingSelection(endingSelection().visibleStart().previous());

}

insertionPos = endingSelection().start();

}

// We don't want any of the pasted content to end up nested in a Mail blockquote, so first break

// out of any surrounding Mail blockquotes. Unless we're inserting in a table, in which case

// breaking the blockquote will prevent the content from actually being inserted in the table.

if (shouldHandleMailBlockquote && m_preventNesting && !(enclosingNodeOfType(insertionPos, &isTableStructureNode))) {

applyCommandToComposite(BreakBlockquoteCommand::create(document()));