CANCEL Untemplatize PositionAlgorithm<Strategy>::rendersInDifferentPosition()

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 562 matching lines @@
 }
 
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::atEndOfTree() const
 {
     if (isNull())
         return true;
     return !Strategy::parent(*anchorNode()) && m_offset >= lastOffsetForEditing(anchorNode());
 }
 
-template <typename Strategy>
-int PositionAlgorithm<Strategy>::renderedOffset() const
+static int renderedOffsetOf(const Position& position)
 {
-    if (!anchorNode()->isTextNode())
-        return m_offset;
+    // TODO(yosin) We should compute offset for |AfterAnchor| and
+    // |AfterChildren|.
+    int offset = position.deprecatedOffset();
+    if (!position.anchorNode()->isTextNode())
+        return offset;
 
-    if (!anchorNode()->layoutObject())
-        return m_offset;
+    if (!position.anchorNode()->layoutObject())
+        return offset;
 
     int result = 0;
-    LayoutText* textLayoutObject = toLayoutText(anchorNode()->layoutObject());
+    LayoutText* textLayoutObject = toLayoutText(position.anchorNode()->layoutObject());
     for (InlineTextBox *box = textLayoutObject->firstTextBox(); box; box = box->nextTextBox()) {
         int start = box->start();
         int end = box->start() + box->len();
-        if (m_offset < start)
+        if (offset < start)
             return result;
-        if (m_offset <= end) {
-            result += m_offset - start;
+        if (offset <= end) {
+            result += offset - start;
             return result;
         }
         result += box->len();
     }
     return result;
 }
 
 // Whether or not [node, 0] and [node, lastOffsetForEditing(node)] are their own VisiblePositions.
 // If true, adjacent candidates are visually distinct.
 // FIXME: Disregard nodes with layoutObjects that have no height, as we do in isCandidate.
@@ skipping 437 matching lines @@
             // not laid out. Return false.
             return false;
         }
         if (m_offset >= static_cast<int>(box->start()) && m_offset < static_cast<int>(box->start() + box->len()))
             return true;
     }
 
     return false;
 }
 
