Oilpan: add Element/Node Member fields to stack allocated objects.

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 223 matching lines @@
     for (size_t i = 0; i < size; ++i)
         pushFullyClippedState(stack, ancestry[size - i - 1]);
     pushFullyClippedState(stack, node);
 
     ASSERT(stack.size() == 1 + depthCrossingShadowBoundaries(node));
 }
 
 // --------
 
 TextIterator::TextIterator(const Range* range, TextIteratorBehaviorFlags behavior)
-    : m_startContainer(0)
+    : m_startContainer(nullptr)
     , m_startOffset(0)
-    , m_endContainer(0)
+    , m_endContainer(nullptr)
     , m_endOffset(0)
-    , m_positionNode(0)
+    , m_positionNode(nullptr)
     , m_textLength(0)
     , m_needsAnotherNewline(false)
     , m_textBox(0)
     , m_remainingTextBox(0)
     , m_firstLetterText(0)
-    , m_lastTextNode(0)
+    , m_lastTextNode(nullptr)
     , m_lastTextNodeEndedWithCollapsedSpace(false)
     , m_lastCharacter(0)
     , m_sortedTextBoxesPosition(0)
     , m_hasEmitted(false)
     , m_emitsCharactersBetweenAllVisiblePositions(behavior & TextIteratorEmitsCharactersBetweenAllVisiblePositions)
     , m_entersTextControls(behavior & TextIteratorEntersTextControls)
     , m_emitsOriginalText(behavior & TextIteratorEmitsOriginalText)
     , m_handledFirstLetter(false)
     , m_ignoresStyleVisibility(behavior & TextIteratorIgnoresStyleVisibility)
     , m_stopsOnFormControls(behavior & TextIteratorStopsOnFormControls)
     , m_shouldStop(false)
     , m_emitsImageAltText(behavior & TextIteratorEmitsImageAltText)
     , m_entersAuthorShadowRoots(behavior & TextIteratorEntersAuthorShadowRoots)
 {
     if (range)
         initialize(range->startPosition(), range->endPosition());
 }
 
 TextIterator::TextIterator(const Position& start, const Position& end, TextIteratorBehaviorFlags behavior)
-    : m_startContainer(0)
+    : m_startContainer(nullptr)
     , m_startOffset(0)
-    , m_endContainer(0)
+    , m_endContainer(nullptr)
     , m_endOffset(0)
-    , m_positionNode(0)
+    , m_positionNode(nullptr)
     , m_textLength(0)
     , m_needsAnotherNewline(false)
     , m_textBox(0)
     , m_remainingTextBox(0)
     , m_firstLetterText(0)
-    , m_lastTextNode(0)
+    , m_lastTextNode(nullptr)
     , m_lastTextNodeEndedWithCollapsedSpace(false)
     , m_lastCharacter(0)
     , m_sortedTextBoxesPosition(0)
     , m_hasEmitted(false)
     , m_emitsCharactersBetweenAllVisiblePositions(behavior & TextIteratorEmitsCharactersBetweenAllVisiblePositions)
     , m_entersTextControls(behavior & TextIteratorEntersTextControls)
     , m_emitsOriginalText(behavior & TextIteratorEmitsOriginalText)
     , m_handledFirstLetter(false)
     , m_ignoresStyleVisibility(behavior & TextIteratorIgnoresStyleVisibility)
     , m_stopsOnFormControls(behavior & TextIteratorStopsOnFormControls)
