Migrate WTF::HashMap::get() to ::at()

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 171 matching lines @@
   if (obj->accessibilityIsIgnored())
     obj = obj->parentObjectUnignored();
 
   return obj;
 }
 
 AXObject* AXObjectCacheImpl::get(LayoutObject* layoutObject) {
   if (!layoutObject)
     return 0;
 
-  AXID axID = m_layoutObjectMapping.get(layoutObject);
+  AXID axID = m_layoutObjectMapping.at(layoutObject);
   ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
   if (!axID)
     return 0;
 
-  return m_objects.get(axID);
+  return m_objects.at(axID);
 }
 
 // Returns true if |node| is an <option> element and its parent <select>
 // is a menu list (not a list box).
 static bool isMenuListOption(Node* node) {
   if (!isHTMLOptionElement(node))
     return false;
   HTMLSelectElement* select = toHTMLOptionElement(node)->ownerSelectElement();
   if (!select)
     return false;
   LayoutObject* layoutObject = select->layoutObject();
   return layoutObject && layoutObject->isMenuList();
 }
 
 AXObject* AXObjectCacheImpl::get(Node* node) {
   if (!node)
     return 0;
 
   // Menu list option and HTML area elements are indexed by DOM node, never by
   // layout object.
   LayoutObject* layoutObject = node->layoutObject();
   if (isMenuListOption(node) || isHTMLAreaElement(node))
     layoutObject = nullptr;
 
-  AXID layoutID = layoutObject ? m_layoutObjectMapping.get(layoutObject) : 0;
+  AXID layoutID = layoutObject ? m_layoutObjectMapping.at(layoutObject) : 0;
   ASSERT(!HashTraits<AXID>::isDeletedValue(layoutID));
 
-  AXID nodeID = m_nodeObjectMapping.get(node);
+  AXID nodeID = m_nodeObjectMapping.at(node);
   ASSERT(!HashTraits<AXID>::isDeletedValue(nodeID));
 
   if (layoutObject && nodeID && !layoutID) {
     // This can happen if an AXNodeObject is created for a node that's not
     // laid out, but later something changes and it gets a layoutObject (like if
     // it's reparented).
     remove(nodeID);
     return 0;
   }
 
   if (layoutID)
-    return m_objects.get(layoutID);
+    return m_objects.at(layoutID);
 
   if (!nodeID)
     return 0;
 
-  return m_objects.get(nodeID);
+  return m_objects.at(nodeID);
 }
 
 AXObject* AXObjectCacheImpl::get(AbstractInlineTextBox* inlineTextBox) {
   if (!inlineTextBox)
     return 0;
 
-  AXID axID = m_inlineTextBoxObjectMapping.get(inlineTextBox);
+  AXID axID = m_inlineTextBoxObjectMapping.at(inlineTextBox);
   ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
   if (!axID)
     return 0;
 
-  return m_objects.get(axID);
+  return m_objects.at(axID);
 }
 
 // FIXME: This probably belongs on Node.
 // FIXME: This should take a const char*, but one caller passes nullAtom.
 bool nodeHasRole(Node* node, const String& role) {
   if (!node || !node->isElementNode())
     return false;
 
   return equalIgnoringCase(toElement(node)->getAttribute(roleAttr), role);
 }
@@ skipping 198 matching lines @@
   m_objects.set(obj->axObjectID(), obj);
   obj->init();
   return obj;
 }
 
 void AXObjectCacheImpl::remove(AXID axID) {
   if (!axID)
     return;
 
   // first fetch object to operate some cleanup functions on it
-  AXObject* obj = m_objects.get(axID);
+  AXObject* obj = m_objects.at(axID);
   if (!obj)
     return;
 
   obj->detach();
   removeAXID(obj);
 
   // finally remove the object
   if (!m_objects.take(axID))
     return;
 
   ASSERT(m_objects.size() >= m_idsInUse.size());
 }
 
 void AXObjectCacheImpl::remove(LayoutObject* layoutObject) {
   if (!layoutObject)
     return;
 
-  AXID axID = m_layoutObjectMapping.get(layoutObject);
+  AXID axID = m_layoutObjectMapping.at(layoutObject);
   remove(axID);
   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);
+  AXID axID = m_nodeObjectMapping.at(node);
   remove(axID);
   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);
+  AXID axID = m_inlineTextBoxObjectMapping.at(inlineTextBox);
   remove(axID);
   m_inlineTextBoxObjectMapping.erase(inlineTextBox);
 }
 
 AXID AXObjectCacheImpl::platformGenerateAXID() const {
   static AXID lastUsedID = 0;
 
   // Generate a new ID.
   AXID objID = lastUsedID;
   do {
@@ skipping 28 matching lines @@
 
   AXID objID = object->axObjectID();
   if (!objID)
     return;
   ASSERT(!HashTraits<AXID>::isDeletedValue(objID));
   ASSERT(m_idsInUse.contains(objID));
   object->setAXObjectID(0);
   m_idsInUse.erase(objID);
 
   if (m_ariaOwnerToChildrenMapping.contains(objID)) {
-    Vector<AXID> childAXIDs = m_ariaOwnerToChildrenMapping.get(objID);
+    Vector<AXID> childAXIDs = m_ariaOwnerToChildrenMapping.at(objID);
     for (size_t i = 0; i < childAXIDs.size(); ++i)
       m_ariaOwnedChildToOwnerMapping.erase(childAXIDs[i]);
     m_ariaOwnerToChildrenMapping.erase(objID);
   }
   m_ariaOwnedChildToOwnerMapping.erase(objID);
   m_ariaOwnedChildToRealParentMapping.erase(objID);
   m_ariaOwnerToIdsMapping.erase(objID);
 }
 
 void AXObjectCacheImpl::selectionChanged(Node* node) {
@@ skipping 109 matching lines @@
   m_notificationsToPost.push_back(std::make_pair(object, notification));
   if (!m_notificationPostTimer.isActive())
     m_notificationPostTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 bool AXObjectCacheImpl::isAriaOwned(const AXObject* child) const {
   return m_ariaOwnedChildToOwnerMapping.contains(child->axObjectID());
 }
 
 AXObject* AXObjectCacheImpl::getAriaOwnedParent(const AXObject* child) const {
-  return objectFromAXID(
-      m_ariaOwnedChildToOwnerMapping.get(child->axObjectID()));
+  return objectFromAXID(m_ariaOwnedChildToOwnerMapping.at(child->axObjectID()));
 }
 
 void AXObjectCacheImpl::updateAriaOwns(
     const AXObject* owner,
     const Vector<String>& idVector,
     HeapVector<Member<AXObject>>& ownedChildren) {
   //
   // Update the map from the AXID of this element to the ids of the owned
   // children, and the reverse map from ids to possible AXID owners.
   //
 
-  HashSet<String> currentIds = m_ariaOwnerToIdsMapping.get(owner->axObjectID());
+  HashSet<String> currentIds = m_ariaOwnerToIdsMapping.at(owner->axObjectID());
   HashSet<String> newIds;
   bool idsChanged = false;
   for (const String& id : idVector) {
     newIds.insert(id);
     if (!currentIds.contains(id)) {
       idsChanged = true;
-      HashSet<AXID>* owners = m_idToAriaOwnersMapping.get(id);
+      HashSet<AXID>* owners = m_idToAriaOwnersMapping.at(id);
       if (!owners) {
         owners = new HashSet<AXID>();
         m_idToAriaOwnersMapping.set(id, WTF::wrapUnique(owners));
       }
       owners->insert(owner->axObjectID());
     }
   }
   for (const String& id : currentIds) {
     if (!newIds.contains(id)) {
       idsChanged = true;
-      HashSet<AXID>* owners = m_idToAriaOwnersMapping.get(id);
+      HashSet<AXID>* owners = m_idToAriaOwnersMapping.at(id);
       if (owners) {
         owners->erase(owner->axObjectID());
         if (owners->isEmpty())
           m_idToAriaOwnersMapping.erase(id);
       }
     }
   }
   if (idsChanged)
     m_ariaOwnerToIdsMapping.set(owner->axObjectID(), newIds);
 
@@ skipping 37 matching lines @@
     if (foundCycle)
       continue;
 
     newChildAXIDs.push_back(child->axObjectID());
     ownedChildren.push_back(child);
   }
 
   // Compare this to the current list of owned children, and exit early if there
   // are no changes.
   Vector<AXID> currentChildAXIDs =
-      m_ariaOwnerToChildrenMapping.get(owner->axObjectID());
+      m_ariaOwnerToChildrenMapping.at(owner->axObjectID());
   bool same = true;
   if (currentChildAXIDs.size() != newChildAXIDs.size()) {
     same = false;
   } else {
     for (size_t i = 0; i < currentChildAXIDs.size() && same; ++i) {
       if (currentChildAXIDs[i] != newChildAXIDs[i])
         same = false;
     }
   }
   if (same)
@@ skipping 15 matching lines @@
     // Remove it from the child -> owner mapping so it's not owned by this owner
     // anymore.
     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);
+          m_ariaOwnedChildToRealParentMapping.at(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.erase(removedChildID);
   }
 
   for (size_t i = 0; i < newChildAXIDs.size(); ++i) {
@@ skipping 19 matching lines @@
 
   // Finally, update the mapping from the owner to the list of child IDs.
   m_ariaOwnerToChildrenMapping.set(owner->axObjectID(), newChildAXIDs);
 }
 
 void AXObjectCacheImpl::updateTreeIfElementIdIsAriaOwned(Element* element) {
   if (!element->hasID())
     return;
 
   String id = element->getIdAttribute();
-  HashSet<AXID>* owners = m_idToAriaOwnersMapping.get(id);
+  HashSet<AXID>* owners = m_idToAriaOwnersMapping.at(id);
   if (!owners)
     return;
 
   AXObject* axElement = getOrCreate(element);
   if (!axElement)
     return;
 
   // If it's already owned, call childrenChanged on the owner to make sure it's
   // still an owner.
   if (isAriaOwned(axElement)) {
@@ skipping 378 matching lines @@
   visitor->trace(m_document);
   visitor->trace(m_nodeObjectMapping);
 
   visitor->trace(m_objects);
   visitor->trace(m_notificationsToPost);
 
   AXObjectCache::trace(visitor);
 }
 
 }  // namespace blink