Get rid of redundant parameter PositionIsOffsetInAnchor from PositionAlgorithm constructor

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 75 matching lines @@
         int m_offset;
     };
 
     static const TreeScope* commonAncestorTreeScope(const PositionType&, const PositionType& b);
     static PositionType createLegacyEditingPosition(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset);
 
     PositionAlgorithm(PassRefPtrWillBeRawPtr<Node> anchorNode, LegacyEditingOffset);
 
     // For creating before/after positions:
     PositionAlgorithm(PassRefPtrWillBeRawPtr<Node> anchorNode, AnchorType);
-    PositionAlgorithm(PassRefPtrWillBeRawPtr<Text> textNode, unsigned offset);
 
     // For creating offset positions:
     // FIXME: This constructor should eventually go away. See bug 63040.
-    PositionAlgorithm(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset, AnchorType);
+    PositionAlgorithm(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset);
 
     PositionAlgorithm(const PositionAlgorithm&);
 
     AnchorType anchorType() const { return m_anchorType; }
 
     void clear() { m_anchorNode.clear(); m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }
 
     // These are always DOM compliant values.  Editing positions like [img, 0] (aka [img, before])
     // will return img->parentNode() and img->nodeIndex() from these functions.
     Node* containerNode() const; // NULL for a before/after position anchored to a node with no parent
@@ skipping 199 matching lines @@
 // These are inline to prevent ref-churn when returning a Position object.
 // If we ever add a PassPosition we can make these non-inline.
 
 template <typename Strategy>
 typename Strategy::PositionType PositionAlgorithm<Strategy>::inParentBeforeNode(const Node& node)
 {
     // FIXME: This should ASSERT(node.parentNode())
     // At least one caller currently hits this ASSERT though, which indicates
     // that the caller is trying to make a position relative to a disconnected node (which is likely an error)
     // Specifically, editing/deleting/delete-ligature-001.html crashes with ASSERT(node->parentNode())
-    return PositionType(Strategy::parent(node), Strategy::index(node), PositionIsOffsetInAnchor);
+    return PositionType(Strategy::parent(node), Strategy::index(node));
 }
 
 inline Position positionInParentBeforeNode(const Node& node)
 {
     return Position::inParentBeforeNode(node);
 }
 
 template <typename Strategy>
 typename Strategy::PositionType PositionAlgorithm<Strategy>::inParentAfterNode(const Node& node)
 {
     ASSERT(node.parentNode());
-    return PositionType(Strategy::parent(node), Strategy::index(node) + 1, PositionIsOffsetInAnchor);
+    return PositionType(Strategy::parent(node), Strategy::index(node) + 1);
 }
 
 inline Position positionInParentAfterNode(const Node& node)
 {
     return Position::inParentAfterNode(node);
 }
 
 // positionBeforeNode and positionAfterNode return neighbor-anchored positions, construction is O(1)
 template <typename Strategy>
 typename Strategy::PositionType PositionAlgorithm<Strategy>::beforeNode(Node* anchorNode)
@@ skipping 28 matching lines @@
 inline int lastOffsetInNode(Node* node)
 {
     return Position::lastOffsetInNode(node);
 }
 
 // firstPositionInNode and lastPositionInNode return parent-anchored positions, lastPositionInNode construction is O(n) due to countChildren()
 template <typename Strategy>
 typename Strategy::PositionType PositionAlgorithm<Strategy>::firstPositionInNode(Node* anchorNode)
 {
     if (anchorNode->isTextNode())
-        return PositionType(anchorNode, 0, PositionIsOffsetInAnchor);
+        return PositionType(anchorNode, 0);
     return PositionType(anchorNode, PositionIsBeforeChildren);
 }
 
 inline Position firstPositionInNode(Node* anchorNode)
 {
     return Position::firstPositionInNode(anchorNode);
 }
 
 template <typename Strategy>
 typename Strategy::PositionType PositionAlgorithm<Strategy>::lastPositionInNode(Node* anchorNode)
 {
     if (anchorNode->isTextNode())
-        return PositionType(anchorNode, lastOffsetInNode(anchorNode), PositionIsOffsetInAnchor);
+        return PositionType(anchorNode, lastOffsetInNode(anchorNode));
     return PositionType(anchorNode, PositionIsAfterChildren);
 }
 
 inline Position lastPositionInNode(Node* anchorNode)
 {
     return Position::lastPositionInNode(anchorNode);
 }
 
 template <typename Strategy>
 int PositionAlgorithm<Strategy>::minOffsetForNode(Node* anchorNode, int offset)
@@ skipping 52 matching lines @@
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const blink::Position&);
 void showTree(const blink::Position*);
 #endif
 
 #endif // Position_h