Move Frame to the Oilpan heap.

Source/core/editing/SpellChecker.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 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 53 matching lines @@
     return isHTMLTextAreaElement(textControl);
 }
 
 bool isSelectionInTextFormControl(const VisibleSelection& selection)
 {
     return !!enclosingTextFormControl(selection.start());
 }
 
 } // namespace
 
-PassOwnPtr<SpellChecker> SpellChecker::create(LocalFrame& frame)
+PassOwnPtrWillBeRawPtr<SpellChecker> SpellChecker::create(LocalFrame& frame)
 {
-    return adoptPtr(new SpellChecker(frame));
+    return adoptPtrWillBeNoop(new SpellChecker(frame));
 }
 
 static SpellCheckerClient& emptySpellCheckerClient()
 {
     DEFINE_STATIC_LOCAL(EmptySpellCheckerClient, client, ());
     return client;
 }
 
 SpellCheckerClient& SpellChecker::spellCheckerClient() const
 {
-    if (Page* page = m_frame.page())
+    if (Page* page = frame().page())
         return page->spellCheckerClient();
     return emptySpellCheckerClient();
 }
 
 TextCheckerClient& SpellChecker::textChecker() const
 {
     return spellCheckerClient().textChecker();
 }
 
 SpellChecker::SpellChecker(LocalFrame& frame)
-    : m_frame(frame)
-    , m_spellCheckRequester(adoptPtr(new SpellCheckRequester(frame)))
+    : m_frame(&frame)
+    , m_spellCheckRequester(SpellCheckRequester::create(frame))
 {
 }
 
 SpellChecker::~SpellChecker()
 {
 }
 
 bool SpellChecker::isContinuousSpellCheckingEnabled() const
 {
     return spellCheckerClient().isContinuousSpellCheckingEnabled();
 }
 
 void SpellChecker::toggleContinuousSpellChecking()
 {
     spellCheckerClient().toggleContinuousSpellChecking();
     if (isContinuousSpellCheckingEnabled())
         return;
-    for (Frame* frame = m_frame.page()->mainFrame(); frame; frame = frame->tree().traverseNext()) {
+    for (Frame* frame = this->frame().page()->mainFrame(); frame; frame = frame->tree().traverseNext()) {
         if (!frame->isLocalFrame())
             continue;
         for (Node* node = &toLocalFrame(frame)->document()->rootNode(); node; node = NodeTraversal::next(*node)) {
             node->setAlreadySpellChecked(false);
         }
     }
 }
 
 bool SpellChecker::isGrammarCheckingEnabled()
 {
@@ skipping 21 matching lines @@
             VisibleSelection selection = VisibleSelection::selectionFromContentsOfNode(element);
             markMisspellingsAndBadGrammar(selection);
             if (!isTextField)
                 parent->setAlreadySpellChecked(true);
         }
     }
 }
 
 void SpellChecker::ignoreSpelling()
 {
-    if (RefPtrWillBeRawPtr<Range> selectedRange = m_frame.selection().toNormalizedRange())
-        m_frame.document()->markers().removeMarkers(selectedRange.get(), DocumentMarker::Spelling);
+    if (RefPtrWillBeRawPtr<Range> selectedRange = frame().selection().toNormalizedRange())
+        frame().document()->markers().removeMarkers(selectedRange.get(), DocumentMarker::Spelling);
 }
 
 void SpellChecker::advanceToNextMisspelling(bool startBeforeSelection)
 {
     // The basic approach is to search in two phases - from the selection end to the end of the doc, and
     // then we wrap and search from the doc start to (approximately) where we started.
 
     // Start at the end of the selection, search to edge of document. Starting at the selection end makes
     // repeated "check spelling" commands work.
-    VisibleSelection selection(m_frame.selection().selection());
+    VisibleSelection selection(frame().selection().selection());
     Position spellingSearchStart, spellingSearchEnd;
-    Range::selectNodeContents(m_frame.document(), spellingSearchStart, spellingSearchEnd);
+    Range::selectNodeContents(frame().document(), spellingSearchStart, spellingSearchEnd);
 
     bool startedWithSelection = false;
     if (selection.start().deprecatedNode()) {
         startedWithSelection = true;
         if (startBeforeSelection) {
             VisiblePosition start(selection.visibleStart());
             // We match AppKit's rule: Start 1 character before the selection.
             VisiblePosition oneBeforeStart = start.previous();
             spellingSearchStart = (oneBeforeStart.isNotNull() ? oneBeforeStart : start).toParentAnchoredPosition();
         } else {
             spellingSearchStart = selection.visibleEnd().toParentAnchoredPosition();
         }
     }
 
     Position position = spellingSearchStart;
     if (!isEditablePosition(position)) {
         // This shouldn't happen in very often because the Spelling menu items aren't enabled unless the
         // selection is editable.
         // This can happen in Mail for a mix of non-editable and editable content (like Stationary),
         // when spell checking the whole document before sending the message.
         // In that case the document might not be editable, but there are editable pockets that need to be spell checked.
 
-        position = firstEditableVisiblePositionAfterPositionInRoot(position, m_frame.document()->documentElement()).deepEquivalent();
+        position = firstEditableVisiblePositionAfterPositionInRoot(position, frame().document()->documentElement()).deepEquivalent();
         if (position.isNull())
             return;
 
         spellingSearchStart = position.parentAnchoredEquivalent();
         startedWithSelection = false; // won't need to wrap
     }
 
     // topNode defines the whole range we want to operate on
     ContainerNode* topNode = highestEditableRoot(position);
     // FIXME: lastOffsetForEditing() is wrong here if editingIgnoresContent(highestEditableRoot()) returns true (e.g. a <table>)
@@ skipping 93 matching lines @@
         // takes precedence and we ignore any potential misspelled word. Select the grammar detail, update the spelling
         // panel, and store a marker so we draw the green squiggle later.
 
         ASSERT(badGrammarPhrase.length() > 0);
         ASSERT(grammarDetail.location != -1 && grammarDetail.length > 0);
 
         // FIXME 4859190: This gets confused with doubled punctuation at the end of a paragraph
         Position badGrammarStart = grammarSearchStart;
         Position badGrammarEnd = grammarSearchEnd;
         TextIterator::subrange(badGrammarStart, badGrammarEnd, grammarPhraseOffset + grammarDetail.location, grammarDetail.length);
-        m_frame.selection().setSelection(VisibleSelection(badGrammarStart, badGrammarEnd));
-        m_frame.selection().revealSelection();
+        frame().selection().setSelection(VisibleSelection(badGrammarStart, badGrammarEnd));
+        frame().selection().revealSelection();
 
-        m_frame.document()->markers().addMarker(badGrammarStart, badGrammarEnd, DocumentMarker::Grammar, grammarDetail.userDescription);
+        frame().document()->markers().addMarker(badGrammarStart, badGrammarEnd, DocumentMarker::Grammar, grammarDetail.userDescription);
     } else if (!misspelledWord.isEmpty()) {
         // We found a misspelling, but not any earlier bad grammar. Select the misspelling, update the spelling panel, and store
         // a marker so we draw the red squiggle later.
 
         Position misspellingStart = spellingSearchStart;
         Position misspellingEnd = spellingSearchEnd;
         TextIterator::subrange(misspellingStart, misspellingEnd, misspellingOffset, misspelledWord.length());
-        m_frame.selection().setSelection(VisibleSelection(misspellingStart, misspellingEnd, DOWNSTREAM));
-        m_frame.selection().revealSelection();
+        frame().selection().setSelection(VisibleSelection(misspellingStart, misspellingEnd, DOWNSTREAM));
+        frame().selection().revealSelection();
 
         spellCheckerClient().updateSpellingUIWithMisspelledWord(misspelledWord);
-        m_frame.document()->markers().addMarker(misspellingStart, misspellingEnd, DocumentMarker::Spelling);
+        frame().document()->markers().addMarker(misspellingStart, misspellingEnd, DocumentMarker::Spelling);
     }
 }
 
 void SpellChecker::showSpellingGuessPanel()
 {
     if (spellCheckerClient().spellingUIIsShowing()) {
         spellCheckerClient().showSpellingUI(false);
         return;
     }
 
     advanceToNextMisspelling(true);
     spellCheckerClient().showSpellingUI(true);
 }
 
 void SpellChecker::clearMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
 {
     RefPtrWillBeRawPtr<Range> selectedRange = movingSelection.toNormalizedRange();
     if (selectedRange)
-        m_frame.document()->markers().removeMarkers(selectedRange.get(), DocumentMarker::MisspellingMarkers());
+        frame().document()->markers().removeMarkers(selectedRange.get(), DocumentMarker::MisspellingMarkers());
 }
 
 void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
 {
     markMisspellingsAndBadGrammar(movingSelection, isContinuousSpellCheckingEnabled() && isGrammarCheckingEnabled(), movingSelection);
 }
 
 void SpellChecker::markMisspellingsAfterLineBreak(const VisibleSelection& wordSelection)
 {
     if (unifiedTextCheckerEnabled()) {
@@ skipping 53 matching lines @@
     if (!misspellingRange)
         return;
 
     // Get the misspelled word.
     const String misspelledWord = plainText(misspellingRange.get());
     String autocorrectedString = textChecker().getAutoCorrectSuggestionForMisspelledWord(misspelledWord);
 
     // If autocorrected word is non empty, replace the misspelled word by this word.
     if (!autocorrectedString.isEmpty()) {
         VisibleSelection newSelection(misspellingRange.get(), DOWNSTREAM);
-        if (newSelection != m_frame.selection().selection()) {
-            m_frame.selection().setSelection(newSelection);
+        if (newSelection != frame().selection().selection()) {
+            frame().selection().setSelection(newSelection);
         }
 
-        m_frame.editor().replaceSelectionWithText(autocorrectedString, false, false);
+        frame().editor().replaceSelectionWithText(autocorrectedString, false, false);
 
         // Reset the charet one character further.
-        m_frame.selection().moveTo(m_frame.selection().selection().visibleEnd());
-        m_frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity);
+        frame().selection().moveTo(frame().selection().selection().visibleEnd());
+        frame().selection().modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity);
     }
 
     if (!isGrammarCheckingEnabled())
         return;
 
     // Check grammar of entire sentence
     markBadGrammar(VisibleSelection(startOfSentence(wordStart), endOfSentence(wordStart)));
 }
 
 void SpellChecker::markMisspellingsOrBadGrammar(const VisibleSelection& selection, bool checkSpelling, RefPtrWillBeRawPtr<Range>& firstMisspellingRange)
