Mixing content editable and non-editable in direction RTL

Source/core/editing/VisibleUnits.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 333 matching lines @@
 }
 
 enum CursorMovementDirection { MoveLeft, MoveRight };
 
 static VisiblePosition visualWordPosition(const VisiblePosition& visiblePosition, CursorMovementDirection direction,
     bool skipsSpaceWhenMovingRight)
 {
     if (visiblePosition.isNull())
         return VisiblePosition();
 
-    TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
+    bool blockDirection = isEnclosingBoxHasLeftToRightDirection(visiblePosition.deepEquivalent());

[yosin_UTC9, 2014/10/08 08:32:51]

nit: Please rename |blockDirection| to |isLeftToRight| or something appropriate.

[Habib Virji, 2014/10/08 08:40:27]

Done.

     InlineBox* previouslyVisitedBox = 0;
     VisiblePosition current = visiblePosition;
     TextBreakIterator* iter = 0;
 
     CachedLogicallyOrderedLeafBoxes leafBoxes;
     Vector<UChar, 1024> string;
 
     while (1) {
         VisiblePosition adjacentCharacterPosition = direction == MoveRight ? current.right(true) : current.left(true);
         if (adjacentCharacterPosition == current || adjacentCharacterPosition.isNull())
@@ skipping 25 matching lines @@
             previouslyVisitedBox = box;
         }
 
         if (!iter)
             break;
 
         iter->first();
         int offsetInIterator = offsetInBox - textBox->start() + previousBoxLength;
 
         bool isWordBreak;
-        bool boxHasSameDirectionalityAsBlock = box->direction() == blockDirection;
+        bool boxHasSameDirectionalityAsBlock = blockDirection ? box->direction() == LTR : box->direction() == RTL;
         bool movingBackward = (direction == MoveLeft && box->direction() == LTR) || (direction == MoveRight && box->direction() == RTL);
         if ((skipsSpaceWhenMovingRight && boxHasSameDirectionalityAsBlock)
             || (!skipsSpaceWhenMovingRight && movingBackward)) {
             bool logicalStartInRenderer = offsetInBox == static_cast<int>(textBox->start()) && previousBoxInDifferentBlock;
             isWordBreak = isLogicalStartOfWord(iter, offsetInIterator, logicalStartInRenderer);
         } else {
             bool logicalEndInRenderer = offsetInBox == static_cast<int>(textBox->start() + textBox->len()) && nextBoxInDifferentBlock;
             isWordBreak = islogicalEndOfWord(iter, offsetInIterator, logicalEndInRenderer);
         }
 
         if (isWordBreak)
             return adjacentCharacterPosition;
 
         current = adjacentCharacterPosition;
     }
     return VisiblePosition();
 }
 
 VisiblePosition leftWordPosition(const VisiblePosition& visiblePosition, bool skipsSpaceWhenMovingRight)
 {
     VisiblePosition leftWordBreak = visualWordPosition(visiblePosition, MoveLeft, skipsSpaceWhenMovingRight);
     leftWordBreak = visiblePosition.honorEditingBoundaryAtOrBefore(leftWordBreak);
 
     // FIXME: How should we handle a non-editable position?
-    if (leftWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
-        TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
-        leftWordBreak = blockDirection == LTR ? startOfEditableContent(visiblePosition) : endOfEditableContent(visiblePosition);
-    }
+    if (leftWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent()))
+        leftWordBreak = isEnclosingBoxHasLeftToRightDirection(visiblePosition.deepEquivalent()) ? startOfEditableContent(visiblePosition) : endOfEditableContent(visiblePosition);
+
     return leftWordBreak;
 }
 
 VisiblePosition rightWordPosition(const VisiblePosition& visiblePosition, bool skipsSpaceWhenMovingRight)
 {
     VisiblePosition rightWordBreak = visualWordPosition(visiblePosition, MoveRight, skipsSpaceWhenMovingRight);
     rightWordBreak = visiblePosition.honorEditingBoundaryAtOrBefore(rightWordBreak);
 
     // FIXME: How should we handle a non-editable position?
-    if (rightWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
-        TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
-        rightWordBreak = blockDirection == LTR ? endOfEditableContent(visiblePosition) : startOfEditableContent(visiblePosition);
-    }
+    if (rightWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent()))
+        rightWordBreak = isEnclosingBoxHasLeftToRightDirection(visiblePosition.deepEquivalent()) ? endOfEditableContent(visiblePosition) : startOfEditableContent(visiblePosition);
+
     return rightWordBreak;
 }
 
 
 enum BoundarySearchContextAvailability { DontHaveMoreContext, MayHaveMoreContext };
 
 typedef unsigned (*BoundarySearchFunction)(const UChar*, unsigned length, unsigned offset, BoundarySearchContextAvailability, bool& needMoreContext);
 
 static VisiblePosition previousBoundary(const VisiblePosition& c, BoundarySearchFunction searchFunction)
 {
@@ skipping 951 matching lines @@
     int caretOffset;
     position.position().getInlineBoxAndOffset(position.affinity(), inlineBox, caretOffset);
 
     if (inlineBox)
         renderer = &inlineBox->renderer();
 
     return renderer->localCaretRect(inlineBox, caretOffset);
 }
 
 }