Use tighter typing in editing: DeleteSelectionCommand

Source/core/editing/DeleteSelectionCommand.cpp

 /*
  * Copyright (C) 2005 Apple Computer, 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 20 matching lines @@
 #include "core/dom/Element.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingBoundary.h"
 #include "core/editing/Editor.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLInputElement.h"
+#include "core/html/HTMLStyleElement.h"
+#include "core/html/HTMLTableRowElement.h"
 #include "core/rendering/RenderTableCell.h"
 #include "core/rendering/RenderText.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static bool isTableCellEmpty(Node* cell)
 {
     ASSERT(isTableCell(cell));
@@ skipping 120 matching lines @@
         end = lastEditablePositionBeforePositionInRoot(end, highestEditableRoot(start));
 
     m_upstreamStart = start.upstream();
     m_downstreamStart = start.downstream();
     m_upstreamEnd = end.upstream();
     m_downstreamEnd = end.downstream();
 
     m_startRoot = editableRootForPosition(start);
     m_endRoot = editableRootForPosition(end);
 
-    m_startTableRow = enclosingNodeOfType(start, &isHTMLTableRowElement);
-    m_endTableRow = enclosingNodeOfType(end, &isHTMLTableRowElement);
+    m_startTableRow = toHTMLTableRowElement(enclosingNodeOfType(start, &isHTMLTableRowElement));
+    m_endTableRow = toHTMLTableRowElement(enclosingNodeOfType(end, &isHTMLTableRowElement));
 
     // Don't move content out of a table cell.
     // If the cell is non-editable, enclosingNodeOfType won't return it by default, so
     // tell that function that we don't care if it returns non-editable nodes.
     Node* startCell = enclosingNodeOfType(m_upstreamStart, &isTableCell, CanCrossEditingBoundary);
     Node* endCell = enclosingNodeOfType(m_downstreamEnd, &isTableCell, CanCrossEditingBoundary);
     // FIXME: This isn't right.  A borderless table with two rows and a single column would appear as two paragraphs.
     if (endCell && endCell != startCell)
         m_mergeBlocksAfterDelete = false;
 
@@ skipping 200 matching lines @@
     }
 
     // FIXME: Update the endpoints of the range being deleted.
     updatePositionForNodeRemoval(m_endingPosition, *node);
     updatePositionForNodeRemoval(m_leadingWhitespace, *node);
     updatePositionForNodeRemoval(m_trailingWhitespace, *node);
 
     CompositeEditCommand::removeNode(node, shouldAssumeContentIsAlwaysEditable);
 }
 
-static void updatePositionForTextRemoval(Node* node, int offset, int count, Position& position)
+static void updatePositionForTextRemoval(Text* node, int offset, int count, Position& position)
 {
     if (position.anchorType() != Position::PositionIsOffsetInAnchor || position.containerNode() != node)
         return;
 
     if (position.offsetInContainerNode() > offset + count)
         position.moveToOffset(position.offsetInContainerNode() - count);
     else if (position.offsetInContainerNode() > offset)
         position.moveToOffset(offset);
 }
 
 void DeleteSelectionCommand::deleteTextFromNode(PassRefPtrWillBeRawPtr<Text> node, unsigned offset, unsigned count)
 {
     // FIXME: Update the endpoints of the range being deleted.
     updatePositionForTextRemoval(node.get(), offset, count, m_endingPosition);
     updatePositionForTextRemoval(node.get(), offset, count, m_leadingWhitespace);
     updatePositionForTextRemoval(node.get(), offset, count, m_trailingWhitespace);
     updatePositionForTextRemoval(node.get(), offset, count, m_downstreamEnd);
 
     CompositeEditCommand::deleteTextFromNode(node, offset, count);
 }
 
 void DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss()
 {
     RefPtrWillBeRawPtr<Range> range = m_selectionToDelete.toNormalizedRange();
     RefPtrWillBeRawPtr<Node> node = range->firstNode();
     while (node && node != range->pastLastNode()) {
         RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::next(*node);
-        if ((isHTMLStyleElement(*node) && !(toElement(node)->hasAttribute(scopedAttr))) || isHTMLLinkElement(*node)) {
+        if ((isHTMLStyleElement(*node) && !toHTMLStyleElement(node)->hasAttribute(scopedAttr))
+            || isHTMLLinkElement(*node)) {
             nextNode = NodeTraversal::nextSkippingChildren(*node);
-            RefPtrWillBeRawPtr<ContainerNode> rootEditableElement = node->rootEditableElement();
+            RefPtrWillBeRawPtr<Element> rootEditableElement = node->rootEditableElement();
             if (rootEditableElement.get()) {
                 removeNode(node);
                 appendNode(node, rootEditableElement);
             }
         }
         node = nextNode;
     }
 }
 
 void DeleteSelectionCommand::handleGeneralDelete()
@@ skipping 307 matching lines @@
     m_downstreamEnd.clear();
     m_endingPosition.clear();
     m_leadingWhitespace.clear();
     m_trailingWhitespace.clear();
 }
 
 // This method removes div elements with no attributes that have only one child or no children at all.
 void DeleteSelectionCommand::removeRedundantBlocks()
 {
     Node* node = m_endingPosition.containerNode();
-    Node* rootNode = node->rootEditableElement();
+    Element* rootElement = node->rootEditableElement();
 
-    while (node != rootNode) {
+    while (node != rootElement) {
         if (isRemovableBlock(node)) {
             if (node == m_endingPosition.anchorNode())
                 updatePositionForNodeRemovalPreservingChildren(m_endingPosition, *node);
 
             CompositeEditCommand::removeNodePreservingChildren(node);
             node = m_endingPosition.anchorNode();
         } else
             node = node->parentNode();
     }
 }
@@ skipping 112 matching lines @@
     visitor->trace(m_deleteIntoBlockquoteStyle);
     visitor->trace(m_startRoot);
     visitor->trace(m_endRoot);
     visitor->trace(m_startTableRow);
     visitor->trace(m_endTableRow);
     visitor->trace(m_temporaryPlaceholder);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink