WIP: prefer using EphemeralRange for SpellChecker.

Source/core/editing/spellcheck/TextCheckingHelper.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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 81 matching lines @@
             misspelling.location = start + wordStart + misspellingLocation;
             misspelling.length = misspellingLength;
             misspelling.replacement = client.getAutoCorrectSuggestionForMisspelledWord(String(text + misspelling.location, misspelling.length));
             results.append(misspelling);
         }
 
         wordStart = wordEnd;
     }
 }
 
-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)
     , m_checkingLength(-1)
 {
 }
 
-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)
     , m_checkingEnd(-1)
     , m_checkingLength(-1)
 {
 }
 
+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)
 {
-    ASSERT(m_checkingRange);
-    return createRange(calculateCharacterSubrange(EphemeralRange(paragraphRange().get()), characterOffset, characterCount));
+    m_paragraphRange = range;
+}
+
+EphemeralRange TextCheckingParagraph::subrange(int characterOffset, int characterCount) const
+{
+    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
 {
     // Both predicates should have same result, but we check both just for sure.
     // We need to investigate to remove this redundancy.
     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;
 }
 
 TextCheckingHelper::TextCheckingHelper(SpellCheckerClient& client, const Position& start, const Position& end)
     : m_client(&client)
     , m_start(start)
     , m_end(end)
 {
 }
 
@@ skipping 217 matching lines @@
     outGrammarDetail.length = 0;
     outGrammarDetail.guesses.clear();
     outGrammarDetail.userDescription = "";
     outGrammarPhraseOffset = 0;
 
     String firstBadGrammarPhrase;
 
     // 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;
     while (startOffset < paragraph.checkingEnd()) {
         Vector<GrammarDetail> grammarDetails;
         int badGrammarPhraseLocation = -1;
         int badGrammarPhraseLength = 0;
         m_client->textChecker().checkGrammarOfString(paragraph.textSubstring(startOffset), grammarDetails, &badGrammarPhraseLocation, &badGrammarPhraseLength);
 
         if (!badGrammarPhraseLength) {
@@ skipping 94 matching lines @@
         return false;
 
     const Settings* settings = frame->settings();
     if (!settings)
         return false;
 
     return settings->unifiedTextCheckerEnabled();
 }
 
 }