Oilpan: Remove WillBe types (part 13)

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/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
 #include "core/input/EventHandler.h"
 
@@ skipping 13 matching lines @@
     case PlatformTouchPoint::TouchMoved:
         return EventTypeNames::pointermove;
     case PlatformTouchPoint::TouchStationary:
         // Fall through to default
     default:
         ASSERT_NOT_REACHED();
         return emptyAtom;
     }
 }
 
-bool isInDocument(PassRefPtrWillBeRawPtr<EventTarget> n)
+bool isInDocument(RawPtr<EventTarget> n)
 {
     return n && n->toNode() && n->toNode()->inDocument();
 }
 
 WebInputEventResult dispatchMouseEvent(
-    PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
+    RawPtr<EventTarget> prpTarget,
     const AtomicString& mouseEventType,
     const PlatformMouseEvent& mouseEvent,
-    PassRefPtrWillBeRawPtr<EventTarget> prpRelatedTarget,
+    RawPtr<EventTarget> prpRelatedTarget,
     int detail = 0,
     bool checkForListener = false)
 {
-    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
-    RefPtrWillBeRawPtr<EventTarget> relatedTarget = prpRelatedTarget;
+    RawPtr<EventTarget> target = prpTarget;
+    RawPtr<EventTarget> relatedTarget = prpRelatedTarget;
     if (target && target->toNode()
         && (!checkForListener || target->hasEventListeners(mouseEventType))) {
-        RefPtrWillBeRawPtr<Node> targetNode = target->toNode();
-        RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(mouseEventType,
+        RawPtr<Node> targetNode = target->toNode();
+        RawPtr<MouseEvent> event = MouseEvent::create(mouseEventType,
             targetNode->document().domWindow(), mouseEvent, detail,
             relatedTarget ? relatedTarget->toNode() : nullptr);
         DispatchEventResult dispatchResult = target->dispatchEvent(event);
         return EventHandler::toWebInputEventResult(dispatchResult);
     }
     return WebInputEventResult::NotHandled;
 }
 
 } // namespace
 
 WebInputEventResult PointerEventManager::dispatchPointerEvent(
-    PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
-    PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
+    RawPtr<EventTarget> prpTarget,
+    RawPtr<PointerEvent> prpPointerEvent,
     bool checkForListener)
 {
-    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+    RawPtr<EventTarget> target = prpTarget;
+    RawPtr<PointerEvent> pointerEvent = prpPointerEvent;
 
     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)) {
-        RefPtrWillBeRawPtr<EventTarget> targetUnderPointer =
+        RawPtr<EventTarget> targetUnderPointer =
             m_nodeUnderPointer.get(pointerId).target;
         if (targetUnderPointer == target) {
             m_nodeUnderPointer.set(pointerId, EventTargetAttributes
                 (targetUnderPointer,
                 eventType == EventTypeNames::pointerover));
         }
     }
 
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return WebInputEventResult::NotHandled;
     if (!checkForListener || target->hasEventListeners(eventType)) {
         DispatchEventResult dispatchResult = target->dispatchEvent(pointerEvent);
         return EventHandler::toWebInputEventResult(dispatchResult);
     }
     return WebInputEventResult::NotHandled;
 }
 
