[WIP] Add support for Android SuggestionSpans when editing text

third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
@@ skipping 53 matching lines @@
     case DocumentMarker::Spelling:
       return DocumentMarker::SpellingMarkerIndex;
     case DocumentMarker::Grammar:
       return DocumentMarker::GrammarMarkerIndex;
     case DocumentMarker::TextMatch:
       return DocumentMarker::TextMatchMarkerIndex;
     case DocumentMarker::InvisibleSpellcheck:
       return DocumentMarker::InvisibleSpellcheckMarkerIndex;
     case DocumentMarker::Composition:
       return DocumentMarker::CompositionMarkerIndex;
+    case DocumentMarker::Suggestion:
+      return DocumentMarker::SuggestionMarkerIndex;
+    case DocumentMarker::SuggestionBackgroundHighlight:
+      return DocumentMarker::SuggestionBackgroundHighlightMarkerIndex;
   }
 
   NOTREACHED();
   return DocumentMarker::SpellingMarkerIndex;
 }
 
 }  // namespace
 
 inline bool DocumentMarkerController::possiblyHasMarkers(
     DocumentMarker::MarkerTypes types) {
   return m_possiblyExistingMarkerTypes.intersects(types);
 }
 
 DocumentMarkerController::DocumentMarkerController(const Document& document)