@@ skipping 30 matching lines @@
     if (!node)
         return false;
     const Element* focusedElement = node->isElementNode() ? toElement(node) : node->parentElement();
     if (!focusedElement)
         return false;
     return focusedElement->isSpellCheckingEnabled();
 }
 
 bool SpellChecker::isSpellCheckingEnabledInFocusedNode() const
 {
-    return isSpellCheckingEnabledFor(m_frame.selection().start().deprecatedNode());
+    return isSpellCheckingEnabledFor(frame().selection().start().deprecatedNode());
 }
 
 void SpellChecker::markMisspellings(const VisibleSelection& selection, RefPtrWillBeRawPtr<Range>& firstMisspellingRange)
 {
     markMisspellingsOrBadGrammar(selection, true, firstMisspellingRange);
 }
 
 void SpellChecker::markBadGrammar(const VisibleSelection& selection)
 {
     RefPtrWillBeRawPtr<Range> firstMisspellingRange = nullptr;
@@ skipping 14 matching lines @@
     Node* editableNode = spellingRange->startContainer();
     if (!editableNode || !editableNode->hasEditableStyle())
         return;
 
     if (!isSpellCheckingEnabledFor(editableNode))
         return;
 
     Range* rangeToCheck = shouldMarkGrammar ? grammarRange : spellingRange;
     TextCheckingParagraph fullParagraphToCheck(rangeToCheck);
 
-    bool asynchronous = m_frame.settings() && m_frame.settings()->asynchronousSpellCheckingEnabled();
+    bool asynchronous = frame().settings() && frame().settings()->asynchronousSpellCheckingEnabled();
     chunkAndMarkAllMisspellingsAndBadGrammar(textCheckingOptions, fullParagraphToCheck, asynchronous);
 }
 
 void SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar(Node* node)
 {
     if (!node)
         return;
-    RefPtrWillBeRawPtr<Range> rangeToCheck = Range::create(*m_frame.document(), firstPositionInNode(node), lastPositionInNode(node));
+    RefPtrWillBeRawPtr<Range> rangeToCheck = Range::create(*frame().document(), firstPositionInNode(node), lastPositionInNode(node));
     TextCheckingParagraph textToCheck(rangeToCheck, rangeToCheck);
     bool asynchronous = true;
     chunkAndMarkAllMisspellingsAndBadGrammar(resolveTextCheckingTypeMask(TextCheckingTypeSpelling | TextCheckingTypeGrammar), textToCheck, asynchronous);
 }
 
 void SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar(TextCheckingTypeMask textCheckingOptions, const TextCheckingParagraph& fullParagraphToCheck, bool asynchronous)
 {
     if (fullParagraphToCheck.isRangeEmpty() || fullParagraphToCheck.isEmpty())
         return;
 
@@ skipping 21 matching lines @@
         currentChunkStart += checkingLength;
     }
 }
 
 void SpellChecker::markAllMisspellingsAndBadGrammarInRanges(TextCheckingTypeMask textCheckingOptions, Range* checkRange, Range* paragraphRange, bool asynchronous, int requestNumber, int* checkingLength)
 {
     TextCheckingParagraph sentenceToCheck(checkRange, paragraphRange);
     if (checkingLength)
         *checkingLength = sentenceToCheck.checkingLength();
 
-    RefPtr<SpellCheckRequest> request = SpellCheckRequest::create(resolveTextCheckingTypeMask(textCheckingOptions), TextCheckingProcessBatch, checkRange, paragraphRange, requestNumber);
+    RefPtrWillBeRawPtr<SpellCheckRequest> request = SpellCheckRequest::create(resolveTextCheckingTypeMask(textCheckingOptions), TextCheckingProcessBatch, checkRange, paragraphRange, requestNumber);
 
     if (asynchronous) {
         m_spellCheckRequester->requestCheckingFor(request);
     } else {
         Vector<TextCheckingResult> results;
         checkTextOfParagraph(textChecker(), sentenceToCheck.text(), resolveTextCheckingTypeMask(textCheckingOptions), results);
         markAndReplaceFor(request, results);
     }
 }
 
