[CodeHealth] Use Position::anchorNode instead of deprecatedNode.

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 374 matching lines @@
 
 template <typename Strategy>
 int PositionAlgorithm<Strategy>::compareTo(const PositionAlgorithm<Strategy>& other) const
 {
     return comparePositions(*this, other);
 }
 
 template <typename Strategy>
 PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::previous(PositionMoveType moveType) const
 {
-    Node* node = deprecatedNode();
+    Node* node = anchorNode();
     if (!node)
         return PositionAlgorithm<Strategy>(*this);
 
     int offset = deprecatedEditingOffset();
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(offset >= 0);
 
     if (offset > 0) {
         if (Node* child = Strategy::childAt(*node, offset - 1))
             return lastPositionInOrAfterNode(child);
@@ skipping 16 matching lines @@
     if (ContainerNode* parent = Strategy::parent(*node))
         return createLegacyEditingPosition(parent, node->nodeIndex());
     return PositionAlgorithm<Strategy>(*this);
 }
 
 template <typename Strategy>
 PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::next(PositionMoveType moveType) const
 {
     ASSERT(moveType != BackwardDeletion);
 
-    Node* node = deprecatedNode();
+    Node* node = anchorNode();
     if (!node)
         return PositionAlgorithm<Strategy>(*this);
 
     int offset = deprecatedEditingOffset();
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(offset >= 0);
 
     if (Node* child = Strategy::childAt(*node, offset))
         return firstPositionInOrBeforeNode(child);
 
@@ skipping 37 matching lines @@
     // FIXME: Position before anchor shouldn't be considered as at the first editing position for node
     // since that position resides outside of the node.
     switch (m_anchorType) {
     case PositionAnchorType::OffsetInAnchor:
         return m_offset <= 0;
     case PositionAnchorType::BeforeChildren:
     case PositionAnchorType::BeforeAnchor:
         return true;
     case PositionAnchorType::AfterChildren:
     case PositionAnchorType::AfterAnchor:
-        return !lastOffsetForEditing(deprecatedNode());
+        return !lastOffsetForEditing(anchorNode());
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::atLastEditingPositionForNode() const
 {
     if (isNull())
         return true;
     // FIXME: Position after anchor shouldn't be considered as at the first editing position for node
     // since that position resides outside of the node.
-    return m_anchorType == PositionAnchorType::AfterAnchor || m_anchorType == PositionAnchorType::AfterChildren || m_offset >= lastOffsetForEditing(deprecatedNode());
+    return m_anchorType == PositionAnchorType::AfterAnchor || m_anchorType == PositionAnchorType::AfterChildren || m_offset >= lastOffsetForEditing(anchorNode());
 }
 
 // A position is considered at editing boundary if one of the following is true:
 // 1. It is the first position in the node and the next visually equivalent position
 //    is non editable.
 // 2. It is the last position in the node and the previous visually equivalent position
 //    is non editable.
 // 3. It is an editable position and both the next and previous visually equivalent
 //    positions are both non editable.
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::atEditingBoundary() const
 {
     PositionAlgorithm<Strategy> nextPosition = downstream(CanCrossEditingBoundary);
-    if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.deprecatedNode()->hasEditableStyle())
+    if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.anchorNode()->hasEditableStyle())
         return true;
 
     PositionAlgorithm<Strategy> prevPosition = upstream(CanCrossEditingBoundary);
-    if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->hasEditableStyle())
+    if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.anchorNode()->hasEditableStyle())
         return true;
 
-    return nextPosition.isNotNull() && !nextPosition.deprecatedNode()->hasEditableStyle()
-        && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->hasEditableStyle();
+    return nextPosition.isNotNull() && !nextPosition.anchorNode()->hasEditableStyle()
+        && prevPosition.isNotNull() && !prevPosition.anchorNode()->hasEditableStyle();
 }
 
 template <typename Strategy>
 static ContainerNode* nonShadowBoundaryParentNode(Node* node)
 {
     ContainerNode* parent = Strategy::parent(*node);
     return parent && !parent->isShadowRoot() ? parent : nullptr;
 }
 
 template <typename Strategy>