-template <typename Strategy>
-bool PositionAlgorithm<Strategy>::rendersInDifferentPosition(const PositionAlgorithm<Strategy> &pos) const
+bool rendersInDifferentPosition(const Position& position1, const Position& position2)
 {
-    if (isNull() || pos.isNull())
+    if (position1.isNull() || position2.isNull())
         return false;
 
-    LayoutObject* layoutObject = anchorNode()->layoutObject();
+    LayoutObject* layoutObject = position1.anchorNode()->layoutObject();
     if (!layoutObject)
         return false;
 
-    LayoutObject* posLayoutObject = pos.anchorNode()->layoutObject();
+    LayoutObject* posLayoutObject = position2.anchorNode()->layoutObject();
     if (!posLayoutObject)
         return false;
 
     if (layoutObject->style()->visibility() != VISIBLE
         || posLayoutObject->style()->visibility() != VISIBLE)
         return false;
 
-    if (anchorNode() == pos.anchorNode()) {
-        if (isHTMLBRElement(*anchorNode()))
+    if (position1.anchorNode() == position2.anchorNode()) {
+        if (isHTMLBRElement(*position1.anchorNode()))
             return false;
 
-        if (m_offset == pos.deprecatedEditingOffset())
+        // TODO(yosin) I'm not sure why do we compare

[yoichio, 2015/08/03 06:19:57]

This is not good comment.
You should be sure or this is a refactoring so the comment is not needed.

[yosin_UTC9, 2015/08/03 06:44:06]

Done.

+        // |deprecatedOffset()| and |deprecatedEditingOffset()|.
+        if (position1.deprecatedOffset() == position2.deprecatedEditingOffset())
             return false;
 
-        if (!anchorNode()->isTextNode() && !pos.anchorNode()->isTextNode()) {
-            if (m_offset != pos.deprecatedEditingOffset())
+        if (!position1.anchorNode()->isTextNode() && !position2.anchorNode()->isTextNode()) {
+            // TODO(yosin) I'm not sure why do we compare
+            // |deprecatedOffset()| and |deprecatedEditingOffset()|.
+            if (position1.deprecatedOffset() != position2.deprecatedEditingOffset())
                 return true;
         }
     }
 
-    if (isHTMLBRElement(*anchorNode()) && pos.isCandidate())
+    if (isHTMLBRElement(*position1.anchorNode()) && position2.isCandidate())
         return true;
 
-    if (isHTMLBRElement(*pos.anchorNode()) && isCandidate())
+    if (isHTMLBRElement(*position2.anchorNode()) && position1.isCandidate())
         return true;
 
-    if (!inSameContainingBlockFlowElement(anchorNode(), pos.anchorNode()))
+    if (!inSameContainingBlockFlowElement(position1.anchorNode(), position2.anchorNode()))
         return true;
 
-    if (anchorNode()->isTextNode() && !inRenderedText())
+    if (position1.anchorNode()->isTextNode() && !position1.inRenderedText())
         return false;
 
-    if (pos.anchorNode()->isTextNode() && !pos.inRenderedText())
+    if (position2.anchorNode()->isTextNode() && !position2.inRenderedText())
         return false;
 
-    int thisRenderedOffset = renderedOffset();
-    int posRenderedOffset = pos.renderedOffset();
+    int renderedOffset1 = renderedOffsetOf(position1);
+    int renderedOffset2 = renderedOffsetOf(position2);
 
-    if (layoutObject == posLayoutObject && thisRenderedOffset == posRenderedOffset)
+    if (layoutObject == posLayoutObject && renderedOffset1 == renderedOffset2)
         return false;
 
-    InlineBoxPosition boxPosition1 = computeInlineBoxPosition(DOWNSTREAM);
-    InlineBoxPosition boxPosition2 = pos.computeInlineBoxPosition(DOWNSTREAM);
+    InlineBoxPosition boxPosition1 = position1.computeInlineBoxPosition(DOWNSTREAM);
+    InlineBoxPosition boxPosition2 = position2.computeInlineBoxPosition(DOWNSTREAM);
 
     WTF_LOG(Editing, "layoutObject:           %p [%p]\n", layoutObject, boxPosition1.inlineBox);
-    WTF_LOG(Editing, "thisRenderedOffset:     %d\n", thisRenderedOffset);
+    WTF_LOG(Editing, "renderedOffset1:     %d\n", renderedOffset1);
     WTF_LOG(Editing, "posLayoutObject:        %p [%p]\n", posLayoutObject, boxPosition2.inlineBox);
-    WTF_LOG(Editing, "posRenderedOffset:      %d\n", posRenderedOffset);
-    WTF_LOG(Editing, "node min/max:           %d:%d\n", caretMinOffset(anchorNode()), caretMaxOffset(anchorNode()));
-    WTF_LOG(Editing, "pos node min/max:       %d:%d\n", caretMinOffset(pos.anchorNode()), caretMaxOffset(pos.anchorNode()));
+    WTF_LOG(Editing, "renderedOffset2:      %d\n", renderedOffset2);
+    WTF_LOG(Editing, "node min/max:           %d:%d\n", caretMinOffset(position1.anchorNode()), caretMaxOffset(position1.anchorNode()));
+    WTF_LOG(Editing, "pos node min/max:       %d:%d\n", caretMinOffset(position2.anchorNode()), caretMaxOffset(position2.anchorNode()));
     WTF_LOG(Editing, "----------------------------------------------------------------------\n");
 
     if (!boxPosition1.inlineBox || !boxPosition2.inlineBox) {
         return false;
     }
 
     if (boxPosition1.inlineBox->root() != boxPosition2.inlineBox->root()) {
         return true;
     }
 
-    if (nextRenderedEditable(anchorNode()) == pos.anchorNode()
-        && thisRenderedOffset == caretMaxOffset(anchorNode()) && !posRenderedOffset) {
+    if (nextRenderedEditable(position1.anchorNode()) == position2.anchorNode()
+        && renderedOffset1 == caretMaxOffset(position1.anchorNode()) && !renderedOffset2) {
         return false;
     }
 
-    if (previousRenderedEditable(anchorNode()) == pos.anchorNode()
-        && !thisRenderedOffset && posRenderedOffset == caretMaxOffset(pos.anchorNode())) {
+    if (previousRenderedEditable(position1.anchorNode()) == position2.anchorNode()
+        && !renderedOffset1 && renderedOffset2 == caretMaxOffset(position2.anchorNode())) {
         return false;
     }
 
     return true;
 }
 
 template <typename Strategy>
 InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(EAffinity affinity) const
 {
     return computeInlineBoxPosition(affinity, primaryDirection());
@@ skipping 406 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif