Consider editability when looking for a caret position

third_party/WebKit/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
@@ skipping 2223 matching lines @@
 }
 
 static bool isNonTextLeafChild(LayoutObject* object) {
   if (object->slowFirstChild())
     return false;
   if (object->isText())
     return false;
   return true;
 }
 
-static InlineTextBox* searchAheadForBetterMatch(LayoutObject* layoutObject) {
+static InlineTextBox* searchAheadForBetterMatch(
+    LayoutObject* layoutObject,
+    EditingBoundaryCrossingRule rule) {
   LayoutBlock* container = layoutObject->containingBlock();
   for (LayoutObject* next = layoutObject->nextInPreOrder(container); next;
        next = next->nextInPreOrder(container)) {
     if (next->isLayoutBlock())
       return 0;
     if (next->isBR())
       return 0;
     if (isNonTextLeafChild(next))
       return 0;
     if (next->isText()) {
+      if (rule == CannotCrossEditingBoundary &&
+          next->style()->userModify() == READ_ONLY)
+        return 0;
       InlineTextBox* match = 0;
       int minOffset = INT_MAX;
       for (InlineTextBox* box = toLayoutText(next)->firstTextBox(); box;
            box = box->nextTextBox()) {
         int caretMinOffset = box->caretMinOffset();
         if (caretMinOffset < minOffset) {
           match = box;
           minOffset = caretMinOffset;
         }
       }
@@ skipping 52 matching lines @@
           ? toShadowRoot(anchorNode)->host().layoutObject()
           : anchorNode->layoutObject();
 
   DCHECK(layoutObject) << position;
 
   if (!layoutObject->isText()) {
     inlineBox = 0;
     if (canHaveChildrenForEditing(anchorNode) &&
         layoutObject->isLayoutBlockFlow() &&
         hasRenderedNonAnonymousDescendantsWithHeight(layoutObject)) {
+      if (layoutObject->isLayoutBlock() &&
+          toLayoutBlock(layoutObject)->childrenInline()) {
+        return InlineBoxPosition(inlineBox, caretOffset);
+      }
       // Try a visually equivalent position with possibly opposite
       // editability. This helps in case |this| is in an editable block
       // but surrounded by non-editable positions. It acts to negate the
       // logic at the beginning of
       // |LayoutObject::createPositionWithAffinity()|.
       PositionTemplate<Strategy> equivalent =
           downstreamIgnoringEditingBoundaries(position);
       if (equivalent == position) {
         equivalent = upstreamIgnoringEditingBoundaries(position);
         if (equivalent == position ||
@@ skipping 33 matching lines @@
           ((caretOffset == caretMinOffset) ^
            (affinity == TextAffinity::Upstream)) ||
           (caretOffset == caretMaxOffset && box->nextLeafChild() &&
            box->nextLeafChild()->isLineBreak()))
         break;
 
       candidate = box;
     }
     if (candidate && candidate == textLayoutObject->lastTextBox() &&
         affinity == TextAffinity::Downstream) {
-      box = searchAheadForBetterMatch(textLayoutObject);
+      box = searchAheadForBetterMatch(textLayoutObject,
+                                      hasEditableStyle(*anchorNode)
+                                          ? CannotCrossEditingBoundary
+                                          : CanCrossEditingBoundary);
       if (box)
         caretOffset = box->caretMinOffset();
     }
     inlineBox = box ? box : candidate;
   }
 
   if (!inlineBox)
     return InlineBoxPosition(inlineBox, caretOffset);
 
   unsigned char level = inlineBox->bidiLevel();
@@ skipping 1537 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink