Use tighter typing in editing: IndentOutdentCommand / InsertListCommand

Source/core/editing/InsertListCommand.cpp

 /*
  * Copyright (C) 2006, 2010 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 33 matching lines @@
 using namespace HTMLNames;
 
 static Node* enclosingListChild(Node* node, Node* listNode)
 {
     Node* listChild = enclosingListChild(node);
     while (listChild && enclosingList(listChild) != listNode)
         listChild = enclosingListChild(listChild->parentNode());
     return listChild;
 }
 
-HTMLElement* InsertListCommand::fixOrphanedListChild(Node* node)
+HTMLUListElement* InsertListCommand::fixOrphanedListChild(Node* node)
 {
     RefPtrWillBeRawPtr<HTMLUListElement> listElement = createUnorderedListElement(document());
     insertNodeBefore(listElement, node);
     removeNode(node);
     appendNode(node, listElement);
     m_listElement = listElement;
     return listElement.get();
 }
 
 PassRefPtrWillBeRawPtr<HTMLElement> InsertListCommand::mergeWithNeighboringLists(PassRefPtrWillBeRawPtr<HTMLElement> passedList)
@@ skipping 20 matching lines @@
 
 bool InsertListCommand::selectionHasListOfType(const VisibleSelection& selection, const HTMLQualifiedName& listTag)
 {
     VisiblePosition start = selection.visibleStart();
 
     if (!enclosingList(start.deepEquivalent().deprecatedNode()))
         return false;
 
     VisiblePosition end = startOfParagraph(selection.visibleEnd());
     while (start.isNotNull() && start != end) {
-        Element* listNode = enclosingList(start.deepEquivalent().deprecatedNode());
-        if (!listNode || !listNode->hasTagName(listTag))
+        HTMLElement* listElement = enclosingList(start.deepEquivalent().deprecatedNode());
+        if (!listElement || !listElement->hasTagName(listTag))
             return false;
         start = startOfNextParagraph(start);
     }
 
     return true;
 }
 
 InsertListCommand::InsertListCommand(Document& document, Type type)
     : CompositeEditCommand(document), m_type(type)
 {
@@ skipping 96 matching lines @@
 void InsertListCommand::doApplyForSingleParagraph(bool forceCreateList, const HTMLQualifiedName& listTag, Range& currentSelection)
 {
     // FIXME: This will produce unexpected results for a selection that starts just before a
     // table and ends inside the first cell, selectionForParagraphIteration should probably
     // be renamed and deployed inside setEndingSelection().
     Node* selectionNode = endingSelection().start().deprecatedNode();
     Node* listChildNode = enclosingListChild(selectionNode);
     bool switchListType = false;
     if (listChildNode) {
         // Remove the list chlild.
-        RefPtrWillBeRawPtr<HTMLElement> listNode = enclosingList(listChildNode);
-        if (!listNode) {
-            listNode = fixOrphanedListChild(listChildNode);
-            listNode = mergeWithNeighboringLists(listNode);
+        RefPtrWillBeRawPtr<HTMLElement> listElement = enclosingList(listChildNode);
+        if (!listElement) {
+            listElement = fixOrphanedListChild(listChildNode);
+            listElement = mergeWithNeighboringLists(listElement);
         }
-        if (!listNode->hasTagName(listTag))
+        if (!listElement->hasTagName(listTag))
             // listChildNode will be removed from the list and a list of type m_type will be created.
             switchListType = true;
 
         // If the list is of the desired type, and we are not removing the list, then exit early.
         if (!switchListType && forceCreateList)
             return;
 
         // If the entire list is selected, then convert the whole list.
-        if (switchListType && isNodeVisiblyContainedWithin(*listNode, currentSelection)) {
-            bool rangeStartIsInList = visiblePositionBeforeNode(*listNode) == VisiblePosition(currentSelection.startPosition());
-            bool rangeEndIsInList = visiblePositionAfterNode(*listNode) == VisiblePosition(currentSelection.endPosition());
+        if (switchListType && isNodeVisiblyContainedWithin(*listElement, currentSelection)) {
+            bool rangeStartIsInList = visiblePositionBeforeNode(*listElement) == VisiblePosition(currentSelection.startPosition());
+            bool rangeEndIsInList = visiblePositionAfterNode(*listElement) == VisiblePosition(currentSelection.endPosition());
 
             RefPtrWillBeRawPtr<HTMLElement> newList = createHTMLElement(document(), listTag);
-            insertNodeBefore(newList, listNode);
+            insertNodeBefore(newList, listElement);
 
-            Node* firstChildInList = enclosingListChild(VisiblePosition(firstPositionInNode(listNode.get())).deepEquivalent().deprecatedNode(), listNode.get());
-            Node* outerBlock = firstChildInList && firstChildInList->isBlockFlowElement() ? firstChildInList : listNode.get();
+            Node* firstChildInList = enclosingListChild(VisiblePosition(firstPositionInNode(listElement.get())).deepEquivalent().deprecatedNode(), listElement.get());
+            Element* outerBlock = firstChildInList && firstChildInList->isBlockFlowElement() ? toElement(firstChildInList) : listElement.get();
 
-            moveParagraphWithClones(VisiblePosition(firstPositionInNode(listNode.get())), VisiblePosition(lastPositionInNode(listNode.get())), newList.get(), outerBlock);
+            moveParagraphWithClones(VisiblePosition(firstPositionInNode(listElement.get())), VisiblePosition(lastPositionInNode(listElement.get())), newList.get(), outerBlock);
 
             // Manually remove listNode because moveParagraphWithClones sometimes leaves it behind in the document.
             // See the bug 33668 and editing/execCommand/insert-list-orphaned-item-with-nested-lists.html.
             // FIXME: This might be a bug in moveParagraphWithClones or deleteSelection.
-            if (listNode && listNode->inDocument())
-                removeNode(listNode);
+            if (listElement && listElement->inDocument())
+                removeNode(listElement);
 
             newList = mergeWithNeighboringLists(newList);
 
             // Restore the start and the end of current selection if they started inside listNode
             // because moveParagraphWithClones could have removed them.
             if (rangeStartIsInList && newList)
                 currentSelection.setStart(newList, 0, IGNORE_EXCEPTION);
             if (rangeEndIsInList && newList)
                 currentSelection.setEnd(newList, lastOffsetInNode(newList.get()), IGNORE_EXCEPTION);
 
             setEndingSelection(VisiblePosition(firstPositionInNode(newList.get())));
 
             return;
         }
 
-        unlistifyParagraph(endingSelection().visibleStart(), listNode.get(), listChildNode);
+        unlistifyParagraph(endingSelection().visibleStart(), listElement.get(), listChildNode);
     }
 
     if (!listChildNode || switchListType || forceCreateList)
         m_listElement = listifyParagraph(endingSelection().visibleStart(), listTag);
 }
 
-void InsertListCommand::unlistifyParagraph(const VisiblePosition& originalStart, HTMLElement* listNode, Node* listChildNode)
+void InsertListCommand::unlistifyParagraph(const VisiblePosition& originalStart, HTMLElement* listElement, Node* listChildNode)
 {
     Node* nextListChild;
     Node* previousListChild;
     VisiblePosition start;
     VisiblePosition end;
     ASSERT(listChildNode);
     if (isHTMLLIElement(*listChildNode)) {
         start = VisiblePosition(firstPositionInNode(listChildNode));
         end = VisiblePosition(lastPositionInNode(listChildNode));
         nextListChild = listChildNode->nextSibling();
         previousListChild = listChildNode->previousSibling();
     } else {
         // A paragraph is visually a list item minus a list marker.  The paragraph will be moved.
         start = startOfParagraph(originalStart, CanSkipOverEditingBoundary);
         end = endOfParagraph(start, CanSkipOverEditingBoundary);
-        nextListChild = enclosingListChild(end.next().deepEquivalent().deprecatedNode(), listNode);
+        nextListChild = enclosingListChild(end.next().deepEquivalent().deprecatedNode(), listElement);
         ASSERT(nextListChild != listChildNode);
-        previousListChild = enclosingListChild(start.previous().deepEquivalent().deprecatedNode(), listNode);
+        previousListChild = enclosingListChild(start.previous().deepEquivalent().deprecatedNode(), listElement);
         ASSERT(previousListChild != listChildNode);
     }
     // When removing a list, we must always create a placeholder to act as a point of insertion
     // for the list content being removed.
     RefPtrWillBeRawPtr<HTMLBRElement> placeholder = createBreakElement(document());
     RefPtrWillBeRawPtr<HTMLElement> elementToInsert = placeholder;
     // If the content of the list item will be moved into another list, put it in a list item
     // so that we don't create an orphaned list child.
-    if (enclosingList(listNode)) {
+    if (enclosingList(listElement)) {
         elementToInsert = createListItemElement(document());
         appendNode(placeholder, elementToInsert);
     }
 
     if (nextListChild && previousListChild) {
         // We want to pull listChildNode out of listNode, and place it before nextListChild
         // and after previousListChild, so we split listNode and insert it between the two lists.
         // But to split listNode, we must first split ancestors of listChildNode between it and listNode,
         // if any exist.
         // FIXME: We appear to split at nextListChild as opposed to listChildNode so that when we remove
         // listChildNode below in moveParagraphs, previousListChild will be removed along with it if it is
         // unrendered. But we ought to remove nextListChild too, if it is unrendered.
-        splitElement(listNode, splitTreeToNode(nextListChild, listNode));
-        insertNodeBefore(elementToInsert, listNode);
-    } else if (nextListChild || listChildNode->parentNode() != listNode) {
+        splitElement(listElement, splitTreeToNode(nextListChild, listElement));
+        insertNodeBefore(elementToInsert, listElement);
+    } else if (nextListChild || listChildNode->parentNode() != listElement) {
         // Just because listChildNode has no previousListChild doesn't mean there isn't any content
         // in listNode that comes before listChildNode, as listChildNode could have ancestors
         // between it and listNode. So, we split up to listNode before inserting the placeholder
         // where we're about to move listChildNode to.
-        if (listChildNode->parentNode() != listNode)
-            splitElement(listNode, splitTreeToNode(listChildNode, listNode).get());
-        insertNodeBefore(elementToInsert, listNode);
+        if (listChildNode->parentNode() != listElement)
+            splitElement(listElement, splitTreeToNode(listChildNode, listElement).get());
+        insertNodeBefore(elementToInsert, listElement);
     } else {
-        insertNodeAfter(elementToInsert, listNode);
+        insertNodeAfter(elementToInsert, listElement);
     }
 
     VisiblePosition insertionPoint = VisiblePosition(positionBeforeNode(placeholder.get()));
     moveParagraphs(start, end, insertionPoint, /* preserveSelection */ true, /* preserveStyle */ true, listChildNode);
 }
 
