Revert of Have Position deal with more references

Source/core/editing/ApplyStyleCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 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 830 matching lines @@
 bool ApplyStyleCommand::shouldApplyInlineStyleToRun(EditingStyle* style, Node* runStart, Node* pastEndNode)
 {
     ASSERT(style && runStart);
 
     for (Node* node = runStart; node && node != pastEndNode; node = NodeTraversal::next(*node)) {
         if (node->hasChildren())
             continue;
         // We don't consider m_isInlineElementToRemoveFunction here because we never apply style when m_isInlineElementToRemoveFunction is specified
         if (!style->styleIsPresentInComputedStyleOfNode(node))
             return true;
-        if (m_styledInlineElement && !enclosingNodeWithTag(positionBeforeNode(*node), m_styledInlineElement->tagQName()))
+        if (m_styledInlineElement && !enclosingNodeWithTag(positionBeforeNode(node), m_styledInlineElement->tagQName()))
             return true;
     }
     return false;
 }
 
 void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, RefPtr<Node>& runStart, RefPtr<Node>& runEnd, PassRefPtr<Node> pastEndNode)
 {
     ASSERT(runStart && runEnd);
     RefPtr<Node> next = runStart;
     for (RefPtr<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
@@ skipping 344 matching lines @@
 {
     ASSERT(start.containerNode()->isTextNode());
 
     Position newEnd;
     if (start.containerNode() == end.containerNode())
         newEnd = Position(end.containerText(), end.offsetInContainerNode() - start.offsetInContainerNode());
     else
         newEnd = end;
 
     splitTextNodeContainingElement(start.containerText(), start.offsetInContainerNode());
-    updateStartEnd(positionBeforeNode(*start.containerNode()), newEnd);
+    updateStartEnd(positionBeforeNode(start.containerNode()), newEnd);
 }
 
 void ApplyStyleCommand::splitTextElementAtEnd(const Position& start, const Position& end)
 {
     ASSERT(end.containerNode()->isTextNode());
 
     bool shouldUpdateStart = start.containerNode() == end.containerNode();
     splitTextNodeContainingElement(end.containerText(), end.offsetInContainerNode());
 
     Node* parentElement = end.containerNode()->parentNode();
     if (!parentElement || !parentElement->previousSibling())
         return;
     Node* firstTextNode = parentElement->previousSibling()->lastChild();
     if (!firstTextNode || !firstTextNode->isTextNode())
         return;
 
     Position newStart = shouldUpdateStart ? Position(toText(firstTextNode), start.offsetInContainerNode()) : start;
-    updateStartEnd(newStart, positionAfterNode(*firstTextNode));
+    updateStartEnd(newStart, positionAfterNode(firstTextNode));
 }
 
 bool ApplyStyleCommand::shouldSplitTextElement(Element* element, EditingStyle* style)
 {
     if (!element || !element->isHTMLElement())
         return false;
 
     return shouldRemoveInlineStyleFromElement(style, toHTMLElement(element));
 }
 
@@ skipping 147 matching lines @@
     StyleChange styleChange(style, positionToComputeInlineStyleChange(start, dummyElement));
 
     if (dummyElement)
         removeNode(dummyElement);
 
     applyInlineStyleChange(start, passedEnd, styleChange, addStyledElement);
 }
 
 Position ApplyStyleCommand::positionToComputeInlineStyleChange(PassRefPtr<Node> startNode, RefPtr<Node>& dummyElement)
 {
-    ASSERT(startNode);
     // It's okay to obtain the style at the startNode because we've removed all relevant styles from the current run.
     if (!startNode->isElementNode()) {
         dummyElement = createStyleSpanElement(document());
-        insertNodeAt(dummyElement, positionBeforeNode(*startNode));
-        return positionBeforeNode(*dummyElement);
+        insertNodeAt(dummyElement, positionBeforeNode(startNode.get()));
+        return positionBeforeNode(dummyElement.get());
     }
 
     return firstPositionInOrBeforeNode(startNode.get());
 }
 
 void ApplyStyleCommand::applyInlineStyleChange(PassRefPtr<Node> passedStart, PassRefPtr<Node> passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement)
 {
     RefPtr<Node> startNode = passedStart;
     RefPtr<Node> endNode = passedEnd;
     ASSERT(startNode->inDocument());
@@ skipping 125 matching lines @@
         String textToMove = nextText->data();
         insertTextIntoNode(childText, childText->length(), textToMove);
         removeNode(next);
         // don't move child node pointer. it may want to merge with more text nodes.
     }
 
     updateStartEnd(newStart, newEnd);
 }
 
 }