Merge 84919 - 2011-04-26 Ryosuke Niwa <rniwa@webkit.org>

Source/WebCore/editing/VisiblePosition.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 15 matching lines @@
 #include "config.h"
 #include "VisiblePosition.h"
 
 #include "Document.h"
 #include "FloatQuad.h"
 #include "HTMLElement.h"
 #include "HTMLNames.h"
 #include "InlineTextBox.h"
 #include "Logging.h"
 #include "Range.h"
+#include "RootInlineBox.h"
 #include "Text.h"
 #include "htmlediting.h"
 #include "visible_units.h"
 #include <stdio.h>
 #include <wtf/text/CString.h>
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
@@ skipping 81 matching lines @@
 
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (offset > caretMinOffset && offset < caretMaxOffset)
                 break;
 
             if (box->isLeftToRightDirection() ? offset < caretMinOffset : offset > caretMaxOffset) {
                 // Overshot to the left.
                 InlineBox* prevBox = box->prevLeafChild();
-                if (!prevBox)
-                    return primaryDirection == LTR ? previousVisuallyDistinctCandidate(m_deepPosition) : nextVisuallyDistinctCandidate(m_deepPosition);
+                if (!prevBox) {
+                    Position positionOnLeft = primaryDirection == LTR ? previousVisuallyDistinctCandidate(m_deepPosition) : nextVisuallyDistinctCandidate(m_deepPosition);
+                    if (positionOnLeft.isNull())
+                        return Position();
+
+                    InlineBox* boxOnLeft;
+                    int offsetOnLeft;
+                    positionOnLeft.getInlineBoxAndOffset(m_affinity, primaryDirection, boxOnLeft, offsetOnLeft);
+                    if (boxOnLeft && boxOnLeft->root() == box->root())
+                        return Position();
+                    return positionOnLeft;
+                }
 
                 // Reposition at the other logical position corresponding to our edge's visual position and go for another round.
                 box = prevBox;
                 renderer = box->renderer();
                 offset = prevBox->caretRightmostOffset();
                 continue;
             }
 
             ASSERT(offset == box->caretLeftmostOffset());
 
             unsigned char level = box->bidiLevel();
             InlineBox* prevBox = box->prevLeafChild();
 
             if (box->direction() == primaryDirection) {
-                if (!prevBox || prevBox->bidiLevel() >= level)
+                if (!prevBox) {
+                    InlineBox* logicalStart = 0;
+                    if (primaryDirection == LTR ? box->root()->getLogicalStartBoxWithNode(logicalStart) : box->root()->getLogicalEndBoxWithNode(logicalStart)) {
+                        box = logicalStart;
+                        renderer = box->renderer();
+                        offset = primaryDirection == LTR ? box->caretMinOffset() : box->caretMaxOffset();
+                    }
+                    break;
+                }
+                if (prevBox->bidiLevel() >= level)
                     break;
 
                 level = prevBox->bidiLevel();
 
                 InlineBox* nextBox = box;
                 do {
                     nextBox = nextBox->nextLeafChild();
                 } while (nextBox && nextBox->bidiLevel() > level);
 
                 if (nextBox && nextBox->bidiLevel() == level)
                     break;
 
-                while (InlineBox* prevBox = box->prevLeafChild()) {
-                    if (prevBox->bidiLevel() < level)
-                        break;
-                    box = prevBox;
-                }
+                box = prevBox;
                 renderer = box->renderer();
                 offset = box->caretRightmostOffset();
                 if (box->direction() == primaryDirection)
                     break;
                 continue;
             }
 
             if (prevBox) {
                 box = prevBox;
                 renderer = box->renderer();
@@ skipping 82 matching lines @@
 
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (offset > caretMinOffset && offset < caretMaxOffset)
                 break;
 
             if (box->isLeftToRightDirection() ? offset > caretMaxOffset : offset < caretMinOffset) {
                 // Overshot to the right.
                 InlineBox* nextBox = box->nextLeafChild();
-                if (!nextBox)
-                    return primaryDirection == LTR ? nextVisuallyDistinctCandidate(m_deepPosition) : previousVisuallyDistinctCandidate(m_deepPosition);
+                if (!nextBox) {
+                    Position positionOnRight = primaryDirection == LTR ? nextVisuallyDistinctCandidate(m_deepPosition) : previousVisuallyDistinctCandidate(m_deepPosition);
+                    if (positionOnRight.isNull())
+                        return Position();
+
+                    InlineBox* boxOnRight;
+                    int offsetOnRight;
+                    positionOnRight.getInlineBoxAndOffset(m_affinity, primaryDirection, boxOnRight, offsetOnRight);
+                    if (boxOnRight && boxOnRight->root() == box->root())
+                        return Position();
+                    return positionOnRight;
+                }
 
                 // Reposition at the other logical position corresponding to our edge's visual position and go for another round.
                 box = nextBox;
                 renderer = box->renderer();
                 offset = nextBox->caretLeftmostOffset();
                 continue;
             }
 
             ASSERT(offset == box->caretRightmostOffset());
 
             unsigned char level = box->bidiLevel();
             InlineBox* nextBox = box->nextLeafChild();
 
             if (box->direction() == primaryDirection) {
-                if (!nextBox || nextBox->bidiLevel() >= level)
+                if (!nextBox) {
+                    InlineBox* logicalEnd = 0;
+                    if (primaryDirection == LTR ? box->root()->getLogicalEndBoxWithNode(logicalEnd) : box->root()->getLogicalStartBoxWithNode(logicalEnd)) {
+                        box = logicalEnd;
+                        renderer = box->renderer();
+                        offset = primaryDirection == LTR ? box->caretMaxOffset() : box->caretMinOffset();
+                    }
+                    break;
+                }
+                if (nextBox->bidiLevel() >= level)
                     break;
 
                 level = nextBox->bidiLevel();
 
                 InlineBox* prevBox = box;
                 do {
                     prevBox = prevBox->prevLeafChild();
                 } while (prevBox && prevBox->bidiLevel() > level);
 
                 if (prevBox && prevBox->bidiLevel() == level)   // For example, abc FED 123 ^ CBA
                     break;
 
-                // For example, abc 123 ^ CBA
-                while (InlineBox* nextBox = box->nextLeafChild()) {
-                    if (nextBox->bidiLevel() < level)
-                        break;
-                    box = nextBox;
-                }
+                // For example, abc 123 ^ CBA or 123 ^ CBA abc
+                box = nextBox;
                 renderer = box->renderer();
                 offset = box->caretLeftmostOffset();
                 if (box->direction() == primaryDirection)
                     break;
                 continue;
             }
 
             if (nextBox) {
                 box = nextBox;
                 renderer = box->renderer();
@@ skipping 359 matching lines @@
     if (vpos)
         vpos->showTreeForThis();
 }
 
 void showTree(const WebCore::VisiblePosition& vpos)
 {
     vpos.showTreeForThis();
 }
 
 #endif