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