Use tighter typing in editing: VisiblePosition & VisibleSelection

Source/core/editing/htmlediting.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 143 matching lines @@
 bool isEditablePosition(const Position& p, EditableType editableType, EUpdateStyle updateStyle)
 {
     Node* node = p.parentAnchoredEquivalent().anchorNode();
     if (!node)
         return false;
     if (updateStyle == UpdateStyle)
         node->document().updateLayoutIgnorePendingStylesheets();
     else
         ASSERT(updateStyle == DoNotUpdateStyle);
 
-    if (isRenderedTableElement(node))
+    if (isRenderedHTMLTableElement(node))
         node = node->parentNode();
 
     return node->hasEditableStyle(editableType);
 }
 
 bool isAtUnsplittableElement(const Position& pos)
 {
     Node* node = pos.deprecatedNode();
     return (node == editableRootForPosition(pos) || node == enclosingNodeOfType(pos, &isTableCell));
 }
 
 
 bool isRichlyEditablePosition(const Position& p, EditableType editableType)
 {
     Node* node = p.deprecatedNode();
     if (!node)
         return false;
 
-    if (isRenderedTableElement(node))
+    if (isRenderedHTMLTableElement(node))
         node = node->parentNode();
 
     return node->rendererIsRichlyEditable(editableType);
 }
 
 Element* editableRootForPosition(const Position& p, EditableType editableType)
 {
     Node* node = p.containerNode();
     if (!node)
         return 0;
 
-    if (isRenderedTableElement(node))
+    if (isRenderedHTMLTableElement(node))
         node = node->parentNode();
 
     return node->rootEditableElement(editableType);
 }
 
 // Finds the enclosing element until which the tree can be split.
 // When a user hits ENTER, he/she won't expect this element to be split into two.
 // You may pass it as the second argument of splitTreeToNode.
 Element* unsplittableElementForPosition(const Position& p)
 {
@@ skipping 244 matching lines @@
 }
 
 static HTMLElement* firstInSpecialElement(const Position& pos)
 {
     Element* rootEditableElement = pos.containerNode()->rootEditableElement();
     for (Node* n = pos.deprecatedNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode()) {
         if (isSpecialHTMLElement(n)) {
             HTMLElement* specialElement = toHTMLElement(n);
             VisiblePosition vPos = VisiblePosition(pos, DOWNSTREAM);
             VisiblePosition firstInElement = VisiblePosition(firstPositionInOrBeforeNode(specialElement), DOWNSTREAM);
-            if (isRenderedTable(specialElement) && vPos == firstInElement.next())
+            if (isRenderedTableElement(specialElement) && vPos == firstInElement.next())
                 return specialElement;
             if (vPos == firstInElement)
                 return specialElement;
         }
     }
     return 0;
 }
 
 static HTMLElement* lastInSpecialElement(const Position& pos)
 {
     Element* rootEditableElement = pos.containerNode()->rootEditableElement();
     for (Node* n = pos.deprecatedNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode()) {
         if (isSpecialHTMLElement(n)) {
             HTMLElement* specialElement = toHTMLElement(n);
             VisiblePosition vPos = VisiblePosition(pos, DOWNSTREAM);
             VisiblePosition lastInElement = VisiblePosition(lastPositionInOrAfterNode(specialElement), DOWNSTREAM);
-            if (isRenderedTable(specialElement) && vPos == lastInElement.previous())
+            if (isRenderedTableElement(specialElement) && vPos == lastInElement.previous())
                 return specialElement;
             if (vPos == lastInElement)
                 return specialElement;
         }
     }
     return 0;
 }
 
 Position positionBeforeContainingSpecialElement(const Position& pos, HTMLElement** containingSpecialElement)
 {
@@ skipping 14 matching lines @@
     if (!n)
         return pos;
     Position result = positionInParentAfterNode(*n);
     if (result.isNull() || result.deprecatedNode()->rootEditableElement() != pos.deprecatedNode()->rootEditableElement())
         return pos;
     if (containingSpecialElement)
         *containingSpecialElement = n;
     return result;
 }
 
-Node* isFirstPositionAfterTable(const VisiblePosition& visiblePosition)
+Element* isFirstPositionAfterTable(const VisiblePosition& visiblePosition)
 {
     Position upstream(visiblePosition.deepEquivalent().upstream());
-    if (isRenderedTable(upstream.deprecatedNode()) && upstream.atLastEditingPositionForNode())
-        return upstream.deprecatedNode();
+    if (isRenderedTableElement(upstream.deprecatedNode()) && upstream.atLastEditingPositionForNode())
+        return toElement(upstream.deprecatedNode());
 
     return 0;
 }
 
