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