Avoid more temporary ranges in connection with various TextIterators.

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 1169 matching lines @@
     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;
 }
 
-PassRefPtrWillBeRawPtr<Range> TextIterator::range() const
+PassRefPtrWillBeRawPtr<Range> TextIterator::createRange() const
 {
     // use the current run information, if we have it
     if (m_positionNode) {
         flushPositionOffsets();
         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;
 }
 
+Document* TextIterator::ownerDocument() const
+{
+    if (m_positionNode)
+        return &m_positionNode->document();
+    if (m_endContainer)
+        return &m_endContainer->document();
+    return 0;
+}
+
 Node* TextIterator::node() const
 {
     if (m_positionNode || m_endContainer) {
         Node* node = startContainer();
         if (node->offsetInCharacters())
             return node;
         return NodeTraversal::childAt(*node, startOffset());
     }
     return 0;
 }
@@ skipping 20 matching lines @@
 
 Node* TextIterator::startContainer() const
 {
     if (m_positionNode) {
         return m_positionNode;
     }
     ASSERT(m_endContainer);
     return m_endContainer;
 }
 
+Node* TextIterator::endContainer() const
+{
+    return startContainer();
+}
+
 Position TextIterator::startPosition() const
 {
     return createLegacyEditingPosition(startContainer(), startOffset());
 }
 
 Position TextIterator::endPosition() const
 {
-    return createLegacyEditingPosition(startContainer(), endOffset());
+    return createLegacyEditingPosition(endContainer(), endOffset());
 }
 
 // --------
 
 SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator(const Range* r, TextIteratorBehaviorFlags behavior)
     : m_node(nullptr)
     , m_offset(0)
     , m_handledNode(false)
     , m_handledChildren(false)
     , m_startNode(nullptr)
@@ skipping 305 matching lines @@
 {
     if (!next)
         return false;
     m_havePassedStartNode |= m_node == m_startNode;
     if (m_havePassedStartNode)
         return false;
     m_node = next;
     return true;
 }
 
-PassRefPtrWillBeRawPtr<Range> SimplifiedBackwardsTextIterator::range() const
-{
-    if (m_positionNode)
-        return Range::create(m_positionNode->document(), m_positionNode, m_positionStartOffset, m_positionNode, m_positionEndOffset);
-
-    return Range::create(m_startNode->document(), m_startNode, m_startOffset, m_startNode, m_startOffset);
-}
-
 Node* SimplifiedBackwardsTextIterator::startContainer() const
 {
     if (m_positionNode)
         return m_positionNode;
     return m_startNode;
 }
 
 int SimplifiedBackwardsTextIterator::endOffset() const
 {
     if (m_positionNode)
         return m_positionEndOffset;
     return m_startOffset;
 }
 
 Position SimplifiedBackwardsTextIterator::startPosition() const
 {
     if (m_positionNode)
         return createLegacyEditingPosition(m_positionNode, m_positionStartOffset);
     return createLegacyEditingPosition(m_startNode, m_startOffset);
 }
 
+Position SimplifiedBackwardsTextIterator::endPosition() const
+{
+    if (m_positionNode)
+        return createLegacyEditingPosition(m_positionNode, m_positionEndOffset);
+    return createLegacyEditingPosition(m_startNode, m_startOffset);
+}
+
 // --------
 
 CharacterIterator::CharacterIterator(const Range* range, TextIteratorBehaviorFlags behavior)
     : m_offset(0)
     , m_runOffset(0)
     , m_atBreak(true)
     , m_textIterator(range, behavior)
 {
     initialize();
 }
 
 CharacterIterator::CharacterIterator(const Position& start, const Position& end, TextIteratorBehaviorFlags behavior)
     : m_offset(0)
     , m_runOffset(0)
     , m_atBreak(true)
     , m_textIterator(start, end, behavior)
 {
     initialize();
 }
 
 void CharacterIterator::initialize()
 {
     while (!atEnd() && !m_textIterator.length())
         m_textIterator.advance();
 }
 
-PassRefPtrWillBeRawPtr<Range> CharacterIterator::range() const
+PassRefPtrWillBeRawPtr<Range> CharacterIterator::createRange() const
 {
-    RefPtrWillBeRawPtr<Range> r = m_textIterator.range();
+    RefPtrWillBeRawPtr<Range> r = m_textIterator.createRange();
     if (!m_textIterator.atEnd()) {
         if (m_textIterator.length() <= 1) {
             ASSERT(!m_runOffset);
         } else {
             Node* n = r->startContainer();
             ASSERT(n == r->endContainer());
             int offset = r->startOffset() + m_runOffset;
             r->setStart(n, offset, ASSERT_NO_EXCEPTION);
             r->setEnd(n, offset + 1, ASSERT_NO_EXCEPTION);
         }
     }
     return r.release();
 }
 
+Document* CharacterIterator::ownerDocument() const
+{
+    return m_textIterator.ownerDocument();
+}
+
 Node* CharacterIterator::startContainer() const
 {
     return m_textIterator.startContainer();
 }
 
+Node* CharacterIterator::endContainer() const
+{
+    return m_textIterator.endContainer();
+}
+
 int CharacterIterator::startOffset() const
 {
     if (!m_textIterator.atEnd()) {
         if (m_textIterator.length() > 1)
             return m_textIterator.startOffset() + m_runOffset;
         ASSERT(!m_runOffset);
     }
     return m_textIterator.startOffset();
 }
 
+int CharacterIterator::endOffset() const
+{
+    if (!m_textIterator.atEnd()) {
+        if (m_textIterator.length() > 1)
+            return m_textIterator.startOffset() + m_runOffset + 1;
+        ASSERT(!m_runOffset);
+    }
+    return m_textIterator.endOffset();
+}
+
 Position CharacterIterator::startPosition() const
 {
     if (!m_textIterator.atEnd()) {
         if (m_textIterator.length() > 1) {
             Node* n = m_textIterator.startContainer();
             int offset = m_textIterator.startOffset() + m_runOffset;
             return createLegacyEditingPosition(n, offset);
         }
         ASSERT(!m_runOffset);
     }
@@ skipping 81 matching lines @@
 BackwardsCharacterIterator::BackwardsCharacterIterator(const Position& start, const Position& end, TextIteratorBehaviorFlags behavior)
     : m_offset(0)
     , m_runOffset(0)
     , m_atBreak(true)
     , m_textIterator(start, end, behavior)
 {
     while (!atEnd() && !m_textIterator.length())
         m_textIterator.advance();
 }
 
-PassRefPtrWillBeRawPtr<Range> BackwardsCharacterIterator::range() const
-{
-    RefPtrWillBeRawPtr<Range> r = m_textIterator.range();
-    if (!m_textIterator.atEnd()) {
-        if (m_textIterator.length() <= 1) {
-            ASSERT(!m_runOffset);
-        } else {
-            Node* n = r->startContainer();
-            ASSERT(n == r->endContainer());
-            int offset = r->endOffset() - m_runOffset;
-            r->setStart(n, offset - 1, ASSERT_NO_EXCEPTION);
-            r->setEnd(n, offset, ASSERT_NO_EXCEPTION);
-        }
-    }
-    return r.release();
-}
-
 Position BackwardsCharacterIterator::endPosition() const
 {
-    Node* n = m_textIterator.startContainer();
     if (!m_textIterator.atEnd()) {
-        if (m_textIterator.length() > 1)
+        if (m_textIterator.length() > 1) {
+            Node* n = m_textIterator.startContainer();
             return createLegacyEditingPosition(n, m_textIterator.endOffset() - m_runOffset);
+        }
         ASSERT(!m_runOffset);
     }
-    return createLegacyEditingPosition(n, m_textIterator.endOffset());
+    return m_textIterator.endPosition();
 }
 
 void BackwardsCharacterIterator::advance(int count)
 {
     if (count <= 0) {
         ASSERT(!count);
         return;
     }
 
     m_atBreak = false;
@@ skipping 483 matching lines @@
 {
     matchStart = 0;
     size_t matchLength = 0;
 
     if (!isValidUTF16(target))
         return 0;
 
     SearchBuffer buffer(target, options);
 
     if (buffer.needsMoreContext()) {
-        RefPtrWillBeRawPtr<Range> startRange = it.range();
-        RefPtrWillBeRawPtr<Range> beforeStartRange = startRange->ownerDocument().createRange();
-        beforeStartRange->setEnd(startRange->startContainer(), startRange->startOffset(), IGNORE_EXCEPTION);
+        RefPtrWillBeRawPtr<Range> beforeStartRange = it.ownerDocument()->createRange();
+        beforeStartRange->setEnd(it.startContainer(), it.startOffset(), IGNORE_EXCEPTION);
         for (SimplifiedBackwardsTextIterator backwardsIterator(beforeStartRange.get()); !backwardsIterator.atEnd(); backwardsIterator.advance()) {
             Vector<UChar, 1024> characters;
             backwardsIterator.prependTextTo(characters);
             buffer.prependContext(characters.data(), characters.size());
             if (!buffer.needsMoreContext())
                 break;
         }
     }
 
     while (!it.atEnd()) {
@@ skipping 65 matching lines @@
             resultEnd = collapseTo;
             return;
         }
     }
 
     CharacterIterator computeRangeIterator(inputStart, inputEnd, iteratorFlagsForFindPlainText);
     calculateCharacterSubrange(computeRangeIterator, matchStart, matchLength, resultStart, resultEnd);
 }
 
 }