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

third_party/WebKit/Source/core/input/PointerEventManager.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/input/PointerEventManager.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
@@ skipping 199 matching lines @@
                                                               pointerEvent);
   boundaryEventDispatcher.sendBoundaryEvents(exitedTarget, enteredTarget);
 }
 
 void PointerEventManager::setNodeUnderPointer(PointerEvent* pointerEvent,
                                               EventTarget* target) {
   if (m_nodeUnderPointer.contains(pointerEvent->pointerId())) {
     EventTargetAttributes node =
         m_nodeUnderPointer.get(pointerEvent->pointerId());
     if (!target) {
-      m_nodeUnderPointer.remove(pointerEvent->pointerId());
+      m_nodeUnderPointer.erase(pointerEvent->pointerId());
     } else if (target !=
                m_nodeUnderPointer.get(pointerEvent->pointerId()).target) {
       m_nodeUnderPointer.set(pointerEvent->pointerId(),
                              EventTargetAttributes(target, false));
     }
     sendBoundaryEvents(node.target, target, pointerEvent);
   } else if (target) {
     m_nodeUnderPointer.add(pointerEvent->pointerId(),
                            EventTargetAttributes(target, false));
     sendBoundaryEvents(nullptr, target, pointerEvent);
@@ skipping 351 matching lines @@
                              pointerEvent, EventTypeNames::lostpointercapture));
   }
 
   if (pendingPointerCaptureTarget) {
     setNodeUnderPointer(pointerEvent, pendingPointerCaptureTarget);
     dispatchPointerEvent(pendingPointerCaptureTarget,
                          m_pointerEventFactory.createPointerCaptureEvent(
                              pointerEvent, EventTypeNames::gotpointercapture));
     m_pointerCaptureTarget.set(pointerId, pendingPointerCaptureTarget);
   } else {
-    m_pointerCaptureTarget.remove(pointerId);
+    m_pointerCaptureTarget.erase(pointerId);
   }
 }
 
 void PointerEventManager::removeTargetFromPointerCapturingMapping(
     PointerCapturingMap& map,
     const EventTarget* target) {
   // We could have kept a reverse mapping to make this deletion possibly
   // faster but it adds some code complication which might not be worth of
   // the performance improvement considering there might not be a lot of
   // active pointer or pointer captures at the same time.
   PointerCapturingMap tmp = map;
   for (PointerCapturingMap::iterator it = tmp.begin(); it != tmp.end(); ++it) {
     if (it->value == target)
-      map.remove(it->key);
+      map.erase(it->key);
   }
 }
 
 EventTarget* PointerEventManager::getCapturingNode(int pointerId) {
   if (m_pointerCaptureTarget.contains(pointerId))
     return m_pointerCaptureTarget.get(pointerId);
   return nullptr;
 }
 
 void PointerEventManager::removePointer(PointerEvent* pointerEvent) {
   int pointerId = pointerEvent->pointerId();
   if (m_pointerEventFactory.remove(pointerId)) {
-    m_pendingPointerCaptureTarget.remove(pointerId);
-    m_pointerCaptureTarget.remove(pointerId);
-    m_nodeUnderPointer.remove(pointerId);
+    m_pendingPointerCaptureTarget.erase(pointerId);
+    m_pointerCaptureTarget.erase(pointerId);
+    m_nodeUnderPointer.erase(pointerId);
   }
 }
 
 void PointerEventManager::elementRemoved(EventTarget* target) {
   removeTargetFromPointerCapturingMapping(m_pendingPointerCaptureTarget,
                                           target);
 }
 
 void PointerEventManager::setPointerCapture(int pointerId,
                                             EventTarget* target) {
@@ skipping 20 matching lines @@
   return m_pendingPointerCaptureTarget.get(pointerId) == target;
 }
 
 bool PointerEventManager::hasProcessedPointerCapture(
     int pointerId,
     const EventTarget* target) const {
   return m_pointerCaptureTarget.get(pointerId) == target;
 }
 
 void PointerEventManager::releasePointerCapture(int pointerId) {
-  m_pendingPointerCaptureTarget.remove(pointerId);
+  m_pendingPointerCaptureTarget.erase(pointerId);
 }
 
 bool PointerEventManager::isActive(const int pointerId) const {
   return m_pointerEventFactory.isActive(pointerId);
 }
 
 // This function checks the type of the pointer event to be touch as touch
 // pointer events are the only ones that are directly dispatched from the main
 // page managers to their target (event if target is in an iframe) and only
 // those managers will keep track of these pointer events.
@@ skipping 25 matching lines @@
     if (firstId > uniqueTouchEventId)
       return false;
     m_touchIdsForCanceledPointerdowns.takeFirst();
     if (firstId == uniqueTouchEventId)
       return true;
   }
   return false;
 }
 
 }  // namespace blink