-Node* isLastPositionBeforeTable(const VisiblePosition& visiblePosition)
+Element* isLastPositionBeforeTable(const VisiblePosition& visiblePosition)
 {
     Position downstream(visiblePosition.deepEquivalent().downstream());
-    if (isRenderedTable(downstream.deprecatedNode()) && downstream.atFirstEditingPositionForNode())
-        return downstream.deprecatedNode();
+    if (isRenderedTableElement(downstream.deprecatedNode()) && downstream.atFirstEditingPositionForNode())
+        return toElement(downstream.deprecatedNode());
 
     return 0;
 }
 
 // Returns the visible position at the beginning of a node
 VisiblePosition visiblePositionBeforeNode(Node& node)
 {
     if (node.hasChildren())
         return VisiblePosition(firstPositionInOrBeforeNode(&node), DOWNSTREAM);
     ASSERT(node.parentNode());
@@ skipping 207 matching lines @@
     if (!firstList || !secondList || !firstList->isHTMLElement() || !secondList->isHTMLElement())
         return false;
 
     return firstList->hasTagName(secondList->tagQName()) // make sure the list types match (ol vs. ul)
     && firstList->hasEditableStyle() && secondList->hasEditableStyle() // both lists are editable
     && firstList->rootEditableElement() == secondList->rootEditableElement() // don't cross editing boundaries
     && isVisiblyAdjacent(positionInParentAfterNode(*firstList), positionInParentBeforeNode(*secondList));
     // Make sure there is no visible content between this li and the previous list
 }
 
+bool isRenderedHTMLTableElement(const Node* node)
+{
+    return isHTMLTableElement(*node) && node->renderer();
+}
+
 bool isRenderedTableElement(const Node* node)
 {
-    return isHTMLTableElement(*node) && node->renderer();
-}
-
-bool isRenderedTable(const Node* node)
-{
     if (!node || !node->isElementNode())
         return false;
 
     RenderObject* renderer = node->renderer();
     return (renderer && renderer->isTable());
 }
 
 bool isTableCell(const Node* node)
 {
     ASSERT(node);
@@ skipping 304 matching lines @@
 VisibleSelection selectionForParagraphIteration(const VisibleSelection& original)
 {
     VisibleSelection newSelection(original);
     VisiblePosition startOfSelection(newSelection.visibleStart());
     VisiblePosition endOfSelection(newSelection.visibleEnd());
 
     // If the end of the selection to modify is just after a table, and
     // if the start of the selection is inside that table, then the last paragraph
     // that we'll want modify is the last one inside the table, not the table itself
     // (a table is itself a paragraph).
-    if (Node* table = isFirstPositionAfterTable(endOfSelection))
+    if (Element* table = isFirstPositionAfterTable(endOfSelection))
         if (startOfSelection.deepEquivalent().deprecatedNode()->isDescendantOf(table))
             newSelection = VisibleSelection(startOfSelection, endOfSelection.previous(CannotCrossEditingBoundary));
 
     // If the start of the selection to modify is just before a table,
     // and if the end of the selection is inside that table, then the first paragraph
     // we'll want to modify is the first one inside the table, not the paragraph
     // containing the table itself.
-    if (Node* table = isLastPositionBeforeTable(startOfSelection))
+    if (Element* table = isLastPositionBeforeTable(startOfSelection))
         if (endOfSelection.deepEquivalent().deprecatedNode()->isDescendantOf(table))
             newSelection = VisibleSelection(startOfSelection.next(CannotCrossEditingBoundary), endOfSelection);
 
     return newSelection;
 }
 
 // FIXME: indexForVisiblePosition and visiblePositionForIndex use TextIterators to convert between
 // VisiblePositions and indices. But TextIterator iteration using TextIteratorEmitsCharactersBetweenAllVisiblePositions
 // does not exactly match VisiblePosition iteration, so using them to preserve a selection during an editing
 // opertion is unreliable. TextIterator's TextIteratorEmitsCharactersBetweenAllVisiblePositions mode needs to be fixed,
@@ skipping 121 matching lines @@
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
         return visiblePosition.next().deepEquivalent().downstream();
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
     return visiblePosition.deepEquivalent().downstream();
 }
 
 } // namespace blink