[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 31 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() {
   m_spelling.clear();
   m_grammar.clear();
   m_textMatches.clear();
   m_compositions.clear();
 }
 
-void DocumentMarkerController::addMarker(const Position& start,
-                                         const Position& end,
-                                         DocumentMarker::MarkerType type,
-                                         const String& description) {
-  // Use a TextIterator to visit the potentially multiple nodes the range
-  // covers.
-  for (TextIterator markedText(start, end); !markedText.atEnd();
-       markedText.advance()) {
-    addMarker(markedText.currentContainer(),
-              new DocumentMarker(
-                  type, markedText.startOffsetInCurrentContainer(),
-                  markedText.endOffsetInCurrentContainer(), description));
-  }
-}
-
-void DocumentMarkerController::addTextMatchMarker(const EphemeralRange& range,
-                                                  bool activeMatch) {
-  DCHECK(!m_document->needsLayoutTreeUpdate());
-
-  // Use a TextIterator to visit the potentially multiple nodes the range
-  // covers.
-  for (TextIterator markedText(range.startPosition(), range.endPosition());
-       !markedText.atEnd(); markedText.advance()) {
-    addMarker(markedText.currentContainer(),
-              new DocumentMarker(markedText.startOffsetInCurrentContainer(),
-                                 markedText.endOffsetInCurrentContainer(),
-                                 activeMatch));
-  }
-  // Don't invalidate tickmarks here. TextFinder invalidates tickmarks using a
-  // throttling algorithm. crbug.com/6819.
-}
-
 void DocumentMarkerController::addCompositionMarker(const Position& start,
                                                     const Position& end,
                                                     Color underlineColor,
                                                     bool thick,
                                                     Color backgroundColor) {
   DCHECK(!m_document->needsLayoutTreeUpdate());
 
   for (TextIterator markedText(start, end); !markedText.atEnd();
        markedText.advance()) {
     addMarker(markedText.currentContainer(),
-              new DocumentMarker(markedText.startOffsetInCurrentContainer(),
-                                 markedText.endOffsetInCurrentContainer(),
-                                 underlineColor, thick, backgroundColor));
+              DocumentMarker::createCompositionMarker(
+                  markedText.startOffsetInCurrentContainer(),
+                  markedText.endOffsetInCurrentContainer(), underlineColor,
+                  thick, backgroundColor));
   }
 }
 
+void DocumentMarkerController::addGrammarOrSpellingMarker(
+    const Position& start,
+    const Position& end,
+    DocumentMarker::MarkerType type,
+    const String& description) {
+  DCHECK(!m_document->needsLayoutTreeUpdate());
+  DCHECK(type == DocumentMarker::Grammar || type == DocumentMarker::Spelling);
+  // Use a TextIterator to visit the potentially multiple nodes the range
+  // covers.
+  for (TextIterator markedText(start, end); !markedText.atEnd();
+       markedText.advance()) {
+    DocumentMarker* marker;
+    if (type == DocumentMarker::Grammar) {
+      marker = DocumentMarker::createGrammarMarker(
+          markedText.startOffsetInCurrentContainer(),
+          markedText.endOffsetInCurrentContainer(), description);
+    } else {
+      marker = DocumentMarker::createSpellingMarker(
+          markedText.startOffsetInCurrentContainer(),
+          markedText.endOffsetInCurrentContainer(), description);
+    }
+
+    addMarker(markedText.currentContainer(), marker);
+  }
+}
+
+void DocumentMarkerController::addGrammarMarker(const Position& start,
+                                                const Position& end,
+                                                const String& description) {
+  addGrammarOrSpellingMarker(start, end, DocumentMarker::Grammar, description);
+}
+
+void DocumentMarkerController::addSpellingMarker(const Position& start,
+                                                 const Position& end,
+                                                 const String& description) {
+  addGrammarOrSpellingMarker(start, end, DocumentMarker::Spelling, description);
+}
+
+void DocumentMarkerController::addTextMatchMarker(const Position& start,
+                                                  const Position& end,
+                                                  bool activeMatch) {
+  DCHECK(!m_document->needsLayoutTreeUpdate());
+
+  // Use a TextIterator to visit the potentially multiple nodes the range
+  // covers.
+  for (TextIterator markedText(start, end); !markedText.atEnd();
+       markedText.advance()) {
+    addMarker(markedText.currentContainer(),
+              DocumentMarker::createTextMatchMarker(
+                  markedText.startOffsetInCurrentContainer(),
+                  markedText.endOffsetInCurrentContainer(), activeMatch));
+  }
+  // Don't invalidate tickmarks here. TextFinder invalidates tickmarks using a
+  // throttling algorithm. crbug.com/6819.
+}
+
 void DocumentMarkerController::prepareForDestruction() {
   clear();
 }
 
 void DocumentMarkerController::removeMarkers(
     const EphemeralRange& range,
     DocumentMarker::MarkerTypes markerTypes,
     RemovePartiallyOverlappingMarkerOrNot
         shouldRemovePartiallyOverlappingMarker) {
   DCHECK(!m_document->needsLayoutTreeUpdate());
@@ skipping 163 matching lines @@
       if (node == startContainer && marker->endOffset() <= startOffset)
         continue;
       if (node == endContainer && marker->startOffset() >= endOffset)
         continue;
       foundMarkers.push_back(marker);
     }
   }
   return foundMarkers;
 }
 
