Use tighter typing in editing: SimplifyMarkupCommand & TextIterator

Source/core/editing/TextIterator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * 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
@@ skipping 145 matching lines @@
     return m_size;
 }
 
 // --------
 
 #if ENABLE(ASSERT)
 
 static unsigned depthCrossingShadowBoundaries(Node* node)
 {
     unsigned depth = 0;
-    for (Node* parent = node->parentOrShadowHostNode(); parent; parent = parent->parentOrShadowHostNode())
+    for (ContainerNode* parent = node->parentOrShadowHostNode(); parent; parent = parent->parentOrShadowHostNode())
         ++depth;
     return depth;
 }
 
 #endif
 
 // This function is like Range::pastLastNode, except for the fact that it can climb up out of shadow trees.
 static Node* nextInPreOrderCrossingShadowBoundaries(Node* rangeEndContainer, int rangeEndOffset)
 {
     if (!rangeEndContainer)
@@ skipping 41 matching lines @@
     // primitives, not with DOM primitives.
 
     // Push true if this node full clips its contents, or if a parent already has fully
     // clipped and this is not a node that ignores its container's clip.
     stack.push(fullyClipsContents(node) || (stack.top() && !ignoresContainerClip(node)));
 }
 
 static void setUpFullyClippedStack(BitStack& stack, Node* node)
 {
     // Put the nodes in a vector so we can iterate in reverse order.
-    WillBeHeapVector<RawPtrWillBeMember<Node>, 100> ancestry;
-    for (Node* parent = node->parentOrShadowHostNode(); parent; parent = parent->parentOrShadowHostNode())
+    WillBeHeapVector<RawPtrWillBeMember<ContainerNode>, 100> ancestry;
+    for (ContainerNode* parent = node->parentOrShadowHostNode(); parent; parent = parent->parentOrShadowHostNode())
         ancestry.append(parent);
 
     // Call pushFullyClippedState on each node starting with the earliest ancestor.
     size_t size = ancestry.size();
     for (size_t i = 0; i < size; ++i)
         pushFullyClippedState(stack, ancestry[size - i - 1]);
     pushFullyClippedState(stack, node);
 
     ASSERT(stack.size() == 1 + depthCrossingShadowBoundaries(node));
 }
