Improve how DocumentMarkerController updates markers in response to text edits

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 161 matching lines @@
   TextIterator marked_text(range.StartPosition(), range.EndPosition());
   DocumentMarkerController::RemoveMarkers(
       marked_text, marker_types, should_remove_partially_overlapping_marker);
 }
 
 static bool StartsFurther(const Member<RenderedDocumentMarker>& lhv,
                           const DocumentMarker* rhv) {
   return lhv->StartOffset() < rhv->StartOffset();
 }
 
-static bool StartsAfter(const Member<RenderedDocumentMarker>& marker,
-                        size_t start_offset) {
-  return marker->StartOffset() < start_offset;
-}
-
 static bool EndsBefore(size_t start_offset,
                        const Member<RenderedDocumentMarker>& rhv) {
   return start_offset < rhv->EndOffset();
 }
 
 static bool CompareByStart(const Member<DocumentMarker>& lhv,
                            const Member<DocumentMarker>& rhv) {
   return lhv->StartOffset() < rhv->StartOffset();
 }
 
@@ skipping 99 matching lines @@
 
   if (!PossiblyHasMarkers(DocumentMarker::AllMarkers()))
     return;
   DCHECK(!markers_.IsEmpty());
 
   MarkerLists* markers = markers_.at(src_node);
   if (!markers)
     return;
 
   bool doc_dirty = false;
-  for (size_t marker_list_index = 0;
-       marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-       ++marker_list_index) {
-    Member<MarkerList>& list = (*markers)[marker_list_index];
+  for (Member<MarkerList> list : *markers) {
     if (!list)
       continue;
 
     unsigned end_offset = length - 1;
     MarkerList::iterator it;
     for (it = list->begin(); it != list->end(); ++it) {
       DocumentMarker* marker = it->Get();
 
       // stop if we are now past the specified range
       if (marker->StartOffset() > end_offset)
@@ skipping 403 matching lines @@
       // cause the node to be redrawn
       if (LayoutObject* layout_object = node->GetLayoutObject()) {
         layout_object->SetShouldDoFullPaintInvalidation(
             kPaintInvalidationDocumentMarkerChange);
         break;
       }
     }
   }
 }
 
-void DocumentMarkerController::ShiftMarkers(Node* node,
-                                            unsigned start_offset,
-                                            int delta) {
-  if (!PossiblyHasMarkers(DocumentMarker::AllMarkers()))
-    return;
-  DCHECK(!markers_.IsEmpty());
-
-  MarkerLists* markers = markers_.at(node);
-  if (!markers)
-    return;
-
-  bool did_shift_marker = false;
-  for (size_t marker_list_index = 0;
-       marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-       ++marker_list_index) {
-    Member<MarkerList>& list = (*markers)[marker_list_index];
-    if (!list)
-      continue;
-    MarkerList::iterator start_pos =
-        std::lower_bound(list->begin(), list->end(), start_offset, StartsAfter);
-    for (MarkerList::iterator marker = start_pos; marker != list->end();
-         ++marker) {
-#if DCHECK_IS_ON()
-      int start_offset = (*marker)->StartOffset();
-      DCHECK_GE(start_offset + delta, 0);
-#endif
-      (*marker)->ShiftOffsets(delta);
-      did_shift_marker = true;
-    }
-  }
-
-  if (did_shift_marker) {
-    InvalidateRectsForMarkersInNode(*node);
-    // repaint the affected node
-    if (node->GetLayoutObject()) {
-      node->GetLayoutObject()->SetShouldDoFullPaintInvalidation(
-          kPaintInvalidationDocumentMarkerChange);
-    }
-  }
-}
-
 bool DocumentMarkerController::SetMarkersActive(const EphemeralRange& range,
                                                 bool active) {
   if (!PossiblyHasMarkers(DocumentMarker::AllMarkers()))
     return false;
 
   DCHECK(!markers_.IsEmpty());
 
   Node* const start_container = range.StartPosition().ComputeContainerNode();
   DCHECK(start_container);
   Node* const end_container = range.EndPosition().ComputeContainerNode();
@@ skipping 79 matching lines @@
   LOG(INFO) << markers_.size() << " nodes have markers:\n"
             << builder.ToString().Utf8().Data();
 }
 #endif
 
 // SynchronousMutationObserver
 void DocumentMarkerController::DidUpdateCharacterData(CharacterData* node,
                                                       unsigned offset,
                                                       unsigned old_length,
                                                       unsigned new_length) {
-  // Shift markers as if we first remove the old text, then insert the new text
-  RemoveMarkers(node, offset, old_length);
-  ShiftMarkers(node, offset + old_length, 0 - old_length);
-  ShiftMarkers(node, offset, new_length);
+  if (!PossiblyHasMarkers(DocumentMarker::AllMarkers()))
+    return;
+  DCHECK(!markers_.IsEmpty());
+
+  MarkerLists* markers = markers_.at(node);
+  if (!markers)
+    return;
+
+  bool did_shift_marker = false;
+  for (MarkerList* list : *markers) {
+    if (!list)
+      continue;
+
+    for (MarkerList::iterator it = list->begin(); it != list->end(); ++it) {
+      RenderedDocumentMarker& marker = **it;
+      Optional<DocumentMarker::MarkerOffsets> result =
+          marker.ComputeOffsetsAfterShift(offset, old_length, new_length);
+      if (result == WTF::kNullopt) {
+        list->erase(it - list->begin());
+        --it;
+        did_shift_marker = true;
+        continue;
+      }
+
+      if (marker.StartOffset() != result.value().start_offset ||
+          marker.EndOffset() != result.value().end_offset) {
+        did_shift_marker = true;
+        marker.SetStartOffset(result.value().start_offset);
+        marker.SetEndOffset(result.value().end_offset);
+      }
+    }
+  }
+
+  if (!did_shift_marker)
+    return;
+  if (!node->GetLayoutObject())
+    return;
+  InvalidateRectsForMarkersInNode(*node);
+  // repaint the affected node
+  node->GetLayoutObject()->SetShouldDoFullPaintInvalidation();
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->ShowMarkers();
 }
 #endif