[oilpan] Handlify Nodes in htmlediting

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 61 matching lines @@
         if (editable == current->rendererIsEditable(editableType))
             return current;
         current = current->nextLeafNode();
     }
     return nullptr;
 }
 
 // FIXME: consolidate with code in previousLinePosition.
 static Position previousRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
-    Node* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
+    Handle<Node> highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
     Handle<Node> previousNode = previousLeafWithSameEditability(adoptRawResult(node), editableType);
 
-    while (previousNode && inSameLine(firstPositionInOrBeforeNode(previousNode.raw()), visiblePosition)) {
+    while (true) {
         HandleScope scope;
+        if (!previousNode || !inSameLine(firstPositionInOrBeforeNode(previousNode), visiblePosition))
+            break;
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
     }
 
     while (previousNode && !previousNode->isShadowRoot()) {
         HandleScope scope;
-        if (highestEditableRoot(firstPositionInOrBeforeNode(previousNode.raw()), editableType) != highestRoot)
+        if (highestEditableRoot(firstPositionInOrBeforeNode(previousNode), editableType) != highestRoot)
             break;
 
-        Position pos = previousNode->hasTagName(brTag) ? positionBeforeNode(previousNode) : createLegacyEditingPosition(previousNode, caretMaxOffset(previousNode.raw()));
+        Position pos = previousNode->hasTagName(brTag) ? positionBeforeNode(previousNode) : createLegacyEditingPosition(previousNode, caretMaxOffset(previousNode));
         
         if (pos.isCandidate())
             return pos;
 
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
     }
     return Position();
 }
 
 static Position nextRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
-    Node* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
+    Handle<Node> highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
     Handle<Node> nextNode = nextLeafWithSameEditability(adoptRawResult(node), editableType);