@@ skipping 59 matching lines @@
 TextIterator::~TextIterator()
 {
 }
 
 void TextIterator::advance()
 {
     if (m_shouldStop)
         return;
 
     // reset the run information
-    m_positionNode = 0;
+    m_positionNode = nullptr;
     m_textLength = 0;
 
     // handle remembered node that needed a newline after the text node's newline
     if (m_needsAnotherNewline) {
         // Emit the extra newline, and position it *inside* m_node, after m_node's
         // contents, in case it's a block, in the same way that we position the first
         // newline. The range for the emitted newline should start where the line
         // break begins.
         // FIXME: It would be cleaner if we emitted two newlines during the last
         // iteration, instead of using m_needsAnotherNewline.
-        Node* baseNode = m_node->lastChild() ? m_node->lastChild() : m_node;
+        Node* baseNode = m_node->lastChild() ? m_node->lastChild() : m_node.get();
         emitCharacter('\n', baseNode->parentNode(), baseNode, 1, 1);
         m_needsAnotherNewline = false;
         return;
     }
 
     if (!m_textBox && m_remainingTextBox) {
         m_textBox = m_remainingTextBox;
         m_remainingTextBox = 0;
         m_firstLetterText = 0;
         m_offset = 0;
     }
     // handle remembered text box
     if (m_textBox) {
         handleTextBox();
         if (m_positionNode)
             return;
     }
 
     while (m_node && (m_node != m_pastEndNode || m_shadowDepth > 0)) {
         if (!m_shouldStop && m_stopsOnFormControls && HTMLFormControlElement::enclosingFormControlElement(m_node))
             m_shouldStop = true;
 
         // if the range ends at offset 0 of an element, represent the
         // position, but not the content, of that element e.g. if the
         // node is a blockflow element, emit a newline that
         // precedes the element
         if (m_node == m_endContainer && !m_endOffset) {
             representNodeOffsetZero();
-            m_node = 0;
+            m_node = nullptr;
             return;
         }
 
         RenderObject* renderer = m_node->renderer();
         if (!renderer) {
             if (m_node->isShadowRoot()) {
                 // A shadow root doesn't have a renderer, but we want to visit children anyway.
                 m_iterationProgress = m_iterationProgress < HandledNode ? HandledNode : m_iterationProgress;
             } else {
                 m_iterationProgress = HandledChildren;
@@ skipping 659 matching lines @@
     // prevent emitting a newline when exiting a collapsed block at beginning of the range
     // FIXME: !m_hasEmitted does not necessarily mean there was a collapsed block... it could
     // have been an hr (e.g.). Also, a collapsed block could have height (e.g. a table) and
     // therefore look like a blank line.
     if (!m_hasEmitted)
         return;
 
     // Emit with a position *inside* m_node, after m_node's contents, in
     // case it is a block, because the run should start where the
     // emitted character is positioned visually.
-    Node* baseNode = m_node->lastChild() ? m_node->lastChild() : m_node;
+    Node* baseNode = m_node->lastChild() ? m_node->lastChild() : m_node.get();
     // FIXME: This shouldn't require the m_lastTextNode to be true, but we can't change that without making
     // the logic in _web_attributedStringFromRange match. We'll get that for free when we switch to use
     // TextIterator in _web_attributedStringFromRange.
     // See <rdar://problem/5428427> for an example of how this mismatch will cause problems.
     if (m_lastTextNode && shouldEmitNewlineAfterNode(*m_node)) {
         // use extra newline to represent margin bottom, as needed
         bool addNewline = shouldEmitExtraNewlineForNode(m_node);
 
         // FIXME: We need to emit a '\n' as we leave an empty block(s) that
         // contain a VisiblePosition when doing selection preservation.
@@ skipping 38 matching lines @@
 void TextIterator::emitText(Node* textNode, RenderObject* renderObject, 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 = 0;
+    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 = 0;
+            m_positionOffsetBaseNode = nullptr;
         }
         return Range::create(m_positionNode->document(), m_positionNode, m_positionStartOffset, m_positionNode, m_positionEndOffset);
     }
 
     // otherwise, return the end of the overall range we were given
     if (m_endContainer)
         return Range::create(m_endContainer->document(), m_endContainer, m_endOffset, m_endContainer, m_endOffset);
 
     return nullptr;
 }
 
 Node* TextIterator::node() const
 {
     RefPtrWillBeRawPtr<Range> textRange = range();
     if (!textRange)
         return 0;
 
     Node* node = textRange->startContainer();
     if (!node)
         return 0;
     if (node->offsetInCharacters())
         return node;
 
     return node->traverseToChildAt(textRange->startOffset());
 }
 
 // --------
 
 SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator(const Range* r, TextIteratorBehaviorFlags behavior)
-    : m_node(0)
+    : m_node(nullptr)
     , m_offset(0)
     , m_handledNode(false)
     , m_handledChildren(false)
-    , m_startNode(0)
+    , m_startNode(nullptr)
     , m_startOffset(0)
-    , m_endNode(0)
+    , m_endNode(nullptr)
     , m_endOffset(0)
-    , m_positionNode(0)
+    , m_positionNode(nullptr)
     , m_positionStartOffset(0)
     , m_positionEndOffset(0)
     , m_textOffset(0)
     , m_textLength(0)
-    , m_lastTextNode(0)
+    , m_lastTextNode(nullptr)
     , m_lastCharacter(0)
     , m_singleCharacterBuffer(0)
     , m_havePassedStartNode(false)
     , m_shouldHandleFirstLetter(false)
     , m_stopsOnFormControls(behavior & TextIteratorStopsOnFormControls)
     , m_shouldStop(false)
     , m_emitsOriginalText(false)
 {
     ASSERT(behavior == TextIteratorDefaultBehavior || behavior == TextIteratorStopsOnFormControls);
 
@@ skipping 33 matching lines @@
     m_startNode = startNode;
     m_startOffset = startOffset;
     m_endNode = endNode;
     m_endOffset = endOffset;
 
 #ifndef NDEBUG
     // Need this just because of the assert.
     m_positionNode = endNode;
 #endif
 
-    m_lastTextNode = 0;
+    m_lastTextNode = nullptr;
     m_lastCharacter = '\n';
 
     m_havePassedStartNode = false;
 
     advance();
 }
 
 void SimplifiedBackwardsTextIterator::advance()
 {
     ASSERT(m_positionNode);
 
     if (m_shouldStop)
         return;
 
     if (m_stopsOnFormControls && HTMLFormControlElement::enclosingFormControlElement(m_node)) {
         m_shouldStop = true;
         return;
     }
 
-    m_positionNode = 0;
+    m_positionNode = nullptr;
     m_textLength = 0;
 
     while (m_node && !m_havePassedStartNode) {
         // Don't handle node if we start iterating at [node, 0].
         if (!m_handledNode && !(m_node == m_endNode && !m_endOffset)) {
             RenderObject* renderer = m_node->renderer();
             if (renderer && renderer->isText() && m_node->nodeType() == Node::TEXT_NODE) {
                 // FIXME: What about CDATA_SECTION_NODE?
                 if (renderer->style()->visibility() == VISIBLE && m_offset > 0)
                     m_handledNode = handleTextNode();
@@ skipping 35 matching lines @@
                     m_handledNode = true;
                     m_handledChildren = true;
                     return;
                 }
             }
 
             m_fullyClippedStack.pop();
             if (advanceRespectingRange(m_node->previousSibling()))
                 pushFullyClippedState(m_fullyClippedStack, m_node);
             else
-                m_node = 0;
+                m_node = nullptr;
         }
 
         // For the purpose of word boundary detection,
         // we should iterate all visible text and trailing (collapsed) whitespaces.
         m_offset = m_node ? maxOffsetIncludingCollapsedSpaces(m_node) : 0;
         m_handledNode = false;
         m_handledChildren = false;
 
         if (m_positionNode)
             return;
@@ skipping 844 matching lines @@
             resultEnd = collapseTo;
             return;
         }
     }
 
     CharacterIterator computeRangeIterator(inputStart, inputEnd, iteratorFlagsForFindPlainText);
     calculateCharacterSubrange(computeRangeIterator, matchStart, matchLength, resultStart, resultEnd);
 }
 
 }