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