Get rid of redundant parameter PositionIsOffsetInAnchor from PositionAlgorithm constructor

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 92 matching lines @@
     : m_anchorNode(anchorNode)
     , m_offset(0)
     , m_anchorType(anchorType)
     , m_isLegacyEditingPosition(false)
 {
     ASSERT(!m_anchorNode || !m_anchorNode->isPseudoElement() || m_anchorNode->isFirstLetterPseudoElement());
     ASSERT(m_anchorType != PositionIsOffsetInAnchor);
 }
 
 template <typename Strategy>
-PositionAlgorithm<Strategy>::PositionAlgorithm(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset, AnchorType anchorType)
+PositionAlgorithm<Strategy>::PositionAlgorithm(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset)
     : m_anchorNode(anchorNode)
     , m_offset(offset)
-    , m_anchorType(anchorType)
+    , m_anchorType(PositionIsOffsetInAnchor)
     , m_isLegacyEditingPosition(false)
 {
     ASSERT(!m_anchorNode || !m_anchorNode->isPseudoElement() || m_anchorNode->isFirstLetterPseudoElement());
-    ASSERT(anchorType == PositionIsOffsetInAnchor);
 }
 
 template <typename Strategy>
-PositionAlgorithm<Strategy>::PositionAlgorithm(PassRefPtrWillBeRawPtr<Text> textNode, unsigned offset)
-    : m_anchorNode(textNode)
-    , m_offset(static_cast<int>(offset))
-    , m_anchorType(PositionIsOffsetInAnchor)
-    , m_isLegacyEditingPosition(false)
-{
-    ASSERT(m_anchorNode);
-}
-
-template <typename Strategy>
 PositionAlgorithm<Strategy>::PositionAlgorithm(const PositionAlgorithm& other)
     : m_anchorNode(other.m_anchorNode)
     , m_offset(other.m_offset)
     , m_anchorType(other.m_anchorType)
     , m_isLegacyEditingPosition(other.m_isLegacyEditingPosition)
 {
 }
 
 // --
 
@@ skipping 88 matching lines @@
 template <typename Strategy>
 typename Strategy::PositionType PositionAlgorithm<Strategy>::parentAnchoredEquivalent() const
 {
     if (!m_anchorNode)
         return PositionType();
 
     // 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 (Strategy::parent(*m_anchorNode) && (Strategy::editingIgnoresContent(m_anchorNode.get()) || isRenderedHTMLTableElement(m_anchorNode.get())))
             return inParentBeforeNode(*m_anchorNode);
-        return PositionType(m_anchorNode.get(), 0, PositionIsOffsetInAnchor);
+        return PositionType(m_anchorNode.get(), 0);
     }
     if (!m_anchorNode->offsetInCharacters()
         && (m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren || static_cast<unsigned>(m_offset) == m_anchorNode->countChildren())
         && (Strategy::editingIgnoresContent(m_anchorNode.get()) || isRenderedHTMLTableElement(m_anchorNode.get()))
         && containerNode()) {
         return inParentAfterNode(*m_anchorNode);
     }
 
-    return PositionType(containerNode(), computeOffsetInContainerNode(), PositionIsOffsetInAnchor);
+    return PositionType(containerNode(), computeOffsetInContainerNode());
 }
 
 template <typename Strategy>
 typename Strategy::PositionType PositionAlgorithm<Strategy>::toOffsetInAnchor() const
 {
     if (isNull())
         return PositionType();
 
-    return PositionType(containerNode(), computeOffsetInContainerNode(), PositionIsOffsetInAnchor);
+    return PositionType(containerNode(), computeOffsetInContainerNode());
 }
 
 template <typename Strategy>
 Node* PositionAlgorithm<Strategy>::computeNodeBeforePosition() const
 {
     if (!m_anchorNode)
         return 0;
     switch (anchorType()) {
     case PositionIsBeforeChildren:
         return 0;
@@ skipping 1129 matching lines @@
 
 PositionInComposedTree toPositionInComposedTree(const Position& pos)
 {
     if (pos.isNull())
         return PositionInComposedTree();
 
     PositionInComposedTree position;
     if (pos.anchorType() == Position::PositionIsOffsetInAnchor) {
         Node* anchor = pos.anchorNode();
         if (anchor->offsetInCharacters())
-            return PositionInComposedTree(anchor, pos.computeOffsetInContainerNode(), PositionInComposedTree::PositionIsOffsetInAnchor);
+            return PositionInComposedTree(anchor, pos.computeOffsetInContainerNode());
         ASSERT(!isActiveInsertionPoint(*anchor));
         int offset = pos.computeOffsetInContainerNode();
         Node* child = NodeTraversal::childAt(*anchor, offset);
         if (!child) {
             if (anchor->isShadowRoot())
                 return PositionInComposedTree(anchor->shadowHost(), PositionInComposedTree::PositionIsAfterChildren);
             return PositionInComposedTree(anchor, PositionInComposedTree::PositionIsAfterChildren);
         }
         child->updateDistribution();
         if (isActiveInsertionPoint(*child)) {
             if (anchor->isShadowRoot())
-                return PositionInComposedTree(anchor->shadowHost(), offset, PositionInComposedTree::PositionIsOffsetInAnchor);
-            return PositionInComposedTree(anchor, offset, PositionInComposedTree::PositionIsOffsetInAnchor);
+                return PositionInComposedTree(anchor->shadowHost(), offset);
+            return PositionInComposedTree(anchor, offset);
         }
-        return PositionInComposedTree(ComposedTreeTraversal::parent(*child), ComposedTreeTraversal::index(*child), PositionInComposedTree::PositionIsOffsetInAnchor);
+        return PositionInComposedTree(ComposedTreeTraversal::parent(*child), ComposedTreeTraversal::index(*child));
     }
 
     return PositionInComposedTree(pos.anchorNode(), static_cast<PositionInComposedTree::AnchorType>(pos.anchorType()));
 }
 
 Position toPositionInDOMTree(const PositionInComposedTree& position)
 {
     if (position.isNull())
         return Position();
 
     Node* anchorNode = position.anchorNode();
 
     switch (position.anchorType()) {
     case PositionInComposedTree::PositionIsAfterChildren:
         // FIXME: When anchorNode is <img>, assertion fails in the constructor.
         return Position(anchorNode, Position::PositionIsAfterChildren);
     case PositionInComposedTree::PositionIsAfterAnchor:
         return positionAfterNode(anchorNode);
     case PositionInComposedTree::PositionIsBeforeChildren:
         return Position(anchorNode, Position::PositionIsBeforeChildren);
     case PositionInComposedTree::PositionIsBeforeAnchor:
         return positionBeforeNode(anchorNode);
     case PositionInComposedTree::PositionIsOffsetInAnchor: {
         int offset = position.offsetInContainerNode();
         if (anchorNode->offsetInCharacters())
-            return Position(anchorNode, offset, Position::PositionIsOffsetInAnchor);
+            return Position(anchorNode, offset);
         Node* child = ComposedTreeTraversal::childAt(*anchorNode, offset);
         if (child)
-            return Position(child->parentNode(), child->nodeIndex(), Position::PositionIsOffsetInAnchor);
+            return Position(child->parentNode(), child->nodeIndex());
         if (!position.offsetInContainerNode())
             return Position(anchorNode, Position::PositionIsBeforeChildren);
 
         // |child| is null when the position is at the end of the children.
         // <div>foo|</div>
         return Position(anchorNode, Position::PositionIsAfterChildren);
     }
     default:
         ASSERT_NOT_REACHED();
         return Position();
@@ skipping 80 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif