Revert of Have Position deal with more references

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 163 matching lines @@
 
 int Position::computeOffsetInContainerNode() const
 {
     if (!m_anchorNode)
         return 0;
 
     switch (anchorType()) {
     case PositionIsBeforeChildren:
         return 0;
     case PositionIsAfterChildren:
-        return lastOffsetInNode(*m_anchorNode);
+        return lastOffsetInNode(m_anchorNode.get());
     case PositionIsOffsetInAnchor:
         return minOffsetForNode(m_anchorNode.get(), m_offset);
     case PositionIsBeforeAnchor:
         return m_anchorNode->nodeIndex();
     case PositionIsAfterAnchor:
         return m_anchorNode->nodeIndex() + 1;
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
@@ skipping 113 matching lines @@
 
         // 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(node, offset - 1);
         case Character:
-            return createLegacyEditingPosition(node, uncheckedPreviousOffset(*node, offset));
+            return createLegacyEditingPosition(node, uncheckedPreviousOffset(node, offset));
         case BackwardDeletion:
-            return createLegacyEditingPosition(node, uncheckedPreviousOffsetForBackwardDeletion(*node, offset));
+            return createLegacyEditingPosition(node, uncheckedPreviousOffsetForBackwardDeletion(node, offset));
         }
     }
 
     if (ContainerNode* parent = node->parentNode())
         return createLegacyEditingPosition(parent, node->nodeIndex());
     return *this;
 }
 
 Position Position::next(PositionMoveType moveType) const
 {
     ASSERT(moveType != BackwardDeletion);
 
     Node* node = deprecatedNode();
     if (!node)
         return *this;
 
     int offset = deprecatedEditingOffset();
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(offset >= 0);
 
     if (Node* child = node->traverseToChildAt(offset))
         return firstPositionInOrBeforeNode(child);
 
     if (!node->hasChildren() && offset < lastOffsetForEditing(node)) {
         // 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(node, (moveType == Character) ? uncheckedNextOffset(*node, offset) : offset + 1);
+        return createLegacyEditingPosition(node, (moveType == Character) ? uncheckedNextOffset(node, offset) : offset + 1);
     }
 
     if (ContainerNode* parent = node->parentNode())
         return createLegacyEditingPosition(parent, node->nodeIndex() + 1);
     return *this;
 }
 
-int Position::uncheckedPreviousOffset(const Node& n, int current)
+int Position::uncheckedPreviousOffset(const Node* n, int current)
 {
-    return n.renderer() ? n.renderer()->previousOffset(current) : current - 1;
+    return n->renderer() ? n->renderer()->previousOffset(current) : current - 1;
 }
 
-int Position::uncheckedPreviousOffsetForBackwardDeletion(const Node& n, int current)
+int Position::uncheckedPreviousOffsetForBackwardDeletion(const Node* n, int current)
 {
-    return n.renderer() ? n.renderer()->previousOffsetForBackwardDeletion(current) : current - 1;
+    return n->renderer() ? n->renderer()->previousOffsetForBackwardDeletion(current) : current - 1;
 }
 
-int Position::uncheckedNextOffset(const Node& n, int current)
+int Position::uncheckedNextOffset(const Node* n, int current)
 {
-    return n.renderer() ? n.renderer()->nextOffset(current) : current + 1;
+    return n->renderer() ? n->renderer()->nextOffset(current) : current + 1;
 }
 
 bool Position::atFirstEditingPositionForNode() const
 {
     if (isNull())
         return true;
     // 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:
@@ skipping 252 matching lines @@
             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) || isRenderedTableElement(currentNode)) {
             if (currentPos.atEndOfNode())
-                return positionAfterNode(*currentNode);
+                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
                 // render tree which can have a different length due to case transformation.
                 // Until we resolve that, disable this so we can run the layout tests!
@@ skipping 733 matching lines @@
     pos.showTreeForThis();
 }
 
 void showTree(const WebCore::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
 }
 
 #endif