[WIP] Clean up DocumentMarkerController API

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 30 matching lines @@
 #include "core/editing/markers/TextMatchMarkerList.h"
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutObject.h"
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
-MarkerRemoverPredicate::MarkerRemoverPredicate(const Vector<String>& words)
-    : m_words(words) {}
-
-bool MarkerRemoverPredicate::operator()(const DocumentMarker& documentMarker,
-                                        const Text& textNode) const {
-  unsigned start = documentMarker.startOffset();
-  unsigned length = documentMarker.endOffset() - documentMarker.startOffset();
-
-  String markerText = textNode.data().substring(start, length);
-  return m_words.contains(markerText);
-}
-
 DocumentMarkerController::DocumentMarkerController(Document& document)
     : m_document(&document) {
   setContext(&document);
 }
 
 void DocumentMarkerController::clear() {
   for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
     MarkerMap& markerMap = markerMapForType(type);
     markerMap.clear();
   }
@@ skipping 211 matching lines @@
       if (node == startContainer && marker->endOffset() <= startOffset)
         continue;
       if (node == endContainer && marker->startOffset() >= endOffset)
         continue;
       foundMarkers.push_back(marker);
     }
   }
   return foundMarkers;
 }
 
-// This method is only ever called with the type DocumentMarker::TextMatch
-// TODO(rlanday): remove the param
-Vector<IntRect> DocumentMarkerController::renderedRectsForMarkers(
-    DocumentMarker::MarkerType) {
+Vector<IntRect> DocumentMarkerController::renderedRectsForTextMatchMarkers() {
   Vector<IntRect> result;
   for (auto nodeIterator = m_textMatches.begin();
        nodeIterator != m_textMatches.end(); ++nodeIterator) {
     const Node& node = *nodeIterator->key;
     TextMatchMarkerList* list =
         toTextMatchMarkerList(nodeIterator->value.get());
 #if DCHECK_IS_ON()
     if (!list->empty()) {
       DCHECK(!m_document->view() || !m_document->view()->needsLayout());
       DCHECK(!m_document->needsLayoutTreeUpdate());
     }
 #endif
     list->appendRenderedRectsToInputList(node, &result);
   }
 
   return result;
 }
 
 static void invalidatePaintForTickmarks(const Node& node) {
   if (FrameView* frameView = node.document().view())
     frameView->invalidatePaintForTickmarks();
 }
 
-void DocumentMarkerController::invalidateRectsForMarkersInNode(Node& node) {
+void DocumentMarkerController::invalidateRectsForTextMatchMarkersInNode(
+    Node& node) {
   if (!m_textMatches.contains(&node))
     return;
 
   toTextMatchMarkerList(m_textMatches.find(&node)->value.get())
       ->invalidateRects();
   invalidatePaintForTickmarks(node);
 }
 
-void DocumentMarkerController::invalidateRectsForAllMarkers() {
+void DocumentMarkerController::invalidateRectsForAllTextMatchMarkers() {
   for (auto& nodeMarkers : m_textMatches)
-    invalidateRectsForMarkersInNode(*nodeMarkers.key);
+    invalidateRectsForTextMatchMarkersInNode(*nodeMarkers.key);
 }
 
 DEFINE_TRACE(DocumentMarkerController) {
   visitor->trace(m_spelling);
   visitor->trace(m_grammar);
   visitor->trace(m_textMatches);
   visitor->trace(m_compositions);
   visitor->trace(m_document);
   SynchronousMutationObserver::trace(visitor);
 }
 
 void DocumentMarkerController::removeMarkers(
     Node* node,
     DocumentMarker::MarkerTypes markerTypes) {
   for (DocumentMarker::MarkerType type : markerTypes) {
     MarkerMap& markerMap = markerMapForType(type);
     markerMap.erase(node);
   }
 }
 
 void DocumentMarkerController::removeMarkers(
     DocumentMarker::MarkerTypes markerTypes) {
   for (DocumentMarker::MarkerType type : markerTypes) {
     MarkerMap& markerMap = markerMapForType(type);
     markerMap.clear();
   }
 }
 
-void DocumentMarkerController::removeMarkers(
-    const MarkerRemoverPredicate& shouldRemoveMarker) {
+void DocumentMarkerController::removeSpellingMarkersForWords(
+    const Vector<String>& words) {
   for (auto& nodeMarkers : m_spelling) {
     const Node& node = *nodeMarkers.key;
     if (!node.isTextNode())
       continue;
     toSpellCheckMarkerList(nodeMarkers.value.get())
-        ->removeMarkersForWords(static_cast<const Text&>(node).data(),
-                                shouldRemoveMarker.m_words);
+        ->removeMarkersForWords(static_cast<const Text&>(node).data(), words);
   }
 }
 
 void DocumentMarkerController::repaintMarkers(
     DocumentMarker::MarkerTypes markerTypes) {
   HeapHashSet<Member<Node>> nodesToRepaint;
   for (DocumentMarker::MarkerType type : markerTypes) {
     MarkerMap& markerMap = markerMapForType(type);
     for (auto& nodeMarkers : markerMap) {
       if (!nodeMarkers.value->empty())
         nodesToRepaint.insert(nodeMarkers.key.get());
     }
   }
 
   for (Member<Node> node : nodesToRepaint) {
     // cause the node to be redrawn
     if (LayoutObject* layoutObject = node->layoutObject()) {
       layoutObject->setShouldDoFullPaintInvalidation(
           PaintInvalidationDocumentMarkerChange);
       break;
     }
   }
 }
 
-bool DocumentMarkerController::setMarkersActive(const EphemeralRange& range,
-                                                bool active) {
+bool DocumentMarkerController::setTextMatchMarkersActive(
+    const EphemeralRange& range,
+    bool active) {
   Node* const startContainer = range.startPosition().computeContainerNode();
   DCHECK(startContainer);
   Node* const endContainer = range.endPosition().computeContainerNode();
   DCHECK(endContainer);
 
   const unsigned containerStartOffset =
       range.startPosition().computeOffsetInContainerNode();
   const unsigned containerEndOffset =
       range.endPosition().computeOffsetInContainerNode();
 
   bool markerFound = false;
   for (Node& node : range.nodes()) {
     int startOffset = node == startContainer ? containerStartOffset : 0;
     int endOffset = node == endContainer ? containerEndOffset : INT_MAX;
-    markerFound |= setMarkersActive(&node, startOffset, endOffset, active);
+    markerFound |=
+        setTextMatchMarkersActive(&node, startOffset, endOffset, active);
   }
   return markerFound;
 }
 
 bool DocumentMarkerController::hasMarkers(Node* node) const {
   for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
     const MarkerMap& markerMap = markerMapForType(type);
     if (markerMap.contains(node))
       return true;
   }
 
   return false;
 }
 
-bool DocumentMarkerController::setMarkersActive(Node* node,
-                                                unsigned startOffset,
-                                                unsigned endOffset,
-                                                bool active) {
+bool DocumentMarkerController::setTextMatchMarkersActive(Node* node,
+                                                         unsigned startOffset,
+                                                         unsigned endOffset,
+                                                         bool active) {
   bool docDirty = false;
   if (m_textMatches.contains(node)) {
     docDirty = toTextMatchMarkerList(m_textMatches.at(node))
                    ->setTextMatchMarkersActive(startOffset, endOffset, active);
   }
 
   if (docDirty && node->layoutObject())
     node->layoutObject()->setShouldDoFullPaintInvalidation(
         PaintInvalidationDocumentMarkerChange);
 
@@ skipping 142 matching lines @@
     auto it = markerMap.find(node);
     if (it != markerMap.end()) {
       didShiftMarker =
           (it->value->shiftMarkers(offset, oldLength, newLength) ==
            DocumentMarkerList::DidShiftMarkerOrNot::DidShiftMarker) ||
           didShiftMarker;
     }
   }
 
   if (didShiftMarker) {
-    invalidateRectsForMarkersInNode(*node);
+    invalidateRectsForTextMatchMarkersInNode(*node);
     // repaint the affected node
     if (node->layoutObject()) {
       node->layoutObject()->setShouldDoFullPaintInvalidation(
           PaintInvalidationDocumentMarkerChange);
     }
   }
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->showMarkers();
 }
 #endif