-    while (nextNode && inSameLine(firstPositionInOrBeforeNode(nextNode.raw()), visiblePosition)) {
+    while (true) {
         HandleScope scope;
+        if (!nextNode || !inSameLine(firstPositionInOrBeforeNode(nextNode), visiblePosition))
+            break;
         nextNode = nextLeafWithSameEditability(nextNode, ContentIsEditable);
     }
 
     while (nextNode && !nextNode->isShadowRoot()) {
         HandleScope scope;
-        if (highestEditableRoot(firstPositionInOrBeforeNode(nextNode.raw()), editableType) != highestRoot)
+        if (highestEditableRoot(firstPositionInOrBeforeNode(nextNode), editableType) != highestRoot)
             break;
 
         Position pos;
-        pos = createLegacyEditingPosition(nextNode, caretMinOffset(nextNode.raw()));
+        pos = createLegacyEditingPosition(nextNode, caretMinOffset(nextNode));
         
         if (pos.isCandidate())
             return pos;
 
         nextNode = nextLeafWithSameEditability(nextNode, editableType);
     }
     return Position();
 }
 
 class CachedLogicallyOrderedLeafBoxes {
@@ skipping 633 matching lines @@
         : positionBeforeNode(startNode);
 }
 
 static VisiblePosition startOfLine(const VisiblePosition& c, LineEndpointComputationMode mode)
 {
     // TODO: this is the current behavior that might need to be fixed.
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     VisiblePosition visPos = startPositionForLine(c, mode);
 
     if (mode == UseLogicalOrdering) {
-        if (Node* editableRoot = highestEditableRoot(c.deepEquivalent())) {
+        if (Handle<Node> editableRoot = highestEditableRoot(c.deepEquivalent())) {
             if (!editableRoot->contains(visPos.deepEquivalent().containerNode()))
-                return firstPositionInNode(adoptRawResult(editableRoot));
+                return firstPositionInNode(editableRoot);
         }
     }
 
     return c.honorEditingBoundaryAtOrBefore(visPos);
 }
 
 // FIXME: Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition startOfLine(const VisiblePosition& currentPosition)
 {
     return startOfLine(currentPosition, UseInlineBoxOrdering);
@@ skipping 73 matching lines @@
 
     if (mode == UseLogicalOrdering) {
         // Make sure the end of line is at the same line as the given input position. For a wrapping line, the logical end
         // position for the not-last-2-lines might incorrectly hand back the logical beginning of the next line. 
         // For example, <div contenteditable dir="rtl" style="line-break:before-white-space">abcdefg abcdefg abcdefg
         // a abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg </div>
         // In this case, use the previous position of the computed logical end position.
         if (!inSameLogicalLine(c, visPos))
             visPos = visPos.previous();
 
-        if (Node* editableRoot = highestEditableRoot(c.deepEquivalent())) {
+        if (Handle<Node> editableRoot = highestEditableRoot(c.deepEquivalent())) {
             if (!editableRoot->contains(visPos.deepEquivalent().containerNode()))
-                return lastPositionInNode(adoptRawResult(editableRoot));
+                return lastPositionInNode(editableRoot);
         }
 
         return c.honorEditingBoundaryAtOrAfter(visPos);
     }
 
     // Make sure the end of line is at the same line as the given input position. Else use the previous position to 
     // obtain end of line. This condition happens when the input position is before the space character at the end 
     // of a soft-wrapped non-editable line. In this scenario, endPositionForLine would incorrectly hand back a position
     // in the next line instead. This fix is to account for the discrepancy between lines with webkit-line-break:after-white-space style
     // versus lines without that style, which would break before a space by default. 
@@ skipping 81 matching lines @@
             if (!root)
                 return position;
         }
     }
     
     if (root) {
         // FIXME: Can be wrong for multi-column layout and with transforms.
         IntPoint pointInLine = absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
         RenderObject* renderer = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->renderer();
         Handle<Node> node = renderer->node();
-        if (node && editingIgnoresContent(node.raw()))
+        if (node && editingIgnoresContent(node))
             return positionInParentBeforeNode(node);
         return renderer->positionForPoint(pointInLine);
     }
     
     // Could not find a previous line. This means we must already be on the first line.
     // Move to the start of the content in this block, which effectively moves us
     // to the start of the line we're on.
     Handle<Element> rootElement = node->rendererIsEditable(editableType) ? node->rootEditableElement(editableType) : node->document()->documentElement();
     if (!rootElement)
         return VisiblePosition();
@@ skipping 37 matching lines @@
             if (!root)
                 return position;
         }
     }
     
     if (root) {
         // FIXME: Can be wrong for multi-column layout and with transforms.
         IntPoint pointInLine = absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
         RenderObject* renderer = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->renderer();
         Handle<Node> node = renderer->node();
-        if (node && editingIgnoresContent(node.raw()))
+        if (node && editingIgnoresContent(node))
             return positionInParentBeforeNode(node);
         return renderer->positionForPoint(pointInLine);
     }
 
     // Could not find a next line. This means we must already be on the last line.
     // Move to the end of the content in this block, which effectively moves us
     // to the end of the line we're on.
     Handle<Element> rootElement = node->rendererIsEditable(editableType) ? node->rootEditableElement(editableType) : node->document()->documentElement();
     if (!rootElement)
         return VisiblePosition();
@@ skipping 55 matching lines @@
 }
 
 VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     Position p = c.deepEquivalent();
     Handle<Node> startNode = p.deprecatedNode();
 
     if (!startNode)
         return VisiblePosition();
     
-    if (isRenderedAsNonInlineTableImageOrHR(startNode.raw()))
+    if (isRenderedAsNonInlineTableImageOrHR(startNode))
         return positionBeforeNode(startNode);
 
-    Handle<Node> startBlock = enclosingBlock(startNode.raw());
+    Handle<Node> startBlock = enclosingBlock(startNode);
 
     Handle<Node> node = startNode;
-    Node* highestRoot = highestEditableRoot(p);
+    Handle<Node> highestRoot = highestEditableRoot(p);
     int offset = p.deprecatedEditingOffset();
     Position::AnchorType type = p.anchorType();
 
     Handle<Node> n = startNode;
     while (n) {
 #if ENABLE(USERSELECT_ALL)
         if (boundaryCrossingRule == CannotCrossEditingBoundary && !Position::nodeIsUserSelectAll(n) && n->rendererIsEditable() != startNode->rendererIsEditable())
 #else
         if (boundaryCrossingRule == CannotCrossEditingBoundary && n->rendererIsEditable() != startNode->rendererIsEditable())
 #endif
             break;
         if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
             while (n && n->rendererIsEditable() != startNode->rendererIsEditable())
                 n = NodeTraversal::previousPostOrder(n, startBlock);
-            if (!n || !n->isDescendantOf(highestRoot))
+            if (!n || !n->isDescendantOf(highestRoot.raw()))
                 break;
         }
         RenderObject* r = n->renderer();
         if (!r) {
             n = NodeTraversal::previousPostOrder(n, startBlock);
             continue;
         }
         RenderStyle* style = r->style();
         if (style->visibility() != VISIBLE) {
             n = NodeTraversal::previousPostOrder(n, startBlock);
             continue;
         }
         
