Make VisiblePosition constructor private

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 83 matching lines @@
             misspelling.replacement = client.getAutoCorrectSuggestionForMisspelledWord(String(text + misspelling.location, misspelling.length));
             results.append(misspelling);
         }
 
         wordStart = wordEnd;
     }
 }
 
 void expandRangeToSentenceBoundary(Range& range)
 {
-    range.setStart(startOfSentence(VisiblePosition(range.startPosition())).deepEquivalent());
-    range.setEnd(endOfSentence(VisiblePosition(range.endPosition())).deepEquivalent());
+    range.setStart(startOfSentence(createVisiblePosition(range.startPosition())).deepEquivalent());
+    range.setEnd(endOfSentence(createVisiblePosition(range.endPosition())).deepEquivalent());
 }
 
 static PassRefPtrWillBeRawPtr<Range> expandToParagraphBoundary(PassRefPtrWillBeRawPtr<Range> range)
 {
     RefPtrWillBeRawPtr<Range> paragraphRange = range->cloneRange();
-    paragraphRange->setStart(startOfParagraph(VisiblePosition(range->startPosition())).deepEquivalent());
-    paragraphRange->setEnd(endOfParagraph(VisiblePosition(range->endPosition())).deepEquivalent());
+    paragraphRange->setStart(startOfParagraph(createVisiblePosition(range->startPosition())).deepEquivalent());
+    paragraphRange->setEnd(endOfParagraph(createVisiblePosition(range->endPosition())).deepEquivalent());
     return paragraphRange;
 }
 
 TextCheckingParagraph::TextCheckingParagraph(PassRefPtrWillBeRawPtr<Range> checkingRange)
     : m_checkingRange(checkingRange)
     , m_checkingStart(-1)
     , m_checkingEnd(-1)
     , m_checkingLength(-1)
 {
 }
 
 TextCheckingParagraph::TextCheckingParagraph(PassRefPtrWillBeRawPtr<Range> checkingRange, PassRefPtrWillBeRawPtr<Range> paragraphRange)
     : m_checkingRange(checkingRange)
     , m_paragraphRange(paragraphRange)
     , m_checkingStart(-1)
     , m_checkingEnd(-1)
     , m_checkingLength(-1)
 {
 }
 
 TextCheckingParagraph::~TextCheckingParagraph()
 {
 }
 
 void TextCheckingParagraph::expandRangeToNextEnd()
 {
     ASSERT(m_checkingRange);
-    paragraphRange()->setEnd(endOfParagraph(startOfNextParagraph(VisiblePosition(paragraphRange()->startPosition()))).deepEquivalent());
+    paragraphRange()->setEnd(endOfParagraph(startOfNextParagraph(createVisiblePosition(paragraphRange()->startPosition()))).deepEquivalent());
     invalidateParagraphRangeValues();
 }
 
 void TextCheckingParagraph::invalidateParagraphRangeValues()
 {
     m_checkingStart = m_checkingEnd = -1;
     m_offsetAsRange = nullptr;
     m_text = String();
 }
 
@@ skipping 155 matching lines @@
     outIsSpelling = true;
     outFirstFoundOffset = 0;
     outGrammarDetail.location = -1;
     outGrammarDetail.length = 0;
     outGrammarDetail.guesses.clear();
     outGrammarDetail.userDescription = "";
 
     // Expand the search range to encompass entire paragraphs, since text 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.
-    Position paragraphStart = startOfParagraph(VisiblePosition(m_start)).toParentAnchoredPosition();
+    Position paragraphStart = startOfParagraph(createVisiblePosition(m_start)).toParentAnchoredPosition();
     Position paragraphEnd = m_end;
     int totalRangeLength = TextIterator::rangeLength(paragraphStart, paragraphEnd);
-    paragraphEnd = endOfParagraph(VisiblePosition(m_start)).toParentAnchoredPosition();
+    paragraphEnd = endOfParagraph(createVisiblePosition(m_start)).toParentAnchoredPosition();
 
     int rangeStartOffset = TextIterator::rangeLength(paragraphStart, m_start);
     int totalLengthProcessed = 0;
 
     bool firstIteration = true;
     bool lastIteration = false;
     while (totalLengthProcessed < totalRangeLength) {
         // Iterate through the search range by paragraphs, checking each one for spelling and grammar.
         int currentLength = TextIterator::rangeLength(paragraphStart, paragraphEnd);
         int currentStartOffset = firstIteration ? rangeStartOffset : 0;
         int currentEndOffset = currentLength;
-        if (inSameParagraph(VisiblePosition(paragraphStart), VisiblePosition(m_end))) {
+        if (inSameParagraph(createVisiblePosition(paragraphStart), createVisiblePosition(m_end))) {
             // Determine the character offset from the end of the original search range to the end of the paragraph,
             // since we will want to ignore results in this area.
             currentEndOffset = TextIterator::rangeLength(paragraphStart, m_end);
             lastIteration = true;
         }
         if (currentStartOffset < currentEndOffset) {
             String paragraphString = plainText(EphemeralRange(paragraphStart, paragraphEnd));
             if (paragraphString.length() > 0) {
                 bool foundGrammar = false;
                 int spellingLocation = 0;
@@ skipping 53 matching lines @@
                         grammarPhraseOffset += TextIterator::rangeLength(m_start, paragraphStart);
                     outIsSpelling = false;
                     outFirstFoundOffset = grammarPhraseOffset;
                     firstFoundItem = badGrammarPhrase;
                     break;
                 }
             }
         }
         if (lastIteration || totalLengthProcessed + currentLength >= totalRangeLength)
             break;
-        VisiblePosition newParagraphStart = startOfNextParagraph(VisiblePosition(paragraphEnd));
+        VisiblePosition newParagraphStart = startOfNextParagraph(createVisiblePosition(paragraphEnd));
         paragraphStart = newParagraphStart.toParentAnchoredPosition();
         paragraphEnd = endOfParagraph(newParagraphStart).toParentAnchoredPosition();
         firstIteration = false;
         totalLengthProcessed += currentLength;
     }
     return firstFoundItem;
 }
 
 int TextCheckingHelper::findFirstGrammarDetail(const Vector<GrammarDetail>& grammarDetails, int badGrammarPhraseLocation, int startOffset, int endOffset, bool markAll) const
 {
@@ skipping 152 matching lines @@
         return false;
 
     const Settings* settings = frame->settings();
     if (!settings)
         return false;
 
     return settings->unifiedTextCheckerEnabled();
 }
 
 }