@@ skipping 12 matching lines @@
 
     return boundary;
 }
 
 
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::atStartOfTree() const
 {
     if (isNull())
         return true;
-    return !Strategy::parent(*deprecatedNode()) && m_offset <= 0;
+    return !Strategy::parent(*anchorNode()) && m_offset <= 0;
 }
 
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::atEndOfTree() const
 {
     if (isNull())
         return true;
-    return !Strategy::parent(*deprecatedNode()) && m_offset >= lastOffsetForEditing(deprecatedNode());
+    return !Strategy::parent(*anchorNode()) && m_offset >= lastOffsetForEditing(anchorNode());
 }
 
 template <typename Strategy>
 int PositionAlgorithm<Strategy>::renderedOffset() const
 {
-    if (!deprecatedNode()->isTextNode())
+    if (!anchorNode()->isTextNode())
         return m_offset;
 
-    if (!deprecatedNode()->layoutObject())
+    if (!anchorNode()->layoutObject())
         return m_offset;
 
     int result = 0;
-    LayoutText* textLayoutObject = toLayoutText(deprecatedNode()->layoutObject());
+    LayoutText* textLayoutObject = toLayoutText(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)
             return result;
         if (m_offset <= end) {
             result += m_offset - start;
             return result;
         }
         result += box->len();
@@ skipping 51 matching lines @@
 
 // This function and downstream() are used for moving back and forth between visually equivalent candidates.
 // For example, for the text node "foo     bar" where whitespace is collapsible, there are two candidates
 // that map to the VisiblePosition between 'b' and the space.  This function will return the left candidate
 // and downstream() will return the right one.
 // Also, upstream() will return [boundary, 0] for any of the positions from [boundary, 0] to the first candidate
 // in boundary, where endsOfNodeAreVisuallyDistinctPositions(boundary) is true.
 template <typename Strategy>
 PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::upstream(EditingBoundaryCrossingRule rule) const
 {
-    Node* startNode = deprecatedNode();
+    Node* startNode = anchorNode();
     if (!startNode)
         return PositionAlgorithm<Strategy>();
 
     // iterate backward from there, looking for a qualified position
     Node* boundary = enclosingVisualBoundary<Strategy>(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
     PositionIteratorAlgorithm<Strategy> lastVisible(m_anchorType == PositionAnchorType::AfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : PositionAlgorithm<Strategy>(*this));
     PositionIteratorAlgorithm<Strategy> currentPos = lastVisible;
     bool startEditable = startNode->hasEditableStyle();
     Node* lastNode = startNode;
@@ skipping 101 matching lines @@
 // This function and upstream() are used for moving back and forth between visually equivalent candidates.
 // For example, for the text node "foo     bar" where whitespace is collapsible, there are two candidates
 // that map to the VisiblePosition between 'b' and the space.  This function will return the right candidate
 // and upstream() will return the left one.
 // Also, downstream() will return the last position in the last atomic node in boundary for all of the positions
 // in boundary after the last candidate, where endsOfNodeAreVisuallyDistinctPositions(boundary).
 // FIXME: This function should never be called when the line box tree is dirty. See https://bugs.webkit.org/show_bug.cgi?id=97264
 template <typename Strategy>
 PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::downstream(EditingBoundaryCrossingRule rule) const
 {
-    Node* startNode = deprecatedNode();
+    Node* startNode = anchorNode();
     if (!startNode)
         return PositionAlgorithm<Strategy>();
 
     // iterate forward from there, looking for a qualified position
     Node* boundary = enclosingVisualBoundary<Strategy>(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
     PositionIteratorAlgorithm<Strategy> lastVisible(m_anchorType == PositionAnchorType::AfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : PositionAlgorithm<Strategy>(*this));
     PositionIteratorAlgorithm<Strategy> currentPos = lastVisible;
     bool startEditable = startNode->hasEditableStyle();
     Node* lastNode = startNode;
@@ skipping 154 matching lines @@
     }
     return candidateRoot;
 }
 
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::isCandidate() const
 {
     if (isNull())
         return false;
 
-    LayoutObject* layoutObject = deprecatedNode()->layoutObject();
+    LayoutObject* layoutObject = anchorNode()->layoutObject();
     if (!layoutObject)
         return false;
 
     if (layoutObject->style()->visibility() != VISIBLE)
         return false;
 
     if (layoutObject->isBR()) {
         // TODO(leviw) The condition should be
         // m_anchorType == PositionAnchorType::BeforeAnchor, but for now we
         // still need to support legacy positions.
-        return !m_offset && m_anchorType != PositionAnchorType::AfterAnchor && !nodeIsUserSelectNone(Strategy::parent(*deprecatedNode()));
+        return !m_offset && m_anchorType != PositionAnchorType::AfterAnchor && !nodeIsUserSelectNone(Strategy::parent(*anchorNode()));
     }
 
     if (layoutObject->isText())
-        return !nodeIsUserSelectNone(deprecatedNode()) && inRenderedText();
+        return !nodeIsUserSelectNone(anchorNode()) && inRenderedText();
 
     if (layoutObject->isSVG()) {
         // We don't consider SVG elements are contenteditable except for
         // associated layoutObject returns isText() true, e.g. LayoutSVGInlineText.
         return false;
     }
 
-    if (isRenderedHTMLTableElement(deprecatedNode()) || Strategy::editingIgnoresContent(deprecatedNode()))
-        return (atFirstEditingPositionForNode() || atLastEditingPositionForNode()) && !nodeIsUserSelectNone(Strategy::parent(*deprecatedNode()));
+    if (isRenderedHTMLTableElement(anchorNode()) || Strategy::editingIgnoresContent(anchorNode()))
+        return (atFirstEditingPositionForNode() || atLastEditingPositionForNode()) && !nodeIsUserSelectNone(Strategy::parent(*anchorNode()));
 
     if (isHTMLHtmlElement(*m_anchorNode))
         return false;
 
     if (layoutObject->isLayoutBlockFlow() || layoutObject->isFlexibleBox() || layoutObject->isLayoutGrid()) {
         if (toLayoutBlock(layoutObject)->logicalHeight() || isHTMLBodyElement(*m_anchorNode)) {
             if (!hasRenderedNonAnonymousDescendantsWithHeight(layoutObject))
-                return atFirstEditingPositionForNode() && !nodeIsUserSelectNone(deprecatedNode());
-            return m_anchorNode->hasEditableStyle() && !nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
+                return atFirstEditingPositionForNode() && !nodeIsUserSelectNone(anchorNode());
+            return m_anchorNode->hasEditableStyle() && !nodeIsUserSelectNone(anchorNode()) && atEditingBoundary();
         }
     } else {
         LocalFrame* frame = m_anchorNode->document().frame();
         bool caretBrowsing = frame->settings() && frame->settings()->caretBrowsingEnabled();
-        return (caretBrowsing || m_anchorNode->hasEditableStyle()) && !nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
+        return (caretBrowsing || m_anchorNode->hasEditableStyle()) && !nodeIsUserSelectNone(anchorNode()) && atEditingBoundary();
     }
 
     return false;
 }
 
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::inRenderedText() const
 {
-    if (isNull() || !deprecatedNode()->isTextNode())
+    if (isNull() || !anchorNode()->isTextNode())
         return false;
 
-    LayoutObject* layoutObject = deprecatedNode()->layoutObject();
+    LayoutObject* layoutObject = anchorNode()->layoutObject();
     if (!layoutObject)
         return false;
 
     LayoutText* textLayoutObject = toLayoutText(layoutObject);
     for (InlineTextBox *box = textLayoutObject->firstTextBox(); box; box = box->nextTextBox()) {
         if (m_offset < static_cast<int>(box->start()) && !textLayoutObject->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not laid out. Return false.
             return false;
         }
         if (box->containsCaretOffset(m_offset)) {
             // Return false for offsets inside composed characters.
             return m_offset == 0 || m_offset == textLayoutObject->nextOffset(textLayoutObject->previousOffset(m_offset));
         }
     }
 
     return false;
 }
 
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::isRenderedCharacter() const
 {
-    if (isNull() || !deprecatedNode()->isTextNode())
+    if (isNull() || !anchorNode()->isTextNode())
         return false;
 
-    LayoutObject* layoutObject = deprecatedNode()->layoutObject();
+    LayoutObject* layoutObject = anchorNode()->layoutObject();
     if (!layoutObject)
         return false;
 
     LayoutText* textLayoutObject = toLayoutText(layoutObject);
     for (InlineTextBox* box = textLayoutObject->firstTextBox(); box; box = box->nextTextBox()) {
         if (m_offset < static_cast<int>(box->start()) && !textLayoutObject->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // 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
 {
     if (isNull() || pos.isNull())
         return false;
 
-    LayoutObject* layoutObject = deprecatedNode()->layoutObject();
+    LayoutObject* layoutObject = anchorNode()->layoutObject();
     if (!layoutObject)
         return false;
 
-    LayoutObject* posLayoutObject = pos.deprecatedNode()->layoutObject();
+    LayoutObject* posLayoutObject = pos.anchorNode()->layoutObject();
     if (!posLayoutObject)
         return false;
 
     if (layoutObject->style()->visibility() != VISIBLE
         || posLayoutObject->style()->visibility() != VISIBLE)
         return false;
 
-    if (deprecatedNode() == pos.deprecatedNode()) {
-        if (isHTMLBRElement(*deprecatedNode()))
+    if (anchorNode() == pos.anchorNode()) {
+        if (isHTMLBRElement(*anchorNode()))
             return false;
 
         if (m_offset == pos.deprecatedEditingOffset())
             return false;
 
-        if (!deprecatedNode()->isTextNode() && !pos.deprecatedNode()->isTextNode()) {
+        if (!anchorNode()->isTextNode() && !pos.anchorNode()->isTextNode()) {
             if (m_offset != pos.deprecatedEditingOffset())
                 return true;
         }
     }
 
-    if (isHTMLBRElement(*deprecatedNode()) && pos.isCandidate())
+    if (isHTMLBRElement(*anchorNode()) && pos.isCandidate())
         return true;
 
-    if (isHTMLBRElement(*pos.deprecatedNode()) && isCandidate())
+    if (isHTMLBRElement(*pos.anchorNode()) && isCandidate())
         return true;
 
-    if (!inSameContainingBlockFlowElement(deprecatedNode(), pos.deprecatedNode()))
+    if (!inSameContainingBlockFlowElement(anchorNode(), pos.anchorNode()))
         return true;
 
-    if (deprecatedNode()->isTextNode() && !inRenderedText())
+    if (anchorNode()->isTextNode() && !inRenderedText())
         return false;
 
-    if (pos.deprecatedNode()->isTextNode() && !pos.inRenderedText())
+    if (pos.anchorNode()->isTextNode() && !pos.inRenderedText())
         return false;
 
     int thisRenderedOffset = renderedOffset();
     int posRenderedOffset = pos.renderedOffset();
 
     if (layoutObject == posLayoutObject && thisRenderedOffset == posRenderedOffset)
         return false;
 
     InlineBoxPosition boxPosition1 = computeInlineBoxPosition(DOWNSTREAM);
     InlineBoxPosition boxPosition2 = pos.computeInlineBoxPosition(DOWNSTREAM);
 
     WTF_LOG(Editing, "layoutObject:           %p [%p]\n", layoutObject, boxPosition1.inlineBox);
     WTF_LOG(Editing, "thisRenderedOffset:     %d\n", thisRenderedOffset);
     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(deprecatedNode()), caretMaxOffset(deprecatedNode()));
-    WTF_LOG(Editing, "pos node min/max:       %d:%d\n", caretMinOffset(pos.deprecatedNode()), caretMaxOffset(pos.deprecatedNode()));
+    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, "----------------------------------------------------------------------\n");
 
     if (!boxPosition1.inlineBox || !boxPosition2.inlineBox) {
         return false;
     }
 
     if (boxPosition1.inlineBox->root() != boxPosition2.inlineBox->root()) {
         return true;
     }
 
-    if (nextRenderedEditable(deprecatedNode()) == pos.deprecatedNode()
-        && thisRenderedOffset == caretMaxOffset(deprecatedNode()) && !posRenderedOffset) {
+    if (nextRenderedEditable(anchorNode()) == pos.anchorNode()
+        && thisRenderedOffset == caretMaxOffset(anchorNode()) && !posRenderedOffset) {
         return false;
     }
 
-    if (previousRenderedEditable(deprecatedNode()) == pos.deprecatedNode()
-        && !thisRenderedOffset && posRenderedOffset == caretMaxOffset(pos.deprecatedNode())) {
+    if (previousRenderedEditable(anchorNode()) == pos.anchorNode()
+        && !thisRenderedOffset && posRenderedOffset == caretMaxOffset(pos.anchorNode())) {
         return false;
     }
 
     return true;
 }
 
 template <typename Strategy>
 InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(EAffinity affinity) const
 {
     return computeInlineBoxPosition(affinity, primaryDirection());
@@ skipping 59 matching lines @@
 
 template <typename Strategy>
 InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(EAffinity affinity, TextDirection primaryDirection) const
 {
     InlineBox* inlineBox = nullptr;
     int caretOffset = deprecatedEditingOffset();
     LayoutObject* layoutObject = m_anchorNode->isShadowRoot() ? toShadowRoot(m_anchorNode)->host()->layoutObject() : m_anchorNode->layoutObject();
 
     if (!layoutObject->isText()) {
         inlineBox = 0;
-        if (canHaveChildrenForEditing(deprecatedNode()) && layoutObject->isLayoutBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(layoutObject)) {
+        if (canHaveChildrenForEditing(anchorNode()) && layoutObject->isLayoutBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(layoutObject)) {
             // Try a visually equivalent position with possibly opposite editability. This helps in case |this| is in
             // an editable block but surrounded by non-editable positions. It acts to negate the logic at the beginning
             // of LayoutObject::createVisiblePosition().
             PositionAlgorithm<Strategy> thisPosition = PositionAlgorithm<Strategy>(*this);
             PositionAlgorithm<Strategy> equivalent = downstreamIgnoringEditingBoundaries(thisPosition);
             if (equivalent == thisPosition) {
                 equivalent = upstreamIgnoringEditingBoundaries(thisPosition);
                 if (equivalent == thisPosition || downstreamIgnoringEditingBoundaries(equivalent) == thisPosition)
                     return InlineBoxPosition(inlineBox, caretOffset);
             }
@@ skipping 160 matching lines @@
         "Invalid",
     };
 
     if (isNull()) {
         fprintf(stderr, "Position [%s]: null\n", msg);
         return;
     }
 
     const char* anchorType = anchorTypes[std::min(static_cast<size_t>(m_anchorType), WTF_ARRAY_LENGTH(anchorTypes) - 1)];
     if (m_anchorNode->isTextNode()) {
-        fprintf(stderr, "Position [%s]: %s%s [%p] %s, (%s) at %d\n", msg, m_isLegacyEditingPosition ? "LEGACY, " : "", deprecatedNode()->nodeName().utf8().data(), deprecatedNode(), anchorType, m_anchorNode->nodeValue().utf8().data(), m_offset);
+        fprintf(stderr, "Position [%s]: %s%s [%p] %s, (%s) at %d\n", msg, m_isLegacyEditingPosition ? "LEGACY, " : "", anchorNode()->nodeName().utf8().data(), anchorNode(), anchorType, m_anchorNode->nodeValue().utf8().data(), m_offset);
         return;
     }
 
-    fprintf(stderr, "Position [%s]: %s%s [%p] %s at %d\n", msg, m_isLegacyEditingPosition ? "LEGACY, " : "", deprecatedNode()->nodeName().utf8().data(), deprecatedNode(), anchorType, m_offset);
+    fprintf(stderr, "Position [%s]: %s%s [%p] %s at %d\n", msg, m_isLegacyEditingPosition ? "LEGACY, " : "", anchorNode()->nodeName().utf8().data(), anchorNode(), anchorType, m_offset);
 }
 
 PositionInComposedTree toPositionInComposedTree(const Position& pos)
 {
     if (pos.isNull())
         return PositionInComposedTree();
 
     PositionInComposedTree position;
     if (pos.anchorType() == PositionAnchorType::OffsetInAnchor) {
         Node* anchor = pos.anchorNode();
@@ skipping 68 matching lines @@
 {
     StringBuilder result;
 
     if (isNull()) {
         result.appendLiteral("<null>");
     } else {
         char s[1024];
         result.appendLiteral("offset ");
         result.appendNumber(m_offset);
         result.appendLiteral(" of ");
-        deprecatedNode()->formatForDebugger(s, sizeof(s));
+        anchorNode()->formatForDebugger(s, sizeof(s));
         result.append(s);
     }
 
     strncpy(buffer, result.toString().utf8().data(), length - 1);
 }
 
 template <typename Strategy>
 void PositionAlgorithm<Strategy>::showAnchorTypeAndOffset() const
 {
     if (m_isLegacyEditingPosition)
@@ skipping 52 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif