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