Adding a word to dictionary should remove spelling markers

Source/core/dom/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.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 13 matching lines @@
  *
  */
 
 #include "config.h"
 #include "core/dom/DocumentMarkerController.h"
 
 #include "core/dom/Node.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Range.h"
 #include "core/dom/RenderedDocumentMarker.h"
+#include "core/dom/Text.h"
 #include "core/editing/TextIterator.h"
 #include "core/rendering/RenderObject.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);
+}
+
 namespace {
 
 DocumentMarker::MarkerTypeIndex MarkerTypeToMarkerIndex(DocumentMarker::MarkerType type)
 {
     switch (type) {
     case DocumentMarker::Spelling:
         return DocumentMarker::SpellingMarkerIndex;
     case DocumentMarker::Grammar:
         return DocumentMarker::GramarMarkerIndex;
     case DocumentMarker::TextMatch:
@@ skipping 434 matching lines @@
 {
     if (!possiblyHasMarkers(markerTypes))
         return;
     ASSERT(!m_markers.isEmpty());
 
     MarkerMap::iterator iterator = m_markers.find(node);
     if (iterator != m_markers.end())
         removeMarkersFromList(iterator, markerTypes);
 }
 
+void DocumentMarkerController::removeMarkers(const MarkerRemoverPredicate& shouldRemoveMarker)
+{
+    for (MarkerMap::iterator i = m_markers.begin(); i != m_markers.end(); ++i) {
+        MarkerLists* markers = i->value.get();
+        for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
+            OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
+
+            Vector<RenderedDocumentMarker *> markersToBeRemoved;

[tkent, 2014/08/14 01:17:14]

|Vector<RenderedDocumentMarker *>| should be
|WillBeHeapVector<RawPtrWillBeMember<RenderedDocumentMarker> >|.

[Klemen Forstnerič, 2014/08/14 16:42:53]

Done.

+            for (size_t j = 0; list.get() && j < list->size(); ++j) {
+                if (i->key->isTextNode() && shouldRemoveMarker(*list->at(j).get(), static_cast<const Text&>(*i->key)))
+                    markersToBeRemoved.append(list->at(j).get());
+            }
+
+            for (size_t j = 0; j < markersToBeRemoved.size(); ++j)
+                list->remove(list->find(markersToBeRemoved[j]));
+        }
+    }
+}
+
 void DocumentMarkerController::removeMarkers(DocumentMarker::MarkerTypes markerTypes)
 {
     if (!possiblyHasMarkers(markerTypes))
         return;
     ASSERT(!m_markers.isEmpty());
 
     Vector<const Node*> nodesWithMarkers;
     copyKeysToVector(m_markers, nodesWithMarkers);
     unsigned size = nodesWithMarkers.size();
     for (unsigned i = 0; i < size; ++i) {
@@ skipping 222 matching lines @@
 
 } // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller)
 {
     if (controller)
         controller->showMarkers();
 }
 #endif