-        if (r->isBR() || isBlock(n.raw()))
+        if (r->isBR() || isBlock(n))
             break;
 
         if (r->isText() && toRenderText(r)->renderedTextLength()) {
             ASSERT_WITH_SECURITY_IMPLICATION(n->isTextNode());
             type = Position::PositionIsOffsetInAnchor;
             if (style->preserveNewline()) {
                 const UChar* chars = toRenderText(r)->characters();
                 int i = toRenderText(r)->textLength();
                 int o = offset;
                 if (n == startNode && o < i)
                     i = max(0, o);
                 while (--i >= 0) {
                     if (chars[i] == '\n')
                         return VisiblePosition(Position(toText(n.raw()), i + 1), DOWNSTREAM);
                 }
             }
             node = n;
             offset = 0;
             n = NodeTraversal::previousPostOrder(n, startBlock);
-        } else if (editingIgnoresContent(n.raw()) || isTableElement(n.raw())) {
+        } else if (editingIgnoresContent(n) || isTableElement(n)) {
             node = n;
             type = Position::PositionIsBeforeAnchor;
             n = n->previousSibling() ? n->previousSibling() : NodeTraversal::previousPostOrder(n, startBlock);
         } else
             n = NodeTraversal::previousPostOrder(n, startBlock);
     }
 
     if (type == Position::PositionIsOffsetInAnchor) {
         ASSERT(type == Position::PositionIsOffsetInAnchor || !offset);
         return VisiblePosition(Position(node, offset, type), DOWNSTREAM);
     }
 
     return VisiblePosition(Position(node, type), DOWNSTREAM);
 }
 
 VisiblePosition endOfParagraph(const VisiblePosition &c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {    
     if (c.isNull())
         return VisiblePosition();
 
     Position p = c.deepEquivalent();
     Handle<Node> startNode = p.deprecatedNode();
 
-    if (isRenderedAsNonInlineTableImageOrHR(startNode.raw()))
+    if (isRenderedAsNonInlineTableImageOrHR(startNode))
         return positionAfterNode(startNode);
     
-    Handle<Node> startBlock = enclosingBlock(startNode.raw());
+    Handle<Node> startBlock = enclosingBlock(startNode);
     Handle<Node> stayInsideBlock = startBlock;
     
     Handle<Node> node = startNode;
-    Handle<Node> highestRoot = adoptRawResult(highestEditableRoot(p));
+    Handle<Node> highestRoot = highestEditableRoot(p);
     int offset = p.deprecatedEditingOffset();
     Position::AnchorType type = p.anchorType();
 
     Handle<Node> n = startNode;
     while (n) {
 #if ENABLE(USERSELECT_ALL)
         if (boundaryCrossingRule == CannotCrossEditingBoundary && !Position::nodeIsUserSelectAll(n.raw()) && n->rendererIsEditable() != startNode->rendererIsEditable())
 #else
         if (boundaryCrossingRule == CannotCrossEditingBoundary && n->rendererIsEditable() != startNode->rendererIsEditable())
 #endif
@@ skipping 11 matching lines @@
         if (!r) {
             n = NodeTraversal::next(n, stayInsideBlock);
             continue;
         }
         RenderStyle* style = r->style();
         if (style->visibility() != VISIBLE) {
             n = NodeTraversal::next(n, stayInsideBlock);
             continue;
         }
         
-        if (r->isBR() || isBlock(n.raw()))
+        if (r->isBR() || isBlock(n))
             break;
 
         // FIXME: We avoid returning a position where the renderer can't accept the caret.
         if (r->isText() && toRenderText(r)->renderedTextLength()) {
             ASSERT_WITH_SECURITY_IMPLICATION(n->isTextNode());
             int length = toRenderText(r)->textLength();
             type = Position::PositionIsOffsetInAnchor;
             if (style->preserveNewline()) {
                 const UChar* chars = toRenderText(r)->characters();
                 int o = n == startNode ? offset : 0;
                 for (int i = o; i < length; ++i) {
                     if (chars[i] == '\n')
                         return VisiblePosition(Position(toText(n.raw()), i), DOWNSTREAM);
                 }
             }
             node = n;
             offset = r->caretMaxOffset();
             n = NodeTraversal::next(n, stayInsideBlock);
-        } else if (editingIgnoresContent(n.raw()) || isTableElement(n.raw())) {
+        } else if (editingIgnoresContent(n) || isTableElement(n)) {
             node = n;
             type = Position::PositionIsAfterAnchor;
             n = NodeTraversal::nextSkippingChildren(n, stayInsideBlock);
         } else
             n = NodeTraversal::next(n, stayInsideBlock);
     }
 
     if (type == Position::PositionIsOffsetInAnchor)
         return VisiblePosition(Position(node, offset, type), DOWNSTREAM);
 
@@ skipping 50 matching lines @@
     } while (inSameParagraph(p, pos));
     return pos;
 }
 
 // ---------
 
 VisiblePosition startOfBlock(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     Position position = visiblePosition.deepEquivalent();
     Handle<Node> startBlock;
-    if (!position.containerNode() || !(startBlock = enclosingBlock(position.containerNode().handle().raw(), rule)))
+    if (!position.containerNode() || !(startBlock = enclosingBlock(position.containerNode(), rule)))
         return VisiblePosition();
     return firstPositionInNode(startBlock);
 }
 
 VisiblePosition endOfBlock(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     Position position = visiblePosition.deepEquivalent();
     Handle<Node> endBlock;
-    if (!position.containerNode() || !(endBlock = enclosingBlock(position.containerNode().handle().raw(), rule)))
+    if (!position.containerNode() || !(endBlock = enclosingBlock(position.containerNode(), rule)))
         return VisiblePosition();
     return lastPositionInNode(endBlock);
 }
 
 bool inSameBlock(const VisiblePosition &a, const VisiblePosition &b)
 {
-    return !a.isNull() && enclosingBlock(a.deepEquivalent().containerNode().handle().raw()) == enclosingBlock(b.deepEquivalent().containerNode().handle().raw());
+    return !a.isNull() && enclosingBlock(a.deepEquivalent().containerNode()) == enclosingBlock(b.deepEquivalent().containerNode());
 }
 
 bool isStartOfBlock(const VisiblePosition &pos)
 {
     return pos.isNotNull() && pos == startOfBlock(pos, CanCrossEditingBoundary);
 }
 
 bool isEndOfBlock(const VisiblePosition &pos)
 {
     return pos.isNotNull() && pos == endOfBlock(pos, CanCrossEditingBoundary);
@@ skipping 49 matching lines @@
 
 bool isEndOfDocument(const VisiblePosition &p)
 {
     return p.isNotNull() && p.next(CanCrossEditingBoundary).isNull();
 }
 
 // ---------
 
 VisiblePosition startOfEditableContent(const VisiblePosition& visiblePosition)
 {
-    Node* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
+    Handle<Node> highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
     if (!highestRoot)
         return VisiblePosition();
 
-    return firstPositionInNode(adoptRawResult(highestRoot));
+    return firstPositionInNode(highestRoot);
 }
 
 VisiblePosition endOfEditableContent(const VisiblePosition& visiblePosition)
 {
-    Node* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
+    Handle<Node> highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
     if (!highestRoot)
         return VisiblePosition();
 
-    return lastPositionInNode(adoptRawResult(highestRoot));
+    return lastPositionInNode(highestRoot);
 }
 
 bool isEndOfEditableOrNonEditableContent(const VisiblePosition &p)
 {
     return p.isNotNull() && p.next().isNull();
 }
 
 VisiblePosition leftBoundaryOfLine(const VisiblePosition& c, TextDirection direction)
 {
     return direction == LTR ? logicalStartOfLine(c) : logicalEndOfLine(c);
 }
 
 VisiblePosition rightBoundaryOfLine(const VisiblePosition& c, TextDirection direction)
 {
     return direction == LTR ? logicalEndOfLine(c) : logicalStartOfLine(c);
 }
 
 }