Don't ever split DocumentMarkers on remove

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 128 matching lines @@
                              marked_text.EndOffsetInCurrentContainer(),
                              underline_color, thick, background_color));
 }
 
 void DocumentMarkerController::PrepareForDestruction() {
   Clear();
 }
 
 void DocumentMarkerController::RemoveMarkers(
     TextIterator& marked_text,
-    DocumentMarker::MarkerTypes marker_types,
-    RemovePartiallyOverlappingMarkerOrNot
-        should_remove_partially_overlapping_marker) {
+    DocumentMarker::MarkerTypes marker_types) {
   for (; !marked_text.AtEnd(); marked_text.Advance()) {
     if (!PossiblyHasMarkers(marker_types))
       return;
     DCHECK(!markers_.IsEmpty());
 
     int start_offset = marked_text.StartOffsetInCurrentContainer();
     int end_offset = marked_text.EndOffsetInCurrentContainer();
     RemoveMarkers(marked_text.CurrentContainer(), start_offset,
-                  end_offset - start_offset, marker_types,
-                  should_remove_partially_overlapping_marker);
+                  end_offset - start_offset, marker_types);
   }
 }
 
 void DocumentMarkerController::RemoveMarkers(
     const EphemeralRange& range,
-    DocumentMarker::MarkerTypes marker_types,
-    RemovePartiallyOverlappingMarkerOrNot
-        should_remove_partially_overlapping_marker) {
+    DocumentMarker::MarkerTypes marker_types) {
   DCHECK(!document_->NeedsLayoutTreeUpdate());
 
   TextIterator marked_text(range.StartPosition(), range.EndPosition());
-  DocumentMarkerController::RemoveMarkers(
-      marked_text, marker_types, should_remove_partially_overlapping_marker);
+  DocumentMarkerController::RemoveMarkers(marked_text, marker_types);
 }
 
 static bool StartsFurther(const Member<RenderedDocumentMarker>& lhv,
                           const DocumentMarker* rhv) {
   return lhv->StartOffset() < rhv->StartOffset();
 }
 
 static bool EndsBefore(size_t start_offset,
                        const Member<RenderedDocumentMarker>& rhv) {
   return start_offset < rhv->EndOffset();
@@ skipping 142 matching lines @@
   if (doc_dirty && dst_node->GetLayoutObject()) {
     dst_node->GetLayoutObject()->SetShouldDoFullPaintInvalidation(
         kPaintInvalidationDocumentMarkerChange);
   }
 }
 
 void DocumentMarkerController::RemoveMarkers(
     Node* node,
     unsigned start_offset,
     int length,
-    DocumentMarker::MarkerTypes marker_types,
-    RemovePartiallyOverlappingMarkerOrNot
-        should_remove_partially_overlapping_marker) {
+    DocumentMarker::MarkerTypes marker_types) {
   if (length <= 0)
     return;
 
   if (!PossiblyHasMarkers(marker_types))
     return;
   DCHECK(!(markers_.IsEmpty()));
 
   MarkerLists* markers = markers_.at(node);
   if (!markers)
     return;
@@ skipping 16 matching lines @@
     MarkerList::iterator start_pos =
         std::upper_bound(list->begin(), list->end(), start_offset, EndsBefore);
     for (MarkerList::iterator i = start_pos; i != list->end();) {
       DocumentMarker marker(*i->Get());
 
       // markers are returned in order, so stop if we are now past the specified
       // range
       if (marker.StartOffset() >= end_offset)
         break;
 
-      // at this point we know that marker and target intersect in some way
+      list->erase(i - list->begin());
       doc_dirty = true;
-
-      // pitch the old marker
-      list->erase(i - list->begin());
-
-      if (should_remove_partially_overlapping_marker) {
-        // Stop here. Don't add resulting slices back.
-        continue;
-      }
-
-      // add either of the resulting slices that are left after removing target
-      if (start_offset > marker.StartOffset()) {
-        DocumentMarker new_left = marker;
-        new_left.SetEndOffset(start_offset);
-        size_t insert_index = i - list->begin();
-        list->insert(insert_index, RenderedDocumentMarker::Create(new_left));
-        // Move to the marker after the inserted one.
-        i = list->begin() + insert_index + 1;
-      }
-      if (marker.EndOffset() > end_offset) {
-        DocumentMarker new_right = marker;
-        new_right.SetStartOffset(end_offset);
-        size_t insert_index = i - list->begin();
-        list->insert(insert_index, RenderedDocumentMarker::Create(new_right));
-        // Move to the marker after the inserted one.
-        i = list->begin() + insert_index + 1;
-      }
     }
 
     if (list->IsEmpty()) {
       list.Clear();
       ++empty_lists_count;
     }
   }
 
   if (empty_lists_count == DocumentMarker::kMarkerTypeIndexesCount) {
     markers_.erase(node);
@@ skipping 452 matching lines @@
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->ShowMarkers();
 }
 #endif