Use ExpandToParagraphBoundary in SpellChecker::FindFirstMisspelling

third_party/WebKit/Source/core/editing/spellcheck/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 1121 matching lines @@
 
   // Initialize out parameters; they will be updated if we find something to
   // return.
   String first_found_item;
   int first_found_offset = 0;
 
   // 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 paragraph_start =
-      StartOfParagraph(CreateVisiblePosition(start)).ToParentAnchoredPosition();
-  Position paragraph_end = end;
-  int total_range_length =
-      TextIterator::RangeLength(paragraph_start, paragraph_end);
-  paragraph_end =
-      EndOfParagraph(CreateVisiblePosition(start)).ToParentAnchoredPosition();
+  EphemeralRange paragraph_range =
+      ExpandToParagraphBoundary(EphemeralRange(start, start));
+  Position paragraph_start = paragraph_range.StartPosition();
+  Position paragraph_end = paragraph_range.EndPosition();
 
-  int range_start_offset = TextIterator::RangeLength(paragraph_start, start);
+  const int total_range_length =
+      TextIterator::RangeLength(paragraph_start, end);
+  const int range_start_offset =
+      TextIterator::RangeLength(paragraph_start, start);
   int total_length_processed = 0;
 
   bool first_iteration = true;
   bool last_iteration = false;
   while (total_length_processed < total_range_length) {
     // Iterate through the search range by paragraphs, checking each one for
     // spelling.
     int current_length =
         TextIterator::RangeLength(paragraph_start, paragraph_end);
     int current_start_offset = first_iteration ? range_start_offset : 0;
     int current_end_offset = current_length;
     if (InSameParagraph(CreateVisiblePosition(paragraph_start),
                         CreateVisiblePosition(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.
       current_end_offset = TextIterator::RangeLength(paragraph_start, end);
       last_iteration = true;
     }
     if (current_start_offset < current_end_offset) {
-      String paragraph_string =
-          PlainText(EphemeralRange(paragraph_start, paragraph_end));
+      String paragraph_string = PlainText(paragraph_range);
       if (paragraph_string.length() > 0) {
         int spelling_location = 0;
 
         Vector<TextCheckingResult> results = FindMisspellings(paragraph_string);
 
         for (unsigned i = 0; i < results.size(); i++) {
           const TextCheckingResult* result = &results[i];
           if (result->location >= current_start_offset &&
               result->location + result->length <= current_end_offset) {
             DCHECK_GT(result->length, 0);
@@ skipping 13 matching lines @@
                 TextIterator::RangeLength(start, paragraph_start);
           first_found_offset = spelling_offset;
           first_found_item = misspelled_word;
           break;
         }
       }
     }
     if (last_iteration ||
         total_length_processed + current_length >= total_range_length)
       break;
-    VisiblePosition new_paragraph_start =
-        StartOfNextParagraph(CreateVisiblePosition(paragraph_end));
+    Position new_paragraph_start =
+        StartOfNextParagraph(CreateVisiblePosition(paragraph_end))
+            .DeepEquivalent();
     if (new_paragraph_start.IsNull())
       break;
 
-    paragraph_start = new_paragraph_start.ToParentAnchoredPosition();
-    paragraph_end =
-        EndOfParagraph(new_paragraph_start).ToParentAnchoredPosition();
+    paragraph_range = ExpandToParagraphBoundary(
+        EphemeralRange(new_paragraph_start, new_paragraph_start));
+    paragraph_start = paragraph_range.StartPosition();
+    paragraph_end = paragraph_range.EndPosition();
     first_iteration = false;
     total_length_processed += current_length;
   }
   return std::make_pair(first_found_item, first_found_offset);
 }
 
 // static
 bool SpellChecker::IsSpellCheckingEnabledAt(const Position& position) {
   if (position.IsNull())
     return false;
   if (TextControlElement* text_control = EnclosingTextControl(position)) {
     if (isHTMLInputElement(text_control)) {
       HTMLInputElement& input = toHTMLInputElement(*text_control);
       // TODO(tkent): The following password type check should be done in
       // HTMLElement::spellcheck(). crbug.com/371567
       if (input.type() == InputTypeNames::password)
         return false;
       if (!input.IsFocusedElementInDocument())
         return false;
     }
   }
   HTMLElement* element =
       Traversal<HTMLElement>::FirstAncestorOrSelf(*position.AnchorNode());
   return element && element->IsSpellCheckingEnabled();
 }
 
 }  // namespace blink