Rewrite DocumentMarkerController to use SynchronousMutationObserver

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 66 matching lines @@
   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) {}
+DocumentMarkerController::DocumentMarkerController(Document& document)
+    : m_possiblyExistingMarkerTypes(0), m_document(&document) {
+  setContext(&document);
+}
 
 void DocumentMarkerController::clear() {
   m_markers.clear();
   m_possiblyExistingMarkerTypes = 0;
 }
 
 void DocumentMarkerController::addMarker(const Position& start,
                                          const Position& end,
                                          DocumentMarker::MarkerType type,
                                          const String& description,
@@ skipping 72 matching lines @@
   TextIterator markedText(range.startPosition(), range.endPosition());
   DocumentMarkerController::removeMarkers(
       markedText, markerTypes, shouldRemovePartiallyOverlappingMarker);
 }
 
 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 385 matching lines @@
 
       if (markerList->front()->type() == DocumentMarker::TextMatch)
         invalidatePaintForTickmarks(node);
     }
   }
 }
 
 DEFINE_TRACE(DocumentMarkerController) {
   visitor->trace(m_markers);
   visitor->trace(m_document);
+  SynchronousMutationObserver::trace(visitor);
 }
 
 void DocumentMarkerController::removeMarkers(
     Node* node,
     DocumentMarker::MarkerTypes markerTypes) {
   if (!possiblyHasMarkers(markerTypes))
     return;
   DCHECK(!m_markers.isEmpty());
 
   MarkerMap::iterator iterator = m_markers.find(node);
@@ skipping 89 matching lines @@
     invalidatePaintForTickmarks(node);
   }
 
   if (nodeCanBeRemoved) {
     m_markers.remove(iterator);
     if (m_markers.isEmpty())
       m_possiblyExistingMarkerTypes = 0;
   }
 }
 
+void DocumentMarkerController::removeZeroLengthMarkers() {
+  for (auto& nodeMarkers : m_markers) {
+    const Node& node = *nodeMarkers.key;
+    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 (list->at(j - 1)->startOffset() == list->at(j - 1)->endOffset()) {
+          list->remove(j - 1);
+          removedMarkers = true;
+        }
+      }
+      if (removedMarkers &&
+          markerListIndex == DocumentMarker::TextMatchMarkerIndex)
+        invalidatePaintForTickmarks(node);
+    }
+  }
+}
+
 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();
   for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
     const Node* node = i->key;
@@ skipping 11 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 we're doing a pure remove operation, remove the markers in the range
+  // being removed (markers containing, but larger than, the range, will be
+  // split)
+  if (newLength == 0) {
+    removeMarkers(node, startOffset, prevLength);

[rlanday, 2017/02/14 02:05:29]

There is a slight behavioral change introduced here, there are cases where we
would previously remove a marker when doing a text replacement where we now keep
the marker around and make it include the new text. This change didn't seem to
break any test cases but it's probably something to watch out for.

+  }
+
   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();
+
+    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 is contained by but not equal to the replaced range, remove
+      // the marker
+      if (((unsigned)startOffset <= (*marker)->startOffset() &&
+           (*marker)->endOffset() < (unsigned)(startOffset + prevLength)) ||
+          ((unsigned)startOffset < (*marker)->startOffset() &&
+           (*marker)->endOffset() <= (unsigned)(startOffset + prevLength))) {
+        list->remove(marker - list->begin());
+        marker--;
+        continue;
+      }
+
+      // algorithm inspired by https://dom.spec.whatwg.org/#concept-cd-replace
+      // but with some changes
+      if ((*marker)->startOffset() > (unsigned)startOffset) {
+        // Deviation from the concept-cd-replace algorithm: < instead of <= in
+        // the next line
+        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) {
+        // Deviation from the concept-cd-replace algorithm: < instead of <= in
+        // the next line
+        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) {
+    removeZeroLengthMarkers();
     invalidateRectsForMarkersInNode(*node);
     // repaint the affected node
     if (node->layoutObject())
       node->layoutObject()->setShouldDoFullPaintInvalidation();
   }
 }
 
 bool DocumentMarkerController::setMarkersActive(const EphemeralRange& range,
                                                 bool active) {
   if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
@@ skipping 79 matching lines @@
         builder.append(")");
       }
     }
     builder.append("\n");
   }
   LOG(INFO) << m_markers.size() << " nodes have markers:\n"
             << builder.toString().utf8().data();
 }
 #endif
 
+// SynchronousMutationObserver
+void DocumentMarkerController::didUpdateCharacterData(CharacterData* node,
+                                                      unsigned offset,
+                                                      unsigned oldLength,
+                                                      unsigned newLength) {
+  shiftMarkers(node, offset, oldLength, newLength);
+}
+
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->showMarkers();
 }
 #endif