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

third_party/WebKit/Source/modules/accessibility/AXObjectCacheImpl.cpp

 /*
  * Copyright (C) 2014, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 472 matching lines @@
 
   ASSERT(m_objects.size() >= m_idsInUse.size());
 }
 
 void AXObjectCacheImpl::remove(LayoutObject* layoutObject) {
   if (!layoutObject)
     return;
 
   AXID axID = m_layoutObjectMapping.get(layoutObject);
   remove(axID);
-  m_layoutObjectMapping.remove(layoutObject);
+  m_layoutObjectMapping.erase(layoutObject);
 }
 
 void AXObjectCacheImpl::remove(Node* node) {
   if (!node)
     return;
 
   // This is all safe even if we didn't have a mapping.
   AXID axID = m_nodeObjectMapping.get(node);
   remove(axID);
-  m_nodeObjectMapping.remove(node);
+  m_nodeObjectMapping.erase(node);
 
   if (node->layoutObject()) {
     remove(node->layoutObject());
     return;
   }
 }
 
 void AXObjectCacheImpl::remove(AbstractInlineTextBox* inlineTextBox) {
   if (!inlineTextBox)
     return;
 
   AXID axID = m_inlineTextBoxObjectMapping.get(inlineTextBox);
   remove(axID);
-  m_inlineTextBoxObjectMapping.remove(inlineTextBox);
+  m_inlineTextBoxObjectMapping.erase(inlineTextBox);
 }
 
 AXID AXObjectCacheImpl::platformGenerateAXID() const {
   static AXID lastUsedID = 0;
 
   // Generate a new ID.
   AXID objID = lastUsedID;
   do {
     ++objID;
   } while (!objID || HashTraits<AXID>::isDeletedValue(objID) ||
@@ skipping 28 matching lines @@
   if (!objID)
     return;
   ASSERT(!HashTraits<AXID>::isDeletedValue(objID));
   ASSERT(m_idsInUse.contains(objID));
   object->setAXObjectID(0);
   m_idsInUse.remove(objID);
 
   if (m_ariaOwnerToChildrenMapping.contains(objID)) {
     Vector<AXID> childAXIDs = m_ariaOwnerToChildrenMapping.get(objID);
     for (size_t i = 0; i < childAXIDs.size(); ++i)
-      m_ariaOwnedChildToOwnerMapping.remove(childAXIDs[i]);
-    m_ariaOwnerToChildrenMapping.remove(objID);
+      m_ariaOwnedChildToOwnerMapping.erase(childAXIDs[i]);
+    m_ariaOwnerToChildrenMapping.erase(objID);
   }
-  m_ariaOwnedChildToOwnerMapping.remove(objID);
-  m_ariaOwnedChildToRealParentMapping.remove(objID);
-  m_ariaOwnerToIdsMapping.remove(objID);
+  m_ariaOwnedChildToOwnerMapping.erase(objID);
+  m_ariaOwnedChildToRealParentMapping.erase(objID);
+  m_ariaOwnerToIdsMapping.erase(objID);
 }
 
 void AXObjectCacheImpl::selectionChanged(Node* node) {
   // Find the nearest ancestor that already has an accessibility object, since
   // we might be in the middle of a layout.
   while (node) {
     if (AXObject* obj = get(node)) {
       obj->selectionChanged();
       return;
     }
@@ skipping 141 matching lines @@
       owners->insert(owner->axObjectID());
     }
   }
   for (const String& id : currentIds) {
     if (!newIds.contains(id)) {
       idsChanged = true;
       HashSet<AXID>* owners = m_idToAriaOwnersMapping.get(id);
       if (owners) {
         owners->remove(owner->axObjectID());
         if (owners->isEmpty())
-          m_idToAriaOwnersMapping.remove(id);
+          m_idToAriaOwnersMapping.erase(id);
       }
     }
   }
   if (idsChanged)
     m_ariaOwnerToIdsMapping.set(owner->axObjectID(), newIds);
 
   //
   // Now figure out the ids that actually correspond to children that exist and
   // that we can legally own (not cyclical, not already owned, etc.) and update
   // the maps and |ownedChildren| based on that.
@@ skipping 61 matching lines @@
     AXID removedChildID = currentChildAXIDs[i];
     AXObject* removedChild = objectFromAXID(removedChildID);
 
     // It's possible that this child has already been owned by some other owner,
     // in which case we don't need to do anything.
     if (removedChild && getAriaOwnedParent(removedChild) != owner)
       continue;
 
     // Remove it from the child -> owner mapping so it's not owned by this owner
     // anymore.
-    m_ariaOwnedChildToOwnerMapping.remove(removedChildID);
+    m_ariaOwnedChildToOwnerMapping.erase(removedChildID);
 
     if (removedChild) {
       // If the child still exists, find its "real" parent, and reparent it back
       // to its real parent in the tree by detaching it from its current parent
       // and calling childrenChanged on its real parent.
       removedChild->detachFromParent();
       AXID realParentID =
           m_ariaOwnedChildToRealParentMapping.get(removedChildID);
       AXObject* realParent = objectFromAXID(realParentID);
       childrenChanged(realParent);
     }
 
     // Remove the child -> original parent mapping too since this object has now
     // been reparented back to its original parent.
-    m_ariaOwnedChildToRealParentMapping.remove(removedChildID);
+    m_ariaOwnedChildToRealParentMapping.erase(removedChildID);
   }
 
   for (size_t i = 0; i < newChildAXIDs.size(); ++i) {
     // Find the AXObject for the child that will now be a child of this owner.
     AXID addedChildID = newChildAXIDs[i];
     AXObject* addedChild = objectFromAXID(addedChildID);
 
     // Add this child to the mapping from child to owner.
     m_ariaOwnedChildToOwnerMapping.set(addedChildID, owner->axObjectID());
 
@@ skipping 411 matching lines @@
   visitor->trace(m_document);
   visitor->trace(m_nodeObjectMapping);
 
   visitor->trace(m_objects);
   visitor->trace(m_notificationsToPost);
 
   AXObjectCache::trace(visitor);
 }
 
 }  // namespace blink