-Vector<IntRect> DocumentMarkerController::renderedRectsForMarkers(
-    DocumentMarker::MarkerType) {
+Vector<IntRect> DocumentMarkerController::renderedRectsForTextMatchMarkers() {
   Vector<IntRect> result;
 
   // outer loop: process each node
   for (auto nodeIterator = m_textMatches.begin();
        nodeIterator != m_textMatches.end(); ++nodeIterator) {
     // inner loop; process each marker in this node
     const Node& node = *nodeIterator->key;
     TextMatchMarkerList* list = nodeIterator->value.get();
 #if DCHECK_IS_ON()
     if (!list->empty()) {
@@ skipping 11 matching lines @@
   }
 
   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;
 
   TextMatchMarkerList& markerList = *(m_textMatches.find(&node)->value);
 
   for (Member<DocumentMarker> marker : markerList) {
     auto renderedTextMatchMarker = toRenderedTextMatchMarkerOrDie(marker.get());
     renderedTextMatchMarker->invalidate();
   }
 
   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) {
   if (markerTypes.contains(DocumentMarker::Spelling))
     m_spelling.remove(node);
 
   if (markerTypes.contains(DocumentMarker::Grammar))
     m_grammar.remove(node);
 
   if (markerTypes.contains(DocumentMarker::TextMatch))
     m_textMatches.remove(node);
 
   if (markerTypes.contains(DocumentMarker::Composition))
     m_compositions.remove(node);
 }
 
+void DocumentMarkerController::removeSpellingMarkersForWords(
+    const Vector<String>& words) {
+  for (auto& nodeMarkers : m_spelling) {
+    const Node& node = *nodeMarkers.key;
+    if (!node.isTextNode())
+      continue;
+    nodeMarkers.value->removeMarkersForWords(static_cast<const Text&>(node),
+                                             words);
+  }
+}
+
 void DocumentMarkerController::removeMarkers(
     DocumentMarker::MarkerTypes markerTypes) {
   if (markerTypes.contains(DocumentMarker::Spelling))
     m_spelling.clear();
 
   if (markerTypes.contains(DocumentMarker::Grammar))
     m_grammar.clear();
 
   if (markerTypes.contains(DocumentMarker::TextMatch))
     m_textMatches.clear();
 
   if (markerTypes.contains(DocumentMarker::Composition))
     m_compositions.clear();
 }
 
-void DocumentMarkerController::removeMarkers(
-    const MarkerRemoverPredicate& shouldRemoveMarker) {
-  for (auto& nodeMarkers : m_spelling) {
-    const Node& node = *nodeMarkers.key;
-    if (!node.isTextNode())
-      continue;
-    nodeMarkers.value->removeMarkersForWords(static_cast<const Text&>(node),
-                                             shouldRemoveMarker.m_words);
-  }
-}
-
 void DocumentMarkerController::repaintMarkers(
     DocumentMarker::MarkerTypes markerTypes) {
   HeapHashSet<Member<Node>> nodesToRepaint;
   for (auto& nodeMarkers : m_spelling) {
     if (!nodeMarkers.value->empty())
       nodesToRepaint.insert(nodeMarkers.key.get());
   }
 
   for (auto& nodeMarkers : m_grammar) {
     if (!nodeMarkers.value->empty())
@@ skipping 13 matching lines @@
   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 {
   return m_spelling.contains(node) || m_grammar.contains(node) ||
          m_textMatches.contains(node) || m_compositions.contains(node);
 }
 
-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 = m_textMatches.at(node)->setTextMatchMarkersActive(
         startOffset, endOffset, active);
   }
 
   if (docDirty && node->layoutObject())
     node->layoutObject()->setShouldDoFullPaintInvalidation(
         PaintInvalidationDocumentMarkerChange);
 
@@ skipping 135 matching lines @@
   shiftMarkersInNode(&m_spelling, node, offset, oldLength, newLength,
                      &didShiftMarker);
   shiftMarkersInNode(&m_grammar, node, offset, oldLength, newLength,
                      &didShiftMarker);
   shiftMarkersInNode(&m_textMatches, node, offset, oldLength, newLength,
                      &didShiftMarker);
   shiftMarkersInNode(&m_compositions, node, offset, oldLength, newLength,
                      &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