-static Element* adjacentEnclosingList(const VisiblePosition& pos, const VisiblePosition& adjacentPos, const HTMLQualifiedName& listTag)
+static HTMLElement* adjacentEnclosingList(const VisiblePosition& pos, const VisiblePosition& adjacentPos, const HTMLQualifiedName& listTag)
 {
-    Element* listNode = outermostEnclosingList(adjacentPos.deepEquivalent().deprecatedNode());
+    HTMLElement* listElement = outermostEnclosingList(adjacentPos.deepEquivalent().deprecatedNode());
 
-    if (!listNode)
+    if (!listElement)
         return 0;
 
     Element* previousCell = enclosingTableCell(pos.deepEquivalent());
     Element* currentCell = enclosingTableCell(adjacentPos.deepEquivalent());
 
-    if (!listNode->hasTagName(listTag)
-        || listNode->contains(pos.deepEquivalent().deprecatedNode())
+    if (!listElement->hasTagName(listTag)
+        || listElement->contains(pos.deepEquivalent().deprecatedNode())
         || previousCell != currentCell
-        || enclosingList(listNode) != enclosingList(pos.deepEquivalent().deprecatedNode()))
+        || enclosingList(listElement) != enclosingList(pos.deepEquivalent().deprecatedNode()))
         return 0;
 
-    return listNode;
+    return listElement;
 }
 
 PassRefPtrWillBeRawPtr<HTMLElement> InsertListCommand::listifyParagraph(const VisiblePosition& originalStart, const HTMLQualifiedName& listTag)
 {
     VisiblePosition start = startOfParagraph(originalStart, CanSkipOverEditingBoundary);
     VisiblePosition end = endOfParagraph(start, CanSkipOverEditingBoundary);
 
     if (start.isNull() || end.isNull())
         return nullptr;
 
     // Check for adjoining lists.
     RefPtrWillBeRawPtr<HTMLElement> listItemElement = createListItemElement(document());
     RefPtrWillBeRawPtr<HTMLBRElement> placeholder = createBreakElement(document());
     appendNode(placeholder, listItemElement);
 
     // Place list item into adjoining lists.
-    Element* previousList = adjacentEnclosingList(start, start.previous(CannotCrossEditingBoundary), listTag);
-    Element* nextList = adjacentEnclosingList(start, end.next(CannotCrossEditingBoundary), listTag);
+    HTMLElement* previousList = adjacentEnclosingList(start, start.previous(CannotCrossEditingBoundary), listTag);
+    HTMLElement* nextList = adjacentEnclosingList(start, end.next(CannotCrossEditingBoundary), listTag);
     RefPtrWillBeRawPtr<HTMLElement> listElement = nullptr;
     if (previousList)
         appendNode(listItemElement, previousList);
     else if (nextList)
         insertNodeAt(listItemElement, positionBeforeNode(nextList));
     else {
         // Create the list.
         listElement = createHTMLElement(document(), listTag);
         appendNode(listItemElement, listElement);
 
@@ skipping 43 matching lines @@
     return listElement;
 }
 
 void InsertListCommand::trace(Visitor* visitor)
 {
     visitor->trace(m_listElement);
     CompositeEditCommand::trace(visitor);
 }
 
 }