Fix bug causing DCHECKs to be hit in DocumentMarkerController

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 146 matching lines @@
 void DocumentMarkerController::PrepareForDestruction() {
   Clear();
 }
 
 void DocumentMarkerController::RemoveMarkers(
     TextIterator& marked_text,
     DocumentMarker::MarkerTypes marker_types) {
   for (; !marked_text.AtEnd(); marked_text.Advance()) {
     if (!PossiblyHasMarkers(marker_types))
       return;
-    DCHECK(!markers_.IsEmpty());

[yosin_UTC9, 2017/05/18 04:29:08]

Rather than removing DCHECK, how about changing PossiblyHasMarkers(..) to check
markers_.IsEmpty()?

For example:
bool DocumentMarkerController::PossiblyHasMarkers(
    DocumentMarker::MarkerTypes types) {
  return !markes_.IsEmpty() &&
possibly_existing_marker_types_.Intersects(types);
}

In this way, we can get small patch. ;-)

 
     int start_offset = marked_text.StartOffsetInCurrentContainer();
     int end_offset = marked_text.EndOffsetInCurrentContainer();
     RemoveMarkersInternal(marked_text.CurrentContainer(), start_offset,
                           end_offset - start_offset, marker_types);
   }
 }
 
 void DocumentMarkerController::RemoveMarkersInRange(
     const EphemeralRange& range,
@@ skipping 60 matching lines @@
 // Moves markers from src_node to dst_node. Markers are moved if their start
 // offset is less than length. Markers that run past that point are truncated.
 void DocumentMarkerController::MoveMarkers(Node* src_node,
                                            int length,
                                            Node* dst_node) {
   if (length <= 0)
     return;
 
   if (!PossiblyHasMarkers(DocumentMarker::AllMarkers()))
     return;
-  DCHECK(!markers_.IsEmpty());
 
   MarkerLists* src_markers = markers_.at(src_node);
   if (!src_markers)
     return;
 
   if (!markers_.Contains(dst_node)) {
     markers_.insert(dst_node,
                     new MarkerLists(DocumentMarker::kMarkerTypeIndexesCount));
   }
   MarkerLists* dst_markers = markers_.at(dst_node);
@@ skipping 22 matching lines @@
 void DocumentMarkerController::RemoveMarkersInternal(
     Node* node,
     unsigned start_offset,
     int length,
     DocumentMarker::MarkerTypes marker_types) {
   if (length <= 0)
     return;
 
   if (!PossiblyHasMarkers(marker_types))
     return;
-  DCHECK(!(markers_.IsEmpty()));
 
   MarkerLists* markers = markers_.at(node);
   if (!markers)
     return;
 
   bool doc_dirty = false;
   size_t empty_lists_count = 0;
   for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
     DocumentMarkerList* const list = ListForType(markers, type);
     if (!list || list->IsEmpty()) {
@@ skipping 87 matching lines @@
             });
   return result;
 }
 
 Vector<IntRect> DocumentMarkerController::RenderedRectsForMarkers(
     DocumentMarker::MarkerType marker_type) {
   Vector<IntRect> result;
 
   if (!PossiblyHasMarkers(marker_type))
     return result;
-  DCHECK(!(markers_.IsEmpty()));
 
   // outer loop: process each node
   MarkerMap::iterator end = markers_.end();
   for (MarkerMap::iterator node_iterator = markers_.begin();
        node_iterator != end; ++node_iterator) {
     // inner loop; process each marker in this node
     const Node& node = *node_iterator->key;
     if (!node.isConnected())
       continue;
     MarkerLists* markers = node_iterator->value.Get();
@@ skipping 68 matching lines @@
   visitor->Trace(markers_);
   visitor->Trace(document_);
   SynchronousMutationObserver::Trace(visitor);
 }
 
 void DocumentMarkerController::RemoveMarkersForNode(
     Node* node,
     DocumentMarker::MarkerTypes marker_types) {
   if (!PossiblyHasMarkers(marker_types))
     return;
-  DCHECK(!markers_.IsEmpty());
 
   MarkerMap::iterator iterator = markers_.find(node);
   if (iterator != markers_.end())
     RemoveMarkersFromList(iterator, marker_types);
 }
 
 void DocumentMarkerController::RemoveSpellingMarkersUnderWords(
     const Vector<String>& words) {
   for (auto& node_markers : markers_) {
     const Node& node = *node_markers.key;
     if (!node.IsTextNode())
       continue;
     MarkerLists* markers = node_markers.value;
     for (DocumentMarker::MarkerType type :
          DocumentMarker::MisspellingMarkers()) {
       DocumentMarkerList* const list = ListForType(markers, type);
       if (!list)
         continue;
       ToSpellCheckMarkerListImpl(list)->RemoveMarkersUnderWords(
           ToText(node).data(), words);
     }
   }
 }
 
 void DocumentMarkerController::RemoveMarkersOfTypes(
     DocumentMarker::MarkerTypes marker_types) {
   if (!PossiblyHasMarkers(marker_types))
     return;
-  DCHECK(!markers_.IsEmpty());
 
   HeapVector<Member<const Node>> nodes_with_markers;
   CopyKeysToVector(markers_, nodes_with_markers);
   unsigned size = nodes_with_markers.size();
   for (unsigned i = 0; i < size; ++i) {
     MarkerMap::iterator iterator = markers_.find(nodes_with_markers[i]);
     if (iterator != markers_.end())
       RemoveMarkersFromList(iterator, marker_types);
   }
 
@@ skipping 46 matching lines @@
     markers_.erase(iterator);
     if (markers_.IsEmpty())
       possibly_existing_marker_types_ = 0;
   }
 }
 
 void DocumentMarkerController::RepaintMarkers(
     DocumentMarker::MarkerTypes marker_types) {
   if (!PossiblyHasMarkers(marker_types))
     return;
-  DCHECK(!markers_.IsEmpty());
 
   // outer loop: process each markered node in the document
   MarkerMap::iterator end = markers_.end();
   for (MarkerMap::iterator i = markers_.begin(); i != end; ++i) {
     const Node* node = i->key;
 
     // inner loop: process each marker in the current node
     MarkerLists* markers = i->value.Get();
     for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
       DocumentMarkerList* const list = ListForType(markers, type);
       if (!list || list->IsEmpty() || !marker_types.Contains(type))
         continue;
 
       // cause the node to be redrawn
       if (LayoutObject* layout_object = node->GetLayoutObject()) {
         layout_object->SetShouldDoFullPaintInvalidation(
             PaintInvalidationReason::kDocumentMarker);
         break;
       }
     }
   }
 }
 
 bool DocumentMarkerController::SetMarkersActive(const EphemeralRange& range,
                                                 bool active) {
   if (!PossiblyHasMarkers(DocumentMarker::AllMarkers()))
     return false;
 
-  DCHECK(!markers_.IsEmpty());
-
   Node* const start_container = range.StartPosition().ComputeContainerNode();
   DCHECK(start_container);
   Node* const end_container = range.EndPosition().ComputeContainerNode();
   DCHECK(end_container);
 
   const unsigned container_start_offset =
       range.StartPosition().ComputeOffsetInContainerNode();
   const unsigned container_end_offset =
       range.EndPosition().ComputeOffsetInContainerNode();
 
@@ skipping 81 matching lines @@
 }
 #endif
 
 // SynchronousMutationObserver
 void DocumentMarkerController::DidUpdateCharacterData(CharacterData* node,
                                                       unsigned offset,
                                                       unsigned old_length,
                                                       unsigned new_length) {
   if (!PossiblyHasMarkers(DocumentMarker::AllMarkers()))
     return;
-  DCHECK(!markers_.IsEmpty());
 
   MarkerLists* markers = markers_.at(node);
   if (!markers)
     return;
 
   bool did_shift_marker = false;
   for (DocumentMarkerList* const list : *markers) {
     if (!list)
       continue;
 
@@ skipping 11 matching lines @@
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->ShowMarkers();
 }
 #endif