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

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 132 matching lines @@
   if (!target)
     return WebInputEventResult::NotHandled;
 
   // Set whether node under pointer has received pointerover or not.
   const int pointerId = pointerEvent->pointerId();
 
   const AtomicString& eventType = pointerEvent->type();
   if ((eventType == EventTypeNames::pointerout ||
        eventType == EventTypeNames::pointerover) &&
       m_nodeUnderPointer.contains(pointerId)) {
-    EventTarget* targetUnderPointer = m_nodeUnderPointer.get(pointerId).target;
+    EventTarget* targetUnderPointer = m_nodeUnderPointer.at(pointerId).target;
     if (targetUnderPointer == target) {
       m_nodeUnderPointer.set(
           pointerId,
           EventTargetAttributes(targetUnderPointer,
                                 eventType == EventTypeNames::pointerover));
     }
   }
 
   if (!RuntimeEnabledFeatures::pointerEventEnabled())
     return WebInputEventResult::NotHandled;
@@ skipping 48 matching lines @@
                                              PointerEvent* pointerEvent) {
   PointerEventBoundaryEventDispatcher boundaryEventDispatcher(this,
                                                               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());
+        m_nodeUnderPointer.at(pointerEvent->pointerId());
     if (!target) {
       m_nodeUnderPointer.erase(pointerEvent->pointerId());
     } else if (target !=
-               m_nodeUnderPointer.get(pointerEvent->pointerId()).target) {
+               m_nodeUnderPointer.at(pointerEvent->pointerId()).target) {
       m_nodeUnderPointer.set(pointerEvent->pointerId(),
                              EventTargetAttributes(target, false));
     }
     sendBoundaryEvents(node.target, target, pointerEvent);
   } else if (target) {
     m_nodeUnderPointer.insert(pointerEvent->pointerId(),
                               EventTargetAttributes(target, false));
     sendBoundaryEvents(nullptr, target, pointerEvent);
   }
 }
 
 void PointerEventManager::blockTouchPointers() {
   if (m_inCanceledStateForPointerTypeTouch)
     return;
   m_inCanceledStateForPointerTypeTouch = true;
 
   Vector<int> touchPointerIds = m_pointerEventFactory.getPointerIdsOfType(
       WebPointerProperties::PointerType::Touch);
 
   for (int pointerId : touchPointerIds) {
     PointerEvent* pointerEvent = m_pointerEventFactory.createPointerCancelEvent(
         pointerId, WebPointerProperties::PointerType::Touch);
 
     DCHECK(m_nodeUnderPointer.contains(pointerId));
-    EventTarget* target = m_nodeUnderPointer.get(pointerId).target;
+    EventTarget* target = m_nodeUnderPointer.at(pointerId).target;
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, target);
 
     // TODO(nzolghadr): This event follows implicit TE capture. The actual
     // target would depend on PE capturing. Perhaps need to split TE/PE event
     // path upstream?  crbug.com/579553.
     dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent);
 
@@ skipping 98 matching lines @@
         // refactor it better after this investigation.
         if (node->isTextNode())
           node = FlatTreeTraversal::parent(*node);
         touchInfo.touchNode = node;
       }
     } else {
       // Set the target of pointer event to the captured node as this
       // pointer is captured otherwise it would have gone to the if block
       // and perform a hit-test.
       touchInfo.touchNode =
-          m_pendingPointerCaptureTarget.get(pointerId)->toNode();
+          m_pendingPointerCaptureTarget.at(pointerId)->toNode();
       touchInfo.targetFrame = touchInfo.touchNode->document().frame();
     }
 
     touchInfos.push_back(touchInfo);
   }
 }
 
 void PointerEventManager::dispatchTouchPointerEvents(
     const WebTouchEvent& event,
     const Vector<WebTouchEvent>& coalescedEvents,
@@ skipping 225 matching lines @@
   // 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.erase(it->key);
   }
 }
 
 EventTarget* PointerEventManager::getCapturingNode(int pointerId) {
   if (m_pointerCaptureTarget.contains(pointerId))
-    return m_pointerCaptureTarget.get(pointerId);
+    return m_pointerCaptureTarget.at(pointerId);
   return nullptr;
 }
 
 void PointerEventManager::removePointer(PointerEvent* pointerEvent) {
   int pointerId = pointerEvent->pointerId();
   if (m_pointerEventFactory.remove(pointerId)) {
     m_pendingPointerCaptureTarget.erase(pointerId);
     m_pointerCaptureTarget.erase(pointerId);
     m_nodeUnderPointer.erase(pointerId);
   }
@@ skipping 18 matching lines @@
 
 void PointerEventManager::releasePointerCapture(int pointerId,
                                                 EventTarget* target) {
   // Only the element that is going to get the next pointer event can release
   // the capture. Note that this might be different from
   // |m_pointercaptureTarget|. |m_pointercaptureTarget| holds the element
   // that had the capture until now and has been receiving the pointerevents
   // but |m_pendingPointerCaptureTarget| indicated the element that gets the
   // very next pointer event. They will be the same if there was no change in
   // capturing of a particular |pointerId|. See crbug.com/614481.
-  if (m_pendingPointerCaptureTarget.get(pointerId) == target)
+  if (m_pendingPointerCaptureTarget.at(pointerId) == target)
     releasePointerCapture(pointerId);
 }
 
 bool PointerEventManager::hasPointerCapture(int pointerId,
                                             const EventTarget* target) const {
-  return m_pendingPointerCaptureTarget.get(pointerId) == target;
+  return m_pendingPointerCaptureTarget.at(pointerId) == target;
 }
 
 bool PointerEventManager::hasProcessedPointerCapture(
     int pointerId,
     const EventTarget* target) const {
-  return m_pointerCaptureTarget.get(pointerId) == target;
+  return m_pointerCaptureTarget.at(pointerId) == target;
 }
 
 void PointerEventManager::releasePointerCapture(int 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.
 bool PointerEventManager::isTouchPointerIdActiveOnFrame(
     int pointerId,
     LocalFrame* frame) const {
   if (m_pointerEventFactory.getPointerType(pointerId) !=
       WebPointerProperties::PointerType::Touch)
     return false;
   Node* lastNodeReceivingEvent =
       m_nodeUnderPointer.contains(pointerId)
-          ? m_nodeUnderPointer.get(pointerId).target->toNode()
+          ? m_nodeUnderPointer.at(pointerId).target->toNode()
           : nullptr;
   return lastNodeReceivingEvent &&
          lastNodeReceivingEvent->document().frame() == frame;
 }
 
 bool PointerEventManager::isAnyTouchActive() const {
   return m_touchEventManager->isAnyTouchActive();
 }
 
 bool PointerEventManager::primaryPointerdownCanceled(
     uint32_t uniqueTouchEventId) {
   // It's safe to assume that uniqueTouchEventIds won't wrap back to 0 from
   // 2^32-1 (>4.2 billion): even with a generous 100 unique ids per touch
   // sequence & one sequence per 10 second, it takes 13+ years to wrap back.
   while (!m_touchIdsForCanceledPointerdowns.isEmpty()) {
     uint32_t firstId = m_touchIdsForCanceledPointerdowns.first();
     if (firstId > uniqueTouchEventId)
       return false;
     m_touchIdsForCanceledPointerdowns.takeFirst();
     if (firstId == uniqueTouchEventId)
       return true;
   }
   return false;
 }
 
 }  // namespace blink