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