Migrate WTF::Vector::remove() to ::erase()

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 267 matching lines @@
   size_t index = firstOverlapping - list->begin();
   list->insert(index, toInsert);
   MarkerList::iterator inserted = list->begin() + index;
   firstOverlapping = inserted + 1;
   for (MarkerList::iterator i = firstOverlapping;
        i != list->end() && (*i)->startOffset() <= (*inserted)->endOffset();) {
     (*inserted)->setStartOffset(
         std::min((*inserted)->startOffset(), (*i)->startOffset()));
     (*inserted)->setEndOffset(
         std::max((*inserted)->endOffset(), (*i)->endOffset()));
-    list->remove(i - list->begin());
+    list->erase(i - list->begin());
   }
 }
 
 // copies markers from srcNode to dstNode, applying the specified shift delta to
 // the copies. The shift is useful if, e.g., the caller has created the dstNode
 // from a non-prefix substring of the srcNode.
 void DocumentMarkerController::copyMarkers(Node* srcNode,
                                            unsigned startOffset,
                                            int length,
                                            Node* dstNode,
@@ skipping 86 matching lines @@
 
       // markers are returned in order, so stop if we are now past the specified
       // range
       if (marker.startOffset() >= endOffset)
         break;
 
       // at this point we know that marker and target intersect in some way
       docDirty = true;
 
       // pitch the old marker
-      list->remove(i - list->begin());
+      list->erase(i - list->begin());
 
       if (shouldRemovePartiallyOverlappingMarker) {
         // Stop here. Don't add resulting slices back.
         continue;
       }
 
       // add either of the resulting slices that are left after removing target
       if (startOffset > marker.startOffset()) {
         DocumentMarker newLeft = marker;
         newLeft.setEndOffset(startOffset);
@@ skipping 212 matching lines @@
     for (size_t markerListIndex = 0;
          markerListIndex < DocumentMarker::MarkerTypeIndexesCount;
          ++markerListIndex) {
       Member<MarkerList>& list = markers[markerListIndex];
       if (!list)
         continue;
       bool removedMarkers = false;
       for (size_t j = list->size(); j > 0; --j) {
         if (shouldRemoveMarker(*list->at(j - 1),
                                static_cast<const Text&>(node))) {
-          list->remove(j - 1);
+          list->erase(j - 1);
           removedMarkers = true;
         }
       }
       if (removedMarkers &&
           markerListIndex == DocumentMarker::TextMatchMarkerIndex)
         invalidatePaintForTickmarks(node);
     }
   }
 }
 
@@ skipping 244 matching lines @@
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller) {
   if (controller)
     controller->showMarkers();
 }
 #endif