-    : m_possiblyExistingMarkerTypes(0), m_document(&document) {}
+    : m_possiblyExistingMarkerTypes(0),
+      m_document(&document),
+      m_nextSuggestionMarkerID(0) {}
 
 void DocumentMarkerController::clear() {
   m_markers.clear();
   m_possiblyExistingMarkerTypes = 0;
+  m_nextSuggestionMarkerID = 0;
 }
 
 void DocumentMarkerController::addMarker(const Position& start,
                                          const Position& end,
                                          DocumentMarker::MarkerType type,
                                          const String& description,
                                          uint32_t hash) {
   // Use a TextIterator to visit the potentially multiple nodes the range
   // covers.
   for (TextIterator markedText(start, end); !markedText.atEnd();
@@ skipping 14 matching lines @@
   for (TextIterator markedText(range.startPosition(), range.endPosition());
        !markedText.atEnd(); markedText.advance())
     addMarker(
         markedText.currentContainer(),
         DocumentMarker(markedText.startOffsetInCurrentContainer(),
                        markedText.endOffsetInCurrentContainer(), activeMatch));
   // Don't invalidate tickmarks here. TextFinder invalidates tickmarks using a
   // throttling algorithm. crbug.com/6819.
 }
 
-void DocumentMarkerController::addCompositionMarker(const Position& start,
-                                                    const Position& end,
-                                                    Color underlineColor,
-                                                    bool thick,
-                                                    Color backgroundColor) {
+void DocumentMarkerController::addCompositionMarker(
+    const Position& start,
+    const Position& end,
+    Color underlineColor,
+    bool thick,
+    Color backgroundColor,
+    const std::vector<std::string>& suggestions) {
+  DCHECK(!m_document->needsLayoutTreeUpdate());
+  for (TextIterator markedText(start, end); !markedText.atEnd();
+       markedText.advance()) {
+    addMarker(markedText.currentContainer(),
+              DocumentMarker(markedText.startOffsetInCurrentContainer(),
+                             markedText.endOffsetInCurrentContainer(),
+                             underlineColor, thick, backgroundColor,
+                             suggestions, m_nextSuggestionMarkerID++));
+  }
+}
+
+void DocumentMarkerController::addSuggestionBackgroundHighlightMarker(
+    const Position& start,
+    const Position& end,
+    Color underlineColor,
+    bool thick,
+    Color backgroundColor) {
   DCHECK(!m_document->needsLayoutTreeUpdate());
 
   for (TextIterator markedText(start, end); !markedText.atEnd();
-       markedText.advance())
+       markedText.advance()) {
     addMarker(markedText.currentContainer(),
-              DocumentMarker(markedText.startOffsetInCurrentContainer(),
+              DocumentMarker(DocumentMarker::SuggestionBackgroundHighlight,
+                             markedText.startOffsetInCurrentContainer(),
                              markedText.endOffsetInCurrentContainer(),
                              underlineColor, thick, backgroundColor));
+  }
 }
 
 void DocumentMarkerController::prepareForDestruction() {
   clear();
 }
 
 void DocumentMarkerController::removeMarkers(
     TextIterator& markedText,
     DocumentMarker::MarkerTypes markerTypes,
     RemovePartiallyOverlappingMarkerOrNot
         shouldRemovePartiallyOverlappingMarker) {
   for (; !markedText.atEnd(); markedText.advance()) {
     if (!possiblyHasMarkers(markerTypes))
       return;
     DCHECK(!m_markers.isEmpty());
 
     int startOffset = markedText.startOffsetInCurrentContainer();
     int endOffset = markedText.endOffsetInCurrentContainer();
     removeMarkers(markedText.currentContainer(), startOffset,
                   endOffset - startOffset, markerTypes,
                   shouldRemovePartiallyOverlappingMarker);
   }
+  showMarkers();
 }
 
 void DocumentMarkerController::removeMarkers(
     const EphemeralRange& range,
     DocumentMarker::MarkerTypes markerTypes,
     RemovePartiallyOverlappingMarkerOrNot
         shouldRemovePartiallyOverlappingMarker) {
   DCHECK(!m_document->needsLayoutTreeUpdate());
 
   TextIterator markedText(range.startPosition(), range.endPosition());
   DocumentMarkerController::removeMarkers(
       markedText, markerTypes, shouldRemovePartiallyOverlappingMarker);
+  showMarkers();
 }
 
 static bool startsFurther(const Member<RenderedDocumentMarker>& lhv,
                           const DocumentMarker* rhv) {
   return lhv->startOffset() < rhv->startOffset();
 }
 
-static bool startsAfter(const Member<RenderedDocumentMarker>& marker,
-                        size_t startOffset) {
-  return marker->startOffset() < startOffset;
-}
-
 static bool endsBefore(size_t startOffset,
                        const Member<RenderedDocumentMarker>& rhv) {
   return startOffset < rhv->endOffset();
 }
 
 static bool compareByStart(const Member<DocumentMarker>& lhv,
                            const Member<DocumentMarker>& rhv) {
   return lhv->startOffset() < rhv->startOffset();
 }
 
@@ skipping 52 matching lines @@
     markers->at(markerListIndex) = new MarkerList;
   }
 
   Member<MarkerList>& list = markers->at(markerListIndex);
   RenderedDocumentMarker* newRenderedMarker =
       RenderedDocumentMarker::create(newMarker);
   if (list->isEmpty() || list->back()->endOffset() < newMarker.startOffset()) {
     list->push_back(newRenderedMarker);
   } else {
     if (newMarker.type() != DocumentMarker::TextMatch &&
-        newMarker.type() != DocumentMarker::Composition) {
+        newMarker.type() != DocumentMarker::Composition &&
+        newMarker.type() != DocumentMarker::Suggestion) {
       mergeOverlapping(list.get(), newRenderedMarker);
     } else {
       MarkerList::iterator pos = std::lower_bound(list->begin(), list->end(),
                                                   &newMarker, startsFurther);
       list->insert(pos - list->begin(), newRenderedMarker);
     }
   }
 
   // repaint the affected node
   if (node->layoutObject())
@@ skipping 78 matching lines @@
     unsigned startOffset,
     int length,
     DocumentMarker::MarkerTypes markerTypes,
     RemovePartiallyOverlappingMarkerOrNot
         shouldRemovePartiallyOverlappingMarker) {
   if (length <= 0)
     return;
 
   if (!possiblyHasMarkers(markerTypes))
     return;
+
   DCHECK(!(m_markers.isEmpty()));
 
   MarkerLists* markers = m_markers.get(node);
   if (!markers)
     return;
 
   bool docDirty = false;
   size_t emptyListsCount = 0;
   for (size_t markerListIndex = 0;
        markerListIndex < DocumentMarker::MarkerTypeIndexesCount;
@@ skipping 56 matching lines @@
 
   if (emptyListsCount == DocumentMarker::MarkerTypeIndexesCount) {
     m_markers.remove(node);
     if (m_markers.isEmpty())
       m_possiblyExistingMarkerTypes = 0;
   }
 
   // repaint the affected node
   if (docDirty && node->layoutObject())
     node->layoutObject()->setShouldDoFullPaintInvalidation();
+
+  showMarkers();
 }
 
 DocumentMarkerVector DocumentMarkerController::markersFor(
     Node* node,
     DocumentMarker::MarkerTypes markerTypes) {
   DocumentMarkerVector result;
 
   MarkerLists* markers = m_markers.get(node);
   if (!markers)
     return result;
@@ skipping 32 matching lines @@
 
 DocumentMarkerVector DocumentMarkerController::markersInRange(
     const EphemeralRange& range,
     DocumentMarker::MarkerTypes markerTypes) {
   if (!possiblyHasMarkers(markerTypes))
     return DocumentMarkerVector();
 
   DocumentMarkerVector foundMarkers;
 
   Node* startContainer = range.startPosition().computeContainerNode();
-  DCHECK(startContainer);
+  if (!startContainer)
+    return DocumentMarkerVector();
+
   unsigned startOffset = static_cast<unsigned>(
       range.startPosition().computeOffsetInContainerNode());
+
   Node* endContainer = range.endPosition().computeContainerNode();
-  DCHECK(endContainer);
+  if (!endContainer)
+    return DocumentMarkerVector();
+
   unsigned endOffset =
       static_cast<unsigned>(range.endPosition().computeOffsetInContainerNode());
 
+  // For zero-length ranges, include spans whose endpoints touch the range

[aelias_OOO_until_Jul13, 2017/01/25 03:34:27]

That's not very principled.  I'd prefer you introduce a new method
markersInRangeInclusive.  From a comment in InputMethodController, it sounds
like that would benefit non-zero-length cases as well?

[rlanday, 2017/01/25 18:48:10]

That's a good idea; I got the idea to do it the way I currently have it by
looking at the Android SpannableString implementation, which actually does
special case zero-length ranges and queries:
https://android.googlesource.com/platform/frameworks/base/+/master/core/java/...

+  // location
+  bool isZeroLengthRange =
+      (startContainer == endContainer) && (startOffset == endOffset);
+
   for (Node& node : range.nodes()) {
     for (DocumentMarker* marker : markersFor(&node)) {
       if (!markerTypes.contains(marker->type()))
         continue;
-      if (node == startContainer && marker->endOffset() <= startOffset)
-        continue;
-      if (node == endContainer && marker->startOffset() >= endOffset)
-        continue;
+      if (node == startContainer) {
+        if (marker->endOffset() < startOffset ||
+            (marker->endOffset() == startOffset && !isZeroLengthRange))
+          continue;
+      }
+      if (node == endContainer) {
+        if (marker->startOffset() > endOffset ||
+            (marker->startOffset() == endOffset && !isZeroLengthRange))
+          continue;
+      }
       foundMarkers.push_back(marker);
     }
   }
   return foundMarkers;
 }
 
 Vector<IntRect> DocumentMarkerController::renderedRectsForMarkers(
     DocumentMarker::MarkerType markerType) {
   Vector<IntRect> result;
 
@@ skipping 82 matching lines @@
 void DocumentMarkerController::removeMarkers(
     Node* node,
     DocumentMarker::MarkerTypes markerTypes) {
   if (!possiblyHasMarkers(markerTypes))
     return;
   DCHECK(!m_markers.isEmpty());
 
   MarkerMap::iterator iterator = m_markers.find(node);
   if (iterator != m_markers.end())
     removeMarkersFromList(iterator, markerTypes);
+
+  showMarkers();
 }
 
 void DocumentMarkerController::removeMarkers(
     const MarkerRemoverPredicate& shouldRemoveMarker) {
   for (auto& nodeMarkers : m_markers) {
     const Node& node = *nodeMarkers.key;
     if (!node.isTextNode())  // MarkerRemoverPredicate requires a Text node.
       continue;
     MarkerLists& markers = *nodeMarkers.value;
     for (size_t markerListIndex = 0;
          markerListIndex < DocumentMarker::MarkerTypeIndexesCount;
          ++markerListIndex) {
       Member<MarkerList>& list = markers[markerListIndex];
       if (!list)
         continue;
       bool removedMarkers = false;
       for (size_t j = list->size(); j > 0; --j) {
         if (shouldRemoveMarker(*list->at(j - 1),
                                static_cast<const Text&>(node))) {
           list->remove(j - 1);
           removedMarkers = true;
         }
       }
       if (removedMarkers &&
           markerListIndex == DocumentMarker::TextMatchMarkerIndex)
         invalidatePaintForTickmarks(node);
     }
   }
+
+  showMarkers();
 }
 
 void DocumentMarkerController::removeMarkers(
     DocumentMarker::MarkerTypes markerTypes) {
   if (!possiblyHasMarkers(markerTypes))
     return;
   DCHECK(!m_markers.isEmpty());
 
   HeapVector<Member<const Node>> nodesWithMarkers;
   copyKeysToVector(m_markers, nodesWithMarkers);
   unsigned size = nodesWithMarkers.size();
   for (unsigned i = 0; i < size; ++i) {
     MarkerMap::iterator iterator = m_markers.find(nodesWithMarkers[i]);
     if (iterator != m_markers.end())
       removeMarkersFromList(iterator, markerTypes);
   }
 
   m_possiblyExistingMarkerTypes.remove(markerTypes);
+
+  showMarkers();
+}
+
+void DocumentMarkerController::removeSuggestionMarkersByID(
+    const Vector<int>& idsToRemove) {
+  for (auto& nodeMarkers : m_markers) {
+    MarkerLists& markers = *nodeMarkers.value;
+    Member<MarkerList>& suggestionMarkerList =
+        markers[DocumentMarker::SuggestionMarkerIndex];
+    if (!suggestionMarkerList)
+      continue;
+    bool removedMarkers = false;
+    for (size_t j = suggestionMarkerList->size(); j > 0; --j) {
+      if (idsToRemove.contains(
+              suggestionMarkerList->at(j - 1)->suggestionMarkerID())) {
+        suggestionMarkerList->remove(j - 1);
+        removedMarkers = true;
+      }
+    }
+  }
 }
 
 void DocumentMarkerController::removeMarkersFromList(
     MarkerMap::iterator iterator,
     DocumentMarker::MarkerTypes markerTypes) {
   bool needsRepainting = false;
   bool nodeCanBeRemoved;
 
   size_t emptyListsCount = 0;
   if (markerTypes == DocumentMarker::AllMarkers()) {
@@ skipping 29 matching lines @@
     if (LayoutObject* layoutObject = node.layoutObject())
       layoutObject->setShouldDoFullPaintInvalidation();
     invalidatePaintForTickmarks(node);
   }
 
   if (nodeCanBeRemoved) {
     m_markers.remove(iterator);
     if (m_markers.isEmpty())
       m_possiblyExistingMarkerTypes = 0;
   }
+
+  showMarkers();
 }
 
 void DocumentMarkerController::repaintMarkers(
     DocumentMarker::MarkerTypes markerTypes) {
   if (!possiblyHasMarkers(markerTypes))
     return;
   DCHECK(!m_markers.isEmpty());
 
   // outer loop: process each markered node in the document
   MarkerMap::iterator end = m_markers.end();
@@ skipping 13 matching lines @@
       // cause the node to be redrawn
       if (LayoutObject* layoutObject = node->layoutObject()) {
         layoutObject->setShouldDoFullPaintInvalidation();
         break;
       }
     }
   }
 }
 
 void DocumentMarkerController::shiftMarkers(Node* node,
-                                            unsigned startOffset,
-                                            int delta) {
+                                            int startOffset,
+                                            int prevLength,
+                                            int newLength) {
+  DCHECK_GE(startOffset, 0);
+  DCHECK_GE(prevLength, 0);
+  DCHECK_GE(newLength, 0);
+
   if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
     return;
   DCHECK(!m_markers.isEmpty());
 
   MarkerLists* markers = m_markers.get(node);
   if (!markers)
     return;
 
   bool didShiftMarker = false;
   for (size_t markerListIndex = 0;
        markerListIndex < DocumentMarker::MarkerTypeIndexesCount;
        ++markerListIndex) {
     Member<MarkerList>& list = (*markers)[markerListIndex];
     if (!list)
       continue;
-    MarkerList::iterator startPos =
-        std::lower_bound(list->begin(), list->end(), startOffset, startsAfter);
-    for (MarkerList::iterator marker = startPos; marker != list->end();
+
+    // algorithm from https://dom.spec.whatwg.org/#concept-cd-replace
+    for (MarkerList::iterator marker = list->begin(); marker != list->end();
          ++marker) {
-#if DCHECK_IS_ON()
-      int startOffset = (*marker)->startOffset();
-      DCHECK_GE(startOffset + delta, 0);
-#endif
-      (*marker)->shiftOffsets(delta);
+      if ((*marker)->startOffset() > (unsigned)startOffset) {
+        if ((*marker)->startOffset() <= (unsigned)(startOffset + prevLength)) {
+          // Marker start was in the replaced text. Move to beginning of new
+          // text
+          (*marker)->setStartOffset(startOffset);
+        } else {
+          // Marker start was after the replaced text. Shift by length
+          // difference
+          unsigned oldStartOffset = (*marker)->startOffset();
+          (*marker)->setStartOffset(oldStartOffset + newLength - prevLength);
+        }
+      }
+
+      if ((*marker)->endOffset() > (unsigned)startOffset) {
+        if ((*marker)->endOffset() <= (unsigned)(startOffset + prevLength)) {
+          // Marker end was in the replaced text. Move to beginning of new text
+          (*marker)->setEndOffset(startOffset);
+        } else {
+          // Marker end was after the replaced text. Shift by length difference
+          unsigned oldEndOffset = (*marker)->endOffset();
+          (*marker)->setEndOffset(oldEndOffset + newLength - prevLength);
+        }
+      }
+
       didShiftMarker = true;
     }
   }
 
   if (didShiftMarker) {
     invalidateRectsForMarkersInNode(*node);
     // repaint the affected node
     if (node->layoutObject())
       node->layoutObject()->setShouldDoFullPaintInvalidation();
   }
@@ skipping 92 matching lines @@
 #endif
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->showMarkers();
 }
 #endif