78972c75226bdf54cb745497278763dc472a03b5
[WebKit-https.git] / Source / WebCore / editing / ReplaceSelectionCommand.cpp
1 /*
2  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2009, 2010, 2011 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "ReplaceSelectionCommand.h"
29
30 #include "ApplyStyleCommand.h"
31 #include "BeforeTextInsertedEvent.h"
32 #include "BreakBlockquoteCommand.h"
33 #include "CSSStyleDeclaration.h"
34 #include "Document.h"
35 #include "DocumentFragment.h"
36 #include "Element.h"
37 #include "ElementIterator.h"
38 #include "EventNames.h"
39 #include "ExceptionCodePlaceholder.h"
40 #include "Frame.h"
41 #include "FrameSelection.h"
42 #include "HTMLInputElement.h"
43 #include "HTMLNames.h"
44 #include "HTMLTitleElement.h"
45 #include "NodeList.h"
46 #include "NodeRenderStyle.h"
47 #include "RenderInline.h"
48 #include "RenderObject.h"
49 #include "RenderText.h"
50 #include "ReplaceDeleteFromTextNodeCommand.h"
51 #include "ReplaceInsertIntoTextNodeCommand.h"
52 #include "SimplifyMarkupCommand.h"
53 #include "SmartReplace.h"
54 #include "StyleProperties.h"
55 #include "Text.h"
56 #include "TextIterator.h"
57 #include "VisibleUnits.h"
58 #include "htmlediting.h"
59 #include "markup.h"
60 #include <wtf/NeverDestroyed.h>
61 #include <wtf/StdLibExtras.h>
62
63 namespace WebCore {
64
65 using namespace HTMLNames;
66
67 enum EFragmentType { EmptyFragment, SingleTextNodeFragment, TreeFragment };
68
69 // --- ReplacementFragment helper class
70
71 class ReplacementFragment {
72     WTF_MAKE_NONCOPYABLE(ReplacementFragment);
73 public:
74     ReplacementFragment(Document&, DocumentFragment*, const VisibleSelection&);
75
76     DocumentFragment* fragment() { return m_fragment.get(); }
77
78     Node* firstChild() const;
79     Node* lastChild() const;
80
81     bool isEmpty() const;
82     
83     bool hasInterchangeNewlineAtStart() const { return m_hasInterchangeNewlineAtStart; }
84     bool hasInterchangeNewlineAtEnd() const { return m_hasInterchangeNewlineAtEnd; }
85     
86     void removeNode(PassRefPtr<Node>);
87     void removeNodePreservingChildren(PassRefPtr<Node>);
88
89 private:
90     PassRefPtr<StyledElement> insertFragmentForTestRendering(Node* rootEditableNode);
91     void removeUnrenderedNodes(Node*);
92     void restoreAndRemoveTestRenderingNodesToFragment(StyledElement*);
93     void removeInterchangeNodes(Node*);
94     
95     void insertNodeBefore(PassRefPtr<Node> node, Node* refNode);
96
97     Document& document() { return *m_document; }
98
99     RefPtr<Document> m_document;
100     RefPtr<DocumentFragment> m_fragment;
101     bool m_hasInterchangeNewlineAtStart;
102     bool m_hasInterchangeNewlineAtEnd;
103 };
104
105 static bool isInterchangeNewlineNode(const Node *node)
106 {
107     DEPRECATED_DEFINE_STATIC_LOCAL(String, interchangeNewlineClassString, (AppleInterchangeNewline));
108     return node && node->hasTagName(brTag) && 
109            static_cast<const Element *>(node)->getAttribute(classAttr) == interchangeNewlineClassString;
110 }
111
112 static bool isInterchangeConvertedSpaceSpan(const Node *node)
113 {
114     DEPRECATED_DEFINE_STATIC_LOCAL(String, convertedSpaceSpanClassString, (AppleConvertedSpace));
115     return node->isHTMLElement() && 
116            static_cast<const HTMLElement *>(node)->getAttribute(classAttr) == convertedSpaceSpanClassString;
117 }
118
119 static Position positionAvoidingPrecedingNodes(Position pos)
120 {
121     // If we're already on a break, it's probably a placeholder and we shouldn't change our position.
122     if (editingIgnoresContent(pos.deprecatedNode()))
123         return pos;
124
125     // We also stop when changing block flow elements because even though the visual position is the
126     // same.  E.g.,
127     //   <div>foo^</div>^
128     // The two positions above are the same visual position, but we want to stay in the same block.
129     Node* enclosingBlockNode = enclosingBlock(pos.containerNode());
130     for (Position nextPosition = pos; nextPosition.containerNode() != enclosingBlockNode; pos = nextPosition) {
131         if (lineBreakExistsAtPosition(pos))
132             break;
133
134         if (pos.containerNode()->nonShadowBoundaryParentNode())
135             nextPosition = positionInParentAfterNode(pos.containerNode());
136         
137         if (nextPosition == pos 
138             || enclosingBlock(nextPosition.containerNode()) != enclosingBlockNode
139             || VisiblePosition(pos) != VisiblePosition(nextPosition))
140             break;
141     }
142     return pos;
143 }
144
145 ReplacementFragment::ReplacementFragment(Document& document, DocumentFragment* fragment, const VisibleSelection& selection)
146     : m_document(&document)
147     , m_fragment(fragment)
148     , m_hasInterchangeNewlineAtStart(false)
149     , m_hasInterchangeNewlineAtEnd(false)
150 {
151     if (!m_fragment)
152         return;
153     if (!m_fragment->firstChild())
154         return;
155     
156     RefPtr<Element> editableRoot = selection.rootEditableElement();
157     ASSERT(editableRoot);
158     if (!editableRoot)
159         return;
160     
161     Node* shadowAncestorNode = editableRoot->deprecatedShadowAncestorNode();
162     
163     if (!editableRoot->getAttributeEventListener(eventNames().webkitBeforeTextInsertedEvent) &&
164         // FIXME: Remove these checks once textareas and textfields actually register an event handler.
165         !(shadowAncestorNode && shadowAncestorNode->renderer() && shadowAncestorNode->renderer()->isTextControl()) &&
166         editableRoot->hasRichlyEditableStyle()) {
167         removeInterchangeNodes(m_fragment.get());
168         return;
169     }
170
171     RefPtr<StyledElement> holder = insertFragmentForTestRendering(editableRoot.get());
172     if (!holder) {
173         removeInterchangeNodes(m_fragment.get());
174         return;
175     }
176     
177     RefPtr<Range> range = VisibleSelection::selectionFromContentsOfNode(holder.get()).toNormalizedRange();
178     String text = plainText(range.get(), static_cast<TextIteratorBehavior>(TextIteratorEmitsOriginalText | TextIteratorIgnoresStyleVisibility));
179
180     removeInterchangeNodes(holder.get());
181     removeUnrenderedNodes(holder.get());
182     restoreAndRemoveTestRenderingNodesToFragment(holder.get());
183
184     // Give the root a chance to change the text.
185     Ref<BeforeTextInsertedEvent> event = BeforeTextInsertedEvent::create(text);
186     editableRoot->dispatchEvent(event);
187     if (text != event->text() || !editableRoot->hasRichlyEditableStyle()) {
188         restoreAndRemoveTestRenderingNodesToFragment(holder.get());
189
190         RefPtr<Range> range = selection.toNormalizedRange();
191         if (!range)
192             return;
193
194         m_fragment = createFragmentFromText(*range, event->text());
195         if (!m_fragment->firstChild())
196             return;
197
198         holder = insertFragmentForTestRendering(editableRoot.get());
199         removeInterchangeNodes(holder.get());
200         removeUnrenderedNodes(holder.get());
201         restoreAndRemoveTestRenderingNodesToFragment(holder.get());
202     }
203 }
204
205 bool ReplacementFragment::isEmpty() const
206 {
207     return (!m_fragment || !m_fragment->firstChild()) && !m_hasInterchangeNewlineAtStart && !m_hasInterchangeNewlineAtEnd;
208 }
209
210 Node *ReplacementFragment::firstChild() const 
211
212     return m_fragment ? m_fragment->firstChild() : 0; 
213 }
214
215 Node *ReplacementFragment::lastChild() const 
216
217     return m_fragment ? m_fragment->lastChild() : 0; 
218 }
219
220 void ReplacementFragment::removeNodePreservingChildren(PassRefPtr<Node> node)
221 {
222     if (!node)
223         return;
224
225     while (RefPtr<Node> n = node->firstChild()) {
226         removeNode(n);
227         insertNodeBefore(n.release(), node.get());
228     }
229     removeNode(node);
230 }
231
232 void ReplacementFragment::removeNode(PassRefPtr<Node> node)
233 {
234     if (!node)
235         return;
236     
237     ContainerNode* parent = node->nonShadowBoundaryParentNode();
238     if (!parent)
239         return;
240     
241     parent->removeChild(*node, ASSERT_NO_EXCEPTION);
242 }
243
244 void ReplacementFragment::insertNodeBefore(PassRefPtr<Node> node, Node* refNode)
245 {
246     if (!node || !refNode)
247         return;
248         
249     ContainerNode* parent = refNode->nonShadowBoundaryParentNode();
250     if (!parent)
251         return;
252         
253     parent->insertBefore(*node, refNode, ASSERT_NO_EXCEPTION);
254 }
255
256 PassRefPtr<StyledElement> ReplacementFragment::insertFragmentForTestRendering(Node* rootEditableElement)
257 {
258     RefPtr<StyledElement> holder = createDefaultParagraphElement(document());
259
260     holder->appendChild(*m_fragment, ASSERT_NO_EXCEPTION);
261     rootEditableElement->appendChild(holder.get(), ASSERT_NO_EXCEPTION);
262     document().updateLayoutIgnorePendingStylesheets();
263
264     return holder.release();
265 }
266
267 void ReplacementFragment::restoreAndRemoveTestRenderingNodesToFragment(StyledElement* holder)
268 {
269     if (!holder)
270         return;
271     
272     while (RefPtr<Node> node = holder->firstChild()) {
273         holder->removeChild(*node, ASSERT_NO_EXCEPTION);
274         m_fragment->appendChild(*node, ASSERT_NO_EXCEPTION);
275     }
276
277     removeNode(holder);
278 }
279
280 void ReplacementFragment::removeUnrenderedNodes(Node* holder)
281 {
282     Vector<RefPtr<Node>> unrendered;
283
284     for (Node* node = holder->firstChild(); node; node = NodeTraversal::next(*node, holder)) {
285         if (!isNodeRendered(node) && !isTableStructureNode(node))
286             unrendered.append(node);
287     }
288
289     for (auto& node : unrendered)
290         removeNode(node);
291 }
292
293 void ReplacementFragment::removeInterchangeNodes(Node* container)
294 {
295     m_hasInterchangeNewlineAtStart = false;
296     m_hasInterchangeNewlineAtEnd = false;
297
298     // Interchange newlines at the "start" of the incoming fragment must be
299     // either the first node in the fragment or the first leaf in the fragment.
300     Node* node = container->firstChild();
301     while (node) {
302         if (isInterchangeNewlineNode(node)) {
303             m_hasInterchangeNewlineAtStart = true;
304             removeNode(node);
305             break;
306         }
307         node = node->firstChild();
308     }
309     if (!container->hasChildNodes())
310         return;
311     // Interchange newlines at the "end" of the incoming fragment must be
312     // either the last node in the fragment or the last leaf in the fragment.
313     node = container->lastChild();
314     while (node) {
315         if (isInterchangeNewlineNode(node)) {
316             m_hasInterchangeNewlineAtEnd = true;
317             removeNode(node);
318             break;
319         }
320         node = node->lastChild();
321     }
322     
323     node = container->firstChild();
324     while (node) {
325         RefPtr<Node> next = NodeTraversal::next(*node);
326         if (isInterchangeConvertedSpaceSpan(node)) {
327             next = NodeTraversal::nextSkippingChildren(*node);
328             removeNodePreservingChildren(node);
329         }
330         node = next.get();
331     }
332 }
333
334 inline void ReplaceSelectionCommand::InsertedNodes::respondToNodeInsertion(Node* node)
335 {
336     if (!node)
337         return;
338     
339     if (!m_firstNodeInserted)
340         m_firstNodeInserted = node;
341     
342     m_lastNodeInserted = node;
343 }
344
345 inline void ReplaceSelectionCommand::InsertedNodes::willRemoveNodePreservingChildren(Node* node)
346 {
347     if (m_firstNodeInserted == node)
348         m_firstNodeInserted = NodeTraversal::next(*node);
349     if (m_lastNodeInserted == node)
350         m_lastNodeInserted = node->lastChild() ? node->lastChild() : NodeTraversal::nextSkippingChildren(*node);
351 }
352
353 inline void ReplaceSelectionCommand::InsertedNodes::willRemoveNode(Node* node)
354 {
355     if (m_firstNodeInserted == node && m_lastNodeInserted == node) {
356         m_firstNodeInserted = nullptr;
357         m_lastNodeInserted = nullptr;
358     } else if (m_firstNodeInserted == node)
359         m_firstNodeInserted = NodeTraversal::nextSkippingChildren(*m_firstNodeInserted);
360     else if (m_lastNodeInserted == node)
361         m_lastNodeInserted = NodeTraversal::previousSkippingChildren(*m_lastNodeInserted);
362 }
363
364 inline void ReplaceSelectionCommand::InsertedNodes::didReplaceNode(Node* node, Node* newNode)
365 {
366     if (m_firstNodeInserted == node)
367         m_firstNodeInserted = newNode;
368     if (m_lastNodeInserted == node)
369         m_lastNodeInserted = newNode;
370 }
371
372 ReplaceSelectionCommand::ReplaceSelectionCommand(Document& document, RefPtr<DocumentFragment>&& fragment, CommandOptions options, EditAction editAction)
373     : CompositeEditCommand(document, editAction)
374     , m_selectReplacement(options & SelectReplacement)
375     , m_smartReplace(options & SmartReplace)
376     , m_matchStyle(options & MatchStyle)
377     , m_documentFragment(fragment)
378     , m_preventNesting(options & PreventNesting)
379     , m_movingParagraph(options & MovingParagraph)
380     , m_sanitizeFragment(options & SanitizeFragment)
381     , m_shouldMergeEnd(false)
382     , m_ignoreMailBlockquote(options & IgnoreMailBlockquote)
383 {
384 }
385
386 static bool hasMatchingQuoteLevel(VisiblePosition endOfExistingContent, VisiblePosition endOfInsertedContent)
387 {
388     Position existing = endOfExistingContent.deepEquivalent();
389     Position inserted = endOfInsertedContent.deepEquivalent();
390     bool isInsideMailBlockquote = enclosingNodeOfType(inserted, isMailBlockquote, CanCrossEditingBoundary);
391     return isInsideMailBlockquote && (numEnclosingMailBlockquotes(existing) == numEnclosingMailBlockquotes(inserted));
392 }
393
394 bool ReplaceSelectionCommand::shouldMergeStart(bool selectionStartWasStartOfParagraph, bool fragmentHasInterchangeNewlineAtStart, bool selectionStartWasInsideMailBlockquote)
395 {
396     if (m_movingParagraph)
397         return false;
398     
399     VisiblePosition startOfInsertedContent(positionAtStartOfInsertedContent());
400     VisiblePosition prev = startOfInsertedContent.previous(CannotCrossEditingBoundary);
401     if (prev.isNull())
402         return false;
403     
404     // When we have matching quote levels, its ok to merge more frequently.
405     // For a successful merge, we still need to make sure that the inserted content starts with the beginning of a paragraph.
406     // And we should only merge here if the selection start was inside a mail blockquote.  This prevents against removing a 
407     // blockquote from newly pasted quoted content that was pasted into an unquoted position.  If that unquoted position happens 
408     // to be right after another blockquote, we don't want to merge and risk stripping a valid block (and newline) from the pasted content.
409     if (isStartOfParagraph(startOfInsertedContent) && selectionStartWasInsideMailBlockquote && hasMatchingQuoteLevel(prev, positionAtEndOfInsertedContent()))
410         return true;
411
412     return !selectionStartWasStartOfParagraph
413         && !fragmentHasInterchangeNewlineAtStart
414         && isStartOfParagraph(startOfInsertedContent)
415         && !startOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)
416         && shouldMerge(startOfInsertedContent, prev);
417 }
418
419 bool ReplaceSelectionCommand::shouldMergeEnd(bool selectionEndWasEndOfParagraph)
420 {
421     VisiblePosition endOfInsertedContent(positionAtEndOfInsertedContent());
422     VisiblePosition next = endOfInsertedContent.next(CannotCrossEditingBoundary);
423     if (next.isNull())
424         return false;
425
426     return !selectionEndWasEndOfParagraph
427         && isEndOfParagraph(endOfInsertedContent)
428         && !endOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)
429         && shouldMerge(endOfInsertedContent, next);
430 }
431
432 static bool isMailPasteAsQuotationNode(const Node* node)
433 {
434     return node && node->hasTagName(blockquoteTag) && downcast<Element>(node)->getAttribute(classAttr) == ApplePasteAsQuotation;
435 }
436
437 static bool isHeaderElement(const Node* a)
438 {
439     if (!a)
440         return false;
441         
442     return a->hasTagName(h1Tag)
443         || a->hasTagName(h2Tag)
444         || a->hasTagName(h3Tag)
445         || a->hasTagName(h4Tag)
446         || a->hasTagName(h5Tag)
447         || a->hasTagName(h6Tag);
448 }
449
450 static bool haveSameTagName(Node* a, Node* b)
451 {
452     return is<Element>(a) && is<Element>(b) && downcast<Element>(*a).tagName() == downcast<Element>(*b).tagName();
453 }
454
455 bool ReplaceSelectionCommand::shouldMerge(const VisiblePosition& source, const VisiblePosition& destination)
456 {
457     if (source.isNull() || destination.isNull())
458         return false;
459         
460     Node* sourceNode = source.deepEquivalent().deprecatedNode();
461     Node* destinationNode = destination.deepEquivalent().deprecatedNode();
462     Node* sourceBlock = enclosingBlock(sourceNode);
463     Node* destinationBlock = enclosingBlock(destinationNode);
464     return !enclosingNodeOfType(source.deepEquivalent(), &isMailPasteAsQuotationNode) &&
465            sourceBlock && (!sourceBlock->hasTagName(blockquoteTag) || isMailBlockquote(sourceBlock))  &&
466            enclosingListChild(sourceBlock) == enclosingListChild(destinationNode) &&
467            enclosingTableCell(source.deepEquivalent()) == enclosingTableCell(destination.deepEquivalent()) &&
468            (!isHeaderElement(sourceBlock) || haveSameTagName(sourceBlock, destinationBlock)) &&
469            // Don't merge to or from a position before or after a block because it would
470            // be a no-op and cause infinite recursion.
471            !isBlock(sourceNode) && !isBlock(destinationNode);
472 }
473
474 // Style rules that match just inserted elements could change their appearance, like
475 // a div inserted into a document with div { display:inline; }.
476 void ReplaceSelectionCommand::removeRedundantStylesAndKeepStyleSpanInline(InsertedNodes& insertedNodes)
477 {
478     RefPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
479     RefPtr<Node> next;
480     for (RefPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
481         // FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance
482
483         next = NodeTraversal::next(*node);
484         if (!is<StyledElement>(*node))
485             continue;
486
487         StyledElement* element = downcast<StyledElement>(node.get());
488
489         const StyleProperties* inlineStyle = element->inlineStyle();
490         RefPtr<EditingStyle> newInlineStyle = EditingStyle::create(inlineStyle);
491         if (inlineStyle) {
492             if (is<HTMLElement>(*element)) {
493                 Vector<QualifiedName> attributes;
494                 HTMLElement& htmlElement = downcast<HTMLElement>(*element);
495
496                 if (newInlineStyle->conflictsWithImplicitStyleOfElement(&htmlElement)) {
497                     // e.g. <b style="font-weight: normal;"> is converted to <span style="font-weight: normal;">
498                     node = replaceElementWithSpanPreservingChildrenAndAttributes(&htmlElement);
499                     element = downcast<StyledElement>(node.get());
500                     insertedNodes.didReplaceNode(&htmlElement, node.get());
501                 } else if (newInlineStyle->extractConflictingImplicitStyleOfAttributes(&htmlElement, EditingStyle::PreserveWritingDirection, 0, attributes,
502                     EditingStyle::DoNotExtractMatchingStyle)) {
503                     // e.g. <font size="3" style="font-size: 20px;"> is converted to <font style="font-size: 20px;">
504                     for (auto& attribute : attributes)
505                         removeNodeAttribute(element, attribute);
506                 }
507             }
508
509             ContainerNode* context = element->parentNode();
510
511             // If Mail wraps the fragment with a Paste as Quotation blockquote, or if you're pasting into a quoted region,
512             // styles from blockquoteNode are allowed to override those from the source document, see <rdar://problem/4930986> and <rdar://problem/5089327>.
513             Node* blockquoteNode = isMailPasteAsQuotationNode(context) ? context : enclosingNodeOfType(firstPositionInNode(context), isMailBlockquote, CanCrossEditingBoundary);
514             if (blockquoteNode)
515                 newInlineStyle->removeStyleFromRulesAndContext(element, document().documentElement());
516
517             newInlineStyle->removeStyleFromRulesAndContext(element, context);
518         }
519
520         if (!inlineStyle || newInlineStyle->isEmpty()) {
521             if (isStyleSpanOrSpanWithOnlyStyleAttribute(element) || isEmptyFontTag(element, AllowNonEmptyStyleAttribute)) {
522                 insertedNodes.willRemoveNodePreservingChildren(element);
523                 removeNodePreservingChildren(element);
524                 continue;
525             }
526             removeNodeAttribute(element, styleAttr);
527         } else if (newInlineStyle->style()->propertyCount() != inlineStyle->propertyCount())
528             setNodeAttribute(element, styleAttr, newInlineStyle->style()->asText());
529
530         // FIXME: Tolerate differences in id, class, and style attributes.
531         if (element->parentNode() && isNonTableCellHTMLBlockElement(element) && areIdenticalElements(element, element->parentNode())
532             && VisiblePosition(firstPositionInNode(element->parentNode())) == VisiblePosition(firstPositionInNode(element))
533             && VisiblePosition(lastPositionInNode(element->parentNode())) == VisiblePosition(lastPositionInNode(element))) {
534             insertedNodes.willRemoveNodePreservingChildren(element);
535             removeNodePreservingChildren(element);
536             continue;
537         }
538
539         if (element->parentNode() && element->parentNode()->hasRichlyEditableStyle())
540             removeNodeAttribute(element, contenteditableAttr);
541
542         // WebKit used to not add display: inline and float: none on copy.
543         // Keep this code around for backward compatibility
544         if (isLegacyAppleStyleSpan(element)) {
545             if (!element->firstChild()) {
546                 insertedNodes.willRemoveNodePreservingChildren(element);
547                 removeNodePreservingChildren(element);
548                 continue;
549             }
550             // There are other styles that style rules can give to style spans,
551             // but these are the two important ones because they'll prevent
552             // inserted content from appearing in the right paragraph.
553             // FIXME: Hyatt is concerned that selectively using display:inline will give inconsistent
554             // results. We already know one issue because td elements ignore their display property
555             // in quirks mode (which Mail.app is always in). We should look for an alternative.
556
557             // Mutate using the CSSOM wrapper so we get the same event behavior as a script.
558             if (isBlock(element))
559                 element->style()->setPropertyInternal(CSSPropertyDisplay, "inline", false, IGNORE_EXCEPTION);
560             if (element->renderer() && element->renderer()->style().isFloating())
561                 element->style()->setPropertyInternal(CSSPropertyFloat, "none", false, IGNORE_EXCEPTION);
562         }
563     }
564 }
565
566 static bool isProhibitedParagraphChild(const AtomicString& name)
567 {
568     // https://dvcs.w3.org/hg/editing/raw-file/57abe6d3cb60/editing.html#prohibited-paragraph-child
569     static NeverDestroyed<HashSet<AtomicString>> elements;
570     if (elements.get().isEmpty()) {
571         elements.get().add(addressTag.localName());
572         elements.get().add(articleTag.localName());
573         elements.get().add(asideTag.localName());
574         elements.get().add(blockquoteTag.localName());
575         elements.get().add(captionTag.localName());
576         elements.get().add(centerTag.localName());
577         elements.get().add(colTag.localName());
578         elements.get().add(colgroupTag.localName());
579         elements.get().add(ddTag.localName());
580         elements.get().add(detailsTag.localName());
581         elements.get().add(dirTag.localName());
582         elements.get().add(divTag.localName());
583         elements.get().add(dlTag.localName());
584         elements.get().add(dtTag.localName());
585         elements.get().add(fieldsetTag.localName());
586         elements.get().add(figcaptionTag.localName());
587         elements.get().add(figureTag.localName());
588         elements.get().add(footerTag.localName());
589         elements.get().add(formTag.localName());
590         elements.get().add(h1Tag.localName());
591         elements.get().add(h2Tag.localName());
592         elements.get().add(h3Tag.localName());
593         elements.get().add(h4Tag.localName());
594         elements.get().add(h5Tag.localName());
595         elements.get().add(h6Tag.localName());
596         elements.get().add(headerTag.localName());
597         elements.get().add(hgroupTag.localName());
598         elements.get().add(hrTag.localName());
599         elements.get().add(liTag.localName());
600         elements.get().add(listingTag.localName());
601         elements.get().add(mainTag.localName()); // Missing in the specification.
602         elements.get().add(menuTag.localName());
603         elements.get().add(navTag.localName());
604         elements.get().add(olTag.localName());
605         elements.get().add(pTag.localName());
606         elements.get().add(plaintextTag.localName());
607         elements.get().add(preTag.localName());
608         elements.get().add(sectionTag.localName());
609         elements.get().add(summaryTag.localName());
610         elements.get().add(tableTag.localName());
611         elements.get().add(tbodyTag.localName());
612         elements.get().add(tdTag.localName());
613         elements.get().add(tfootTag.localName());
614         elements.get().add(thTag.localName());
615         elements.get().add(theadTag.localName());
616         elements.get().add(trTag.localName());
617         elements.get().add(ulTag.localName());
618         elements.get().add(xmpTag.localName());
619     }
620     return elements.get().contains(name);
621 }
622
623 void ReplaceSelectionCommand::makeInsertedContentRoundTrippableWithHTMLTreeBuilder(InsertedNodes& insertedNodes)
624 {
625     RefPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
626     RefPtr<Node> next;
627     for (RefPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
628         next = NodeTraversal::next(*node);
629
630         if (!is<HTMLElement>(*node))
631             continue;
632
633         if (isProhibitedParagraphChild(downcast<HTMLElement>(*node).localName())) {
634             if (auto* paragraphElement = enclosingElementWithTag(positionInParentBeforeNode(node.get()), pTag)) {
635                 auto* parent = paragraphElement->parentNode();
636                 if (parent && parent->hasEditableStyle())
637                     moveNodeOutOfAncestor(node, paragraphElement, insertedNodes);
638             }
639         }
640
641         if (isHeaderElement(node.get())) {
642             auto* headerElement = highestEnclosingNodeOfType(positionInParentBeforeNode(node.get()), isHeaderElement);
643             if (headerElement) {
644                 if (headerElement->parentNode() && headerElement->parentNode()->isContentRichlyEditable())
645                     moveNodeOutOfAncestor(node, headerElement, insertedNodes);
646                 else {
647                     HTMLElement* newSpanElement = replaceElementWithSpanPreservingChildrenAndAttributes(downcast<HTMLElement>(node.get()));
648                     insertedNodes.didReplaceNode(node.get(), newSpanElement);
649                 }
650             }
651         }
652     }
653 }
654
655 void ReplaceSelectionCommand::moveNodeOutOfAncestor(PassRefPtr<Node> prpNode, PassRefPtr<Node> prpAncestor, InsertedNodes& insertedNodes)
656 {
657     RefPtr<Node> node = prpNode;
658     RefPtr<Node> ancestor = prpAncestor;
659
660     VisiblePosition positionAtEndOfNode = lastPositionInOrAfterNode(node.get());
661     VisiblePosition lastPositionInParagraph = lastPositionInNode(ancestor.get());
662     if (positionAtEndOfNode == lastPositionInParagraph) {
663         removeNode(node);
664         if (ancestor->nextSibling())
665             insertNodeBefore(node, ancestor->nextSibling());
666         else
667             appendNode(node, ancestor->parentNode());
668     } else {
669         RefPtr<Node> nodeToSplitTo = splitTreeToNode(node.get(), ancestor.get(), true);
670         removeNode(node);
671         insertNodeBefore(node, nodeToSplitTo);
672     }
673     if (!ancestor->firstChild()) {
674         insertedNodes.willRemoveNode(ancestor.get());
675         removeNode(ancestor.release());
676     }
677 }
678
679 static inline bool hasRenderedText(const Text& text)
680 {
681     return text.renderer() && text.renderer()->hasRenderedText();
682 }
683
684 void ReplaceSelectionCommand::removeUnrenderedTextNodesAtEnds(InsertedNodes& insertedNodes)
685 {
686     document().updateLayoutIgnorePendingStylesheets();
687
688     Node* lastLeafInserted = insertedNodes.lastLeafInserted();
689     if (is<Text>(lastLeafInserted) && !hasRenderedText(downcast<Text>(*lastLeafInserted))
690         && !enclosingElementWithTag(firstPositionInOrBeforeNode(lastLeafInserted), selectTag)
691         && !enclosingElementWithTag(firstPositionInOrBeforeNode(lastLeafInserted), scriptTag)) {
692         insertedNodes.willRemoveNode(lastLeafInserted);
693         removeNode(lastLeafInserted);
694     }
695
696     // We don't have to make sure that firstNodeInserted isn't inside a select or script element
697     // because it is a top level node in the fragment and the user can't insert into those elements.
698     Node* firstNodeInserted = insertedNodes.firstNodeInserted();
699     if (is<Text>(firstNodeInserted) && !hasRenderedText(downcast<Text>(*firstNodeInserted))) {
700         insertedNodes.willRemoveNode(firstNodeInserted);
701         removeNode(firstNodeInserted);
702     }
703 }
704
705 VisiblePosition ReplaceSelectionCommand::positionAtEndOfInsertedContent() const
706 {
707     // FIXME: Why is this hack here?  What's special about <select> tags?
708     auto* enclosingSelect = enclosingElementWithTag(m_endOfInsertedContent, selectTag);
709     return enclosingSelect ? lastPositionInOrAfterNode(enclosingSelect) : m_endOfInsertedContent;
710 }
711
712 VisiblePosition ReplaceSelectionCommand::positionAtStartOfInsertedContent() const
713 {
714     return m_startOfInsertedContent;
715 }
716
717 static void removeHeadContents(ReplacementFragment& fragment)
718 {
719     if (fragment.isEmpty())
720         return;
721
722     Vector<Element*> toRemove;
723
724     auto it = descendantsOfType<Element>(*fragment.fragment()).begin();
725     auto end = descendantsOfType<Element>(*fragment.fragment()).end();
726     while (it != end) {
727         if (is<HTMLBaseElement>(*it) || is<HTMLLinkElement>(*it) || is<HTMLMetaElement>(*it) || is<HTMLStyleElement>(*it) || is<HTMLTitleElement>(*it)) {
728             toRemove.append(&*it);
729             it.traverseNextSkippingChildren();
730             continue;
731         }
732         ++it;
733     }
734
735     for (auto& element : toRemove)
736         fragment.removeNode(element);
737 }
738
739 // Remove style spans before insertion if they are unnecessary.  It's faster because we'll 
740 // avoid doing a layout.
741 static bool handleStyleSpansBeforeInsertion(ReplacementFragment& fragment, const Position& insertionPos)
742 {
743     Node* topNode = fragment.firstChild();
744
745     // Handling the case where we are doing Paste as Quotation or pasting into quoted content is more complicated (see handleStyleSpans)
746     // and doesn't receive the optimization.
747     if (isMailPasteAsQuotationNode(topNode) || enclosingNodeOfType(firstPositionInOrBeforeNode(topNode), isMailBlockquote, CanCrossEditingBoundary))
748         return false;
749
750     // Either there are no style spans in the fragment or a WebKit client has added content to the fragment
751     // before inserting it.  Look for and handle style spans after insertion.
752     if (!isLegacyAppleStyleSpan(topNode))
753         return false;
754
755     Node* wrappingStyleSpan = topNode;
756     RefPtr<EditingStyle> styleAtInsertionPos = EditingStyle::create(insertionPos.parentAnchoredEquivalent());
757     String styleText = styleAtInsertionPos->style()->asText();
758
759     // FIXME: This string comparison is a naive way of comparing two styles.
760     // We should be taking the diff and check that the diff is empty.
761     if (styleText != downcast<Element>(*wrappingStyleSpan).getAttribute(styleAttr))
762         return false;
763
764     fragment.removeNodePreservingChildren(wrappingStyleSpan);
765     return true;
766 }
767
768 // At copy time, WebKit wraps copied content in a span that contains the source document's 
769 // default styles.  If the copied Range inherits any other styles from its ancestors, we put 
770 // those styles on a second span.
771 // This function removes redundant styles from those spans, and removes the spans if all their 
772 // styles are redundant. 
773 // We should remove the Apple-style-span class when we're done, see <rdar://problem/5685600>.
774 // We should remove styles from spans that are overridden by all of their children, either here
775 // or at copy time.
776 void ReplaceSelectionCommand::handleStyleSpans(InsertedNodes& insertedNodes)
777 {
778     HTMLElement* wrappingStyleSpan = nullptr;
779     // The style span that contains the source document's default style should be at
780     // the top of the fragment, but Mail sometimes adds a wrapper (for Paste As Quotation),
781     // so search for the top level style span instead of assuming it's at the top.
782     for (Node* node = insertedNodes.firstNodeInserted(); node; node = NodeTraversal::next(*node)) {
783         if (isLegacyAppleStyleSpan(node)) {
784             wrappingStyleSpan = downcast<HTMLElement>(node);
785             break;
786         }
787     }
788     
789     // There might not be any style spans if we're pasting from another application or if 
790     // we are here because of a document.execCommand("InsertHTML", ...) call.
791     if (!wrappingStyleSpan)
792         return;
793
794     RefPtr<EditingStyle> style = EditingStyle::create(wrappingStyleSpan->inlineStyle());
795     ContainerNode* context = wrappingStyleSpan->parentNode();
796
797     // If Mail wraps the fragment with a Paste as Quotation blockquote, or if you're pasting into a quoted region,
798     // styles from blockquoteNode are allowed to override those from the source document, see <rdar://problem/4930986> and <rdar://problem/5089327>.
799     Node* blockquoteNode = isMailPasteAsQuotationNode(context) ? context : enclosingNodeOfType(firstPositionInNode(context), isMailBlockquote, CanCrossEditingBoundary);
800     if (blockquoteNode)
801         context = document().documentElement();
802
803     // This operation requires that only editing styles to be removed from sourceDocumentStyle.
804     style->prepareToApplyAt(firstPositionInNode(context));
805
806     // Remove block properties in the span's style. This prevents properties that probably have no effect 
807     // currently from affecting blocks later if the style is cloned for a new block element during a future 
808     // editing operation.
809     // FIXME: They *can* have an effect currently if blocks beneath the style span aren't individually marked
810     // with block styles by the editing engine used to style them.  WebKit doesn't do this, but others might.
811     style->removeBlockProperties();
812
813     if (style->isEmpty() || !wrappingStyleSpan->firstChild()) {
814         insertedNodes.willRemoveNodePreservingChildren(wrappingStyleSpan);
815         removeNodePreservingChildren(wrappingStyleSpan);
816     } else
817         setNodeAttribute(wrappingStyleSpan, styleAttr, style->style()->asText());
818 }
819
820 void ReplaceSelectionCommand::mergeEndIfNeeded()
821 {
822     if (!m_shouldMergeEnd)
823         return;
824
825     VisiblePosition startOfInsertedContent(positionAtStartOfInsertedContent());
826     VisiblePosition endOfInsertedContent(positionAtEndOfInsertedContent());
827     
828     // Bail to avoid infinite recursion.
829     if (m_movingParagraph) {
830         ASSERT_NOT_REACHED();
831         return;
832     }
833     
834     // Merging two paragraphs will destroy the moved one's block styles.  Always move the end of inserted forward 
835     // to preserve the block style of the paragraph already in the document, unless the paragraph to move would 
836     // include the what was the start of the selection that was pasted into, so that we preserve that paragraph's
837     // block styles.
838     bool mergeForward = !(inSameParagraph(startOfInsertedContent, endOfInsertedContent) && !isStartOfParagraph(startOfInsertedContent));
839     
840     VisiblePosition destination = mergeForward ? endOfInsertedContent.next() : endOfInsertedContent;
841     VisiblePosition startOfParagraphToMove = mergeForward ? startOfParagraph(endOfInsertedContent) : endOfInsertedContent.next();
842    
843     // Merging forward could result in deleting the destination anchor node.
844     // To avoid this, we add a placeholder node before the start of the paragraph.
845     if (endOfParagraph(startOfParagraphToMove) == destination) {
846         RefPtr<Node> placeholder = createBreakElement(document());
847         insertNodeBefore(placeholder, startOfParagraphToMove.deepEquivalent().deprecatedNode());
848         destination = VisiblePosition(positionBeforeNode(placeholder.get()));
849     }
850
851     moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination);
852     
853     // Merging forward will remove m_endOfInsertedContent from the document.
854     if (mergeForward) {
855         if (m_startOfInsertedContent.isOrphan())
856             m_startOfInsertedContent = endingSelection().visibleStart().deepEquivalent();
857          m_endOfInsertedContent = endingSelection().visibleEnd().deepEquivalent();
858         // If we merged text nodes, m_endOfInsertedContent could be null. If this is the case, we use m_startOfInsertedContent.
859         if (m_endOfInsertedContent.isNull())
860             m_endOfInsertedContent = m_startOfInsertedContent;
861     }
862 }
863
864 static Node* enclosingInline(Node* node)
865 {
866     while (ContainerNode* parent = node->parentNode()) {
867         if (isBlockFlowElement(parent) || parent->hasTagName(bodyTag))
868             return node;
869         // Stop if any previous sibling is a block.
870         for (Node* sibling = node->previousSibling(); sibling; sibling = sibling->previousSibling()) {
871             if (isBlockFlowElement(sibling))
872                 return node;
873         }
874         node = parent;
875     }
876     return node;
877 }
878
879 static bool isInlineNodeWithStyle(const Node* node)
880 {
881     // We don't want to skip over any block elements.
882     if (isBlock(node))
883         return false;
884
885     if (!node->isHTMLElement())
886         return false;
887
888     // We can skip over elements whose class attribute is
889     // one of our internal classes.
890     const HTMLElement* element = static_cast<const HTMLElement*>(node);
891     const AtomicString& classAttributeValue = element->getAttribute(classAttr);
892     if (classAttributeValue == AppleTabSpanClass
893         || classAttributeValue == AppleConvertedSpace
894         || classAttributeValue == ApplePasteAsQuotation)
895         return true;
896
897     return EditingStyle::elementIsStyledSpanOrHTMLEquivalent(element);
898 }
899
900 inline Node* nodeToSplitToAvoidPastingIntoInlineNodesWithStyle(const Position& insertionPos)
901 {
902     Node* containgBlock = enclosingBlock(insertionPos.containerNode());
903     return highestEnclosingNodeOfType(insertionPos, isInlineNodeWithStyle, CannotCrossEditingBoundary, containgBlock);
904 }
905
906 void ReplaceSelectionCommand::doApply()
907 {
908     VisibleSelection selection = endingSelection();
909     ASSERT(selection.isCaretOrRange());
910     ASSERT(selection.start().deprecatedNode());
911     if (!selection.isNonOrphanedCaretOrRange() || !selection.start().deprecatedNode())
912         return;
913
914     if (!selection.rootEditableElement())
915         return;
916
917     // In plain text only regions, we create style-less fragments, so the inserted content will automatically
918     // match the style of the surrounding area and so we can avoid unnecessary work below for m_matchStyle.
919     if (!selection.isContentRichlyEditable())
920         m_matchStyle = false;
921
922     ReplacementFragment fragment(document(), m_documentFragment.get(), selection);
923     if (performTrivialReplace(fragment))
924         return;
925     
926     // We can skip matching the style if the selection is plain text.
927     if ((selection.start().deprecatedNode()->renderer() && selection.start().deprecatedNode()->renderer()->style().userModify() == READ_WRITE_PLAINTEXT_ONLY)
928         && (selection.end().deprecatedNode()->renderer() && selection.end().deprecatedNode()->renderer()->style().userModify() == READ_WRITE_PLAINTEXT_ONLY))
929         m_matchStyle = false;
930     
931     if (m_matchStyle) {
932         m_insertionStyle = EditingStyle::create(selection.start());
933         m_insertionStyle->mergeTypingStyle(document());
934     }
935
936     VisiblePosition visibleStart = selection.visibleStart();
937     VisiblePosition visibleEnd = selection.visibleEnd();
938     
939     bool selectionEndWasEndOfParagraph = isEndOfParagraph(visibleEnd);
940     bool selectionStartWasStartOfParagraph = isStartOfParagraph(visibleStart);
941     
942     Node* startBlock = enclosingBlock(visibleStart.deepEquivalent().deprecatedNode());
943     
944     Position insertionPos = selection.start();
945     bool shouldHandleMailBlockquote = enclosingNodeOfType(insertionPos, isMailBlockquote, CanCrossEditingBoundary) && !m_ignoreMailBlockquote;
946     bool selectionIsPlainText = !selection.isContentRichlyEditable();
947     Element* currentRoot = selection.rootEditableElement();
948
949     if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph && !shouldHandleMailBlockquote)
950         || startBlock == currentRoot || isListItem(startBlock) || selectionIsPlainText)
951         m_preventNesting = false;
952     
953     if (selection.isRange()) {
954         // When the end of the selection being pasted into is at the end of a paragraph, and that selection
955         // spans multiple blocks, not merging may leave an empty line.
956         // When the start of the selection being pasted into is at the start of a block, not merging 
957         // will leave hanging block(s).
958         // Merge blocks if the start of the selection was in a Mail blockquote, since we handle  
959         // that case specially to prevent nesting. 
960         bool mergeBlocksAfterDelete = shouldHandleMailBlockquote || isEndOfParagraph(visibleEnd) || isStartOfBlock(visibleStart);
961         // FIXME: We should only expand to include fully selected special elements if we are copying a 
962         // selection and pasting it on top of itself.
963         deleteSelection(false, mergeBlocksAfterDelete, true, false);
964         visibleStart = endingSelection().visibleStart();
965         if (fragment.hasInterchangeNewlineAtStart()) {
966             if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart)) {
967                 if (!isEndOfEditableOrNonEditableContent(visibleStart))
968                     setEndingSelection(visibleStart.next());
969             } else
970                 insertParagraphSeparator();
971         }
972         insertionPos = endingSelection().start();
973     } else {
974         ASSERT(selection.isCaret());
975         if (fragment.hasInterchangeNewlineAtStart()) {
976             VisiblePosition next = visibleStart.next(CannotCrossEditingBoundary);
977             if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart) && next.isNotNull())
978                 setEndingSelection(next);
979             else  {
980                 insertParagraphSeparator();
981                 visibleStart = endingSelection().visibleStart();
982             }
983         }
984         // We split the current paragraph in two to avoid nesting the blocks from the fragment inside the current block.
985         // For example paste <div>foo</div><div>bar</div><div>baz</div> into <div>x^x</div>, where ^ is the caret.  
986         // As long as the  div styles are the same, visually you'd expect: <div>xbar</div><div>bar</div><div>bazx</div>, 
987         // not <div>xbar<div>bar</div><div>bazx</div></div>.
988         // Don't do this if the selection started in a Mail blockquote.
989         if (m_preventNesting && !shouldHandleMailBlockquote && !isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart)) {
990             insertParagraphSeparator();
991             setEndingSelection(endingSelection().visibleStart().previous());
992         }
993         insertionPos = endingSelection().start();
994     }
995     
996     // We don't want any of the pasted content to end up nested in a Mail blockquote, so first break 
997     // out of any surrounding Mail blockquotes. Unless we're inserting in a table, in which case
998     // breaking the blockquote will prevent the content from actually being inserted in the table.
999     if (shouldHandleMailBlockquote && m_preventNesting && !(enclosingNodeOfType(insertionPos, &isTableStructureNode))) {
1000         applyCommandToComposite(BreakBlockquoteCommand::create(document())); 
1001         // This will leave a br between the split. 
1002         Node* br = endingSelection().start().deprecatedNode(); 
1003         ASSERT(br->hasTagName(brTag)); 
1004         // Insert content between the two blockquotes, but remove the br (since it was just a placeholder). 
1005         insertionPos = positionInParentBeforeNode(br);
1006         removeNode(br);
1007     }
1008     
1009     // Inserting content could cause whitespace to collapse, e.g. inserting <div>foo</div> into hello^ world.
1010     prepareWhitespaceAtPositionForSplit(insertionPos);
1011
1012     // If the downstream node has been removed there's no point in continuing.
1013     if (!insertionPos.downstream().deprecatedNode())
1014       return;
1015     
1016     // NOTE: This would be an incorrect usage of downstream() if downstream() were changed to mean the last position after 
1017     // p that maps to the same visible position as p (since in the case where a br is at the end of a block and collapsed 
1018     // away, there are positions after the br which map to the same visible position as [br, 0]).  
1019     RefPtr<Node> endBR = insertionPos.downstream().deprecatedNode()->hasTagName(brTag) ? insertionPos.downstream().deprecatedNode() : nullptr;
1020     VisiblePosition originalVisPosBeforeEndBR;
1021     if (endBR)
1022         originalVisPosBeforeEndBR = VisiblePosition(positionBeforeNode(endBR.get()), DOWNSTREAM).previous();
1023     
1024     RefPtr<Node> insertionBlock = enclosingBlock(insertionPos.deprecatedNode());
1025     
1026     // Adjust insertionPos to prevent nesting.
1027     // If the start was in a Mail blockquote, we will have already handled adjusting insertionPos above.
1028     if (m_preventNesting && insertionBlock && !isTableCell(insertionBlock.get()) && !shouldHandleMailBlockquote) {
1029         ASSERT(insertionBlock != currentRoot);
1030         VisiblePosition visibleInsertionPos(insertionPos);
1031         if (isEndOfBlock(visibleInsertionPos) && !(isStartOfBlock(visibleInsertionPos) && fragment.hasInterchangeNewlineAtEnd()))
1032             insertionPos = positionInParentAfterNode(insertionBlock.get());
1033         else if (isStartOfBlock(visibleInsertionPos))
1034             insertionPos = positionInParentBeforeNode(insertionBlock.get());
1035     }
1036     
1037     // Paste at start or end of link goes outside of link.
1038     insertionPos = positionAvoidingSpecialElementBoundary(insertionPos);
1039     
1040     // FIXME: Can this wait until after the operation has been performed?  There doesn't seem to be
1041     // any work performed after this that queries or uses the typing style.
1042     frame().selection().clearTypingStyle();
1043
1044     removeHeadContents(fragment);
1045
1046     // We don't want the destination to end up inside nodes that weren't selected.  To avoid that, we move the
1047     // position forward without changing the visible position so we're still at the same visible location, but
1048     // outside of preceding tags.
1049     insertionPos = positionAvoidingPrecedingNodes(insertionPos);
1050
1051     // Paste into run of tabs splits the tab span.
1052     insertionPos = positionOutsideTabSpan(insertionPos);
1053
1054     bool handledStyleSpans = handleStyleSpansBeforeInsertion(fragment, insertionPos);
1055
1056     // We're finished if there is nothing to add.
1057     if (fragment.isEmpty() || !fragment.firstChild())
1058         return;
1059
1060     // If we are not trying to match the destination style we prefer a position
1061     // that is outside inline elements that provide style.
1062     // This way we can produce a less verbose markup.
1063     // We can skip this optimization for fragments not wrapped in one of
1064     // our style spans and for positions inside list items
1065     // since insertAsListItems already does the right thing.
1066     if (!m_matchStyle && !enclosingList(insertionPos.containerNode())) {
1067         if (insertionPos.containerNode()->isTextNode() && insertionPos.offsetInContainerNode() && !insertionPos.atLastEditingPositionForNode()) {
1068             splitTextNode(insertionPos.containerText(), insertionPos.offsetInContainerNode());
1069             insertionPos = firstPositionInNode(insertionPos.containerNode());
1070         }
1071
1072         if (RefPtr<Node> nodeToSplitTo = nodeToSplitToAvoidPastingIntoInlineNodesWithStyle(insertionPos)) {
1073             if (insertionPos.containerNode() != nodeToSplitTo->parentNode()) {
1074                 Node* splitStart = insertionPos.computeNodeAfterPosition();
1075                 if (!splitStart)
1076                     splitStart = insertionPos.containerNode();
1077                 nodeToSplitTo = splitTreeToNode(splitStart, nodeToSplitTo->parentNode()).get();
1078                 insertionPos = positionInParentBeforeNode(nodeToSplitTo.get());
1079             }
1080         }
1081     }
1082
1083     // FIXME: When pasting rich content we're often prevented from heading down the fast path by style spans.  Try
1084     // again here if they've been removed.
1085
1086     // 1) Insert the content.
1087     // 2) Remove redundant styles and style tags, this inner <b> for example: <b>foo <b>bar</b> baz</b>.
1088     // 3) Merge the start of the added content with the content before the position being pasted into.
1089     // 4) Do one of the following: a) expand the last br if the fragment ends with one and it collapsed,
1090     // b) merge the last paragraph of the incoming fragment with the paragraph that contained the 
1091     // end of the selection that was pasted into, or c) handle an interchange newline at the end of the 
1092     // incoming fragment.
1093     // 5) Add spaces for smart replace.
1094     // 6) Select the replacement if requested, and match style if requested.
1095
1096     InsertedNodes insertedNodes;
1097     RefPtr<Node> refNode = fragment.firstChild();
1098     RefPtr<Node> node = refNode->nextSibling();
1099     
1100     fragment.removeNode(refNode);
1101
1102     Node* blockStart = enclosingBlock(insertionPos.deprecatedNode());
1103     if ((isListElement(refNode.get()) || (isLegacyAppleStyleSpan(refNode.get()) && isListElement(refNode->firstChild())))
1104         && blockStart && blockStart->renderer()->isListItem())
1105         refNode = insertAsListItems(downcast<HTMLElement>(refNode.get()), blockStart, insertionPos, insertedNodes);
1106     else {
1107         insertNodeAt(refNode, insertionPos);
1108         insertedNodes.respondToNodeInsertion(refNode.get());
1109     }
1110
1111     // Mutation events (bug 22634) may have already removed the inserted content
1112     if (!refNode->inDocument())
1113         return;
1114
1115     bool plainTextFragment = isPlainTextMarkup(refNode.get());
1116
1117     while (node) {
1118         RefPtr<Node> next = node->nextSibling();
1119         fragment.removeNode(node.get());
1120         insertNodeAfter(node, refNode.get());
1121         insertedNodes.respondToNodeInsertion(node.get());
1122
1123         // Mutation events (bug 22634) may have already removed the inserted content
1124         if (!node->inDocument())
1125             return;
1126
1127         refNode = node;
1128         if (node && plainTextFragment)
1129             plainTextFragment = isPlainTextMarkup(node.get());
1130         node = next;
1131     }
1132
1133     removeUnrenderedTextNodesAtEnds(insertedNodes);
1134
1135     if (!handledStyleSpans)
1136         handleStyleSpans(insertedNodes);
1137
1138     // Mutation events (bug 20161) may have already removed the inserted content
1139     if (!insertedNodes.firstNodeInserted() || !insertedNodes.firstNodeInserted()->inDocument())
1140         return;
1141
1142     VisiblePosition startOfInsertedContent = firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted());
1143
1144     // We inserted before the insertionBlock to prevent nesting, and the content before the insertionBlock wasn't in its own block and
1145     // didn't have a br after it, so the inserted content ended up in the same paragraph.
1146     if (!startOfInsertedContent.isNull() && insertionBlock && insertionPos.deprecatedNode() == insertionBlock->parentNode() && (unsigned)insertionPos.deprecatedEditingOffset() < insertionBlock->computeNodeIndex() && !isStartOfParagraph(startOfInsertedContent))
1147         insertNodeAt(createBreakElement(document()), startOfInsertedContent.deepEquivalent());
1148
1149     if (endBR && (plainTextFragment || shouldRemoveEndBR(endBR.get(), originalVisPosBeforeEndBR))) {
1150         RefPtr<Node> parent = endBR->parentNode();
1151         insertedNodes.willRemoveNode(endBR.get());
1152         removeNode(endBR);
1153         if (Node* nodeToRemove = highestNodeToRemoveInPruning(parent.get())) {
1154             insertedNodes.willRemoveNode(nodeToRemove);
1155             removeNode(nodeToRemove);
1156         }
1157     }
1158     
1159     makeInsertedContentRoundTrippableWithHTMLTreeBuilder(insertedNodes);
1160
1161     removeRedundantStylesAndKeepStyleSpanInline(insertedNodes);
1162
1163     if (m_sanitizeFragment)
1164         applyCommandToComposite(SimplifyMarkupCommand::create(document(), insertedNodes.firstNodeInserted(), insertedNodes.pastLastLeaf()));
1165
1166     // Setup m_startOfInsertedContent and m_endOfInsertedContent. This should be the last two lines of code that access insertedNodes.
1167     m_startOfInsertedContent = firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted());
1168     m_endOfInsertedContent = lastPositionInOrAfterNode(insertedNodes.lastLeafInserted());
1169
1170     // Determine whether or not we should merge the end of inserted content with what's after it before we do
1171     // the start merge so that the start merge doesn't effect our decision.
1172     m_shouldMergeEnd = shouldMergeEnd(selectionEndWasEndOfParagraph);
1173     
1174     if (shouldMergeStart(selectionStartWasStartOfParagraph, fragment.hasInterchangeNewlineAtStart(), shouldHandleMailBlockquote)) {
1175         VisiblePosition startOfParagraphToMove = positionAtStartOfInsertedContent();
1176         VisiblePosition destination = startOfParagraphToMove.previous();
1177         // We need to handle the case where we need to merge the end
1178         // but our destination node is inside an inline that is the last in the block.
1179         // We insert a placeholder before the newly inserted content to avoid being merged into the inline.
1180         Node* destinationNode = destination.deepEquivalent().deprecatedNode();
1181         if (m_shouldMergeEnd && destinationNode != enclosingInline(destinationNode) && enclosingInline(destinationNode)->nextSibling())
1182             insertNodeBefore(createBreakElement(document()), refNode.get());
1183         
1184         // Merging the the first paragraph of inserted content with the content that came
1185         // before the selection that was pasted into would also move content after 
1186         // the selection that was pasted into if: only one paragraph was being pasted, 
1187         // and it was not wrapped in a block, the selection that was pasted into ended 
1188         // at the end of a block and the next paragraph didn't start at the start of a block.
1189         // Insert a line break just after the inserted content to separate it from what 
1190         // comes after and prevent that from happening.
1191         VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
1192         if (startOfParagraph(endOfInsertedContent) == startOfParagraphToMove) {
1193             insertNodeAt(createBreakElement(document()), endOfInsertedContent.deepEquivalent());
1194             // Mutation events (bug 22634) triggered by inserting the <br> might have removed the content we're about to move
1195             if (!startOfParagraphToMove.deepEquivalent().anchorNode()->inDocument())
1196                 return;
1197         }
1198
1199         // FIXME: Maintain positions for the start and end of inserted content instead of keeping nodes.  The nodes are
1200         // only ever used to create positions where inserted content starts/ends.
1201         moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination);
1202         m_startOfInsertedContent = endingSelection().visibleStart().deepEquivalent().downstream();
1203         if (m_endOfInsertedContent.isOrphan())
1204             m_endOfInsertedContent = endingSelection().visibleEnd().deepEquivalent().upstream();
1205     }
1206
1207     Position lastPositionToSelect;
1208     if (fragment.hasInterchangeNewlineAtEnd()) {
1209         VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
1210         VisiblePosition next = endOfInsertedContent.next(CannotCrossEditingBoundary);
1211
1212         if (selectionEndWasEndOfParagraph || !isEndOfParagraph(endOfInsertedContent) || next.isNull()) {
1213             if (!isStartOfParagraph(endOfInsertedContent)) {
1214                 setEndingSelection(endOfInsertedContent);
1215                 Node* enclosingNode = enclosingBlock(endOfInsertedContent.deepEquivalent().deprecatedNode());
1216                 if (isListItem(enclosingNode)) {
1217                     RefPtr<Node> newListItem = createListItemElement(document());
1218                     insertNodeAfter(newListItem, enclosingNode);
1219                     setEndingSelection(VisiblePosition(firstPositionInNode(newListItem.get())));
1220                 } else {
1221                     // Use a default paragraph element (a plain div) for the empty paragraph, using the last paragraph
1222                     // block's style seems to annoy users.
1223                     insertParagraphSeparator(true, !shouldHandleMailBlockquote && highestEnclosingNodeOfType(endOfInsertedContent.deepEquivalent(),
1224                         isMailBlockquote, CannotCrossEditingBoundary, insertedNodes.firstNodeInserted()->parentNode()));
1225                 }
1226
1227                 // Select up to the paragraph separator that was added.
1228                 lastPositionToSelect = endingSelection().visibleStart().deepEquivalent();
1229                 updateNodesInserted(lastPositionToSelect.deprecatedNode());
1230             }
1231         } else {
1232             // Select up to the beginning of the next paragraph.
1233             lastPositionToSelect = next.deepEquivalent().downstream();
1234         }
1235         
1236     } else
1237         mergeEndIfNeeded();
1238
1239     if (Node* mailBlockquote = enclosingNodeOfType(positionAtStartOfInsertedContent().deepEquivalent(), isMailPasteAsQuotationNode))
1240         removeNodeAttribute(downcast<Element>(mailBlockquote), classAttr);
1241
1242     if (shouldPerformSmartReplace())
1243         addSpacesForSmartReplace();
1244
1245     // If we are dealing with a fragment created from plain text
1246     // no style matching is necessary.
1247     if (plainTextFragment)
1248         m_matchStyle = false;
1249         
1250     completeHTMLReplacement(lastPositionToSelect);
1251 }
1252
1253 bool ReplaceSelectionCommand::shouldRemoveEndBR(Node* endBR, const VisiblePosition& originalVisPosBeforeEndBR)
1254 {
1255     if (!endBR || !endBR->inDocument())
1256         return false;
1257         
1258     VisiblePosition visiblePos(positionBeforeNode(endBR));
1259     
1260     // Don't remove the br if nothing was inserted.
1261     if (visiblePos.previous() == originalVisPosBeforeEndBR)
1262         return false;
1263     
1264     // Remove the br if it is collapsed away and so is unnecessary.
1265     if (!document().inNoQuirksMode() && isEndOfBlock(visiblePos) && !isStartOfParagraph(visiblePos))
1266         return true;
1267         
1268     // A br that was originally holding a line open should be displaced by inserted content or turned into a line break.
1269     // A br that was originally acting as a line break should still be acting as a line break, not as a placeholder.
1270     return isStartOfParagraph(visiblePos) && isEndOfParagraph(visiblePos);
1271 }
1272
1273 bool ReplaceSelectionCommand::shouldPerformSmartReplace() const
1274 {
1275     if (!m_smartReplace)
1276         return false;
1277
1278     Element* textControl = enclosingTextFormControl(positionAtStartOfInsertedContent().deepEquivalent());
1279     if (is<HTMLInputElement>(textControl) && downcast<HTMLInputElement>(*textControl).isPasswordField())
1280         return false; // Disable smart replace for password fields.
1281
1282     return true;
1283 }
1284
1285 static bool isCharacterSmartReplaceExemptConsideringNonBreakingSpace(UChar32 character, bool previousCharacter)
1286 {
1287     return isCharacterSmartReplaceExempt(character == noBreakSpace ? ' ' : character, previousCharacter);
1288 }
1289
1290 void ReplaceSelectionCommand::addSpacesForSmartReplace()
1291 {
1292     VisiblePosition startOfInsertedContent = positionAtStartOfInsertedContent();
1293     VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
1294
1295     Position endUpstream = endOfInsertedContent.deepEquivalent().upstream();
1296     Node* endNode = endUpstream.computeNodeBeforePosition();
1297     int endOffset = is<Text>(endNode) ? downcast<Text>(*endNode).length() : 0;
1298     if (endUpstream.anchorType() == Position::PositionIsOffsetInAnchor) {
1299         endNode = endUpstream.containerNode();
1300         endOffset = endUpstream.offsetInContainerNode();
1301     }
1302
1303     bool needsTrailingSpace = !isEndOfParagraph(endOfInsertedContent) && !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(endOfInsertedContent.characterAfter(), false);
1304     if (needsTrailingSpace && endNode) {
1305         bool collapseWhiteSpace = !endNode->renderer() || endNode->renderer()->style().collapseWhiteSpace();
1306         if (is<Text>(*endNode)) {
1307             insertTextIntoNode(downcast<Text>(endNode), endOffset, collapseWhiteSpace ? nonBreakingSpaceString() : " ");
1308             if (m_endOfInsertedContent.containerNode() == endNode)
1309                 m_endOfInsertedContent.moveToOffset(m_endOfInsertedContent.offsetInContainerNode() + 1);
1310         } else {
1311             RefPtr<Node> node = document().createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
1312             insertNodeAfter(node, endNode);
1313             updateNodesInserted(node.get());
1314         }
1315     }
1316
1317     document().updateLayout();
1318
1319     Position startDownstream = startOfInsertedContent.deepEquivalent().downstream();
1320     Node* startNode = startDownstream.computeNodeAfterPosition();
1321     unsigned startOffset = 0;
1322     if (startDownstream.anchorType() == Position::PositionIsOffsetInAnchor) {
1323         startNode = startDownstream.containerNode();
1324         startOffset = startDownstream.offsetInContainerNode();
1325     }
1326
1327     bool needsLeadingSpace = !isStartOfParagraph(startOfInsertedContent) && !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(startOfInsertedContent.previous().characterAfter(), true);
1328     if (needsLeadingSpace && startNode) {
1329         bool collapseWhiteSpace = !startNode->renderer() || startNode->renderer()->style().collapseWhiteSpace();
1330         if (is<Text>(*startNode)) {
1331             insertTextIntoNode(downcast<Text>(startNode), startOffset, collapseWhiteSpace ? nonBreakingSpaceString() : " ");
1332             if (m_endOfInsertedContent.containerNode() == startNode && m_endOfInsertedContent.offsetInContainerNode())
1333                 m_endOfInsertedContent.moveToOffset(m_endOfInsertedContent.offsetInContainerNode() + 1);
1334         } else {
1335             RefPtr<Node> node = document().createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
1336             // Don't updateNodesInserted. Doing so would set m_endOfInsertedContent to be the node containing the leading space,
1337             // but m_endOfInsertedContent is supposed to mark the end of pasted content.
1338             insertNodeBefore(node, startNode);
1339             m_startOfInsertedContent = firstPositionInNode(node.get());
1340         }
1341     }
1342 }
1343
1344 void ReplaceSelectionCommand::completeHTMLReplacement(const Position &lastPositionToSelect)
1345 {
1346     Position start = positionAtStartOfInsertedContent().deepEquivalent();
1347     Position end = positionAtEndOfInsertedContent().deepEquivalent();
1348
1349     // Mutation events may have deleted start or end
1350     if (start.isNotNull() && !start.isOrphan() && end.isNotNull() && !end.isOrphan()) {
1351         // FIXME (11475): Remove this and require that the creator of the fragment to use nbsps.
1352         rebalanceWhitespaceAt(start);
1353         rebalanceWhitespaceAt(end);
1354
1355         if (m_matchStyle) {
1356             ASSERT(m_insertionStyle);
1357             applyStyle(m_insertionStyle.get(), start, end);
1358         }
1359
1360         if (lastPositionToSelect.isNotNull())
1361             end = lastPositionToSelect;
1362
1363         mergeTextNodesAroundPosition(start, end);
1364         mergeTextNodesAroundPosition(end, start);
1365     } else if (lastPositionToSelect.isNotNull())
1366         start = end = lastPositionToSelect;
1367     else
1368         return;
1369
1370     if (m_selectReplacement)
1371         setEndingSelection(VisibleSelection(start, end, SEL_DEFAULT_AFFINITY, endingSelection().isDirectional()));
1372     else
1373         setEndingSelection(VisibleSelection(end, SEL_DEFAULT_AFFINITY, endingSelection().isDirectional()));
1374 }
1375
1376 void ReplaceSelectionCommand::mergeTextNodesAroundPosition(Position& position, Position& positionOnlyToBeUpdated)
1377 {
1378     bool positionIsOffsetInAnchor = position.anchorType() == Position::PositionIsOffsetInAnchor;
1379     bool positionOnlyToBeUpdatedIsOffsetInAnchor = positionOnlyToBeUpdated.anchorType() == Position::PositionIsOffsetInAnchor;
1380     RefPtr<Text> text;
1381     if (positionIsOffsetInAnchor && is<Text>(position.containerNode()))
1382         text = downcast<Text>(position.containerNode());
1383     else {
1384         Node* before = position.computeNodeBeforePosition();
1385         if (is<Text>(before))
1386             text = downcast<Text>(before);
1387         else {
1388             Node* after = position.computeNodeAfterPosition();
1389             if (is<Text>(after))
1390                 text = downcast<Text>(after);
1391         }
1392     }
1393     if (!text)
1394         return;
1395
1396     if (is<Text>(text->previousSibling())) {
1397         Ref<Text> previous(downcast<Text>(*text->previousSibling()));
1398         insertTextIntoNode(text, 0, previous->data());
1399
1400         if (positionIsOffsetInAnchor)
1401             position.moveToOffset(previous->length() + position.offsetInContainerNode());
1402         else
1403             updatePositionForNodeRemoval(position, previous.get());
1404
1405         if (positionOnlyToBeUpdatedIsOffsetInAnchor) {
1406             if (positionOnlyToBeUpdated.containerNode() == text)
1407                 positionOnlyToBeUpdated.moveToOffset(previous->length() + positionOnlyToBeUpdated.offsetInContainerNode());
1408             else if (positionOnlyToBeUpdated.containerNode() == previous.ptr())
1409                 positionOnlyToBeUpdated.moveToPosition(text, positionOnlyToBeUpdated.offsetInContainerNode());
1410         } else
1411             updatePositionForNodeRemoval(positionOnlyToBeUpdated, previous.get());
1412
1413         removeNode(previous.ptr());
1414     }
1415     if (is<Text>(text->nextSibling())) {
1416         Ref<Text> next(downcast<Text>(*text->nextSibling()));
1417         unsigned originalLength = text->length();
1418         insertTextIntoNode(text, originalLength, next->data());
1419
1420         if (!positionIsOffsetInAnchor)
1421             updatePositionForNodeRemoval(position, next.get());
1422
1423         if (positionOnlyToBeUpdatedIsOffsetInAnchor && positionOnlyToBeUpdated.containerNode() == next.ptr())
1424             positionOnlyToBeUpdated.moveToPosition(text, originalLength + positionOnlyToBeUpdated.offsetInContainerNode());
1425         else
1426             updatePositionForNodeRemoval(positionOnlyToBeUpdated, next.get());
1427
1428         removeNode(next.ptr());
1429     }
1430 }
1431
1432 // If the user is inserting a list into an existing list, instead of nesting the list,
1433 // we put the list items into the existing list.
1434 Node* ReplaceSelectionCommand::insertAsListItems(PassRefPtr<HTMLElement> prpListElement, Node* insertionBlock, const Position& insertPos, InsertedNodes& insertedNodes)
1435 {
1436     RefPtr<HTMLElement> listElement = prpListElement;
1437
1438     while (listElement->hasOneChild() && isListElement(listElement->firstChild()))
1439         listElement = downcast<HTMLElement>(listElement->firstChild());
1440
1441     bool isStart = isStartOfParagraph(insertPos);
1442     bool isEnd = isEndOfParagraph(insertPos);
1443     bool isMiddle = !isStart && !isEnd;
1444     Node* lastNode = insertionBlock;
1445
1446     // If we're in the middle of a list item, we should split it into two separate
1447     // list items and insert these nodes between them.
1448     if (isMiddle) {
1449         int textNodeOffset = insertPos.offsetInContainerNode();
1450         if (is<Text>(*insertPos.deprecatedNode()) && textNodeOffset > 0)
1451             splitTextNode(downcast<Text>(insertPos.deprecatedNode()), textNodeOffset);
1452         splitTreeToNode(insertPos.deprecatedNode(), lastNode, true);
1453     }
1454
1455     while (RefPtr<Node> listItem = listElement->firstChild()) {
1456         listElement->removeChild(*listItem, ASSERT_NO_EXCEPTION);
1457         if (isStart || isMiddle) {
1458             insertNodeBefore(listItem, lastNode);
1459             insertedNodes.respondToNodeInsertion(listItem.get());
1460         } else if (isEnd) {
1461             insertNodeAfter(listItem, lastNode);
1462             insertedNodes.respondToNodeInsertion(listItem.get());
1463             lastNode = listItem.get();
1464         } else
1465             ASSERT_NOT_REACHED();
1466     }
1467     if ((isStart || isMiddle) && lastNode->previousSibling())
1468         lastNode = lastNode->previousSibling();
1469     return lastNode;
1470 }
1471
1472 void ReplaceSelectionCommand::updateNodesInserted(Node *node)
1473 {
1474     if (!node)
1475         return;
1476
1477     if (m_startOfInsertedContent.isNull())
1478         m_startOfInsertedContent = firstPositionInOrBeforeNode(node);
1479
1480     m_endOfInsertedContent = lastPositionInOrAfterNode(node->lastDescendant());
1481 }
1482
1483 // During simple pastes, where we're just pasting a text node into a run of text, we insert the text node
1484 // directly into the text node that holds the selection.  This is much faster than the generalized code in
1485 // ReplaceSelectionCommand, and works around <https://bugs.webkit.org/show_bug.cgi?id=6148> since we don't 
1486 // split text nodes.
1487 bool ReplaceSelectionCommand::performTrivialReplace(const ReplacementFragment& fragment)
1488 {
1489     if (!is<Text>(fragment.firstChild()) || fragment.firstChild() != fragment.lastChild())
1490         return false;
1491
1492     // FIXME: Would be nice to handle smart replace in the fast path.
1493     if (m_smartReplace || fragment.hasInterchangeNewlineAtStart() || fragment.hasInterchangeNewlineAtEnd())
1494         return false;
1495
1496     // e.g. when "bar" is inserted after "foo" in <div><u>foo</u></div>, "bar" should not be underlined.
1497     if (nodeToSplitToAvoidPastingIntoInlineNodesWithStyle(endingSelection().start()))
1498         return false;
1499
1500     RefPtr<Node> nodeAfterInsertionPos = endingSelection().end().downstream().anchorNode();
1501     Text& textNode = downcast<Text>(*fragment.firstChild());
1502     // Our fragment creation code handles tabs, spaces, and newlines, so we don't have to worry about those here.
1503
1504     Position start = endingSelection().start();
1505     Position end = replaceSelectedTextInNode(textNode.data());
1506     if (end.isNull())
1507         return false;
1508
1509     if (nodeAfterInsertionPos && nodeAfterInsertionPos->parentNode() && nodeAfterInsertionPos->hasTagName(brTag)
1510         && shouldRemoveEndBR(nodeAfterInsertionPos.get(), positionBeforeNode(nodeAfterInsertionPos.get())))
1511         removeNodeAndPruneAncestors(nodeAfterInsertionPos.get());
1512
1513     VisibleSelection selectionAfterReplace(m_selectReplacement ? start : end, end);
1514
1515     setEndingSelection(selectionAfterReplace);
1516
1517     return true;
1518 }
1519
1520 } // namespace WebCore