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 10 matching lines @@
 
       // cause the node to be redrawn
       if (LayoutObject* layoutObject = node->layoutObject()) {
         layoutObject->setShouldDoFullPaintInvalidation();
         break;
       }
     }
   }
 }
 
 void DocumentMarkerController::shiftMarkers(Node* node,

[yosin_UTC9, 2017/02/15 02:23:25]

Let's make this function as didUpdateCharacterData().

-                                            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);
+  }
+
   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