Get rid of Position::computedStyle
[WebKit-https.git] / Source / WebCore / dom / Position.cpp
1 /*
2  * Copyright (C) 2004, 2005, 2006, 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 "Position.h"
28
29 #include "CSSComputedStyleDeclaration.h"
30 #include "HTMLNames.h"
31 #include "InlineIterator.h"
32 #include "InlineTextBox.h"
33 #include "Logging.h"
34 #include "PositionIterator.h"
35 #include "RenderBlock.h"
36 #include "RenderInline.h"
37 #include "RenderText.h"
38 #include "RuntimeEnabledFeatures.h"
39 #include "Text.h"
40 #include "TextIterator.h"
41 #include "VisiblePosition.h"
42 #include "VisibleUnits.h"
43 #include "htmlediting.h"
44 #include <stdio.h>
45 #include <wtf/text/CString.h>
46 #include <wtf/unicode/CharacterNames.h>
47   
48 namespace WebCore {
49
50 using namespace HTMLNames;
51
52 static Node* nextRenderedEditable(Node* node)
53 {
54     while ((node = nextLeafNode(node))) {
55         if (!node->rendererIsEditable())
56             continue;
57         RenderObject* renderer = node->renderer();
58         if (!renderer)
59             continue;
60         if ((renderer->isBox() && toRenderBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toRenderText(renderer)->firstTextBox()))
61             return node;
62     }
63     return 0;
64 }
65
66 static Node* previousRenderedEditable(Node* node)
67 {
68     while ((node = previousLeafNode(node))) {
69         if (!node->rendererIsEditable())
70             continue;
71         RenderObject* renderer = node->renderer();
72         if (!renderer)
73             continue;
74         if ((renderer->isBox() && toRenderBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toRenderText(renderer)->firstTextBox()))
75             return node;
76     }
77     return 0;
78 }
79
80 Position::Position(PassRefPtr<Node> anchorNode, LegacyEditingOffset offset)
81     : m_anchorNode(anchorNode)
82     , m_offset(offset.value())
83     , m_anchorType(anchorTypeForLegacyEditingPosition(m_anchorNode.get(), m_offset))
84     , m_isLegacyEditingPosition(true)
85 {
86 #if ENABLE(SHADOW_DOM)
87     ASSERT((m_anchorNode && RuntimeEnabledFeatures::shadowDOMEnabled())
88            || !m_anchorNode || !m_anchorNode->isShadowRoot());
89 #else
90     ASSERT(!m_anchorNode || !m_anchorNode->isShadowRoot());
91 #endif
92     ASSERT(!m_anchorNode || !m_anchorNode->isPseudoElement());
93 }
94
95 Position::Position(PassRefPtr<Node> anchorNode, AnchorType anchorType)
96     : m_anchorNode(anchorNode)
97     , m_offset(0)
98     , m_anchorType(anchorType)
99     , m_isLegacyEditingPosition(false)
100 {
101 #if ENABLE(SHADOW_DOM)
102     ASSERT((m_anchorNode && RuntimeEnabledFeatures::shadowDOMEnabled())
103            || !m_anchorNode || !m_anchorNode->isShadowRoot());
104 #else
105     ASSERT(!m_anchorNode || !m_anchorNode->isShadowRoot());
106 #endif
107
108     ASSERT(!m_anchorNode || !m_anchorNode->isPseudoElement());
109
110     ASSERT(anchorType != PositionIsOffsetInAnchor);
111     ASSERT(!((anchorType == PositionIsBeforeChildren || anchorType == PositionIsAfterChildren)
112         && (m_anchorNode->isTextNode() || editingIgnoresContent(m_anchorNode.get()))));
113 }
114
115 Position::Position(PassRefPtr<Node> anchorNode, int offset, AnchorType anchorType)
116     : m_anchorNode(anchorNode)
117     , m_offset(offset)
118     , m_anchorType(anchorType)
119     , m_isLegacyEditingPosition(false)
120 {
121 #if ENABLE(SHADOW_DOM)
122     ASSERT((m_anchorNode && RuntimeEnabledFeatures::shadowDOMEnabled())
123            || !m_anchorNode || !editingIgnoresContent(m_anchorNode.get()) || !m_anchorNode->isShadowRoot());
124 #else
125     ASSERT(!m_anchorNode || !editingIgnoresContent(m_anchorNode.get()) || !m_anchorNode->isShadowRoot());
126 #endif
127
128     ASSERT(!m_anchorNode || !m_anchorNode->isPseudoElement());
129
130     ASSERT(anchorType == PositionIsOffsetInAnchor);
131 }
132
133 Position::Position(PassRefPtr<Text> textNode, unsigned offset)
134     : m_anchorNode(textNode)
135     , m_offset(static_cast<int>(offset))
136     , m_anchorType(PositionIsOffsetInAnchor)
137     , m_isLegacyEditingPosition(false)
138 {
139     ASSERT(m_anchorNode);
140 }
141
142 void Position::moveToPosition(PassRefPtr<Node> node, int offset)
143 {
144     ASSERT(!editingIgnoresContent(node.get()));
145     ASSERT(anchorType() == PositionIsOffsetInAnchor || m_isLegacyEditingPosition);
146     m_anchorNode = node;
147     m_offset = offset;
148     if (m_isLegacyEditingPosition)
149         m_anchorType = anchorTypeForLegacyEditingPosition(m_anchorNode.get(), m_offset);
150 }
151 void Position::moveToOffset(int offset)
152 {
153     ASSERT(anchorType() == PositionIsOffsetInAnchor || m_isLegacyEditingPosition);
154     m_offset = offset;
155     if (m_isLegacyEditingPosition)
156         m_anchorType = anchorTypeForLegacyEditingPosition(m_anchorNode.get(), m_offset);
157 }
158
159 Node* Position::containerNode() const
160 {
161     if (!m_anchorNode)
162         return 0;
163
164     switch (anchorType()) {
165     case PositionIsBeforeChildren:
166     case PositionIsAfterChildren:
167     case PositionIsOffsetInAnchor:
168         return m_anchorNode.get();
169     case PositionIsBeforeAnchor:
170     case PositionIsAfterAnchor:
171         return findParent(m_anchorNode.get());
172     }
173     ASSERT_NOT_REACHED();
174     return 0;
175 }
176
177 Text* Position::containerText() const
178 {
179     switch (anchorType()) {
180     case PositionIsOffsetInAnchor:
181         return m_anchorNode && m_anchorNode->isTextNode() ? toText(m_anchorNode.get()) : 0;
182     case PositionIsBeforeAnchor:
183     case PositionIsAfterAnchor:
184         return 0;
185     case PositionIsBeforeChildren:
186     case PositionIsAfterChildren:
187         ASSERT(!m_anchorNode || !m_anchorNode->isTextNode());
188         return 0;
189     }
190     ASSERT_NOT_REACHED();
191     return 0;
192 }
193
194 int Position::computeOffsetInContainerNode() const
195 {
196     if (!m_anchorNode)
197         return 0;
198
199     switch (anchorType()) {
200     case PositionIsBeforeChildren:
201         return 0;
202     case PositionIsAfterChildren:
203         return lastOffsetInNode(m_anchorNode.get());
204     case PositionIsOffsetInAnchor:
205         return minOffsetForNode(m_anchorNode.get(), m_offset);
206     case PositionIsBeforeAnchor:
207         return m_anchorNode->nodeIndex();
208     case PositionIsAfterAnchor:
209         return m_anchorNode->nodeIndex() + 1;
210     }
211     ASSERT_NOT_REACHED();
212     return 0;
213 }
214
215 int Position::offsetForPositionAfterAnchor() const
216 {
217     ASSERT(m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren);
218     ASSERT(!m_isLegacyEditingPosition);
219     return lastOffsetForEditing(m_anchorNode.get());
220 }
221
222 // Neighbor-anchored positions are invalid DOM positions, so they need to be
223 // fixed up before handing them off to the Range object.
224 Position Position::parentAnchoredEquivalent() const
225 {
226     if (!m_anchorNode)
227         return Position();
228     
229     // FIXME: This should only be necessary for legacy positions, but is also needed for positions before and after Tables
230     if (m_offset <= 0 && (m_anchorType != PositionIsAfterAnchor && m_anchorType != PositionIsAfterChildren)) {
231         if (findParent(m_anchorNode.get()) && (editingIgnoresContent(m_anchorNode.get()) || isTableElement(m_anchorNode.get())))
232             return positionInParentBeforeNode(m_anchorNode.get());
233         return Position(m_anchorNode.get(), 0, PositionIsOffsetInAnchor);
234     }
235     if (!m_anchorNode->offsetInCharacters()
236         && (m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren || static_cast<unsigned>(m_offset) == m_anchorNode->childNodeCount())
237         && (editingIgnoresContent(m_anchorNode.get()) || isTableElement(m_anchorNode.get()))
238         && containerNode()) {
239         return positionInParentAfterNode(m_anchorNode.get());
240     }
241
242     return Position(containerNode(), computeOffsetInContainerNode(), PositionIsOffsetInAnchor);
243 }
244
245 Node* Position::computeNodeBeforePosition() const
246 {
247     if (!m_anchorNode)
248         return 0;
249
250     switch (anchorType()) {
251     case PositionIsBeforeChildren:
252         return 0;
253     case PositionIsAfterChildren:
254         return m_anchorNode->lastChild();
255     case PositionIsOffsetInAnchor:
256         return m_anchorNode->childNode(m_offset - 1); // -1 converts to childNode((unsigned)-1) and returns null.
257     case PositionIsBeforeAnchor:
258         return m_anchorNode->previousSibling();
259     case PositionIsAfterAnchor:
260         return m_anchorNode.get();
261     }
262     ASSERT_NOT_REACHED();
263     return 0;
264 }
265
266 Node* Position::computeNodeAfterPosition() const
267 {
268     if (!m_anchorNode)
269         return 0;
270
271     switch (anchorType()) {
272     case PositionIsBeforeChildren:
273         return m_anchorNode->firstChild();
274     case PositionIsAfterChildren:
275         return 0;
276     case PositionIsOffsetInAnchor:
277         return m_anchorNode->childNode(m_offset);
278     case PositionIsBeforeAnchor:
279         return m_anchorNode.get();
280     case PositionIsAfterAnchor:
281         return m_anchorNode->nextSibling();
282     }
283     ASSERT_NOT_REACHED();
284     return 0;
285 }
286
287 Position::AnchorType Position::anchorTypeForLegacyEditingPosition(Node* anchorNode, int offset)
288 {
289     if (anchorNode && editingIgnoresContent(anchorNode)) {
290         if (offset == 0)
291             return Position::PositionIsBeforeAnchor;
292         return Position::PositionIsAfterAnchor;
293     }
294     return Position::PositionIsOffsetInAnchor;
295 }
296
297 // FIXME: This method is confusing (does it return anchorNode() or containerNode()?) and should be renamed or removed
298 Element* Position::element() const
299 {
300     Node* n = anchorNode();
301     while (n && !n->isElementNode())
302         n = n->parentNode();
303     return toElement(n);
304 }
305
306 Position Position::previous(PositionMoveType moveType) const
307 {
308     Node* n = deprecatedNode();
309     if (!n)
310         return *this;
311
312     int o = deprecatedEditingOffset();
313     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
314     ASSERT(o >= 0);
315
316     if (o > 0) {
317         Node* child = n->childNode(o - 1);
318         if (child)
319             return lastPositionInOrAfterNode(child);
320
321         // There are two reasons child might be 0:
322         //   1) The node is node like a text node that is not an element, and therefore has no children.
323         //      Going backward one character at a time is correct.
324         //   2) The old offset was a bogus offset like (<br>, 1), and there is no child.
325         //      Going from 1 to 0 is correct.
326         switch (moveType) {
327         case CodePoint:
328             return createLegacyEditingPosition(n, o - 1);
329         case Character:
330             return createLegacyEditingPosition(n, uncheckedPreviousOffset(n, o));
331         case BackwardDeletion:
332             return createLegacyEditingPosition(n, uncheckedPreviousOffsetForBackwardDeletion(n, o));
333         }
334     }
335
336     ContainerNode* parent = findParent(n);
337     if (!parent)
338         return *this;
339
340     return createLegacyEditingPosition(parent, n->nodeIndex());
341 }
342
343 Position Position::next(PositionMoveType moveType) const
344 {
345     ASSERT(moveType != BackwardDeletion);
346
347     Node* n = deprecatedNode();
348     if (!n)
349         return *this;
350
351     int o = deprecatedEditingOffset();
352     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
353     ASSERT(o >= 0);
354
355     Node* child = n->childNode(o);
356     if (child || (!n->hasChildNodes() && o < lastOffsetForEditing(n))) {
357         if (child)
358             return firstPositionInOrBeforeNode(child);
359
360         // There are two reasons child might be 0:
361         //   1) The node is node like a text node that is not an element, and therefore has no children.
362         //      Going forward one character at a time is correct.
363         //   2) The new offset is a bogus offset like (<br>, 1), and there is no child.
364         //      Going from 0 to 1 is correct.
365         return createLegacyEditingPosition(n, (moveType == Character) ? uncheckedNextOffset(n, o) : o + 1);
366     }
367
368     ContainerNode* parent = findParent(n);
369     if (!parent)
370         return *this;
371
372     return createLegacyEditingPosition(parent, n->nodeIndex() + 1);
373 }
374
375 int Position::uncheckedPreviousOffset(const Node* n, int current)
376 {
377     return n->renderer() ? n->renderer()->previousOffset(current) : current - 1;
378 }
379
380 int Position::uncheckedPreviousOffsetForBackwardDeletion(const Node* n, int current)
381 {
382     return n->renderer() ? n->renderer()->previousOffsetForBackwardDeletion(current) : current - 1;
383 }
384
385 int Position::uncheckedNextOffset(const Node* n, int current)
386 {
387     return n->renderer() ? n->renderer()->nextOffset(current) : current + 1;
388 }
389
390 bool Position::atFirstEditingPositionForNode() const
391 {
392     if (isNull())
393         return true;
394     // FIXME: Position before anchor shouldn't be considered as at the first editing position for node
395     // since that position resides outside of the node.
396     switch (m_anchorType) {
397     case PositionIsOffsetInAnchor:
398         return m_offset <= 0;
399     case PositionIsBeforeChildren:
400     case PositionIsBeforeAnchor:
401         return true;
402     case PositionIsAfterChildren:
403     case PositionIsAfterAnchor:
404         return !lastOffsetForEditing(deprecatedNode());
405     }
406     ASSERT_NOT_REACHED();
407     return false;
408 }
409
410 bool Position::atLastEditingPositionForNode() const
411 {
412     if (isNull())
413         return true;
414     // FIXME: Position after anchor shouldn't be considered as at the first editing position for node
415     // since that position resides outside of the node.
416     return m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren || m_offset >= lastOffsetForEditing(deprecatedNode());
417 }
418
419 // A position is considered at editing boundary if one of the following is true:
420 // 1. It is the first position in the node and the next visually equivalent position
421 //    is non editable.
422 // 2. It is the last position in the node and the previous visually equivalent position
423 //    is non editable.
424 // 3. It is an editable position and both the next and previous visually equivalent
425 //    positions are both non editable.
426 bool Position::atEditingBoundary() const
427 {
428     Position nextPosition = downstream(CanCrossEditingBoundary);
429     if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.deprecatedNode()->rendererIsEditable())
430         return true;
431         
432     Position prevPosition = upstream(CanCrossEditingBoundary);
433     if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->rendererIsEditable())
434         return true;
435         
436     return nextPosition.isNotNull() && !nextPosition.deprecatedNode()->rendererIsEditable()
437         && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->rendererIsEditable();
438 }
439
440 Node* Position::parentEditingBoundary() const
441 {
442     if (!m_anchorNode || !m_anchorNode->document())
443         return 0;
444
445     Node* documentElement = m_anchorNode->document()->documentElement();
446     if (!documentElement)
447         return 0;
448
449     Node* boundary = m_anchorNode.get();
450     while (boundary != documentElement && boundary->nonShadowBoundaryParentNode() && m_anchorNode->rendererIsEditable() == boundary->parentNode()->rendererIsEditable())
451         boundary = boundary->nonShadowBoundaryParentNode();
452     
453     return boundary;
454 }
455
456
457 bool Position::atStartOfTree() const
458 {
459     if (isNull())
460         return true;
461     return !findParent(deprecatedNode()) && m_offset <= 0;
462 }
463
464 bool Position::atEndOfTree() const
465 {
466     if (isNull())
467         return true;
468     return !findParent(deprecatedNode()) && m_offset >= lastOffsetForEditing(deprecatedNode());
469 }
470
471 int Position::renderedOffset() const
472 {
473     if (!deprecatedNode()->isTextNode())
474         return m_offset;
475    
476     if (!deprecatedNode()->renderer())
477         return m_offset;
478                     
479     int result = 0;
480     RenderText* textRenderer = toRenderText(deprecatedNode()->renderer());
481     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
482         int start = box->start();
483         int end = box->start() + box->len();
484         if (m_offset < start)
485             return result;
486         if (m_offset <= end) {
487             result += m_offset - start;
488             return result;
489         }
490         result += box->len();
491     }
492     return result;
493 }
494
495 // return first preceding DOM position rendered at a different location, or "this"
496 Position Position::previousCharacterPosition(EAffinity affinity) const
497 {
498     if (isNull())
499         return Position();
500
501     Node* fromRootEditableElement = deprecatedNode()->rootEditableElement();
502
503     bool atStartOfLine = isStartOfLine(VisiblePosition(*this, affinity));
504     bool rendered = isCandidate();
505     
506     Position currentPos = *this;
507     while (!currentPos.atStartOfTree()) {
508         currentPos = currentPos.previous();
509
510         if (currentPos.deprecatedNode()->rootEditableElement() != fromRootEditableElement)
511             return *this;
512
513         if (atStartOfLine || !rendered) {
514             if (currentPos.isCandidate())
515                 return currentPos;
516         } else if (rendersInDifferentPosition(currentPos))
517             return currentPos;
518     }
519     
520     return *this;
521 }
522
523 // return first following position rendered at a different location, or "this"
524 Position Position::nextCharacterPosition(EAffinity affinity) const
525 {
526     if (isNull())
527         return Position();
528
529     Node* fromRootEditableElement = deprecatedNode()->rootEditableElement();
530
531     bool atEndOfLine = isEndOfLine(VisiblePosition(*this, affinity));
532     bool rendered = isCandidate();
533     
534     Position currentPos = *this;
535     while (!currentPos.atEndOfTree()) {
536         currentPos = currentPos.next();
537
538         if (currentPos.deprecatedNode()->rootEditableElement() != fromRootEditableElement)
539             return *this;
540
541         if (atEndOfLine || !rendered) {
542             if (currentPos.isCandidate())
543                 return currentPos;
544         } else if (rendersInDifferentPosition(currentPos))
545             return currentPos;
546     }
547     
548     return *this;
549 }
550
551 // Whether or not [node, 0] and [node, lastOffsetForEditing(node)] are their own VisiblePositions.
552 // If true, adjacent candidates are visually distinct.
553 // FIXME: Disregard nodes with renderers that have no height, as we do in isCandidate.
554 // FIXME: Share code with isCandidate, if possible.
555 static bool endsOfNodeAreVisuallyDistinctPositions(Node* node)
556 {
557     if (!node || !node->renderer())
558         return false;
559         
560     if (!node->renderer()->isInline())
561         return true;
562         
563     // Don't include inline tables.
564     if (node->hasTagName(tableTag))
565         return false;
566     
567     // There is a VisiblePosition inside an empty inline-block container.
568     return node->renderer()->isReplaced() && canHaveChildrenForEditing(node) && toRenderBox(node->renderer())->height() != 0 && !node->firstChild();
569 }
570
571 static Node* enclosingVisualBoundary(Node* node)
572 {
573     while (node && !endsOfNodeAreVisuallyDistinctPositions(node))
574         node = node->parentNode();
575         
576     return node;
577 }
578
579 // upstream() and downstream() want to return positions that are either in a
580 // text node or at just before a non-text node.  This method checks for that.
581 static bool isStreamer(const PositionIterator& pos)
582 {
583     if (!pos.node())
584         return true;
585         
586     if (isAtomicNode(pos.node()))
587         return true;
588         
589     return pos.atStartOfNode();
590 }
591
592 // This function and downstream() are used for moving back and forth between visually equivalent candidates.
593 // For example, for the text node "foo     bar" where whitespace is collapsible, there are two candidates 
594 // that map to the VisiblePosition between 'b' and the space.  This function will return the left candidate 
595 // and downstream() will return the right one.
596 // Also, upstream() will return [boundary, 0] for any of the positions from [boundary, 0] to the first candidate
597 // in boundary, where endsOfNodeAreVisuallyDistinctPositions(boundary) is true.
598 Position Position::upstream(EditingBoundaryCrossingRule rule) const
599 {
600     Node* startNode = deprecatedNode();
601     if (!startNode)
602         return Position();
603     
604     // iterate backward from there, looking for a qualified position
605     Node* boundary = enclosingVisualBoundary(startNode);
606     // FIXME: PositionIterator should respect Before and After positions.
607     PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : *this;
608     PositionIterator currentPos = lastVisible;
609     bool startEditable = startNode->rendererIsEditable();
610     Node* lastNode = startNode;
611     bool boundaryCrossed = false;
612     for (; !currentPos.atStart(); currentPos.decrement()) {
613         Node* currentNode = currentPos.node();
614         
615         // Don't check for an editability change if we haven't moved to a different node,
616         // to avoid the expense of computing rendererIsEditable().
617         if (currentNode != lastNode) {
618             // Don't change editability.
619             bool currentEditable = currentNode->rendererIsEditable();
620             if (startEditable != currentEditable) {
621                 if (rule == CannotCrossEditingBoundary)
622                     break;
623                 boundaryCrossed = true;
624             }
625             lastNode = currentNode;
626         }
627
628         // If we've moved to a position that is visually distinct, return the last saved position. There 
629         // is code below that terminates early if we're *about* to move to a visually distinct position.
630         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
631             return lastVisible;
632
633         // skip position in unrendered or invisible node
634         RenderObject* renderer = currentNode->renderer();
635         if (!renderer || renderer->style()->visibility() != VISIBLE)
636             continue;
637                  
638         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
639             lastVisible = currentPos;
640             break;
641         }
642         
643         // track last visible streamer position
644         if (isStreamer(currentPos))
645             lastVisible = currentPos;
646         
647         // Don't move past a position that is visually distinct.  We could rely on code above to terminate and 
648         // return lastVisible on the next iteration, but we terminate early to avoid doing a nodeIndex() call.
649         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentPos.atStartOfNode())
650             return lastVisible;
651
652         // Return position after tables and nodes which have content that can be ignored.
653         if (editingIgnoresContent(currentNode) || isTableElement(currentNode)) {
654             if (currentPos.atEndOfNode())
655                 return positionAfterNode(currentNode);
656             continue;
657         }
658
659         // return current position if it is in rendered text
660         if (renderer->isText() && toRenderText(renderer)->firstTextBox()) {
661             if (currentNode != startNode) {
662                 // This assertion fires in layout tests in the case-transform.html test because
663                 // of a mix-up between offsets in the text in the DOM tree with text in the
664                 // render tree which can have a different length due to case transformation.
665                 // Until we resolve that, disable this so we can run the layout tests!
666                 //ASSERT(currentOffset >= renderer->caretMaxOffset());
667                 return createLegacyEditingPosition(currentNode, renderer->caretMaxOffset());
668             }
669
670             unsigned textOffset = currentPos.offsetInLeafNode();
671             RenderText* textRenderer = toRenderText(renderer);
672             InlineTextBox* lastTextBox = textRenderer->lastTextBox();
673             for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
674                 if (textOffset <= box->start() + box->len()) {
675                     if (textOffset > box->start())
676                         return currentPos;
677                     continue;
678                 }
679
680                 if (box == lastTextBox || textOffset != box->start() + box->len() + 1)
681                     continue;
682
683                 // The text continues on the next line only if the last text box is not on this line and
684                 // none of the boxes on this line have a larger start offset.
685
686                 bool continuesOnNextLine = true;
687                 InlineBox* otherBox = box;
688                 while (continuesOnNextLine) {
689                     otherBox = otherBox->nextLeafChild();
690                     if (!otherBox)
691                         break;
692                     if (otherBox == lastTextBox || (otherBox->renderer() == textRenderer && static_cast<InlineTextBox*>(otherBox)->start() > textOffset))
693                         continuesOnNextLine = false;
694                 }
695
696                 otherBox = box;
697                 while (continuesOnNextLine) {
698                     otherBox = otherBox->prevLeafChild();
699                     if (!otherBox)
700                         break;
701                     if (otherBox == lastTextBox || (otherBox->renderer() == textRenderer && static_cast<InlineTextBox*>(otherBox)->start() > textOffset))
702                         continuesOnNextLine = false;
703                 }
704
705                 if (continuesOnNextLine)
706                     return currentPos;
707             }
708         }
709     }
710
711     return lastVisible;
712 }
713
714 // This function and upstream() are used for moving back and forth between visually equivalent candidates.
715 // For example, for the text node "foo     bar" where whitespace is collapsible, there are two candidates 
716 // that map to the VisiblePosition between 'b' and the space.  This function will return the right candidate 
717 // and upstream() will return the left one.
718 // Also, downstream() will return the last position in the last atomic node in boundary for all of the positions
719 // in boundary after the last candidate, where endsOfNodeAreVisuallyDistinctPositions(boundary).
720 // FIXME: This function should never be called when the line box tree is dirty. See https://bugs.webkit.org/show_bug.cgi?id=97264
721 Position Position::downstream(EditingBoundaryCrossingRule rule) const
722 {
723     Node* startNode = deprecatedNode();
724     if (!startNode)
725         return Position();
726
727     // iterate forward from there, looking for a qualified position
728     Node* boundary = enclosingVisualBoundary(startNode);
729     // FIXME: PositionIterator should respect Before and After positions.
730     PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : *this;
731     PositionIterator currentPos = lastVisible;
732     bool startEditable = startNode->rendererIsEditable();
733     Node* lastNode = startNode;
734     bool boundaryCrossed = false;
735     for (; !currentPos.atEnd(); currentPos.increment()) {   
736         Node* currentNode = currentPos.node();
737         
738         // Don't check for an editability change if we haven't moved to a different node,
739         // to avoid the expense of computing rendererIsEditable().
740         if (currentNode != lastNode) {
741             // Don't change editability.
742             bool currentEditable = currentNode->rendererIsEditable();
743             if (startEditable != currentEditable) {
744                 if (rule == CannotCrossEditingBoundary)
745                     break;
746                 boundaryCrossed = true;
747             }
748                 
749             lastNode = currentNode;
750         }
751
752         // stop before going above the body, up into the head
753         // return the last visible streamer position
754         if (currentNode->hasTagName(bodyTag) && currentPos.atEndOfNode())
755             break;
756             
757         // Do not move to a visually distinct position.
758         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
759             return lastVisible;
760         // Do not move past a visually disinct position.
761         // Note: The first position after the last in a node whose ends are visually distinct
762         // positions will be [boundary->parentNode(), originalBlock->nodeIndex() + 1].
763         if (boundary && boundary->parentNode() == currentNode)
764             return lastVisible;
765
766         // skip position in unrendered or invisible node
767         RenderObject* renderer = currentNode->renderer();
768         if (!renderer || renderer->style()->visibility() != VISIBLE)
769             continue;
770             
771         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
772             lastVisible = currentPos;
773             break;
774         }
775         
776         // track last visible streamer position
777         if (isStreamer(currentPos))
778             lastVisible = currentPos;
779
780         // Return position before tables and nodes which have content that can be ignored.
781         if (editingIgnoresContent(currentNode) || isTableElement(currentNode)) {
782             if (currentPos.offsetInLeafNode() <= renderer->caretMinOffset())
783                 return createLegacyEditingPosition(currentNode, renderer->caretMinOffset());
784             continue;
785         }
786
787         // return current position if it is in rendered text
788         if (renderer->isText() && toRenderText(renderer)->firstTextBox()) {
789             if (currentNode != startNode) {
790                 ASSERT(currentPos.atStartOfNode());
791                 return createLegacyEditingPosition(currentNode, renderer->caretMinOffset());
792             }
793
794             unsigned textOffset = currentPos.offsetInLeafNode();
795             RenderText* textRenderer = toRenderText(renderer);
796             InlineTextBox* lastTextBox = textRenderer->lastTextBox();
797             for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
798                 if (textOffset <= box->end()) {
799                     if (textOffset >= box->start())
800                         return currentPos;
801                     continue;
802                 }
803
804                 if (box == lastTextBox || textOffset != box->start() + box->len())
805                     continue;
806
807                 // The text continues on the next line only if the last text box is not on this line and
808                 // none of the boxes on this line have a larger start offset.
809
810                 bool continuesOnNextLine = true;
811                 InlineBox* otherBox = box;
812                 while (continuesOnNextLine) {
813                     otherBox = otherBox->nextLeafChild();
814                     if (!otherBox)
815                         break;
816                     if (otherBox == lastTextBox || (otherBox->renderer() == textRenderer && static_cast<InlineTextBox*>(otherBox)->start() >= textOffset))
817                         continuesOnNextLine = false;
818                 }
819
820                 otherBox = box;
821                 while (continuesOnNextLine) {
822                     otherBox = otherBox->prevLeafChild();
823                     if (!otherBox)
824                         break;
825                     if (otherBox == lastTextBox || (otherBox->renderer() == textRenderer && static_cast<InlineTextBox*>(otherBox)->start() >= textOffset))
826                         continuesOnNextLine = false;
827                 }
828
829                 if (continuesOnNextLine)
830                     return currentPos;
831             }
832         }
833     }
834     
835     return lastVisible;
836 }
837
838 static int boundingBoxLogicalHeight(RenderObject *o, const IntRect &rect)
839 {
840     return o->style()->isHorizontalWritingMode() ? rect.height() : rect.width();
841 }
842
843 bool Position::hasRenderedNonAnonymousDescendantsWithHeight(RenderObject* renderer)
844 {
845     RenderObject* stop = renderer->nextInPreOrderAfterChildren();
846     for (RenderObject *o = renderer->firstChild(); o && o != stop; o = o->nextInPreOrder())
847         if (o->nonPseudoNode()) {
848             if ((o->isText() && boundingBoxLogicalHeight(o, toRenderText(o)->linesBoundingBox()))
849                 || (o->isBox() && toRenderBox(o)->pixelSnappedLogicalHeight())
850                 || (o->isRenderInline() && isEmptyInline(o) && boundingBoxLogicalHeight(o, toRenderInline(o)->linesBoundingBox())))
851                 return true;
852         }
853     return false;
854 }
855
856 bool Position::nodeIsUserSelectNone(Node* node)
857 {
858     return node && node->renderer() && node->renderer()->style()->userSelect() == SELECT_NONE;
859 }
860
861 ContainerNode* Position::findParent(const Node* node)
862 {
863     // FIXME: See http://web.ug/82697
864
865 #if ENABLE(SHADOW_DOM)
866     if (RuntimeEnabledFeatures::shadowDOMEnabled())
867         return node->parentNode();
868 #endif
869
870     return node->nonShadowBoundaryParentNode();
871 }
872
873 #if ENABLE(USERSELECT_ALL)
874 bool Position::nodeIsUserSelectAll(const Node* node)
875 {
876     return node && node->renderer() && node->renderer()->style()->userSelect() == SELECT_ALL;
877 }
878
879 Node* Position::rootUserSelectAllForNode(Node* node)
880 {
881     if (!node || !nodeIsUserSelectAll(node))
882         return 0;
883     Node* parent = node->parentNode();
884     if (!parent)
885         return node;
886
887     Node* candidateRoot = node;
888     while (parent) {
889         if (!parent->renderer()) {
890             parent = parent->parentNode();
891             continue;
892         }
893         if (!nodeIsUserSelectAll(parent))
894             break;
895         candidateRoot = parent;
896         parent = candidateRoot->parentNode();
897     }
898     return candidateRoot;
899 }
900 #endif
901
902 bool Position::isCandidate() const
903 {
904     if (isNull())
905         return false;
906         
907     RenderObject* renderer = deprecatedNode()->renderer();
908     if (!renderer)
909         return false;
910     
911     if (renderer->style()->visibility() != VISIBLE)
912         return false;
913
914     if (renderer->isBR())
915         // FIXME: The condition should be m_anchorType == PositionIsBeforeAnchor, but for now we still need to support legacy positions.
916         return !m_offset && m_anchorType != PositionIsAfterAnchor && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
917
918     if (renderer->isText())
919         return !nodeIsUserSelectNone(deprecatedNode()) && inRenderedText();
920
921     if (isTableElement(deprecatedNode()) || editingIgnoresContent(deprecatedNode()))
922         return (atFirstEditingPositionForNode() || atLastEditingPositionForNode()) && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
923
924     if (m_anchorNode->hasTagName(htmlTag))
925         return false;
926         
927     if (renderer->isBlockFlow()) {
928         if (toRenderBlock(renderer)->logicalHeight() || m_anchorNode->hasTagName(bodyTag)) {
929             if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(renderer))
930                 return atFirstEditingPositionForNode() && !Position::nodeIsUserSelectNone(deprecatedNode());
931             return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
932         }
933     } else
934         return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
935
936     return false;
937 }
938
939 bool Position::inRenderedText() const
940 {
941     if (isNull() || !deprecatedNode()->isTextNode())
942         return false;
943         
944     RenderObject* renderer = deprecatedNode()->renderer();
945     if (!renderer)
946         return false;
947     
948     RenderText *textRenderer = toRenderText(renderer);
949     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
950         if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
951             // The offset we're looking for is before this node
952             // this means the offset must be in content that is
953             // not rendered. Return false.
954             return false;
955         }
956         if (box->containsCaretOffset(m_offset))
957             // Return false for offsets inside composed characters.
958             return m_offset == 0 || m_offset == textRenderer->nextOffset(textRenderer->previousOffset(m_offset));
959     }
960     
961     return false;
962 }
963
964 bool Position::isRenderedCharacter() const
965 {
966     if (isNull() || !deprecatedNode()->isTextNode())
967         return false;
968         
969     RenderObject* renderer = deprecatedNode()->renderer();
970     if (!renderer)
971         return false;
972     
973     RenderText* textRenderer = toRenderText(renderer);
974     for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
975         if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
976             // The offset we're looking for is before this node
977             // this means the offset must be in content that is
978             // not rendered. Return false.
979             return false;
980         }
981         if (m_offset >= static_cast<int>(box->start()) && m_offset < static_cast<int>(box->start() + box->len()))
982             return true;
983     }
984     
985     return false;
986 }
987
988 static bool inSameEnclosingBlockFlowElement(Node* a, Node* b)
989 {
990     return a && b && deprecatedEnclosingBlockFlowElement(a) == deprecatedEnclosingBlockFlowElement(b);
991 }
992
993 bool Position::rendersInDifferentPosition(const Position &pos) const
994 {
995     if (isNull() || pos.isNull())
996         return false;
997
998     RenderObject* renderer = deprecatedNode()->renderer();
999     if (!renderer)
1000         return false;
1001     
1002     RenderObject* posRenderer = pos.deprecatedNode()->renderer();
1003     if (!posRenderer)
1004         return false;
1005
1006     if (renderer->style()->visibility() != VISIBLE ||
1007         posRenderer->style()->visibility() != VISIBLE)
1008         return false;
1009     
1010     if (deprecatedNode() == pos.deprecatedNode()) {
1011         if (deprecatedNode()->hasTagName(brTag))
1012             return false;
1013
1014         if (m_offset == pos.deprecatedEditingOffset())
1015             return false;
1016             
1017         if (!deprecatedNode()->isTextNode() && !pos.deprecatedNode()->isTextNode()) {
1018             if (m_offset != pos.deprecatedEditingOffset())
1019                 return true;
1020         }
1021     }
1022     
1023     if (deprecatedNode()->hasTagName(brTag) && pos.isCandidate())
1024         return true;
1025                 
1026     if (pos.deprecatedNode()->hasTagName(brTag) && isCandidate())
1027         return true;
1028                 
1029     if (!inSameEnclosingBlockFlowElement(deprecatedNode(), pos.deprecatedNode()))
1030         return true;
1031
1032     if (deprecatedNode()->isTextNode() && !inRenderedText())
1033         return false;
1034
1035     if (pos.deprecatedNode()->isTextNode() && !pos.inRenderedText())
1036         return false;
1037
1038     int thisRenderedOffset = renderedOffset();
1039     int posRenderedOffset = pos.renderedOffset();
1040
1041     if (renderer == posRenderer && thisRenderedOffset == posRenderedOffset)
1042         return false;
1043
1044     int ignoredCaretOffset;
1045     InlineBox* b1;
1046     getInlineBoxAndOffset(DOWNSTREAM, b1, ignoredCaretOffset);
1047     InlineBox* b2;
1048     pos.getInlineBoxAndOffset(DOWNSTREAM, b2, ignoredCaretOffset);
1049
1050     LOG(Editing, "renderer:               %p [%p]\n", renderer, b1);
1051     LOG(Editing, "thisRenderedOffset:         %d\n", thisRenderedOffset);
1052     LOG(Editing, "posRenderer:            %p [%p]\n", posRenderer, b2);
1053     LOG(Editing, "posRenderedOffset:      %d\n", posRenderedOffset);
1054     LOG(Editing, "node min/max:           %d:%d\n", caretMinOffset(deprecatedNode()), caretMaxOffset(deprecatedNode()));
1055     LOG(Editing, "pos node min/max:       %d:%d\n", caretMinOffset(pos.deprecatedNode()), caretMaxOffset(pos.deprecatedNode()));
1056     LOG(Editing, "----------------------------------------------------------------------\n");
1057
1058     if (!b1 || !b2) {
1059         return false;
1060     }
1061
1062     if (b1->root() != b2->root()) {
1063         return true;
1064     }
1065
1066     if (nextRenderedEditable(deprecatedNode()) == pos.deprecatedNode()
1067         && thisRenderedOffset == caretMaxOffset(deprecatedNode()) && !posRenderedOffset) {
1068         return false;
1069     }
1070     
1071     if (previousRenderedEditable(deprecatedNode()) == pos.deprecatedNode()
1072         && !thisRenderedOffset && posRenderedOffset == caretMaxOffset(pos.deprecatedNode())) {
1073         return false;
1074     }
1075
1076     return true;
1077 }
1078
1079 // This assumes that it starts in editable content.
1080 Position Position::leadingWhitespacePosition(EAffinity affinity, bool considerNonCollapsibleWhitespace) const
1081 {
1082     ASSERT(isEditablePosition(*this));
1083     if (isNull())
1084         return Position();
1085     
1086     if (upstream().deprecatedNode()->hasTagName(brTag))
1087         return Position();
1088
1089     Position prev = previousCharacterPosition(affinity);
1090     if (prev != *this && inSameEnclosingBlockFlowElement(deprecatedNode(), prev.deprecatedNode()) && prev.deprecatedNode()->isTextNode()) {
1091         String string = toText(prev.deprecatedNode())->data();
1092         UChar c = string[prev.deprecatedEditingOffset()];
1093         if (considerNonCollapsibleWhitespace ? (isSpaceOrNewline(c) || c == noBreakSpace) : isCollapsibleWhitespace(c))
1094             if (isEditablePosition(prev))
1095                 return prev;
1096     }
1097
1098     return Position();
1099 }
1100
1101 // This assumes that it starts in editable content.
1102 Position Position::trailingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace) const
1103 {
1104     ASSERT(isEditablePosition(*this));
1105     if (isNull())
1106         return Position();
1107     
1108     VisiblePosition v(*this);
1109     UChar c = v.characterAfter();
1110     // The space must not be in another paragraph and it must be editable.
1111     if (!isEndOfParagraph(v) && v.next(CannotCrossEditingBoundary).isNotNull())
1112         if (considerNonCollapsibleWhitespace ? (isSpaceOrNewline(c) || c == noBreakSpace) : isCollapsibleWhitespace(c))
1113             return *this;
1114     
1115     return Position();
1116 }
1117
1118 void Position::getInlineBoxAndOffset(EAffinity affinity, InlineBox*& inlineBox, int& caretOffset) const
1119 {
1120     getInlineBoxAndOffset(affinity, primaryDirection(), inlineBox, caretOffset);
1121 }
1122
1123 static bool isNonTextLeafChild(RenderObject* object)
1124 {
1125     if (object->firstChild())
1126         return false;
1127     if (object->isText())
1128         return false;
1129     return true;
1130 }
1131
1132 static InlineTextBox* searchAheadForBetterMatch(RenderObject* renderer)
1133 {
1134     RenderBlock* container = renderer->containingBlock();
1135     RenderObject* next = renderer;
1136     while ((next = next->nextInPreOrder(container))) {
1137         if (next->isRenderBlock())
1138             return 0;
1139         if (next->isBR())
1140             return 0;
1141         if (isNonTextLeafChild(next))
1142             return 0;
1143         if (next->isText()) {
1144             InlineTextBox* match = 0;
1145             int minOffset = INT_MAX;
1146             for (InlineTextBox* box = toRenderText(next)->firstTextBox(); box; box = box->nextTextBox()) {
1147                 int caretMinOffset = box->caretMinOffset();
1148                 if (caretMinOffset < minOffset) {
1149                     match = box;
1150                     minOffset = caretMinOffset;
1151                 }
1152             }
1153             if (match)
1154                 return match;
1155         }
1156     }
1157     return 0;
1158 }
1159
1160 static Position downstreamIgnoringEditingBoundaries(Position position)
1161 {
1162     Position lastPosition;
1163     while (position != lastPosition) {
1164         lastPosition = position;
1165         position = position.downstream(CanCrossEditingBoundary);
1166     }
1167     return position;
1168 }
1169
1170 static Position upstreamIgnoringEditingBoundaries(Position position)
1171 {
1172     Position lastPosition;
1173     while (position != lastPosition) {
1174         lastPosition = position;
1175         position = position.upstream(CanCrossEditingBoundary);
1176     }
1177     return position;
1178 }
1179
1180 void Position::getInlineBoxAndOffset(EAffinity affinity, TextDirection primaryDirection, InlineBox*& inlineBox, int& caretOffset) const
1181 {
1182     caretOffset = deprecatedEditingOffset();
1183     RenderObject* renderer = deprecatedNode()->renderer();
1184
1185     if (!renderer->isText()) {
1186         inlineBox = 0;
1187         if (canHaveChildrenForEditing(deprecatedNode()) && renderer->isBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(renderer)) {
1188             // Try a visually equivalent position with possibly opposite editability. This helps in case |this| is in
1189             // an editable block but surrounded by non-editable positions. It acts to negate the logic at the beginning
1190             // of RenderObject::createVisiblePosition().
1191             Position equivalent = downstreamIgnoringEditingBoundaries(*this);
1192             if (equivalent == *this) {
1193                 equivalent = upstreamIgnoringEditingBoundaries(*this);
1194                 if (equivalent == *this || downstreamIgnoringEditingBoundaries(equivalent) == *this)
1195                     return;
1196             }
1197
1198             equivalent.getInlineBoxAndOffset(UPSTREAM, primaryDirection, inlineBox, caretOffset);
1199             return;
1200         }
1201         if (renderer->isBox()) {
1202             inlineBox = toRenderBox(renderer)->inlineBoxWrapper();
1203             if (!inlineBox || (caretOffset > inlineBox->caretMinOffset() && caretOffset < inlineBox->caretMaxOffset()))
1204                 return;
1205         }
1206     } else {
1207         RenderText* textRenderer = toRenderText(renderer);
1208
1209         InlineTextBox* box;
1210         InlineTextBox* candidate = 0;
1211
1212         for (box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
1213             int caretMinOffset = box->caretMinOffset();
1214             int caretMaxOffset = box->caretMaxOffset();
1215
1216             if (caretOffset < caretMinOffset || caretOffset > caretMaxOffset || (caretOffset == caretMaxOffset && box->isLineBreak()))
1217                 continue;
1218
1219             if (caretOffset > caretMinOffset && caretOffset < caretMaxOffset) {
1220                 inlineBox = box;
1221                 return;
1222             }
1223
1224             if (((caretOffset == caretMaxOffset) ^ (affinity == DOWNSTREAM))
1225                 || ((caretOffset == caretMinOffset) ^ (affinity == UPSTREAM))
1226                 || (caretOffset == caretMaxOffset && box->nextLeafChild() && box->nextLeafChild()->isLineBreak()))
1227                 break;
1228
1229             candidate = box;
1230         }
1231         if (candidate && candidate == textRenderer->lastTextBox() && affinity == DOWNSTREAM) {
1232             box = searchAheadForBetterMatch(textRenderer);
1233             if (box)
1234                 caretOffset = box->caretMinOffset();
1235         }
1236         inlineBox = box ? box : candidate;
1237     }
1238
1239     if (!inlineBox)
1240         return;
1241
1242     unsigned char level = inlineBox->bidiLevel();
1243
1244     if (inlineBox->direction() == primaryDirection) {
1245         if (caretOffset == inlineBox->caretRightmostOffset()) {
1246             InlineBox* nextBox = inlineBox->nextLeafChild();
1247             if (!nextBox || nextBox->bidiLevel() >= level)
1248                 return;
1249
1250             level = nextBox->bidiLevel();
1251             InlineBox* prevBox = inlineBox;
1252             do {
1253                 prevBox = prevBox->prevLeafChild();
1254             } while (prevBox && prevBox->bidiLevel() > level);
1255
1256             if (prevBox && prevBox->bidiLevel() == level)   // For example, abc FED 123 ^ CBA
1257                 return;
1258
1259             // For example, abc 123 ^ CBA
1260             while (InlineBox* nextBox = inlineBox->nextLeafChild()) {
1261                 if (nextBox->bidiLevel() < level)
1262                     break;
1263                 inlineBox = nextBox;
1264             }
1265             caretOffset = inlineBox->caretRightmostOffset();
1266         } else {
1267             InlineBox* prevBox = inlineBox->prevLeafChild();
1268             if (!prevBox || prevBox->bidiLevel() >= level)
1269                 return;
1270
1271             level = prevBox->bidiLevel();
1272             InlineBox* nextBox = inlineBox;
1273             do {
1274                 nextBox = nextBox->nextLeafChild();
1275             } while (nextBox && nextBox->bidiLevel() > level);
1276
1277             if (nextBox && nextBox->bidiLevel() == level)
1278                 return;
1279
1280             while (InlineBox* prevBox = inlineBox->prevLeafChild()) {
1281                 if (prevBox->bidiLevel() < level)
1282                     break;
1283                 inlineBox = prevBox;
1284             }
1285             caretOffset = inlineBox->caretLeftmostOffset();
1286         }
1287         return;
1288     }
1289
1290     if (caretOffset == inlineBox->caretLeftmostOffset()) {
1291         InlineBox* prevBox = inlineBox->prevLeafChildIgnoringLineBreak();
1292         if (!prevBox || prevBox->bidiLevel() < level) {
1293             // Left edge of a secondary run. Set to the right edge of the entire run.
1294             while (InlineBox* nextBox = inlineBox->nextLeafChildIgnoringLineBreak()) {
1295                 if (nextBox->bidiLevel() < level)
1296                     break;
1297                 inlineBox = nextBox;
1298             }
1299             caretOffset = inlineBox->caretRightmostOffset();
1300         } else if (prevBox->bidiLevel() > level) {
1301             // Right edge of a "tertiary" run. Set to the left edge of that run.
1302             while (InlineBox* tertiaryBox = inlineBox->prevLeafChildIgnoringLineBreak()) {
1303                 if (tertiaryBox->bidiLevel() <= level)
1304                     break;
1305                 inlineBox = tertiaryBox;
1306             }
1307             caretOffset = inlineBox->caretLeftmostOffset();
1308         }
1309     } else {
1310         InlineBox* nextBox = inlineBox->nextLeafChildIgnoringLineBreak();
1311         if (!nextBox || nextBox->bidiLevel() < level) {
1312             // Right edge of a secondary run. Set to the left edge of the entire run.
1313             while (InlineBox* prevBox = inlineBox->prevLeafChildIgnoringLineBreak()) {
1314                 if (prevBox->bidiLevel() < level)
1315                     break;
1316                 inlineBox = prevBox;
1317             }
1318             caretOffset = inlineBox->caretLeftmostOffset();
1319         } else if (nextBox->bidiLevel() > level) {
1320             // Left edge of a "tertiary" run. Set to the right edge of that run.
1321             while (InlineBox* tertiaryBox = inlineBox->nextLeafChildIgnoringLineBreak()) {
1322                 if (tertiaryBox->bidiLevel() <= level)
1323                     break;
1324                 inlineBox = tertiaryBox;
1325             }
1326             caretOffset = inlineBox->caretRightmostOffset();
1327         }
1328     }
1329 }
1330
1331 TextDirection Position::primaryDirection() const
1332 {
1333     TextDirection primaryDirection = LTR;
1334     for (const RenderObject* r = m_anchorNode->renderer(); r; r = r->parent()) {
1335         if (r->isBlockFlow()) {
1336             primaryDirection = r->style()->direction();
1337             break;
1338         }
1339     }
1340
1341     return primaryDirection;
1342 }
1343
1344
1345 void Position::debugPosition(const char* msg) const
1346 {
1347     if (isNull())
1348         fprintf(stderr, "Position [%s]: null\n", msg);
1349     else
1350         fprintf(stderr, "Position [%s]: %s [%p] at %d\n", msg, deprecatedNode()->nodeName().utf8().data(), deprecatedNode(), m_offset);
1351 }
1352
1353 #ifndef NDEBUG
1354
1355 void Position::formatForDebugger(char* buffer, unsigned length) const
1356 {
1357     StringBuilder result;
1358
1359     if (isNull())
1360         result.appendLiteral("<null>");
1361     else {
1362         char s[1024];
1363         result.appendLiteral("offset ");
1364         result.appendNumber(m_offset);
1365         result.appendLiteral(" of ");
1366         deprecatedNode()->formatForDebugger(s, sizeof(s));
1367         result.append(s);
1368     }
1369
1370     strncpy(buffer, result.toString().utf8().data(), length - 1);
1371 }
1372
1373 void Position::showAnchorTypeAndOffset() const
1374 {
1375     if (m_isLegacyEditingPosition)
1376         fputs("legacy, ", stderr);
1377     switch (anchorType()) {
1378     case PositionIsOffsetInAnchor:
1379         fputs("offset", stderr);
1380         break;
1381     case PositionIsBeforeChildren:
1382         fputs("beforeChildren", stderr);
1383         break;
1384     case PositionIsAfterChildren:
1385         fputs("afterChildren", stderr);
1386         break;
1387     case PositionIsBeforeAnchor:
1388         fputs("before", stderr);
1389         break;
1390     case PositionIsAfterAnchor:
1391         fputs("after", stderr);
1392         break;
1393     }
1394     fprintf(stderr, ", offset:%d\n", m_offset);
1395 }
1396
1397 void Position::showTreeForThis() const
1398 {
1399     if (anchorNode()) {
1400         anchorNode()->showTreeForThis();
1401         showAnchorTypeAndOffset();
1402     }
1403 }
1404
1405 #endif
1406
1407
1408
1409 } // namespace WebCore
1410
1411 #ifndef NDEBUG
1412
1413 void showTree(const WebCore::Position& pos)
1414 {
1415     pos.showTreeForThis();
1416 }
1417
1418 void showTree(const WebCore::Position* pos)
1419 {
1420     if (pos)
1421         pos->showTreeForThis();
1422 }
1423
1424 #endif