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