Revert of Have Position deal with more references

Source/core/dom/Position.h

 /*
  * Copyright (C) 2004, 2006, 2008 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 134 matching lines @@
     bool isOrphan() const { return m_anchorNode && !m_anchorNode->inDocument(); }
 
     Element* element() const;
     PassRefPtr<CSSComputedStyleDeclaration> computedStyle() const;
 
     // Move up or down the DOM by one position.
     // Offsets are computed using render text for nodes that have renderers - but note that even when
     // using composed characters, the result may be inside a single user-visible character if a ligature is formed.
     Position previous(PositionMoveType = CodePoint) const;
     Position next(PositionMoveType = CodePoint) const;
-    static int uncheckedPreviousOffset(const Node&, int current);
-    static int uncheckedPreviousOffsetForBackwardDeletion(const Node&, int current);
-    static int uncheckedNextOffset(const Node&, int current);
+    static int uncheckedPreviousOffset(const Node*, int current);
+    static int uncheckedPreviousOffsetForBackwardDeletion(const Node*, int current);
+    static int uncheckedNextOffset(const Node*, int current);
 
     // These can be either inside or just before/after the node, depending on
     // if the node is ignored by editing or not.
     // FIXME: These should go away. They only make sense for legacy positions.
     bool atFirstEditingPositionForNode() const;
     bool atLastEditingPositionForNode() const;
 
     // Returns true if the visually equivalent positions around have different editability
     bool atEditingBoundary() const;
     Node* parentEditingBoundary() const;
@@ skipping 18 matching lines @@
     void getInlineBoxAndOffset(EAffinity, InlineBox*&, int& caretOffset) const;
     void getInlineBoxAndOffset(EAffinity, TextDirection primaryDirection, InlineBox*&, int& caretOffset) const;
 
     TextDirection primaryDirection() const;
 
     static bool hasRenderedNonAnonymousDescendantsWithHeight(RenderObject*);
     static bool nodeIsUserSelectNone(Node*);
     static bool nodeIsUserSelectAll(const Node*);
     static Node* rootUserSelectAllForNode(Node*);
 
+    static ContainerNode* findParent(const Node*);
+
     void debugPosition(const char* msg = "") const;
 
 #ifndef NDEBUG
     void formatForDebugger(char* buffer, unsigned length) const;
     void showAnchorTypeAndOffset() const;
     void showTreeForThis() const;
 #endif
 
 private:
     int offsetForPositionAfterAnchor() const;
@@ skipping 45 matching lines @@
     return Position(node.parentNode(), node.nodeIndex(), Position::PositionIsOffsetInAnchor);
 }
 
 inline Position positionInParentAfterNode(const Node& node)
 {
     ASSERT(node.parentNode());
     return Position(node.parentNode(), node.nodeIndex() + 1, Position::PositionIsOffsetInAnchor);
 }
 
 // positionBeforeNode and positionAfterNode return neighbor-anchored positions, construction is O(1)
-inline Position positionBeforeNode(Node& anchorNode)
+inline Position positionBeforeNode(Node* anchorNode)
 {
-    return Position(PassRefPtr<Node>(anchorNode), Position::PositionIsBeforeAnchor);
+    ASSERT(anchorNode);
+    return Position(anchorNode, Position::PositionIsBeforeAnchor);
 }
 
-inline Position positionAfterNode(Node& anchorNode)
+inline Position positionAfterNode(Node* anchorNode)
 {
-    return Position(PassRefPtr<Node>(anchorNode), Position::PositionIsAfterAnchor);
+    ASSERT(anchorNode);
+    return Position(anchorNode, Position::PositionIsAfterAnchor);
 }
 
-inline int lastOffsetInNode(Node& node)
+inline int lastOffsetInNode(Node* node)
 {
-    return node.offsetInCharacters() ? node.maxCharacterOffset() : static_cast<int>(node.countChildren());
+    return node->offsetInCharacters() ? node->maxCharacterOffset() : static_cast<int>(node->countChildren());
 }
 
 // firstPositionInNode and lastPositionInNode return parent-anchored positions, lastPositionInNode construction is O(n) due to countChildren()
 inline Position firstPositionInNode(Node* anchorNode)
 {
     if (anchorNode->isTextNode())
         return Position(anchorNode, 0, Position::PositionIsOffsetInAnchor);
     return Position(anchorNode, Position::PositionIsBeforeChildren);
 }
 
 inline Position lastPositionInNode(Node* anchorNode)
 {
     if (anchorNode->isTextNode())
-        return Position(anchorNode, lastOffsetInNode(*anchorNode), Position::PositionIsOffsetInAnchor);
+        return Position(anchorNode, lastOffsetInNode(anchorNode), Position::PositionIsOffsetInAnchor);
     return Position(anchorNode, Position::PositionIsAfterChildren);
 }
 
 inline int minOffsetForNode(Node* anchorNode, int offset)
 {
     if (anchorNode->offsetInCharacters())
         return std::min(offset, anchorNode->maxCharacterOffset());
 
     int newOffset = 0;
     for (Node* node = anchorNode->firstChild(); node && newOffset < offset; node = node->nextSibling())
@@ skipping 38 matching lines @@
 
 } // namespace WebCore
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const WebCore::Position&);
 void showTree(const WebCore::Position*);
 #endif
 
 #endif // Position_h