Clean up DocumentMarkerController::copyMarkers() (now it's moveMarkers())

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 176 matching lines @@
 static bool CompareByStart(const Member<DocumentMarker>& lhv,
                            const Member<DocumentMarker>& rhv) {
   return lhv->StartOffset() < rhv->StartOffset();
 }
 
 static bool DoesNotOverlap(const Member<RenderedDocumentMarker>& lhv,
                            const DocumentMarker* rhv) {
   return lhv->EndOffset() < rhv->StartOffset();
 }
 
-static bool DoesNotInclude(const Member<RenderedDocumentMarker>& marker,
-                           size_t start_offset) {
-  return marker->EndOffset() < start_offset;
-}
-
 static void UpdateMarkerRenderedRect(const Node& node,
                                      RenderedDocumentMarker& marker) {
   Range* range = Range::Create(node.GetDocument());
   // The offsets of the marker may be out-dated, so check for exceptions.
   DummyExceptionStateForTesting exception_state;
   range->setStart(&const_cast<Node&>(node), marker.StartOffset(),
                   exception_state);
   if (!exception_state.HadException()) {
     range->setEnd(&const_cast<Node&>(node), marker.EndOffset(),
                   IGNORE_EXCEPTION_FOR_TESTING);
@@ skipping 67 matching lines @@
   for (MarkerList::iterator i = first_overlapping;
        i != list->end() && (*i)->StartOffset() <= (*inserted)->EndOffset();) {
     (*inserted)->SetStartOffset(
         std::min((*inserted)->StartOffset(), (*i)->StartOffset()));
     (*inserted)->SetEndOffset(
         std::max((*inserted)->EndOffset(), (*i)->EndOffset()));
     list->erase(i - list->begin());
   }
 }
 
-// copies markers from srcNode to dstNode, applying the specified shift delta to
-// the copies. The shift is useful if, e.g., the caller has created the dstNode
-// from a non-prefix substring of the srcNode.
-void DocumentMarkerController::CopyMarkers(Node* src_node,
-                                           unsigned start_offset,
+// Moves markers from src_node to dst_node. Markers are moved if their start
+// offset is less than length. Markers that run past that point are truncated.
+void DocumentMarkerController::MoveMarkers(Node* src_node,
                                            int length,
-                                           Node* dst_node,
-                                           int delta) {
+                                           Node* dst_node) {
   if (length <= 0)
     return;
 
   if (!PossiblyHasMarkers(DocumentMarker::AllMarkers()))
     return;
   DCHECK(!markers_.IsEmpty());
 
   MarkerLists* markers = markers_.at(src_node);
   if (!markers)
     return;
 
   bool doc_dirty = false;
   for (Member<MarkerList> list : *markers) {
     if (!list)
       continue;
 
-    unsigned end_offset = start_offset + length - 1;
-    MarkerList::iterator start_pos = std::lower_bound(
-        list->begin(), list->end(), start_offset, DoesNotInclude);
-    for (MarkerList::iterator i = start_pos; i != list->end(); ++i) {
-      DocumentMarker* marker = i->Get();
+    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)
         break;
 
-      // pin the marker to the specified range and apply the shift delta
+      // pin the marker to the specified range
       doc_dirty = true;
-      if (marker->StartOffset() < start_offset)
-        marker->SetStartOffset(start_offset);
       if (marker->EndOffset() > end_offset)
         marker->SetEndOffset(end_offset);
-      marker->ShiftOffsets(delta);
 
       AddMarker(dst_node, *marker);
     }
+
+    // Remove the range of markers that were moved to dstNode
+    list->erase(0, it - list->begin());
   }
 
   // repaint the affected node
   if (doc_dirty && dst_node->GetLayoutObject()) {
     dst_node->GetLayoutObject()->SetShouldDoFullPaintInvalidation(
         kPaintInvalidationDocumentMarkerChange);
   }
 }
 
 void DocumentMarkerController::RemoveMarkers(
@@ skipping 530 matching lines @@
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->ShowMarkers();
 }
 #endif