[oilpan] Handlify Nodes in htmlediting

Source/core/dom/Position.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 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 80 matching lines @@
 Position::Position(const Handle<Node>& anchorNode, AnchorType anchorType)
     : m_anchorNode(anchorNode)
     , m_offset(0)
     , m_anchorType(anchorType)
     , m_isLegacyEditingPosition(false)
 {
     ASSERT(!m_anchorNode || !m_anchorNode->isPseudoElement());
 
     ASSERT(anchorType != PositionIsOffsetInAnchor);
     ASSERT(!((anchorType == PositionIsBeforeChildren || anchorType == PositionIsAfterChildren)
-             && (m_anchorNode->isTextNode() || editingIgnoresContent(m_anchorNode.raw()))));
+             && (m_anchorNode->isTextNode() || editingIgnoresContent(m_anchorNode))));
 }
 
 Position::Position(const Handle<Node>& anchorNode, int offset, AnchorType anchorType)
     : m_anchorNode(anchorNode)
     , m_offset(offset)
     , m_anchorType(anchorType)
     , m_isLegacyEditingPosition(false)
 {
     ASSERT(!m_anchorNode || !m_anchorNode->isPseudoElement());
 
     ASSERT(anchorType == PositionIsOffsetInAnchor);
 }
 
 Position::Position(const Handle<Text>& textNode, unsigned offset)
     : m_anchorNode(textNode)
     , m_offset(static_cast<int>(offset))
     , m_anchorType(PositionIsOffsetInAnchor)
     , m_isLegacyEditingPosition(false)
 {
     ASSERT(m_anchorNode);
 }
 
 void Position::moveToPosition(const Handle<Node>& node, int offset)
 {
-    ASSERT(!editingIgnoresContent(node.raw()));
+    ASSERT(!editingIgnoresContent(node));
     ASSERT(anchorType() == PositionIsOffsetInAnchor || m_isLegacyEditingPosition);
     m_anchorNode = node;
     m_offset = offset;
     if (m_isLegacyEditingPosition)
         m_anchorType = anchorTypeForLegacyEditingPosition(m_anchorNode, m_offset);
 }
 void Position::moveToOffset(int offset)
 {
     ASSERT(anchorType() == PositionIsOffsetInAnchor || m_isLegacyEditingPosition);
     m_offset = offset;
@@ skipping 54 matching lines @@
         return m_anchorNode->nodeIndex() + 1;
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 int Position::offsetForPositionAfterAnchor() const
 {
     ASSERT(m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren);
     ASSERT(!m_isLegacyEditingPosition);
-    return lastOffsetForEditing(m_anchorNode.raw());
+    return lastOffsetForEditing(m_anchorNode);
 }
 
 // Neighbor-anchored positions are invalid DOM positions, so they need to be
 // fixed up before handing them off to the Range object.
 Position Position::parentAnchoredEquivalent() const
 {
     if (!m_anchorNode)
         return Position();
 
     // FIXME: This should only be necessary for legacy positions, but is also needed for positions before and after Tables
     if (m_offset <= 0 && (m_anchorType != PositionIsAfterAnchor && m_anchorType != PositionIsAfterChildren)) {
-        if (findParent(m_anchorNode) && (editingIgnoresContent(m_anchorNode.raw()) || isTableElement(m_anchorNode.raw())))
+        if (findParent(m_anchorNode) && (editingIgnoresContent(m_anchorNode) || isTableElement(m_anchorNode)))
             return positionInParentBeforeNode(m_anchorNode);
         return Position(m_anchorNode, 0, PositionIsOffsetInAnchor);
     }
     if (!m_anchorNode->offsetInCharacters()
         && (m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren || static_cast<unsigned>(m_offset) == m_anchorNode->childNodeCount())
-        && (editingIgnoresContent(m_anchorNode.raw()) || isTableElement(m_anchorNode.raw()))
+        && (editingIgnoresContent(m_anchorNode) || isTableElement(m_anchorNode))
         && containerNode()) {
         return positionInParentAfterNode(m_anchorNode);
     }
 
     return Position(containerNode(), computeOffsetInContainerNode(), PositionIsOffsetInAnchor);
 }
 
 Result<Node> Position::computeNodeBeforePosition() const
 {
     if (!m_anchorNode)
@@ skipping 31 matching lines @@
         return m_anchorNode;
     case PositionIsAfterAnchor:
         return m_anchorNode->nextSibling();
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 Position::AnchorType Position::anchorTypeForLegacyEditingPosition(const Handle<Node>& anchorNode, int offset)
 {
-    if (anchorNode && editingIgnoresContent(anchorNode.raw())) {
+    if (anchorNode && editingIgnoresContent(anchorNode)) {
         if (offset == 0)
             return Position::PositionIsBeforeAnchor;
         return Position::PositionIsAfterAnchor;
     }
     return Position::PositionIsOffsetInAnchor;
 }
 
 // FIXME: This method is confusing (does it return anchorNode() or containerNode()?) and should be renamed or removed
 Result<Element> Position::element() const
 {
@@ skipping 19 matching lines @@
     if (!n)
         return *this;
 
     int o = deprecatedEditingOffset();
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(o >= 0);
 
     if (o > 0) {
         Handle<Node> child = n->childNode(o - 1);
         if (child)
-            return lastPositionInOrAfterNode(child.raw());
+            return lastPositionInOrAfterNode(child);
 
         // There are two reasons child might be 0:
         //   1) The node is node like a text node that is not an element, and therefore has no children.
         //      Going backward one character at a time is correct.
         //   2) The old offset was a bogus offset like (<br>, 1), and there is no child.
         //      Going from 1 to 0 is correct.
         switch (moveType) {
         case CodePoint:
             return createLegacyEditingPosition(n, o - 1);
         case Character:
@@ skipping 16 matching lines @@
 
     Handle<Node> n = deprecatedNode();
     if (!n)
         return *this;
 
     int o = deprecatedEditingOffset();
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(o >= 0);
 
     Handle<Node> child = n->childNode(o);
-    if (child || (!n->hasChildNodes() && o < lastOffsetForEditing(n.raw()))) {
+    if (child || (!n->hasChildNodes() && o < lastOffsetForEditing(n))) {
         if (child)
-            return firstPositionInOrBeforeNode(child.raw());
+            return firstPositionInOrBeforeNode(child);
 
         // There are two reasons child might be 0:
         //   1) The node is node like a text node that is not an element, and therefore has no children.
         //      Going forward one character at a time is correct.
         //   2) The new offset is a bogus offset like (<br>, 1), and there is no child.
         //      Going from 0 to 1 is correct.
         return createLegacyEditingPosition(n, (moveType == Character) ? uncheckedNextOffset(n, o) : o + 1);
     }
 
     Handle<ContainerNode> parent = findParent(n);
@@ skipping 25 matching lines @@
     // FIXME: Position before anchor shouldn't be considered as at the first editing position for node
     // since that position resides outside of the node.
     switch (m_anchorType) {
     case PositionIsOffsetInAnchor:
         return m_offset <= 0;
     case PositionIsBeforeChildren:
     case PositionIsBeforeAnchor:
         return true;
     case PositionIsAfterChildren:
     case PositionIsAfterAnchor:
-        return !lastOffsetForEditing(deprecatedNode().handle().raw());
+        return !lastOffsetForEditing(deprecatedNode());
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
 bool Position::atLastEditingPositionForNode() const
 {
     if (isNull())
         return true;
     // FIXME: Position after anchor shouldn't be considered as at the first editing position for node
     // since that position resides outside of the node.
-    return m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren || m_offset >= lastOffsetForEditing(deprecatedNode().handle().raw());
+    return m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren || m_offset >= lastOffsetForEditing(deprecatedNode());
 }
 
 // A position is considered at editing boundary if one of the following is true:
 // 1. It is the first position in the node and the next visually equivalent position
 //    is non editable.
 // 2. It is the last position in the node and the previous visually equivalent position
 //    is non editable.
 // 3. It is an editable position and both the next and previous visually equivalent
 //    positions are both non editable.
 bool Position::atEditingBoundary() const
@@ skipping 35 matching lines @@
     if (isNull())
         return true;
     return !findParent(deprecatedNode()) && m_offset <= 0;
 }
 
 bool Position::atEndOfTree() const
 {
     HandleScope scope;
     if (isNull())
         return true;
-    return !findParent(deprecatedNode()) && m_offset >= lastOffsetForEditing(deprecatedNode().handle().raw());
+    return !findParent(deprecatedNode()) && m_offset >= lastOffsetForEditing(deprecatedNode());
 }
 
 int Position::renderedOffset() const
 {
     if (!deprecatedNode()->isTextNode())
         return m_offset;
 
     if (!deprecatedNode()->renderer())
         return m_offset;
 
@@ skipping 80 matching lines @@
         return false;
 
     if (!node->renderer()->isInline())
         return true;
 
     // Don't include inline tables.
     if (node->hasTagName(tableTag))
         return false;
 
     // There is a VisiblePosition inside an empty inline-block container.
-    return node->renderer()->isReplaced() && canHaveChildrenForEditing(node.raw()) && toRenderBox(node->renderer())->height() != 0 && !node->firstChild();
+    return node->renderer()->isReplaced() && canHaveChildrenForEditing(node) && toRenderBox(node->renderer())->height() != 0 && !node->firstChild();
 }
 
 static Result<Node> enclosingVisualBoundary(const Handle<Node>& node)
 {
     Handle<Node> current = node;
     NoHandleScope scope;
     while (current && !endsOfNodeAreVisuallyDistinctPositions(current)) {
         current = current->parentNode();
     }
 
     return current;
 }
 
 // upstream() and downstream() want to return positions that are either in a
 // text node or at just before a non-text node.  This method checks for that.
 static bool isStreamer(const PositionIterator& pos)
 {
     if (!pos.node())
         return true;
 
-    if (isAtomicNode(pos.node().handle().raw()))
+    if (isAtomicNode(pos.node()))
         return true;
 
     return pos.atStartOfNode();
 }
 
 // This function and downstream() are used for moving back and forth between visually equivalent candidates.
 // For example, for the text node "foo     bar" where whitespace is collapsible, there are two candidates
 // that map to the VisiblePosition between 'b' and the space.  This function will return the left candidate
 // and downstream() will return the right one.
 // Also, upstream() will return [boundary, 0] for any of the positions from [boundary, 0] to the first candidate
 // in boundary, where endsOfNodeAreVisuallyDistinctPositions(boundary) is true.
 Position Position::upstream(EditingBoundaryCrossingRule rule) const
 {
     HandleScope scope;
     Handle<Node> startNode = deprecatedNode();
     if (!startNode)
         return Position();
 
     // iterate backward from there, looking for a qualified position
     Handle<Node> boundary = enclosingVisualBoundary(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
-    PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode, caretMaxOffset(m_anchorNode.raw())) : *this;
+    PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode, caretMaxOffset(m_anchorNode)) : *this;
     PositionIterator currentPos = lastVisible;
     bool startEditable = startNode->rendererIsEditable();
     Handle<Node> lastNode = startNode;
     bool boundaryCrossed = false;
     Handle<Node> currentNode;
     for (; !currentPos.atStart(); currentPos.decrement()) {
         HandleScope scope;
         currentNode = currentPos.node();
 
         // Don't check for an editability change if we haven't moved to a different node,
@@ skipping 27 matching lines @@
         // track last visible streamer position
         if (isStreamer(currentPos))
             lastVisible = currentPos;
 
         // Don't move past a position that is visually distinct.  We could rely on code above to terminate and
         // return lastVisible on the next iteration, but we terminate early to avoid doing a nodeIndex() call.
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentPos.atStartOfNode())
             return lastVisible;
 
         // Return position after tables and nodes which have content that can be ignored.
-        if (editingIgnoresContent(currentNode.raw()) || isTableElement(currentNode.raw())) {
+        if (editingIgnoresContent(currentNode) || isTableElement(currentNode)) {
             if (currentPos.atEndOfNode())
                 return positionAfterNode(currentNode);
             continue;
         }
 
         // return current position if it is in rendered text
         if (renderer->isText() && toRenderText(renderer)->firstTextBox()) {
             if (currentNode != startNode) {
                 // This assertion fires in layout tests in the case-transform.html test because
                 // of a mix-up between offsets in the text in the DOM tree with text in the
@@ skipping 57 matching lines @@
 Position Position::downstream(EditingBoundaryCrossingRule rule) const
 {
     HandleScope scope;
     Handle<Node> startNode = deprecatedNode();
     if (!startNode)
         return Position();
 
     // iterate forward from there, looking for a qualified position
     Handle<Node> boundary = enclosingVisualBoundary(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
-    PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode, caretMaxOffset(m_anchorNode.raw())) : *this;
+    PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode, caretMaxOffset(m_anchorNode)) : *this;
     PositionIterator currentPos = lastVisible;
     bool startEditable = startNode->rendererIsEditable();
     Handle<Node> lastNode = startNode;
     bool boundaryCrossed = false;
     Handle<Node> currentNode;
     for (; !currentPos.atEnd(); currentPos.increment()) {
         HandleScope scope;
         currentNode = currentPos.node();
 
         // Don't check for an editability change if we haven't moved to a different node,
@@ skipping 32 matching lines @@
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer(currentPos))
             lastVisible = currentPos;
 
         // Return position before tables and nodes which have content that can be ignored.
-        if (editingIgnoresContent(currentNode.raw()) || isTableElement(currentNode.raw())) {
+        if (editingIgnoresContent(currentNode) || isTableElement(currentNode)) {
             if (currentPos.offsetInLeafNode() <= renderer->caretMinOffset())
                 return createLegacyEditingPosition(currentNode, renderer->caretMinOffset());
             continue;
         }
 
         // return current position if it is in rendered text
         if (renderer->isText() && toRenderText(renderer)->firstTextBox()) {
             if (currentNode != startNode) {
                 ASSERT(currentPos.atStartOfNode());
                 return createLegacyEditingPosition(currentNode, renderer->caretMinOffset());
@@ skipping 114 matching lines @@
     if (renderer->style()->visibility() != VISIBLE)
         return false;
 
     if (renderer->isBR())
         // FIXME: The condition should be m_anchorType == PositionIsBeforeAnchor, but for now we still need to support legacy positions.
         return !m_offset && m_anchorType != PositionIsAfterAnchor && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
 
     if (renderer->isText())
         return !nodeIsUserSelectNone(deprecatedNode()) && inRenderedText();
 
-    if (isTableElement(deprecatedNode().handle().raw()) || editingIgnoresContent(deprecatedNode().handle().raw()))
+    if (isTableElement(deprecatedNode()) || editingIgnoresContent(deprecatedNode()))
         return (atFirstEditingPositionForNode() || atLastEditingPositionForNode()) && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
 
     if (m_anchorNode->hasTagName(htmlTag))
         return false;
 
     if (renderer->isBlockFlow()) {
         if (toRenderBlock(renderer)->logicalHeight() || m_anchorNode->hasTagName(bodyTag)) {
             if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(renderer))
                 return atFirstEditingPositionForNode() && !Position::nodeIsUserSelectNone(deprecatedNode());
             return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
@@ skipping 107 matching lines @@
     int ignoredCaretOffset;
     InlineBox* b1;
     getInlineBoxAndOffset(DOWNSTREAM, b1, ignoredCaretOffset);
     InlineBox* b2;
     pos.getInlineBoxAndOffset(DOWNSTREAM, b2, ignoredCaretOffset);
 
     LOG(Editing, "renderer:               %p [%p]\n", renderer, b1);
     LOG(Editing, "thisRenderedOffset:         %d\n", thisRenderedOffset);
     LOG(Editing, "posRenderer:            %p [%p]\n", posRenderer, b2);
     LOG(Editing, "posRenderedOffset:      %d\n", posRenderedOffset);
-    LOG(Editing, "node min/max:           %d:%d\n", caretMinOffset(deprecatedNode().handle().raw()), caretMaxOffset(deprecatedNode().handle().raw()));
-    LOG(Editing, "pos node min/max:       %d:%d\n", caretMinOffset(pos.deprecatedNode().handle().raw()), caretMaxOffset(pos.deprecatedNode().handle().raw()));
+    LOG(Editing, "node min/max:           %d:%d\n", caretMinOffset(deprecatedNode()), caretMaxOffset(deprecatedNode()));
+    LOG(Editing, "pos node min/max:       %d:%d\n", caretMinOffset(pos.deprecatedNode()), caretMaxOffset(pos.deprecatedNode()));
     LOG(Editing, "----------------------------------------------------------------------\n");
 
     if (!b1 || !b2) {
         return false;
     }
 
     if (b1->root() != b2->root()) {
         return true;
     }
 
     if (nextRenderedEditable(deprecatedNode()) == pos.deprecatedNode()
-        && thisRenderedOffset == caretMaxOffset(deprecatedNode().handle().raw()) && !posRenderedOffset) {
+        && thisRenderedOffset == caretMaxOffset(deprecatedNode()) && !posRenderedOffset) {
         return false;
     }
 
     if (previousRenderedEditable(deprecatedNode()) == pos.deprecatedNode()
-        && !thisRenderedOffset && posRenderedOffset == caretMaxOffset(pos.deprecatedNode().handle().raw())) {
+        && !thisRenderedOffset && posRenderedOffset == caretMaxOffset(pos.deprecatedNode())) {
         return false;
     }
 
     return true;
 }
 
 // This assumes that it starts in editable content.
 Position Position::leadingWhitespacePosition(EAffinity affinity, bool considerNonCollapsibleWhitespace) const
 {
     ASSERT(isEditablePosition(*this));
@@ skipping 94 matching lines @@
     return position;
 }
 
 void Position::getInlineBoxAndOffset(EAffinity affinity, TextDirection primaryDirection, InlineBox*& inlineBox, int& caretOffset) const
 {
     caretOffset = deprecatedEditingOffset();
     RenderObject* renderer = deprecatedNode()->renderer();
 
     if (!renderer->isText()) {
         inlineBox = 0;
-        if (canHaveChildrenForEditing(deprecatedNode().handle().raw()) && renderer->isBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(renderer)) {
+        if (canHaveChildrenForEditing(deprecatedNode()) && renderer->isBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(renderer)) {
             // 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 RenderObject::createVisiblePosition().
             Position equivalent = downstreamIgnoringEditingBoundaries(*this);
             if (equivalent == *this) {
                 equivalent = upstreamIgnoringEditingBoundaries(*this);
                 if (equivalent == *this || downstreamIgnoringEditingBoundaries(equivalent) == *this)
                     return;
             }
 
@@ skipping 217 matching lines @@
     pos.showTreeForThis();
 }
 
 void showTree(const WebCore::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
 }
 
 #endif