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