-void SpellChecker::markAndReplaceFor(PassRefPtr<SpellCheckRequest> request, const Vector<TextCheckingResult>& results)
+void SpellChecker::markAndReplaceFor(PassRefPtrWillBeRawPtr<SpellCheckRequest> request, const Vector<TextCheckingResult>& results)
 {
     ASSERT(request);
 
     TextCheckingTypeMask textCheckingOptions = request->data().mask();
     TextCheckingParagraph paragraph(request->checkingRange(), request->paragraphRange());
 
     bool shouldMarkSpelling = textCheckingOptions & TextCheckingTypeSpelling;
     bool shouldMarkGrammar = textCheckingOptions & TextCheckingTypeGrammar;
 
     // Expand the range to encompass entire paragraphs, since text checking needs that much context.
     int selectionOffset = 0;
     int ambiguousBoundaryOffset = -1;
     bool selectionChanged = false;
     bool restoreSelectionAfterChange = false;
     bool adjustSelectionForParagraphBoundaries = false;
 
     if (shouldMarkSpelling) {
-        if (m_frame.selection().isCaret()) {
+        if (frame().selection().isCaret()) {
             // Attempt to save the caret position so we can restore it later if needed
-            Position caretPosition = m_frame.selection().end();
+            Position caretPosition = frame().selection().end();
             selectionOffset = paragraph.offsetTo(caretPosition, ASSERT_NO_EXCEPTION);
             restoreSelectionAfterChange = true;
             if (selectionOffset > 0 && (static_cast<unsigned>(selectionOffset) > paragraph.text().length() || paragraph.textCharAt(selectionOffset - 1) == newlineCharacter))
                 adjustSelectionForParagraphBoundaries = true;
             if (selectionOffset > 0 && static_cast<unsigned>(selectionOffset) <= paragraph.text().length() && isAmbiguousBoundaryCharacter(paragraph.textCharAt(selectionOffset - 1)))
                 ambiguousBoundaryOffset = selectionOffset - 1;
         }
     }
 
     for (unsigned i = 0; i < results.size(); i++) {
@@ skipping 28 matching lines @@
             invisibleSpellcheckRange->startContainer()->document().markers().addMarker(invisibleSpellcheckRange.get(), DocumentMarker::InvisibleSpellcheck, result->replacement, result->hash);
         }
     }
 
     if (selectionChanged) {
         TextCheckingParagraph extendedParagraph(paragraph);
         // Restore the caret position if we have made any replacements
         extendedParagraph.expandRangeToNextEnd();
         if (restoreSelectionAfterChange && selectionOffset >= 0 && selectionOffset <= extendedParagraph.rangeLength()) {
             RefPtrWillBeRawPtr<Range> selectionRange = extendedParagraph.subrange(0, selectionOffset);
-            m_frame.selection().moveTo(selectionRange->endPosition(), DOWNSTREAM);
+            frame().selection().moveTo(selectionRange->endPosition(), DOWNSTREAM);
             if (adjustSelectionForParagraphBoundaries)
-                m_frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity);
+                frame().selection().modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity);
         } else {
             // If this fails for any reason, the fallback is to go one position beyond the last replacement
-            m_frame.selection().moveTo(m_frame.selection().selection().visibleEnd());
-            m_frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity);
+            frame().selection().moveTo(frame().selection().selection().visibleEnd());
+            frame().selection().modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity);
         }
     }
 }
 
 void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection& spellingSelection, bool markGrammar, const VisibleSelection& grammarSelection)
 {
     if (unifiedTextCheckerEnabled()) {
         if (!isContinuousSpellCheckingEnabled())
             return;
 
@@ skipping 19 matching lines @@
     // We want to remove the markers from a word if an editing command will change the word. This can happen in one of
     // several scenarios:
     // 1. Insert in the middle of a word.
     // 2. Appending non whitespace at the beginning of word.
     // 3. Appending non whitespace at the end of word.
     // Note that, appending only whitespaces at the beginning or end of word won't change the word, so we don't need to
     // remove the markers on that word.
     // Of course, if current selection is a range, we potentially will edit two words that fall on the boundaries of
     // selection, and remove words between the selection boundaries.
     //
-    VisiblePosition startOfSelection = m_frame.selection().selection().visibleStart();
-    VisiblePosition endOfSelection = m_frame.selection().selection().visibleEnd();
+    VisiblePosition startOfSelection = frame().selection().selection().visibleStart();
+    VisiblePosition endOfSelection = frame().selection().selection().visibleEnd();
     if (startOfSelection.isNull())
         return;
     // First word is the word that ends after or on the start of selection.
     VisiblePosition startOfFirstWord = startOfWord(startOfSelection, LeftWordIfOnBoundary);
     VisiblePosition endOfFirstWord = endOfWord(startOfSelection, LeftWordIfOnBoundary);
     // Last word is the word that begins before or on the end of selection
     VisiblePosition startOfLastWord = startOfWord(endOfSelection, RightWordIfOnBoundary);
     VisiblePosition endOfLastWord = endOfWord(endOfSelection, RightWordIfOnBoundary);
 
     if (startOfFirstWord.isNull()) {
@@ skipping 26 matching lines @@
 
     if (startOfFirstWord.isNull() || endOfFirstWord.isNull() || startOfLastWord.isNull() || endOfLastWord.isNull())
         return;
 
     // Now we remove markers on everything between startOfFirstWord and endOfLastWord.
     // However, if an autocorrection change a single word to multiple words, we want to remove correction mark from all the
     // resulted words even we only edit one of them. For example, assuming autocorrection changes "avantgarde" to "avant
     // garde", we will have CorrectionIndicator marker on both words and on the whitespace between them. If we then edit garde,
     // we would like to remove the marker from word "avant" and whitespace as well. So we need to get the continous range of
     // of marker that contains the word in question, and remove marker on that whole range.
-    Document* document = m_frame.document();
+    Document* document = frame().document();
     ASSERT(document);
     RefPtrWillBeRawPtr<Range> wordRange = Range::create(*document, startOfFirstWord.deepEquivalent(), endOfLastWord.deepEquivalent());
     document->markers().removeMarkers(wordRange.get(), DocumentMarker::MisspellingMarkers(), DocumentMarkerController::RemovePartiallyOverlappingMarker);
 }
 
 void SpellChecker::didEndEditingOnTextField(Element* e)
 {
     // Remove markers when deactivating a selection in an <input type="text"/>.
     // Prevent new ones from appearing too.
     m_spellCheckRequester->cancelCheck();
     HTMLTextFormControlElement* textFormControlElement = toHTMLTextFormControlElement(e);
     HTMLElement* innerEditor = textFormControlElement->innerEditorElement();
     DocumentMarker::MarkerTypes markerTypes(DocumentMarker::Spelling);
     if (isGrammarCheckingEnabled() || unifiedTextCheckerEnabled())
         markerTypes.add(DocumentMarker::Grammar);
     for (Node* node = innerEditor; node; node = NodeTraversal::next(*node, innerEditor)) {
-        m_frame.document()->markers().removeMarkers(node, markerTypes);
+        frame().document()->markers().removeMarkers(node, markerTypes);
     }
 }
 
 void SpellChecker::replaceMisspelledRange(const String& text)
 {
-    RefPtrWillBeRawPtr<Range> caretRange = m_frame.selection().toNormalizedRange();
+    RefPtrWillBeRawPtr<Range> caretRange = frame().selection().toNormalizedRange();
     if (!caretRange)
         return;
-    DocumentMarkerVector markers = m_frame.document()->markers().markersInRange(caretRange.get(), DocumentMarker::MisspellingMarkers());
+    DocumentMarkerVector markers = frame().document()->markers().markersInRange(caretRange.get(), DocumentMarker::MisspellingMarkers());
     if (markers.size() < 1 || markers[0]->startOffset() >= markers[0]->endOffset())
         return;
     RefPtrWillBeRawPtr<Range> markerRange = Range::create(caretRange->ownerDocument(), caretRange->startContainer(), markers[0]->startOffset(), caretRange->endContainer(), markers[0]->endOffset());
     if (!markerRange)
         return;
-    m_frame.selection().setSelection(VisibleSelection(markerRange.get()), CharacterGranularity);
-    m_frame.editor().replaceSelectionWithText(text, false, false);
+    frame().selection().setSelection(VisibleSelection(markerRange.get()), CharacterGranularity);
+    frame().editor().replaceSelectionWithText(text, false, false);
 }
 
 void SpellChecker::respondToChangedSelection(const VisibleSelection& oldSelection, FrameSelection::SetSelectionOptions options)
 {
     bool closeTyping = options & FrameSelection::CloseTyping;
     bool isContinuousSpellCheckingEnabled = this->isContinuousSpellCheckingEnabled();
     bool isContinuousGrammarCheckingEnabled = isContinuousSpellCheckingEnabled && isGrammarCheckingEnabled();
     if (isContinuousSpellCheckingEnabled) {
         VisibleSelection newAdjacentWords;
         VisibleSelection newSelectedSentence;
-        bool caretBrowsing = m_frame.settings() && m_frame.settings()->caretBrowsingEnabled();
-        const VisibleSelection newSelection = m_frame.selection().selection();
+        bool caretBrowsing = frame().settings() && frame().settings()->caretBrowsingEnabled();
+        const VisibleSelection newSelection = frame().selection().selection();
         if (isSelectionInTextFormControl(newSelection)) {
             Position newStart = newSelection.start();
             newAdjacentWords.setWithoutValidation(HTMLTextFormControlElement::startOfWord(newStart), HTMLTextFormControlElement::endOfWord(newStart));
             if (isContinuousGrammarCheckingEnabled)
                 newSelectedSentence.setWithoutValidation(HTMLTextFormControlElement::startOfSentence(newStart), HTMLTextFormControlElement::endOfSentence(newStart));
         } else if (newSelection.isContentEditable() || caretBrowsing) {
             VisiblePosition newStart(newSelection.visibleStart());
             newAdjacentWords = VisibleSelection(startOfWord(newStart, LeftWordIfOnBoundary), endOfWord(newStart, RightWordIfOnBoundary));
             if (isContinuousGrammarCheckingEnabled)
                 newSelectedSentence = VisibleSelection(startOfSentence(newStart), endOfSentence(newStart));
@@ skipping 14 matching lines @@
             && oldSelection.start().inDocument()) {
             spellCheckOldSelection(oldSelection, newAdjacentWords);
         }
 
         // FIXME(http://crbug.com/382809):
         // shouldEraseMarkersAfterChangeSelection is true, we cause synchronous
         // layout.
         if (textChecker().shouldEraseMarkersAfterChangeSelection(TextCheckingTypeSpelling)) {
             Position start, end;
             if (newAdjacentWords.toNormalizedPositions(start, end))
-                m_frame.document()->markers().removeMarkers(start, end, DocumentMarker::Spelling);
+                frame().document()->markers().removeMarkers(start, end, DocumentMarker::Spelling);
         }
         if (textChecker().shouldEraseMarkersAfterChangeSelection(TextCheckingTypeGrammar)) {
             Position start, end;
             if (newSelectedSentence.toNormalizedPositions(start, end))
-                m_frame.document()->markers().removeMarkers(start, end, DocumentMarker::Grammar);
+                frame().document()->markers().removeMarkers(start, end, DocumentMarker::Grammar);
         }
     }
 
     // When continuous spell checking is off, existing markers disappear after the selection changes.
     if (!isContinuousSpellCheckingEnabled)
-        m_frame.document()->markers().removeMarkers(DocumentMarker::Spelling);
+        frame().document()->markers().removeMarkers(DocumentMarker::Spelling);
     if (!isContinuousGrammarCheckingEnabled)
-        m_frame.document()->markers().removeMarkers(DocumentMarker::Grammar);
+        frame().document()->markers().removeMarkers(DocumentMarker::Grammar);
 }
 
 void SpellChecker::removeSpellingMarkers()
 {
-    m_frame.document()->markers().removeMarkers(DocumentMarker::MisspellingMarkers());
+    frame().document()->markers().removeMarkers(DocumentMarker::MisspellingMarkers());
 }
 
 void SpellChecker::removeSpellingMarkersUnderWords(const Vector<String>& words)
 {
     MarkerRemoverPredicate removerPredicate(words);
 
-    DocumentMarkerController& markerController = m_frame.document()->markers();
+    DocumentMarkerController& markerController = frame().document()->markers();
     markerController.removeMarkers(removerPredicate);
     markerController.repaintMarkers();
 }
 
 void SpellChecker::spellCheckAfterBlur()
 {
-    if (!m_frame.selection().selection().isContentEditable())
+    if (!frame().selection().selection().isContentEditable())
         return;
 
-    if (isSelectionInTextField(m_frame.selection().selection())) {
+    if (isSelectionInTextField(frame().selection().selection())) {
         // textFieldDidEndEditing() and textFieldDidBeginEditing() handle this.
         return;
     }
 
     VisibleSelection empty;
-    spellCheckOldSelection(m_frame.selection().selection(), empty);
+    spellCheckOldSelection(frame().selection().selection(), empty);
 }
 
 void SpellChecker::spellCheckOldSelection(const VisibleSelection& oldSelection, const VisibleSelection& newAdjacentWords)
 {
     VisiblePosition oldStart(oldSelection.visibleStart());
     VisibleSelection oldAdjacentWords = VisibleSelection(startOfWord(oldStart, LeftWordIfOnBoundary), endOfWord(oldStart, RightWordIfOnBoundary));
     if (oldAdjacentWords  != newAdjacentWords) {
         if (isContinuousSpellCheckingEnabled() && isGrammarCheckingEnabled()) {
             VisibleSelection selectedSentence = VisibleSelection(startOfSentence(oldStart), endOfSentence(oldStart));
             markMisspellingsAndBadGrammar(oldAdjacentWords, true, selectedSentence);
@@ skipping 16 matching lines @@
             node = node->firstChild();
         else
             node = node->nextSibling();
     }
 
     return 0;
 }
 
 bool SpellChecker::selectionStartHasMarkerFor(DocumentMarker::MarkerType markerType, int from, int length) const
 {
-    Node* node = findFirstMarkable(m_frame.selection().start().deprecatedNode());
+    Node* node = findFirstMarkable(frame().selection().start().deprecatedNode());
     if (!node)
         return false;
 
     unsigned startOffset = static_cast<unsigned>(from);
     unsigned endOffset = static_cast<unsigned>(from + length);
-    DocumentMarkerVector markers = m_frame.document()->markers().markersFor(node);
+    DocumentMarkerVector markers = frame().document()->markers().markersFor(node);
     for (size_t i = 0; i < markers.size(); ++i) {
         DocumentMarker* marker = markers[i];
         if (marker->startOffset() <= startOffset && endOffset <= marker->endOffset() && marker->type() == markerType)
             return true;
     }
 
     return false;
 }
 
 bool SpellChecker::selectionStartHasSpellingMarkerFor(int from, int length) const
@@ skipping 10 matching lines @@
     if (shouldMarkSpelling)
         checkingTypes |= TextCheckingTypeSpelling;
     if (shouldMarkGrammar)
         checkingTypes |= TextCheckingTypeGrammar;
 
     return checkingTypes;
 }
 
 bool SpellChecker::unifiedTextCheckerEnabled() const
 {
-    return blink::unifiedTextCheckerEnabled(&m_frame);
+    return blink::unifiedTextCheckerEnabled(m_frame);
 }
 
 void SpellChecker::cancelCheck()
 {
     m_spellCheckRequester->cancelCheck();
 }
 
 void SpellChecker::requestTextChecking(const Element& element)
 {
     RefPtrWillBeRawPtr<Range> rangeToCheck = rangeOfContents(const_cast<Element*>(&element));
     m_spellCheckRequester->requestCheckingFor(SpellCheckRequest::create(TextCheckingTypeSpelling | TextCheckingTypeGrammar, TextCheckingProcessBatch, rangeToCheck, rangeToCheck));
 }
 
+void SpellChecker::trace(Visitor* visitor)
+{
+    visitor->trace(m_frame);
+    visitor->trace(m_spellCheckRequester);
+}
 
 } // namespace blink