Fix non-Oilpan following r379558.

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 82 matching lines @@
 PassRefPtrWillBeRawPtr<EventTarget> PointerEventManager::getEffectiveTargetForPointerEvent(
     PassRefPtrWillBeRawPtr<EventTarget> target, int pointerId)
 {
     if (EventTarget* capturingTarget = getCapturingNode(pointerId))
         return capturingTarget;
     return target;
 }
 
 // Sends node transition events (pointer|mouse)(out|leave|over|enter) to the corresponding targets
 void PointerEventManager::sendNodeTransitionEvents(
-    PassRefPtrWillBeRawPtr<Node> exitedNode,
-    PassRefPtrWillBeRawPtr<Node> enteredNode,
+    PassRefPtrWillBeRawPtr<Node> prpExitedNode,
+    PassRefPtrWillBeRawPtr<Node> prpEnteredNode,
     const PlatformMouseEvent& mouseEvent,
     PassRefPtrWillBeRawPtr<AbstractView> view)
 {
+    RefPtrWillBeRawPtr<Node> exitedNode = prpExitedNode;
+    RefPtrWillBeRawPtr<Node> enteredNode = prpEnteredNode;
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(EventTypeNames::mouseout, mouseEvent,
         nullptr, view);
     processPendingPointerCapture(pointerEvent, enteredNode, mouseEvent, true);
 
     // Pointer event type does not matter as it will be overridden in the sendNodeTransitionEvents
     sendNodeTransitionEvents(exitedNode, enteredNode, pointerEvent, mouseEvent,
         true);
 }
 
@@ skipping 147 matching lines @@
                 EventTargetAttributes(target, false));
         }
         sendNodeTransitionEvents(node.target, target, pointerEvent);
     } else if (target) {
         m_nodeUnderPointer.add(pointerEvent->pointerId(),
             EventTargetAttributes(target, false));
         sendNodeTransitionEvents(nullptr, target, pointerEvent);
     }
 }
 
-void PointerEventManager::sendTouchCancelPointerEvent(PassRefPtrWillBeRawPtr<EventTarget> target,
-    const PlatformTouchPoint& point)
+void PointerEventManager::sendTouchCancelPointerEvent(PassRefPtrWillBeRawPtr<EventTarget> prpTarget, const PlatformTouchPoint& point)
 {
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
-        m_pointerEventFactory.createPointerCancel(point);
+    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
+    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventFactory.createPointerCancel(point);
 
     processPendingPointerCapture(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);
 
@@ skipping 25 matching lines @@
     if (touchPoint.state() == PlatformTouchPoint::TouchReleased
         || touchPoint.state() == PlatformTouchPoint::TouchCancelled) {
         setNodeUnderPointer(pointerEvent, nullptr);
         removePointer(pointerEvent);
     }
 
     return result;
 }
 
 WebInputEventResult PointerEventManager::sendMousePointerEvent(
-    PassRefPtrWillBeRawPtr<Node> target, const AtomicString& mouseEventType,
+    PassRefPtrWillBeRawPtr<Node> prpTarget, const AtomicString& mouseEventType,
     int clickCount, const PlatformMouseEvent& mouseEvent,
     PassRefPtrWillBeRawPtr<Node> relatedTarget,
     PassRefPtrWillBeRawPtr<AbstractView> view)
 {
+    RefPtrWillBeRawPtr<Node> target = prpTarget;
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(mouseEventType, mouseEvent,
         relatedTarget, view);
 
     processPendingPointerCapture(pointerEvent, target, mouseEvent, true);
 
     // TODO(crbug.com/587955): We should call setNodeUnderPointer here but it causes sending
     // transition events that should be first removed from EventHandler.
 
     RefPtrWillBeRawPtr<EventTarget> effectiveTarget =
@@ skipping 102 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> pointerEvent)
+    const PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent)
 {
+    RefPtrWillBeRawPtr<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 28 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
 #endif
 }
 
 
 } // namespace blink