-PassRefPtrWillBeRawPtr<EventTarget> PointerEventManager::getEffectiveTargetForPointerEvent(
-    PassRefPtrWillBeRawPtr<EventTarget> target, int pointerId)
+RawPtr<EventTarget> PointerEventManager::getEffectiveTargetForPointerEvent(
+    RawPtr<EventTarget> target, int pointerId)
 {
     if (EventTarget* capturingTarget = getCapturingNode(pointerId))
         return capturingTarget;
     return target;
 }
 
 void PointerEventManager::sendMouseAndPossiblyPointerNodeTransitionEvents(
-    PassRefPtrWillBeRawPtr<Node> exitedNode,
-    PassRefPtrWillBeRawPtr<Node> enteredNode,
+    RawPtr<Node> exitedNode,
+    RawPtr<Node> enteredNode,
     const PlatformMouseEvent& mouseEvent,
-    PassRefPtrWillBeRawPtr<AbstractView> view,
+    RawPtr<AbstractView> view,
     bool isFrameBoundaryTransition)
 {
     // Pointer event type does not matter as it will be overridden in the sendNodeTransitionEvents
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
+    RawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(EventTypeNames::mouseout, mouseEvent,
         nullptr, view);
 
     // TODO(crbug/545647): This state should reset with pointercancel too.
     // This function also gets called for compat mouse events of touch at this
     // stage. So if the event is not frame boundary transition it is only a
     // compatibility mouse event and we do not need to change pointer event
     // behavior regarding preventMouseEvent state in that case.
     if (isFrameBoundaryTransition && pointerEvent->buttons() == 0) {
         m_preventMouseEventForPointerTypeMouse = false;
     }
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, enteredNode,
         exitedNode, mouseEvent, true, isFrameBoundaryTransition);
 }
 
 void PointerEventManager::sendNodeTransitionEvents(
-    PassRefPtrWillBeRawPtr<EventTarget> prpExitedTarget,
-    PassRefPtrWillBeRawPtr<EventTarget> prpEnteredTarget,
-    PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
+    RawPtr<EventTarget> prpExitedTarget,
+    RawPtr<EventTarget> prpEnteredTarget,
+    RawPtr<PointerEvent> prpPointerEvent,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
-    RefPtrWillBeRawPtr<EventTarget> exitedTarget = prpExitedTarget;
-    RefPtrWillBeRawPtr<EventTarget> enteredTarget = prpEnteredTarget;
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+    RawPtr<EventTarget> exitedTarget = prpExitedTarget;
+    RawPtr<EventTarget> enteredTarget = prpEnteredTarget;
+    RawPtr<PointerEvent> pointerEvent = prpPointerEvent;
 
     if (exitedTarget == enteredTarget)
         return;
 
     if (EventTarget* capturingTarget = getCapturingNode(pointerEvent->pointerId())) {
         if (capturingTarget == exitedTarget)
             enteredTarget = nullptr;
         else if (capturingTarget == enteredTarget)
             exitedTarget = nullptr;
         else
             return;
     }
 
     // Dispatch pointerout/mouseout events
     if (isInDocument(exitedTarget)) {
         if (!sendMouseEvent) {
             dispatchPointerEvent(exitedTarget, m_pointerEventFactory.createPointerTransitionEvent(
                 pointerEvent, EventTypeNames::pointerout, enteredTarget));
         } else {
             dispatchMouseEvent(exitedTarget,
                 EventTypeNames::mouseout, mouseEvent, enteredTarget);
         }
     }
 
     // Create lists of all exited/entered ancestors, locate the common ancestor
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> exitedAncestors;
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> enteredAncestors;
+    HeapVector<Member<Node>, 32> exitedAncestors;
+    HeapVector<Member<Node>, 32> enteredAncestors;
     if (isInDocument(exitedTarget)) {
-        RefPtrWillBeRawPtr<Node> exitedNode = exitedTarget->toNode();
+        RawPtr<Node> exitedNode = exitedTarget->toNode();
         exitedNode->updateDistribution();
-        for (RefPtrWillBeRawPtr<Node> node = exitedNode; node; node = FlatTreeTraversal::parent(*node))
+        for (RawPtr<Node> node = exitedNode; node; node = FlatTreeTraversal::parent(*node))
             exitedAncestors.append(node);
     }
 
     if (isInDocument(enteredTarget)) {
-        RefPtrWillBeRawPtr<Node> enteredNode = enteredTarget->toNode();
+        RawPtr<Node> enteredNode = enteredTarget->toNode();
         enteredNode->updateDistribution();
-        for (RefPtrWillBeRawPtr<Node> node = enteredNode; node; node = FlatTreeTraversal::parent(*node))
+        for (RawPtr<Node> node = enteredNode; node; node = FlatTreeTraversal::parent(*node))
             enteredAncestors.append(node);
     }
 
     // A note on mouseenter and mouseleave: These are non-bubbling events, and they are dispatched if there
     // is a capturing event handler on an ancestor or a normal event handler on the element itself. This special
     // handling is necessary to avoid O(n^2) capturing event handler checks.
     //
     //   Note, however, that this optimization can possibly cause some unanswered/missing/redundant mouseenter or
     // mouseleave events in certain contrived eventhandling scenarios, e.g., when:
     // - the mouseleave handler for a node sets the only capturing-mouseleave-listener in its ancestor, or
@@ skipping 73 matching lines @@
                 !enteredNodeHasCapturingAncestor);
         } else {
             dispatchMouseEvent(enteredAncestors[i-1].get(),
                 EventTypeNames::mouseenter, mouseEvent, exitedTarget,
                 0, !enteredNodeHasCapturingAncestor);
         }
     }
 }
 
 void PointerEventManager::setNodeUnderPointer(
-    PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
-    PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
+    RawPtr<PointerEvent> prpPointerEvent,
+    RawPtr<EventTarget> prpTarget,
     bool sendEvent)
 {
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
-    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
+    RawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+    RawPtr<EventTarget> target = prpTarget;
     if (m_nodeUnderPointer.contains(pointerEvent->pointerId())) {
         EventTargetAttributes node = m_nodeUnderPointer.get(
             pointerEvent->pointerId());
         if (!target) {
             m_nodeUnderPointer.remove(pointerEvent->pointerId());
         } else if (target
             != m_nodeUnderPointer.get(pointerEvent->pointerId()).target) {
             m_nodeUnderPointer.set(pointerEvent->pointerId(),
                 EventTargetAttributes(target, false));
         }
         if (sendEvent)
             sendNodeTransitionEvents(node.target, target, pointerEvent);
     } else if (target) {
         m_nodeUnderPointer.add(pointerEvent->pointerId(),
             EventTargetAttributes(target, false));
         if (sendEvent)
             sendNodeTransitionEvents(nullptr, target, pointerEvent);
     }
 }
 
