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

third_party/WebKit/Source/core/events/PointerEventFactory.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/events/PointerEventFactory.h"
 
 #include "core/frame/FrameView.h"
 #include "platform/geometry/FloatSize.h"
 
 namespace blink {
@@ skipping 331 matching lines @@
 
   return PointerEvent::create(type, pointerEventInit);
 }
 
 PointerEvent* PointerEventFactory::createPointerCancelEvent(
     const int pointerId,
     const WebPointerProperties::PointerType pointerType) {
   DCHECK(m_pointerIdMapping.contains(pointerId));
   m_pointerIdMapping.set(
       pointerId,
-      PointerAttributes(m_pointerIdMapping.get(pointerId).incomingId, false));
+      PointerAttributes(m_pointerIdMapping.at(pointerId).incomingId, false));
 
   PointerEventInit pointerEventInit;
 
   pointerEventInit.setPointerId(pointerId);
   pointerEventInit.setPointerType(
       pointerTypeNameForWebPointPointerType(pointerType));
   pointerEventInit.setIsPrimary(isPrimary(pointerId));
 
   setEventSpecificFields(pointerEventInit, EventTypeNames::pointercancel);
 
@@ skipping 85 matching lines @@
 
 int PointerEventFactory::addIdAndActiveButtons(const IncomingId p,
                                                bool isActiveButtons) {
   // Do not add extra mouse pointer as it was added in initialization
   if (p.pointerType() == WebPointerProperties::PointerType::Mouse) {
     m_pointerIdMapping.set(s_mouseId, PointerAttributes(p, isActiveButtons));
     return s_mouseId;
   }
 
   if (m_pointerIncomingIdMapping.contains(p)) {
-    int mappedId = m_pointerIncomingIdMapping.get(p);
+    int mappedId = m_pointerIncomingIdMapping.at(p);
     m_pointerIdMapping.set(mappedId, PointerAttributes(p, isActiveButtons));
     return mappedId;
   }
   int typeInt = p.pointerTypeInt();
   // We do not handle the overflow of m_currentId as it should be very rare
   int mappedId = m_currentId++;
   if (!m_idCount[typeInt])
     m_primaryId[typeInt] = mappedId;
   m_idCount[typeInt]++;
   m_pointerIncomingIdMapping.insert(p, mappedId);
   m_pointerIdMapping.insert(mappedId, PointerAttributes(p, isActiveButtons));
   return mappedId;
 }
 
 bool PointerEventFactory::remove(const int mappedId) {
   // Do not remove mouse pointer id as it should always be there
   if (mappedId == s_mouseId || !m_pointerIdMapping.contains(mappedId))
     return false;
 
-  IncomingId p = m_pointerIdMapping.get(mappedId).incomingId;
+  IncomingId p = m_pointerIdMapping.at(mappedId).incomingId;
   int typeInt = p.pointerTypeInt();
   m_pointerIdMapping.erase(mappedId);
   m_pointerIncomingIdMapping.erase(p);
   if (m_primaryId[typeInt] == mappedId)
     m_primaryId[typeInt] = PointerEventFactory::s_invalidId;
   m_idCount[typeInt]--;
   return true;
 }
 
 Vector<int> PointerEventFactory::getPointerIdsOfType(
     WebPointerProperties::PointerType pointerType) const {
   Vector<int> mappedIds;
 
   for (auto iter = m_pointerIdMapping.begin(); iter != m_pointerIdMapping.end();
        ++iter) {
     int mappedId = iter->key;
     if (iter->value.incomingId.pointerType() == pointerType)
       mappedIds.push_back(mappedId);
   }
 
   // Sorting for a predictable ordering.
   std::sort(mappedIds.begin(), mappedIds.end());
   return mappedIds;
 }
 
 bool PointerEventFactory::isPrimary(int mappedId) const {
   if (!m_pointerIdMapping.contains(mappedId))
     return false;
 
-  IncomingId p = m_pointerIdMapping.get(mappedId).incomingId;
+  IncomingId p = m_pointerIdMapping.at(mappedId).incomingId;
   return m_primaryId[p.pointerTypeInt()] == mappedId;
 }
 
 bool PointerEventFactory::isActive(const int pointerId) const {
   return m_pointerIdMapping.contains(pointerId);
 }
 
 bool PointerEventFactory::isActiveButtonsState(const int pointerId) const {
   return m_pointerIdMapping.contains(pointerId) &&
-         m_pointerIdMapping.get(pointerId).isActiveButtons;
+         m_pointerIdMapping.at(pointerId).isActiveButtons;
 }
 
 WebPointerProperties::PointerType PointerEventFactory::getPointerType(
     int pointerId) const {
   if (!isActive(pointerId))
     return WebPointerProperties::PointerType::Unknown;
-  return m_pointerIdMapping.get(pointerId).incomingId.pointerType();
+  return m_pointerIdMapping.at(pointerId).incomingId.pointerType();
 }
 
 int PointerEventFactory::getPointerEventId(
     const WebPointerProperties& properties) const {
   if (properties.pointerType == WebPointerProperties::PointerType::Mouse)
     return PointerEventFactory::s_mouseId;
   IncomingId id(properties.pointerType, properties.id);
   if (m_pointerIncomingIdMapping.contains(id))
-    return m_pointerIncomingIdMapping.get(id);
+    return m_pointerIncomingIdMapping.at(id);
   return PointerEventFactory::s_invalidId;
 }
 
 }  // namespace blink