Use NeverDestroyed instead of DEPRECATED_DEFINE_STATIC_LOCAL
[WebKit-https.git] / Source / WebCore / editing / ApplyStyleCommand.cpp
1 /*
2  * Copyright (C) 2005, 2006, 2008, 2009 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "ApplyStyleCommand.h"
28
29 #include "CSSComputedStyleDeclaration.h"
30 #include "CSSParser.h"
31 #include "CSSValuePool.h"
32 #include "Document.h"
33 #include "Editor.h"
34 #include "ElementIterator.h"
35 #include "Frame.h"
36 #include "HTMLFontElement.h"
37 #include "HTMLInterchange.h"
38 #include "HTMLNames.h"
39 #include "HTMLSpanElement.h"
40 #include "NodeList.h"
41 #include "NodeTraversal.h"
42 #include "RenderObject.h"
43 #include "RenderText.h"
44 #include "StyleProperties.h"
45 #include "StyleResolver.h"
46 #include "Text.h"
47 #include "TextIterator.h"
48 #include "TextNodeTraversal.h"
49 #include "VisibleUnits.h"
50 #include "htmlediting.h"
51 #include <wtf/NeverDestroyed.h>
52 #include <wtf/StdLibExtras.h>
53 #include <wtf/text/StringBuilder.h>
54
55 namespace WebCore {
56
57 using namespace HTMLNames;
58
59 static int toIdentifier(PassRefPtr<CSSValue> value)
60 {
61     return (value && value->isPrimitiveValue()) ? static_pointer_cast<CSSPrimitiveValue>(value)->getValueID() : 0;
62 }
63
64 static String& styleSpanClassString()
65 {
66     static NeverDestroyed<String> styleSpanClassString(AppleStyleSpanClass);
67     return styleSpanClassString;
68 }
69
70 bool isLegacyAppleStyleSpan(const Node* node)
71 {
72     if (!is<HTMLSpanElement>(node))
73         return false;
74
75     return downcast<HTMLSpanElement>(*node).fastGetAttribute(classAttr) == styleSpanClassString();
76 }
77
78 static bool hasNoAttributeOrOnlyStyleAttribute(const StyledElement* element, ShouldStyleAttributeBeEmpty shouldStyleAttributeBeEmpty)
79 {
80     if (!element->hasAttributes())
81         return true;
82
83     unsigned matchedAttributes = 0;
84     if (element->getAttribute(classAttr) == styleSpanClassString())
85         matchedAttributes++;
86     if (element->hasAttribute(styleAttr) && (shouldStyleAttributeBeEmpty == AllowNonEmptyStyleAttribute
87         || !element->inlineStyle() || element->inlineStyle()->isEmpty()))
88         matchedAttributes++;
89
90     ASSERT(matchedAttributes <= element->attributeCount());
91     return matchedAttributes == element->attributeCount();
92 }
93
94 bool isStyleSpanOrSpanWithOnlyStyleAttribute(const Element* element)
95 {
96     if (!is<HTMLSpanElement>(element))
97         return false;
98     return hasNoAttributeOrOnlyStyleAttribute(downcast<HTMLSpanElement>(element), AllowNonEmptyStyleAttribute);
99 }
100
101 static inline bool isSpanWithoutAttributesOrUnstyledStyleSpan(const Element* element)
102 {
103     if (!is<HTMLSpanElement>(element))
104         return false;
105     return hasNoAttributeOrOnlyStyleAttribute(downcast<HTMLSpanElement>(element), StyleAttributeShouldBeEmpty);
106 }
107
108 bool isEmptyFontTag(const Element* element, ShouldStyleAttributeBeEmpty shouldStyleAttributeBeEmpty)
109 {
110     if (!is<HTMLFontElement>(element))
111         return false;
112
113     return hasNoAttributeOrOnlyStyleAttribute(downcast<HTMLFontElement>(element), shouldStyleAttributeBeEmpty);
114 }
115
116 static RefPtr<Element> createFontElement(Document& document)
117 {
118     return createHTMLElement(document, fontTag);
119 }
120
121 RefPtr<HTMLElement> createStyleSpanElement(Document& document)
122 {
123     return createHTMLElement(document, spanTag);
124 }
125
126 ApplyStyleCommand::ApplyStyleCommand(Document& document, const EditingStyle* style, EditAction editingAction, EPropertyLevel propertyLevel)
127     : CompositeEditCommand(document, editingAction)
128     , m_style(style->copy())
129     , m_propertyLevel(propertyLevel)
130     , m_start(endingSelection().start().downstream())
131     , m_end(endingSelection().end().upstream())
132     , m_useEndingSelection(true)
133     , m_removeOnly(false)
134 {
135 }
136
137 ApplyStyleCommand::ApplyStyleCommand(Document& document, const EditingStyle* style, const Position& start, const Position& end, EditAction editingAction, EPropertyLevel propertyLevel)
138     : CompositeEditCommand(document, editingAction)
139     , m_style(style->copy())
140     , m_propertyLevel(propertyLevel)
141     , m_start(start)
142     , m_end(end)
143     , m_useEndingSelection(false)
144     , m_removeOnly(false)
145 {
146 }
147
148 ApplyStyleCommand::ApplyStyleCommand(PassRefPtr<Element> element, bool removeOnly, EditAction editingAction)
149     : CompositeEditCommand(element->document(), editingAction)
150     , m_style(EditingStyle::create())
151     , m_propertyLevel(PropertyDefault)
152     , m_start(endingSelection().start().downstream())
153     , m_end(endingSelection().end().upstream())
154     , m_useEndingSelection(true)
155     , m_styledInlineElement(element)
156     , m_removeOnly(removeOnly)
157 {
158 }
159
160 ApplyStyleCommand::ApplyStyleCommand(Document& document, const EditingStyle* style, IsInlineElementToRemoveFunction isInlineElementToRemoveFunction, EditAction editingAction)
161     : CompositeEditCommand(document, editingAction)
162     , m_style(style->copy())
163     , m_propertyLevel(PropertyDefault)
164     , m_start(endingSelection().start().downstream())
165     , m_end(endingSelection().end().upstream())
166     , m_useEndingSelection(true)
167     , m_removeOnly(true)
168     , m_isInlineElementToRemoveFunction(isInlineElementToRemoveFunction)
169 {
170 }
171
172 void ApplyStyleCommand::updateStartEnd(const Position& newStart, const Position& newEnd)
173 {
174     ASSERT(comparePositions(newEnd, newStart) >= 0);
175
176     if (!m_useEndingSelection && (newStart != m_start || newEnd != m_end))
177         m_useEndingSelection = true;
178
179     bool wasBaseFirst = startingSelection().isBaseFirst() || !startingSelection().isDirectional();
180     setEndingSelection(VisibleSelection(wasBaseFirst ? newStart : newEnd, wasBaseFirst ? newEnd : newStart, VP_DEFAULT_AFFINITY, endingSelection().isDirectional()));
181     m_start = newStart;
182     m_end = newEnd;
183 }
184
185 Position ApplyStyleCommand::startPosition()
186 {
187     if (m_useEndingSelection)
188         return endingSelection().start();
189     
190     return m_start;
191 }
192
193 Position ApplyStyleCommand::endPosition()
194 {
195     if (m_useEndingSelection)
196         return endingSelection().end();
197     
198     return m_end;
199 }
200
201 void ApplyStyleCommand::doApply()
202 {
203     switch (m_propertyLevel) {
204     case PropertyDefault: {
205         // Apply the block-centric properties of the style.
206         RefPtr<EditingStyle> blockStyle = m_style->extractAndRemoveBlockProperties();
207         if (!blockStyle->isEmpty())
208             applyBlockStyle(blockStyle.get());
209         // Apply any remaining styles to the inline elements.
210         if (!m_style->isEmpty() || m_styledInlineElement || m_isInlineElementToRemoveFunction) {
211             applyRelativeFontStyleChange(m_style.get());
212             applyInlineStyle(m_style.get());
213         }
214         break;
215     }
216     case ForceBlockProperties:
217         // Force all properties to be applied as block styles.
218         applyBlockStyle(m_style.get());
219         break;
220     }
221 }
222
223 void ApplyStyleCommand::applyBlockStyle(EditingStyle *style)
224 {
225     // update document layout once before removing styles
226     // so that we avoid the expense of updating before each and every call
227     // to check a computed style
228     document().updateLayoutIgnorePendingStylesheets();
229
230     // get positions we want to use for applying style
231     Position start = startPosition();
232     Position end = endPosition();
233     if (comparePositions(end, start) < 0) {
234         Position swap = start;
235         start = end;
236         end = swap;
237     }
238
239     VisiblePosition visibleStart(start);
240     VisiblePosition visibleEnd(end);
241
242     if (visibleStart.isNull() || visibleStart.isOrphan() || visibleEnd.isNull() || visibleEnd.isOrphan())
243         return;
244
245     // Save and restore the selection endpoints using their indices in the editable root, since
246     // addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.
247     // Calculate start and end indices from the start of the tree that they're in.
248     Node* scope = highestEditableRoot(visibleStart.deepEquivalent());
249     if (!scope)
250         return;
251
252     RefPtr<Range> startRange = Range::create(document(), firstPositionInNode(scope), visibleStart.deepEquivalent().parentAnchoredEquivalent());
253     RefPtr<Range> endRange = Range::create(document(), firstPositionInNode(scope), visibleEnd.deepEquivalent().parentAnchoredEquivalent());
254     int startIndex = TextIterator::rangeLength(startRange.get(), true);
255     int endIndex = TextIterator::rangeLength(endRange.get(), true);
256
257     VisiblePosition paragraphStart(startOfParagraph(visibleStart));
258     VisiblePosition nextParagraphStart(endOfParagraph(paragraphStart).next());
259     if (visibleEnd != visibleStart && isStartOfParagraph(visibleEnd))
260         visibleEnd = visibleEnd.previous(CannotCrossEditingBoundary);
261     VisiblePosition beyondEnd(endOfParagraph(visibleEnd).next());
262     while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {
263         StyleChange styleChange(style, paragraphStart.deepEquivalent());
264         if (styleChange.cssStyle() || m_removeOnly) {
265             RefPtr<Node> block = enclosingBlock(paragraphStart.deepEquivalent().deprecatedNode());
266             if (!m_removeOnly) {
267                 RefPtr<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());
268                 if (newBlock)
269                     block = newBlock;
270             }
271             ASSERT(!block || is<HTMLElement>(*block));
272             if (is<HTMLElement>(block.get())) {
273                 removeCSSStyle(style, downcast<HTMLElement>(block.get()));
274                 if (!m_removeOnly)
275                     addBlockStyle(styleChange, downcast<HTMLElement>(block.get()));
276             }
277
278             if (nextParagraphStart.isOrphan())
279                 nextParagraphStart = endOfParagraph(paragraphStart).next();
280         }
281
282         paragraphStart = nextParagraphStart;
283         nextParagraphStart = endOfParagraph(paragraphStart).next();
284     }
285     
286     startRange = TextIterator::rangeFromLocationAndLength(downcast<ContainerNode>(scope), startIndex, 0, true);
287     endRange = TextIterator::rangeFromLocationAndLength(downcast<ContainerNode>(scope), endIndex, 0, true);
288     if (startRange && endRange)
289         updateStartEnd(startRange->startPosition(), endRange->startPosition());
290 }
291
292 static PassRefPtr<MutableStyleProperties> copyStyleOrCreateEmpty(const StyleProperties* style)
293 {
294     if (!style)
295         return MutableStyleProperties::create();
296     return style->mutableCopy();
297 }
298
299 void ApplyStyleCommand::applyRelativeFontStyleChange(EditingStyle* style)
300 {
301     static const float MinimumFontSize = 0.1f;
302
303     if (!style || !style->hasFontSizeDelta())
304         return;
305
306     Position start = startPosition();
307     Position end = endPosition();
308     if (comparePositions(end, start) < 0) {
309         Position swap = start;
310         start = end;
311         end = swap;
312     }
313
314     // Join up any adjacent text nodes.
315     if (start.deprecatedNode()->isTextNode()) {
316         joinChildTextNodes(start.deprecatedNode()->parentNode(), start, end);
317         start = startPosition();
318         end = endPosition();
319     }
320     
321     if (start.isNull() || end.isNull())
322         return;
323
324     if (end.deprecatedNode()->isTextNode() && start.deprecatedNode()->parentNode() != end.deprecatedNode()->parentNode()) {
325         joinChildTextNodes(end.deprecatedNode()->parentNode(), start, end);
326         start = startPosition();
327         end = endPosition();
328     }
329
330     if (start.isNull() || end.isNull())
331         return;
332
333     // Split the start text nodes if needed to apply style.
334     if (isValidCaretPositionInTextNode(start)) {
335         splitTextAtStart(start, end);
336         start = startPosition();
337         end = endPosition();
338     }
339
340     if (start.isNull() || end.isNull())
341         return;
342
343     if (isValidCaretPositionInTextNode(end)) {
344         splitTextAtEnd(start, end);
345         start = startPosition();
346         end = endPosition();
347     }
348
349     if (start.isNull() || end.isNull())
350         return;
351
352     // Calculate loop end point.
353     // If the end node is before the start node (can only happen if the end node is
354     // an ancestor of the start node), we gather nodes up to the next sibling of the end node
355     Node* beyondEnd;
356     ASSERT(start.deprecatedNode());
357     ASSERT(end.deprecatedNode());
358     if (start.deprecatedNode()->isDescendantOf(end.deprecatedNode()))
359         beyondEnd = NodeTraversal::nextSkippingChildren(*end.deprecatedNode());
360     else
361         beyondEnd = NodeTraversal::next(*end.deprecatedNode());
362     
363     start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
364     Node* startNode = start.deprecatedNode();
365
366     // Make sure we're not already at the end or the next NodeTraversal::next() will traverse
367     // past it.
368     if (startNode == beyondEnd)
369         return;
370
371     if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode)) {
372         // Move out of text node if range does not include its characters.
373         startNode = NodeTraversal::next(*startNode);
374         if (!startNode)
375             return;
376     }
377
378     // Store away font size before making any changes to the document.
379     // This ensures that changes to one node won't effect another.
380     HashMap<Node*, float> startingFontSizes;
381     for (Node* node = startNode; node != beyondEnd; node = NodeTraversal::next(*node)) {
382         ASSERT(node);
383         startingFontSizes.set(node, computedFontSize(node));
384     }
385
386     // These spans were added by us. If empty after font size changes, they can be removed.
387     Vector<RefPtr<HTMLElement>> unstyledSpans;
388     
389     Node* lastStyledNode = nullptr;
390     for (Node* node = startNode; node != beyondEnd; node = NodeTraversal::next(*node)) {
391         ASSERT(node);
392         RefPtr<HTMLElement> element;
393         if (is<HTMLElement>(*node)) {
394             // Only work on fully selected nodes.
395             if (!nodeFullySelected(node, start, end))
396                 continue;
397             element = downcast<HTMLElement>(node);
398         } else if (node->isTextNode() && node->renderer() && node->parentNode() != lastStyledNode) {
399             // Last styled node was not parent node of this text node, but we wish to style this
400             // text node. To make this possible, add a style span to surround this text node.
401             RefPtr<HTMLElement> span = createStyleSpanElement(document());
402             surroundNodeRangeWithElement(node, node, span.get());
403             element = span.release();
404         }  else {
405             // Only handle HTML elements and text nodes.
406             continue;
407         }
408         lastStyledNode = node;
409
410         RefPtr<MutableStyleProperties> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());
411         float currentFontSize = computedFontSize(node);
412         float desiredFontSize = std::max(MinimumFontSize, startingFontSizes.get(node) + style->fontSizeDelta());
413         RefPtr<CSSValue> value = inlineStyle->getPropertyCSSValue(CSSPropertyFontSize);
414         if (value) {
415             element->removeInlineStyleProperty(CSSPropertyFontSize);
416             currentFontSize = computedFontSize(node);
417         }
418         if (currentFontSize != desiredFontSize) {
419             inlineStyle->setProperty(CSSPropertyFontSize, CSSValuePool::singleton().createValue(desiredFontSize, CSSPrimitiveValue::CSS_PX), false);
420             setNodeAttribute(element.get(), styleAttr, inlineStyle->asText());
421         }
422         if (inlineStyle->isEmpty()) {
423             removeNodeAttribute(element.get(), styleAttr);
424             if (isSpanWithoutAttributesOrUnstyledStyleSpan(element.get()))
425                 unstyledSpans.append(element.release());
426         }
427     }
428
429     for (auto& unstyledSpan : unstyledSpans)
430         removeNodePreservingChildren(unstyledSpan.get());
431 }
432
433 static ContainerNode* dummySpanAncestorForNode(const Node* node)
434 {
435     while (node && (!is<Element>(*node) || !isStyleSpanOrSpanWithOnlyStyleAttribute(downcast<Element>(node))))
436         node = node->parentNode();
437     
438     return node ? node->parentNode() : nullptr;
439 }
440
441 void ApplyStyleCommand::cleanupUnstyledAppleStyleSpans(ContainerNode* dummySpanAncestor)
442 {
443     if (!dummySpanAncestor)
444         return;
445
446     // Dummy spans are created when text node is split, so that style information
447     // can be propagated, which can result in more splitting. If a dummy span gets
448     // cloned/split, the new node is always a sibling of it. Therefore, we scan
449     // all the children of the dummy's parent
450
451     Vector<Element*> toRemove;
452     for (auto& child : childrenOfType<Element>(*dummySpanAncestor)) {
453         if (isSpanWithoutAttributesOrUnstyledStyleSpan(&child))
454             toRemove.append(&child);
455     }
456
457     for (auto& element : toRemove)
458         removeNodePreservingChildren(element);
459 }
460
461 HTMLElement* ApplyStyleCommand::splitAncestorsWithUnicodeBidi(Node* node, bool before, WritingDirection allowedDirection)
462 {
463     // We are allowed to leave the highest ancestor with unicode-bidi unsplit if it is unicode-bidi: embed and direction: allowedDirection.
464     // In that case, we return the unsplit ancestor. Otherwise, we return 0.
465     Element* block = enclosingBlock(node);
466     if (!block || block == node)
467         return 0;
468
469     Node* highestAncestorWithUnicodeBidi = nullptr;
470     Node* nextHighestAncestorWithUnicodeBidi = nullptr;
471     int highestAncestorUnicodeBidi = 0;
472     for (Node* n = node->parentNode(); n != block; n = n->parentNode()) {
473         int unicodeBidi = toIdentifier(ComputedStyleExtractor(n).propertyValue(CSSPropertyUnicodeBidi));
474         if (unicodeBidi && unicodeBidi != CSSValueNormal) {
475             highestAncestorUnicodeBidi = unicodeBidi;
476             nextHighestAncestorWithUnicodeBidi = highestAncestorWithUnicodeBidi;
477             highestAncestorWithUnicodeBidi = n;
478         }
479     }
480
481     if (!highestAncestorWithUnicodeBidi)
482         return 0;
483
484     HTMLElement* unsplitAncestor = nullptr;
485
486     WritingDirection highestAncestorDirection;
487     if (allowedDirection != NaturalWritingDirection
488         && highestAncestorUnicodeBidi != CSSValueBidiOverride
489         && is<HTMLElement>(*highestAncestorWithUnicodeBidi)
490         && EditingStyle::create(highestAncestorWithUnicodeBidi, EditingStyle::AllProperties)->textDirection(highestAncestorDirection)
491         && highestAncestorDirection == allowedDirection) {
492         if (!nextHighestAncestorWithUnicodeBidi)
493             return downcast<HTMLElement>(highestAncestorWithUnicodeBidi);
494
495         unsplitAncestor = downcast<HTMLElement>(highestAncestorWithUnicodeBidi);
496         highestAncestorWithUnicodeBidi = nextHighestAncestorWithUnicodeBidi;
497     }
498
499     // Split every ancestor through highest ancestor with embedding.
500     RefPtr<Node> currentNode = node;
501     while (currentNode) {
502         RefPtr<Element> parent = downcast<Element>(currentNode->parentNode());
503         if (before ? currentNode->previousSibling() : currentNode->nextSibling())
504             splitElement(parent, before ? currentNode : currentNode->nextSibling());
505         if (parent == highestAncestorWithUnicodeBidi)
506             break;
507         currentNode = parent;
508     }
509     return unsplitAncestor;
510 }
511
512 void ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock(Node* node, Node* unsplitAncestor)
513 {
514     Element* block = enclosingBlock(node);
515     if (!block || block == node)
516         return;
517
518     Node* parent = nullptr;
519     for (Node* ancestor = node->parentNode(); ancestor != block && ancestor != unsplitAncestor; ancestor = parent) {
520         parent = ancestor->parentNode();
521         if (!is<StyledElement>(*ancestor))
522             continue;
523
524         StyledElement& element = downcast<StyledElement>(*ancestor);
525         int unicodeBidi = toIdentifier(ComputedStyleExtractor(&element).propertyValue(CSSPropertyUnicodeBidi));
526         if (!unicodeBidi || unicodeBidi == CSSValueNormal)
527             continue;
528
529         // FIXME: This code should really consider the mapped attribute 'dir', the inline style declaration,
530         // and all matching style rules in order to determine how to best set the unicode-bidi property to 'normal'.
531         // For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and
532         // otherwise it sets the property in the inline style declaration.
533         if (element.fastHasAttribute(dirAttr)) {
534             // FIXME: If this is a BDO element, we should probably just remove it if it has no
535             // other attributes, like we (should) do with B and I elements.
536             removeNodeAttribute(&element, dirAttr);
537         } else {
538             RefPtr<MutableStyleProperties> inlineStyle = copyStyleOrCreateEmpty(element.inlineStyle());
539             inlineStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);
540             inlineStyle->removeProperty(CSSPropertyDirection);
541             setNodeAttribute(&element, styleAttr, inlineStyle->asText());
542             if (isSpanWithoutAttributesOrUnstyledStyleSpan(&element))
543                 removeNodePreservingChildren(&element);
544         }
545     }
546 }
547
548 static Node* highestEmbeddingAncestor(Node* startNode, Node* enclosingNode)
549 {
550     for (Node* n = startNode; n && n != enclosingNode; n = n->parentNode()) {
551         if (n->isHTMLElement() && toIdentifier(ComputedStyleExtractor(n).propertyValue(CSSPropertyUnicodeBidi)) == CSSValueEmbed)
552             return n;
553     }
554
555     return 0;
556 }
557
558 void ApplyStyleCommand::applyInlineStyle(EditingStyle* style)
559 {
560     RefPtr<ContainerNode> startDummySpanAncestor;
561     RefPtr<ContainerNode> endDummySpanAncestor;
562
563     // update document layout once before removing styles
564     // so that we avoid the expense of updating before each and every call
565     // to check a computed style
566     document().updateLayoutIgnorePendingStylesheets();
567
568     // adjust to the positions we want to use for applying style
569     Position start = startPosition();
570     Position end = endPosition();
571
572     if (start.isNull() || end.isNull())
573         return;
574
575     if (comparePositions(end, start) < 0) {
576         Position swap = start;
577         start = end;
578         end = swap;
579     }
580
581     // split the start node and containing element if the selection starts inside of it
582     bool splitStart = isValidCaretPositionInTextNode(start);
583     if (splitStart) {
584         if (shouldSplitTextElement(start.deprecatedNode()->parentElement(), style))
585             splitTextElementAtStart(start, end);
586         else
587             splitTextAtStart(start, end);
588         start = startPosition();
589         end = endPosition();
590         startDummySpanAncestor = dummySpanAncestorForNode(start.deprecatedNode());
591     }
592
593     if (start.isNull() || end.isNull())
594         return;
595
596     // split the end node and containing element if the selection ends inside of it
597     bool splitEnd = isValidCaretPositionInTextNode(end);
598     if (splitEnd) {
599         if (shouldSplitTextElement(end.deprecatedNode()->parentElement(), style))
600             splitTextElementAtEnd(start, end);
601         else
602             splitTextAtEnd(start, end);
603         start = startPosition();
604         end = endPosition();
605         endDummySpanAncestor = dummySpanAncestorForNode(end.deprecatedNode());
606     }
607
608     if (start.isNull() || end.isNull())
609         return;
610
611     // Remove style from the selection.
612     // Use the upstream position of the start for removing style.
613     // This will ensure we remove all traces of the relevant styles from the selection
614     // and prevent us from adding redundant ones, as described in:
615     // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
616     Position removeStart = start.upstream();
617     WritingDirection textDirection = NaturalWritingDirection;
618     bool hasTextDirection = style->textDirection(textDirection);
619     RefPtr<EditingStyle> styleWithoutEmbedding;
620     RefPtr<EditingStyle> embeddingStyle;
621     if (hasTextDirection) {
622         // Leave alone an ancestor that provides the desired single level embedding, if there is one.
623         HTMLElement* startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.deprecatedNode(), true, textDirection);
624         HTMLElement* endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.deprecatedNode(), false, textDirection);
625         removeEmbeddingUpToEnclosingBlock(start.deprecatedNode(), startUnsplitAncestor);
626         removeEmbeddingUpToEnclosingBlock(end.deprecatedNode(), endUnsplitAncestor);
627
628         // Avoid removing the dir attribute and the unicode-bidi and direction properties from the unsplit ancestors.
629         Position embeddingRemoveStart = removeStart;
630         if (startUnsplitAncestor && nodeFullySelected(startUnsplitAncestor, removeStart, end))
631             embeddingRemoveStart = positionInParentAfterNode(startUnsplitAncestor);
632
633         Position embeddingRemoveEnd = end;
634         if (endUnsplitAncestor && nodeFullySelected(endUnsplitAncestor, removeStart, end))
635             embeddingRemoveEnd = positionInParentBeforeNode(endUnsplitAncestor).downstream();
636
637         if (embeddingRemoveEnd != removeStart || embeddingRemoveEnd != end) {
638             styleWithoutEmbedding = style->copy();
639             embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();
640
641             if (comparePositions(embeddingRemoveStart, embeddingRemoveEnd) <= 0)
642                 removeInlineStyle(embeddingStyle.get(), embeddingRemoveStart, embeddingRemoveEnd);
643         }
644     }
645
646     removeInlineStyle(styleWithoutEmbedding ? styleWithoutEmbedding.get() : style, removeStart, end);
647     start = startPosition();
648     end = endPosition();
649     if (start.isNull() || start.isOrphan() || end.isNull() || end.isOrphan())
650         return;
651
652     if (splitStart && mergeStartWithPreviousIfIdentical(start, end)) {
653         start = startPosition();
654         end = endPosition();
655     }
656
657     if (splitEnd) {
658         mergeEndWithNextIfIdentical(start, end);
659         start = startPosition();
660         end = endPosition();
661     }
662
663     if (start.isNull() || end.isNull())
664         return;
665
666     // update document layout once before running the rest of the function
667     // so that we avoid the expense of updating before each and every call
668     // to check a computed style
669     document().updateLayoutIgnorePendingStylesheets();
670
671     RefPtr<EditingStyle> styleToApply = style;
672     if (hasTextDirection) {
673         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
674         Node* embeddingStartNode = highestEmbeddingAncestor(start.deprecatedNode(), enclosingBlock(start.deprecatedNode()));
675         Node* embeddingEndNode = highestEmbeddingAncestor(end.deprecatedNode(), enclosingBlock(end.deprecatedNode()));
676
677         if (embeddingStartNode || embeddingEndNode) {
678             Position embeddingApplyStart = embeddingStartNode ? positionInParentAfterNode(embeddingStartNode) : start;
679             Position embeddingApplyEnd = embeddingEndNode ? positionInParentBeforeNode(embeddingEndNode) : end;
680             ASSERT(embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull());
681
682             if (!embeddingStyle) {
683                 styleWithoutEmbedding = style->copy();
684                 embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();
685             }
686             fixRangeAndApplyInlineStyle(embeddingStyle.get(), embeddingApplyStart, embeddingApplyEnd);
687
688             styleToApply = styleWithoutEmbedding;
689         }
690     }
691
692     fixRangeAndApplyInlineStyle(styleToApply.get(), start, end);
693
694     // Remove dummy style spans created by splitting text elements.
695     cleanupUnstyledAppleStyleSpans(startDummySpanAncestor.get());
696     if (endDummySpanAncestor != startDummySpanAncestor)
697         cleanupUnstyledAppleStyleSpans(endDummySpanAncestor.get());
698 }
699
700 void ApplyStyleCommand::fixRangeAndApplyInlineStyle(EditingStyle* style, const Position& start, const Position& end)
701 {
702     Node* startNode = start.deprecatedNode();
703
704     if (start.deprecatedEditingOffset() >= caretMaxOffset(start.deprecatedNode())) {
705         startNode = NodeTraversal::next(*startNode);
706         if (!startNode || comparePositions(end, firstPositionInOrBeforeNode(startNode)) < 0)
707             return;
708     }
709
710     Node* pastEndNode = end.deprecatedNode();
711     if (end.deprecatedEditingOffset() >= caretMaxOffset(end.deprecatedNode()))
712         pastEndNode = NodeTraversal::nextSkippingChildren(*end.deprecatedNode());
713
714     // FIXME: Callers should perform this operation on a Range that includes the br
715     // if they want style applied to the empty line.
716     if (start == end && start.deprecatedNode()->hasTagName(brTag))
717         pastEndNode = NodeTraversal::next(*start.deprecatedNode());
718
719     // Start from the highest fully selected ancestor so that we can modify the fully selected node.
720     // e.g. When applying font-size: large on <font color="blue">hello</font>, we need to include the font element in our run
721     // to generate <font color="blue" size="4">hello</font> instead of <font color="blue"><font size="4">hello</font></font>
722     RefPtr<Range> range = Range::create(startNode->document(), start, end);
723     Element* editableRoot = startNode->rootEditableElement();
724     if (startNode != editableRoot) {
725         while (editableRoot && startNode->parentNode() != editableRoot && isNodeVisiblyContainedWithin(startNode->parentNode(), range.get()))
726             startNode = startNode->parentNode();
727     }
728
729     applyInlineStyleToNodeRange(style, startNode, pastEndNode);
730 }
731
732 static bool containsNonEditableRegion(Node& node)
733 {
734     if (!node.hasEditableStyle())
735         return true;
736
737     Node* sibling = NodeTraversal::nextSkippingChildren(node);
738     for (Node* descendant = node.firstChild(); descendant && descendant != sibling; descendant = NodeTraversal::next(*descendant)) {
739         if (!descendant->hasEditableStyle())
740             return true;
741     }
742
743     return false;
744 }
745
746 struct InlineRunToApplyStyle {
747     InlineRunToApplyStyle(Node* start, Node* end, Node* pastEndNode)
748         : start(start)
749         , end(end)
750         , pastEndNode(pastEndNode)
751     {
752         ASSERT(start->parentNode() == end->parentNode());
753     }
754
755     bool startAndEndAreStillInDocument()
756     {
757         return start && end && start->inDocument() && end->inDocument();
758     }
759
760     RefPtr<Node> start;
761     RefPtr<Node> end;
762     RefPtr<Node> pastEndNode;
763     Position positionForStyleComputation;
764     RefPtr<Node> dummyElement;
765     StyleChange change;
766 };
767
768 void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, PassRefPtr<Node> startNode, PassRefPtr<Node> pastEndNode)
769 {
770     if (m_removeOnly)
771         return;
772
773     document().updateLayoutIgnorePendingStylesheets();
774
775     Vector<InlineRunToApplyStyle> runs;
776     RefPtr<Node> node = startNode;
777     for (RefPtr<Node> next; node && node != pastEndNode; node = next) {
778         next = NodeTraversal::next(*node);
779
780         if (!node->renderer() || !node->hasEditableStyle())
781             continue;
782         
783         if (!node->hasRichlyEditableStyle() && is<HTMLElement>(*node)) {
784             // This is a plaintext-only region. Only proceed if it's fully selected.
785             // pastEndNode is the node after the last fully selected node, so if it's inside node then
786             // node isn't fully selected.
787             if (pastEndNode && pastEndNode->isDescendantOf(node.get()))
788                 break;
789             // Add to this element's inline style and skip over its contents.
790             HTMLElement& element = downcast<HTMLElement>(*node);
791             RefPtr<MutableStyleProperties> inlineStyle = copyStyleOrCreateEmpty(element.inlineStyle());
792             if (MutableStyleProperties* otherStyle = style->style())
793                 inlineStyle->mergeAndOverrideOnConflict(*otherStyle);
794             setNodeAttribute(&element, styleAttr, inlineStyle->asText());
795             next = NodeTraversal::nextSkippingChildren(*node);
796             continue;
797         }
798         
799         if (isBlock(node.get()))
800             continue;
801         
802         if (node->hasChildNodes()) {
803             if (node->contains(pastEndNode.get()) || containsNonEditableRegion(*node) || !node->parentNode()->hasEditableStyle())
804                 continue;
805             if (editingIgnoresContent(node.get())) {
806                 next = NodeTraversal::nextSkippingChildren(*node);
807                 continue;
808             }
809         }
810
811         Node* runStart = node.get();
812         Node* runEnd = node.get();
813         Node* sibling = node->nextSibling();
814         while (sibling && sibling != pastEndNode && !sibling->contains(pastEndNode.get()) && (!isBlock(sibling) || sibling->hasTagName(brTag)) && !containsNonEditableRegion(*sibling)) {
815             runEnd = sibling;
816             sibling = runEnd->nextSibling();
817         }
818         next = NodeTraversal::nextSkippingChildren(*runEnd);
819
820         Node* pastEndNode = NodeTraversal::nextSkippingChildren(*runEnd);
821         if (!shouldApplyInlineStyleToRun(style, runStart, pastEndNode))
822             continue;
823
824         runs.append(InlineRunToApplyStyle(runStart, runEnd, pastEndNode));
825     }
826
827     for (auto& run : runs) {
828         removeConflictingInlineStyleFromRun(style, run.start, run.end, run.pastEndNode);
829         if (run.startAndEndAreStillInDocument())
830             run.positionForStyleComputation = positionToComputeInlineStyleChange(run.start, run.dummyElement);
831     }
832
833     document().updateLayoutIgnorePendingStylesheets();
834
835     for (auto& run : runs)
836         run.change = StyleChange(style, run.positionForStyleComputation);
837
838     for (auto& run : runs) {
839         if (run.dummyElement)
840             removeNode(run.dummyElement);
841         if (run.startAndEndAreStillInDocument())
842             applyInlineStyleChange(run.start.release(), run.end.release(), run.change, AddStyledElement);
843     }
844 }
845
846 bool ApplyStyleCommand::isStyledInlineElementToRemove(Element* element) const
847 {
848     return (m_styledInlineElement && element->hasTagName(m_styledInlineElement->tagQName()))
849         || (m_isInlineElementToRemoveFunction && m_isInlineElementToRemoveFunction(element));
850 }
851
852 bool ApplyStyleCommand::shouldApplyInlineStyleToRun(EditingStyle* style, Node* runStart, Node* pastEndNode)
853 {
854     ASSERT(style && runStart);
855
856     for (Node* node = runStart; node && node != pastEndNode; node = NodeTraversal::next(*node)) {
857         if (node->hasChildNodes())
858             continue;
859         // We don't consider m_isInlineElementToRemoveFunction here because we never apply style when m_isInlineElementToRemoveFunction is specified
860         if (!style->styleIsPresentInComputedStyleOfNode(node))
861             return true;
862         if (m_styledInlineElement && !enclosingElementWithTag(positionBeforeNode(node), m_styledInlineElement->tagQName()))
863             return true;
864     }
865     return false;
866 }
867
868 void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, RefPtr<Node>& runStart, RefPtr<Node>& runEnd, PassRefPtr<Node> pastEndNode)
869 {
870     ASSERT(runStart && runEnd);
871     RefPtr<Node> next = runStart;
872     for (RefPtr<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
873         if (editingIgnoresContent(node.get())) {
874             ASSERT(!node->contains(pastEndNode.get()));
875             next = NodeTraversal::nextSkippingChildren(*node);
876         } else
877             next = NodeTraversal::next(*node);
878
879         if (!is<HTMLElement>(*node))
880             continue;
881
882         RefPtr<Node> previousSibling = node->previousSibling();
883         RefPtr<Node> nextSibling = node->nextSibling();
884         RefPtr<ContainerNode> parent = node->parentNode();
885         removeInlineStyleFromElement(style, downcast<HTMLElement>(node.get()), RemoveAlways);
886         if (!node->inDocument()) {
887             // FIXME: We might need to update the start and the end of current selection here but need a test.
888             if (runStart == node)
889                 runStart = previousSibling ? previousSibling->nextSibling() : parent->firstChild();
890             if (runEnd == node)
891                 runEnd = nextSibling ? nextSibling->previousSibling() : parent->lastChild();
892         }
893     }
894 }
895
896 bool ApplyStyleCommand::removeInlineStyleFromElement(EditingStyle* style, PassRefPtr<HTMLElement> element, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
897 {
898     ASSERT(element);
899
900     if (!element->parentNode() || !isEditableNode(*element->parentNode()))
901         return false;
902
903     if (isStyledInlineElementToRemove(element.get())) {
904         if (mode == RemoveNone)
905             return true;
906         if (extractedStyle)
907             extractedStyle->mergeInlineStyleOfElement(element.get(), EditingStyle::OverrideValues);
908         removeNodePreservingChildren(element);
909         return true;
910     }
911
912     bool removed = false;
913     if (removeImplicitlyStyledElement(style, element.get(), mode, extractedStyle))
914         removed = true;
915
916     if (!element->inDocument())
917         return removed;
918
919     // If the node was converted to a span, the span may still contain relevant
920     // styles which must be removed (e.g. <b style='font-weight: bold'>)
921     if (removeCSSStyle(style, element.get(), mode, extractedStyle))
922         removed = true;
923
924     return removed;
925 }
926     
927 void ApplyStyleCommand::replaceWithSpanOrRemoveIfWithoutAttributes(HTMLElement*& elem)
928 {
929     if (hasNoAttributeOrOnlyStyleAttribute(elem, StyleAttributeShouldBeEmpty))
930         removeNodePreservingChildren(elem);
931     else {
932         HTMLElement* newSpanElement = replaceElementWithSpanPreservingChildrenAndAttributes(elem);
933         ASSERT(newSpanElement && newSpanElement->inDocument());
934         elem = newSpanElement;
935     }
936 }
937     
938 bool ApplyStyleCommand::removeImplicitlyStyledElement(EditingStyle* style, HTMLElement* element, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
939 {
940     ASSERT(style);
941     if (mode == RemoveNone) {
942         ASSERT(!extractedStyle);
943         return style->conflictsWithImplicitStyleOfElement(element) || style->conflictsWithImplicitStyleOfAttributes(element);
944     }
945
946     ASSERT(mode == RemoveIfNeeded || mode == RemoveAlways);
947     if (style->conflictsWithImplicitStyleOfElement(element, extractedStyle, mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle : EditingStyle::DoNotExtractMatchingStyle)) {
948         replaceWithSpanOrRemoveIfWithoutAttributes(element);
949         return true;
950     }
951
952     // unicode-bidi and direction are pushed down separately so don't push down with other styles
953     Vector<QualifiedName> attributes;
954     if (!style->extractConflictingImplicitStyleOfAttributes(element, extractedStyle ? EditingStyle::PreserveWritingDirection : EditingStyle::DoNotPreserveWritingDirection,
955         extractedStyle, attributes, mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle : EditingStyle::DoNotExtractMatchingStyle))
956         return false;
957
958     for (auto& attribute : attributes)
959         removeNodeAttribute(element, attribute);
960
961     if (isEmptyFontTag(element) || isSpanWithoutAttributesOrUnstyledStyleSpan(element))
962         removeNodePreservingChildren(element);
963
964     return true;
965 }
966
967 bool ApplyStyleCommand::removeCSSStyle(EditingStyle* style, HTMLElement* element, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
968 {
969     ASSERT(style);
970     ASSERT(element);
971
972     if (mode == RemoveNone)
973         return style->conflictsWithInlineStyleOfElement(element);
974
975     RefPtr<MutableStyleProperties> newInlineStyle;
976     if (!style->conflictsWithInlineStyleOfElement(element, newInlineStyle, extractedStyle))
977         return false;
978
979     if (newInlineStyle->isEmpty())
980         removeNodeAttribute(element, styleAttr);
981     else
982         setNodeAttribute(element, styleAttr, newInlineStyle->asText());
983
984     if (isSpanWithoutAttributesOrUnstyledStyleSpan(element))
985         removeNodePreservingChildren(element);
986
987     return true;
988 }
989
990 HTMLElement* ApplyStyleCommand::highestAncestorWithConflictingInlineStyle(EditingStyle* style, Node* node)
991 {
992     if (!node)
993         return nullptr;
994
995     HTMLElement* result = nullptr;
996     Node* unsplittableElement = unsplittableElementForPosition(firstPositionInOrBeforeNode(node));
997
998     for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
999         if (is<HTMLElement>(*ancestor) && shouldRemoveInlineStyleFromElement(style, downcast<HTMLElement>(ancestor)))
1000             result = downcast<HTMLElement>(ancestor);
1001         // Should stop at the editable root (cannot cross editing boundary) and
1002         // also stop at the unsplittable element to be consistent with other UAs
1003         if (ancestor == unsplittableElement)
1004             break;
1005     }
1006
1007     return result;
1008 }
1009
1010 void ApplyStyleCommand::applyInlineStyleToPushDown(Node* node, EditingStyle* style)
1011 {
1012     ASSERT(node);
1013
1014     node->document().updateStyleIfNeeded();
1015
1016     if (!style || style->isEmpty() || !node->renderer() || is<HTMLIFrameElement>(*node))
1017         return;
1018
1019     RefPtr<EditingStyle> newInlineStyle = style;
1020     if (is<HTMLElement>(*node) && downcast<HTMLElement>(node)->inlineStyle()) {
1021         newInlineStyle = style->copy();
1022         newInlineStyle->mergeInlineStyleOfElement(downcast<HTMLElement>(node), EditingStyle::OverrideValues);
1023     }
1024
1025     // Since addInlineStyleIfNeeded can't add styles to block-flow render objects, add style attribute instead.
1026     // FIXME: applyInlineStyleToRange should be used here instead.
1027     if ((node->renderer()->isRenderBlockFlow() || node->hasChildNodes()) && is<HTMLElement>(*node)) {
1028         setNodeAttribute(downcast<HTMLElement>(node), styleAttr, newInlineStyle->style()->asText());
1029         return;
1030     }
1031
1032     if (node->renderer()->isText() && static_cast<RenderText*>(node->renderer())->isAllCollapsibleWhitespace())
1033         return;
1034     if (node->renderer()->isBR() && !node->renderer()->style().preserveNewline())
1035         return;
1036
1037     // We can't wrap node with the styled element here because new styled element will never be removed if we did.
1038     // If we modified the child pointer in pushDownInlineStyleAroundNode to point to new style element
1039     // then we fall into an infinite loop where we keep removing and adding styled element wrapping node.
1040     addInlineStyleIfNeeded(newInlineStyle.get(), node, node, DoNotAddStyledElement);
1041 }
1042
1043 void ApplyStyleCommand::pushDownInlineStyleAroundNode(EditingStyle* style, Node* targetNode)
1044 {
1045     HTMLElement* highestAncestor = highestAncestorWithConflictingInlineStyle(style, targetNode);
1046     if (!highestAncestor)
1047         return;
1048
1049     // The outer loop is traversing the tree vertically from highestAncestor to targetNode
1050     RefPtr<Node> current = highestAncestor;
1051     // Along the way, styled elements that contain targetNode are removed and accumulated into elementsToPushDown.
1052     // Each child of the removed element, exclusing ancestors of targetNode, is then wrapped by clones of elements in elementsToPushDown.
1053     Vector<Ref<Element>> elementsToPushDown;
1054     while (current && current != targetNode && current->contains(targetNode)) {
1055         NodeVector currentChildren;
1056         getChildNodes(*current.get(), currentChildren);
1057
1058         RefPtr<StyledElement> styledElement;
1059         if (is<StyledElement>(*current) && isStyledInlineElementToRemove(downcast<Element>(current.get()))) {
1060             styledElement = downcast<StyledElement>(current.get());
1061             elementsToPushDown.append(*styledElement);
1062         }
1063
1064         RefPtr<EditingStyle> styleToPushDown = EditingStyle::create();
1065         if (is<HTMLElement>(*current))
1066             removeInlineStyleFromElement(style, downcast<HTMLElement>(current.get()), RemoveIfNeeded, styleToPushDown.get());
1067
1068         // The inner loop will go through children on each level
1069         // FIXME: we should aggregate inline child elements together so that we don't wrap each child separately.
1070         for (Ref<Node>& childRef : currentChildren) {
1071             Node& child = childRef;
1072             if (!child.parentNode())
1073                 continue;
1074             if (!child.contains(targetNode) && elementsToPushDown.size()) {
1075                 for (auto& element : elementsToPushDown) {
1076                     RefPtr<Element> wrapper = element->cloneElementWithoutChildren(document());
1077                     wrapper->removeAttribute(styleAttr);
1078                     surroundNodeRangeWithElement(&child, &child, wrapper);
1079                 }
1080             }
1081
1082             // Apply style to all nodes containing targetNode and their siblings but NOT to targetNode
1083             // But if we've removed styledElement then always apply the style.
1084             if (&child != targetNode || styledElement)
1085                 applyInlineStyleToPushDown(&child, styleToPushDown.get());
1086
1087             // We found the next node for the outer loop (contains targetNode)
1088             // When reached targetNode, stop the outer loop upon the completion of the current inner loop
1089             if (&child == targetNode || child.contains(targetNode))
1090                 current = &child;
1091         }
1092     }
1093 }
1094
1095 void ApplyStyleCommand::removeInlineStyle(EditingStyle* style, const Position &start, const Position &end)
1096 {
1097     ASSERT(start.isNotNull());
1098     ASSERT(end.isNotNull());
1099     ASSERT(start.anchorNode()->inDocument());
1100     ASSERT(end.anchorNode()->inDocument());
1101     ASSERT(comparePositions(start, end) <= 0);
1102     // FIXME: We should assert that start/end are not in the middle of a text node.
1103
1104     Position pushDownStart = start.downstream();
1105     // If the pushDownStart is at the end of a text node, then this node is not fully selected.
1106     // Move it to the next deep quivalent position to avoid removing the style from this node.
1107     // e.g. if pushDownStart was at Position("hello", 5) in <b>hello<div>world</div></b>, we want Position("world", 0) instead.
1108     Node* pushDownStartContainer = pushDownStart.containerNode();
1109     if (pushDownStartContainer && pushDownStartContainer->isTextNode()
1110         && pushDownStart.computeOffsetInContainerNode() == pushDownStartContainer->maxCharacterOffset())
1111         pushDownStart = nextVisuallyDistinctCandidate(pushDownStart);
1112     // If pushDownEnd is at the start of a text node, then this node is not fully selected.
1113     // Move it to the previous deep equivalent position to avoid removing the style from this node.
1114     Position pushDownEnd = end.upstream();
1115     Node* pushDownEndContainer = pushDownEnd.containerNode();
1116     if (pushDownEndContainer && pushDownEndContainer->isTextNode() && !pushDownEnd.computeOffsetInContainerNode())
1117         pushDownEnd = previousVisuallyDistinctCandidate(pushDownEnd);
1118
1119     pushDownInlineStyleAroundNode(style, pushDownStart.deprecatedNode());
1120     pushDownInlineStyleAroundNode(style, pushDownEnd.deprecatedNode());
1121
1122     // The s and e variables store the positions used to set the ending selection after style removal
1123     // takes place. This will help callers to recognize when either the start node or the end node
1124     // are removed from the document during the work of this function.
1125     // If pushDownInlineStyleAroundNode has pruned start.deprecatedNode() or end.deprecatedNode(),
1126     // use pushDownStart or pushDownEnd instead, which pushDownInlineStyleAroundNode won't prune.
1127     Position s = start.isNull() || start.isOrphan() ? pushDownStart : start;
1128     Position e = end.isNull() || end.isOrphan() ? pushDownEnd : end;
1129
1130     RefPtr<Node> node = start.deprecatedNode();
1131     while (node) {
1132         RefPtr<Node> next;
1133         if (editingIgnoresContent(node.get())) {
1134             ASSERT(node == end.deprecatedNode() || !node->contains(end.deprecatedNode()));
1135             next = NodeTraversal::nextSkippingChildren(*node);
1136         } else
1137             next = NodeTraversal::next(*node);
1138
1139         if (is<HTMLElement>(*node) && nodeFullySelected(node.get(), start, end)) {
1140             Ref<HTMLElement> elem = downcast<HTMLElement>(*node);
1141             RefPtr<Node> prev = NodeTraversal::previousPostOrder(elem);
1142             RefPtr<Node> next = NodeTraversal::next(elem);
1143             RefPtr<EditingStyle> styleToPushDown;
1144             RefPtr<Node> childNode;
1145             if (isStyledInlineElementToRemove(elem.ptr())) {
1146                 styleToPushDown = EditingStyle::create();
1147                 childNode = elem->firstChild();
1148             }
1149
1150             removeInlineStyleFromElement(style, elem.ptr(), RemoveIfNeeded, styleToPushDown.get());
1151             if (!elem->inDocument()) {
1152                 if (s.deprecatedNode() == elem.ptr()) {
1153                     // Since elem must have been fully selected, and it is at the start
1154                     // of the selection, it is clear we can set the new s offset to 0.
1155                     ASSERT(s.anchorType() == Position::PositionIsBeforeAnchor || s.offsetInContainerNode() <= 0);
1156                     s = firstPositionInOrBeforeNode(next.get());
1157                 }
1158                 if (e.deprecatedNode() == elem.ptr()) {
1159                     // Since elem must have been fully selected, and it is at the end
1160                     // of the selection, it is clear we can set the new e offset to
1161                     // the max range offset of prev.
1162                     ASSERT(s.anchorType() == Position::PositionIsAfterAnchor || !offsetIsBeforeLastNodeOffset(s.offsetInContainerNode(), s.containerNode()));
1163                     e = lastPositionInOrAfterNode(prev.get());
1164                 }
1165             }
1166
1167             if (styleToPushDown) {
1168                 for (; childNode; childNode = childNode->nextSibling())
1169                     applyInlineStyleToPushDown(childNode.get(), styleToPushDown.get());
1170             }
1171         }
1172         if (node == end.deprecatedNode())
1173             break;
1174         node = next.get();
1175     }
1176
1177     updateStartEnd(s, e);
1178 }
1179
1180 bool ApplyStyleCommand::nodeFullySelected(Node *node, const Position &start, const Position &end) const
1181 {
1182     ASSERT(node);
1183     ASSERT(node->isElementNode());
1184
1185     // The tree may have changed and Position::upstream() relies on an up-to-date layout.
1186     node->document().updateLayoutIgnorePendingStylesheets();
1187
1188     return comparePositions(firstPositionInOrBeforeNode(node), start) >= 0
1189         && comparePositions(lastPositionInOrAfterNode(node).upstream(), end) <= 0;
1190 }
1191
1192 bool ApplyStyleCommand::nodeFullyUnselected(Node *node, const Position &start, const Position &end) const
1193 {
1194     ASSERT(node);
1195     ASSERT(node->isElementNode());
1196
1197     bool isFullyBeforeStart = comparePositions(lastPositionInOrAfterNode(node).upstream(), start) < 0;
1198     bool isFullyAfterEnd = comparePositions(firstPositionInOrBeforeNode(node), end) > 0;
1199
1200     return isFullyBeforeStart || isFullyAfterEnd;
1201 }
1202
1203 void ApplyStyleCommand::splitTextAtStart(const Position& start, const Position& end)
1204 {
1205     ASSERT(start.containerNode()->isTextNode());
1206
1207     Position newEnd;
1208     if (end.anchorType() == Position::PositionIsOffsetInAnchor && start.containerNode() == end.containerNode())
1209         newEnd = Position(end.containerText(), end.offsetInContainerNode() - start.offsetInContainerNode());
1210     else
1211         newEnd = end;
1212
1213     RefPtr<Text> text = start.containerText();
1214     splitTextNode(text, start.offsetInContainerNode());
1215     updateStartEnd(firstPositionInNode(text.get()), newEnd);
1216 }
1217
1218 void ApplyStyleCommand::splitTextAtEnd(const Position& start, const Position& end)
1219 {
1220     ASSERT(is<Text>(end.containerNode()));
1221
1222     bool shouldUpdateStart = start.anchorType() == Position::PositionIsOffsetInAnchor && start.containerNode() == end.containerNode();
1223     Text& text = downcast<Text>(*end.deprecatedNode());
1224     splitTextNode(&text, end.offsetInContainerNode());
1225
1226     Node* prevNode = text.previousSibling();
1227     if (!is<Text>(prevNode))
1228         return;
1229
1230     Position newStart = shouldUpdateStart ? Position(downcast<Text>(prevNode), start.offsetInContainerNode()) : start;
1231     updateStartEnd(newStart, lastPositionInNode(prevNode));
1232 }
1233
1234 void ApplyStyleCommand::splitTextElementAtStart(const Position& start, const Position& end)
1235 {
1236     ASSERT(start.containerNode()->isTextNode());
1237
1238     Position newEnd;
1239     if (start.containerNode() == end.containerNode())
1240         newEnd = Position(end.containerText(), end.offsetInContainerNode() - start.offsetInContainerNode());
1241     else
1242         newEnd = end;
1243
1244     splitTextNodeContainingElement(start.containerText(), start.offsetInContainerNode());
1245     updateStartEnd(positionBeforeNode(start.containerNode()), newEnd);
1246 }
1247
1248 void ApplyStyleCommand::splitTextElementAtEnd(const Position& start, const Position& end)
1249 {
1250     ASSERT(end.containerNode()->isTextNode());
1251
1252     bool shouldUpdateStart = start.containerNode() == end.containerNode();
1253     splitTextNodeContainingElement(end.containerText(), end.offsetInContainerNode());
1254
1255     Node* parentElement = end.containerNode()->parentNode();
1256     if (!parentElement || !parentElement->previousSibling())
1257         return;
1258     Node* firstTextNode = parentElement->previousSibling()->lastChild();
1259     if (!is<Text>(firstTextNode))
1260         return;
1261
1262     Position newStart = shouldUpdateStart ? Position(downcast<Text>(firstTextNode), start.offsetInContainerNode()) : start;
1263     updateStartEnd(newStart, positionAfterNode(firstTextNode));
1264 }
1265
1266 bool ApplyStyleCommand::shouldSplitTextElement(Element* element, EditingStyle* style)
1267 {
1268     if (!is<HTMLElement>(element))
1269         return false;
1270
1271     return shouldRemoveInlineStyleFromElement(style, downcast<HTMLElement>(element));
1272 }
1273
1274 bool ApplyStyleCommand::isValidCaretPositionInTextNode(const Position& position)
1275 {
1276     Node* node = position.containerNode();
1277     if (position.anchorType() != Position::PositionIsOffsetInAnchor || !node->isTextNode())
1278         return false;
1279     int offsetInText = position.offsetInContainerNode();
1280     return offsetInText > caretMinOffset(node) && offsetInText < caretMaxOffset(node);
1281 }
1282
1283 bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position& start, const Position& end)
1284 {
1285     Node* startNode = start.containerNode();
1286     int startOffset = start.computeOffsetInContainerNode();
1287     if (startOffset)
1288         return false;
1289
1290     if (isAtomicNode(startNode)) {
1291         // note: prior siblings could be unrendered elements. it's silly to miss the
1292         // merge opportunity just for that.
1293         if (startNode->previousSibling())
1294             return false;
1295
1296         startNode = startNode->parentNode();
1297     }
1298
1299     if (!startNode->isElementNode())
1300         return false;
1301
1302     Node* previousSibling = startNode->previousSibling();
1303
1304     if (previousSibling && areIdenticalElements(startNode, previousSibling)) {
1305         Element* previousElement = downcast<Element>(previousSibling);
1306         Element* element = downcast<Element>(startNode);
1307         Node* startChild = element->firstChild();
1308         ASSERT(startChild);
1309         mergeIdenticalElements(previousElement, element);
1310
1311         unsigned startOffsetAdjustment = startChild->computeNodeIndex();
1312         unsigned endOffsetAdjustment = startNode == end.deprecatedNode() ? startOffsetAdjustment : 0;
1313         updateStartEnd(Position(startNode, startOffsetAdjustment, Position::PositionIsOffsetInAnchor),
1314                        Position(end.deprecatedNode(), end.deprecatedEditingOffset() + endOffsetAdjustment, Position::PositionIsOffsetInAnchor)); 
1315         return true;
1316     }
1317
1318     return false;
1319 }
1320
1321 bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position& start, const Position& end)
1322 {
1323     Node* endNode = end.containerNode();
1324
1325     if (isAtomicNode(endNode)) {
1326         int endOffset = end.computeOffsetInContainerNode();
1327         if (offsetIsBeforeLastNodeOffset(endOffset, endNode) || end.deprecatedNode()->nextSibling())
1328             return false;
1329
1330         endNode = end.deprecatedNode()->parentNode();
1331     }
1332
1333     if (!endNode->isElementNode() || endNode->hasTagName(brTag))
1334         return false;
1335
1336     Node* nextSibling = endNode->nextSibling();
1337     if (nextSibling && areIdenticalElements(endNode, nextSibling)) {
1338         Element* nextElement = downcast<Element>(nextSibling);
1339         Element* element = downcast<Element>(endNode);
1340         Node* nextChild = nextElement->firstChild();
1341
1342         mergeIdenticalElements(element, nextElement);
1343
1344         bool shouldUpdateStart = start.containerNode() == endNode;
1345         unsigned endOffset = nextChild ? nextChild->computeNodeIndex() : nextElement->countChildNodes();
1346         updateStartEnd(shouldUpdateStart ? Position(nextElement, start.offsetInContainerNode(), Position::PositionIsOffsetInAnchor) : start,
1347                        Position(nextElement, endOffset, Position::PositionIsOffsetInAnchor));
1348         return true;
1349     }
1350
1351     return false;
1352 }
1353
1354 void ApplyStyleCommand::surroundNodeRangeWithElement(PassRefPtr<Node> passedStartNode, PassRefPtr<Node> endNode, PassRefPtr<Element> elementToInsert)
1355 {
1356     ASSERT(passedStartNode);
1357     ASSERT(endNode);
1358     ASSERT(elementToInsert);
1359     RefPtr<Node> startNode = passedStartNode;
1360     RefPtr<Element> element = elementToInsert;
1361
1362     insertNodeBefore(element, startNode);
1363
1364     RefPtr<Node> node = startNode;
1365     while (node) {
1366         RefPtr<Node> next = node->nextSibling();
1367         if (isEditableNode(*node)) {
1368             removeNode(node);
1369             appendNode(node, element);
1370         }
1371         if (node == endNode)
1372             break;
1373         node = next;
1374     }
1375
1376     RefPtr<Node> nextSibling = element->nextSibling();
1377     RefPtr<Node> previousSibling = element->previousSibling();
1378     if (is<Element>(nextSibling.get()) && nextSibling->hasEditableStyle()
1379         && areIdenticalElements(element.get(), downcast<Element>(nextSibling.get())))
1380         mergeIdenticalElements(element.get(), downcast<Element>(nextSibling.get()));
1381
1382     if (is<Element>(previousSibling.get()) && previousSibling->hasEditableStyle()) {
1383         Node* mergedElement = previousSibling->nextSibling();
1384         ASSERT(mergedElement);
1385         if (is<Element>(*mergedElement) && mergedElement->hasEditableStyle()
1386             && areIdenticalElements(downcast<Element>(previousSibling.get()), downcast<Element>(mergedElement)))
1387             mergeIdenticalElements(downcast<Element>(previousSibling.get()), downcast<Element>(mergedElement));
1388     }
1389
1390     // FIXME: We should probably call updateStartEnd if the start or end was in the node
1391     // range so that the endingSelection() is canonicalized.  See the comments at the end of
1392     // VisibleSelection::validate().
1393 }
1394
1395 void ApplyStyleCommand::addBlockStyle(const StyleChange& styleChange, HTMLElement* block)
1396 {
1397     ASSERT(styleChange.cssStyle());
1398     // Do not check for legacy styles here. Those styles, like <B> and <I>, only apply for
1399     // inline content.
1400     if (!block)
1401         return;
1402         
1403     String cssStyle = styleChange.cssStyle()->asText();
1404     StringBuilder cssText;
1405     cssText.append(cssStyle);
1406     if (const StyleProperties* decl = block->inlineStyle()) {
1407         if (!cssStyle.isEmpty())
1408             cssText.append(' ');
1409         cssText.append(decl->asText());
1410     }
1411     setNodeAttribute(block, styleAttr, cssText.toString());
1412 }
1413
1414 void ApplyStyleCommand::addInlineStyleIfNeeded(EditingStyle* style, PassRefPtr<Node> passedStart, PassRefPtr<Node> passedEnd, EAddStyledElement addStyledElement)
1415 {
1416     if (!passedStart || !passedEnd || !passedStart->inDocument() || !passedEnd->inDocument())
1417         return;
1418
1419     RefPtr<Node> start = passedStart;
1420     RefPtr<Node> dummyElement;
1421     StyleChange styleChange(style, positionToComputeInlineStyleChange(start, dummyElement));
1422
1423     if (dummyElement)
1424         removeNode(dummyElement);
1425
1426     applyInlineStyleChange(start, passedEnd, styleChange, addStyledElement);
1427 }
1428
1429 Position ApplyStyleCommand::positionToComputeInlineStyleChange(PassRefPtr<Node> startNode, RefPtr<Node>& dummyElement)
1430 {
1431     // It's okay to obtain the style at the startNode because we've removed all relevant styles from the current run.
1432     if (!startNode->isElementNode()) {
1433         dummyElement = createStyleSpanElement(document());
1434         insertNodeAt(dummyElement, positionBeforeNode(startNode.get()));
1435         return firstPositionInOrBeforeNode(dummyElement.get());
1436     }
1437
1438     return firstPositionInOrBeforeNode(startNode.get());
1439 }
1440
1441 void ApplyStyleCommand::applyInlineStyleChange(PassRefPtr<Node> passedStart, PassRefPtr<Node> passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement)
1442 {
1443     RefPtr<Node> startNode = passedStart;
1444     RefPtr<Node> endNode = passedEnd;
1445     ASSERT(startNode->inDocument());
1446     ASSERT(endNode->inDocument());
1447
1448     // Find appropriate font and span elements top-down.
1449     HTMLFontElement* fontContainer = nullptr;
1450     HTMLElement* styleContainer = nullptr;
1451     for (Node* container = startNode.get(); container && startNode == endNode; container = container->firstChild()) {
1452         if (is<HTMLFontElement>(*container))
1453             fontContainer = downcast<HTMLFontElement>(container);
1454         bool styleContainerIsNotSpan = !is<HTMLSpanElement>(styleContainer);
1455         if (is<HTMLElement>(*container) && (is<HTMLSpanElement>(*container) || (styleContainerIsNotSpan && container->hasChildNodes())))
1456             styleContainer = downcast<HTMLElement>(container);
1457         if (!container->firstChild())
1458             break;
1459         startNode = container->firstChild();
1460         endNode = container->lastChild();
1461     }
1462
1463     // Font tags need to go outside of CSS so that CSS font sizes override leagcy font sizes.
1464     if (styleChange.applyFontColor() || styleChange.applyFontFace() || styleChange.applyFontSize()) {
1465         if (fontContainer) {
1466             if (styleChange.applyFontColor())
1467                 setNodeAttribute(fontContainer, colorAttr, styleChange.fontColor());
1468             if (styleChange.applyFontFace())
1469                 setNodeAttribute(fontContainer, faceAttr, styleChange.fontFace());
1470             if (styleChange.applyFontSize())
1471                 setNodeAttribute(fontContainer, sizeAttr, styleChange.fontSize());
1472         } else {
1473             RefPtr<Element> fontElement = createFontElement(document());
1474             if (styleChange.applyFontColor())
1475                 fontElement->setAttribute(colorAttr, styleChange.fontColor());
1476             if (styleChange.applyFontFace())
1477                 fontElement->setAttribute(faceAttr, styleChange.fontFace());
1478             if (styleChange.applyFontSize())
1479                 fontElement->setAttribute(sizeAttr, styleChange.fontSize());
1480             surroundNodeRangeWithElement(startNode, endNode, fontElement.get());
1481         }
1482     }
1483
1484     if (auto styleToMerge = styleChange.cssStyle()) {
1485         if (styleContainer) {
1486             if (auto existingStyle = styleContainer->inlineStyle()) {
1487                 auto inlineStyle = EditingStyle::create(existingStyle);
1488                 inlineStyle->overrideWithStyle(styleToMerge);
1489                 setNodeAttribute(styleContainer, styleAttr, inlineStyle->style()->asText());
1490             } else
1491                 setNodeAttribute(styleContainer, styleAttr, styleToMerge->asText());
1492         } else {
1493             RefPtr<Element> styleElement = createStyleSpanElement(document());
1494             styleElement->setAttribute(styleAttr, styleToMerge->asText());
1495             surroundNodeRangeWithElement(startNode, endNode, styleElement.release());
1496         }
1497     }
1498
1499     if (styleChange.applyBold())
1500         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), bTag));
1501
1502     if (styleChange.applyItalic())
1503         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), iTag));
1504
1505     if (styleChange.applyUnderline())
1506         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), uTag));
1507
1508     if (styleChange.applyLineThrough())
1509         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), strikeTag));
1510
1511     if (styleChange.applySubscript())
1512         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), subTag));
1513     else if (styleChange.applySuperscript())
1514         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), supTag));
1515
1516     if (m_styledInlineElement && addStyledElement == AddStyledElement)
1517         surroundNodeRangeWithElement(startNode, endNode, m_styledInlineElement->cloneElementWithoutChildren(document()));
1518 }
1519
1520 float ApplyStyleCommand::computedFontSize(Node* node)
1521 {
1522     if (!node)
1523         return 0;
1524
1525     RefPtr<CSSValue> value = ComputedStyleExtractor(node).propertyValue(CSSPropertyFontSize);
1526     return downcast<CSSPrimitiveValue>(*value).getFloatValue(CSSPrimitiveValue::CSS_PX);
1527 }
1528
1529 void ApplyStyleCommand::joinChildTextNodes(Node* node, const Position& start, const Position& end)
1530 {
1531     if (!node)
1532         return;
1533
1534     Position newStart = start;
1535     Position newEnd = end;
1536
1537     Vector<RefPtr<Text>> textNodes;
1538     for (Text* textNode = TextNodeTraversal::firstChild(*node); textNode; textNode = TextNodeTraversal::nextSibling(*textNode))
1539         textNodes.append(textNode);
1540
1541     for (auto& childText : textNodes) {
1542         Node* next = childText->nextSibling();
1543         if (!is<Text>(next))
1544             continue;
1545     
1546         Text& nextText = downcast<Text>(*next);
1547         if (start.anchorType() == Position::PositionIsOffsetInAnchor && next == start.containerNode())
1548             newStart = Position(childText, childText->length() + start.offsetInContainerNode());
1549         if (end.anchorType() == Position::PositionIsOffsetInAnchor && next == end.containerNode())
1550             newEnd = Position(childText, childText->length() + end.offsetInContainerNode());
1551         String textToMove = nextText.data();
1552         insertTextIntoNode(childText, childText->length(), textToMove);
1553         removeNode(next);
1554         // don't move child node pointer. it may want to merge with more text nodes.
1555     }
1556
1557     updateStartEnd(newStart, newEnd);
1558 }
1559
1560 }