-void PointerEventManager::sendTouchCancelPointerEvent(PassRefPtrWillBeRawPtr<EventTarget> prpTarget, const PlatformTouchPoint& point)
+void PointerEventManager::sendTouchCancelPointerEvent(RawPtr<EventTarget> prpTarget, const PlatformTouchPoint& point)
 {
-    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventFactory.createPointerCancelEvent(point);
+    RawPtr<EventTarget> target = prpTarget;
+    RawPtr<PointerEvent> pointerEvent = m_pointerEventFactory.createPointerCancelEvent(point);
 
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, target);
 
     // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
     dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent.get());
 
     setNodeUnderPointer(pointerEvent, nullptr);
 
     removePointer(pointerEvent);
 }
 
 WebInputEventResult PointerEventManager::sendTouchPointerEvent(
-    PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
+    RawPtr<EventTarget> prpTarget,
     const PlatformTouchPoint& touchPoint, PlatformEvent::Modifiers modifiers,
     const double width, const double height,
     const double clientX, const double clientY)
 {
-    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
+    RawPtr<EventTarget> target = prpTarget;
 
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
+    RawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(
         pointerEventNameForTouchPointState(touchPoint.state()),
         touchPoint, modifiers, width, height, clientX, clientY);
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, target);
 
     // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
     WebInputEventResult result = dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent.get());
 
     if (touchPoint.state() == PlatformTouchPoint::TouchReleased
         || touchPoint.state() == PlatformTouchPoint::TouchCancelled) {
         setNodeUnderPointer(pointerEvent, nullptr);
         removePointer(pointerEvent);
     }
 
     return result;
 }
 
 WebInputEventResult PointerEventManager::sendMousePointerEvent(
-    PassRefPtrWillBeRawPtr<Node> prpTarget, const AtomicString& mouseEventType,
+    RawPtr<Node> prpTarget, const AtomicString& mouseEventType,
     int clickCount, const PlatformMouseEvent& mouseEvent,
-    PassRefPtrWillBeRawPtr<Node> relatedTarget,
-    PassRefPtrWillBeRawPtr<AbstractView> view,
-    PassRefPtrWillBeRawPtr<Node> lastNodeUnderMouse)
+    RawPtr<Node> relatedTarget,
+    RawPtr<AbstractView> view,
+    RawPtr<Node> lastNodeUnderMouse)
 {
-    RefPtrWillBeRawPtr<Node> target = prpTarget;
+    RawPtr<Node> target = prpTarget;
 
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
+    RawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(mouseEventType, mouseEvent,
         relatedTarget, view);
 
     // This is for when the mouse is released outside of the page.
     if (pointerEvent->type() == EventTypeNames::pointermove
         && !pointerEvent->buttons()) {
         m_preventMouseEventForPointerTypeMouse = false;
     }
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, target,
         lastNodeUnderMouse, mouseEvent, true, true);
 
