Fix non-Oilpan PassRefPtr<> usage following r375261.

third_party/WebKit/Source/core/input/PointerEventManager.cpp

 // Copyright 2015 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 40 matching lines @@
     ASSERT_NOT_REACHED();
     return emptyAtom;
 }
 
 bool isInDocument(PassRefPtrWillBeRawPtr<EventTarget> n)
 {
     return n && n->toNode() && n->toNode()->inDocument();
 }
 
 WebInputEventResult dispatchPointerEvent(
-    PassRefPtrWillBeRawPtr<EventTarget> target,
-    PassRefPtrWillBeRawPtr<PointerEvent> pointerevent,
+    PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
+    PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     bool checkForListener = false)
 {
+    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
+    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return WebInputEventResult::NotHandled;
-    if (!checkForListener || target->hasEventListeners(pointerevent->type())) {
-        bool dispatchResult = target->dispatchEvent(pointerevent);
-        return EventHandler::eventToEventResult(pointerevent, dispatchResult);
+    if (!checkForListener || target->hasEventListeners(pointerEvent->type())) {
+        bool dispatchResult = target->dispatchEvent(pointerEvent);
+        return EventHandler::eventToEventResult(pointerEvent, dispatchResult);
     }
     return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult dispatchMouseEvent(
-    PassRefPtrWillBeRawPtr<EventTarget> target,
+    PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
     const AtomicString& mouseEventType,
     const PlatformMouseEvent& mouseEvent,
-    PassRefPtrWillBeRawPtr<EventTarget> relatedTarget,
+    PassRefPtrWillBeRawPtr<EventTarget> prpRelatedTarget,
     int detail = 0,
     bool checkForListener = false)
 {
+    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
+    RefPtrWillBeRawPtr<EventTarget> relatedTarget = prpRelatedTarget;
     if (target->toNode()
         && (!checkForListener || target->hasEventListeners(mouseEventType))) {
         RefPtrWillBeRawPtr<Node> targetNode = target->toNode();
         RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(mouseEventType,
             targetNode->document().domWindow(), mouseEvent, detail,
             relatedTarget ? relatedTarget->toNode() : nullptr);
         bool res = target->dispatchEvent(event);
         return EventHandler::eventToEventResult(event, res);
     }
     return WebInputEventResult::NotHandled;
@@ skipping 17 matching lines @@
     const PlatformMouseEvent& mouseEvent,
     PassRefPtrWillBeRawPtr<AbstractView> view)
 {
     // Pointer event type does not matter as it will be overridden in the sendNodeTransitionEvents
     sendNodeTransitionEvents(exitedNode, enteredNode,
         m_pointerEventFactory.create(EventTypeNames::pointerout, mouseEvent, nullptr, view),
         mouseEvent, true);
 }
 
 void PointerEventManager::sendNodeTransitionEvents(
-    PassRefPtrWillBeRawPtr<EventTarget> exitedTarget,
-    PassRefPtrWillBeRawPtr<EventTarget> enteredTarget,
-    PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent,
+    PassRefPtrWillBeRawPtr<EventTarget> prpExitedTarget,
+    PassRefPtrWillBeRawPtr<EventTarget> prpEnteredTarget,
+    PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
+    RefPtrWillBeRawPtr<EventTarget> exitedTarget = prpExitedTarget;
+    RefPtrWillBeRawPtr<EventTarget> enteredTarget = prpEnteredTarget;
+    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
     if (exitedTarget == enteredTarget)
         return;
 
     // Dispatch pointerout/mouseout events
     if (isInDocument(exitedTarget)) {
         dispatchPointerEvent(exitedTarget, m_pointerEventFactory.create(
             pointerEvent, EventTypeNames::pointerout, enteredTarget));
         if (sendMouseEvent) {
             dispatchMouseEvent(exitedTarget,
                 EventTypeNames::mouseout, mouseEvent, enteredTarget);
@@ skipping 97 matching lines @@
             !enteredNodeHasCapturingAncestor);
         if (sendMouseEvent) {
             dispatchMouseEvent(enteredAncestors[i-1].get(),
                 EventTypeNames::mouseenter, mouseEvent, exitedTarget,
                 0, !enteredNodeHasCapturingAncestor);
         }
     }
 }
 
 void PointerEventManager::setNodeUnderPointer(
-    PassRefPtrWillBeRawPtr<PointerEvent> pointerevent,
-    PassRefPtrWillBeRawPtr<EventTarget> target)
+    PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
+    PassRefPtrWillBeRawPtr<EventTarget> prpTarget)
 {
-    if (m_nodeUnderPointer.contains(pointerevent->pointerId())) {
+    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
+    if (m_nodeUnderPointer.contains(pointerEvent->pointerId())) {
         sendNodeTransitionEvents(m_nodeUnderPointer.get(
-            pointerevent->pointerId()), target, pointerevent);
+            pointerEvent->pointerId()), target, pointerEvent);
         if (!target)
-            m_nodeUnderPointer.remove(pointerevent->pointerId());
+            m_nodeUnderPointer.remove(pointerEvent->pointerId());
         else
-            m_nodeUnderPointer.set(pointerevent->pointerId(), target);
+            m_nodeUnderPointer.set(pointerEvent->pointerId(), target);
     } else if (target) {
-        sendNodeTransitionEvents(nullptr, target, pointerevent);
-        m_nodeUnderPointer.add(pointerevent->pointerId(), target);
+        sendNodeTransitionEvents(nullptr, target, pointerEvent);
+        m_nodeUnderPointer.add(pointerEvent->pointerId(), target);
     }
 }
 
 void PointerEventManager::sendTouchCancelPointerEvent(PassRefPtrWillBeRawPtr<EventTarget> target,
     const PlatformTouchPoint& point)
 {
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.createPointerCancel(point);
 
     // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
     target->dispatchEvent(pointerEvent.get());
 
     m_pointerEventFactory.remove(pointerEvent);
     setNodeUnderPointer(pointerEvent, nullptr);
 }
 
 WebInputEventResult PointerEventManager::sendTouchPointerEvent(
-    PassRefPtrWillBeRawPtr<EventTarget> target,
+    PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
     const PlatformTouchPoint& touchPoint, PlatformEvent::Modifiers modifiers,
     const double width, const double height,
     const double clientX, const double clientY)
 {
+    RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(
         pointerEventNameForTouchPointState(touchPoint.state()),
         touchPoint, modifiers, width, height, clientX, clientY);
 
     setNodeUnderPointer(pointerEvent, target);
 
     // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
     WebInputEventResult result = dispatchPointerEvent(target, pointerEvent.get());
 
@@ skipping 72 matching lines @@
 
 DEFINE_TRACE(PointerEventManager)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_nodeUnderPointer);
 #endif
 }
 
 
 } // namespace blink