WIP: prefer using EphemeralRange for SpellChecker.

Source/core/editing/spellcheck/TextCheckingHelper.cpp

Index: Source/core/editing/spellcheck/TextCheckingHelper.cpp
diff --git a/Source/core/editing/spellcheck/TextCheckingHelper.cpp b/Source/core/editing/spellcheck/TextCheckingHelper.cpp
index ede8e89051d753aef1a661c68875df45601cc79e..6afde0a6377d5d193864859aa42ff7680299f2b2 100644
--- a/Source/core/editing/spellcheck/TextCheckingHelper.cpp
+++ b/Source/core/editing/spellcheck/TextCheckingHelper.cpp
@@ -99,21 +99,17 @@ static void findMisspellings(TextCheckerClient& client, const UChar* text, int s
     }
 }
 
-void expandRangeToSentenceBoundary(Range& range)
+EphemeralRange expandRangeToSentenceBoundary(const EphemeralRange& range)
 {
-    range.setStart(startOfSentence(createVisiblePosition(range.startPosition())).deepEquivalent());
-    range.setEnd(endOfSentence(createVisiblePosition(range.endPosition())).deepEquivalent());
+    return EphemeralRange(startOfSentence(createVisiblePosition(range.startPosition())).deepEquivalent(), endOfSentence(createVisiblePosition(range.endPosition())).deepEquivalent());
 }
 
-static PassRefPtrWillBeRawPtr<Range> expandToParagraphBoundary(PassRefPtrWillBeRawPtr<Range> range)
+static EphemeralRange expandToParagraphBoundary(const EphemeralRange& range)
 {
-    RefPtrWillBeRawPtr<Range> paragraphRange = range->cloneRange();
-    paragraphRange->setStart(startOfParagraph(createVisiblePosition(range->startPosition())).deepEquivalent());
-    paragraphRange->setEnd(endOfParagraph(createVisiblePosition(range->endPosition())).deepEquivalent());
-    return paragraphRange;
+    return EphemeralRange(startOfParagraph(createVisiblePosition(range.startPosition())).deepEquivalent(), endOfParagraph(createVisiblePosition(range.endPosition())).deepEquivalent());
 }
 
-TextCheckingParagraph::TextCheckingParagraph(PassRefPtrWillBeRawPtr<Range> checkingRange)
+TextCheckingParagraph::TextCheckingParagraph(const EphemeralRange checkingRange)
     : m_checkingRange(checkingRange)
     , m_checkingStart(-1)
     , m_checkingEnd(-1)