-    RefPtrWillBeRawPtr<EventTarget> effectiveTarget =
+    RawPtr<EventTarget> effectiveTarget =
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId());
 
     WebInputEventResult result =
         dispatchPointerEvent(effectiveTarget, pointerEvent);
 
     if (result != WebInputEventResult::NotHandled
         && pointerEvent->type() == EventTypeNames::pointerdown)
         m_preventMouseEventForPointerTypeMouse = true;
 
     if (!m_preventMouseEventForPointerTypeMouse) {
@@ skipping 20 matching lines @@
 }
 
 void PointerEventManager::clear()
 {
     m_preventMouseEventForPointerTypeMouse = false;
     m_pointerEventFactory.clear();
     m_nodeUnderPointer.clear();
 }
 
 void PointerEventManager::processCaptureAndPositionOfPointerEvent(
-    const PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
-    const PassRefPtrWillBeRawPtr<EventTarget> prpHitTestTarget,
-    const PassRefPtrWillBeRawPtr<EventTarget> lastNodeUnderMouse,
+    const RawPtr<PointerEvent> prpPointerEvent,
+    const RawPtr<EventTarget> prpHitTestTarget,
+    const RawPtr<EventTarget> lastNodeUnderMouse,
     const PlatformMouseEvent& mouseEvent,
     bool sendMouseEvent, bool setPointerPosition)
 {
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
-    RefPtrWillBeRawPtr<EventTarget> hitTestTarget = prpHitTestTarget;
+    RawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+    RawPtr<EventTarget> hitTestTarget = prpHitTestTarget;
     bool isCaptureChanged = false;
 
     if (setPointerPosition) {
         isCaptureChanged = processPendingPointerCapture(pointerEvent,
             hitTestTarget, mouseEvent, sendMouseEvent);
         // If there was a change in capturing processPendingPointerCapture has
         // already taken care of transition events. So we don't need to send the
         // transition events here.
         setNodeUnderPointer(pointerEvent, hitTestTarget, !isCaptureChanged);
     }
     if (sendMouseEvent && !isCaptureChanged) {
         // lastNodeUnderMouse is needed here because it is still stored in EventHandler.
         sendNodeTransitionEvents(lastNodeUnderMouse, hitTestTarget,
             pointerEvent, mouseEvent, true);
     }
 }
 
 bool PointerEventManager::processPendingPointerCapture(
-    const PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
-    const PassRefPtrWillBeRawPtr<EventTarget> prpHitTestTarget,
+    const RawPtr<PointerEvent> prpPointerEvent,
+    const RawPtr<EventTarget> prpHitTestTarget,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
-    RefPtrWillBeRawPtr<EventTarget> hitTestTarget = prpHitTestTarget;
+    RawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+    RawPtr<EventTarget> hitTestTarget = prpHitTestTarget;
     int pointerId = pointerEvent->pointerId();
-    const RefPtrWillBeRawPtr<EventTarget> pointerCaptureTarget =
+    const RawPtr<EventTarget> pointerCaptureTarget =
         m_pointerCaptureTarget.contains(pointerId)
         ? m_pointerCaptureTarget.get(pointerId) : nullptr;
-    const RefPtrWillBeRawPtr<EventTarget> pendingPointerCaptureTarget =
+    const RawPtr<EventTarget> pendingPointerCaptureTarget =
         m_pendingPointerCaptureTarget.contains(pointerId)
         ? m_pendingPointerCaptureTarget.get(pointerId) : nullptr;
     const EventTargetAttributes &nodeUnderPointerAtt =
         m_nodeUnderPointer.contains(pointerId)
         ? m_nodeUnderPointer.get(pointerId) : EventTargetAttributes();
     const bool isCaptureChanged =
         pointerCaptureTarget != pendingPointerCaptureTarget;
 
     if (isCaptureChanged) {
         if ((hitTestTarget != nodeUnderPointerAtt.target
@@ skipping 67 matching lines @@
 }
 
 EventTarget* PointerEventManager::getCapturingNode(int pointerId)
 {
     if (m_pointerCaptureTarget.contains(pointerId))
         return m_pointerCaptureTarget.get(pointerId);
     return nullptr;
 }
 
 void PointerEventManager::removePointer(
-    const PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent)
+    const RawPtr<PointerEvent> prpPointerEvent)
 {
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+    RawPtr<PointerEvent> pointerEvent = prpPointerEvent;
     if (m_pointerEventFactory.remove(pointerEvent)) {
         int pointerId = pointerEvent->pointerId();
         m_pendingPointerCaptureTarget.remove(pointerId);
         m_pointerCaptureTarget.remove(pointerId);
         m_nodeUnderPointer.remove(pointerId);
     }
 }
 
 void PointerEventManager::elementRemoved(EventTarget* target)
 {
@@ skipping 26 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
 #endif
 }
 
 
 } // namespace blink