@@ skipping 217 matching lines @@
                 }
                 m_iterationProgress = HandledUserAgentShadowRoot;
             }
 
             // Handle the current node according to its type.
             if (m_iterationProgress < HandledNode) {
                 bool handledNode = false;
                 if (renderer->isText() && m_node->nodeType() == Node::TEXT_NODE) { // FIXME: What about CDATA_SECTION_NODE?
                     handledNode = handleTextNode();
                 } else if (renderer && (renderer->isImage() || renderer->isWidget()
-                    || (m_node && m_node->isElementNode()
-                    && (toElement(m_node)->isFormControlElement()
-                    || isHTMLLegendElement(toElement(*m_node))
-                    || isHTMLMeterElement(toElement(*m_node))
-                    || isHTMLProgressElement(toElement(*m_node)))))) {
+                    || (m_node && m_node->isHTMLElement()
+                    && (isHTMLFormControlElement(toHTMLElement(*m_node))
+                    || isHTMLLegendElement(toHTMLElement(*m_node))
+                    || isHTMLMeterElement(toHTMLElement(*m_node))
+                    || isHTMLProgressElement(toHTMLElement(*m_node)))))) {
                     handledNode = handleReplacedElement();
                 } else {
                     handledNode = handleNonTextNode();
                 }
                 if (handledNode)
                     m_iterationProgress = HandledNode;
                 if (m_positionNode)
                     return;
             }
         }
 
         // Find a new current node to handle in depth-first manner,
         // calling exitNode() as we come back thru a parent node.
         //
         // 1. Iterate over child nodes, if we haven't done yet.
         Node* next = m_iterationProgress < HandledChildren ? m_node->firstChild() : 0;
         m_offset = 0;
         if (!next) {
             // 2. If we've already iterated children or they are not available, go to the next sibling node.
             next = m_node->nextSibling();
             if (!next) {
                 // 3. If we are at the last child, go up the node tree until we find a next sibling.
                 bool pastEnd = NodeTraversal::next(*m_node) == m_pastEndNode;
-                Node* parentNode = m_node->parentNode();
+                ContainerNode* parentNode = m_node->parentNode();
                 while (!next && parentNode) {
                     if ((pastEnd && parentNode == m_endContainer) || m_endContainer->isDescendantOf(parentNode))
                         return;
                     bool haveRenderer = m_node->renderer();
                     m_node = parentNode;
                     m_fullyClippedStack.pop();
                     parentNode = m_node->parentNode();
                     if (haveRenderer)
                         exitNode();
                     if (m_positionNode) {
@@ skipping 92 matching lines @@
     } else {
         builder.append(string(), startOffset() + position, lengthToAppend);
     }
 }
 
 bool TextIterator::handleTextNode()
 {
     if (m_fullyClippedStack.top() && !m_ignoresStyleVisibility)
         return false;
 
-    RenderText* renderer = toRenderText(m_node->renderer());
+    Text* textNode = toText(m_node);
+    RenderText* renderer = textNode->renderer();
 
-    m_lastTextNode = m_node;
+    m_lastTextNode = textNode;
     String str = renderer->text();
 
     // handle pre-formatted text
     if (!renderer->style()->collapseWhiteSpace()) {
         int runStart = m_offset;
         if (m_lastTextNodeEndedWithCollapsedSpace && hasVisibleTextNode(renderer)) {
-            emitCharacter(' ', m_node, 0, runStart, runStart);
+            emitCharacter(' ', textNode, 0, runStart, runStart);
             return false;
         }
         if (!m_handledFirstLetter && renderer->isTextFragment() && !m_offset) {
             handleTextNodeFirstLetter(toRenderTextFragment(renderer));
             if (m_firstLetterText) {
                 String firstLetter = m_firstLetterText->text();
-                emitText(m_node, m_firstLetterText, m_offset, m_offset + firstLetter.length());
+                emitText(textNode, m_firstLetterText, m_offset, m_offset + firstLetter.length());
                 m_firstLetterText = 0;
                 m_textBox = 0;
                 return false;
             }
         }
         if (renderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
             return false;
         int strLength = str.length();
-        int end = (m_node == m_endContainer) ? m_endOffset : INT_MAX;
+        int end = (textNode == m_endContainer) ? m_endOffset : INT_MAX;
         int runEnd = std::min(strLength, end);
 
         if (runStart >= runEnd)
             return true;
 
-        emitText(m_node, runStart, runEnd);
+        emitText(textNode, textNode->renderer(), runStart, runEnd);
         return true;
     }
 
     if (renderer->firstTextBox())
         m_textBox = renderer->firstTextBox();
 
     bool shouldHandleFirstLetter = !m_handledFirstLetter && renderer->isTextFragment() && !m_offset;
     if (shouldHandleFirstLetter)
         handleTextNodeFirstLetter(toRenderTextFragment(renderer));
 
@@ skipping 499 matching lines @@
     // remember information with which to construct the TextIterator::characters() and length()
     m_singleCharacterBuffer = c;
     ASSERT(m_singleCharacterBuffer);
     m_textLength = 1;
 
     // remember some iteration state
     m_lastTextNodeEndedWithCollapsedSpace = false;
     m_lastCharacter = c;
 }
 
-void TextIterator::emitText(Node* textNode, RenderObject* renderObject, int textStartOffset, int textEndOffset)
+void TextIterator::emitText(Node* textNode, RenderText* renderer, int textStartOffset, int textEndOffset)
 {
-    RenderText* renderer = toRenderText(renderObject);
     m_text = m_emitsOriginalText ? renderer->originalText() : renderer->text();
     ASSERT(!m_text.isEmpty());
     ASSERT(0 <= textStartOffset && textStartOffset < static_cast<int>(m_text.length()));
     ASSERT(0 <= textEndOffset && textEndOffset <= static_cast<int>(m_text.length()));
     ASSERT(textStartOffset <= textEndOffset);
 
     m_positionNode = textNode;
     m_positionOffsetBaseNode = nullptr;
     m_positionStartOffset = textStartOffset;
     m_positionEndOffset = textEndOffset;
     m_singleCharacterBuffer = 0;
     m_textLength = textEndOffset - textStartOffset;
     m_lastCharacter = m_text[textEndOffset - 1];
 
     m_lastTextNodeEndedWithCollapsedSpace = false;
     m_hasEmitted = true;
 }
 
-void TextIterator::emitText(Node* textNode, int textStartOffset, int textEndOffset)
-{
-    emitText(textNode, m_node->renderer(), textStartOffset, textEndOffset);
-}
-
 PassRefPtrWillBeRawPtr<Range> TextIterator::range() const
 {
     // use the current run information, if we have it
     if (m_positionNode) {
         if (m_positionOffsetBaseNode) {
             int index = m_positionOffsetBaseNode->nodeIndex();
             m_positionStartOffset += index;
             m_positionEndOffset += index;
             m_positionOffsetBaseNode = nullptr;
         }
@@ skipping 177 matching lines @@
         m_handledNode = false;
         m_handledChildren = false;
 
         if (m_positionNode)
             return;
     }
 }
 
 bool SimplifiedBackwardsTextIterator::handleTextNode()
 {
-    m_lastTextNode = m_node;
+    m_lastTextNode = toText(m_node);
 
     int startOffset;
     int offsetInNode;
     RenderText* renderer = handleFirstLetter(startOffset, offsetInNode);
     if (!renderer)
         return true;
 
     String text = renderer->text();
     if (!renderer->firstTextBox() && text.length() > 0)
         return true;
@@ skipping 827 matching lines @@
             resultEnd = collapseTo;
             return;
         }
     }
 
     CharacterIterator computeRangeIterator(inputStart, inputEnd, iteratorFlagsForFindPlainText);
     calculateCharacterSubrange(computeRangeIterator, matchStart, matchLength, resultStart, resultEnd);
 }
 
 }