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