@@ -121,7 +117,7 @@ TextCheckingParagraph::TextCheckingParagraph(PassRefPtrWillBeRawPtr<Range> check
 {
 }
 
-TextCheckingParagraph::TextCheckingParagraph(PassRefPtrWillBeRawPtr<Range> checkingRange, PassRefPtrWillBeRawPtr<Range> paragraphRange)
+TextCheckingParagraph::TextCheckingParagraph(const EphemeralRange checkingRange, const EphemeralRange paragraphRange)
     : m_checkingRange(checkingRange)
     , m_paragraphRange(paragraphRange)
     , m_checkingStart(-1)
@@ -130,52 +126,68 @@ TextCheckingParagraph::TextCheckingParagraph(PassRefPtrWillBeRawPtr<Range> check
 {
 }
 
+TextCheckingParagraph::TextCheckingParagraph(PassRefPtrWillBeRawPtr<Range> checkingRange, PassRefPtrWillBeRawPtr<Range> paragraphRange)
+    : m_checkingRange(checkingRange.get())
+    , m_paragraphRange(paragraphRange.get())
+    , m_checkingStart(-1)
+    , m_checkingEnd(-1)
+    , m_checkingLength(-1)
+{
+}
+
 TextCheckingParagraph::~TextCheckingParagraph()
 {
 }
 
 void TextCheckingParagraph::expandRangeToNextEnd()
 {
-    ASSERT(m_checkingRange);
-    paragraphRange()->setEnd(endOfParagraph(startOfNextParagraph(createVisiblePosition(paragraphRange()->startPosition()))).deepEquivalent());
+    ASSERT(m_checkingRange.isNotNull());
+    setParagraphRange(EphemeralRange(paragraphRange().startPosition(), endOfParagraph(startOfNextParagraph(createVisiblePosition(paragraphRange().startPosition()))).deepEquivalent()));
     invalidateParagraphRangeValues();
 }
 
 void TextCheckingParagraph::invalidateParagraphRangeValues()
 {
     m_checkingStart = m_checkingEnd = -1;
-    m_offsetAsRange = nullptr;
+    m_offsetAsRange = EphemeralRange();
     m_text = String();
 }
 
 int TextCheckingParagraph::rangeLength() const
 {
-    ASSERT(m_checkingRange);
-    return TextIterator::rangeLength(paragraphRange()->startPosition(), paragraphRange()->endPosition());
+    ASSERT(m_checkingRange.isNotNull());
+    return TextIterator::rangeLength(paragraphRange().startPosition(), paragraphRange().endPosition());
 }
 
-PassRefPtrWillBeRawPtr<Range> TextCheckingParagraph::paragraphRange() const
+EphemeralRange TextCheckingParagraph::paragraphRange() const
 {
-    ASSERT(m_checkingRange);
-    if (!m_paragraphRange)
+    ASSERT(m_checkingRange.isNotNull());
+    if (m_paragraphRange.isNull())
         m_paragraphRange = expandToParagraphBoundary(checkingRange());
     return m_paragraphRange;
 }
 
-PassRefPtrWillBeRawPtr<Range> TextCheckingParagraph::subrange(int characterOffset, int characterCount) const
+void TextCheckingParagraph::setParagraphRange(const EphemeralRange& range)
+{
+    m_paragraphRange = range;
+}
+
+EphemeralRange TextCheckingParagraph::subrange(int characterOffset, int characterCount) const
 {
-    ASSERT(m_checkingRange);
-    return createRange(calculateCharacterSubrange(EphemeralRange(paragraphRange().get()), characterOffset, characterCount));
+    ASSERT(m_checkingRange.isNotNull());
+    return calculateCharacterSubrange(paragraphRange(), characterOffset, characterCount);
 }
 
 int TextCheckingParagraph::offsetTo(const Position& position, ExceptionState& exceptionState) const
 {
-    ASSERT(m_checkingRange);
-    RefPtrWillBeRawPtr<Range> range = offsetAsRange()->cloneRange();
+    ASSERT(m_checkingRange.isNotNull());
+    RefPtrWillBeRawPtr<Range> range = createRange(offsetAsRange());

[yosin_UTC9, 2015/09/10 01:58:39]

Let's avoid to use |Range|.
This could be:

return TextItertaor::rangeLength(m_offsetAsRange.startPosition(), position);

[sof, 2015/09/10 06:12:10]

Don't we need to account for the exception-raising possibilities of
Range::setEnd() ?

[yosin_UTC9, 2015/09/10 06:37:03]

Since caller is SpellChecker::markAndReplaceFor()
  selectionOffset = paragraph.offsetTo(caretPosition, ASSERT_NO_EXCEPTION);

Range::setEnd() should not raise an exception.

[sof, 2015/09/10 06:42:27]

But this is a public function taking an ExceptionState&, so how can you insist
on that assumption? Do you want to drop that extra arg?

[yosin_UTC9, 2015/09/10 07:01:46]

Yes, please. We don't want to have V8 thing in spell check module.

[sof, 2015/09/10 07:16:27]

Good, let's simplify that away.

     range->setEnd(position.computeContainerNode(), position.computeOffsetInContainerNode(), exceptionState);
     if (exceptionState.hadException())
         return 0;
-    return TextIterator::rangeLength(range->startPosition(), range->endPosition());
+    int offset = TextIterator::rangeLength(range->startPosition(), range->endPosition());
+    range->dispose();
+    return offset;
 }
 
 bool TextCheckingParagraph::isEmpty() const
@@ -185,44 +197,44 @@ bool TextCheckingParagraph::isEmpty() const
     return isRangeEmpty() || isTextEmpty();
 }
 
-PassRefPtrWillBeRawPtr<Range> TextCheckingParagraph::offsetAsRange() const
+EphemeralRange TextCheckingParagraph::offsetAsRange() const
 {
-    ASSERT(m_checkingRange);
-    if (!m_offsetAsRange)
-        m_offsetAsRange = Range::create(paragraphRange()->startContainer()->document(), paragraphRange()->startPosition(), checkingRange()->startPosition());
+    ASSERT(m_checkingRange.isNotNull());
+    if (m_offsetAsRange.isNull())
+        m_offsetAsRange = EphemeralRange(paragraphRange().startPosition(), checkingRange().startPosition());
 
     return m_offsetAsRange;
 }
 
 const String& TextCheckingParagraph::text() const
 {
-    ASSERT(m_checkingRange);
+    ASSERT(m_checkingRange.isNotNull());
     if (m_text.isEmpty())
-        m_text = plainText(EphemeralRange(paragraphRange().get()));
+        m_text = plainText(paragraphRange());
     return m_text;
 }
 
 int TextCheckingParagraph::checkingStart() const
 {
-    ASSERT(m_checkingRange);
+    ASSERT(m_checkingRange.isNotNull());
     if (m_checkingStart == -1)
-        m_checkingStart = TextIterator::rangeLength(offsetAsRange()->startPosition(), offsetAsRange()->endPosition());
+        m_checkingStart = TextIterator::rangeLength(offsetAsRange().startPosition(), offsetAsRange().endPosition());
     return m_checkingStart;
 }
 
 int TextCheckingParagraph::checkingEnd() const
 {
-    ASSERT(m_checkingRange);
+    ASSERT(m_checkingRange.isNotNull());
     if (m_checkingEnd == -1)
-        m_checkingEnd = checkingStart() + TextIterator::rangeLength(checkingRange()->startPosition(), checkingRange()->endPosition());
+        m_checkingEnd = checkingStart() + TextIterator::rangeLength(checkingRange().startPosition(), checkingRange().endPosition());
     return m_checkingEnd;
 }
 
 int TextCheckingParagraph::checkingLength() const
 {
-    ASSERT(m_checkingRange);
+    ASSERT(m_checkingRange.isNotNull());
     if (-1 == m_checkingLength)
-        m_checkingLength = TextIterator::rangeLength(checkingRange()->startPosition(), checkingRange()->endPosition());
+        m_checkingLength = TextIterator::rangeLength(checkingRange().startPosition(), checkingRange().endPosition());
     return m_checkingLength;
 }
 
@@ -460,7 +472,7 @@ String TextCheckingHelper::findFirstBadGrammar(GrammarDetail& outGrammarDetail,
     // Expand the search range to encompass entire paragraphs, since grammar checking needs that much context.
     // Determine the character offset from the start of the paragraph to the start of the original search range,
     // since we will want to ignore results in this area.
-    TextCheckingParagraph paragraph(Range::create(m_start.computeContainerNode()->document(), m_start, m_end));
+    TextCheckingParagraph paragraph(EphemeralRange(m_start, m_end));
 
     // Start checking from beginning of paragraph, but skip past results that occur before the start of the original search range.
     int startOffset = 0;