[Reland] Allow storing multiple replacements on SpellCheckResult

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 518 matching lines @@
             chunk_range.EndPosition(), check_range.EndPosition()));
     }
   }
 }
 
 static void AddMarker(Document* document,
                       const EphemeralRange& checking_range,
                       DocumentMarker::MarkerType type,
                       int location,
                       int length,
-                      const String& description) {
+                      const Vector<String>& descriptions) {
   DCHECK(type == DocumentMarker::kSpelling || type == DocumentMarker::kGrammar)
       << type;
   DCHECK_GT(length, 0);
   DCHECK_GE(location, 0);
   const EphemeralRange& range_to_mark =
       CalculateCharacterSubrange(checking_range, location, length);
   if (!SpellChecker::IsSpellCheckingEnabledAt(range_to_mark.StartPosition()))
     return;
   if (!SpellChecker::IsSpellCheckingEnabledAt(range_to_mark.EndPosition()))
     return;
 
+  String description;
+  for (size_t i = 0; i < descriptions.size(); ++i) {
+    if (i != 0)
+      description.append('\n');
+    description.append(descriptions[i]);
+  }
+
   if (type == DocumentMarker::kSpelling) {
     document->Markers().AddSpellingMarker(range_to_mark, description);
     return;
   }
 
   DCHECK_EQ(type, DocumentMarker::kGrammar);
   document->Markers().AddGrammarMarker(range_to_mark, description);
 }
 
 void SpellChecker::MarkAndReplaceFor(
@@ skipping 75 matching lines @@
     //    instance, we would not mark "wouldn'" as misspelled right after
     //    apostrophe is typed.
     switch (result.decoration) {
       case kTextDecorationTypeSpelling:
         if (result_location < paragraph.CheckingStart() ||
             result_location + result_length > spelling_range_end_offset ||
             result_ends_at_ambiguous_boundary)
           continue;
         AddMarker(GetFrame().GetDocument(), paragraph.CheckingRange(),
                   DocumentMarker::kSpelling, result_location, result_length,
-                  result.replacement);
+                  result.replacements);
         continue;
 
       case kTextDecorationTypeGrammar:
         if (!paragraph.CheckingRangeCovers(result_location, result_length))
           continue;
         DCHECK_GT(result_length, 0);
         DCHECK_GE(result_location, 0);
         for (const GrammarDetail& detail : result.details) {
           DCHECK_GT(detail.length, 0);
           DCHECK_GE(detail.location, 0);
           if (!paragraph.CheckingRangeCovers(result_location + detail.location,
                                              detail.length))
             continue;
           AddMarker(GetFrame().GetDocument(), paragraph.CheckingRange(),
                     DocumentMarker::kGrammar, result_location + detail.location,
-                    detail.length, result.replacement);
+                    detail.length, result.replacements);
         }
         continue;
     }
     NOTREACHED();
   }
 }
 
 void SpellChecker::UpdateMarkersForWordsAffectedByEditing(
     bool do_not_remove_if_selection_at_word_boundary) {
   if (RuntimeEnabledFeatures::idleTimeSpellCheckingEnabled())
@@ skipping 558 matching lines @@
       if (!input.IsFocusedElementInDocument())
         return false;
     }
   }
   HTMLElement* element =
       Traversal<HTMLElement>::FirstAncestorOrSelf(*position.AnchorNode());
   return element && element->IsSpellCheckingEnabled();
 }
 
 }  // namespace blink