[DMC #1.91] Rewrite loops in DocumentMarkerController to use ListForType()

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 234 matching lines @@
   if (!src_markers)
     return;
 
   if (!markers_.Contains(dst_node)) {
     markers_.insert(dst_node,
                     new MarkerLists(DocumentMarker::kMarkerTypeIndexesCount));
   }
   MarkerLists* dst_markers = markers_.at(dst_node);
 
   bool doc_dirty = false;
-  for (size_t marker_list_index = 0; marker_list_index < src_markers->size();
-       ++marker_list_index) {
-    MarkerList* src_list = src_markers->at(marker_list_index);
+  for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+    MarkerList* src_list = ListForType(src_markers, type);
     if (!src_list)
       continue;
 
-    if (!dst_markers->at(marker_list_index))
-      dst_markers->at(marker_list_index) = new MarkerList;
-    MarkerList* dst_list = dst_markers->at(marker_list_index);
+    if (!ListForType(dst_markers, type))
+      ListForType(dst_markers, type) = new MarkerList;
+    MarkerList* dst_list = ListForType(dst_markers, type);
 
     if (DocumentMarkerListEditor::MoveMarkers(src_list, length, dst_list))
       doc_dirty = true;
   }
 
   // repaint the affected node
   if (doc_dirty && dst_node->GetLayoutObject()) {
     dst_node->GetLayoutObject()->SetShouldDoFullPaintInvalidation(
         kPaintInvalidationDocumentMarkerChange);
   }
@@ skipping 10 matching lines @@
   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 (size_t marker_list_index = 0;
-       marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-       ++marker_list_index) {
-    Member<MarkerList>& list = (*markers)[marker_list_index];
+  for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+    Member<MarkerList>& list = ListForType(markers, type);
     if (!list || list->IsEmpty()) {
       if (list.Get() && list->IsEmpty())
         list.Clear();
       ++empty_lists_count;
       continue;
     }
-    if (!marker_types.Contains((*list->begin())->GetType()))
+    if (!marker_types.Contains(type))
       continue;
 
     if (DocumentMarkerListEditor::RemoveMarkers(list, start_offset, length))
       doc_dirty = true;
 
     if (list->IsEmpty()) {
       list.Clear();
       ++empty_lists_count;
     }
   }
@@ skipping 13 matching lines @@
 
 DocumentMarkerVector DocumentMarkerController::MarkersFor(
     Node* node,
     DocumentMarker::MarkerTypes marker_types) {
   DocumentMarkerVector result;
 
   MarkerLists* markers = markers_.at(node);
   if (!markers)
     return result;
 
-  for (size_t marker_list_index = 0;
-       marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-       ++marker_list_index) {
-    Member<MarkerList>& list = (*markers)[marker_list_index];
+  for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+    Member<MarkerList>& list = ListForType(markers, type);
     if (!list || list->IsEmpty() ||
         !marker_types.Contains((*list->begin())->GetType()))
       continue;
 
     for (size_t i = 0; i < list->size(); ++i)
       result.push_back(list->at(i).Get());
   }
 
   std::sort(result.begin(), result.end(),
             [](const Member<DocumentMarker>& marker1,
                const Member<DocumentMarker>& marker2) {
               return marker1->StartOffset() < marker2->StartOffset();
             });
   return result;
 }
 
 DocumentMarkerVector DocumentMarkerController::Markers() {
   DocumentMarkerVector result;
   for (MarkerMap::iterator i = markers_.begin(); i != markers_.end(); ++i) {
     MarkerLists* markers = i->value.Get();
-    for (size_t marker_list_index = 0;
-         marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-         ++marker_list_index) {
-      Member<MarkerList>& list = (*markers)[marker_list_index];
+    for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+      Member<MarkerList>& list = ListForType(markers, type);
       for (size_t j = 0; list.Get() && j < list->size(); ++j)
         result.push_back(list->at(j).Get());
     }
   }
   std::sort(result.begin(), result.end(),
             [](const Member<DocumentMarker>& marker1,
                const Member<DocumentMarker>& marker2) {
               return marker1->StartOffset() < marker2->StartOffset();
             });
   return result;
@@ skipping 40 matching lines @@
 
   // 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();
-    for (size_t marker_list_index = 0;
-         marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-         ++marker_list_index) {
-      Member<MarkerList>& list = (*markers)[marker_list_index];
-      if (!list || list->IsEmpty() ||
-          (*list->begin())->GetType() != marker_type)
+    for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+      Member<MarkerList>& list = ListForType(markers, type);
+      if (!list || list->IsEmpty() || type != marker_type)
         continue;
       for (unsigned marker_index = 0; marker_index < list->size();
            ++marker_index) {
         RenderedDocumentMarker* marker = list->at(marker_index).Get();
         UpdateMarkerRenderedRectIfNeeded(node, *marker);
         if (!marker->IsRendered())
           continue;
         result.push_back(marker->RenderedRect());
       }
     }
@@ skipping 65 matching lines @@
   if (iterator != markers_.end())
     RemoveMarkersFromList(iterator, marker_types);
 }
 
 void DocumentMarkerController::RemoveMarkers(
     const MarkerRemoverPredicate& should_remove_marker) {
   for (auto& node_markers : markers_) {
     const Node& node = *node_markers.key;
     if (!node.IsTextNode())  // MarkerRemoverPredicate requires a Text node.
       continue;
-    MarkerLists& markers = *node_markers.value;
-    for (size_t marker_list_index = 0;
-         marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-         ++marker_list_index) {
-      Member<MarkerList>& list = markers[marker_list_index];
+    MarkerLists* markers = node_markers.value;
+    for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+      Member<MarkerList>& list = ListForType(markers, type);
       if (!list)
         continue;
       bool removed_markers = false;
       for (size_t j = list->size(); j > 0; --j) {
         if (should_remove_marker(*list->at(j - 1),
                                  static_cast<const Text&>(node))) {
           list->erase(j - 1);
           removed_markers = true;
         }
       }
-      if (removed_markers &&
-          marker_list_index == DocumentMarker::kTextMatchMarkerIndex)
+      if (removed_markers && type == DocumentMarker::kTextMatch)
         InvalidatePaintForTickmarks(node);
     }
   }
 }
 
 void DocumentMarkerController::RemoveMarkers(
     DocumentMarker::MarkerTypes marker_types) {
   if (!PossiblyHasMarkers(marker_types))
     return;
   DCHECK(!markers_.IsEmpty());
@@ skipping 16 matching lines @@
   bool needs_repainting = false;
   bool node_can_be_removed;
 
   size_t empty_lists_count = 0;
   if (marker_types == DocumentMarker::AllMarkers()) {
     needs_repainting = true;
     node_can_be_removed = true;
   } else {
     MarkerLists* markers = iterator->value.Get();
 
-    for (size_t marker_list_index = 0;
-         marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-         ++marker_list_index) {
-      Member<MarkerList>& list = (*markers)[marker_list_index];
+    for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+      Member<MarkerList>& list = ListForType(markers, type);
       if (!list || list->IsEmpty()) {
         if (list.Get() && list->IsEmpty())
           list.Clear();
         ++empty_lists_count;
         continue;
       }
-      if (marker_types.Contains((*list->begin())->GetType())) {
+      if (marker_types.Contains(type)) {
         list->clear();
         list.Clear();
         ++empty_lists_count;
         needs_repainting = true;
       }
     }
 
     node_can_be_removed =
         empty_lists_count == DocumentMarker::kMarkerTypeIndexesCount;
   }
@@ skipping 20 matching lines @@
     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 (size_t marker_list_index = 0;
-         marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-         ++marker_list_index) {
-      Member<MarkerList>& list = (*markers)[marker_list_index];
-      if (!list || list->IsEmpty() ||
-          !marker_types.Contains((*list->begin())->GetType()))
+    for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+      Member<MarkerList>& 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(
             kPaintInvalidationDocumentMarkerChange);
         break;
       }
     }
   }
@@ skipping 63 matching lines @@
 
 #ifndef NDEBUG
 void DocumentMarkerController::ShowMarkers() const {
   StringBuilder builder;
   MarkerMap::const_iterator end = markers_.end();
   for (MarkerMap::const_iterator node_iterator = markers_.begin();
        node_iterator != end; ++node_iterator) {
     const Node* node = node_iterator->key;
     builder.Append(String::Format("%p", node));
     MarkerLists* markers = markers_.at(node);
-    for (size_t marker_list_index = 0;
-         marker_list_index < DocumentMarker::kMarkerTypeIndexesCount;
-         ++marker_list_index) {
-      Member<MarkerList>& list = (*markers)[marker_list_index];
+    for (DocumentMarker::MarkerType type : DocumentMarker::AllMarkers()) {
+      Member<MarkerList>& list = ListForType(markers, type);
       for (unsigned marker_index = 0; list.Get() && marker_index < list->size();
            ++marker_index) {
         DocumentMarker* marker = list->at(marker_index).Get();
         builder.Append(" ");
         builder.AppendNumber(marker->GetType());
         builder.Append(":[");
         builder.AppendNumber(marker->StartOffset());
         builder.Append(":");
         builder.AppendNumber(marker->EndOffset());
         builder.Append("](");
@@ skipping 41 matching lines @@
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->ShowMarkers();
 }
 #endif