Fixed memory issues with EventHandler::TouchInfo.

Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 3430 matching lines @@
         return result;
     if (frame->view()) {
         IntRect rect = frame->view()->visibleContentRect(IncludeScrollbars);
         if (!rect.contains(roundedIntPoint(point)))
             return result;
     }
     frame->contentLayoutObject()->hitTest(result);
     return result;
 }
 
-void EventHandler::dispatchPointerEventsForTouchEvent(const PlatformTouchEvent& event, Vector<TouchInfo>& touchInfos)
+void EventHandler::dispatchPointerEventsForTouchEvent(const PlatformTouchEvent& event, WillBeHeapVector<TouchInfo>& touchInfos)
 {
     const String& PointerTypeStrForTouch("touch");
 
     // Iterate through the touch points, sending PointerEvents to the targets as required.
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         const unsigned& pointerId = point.id();
         const PlatformTouchPoint::State pointState = point.state();
 
@@ skipping 34 matching lines @@
         touchInfo.touchTarget->toNode()->dispatchPointerEvent(pointerEvent.get());
         touchInfo.consumed = pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
 
         // Remove the released/cancelled id at the end to correctly determine primary id above.
         if (pointerReleasedOrCancelled)
             m_pointerIdManager.remove(PointerIdManager::PointerTypeTouch, pointerId);
     }
 }
 
 bool EventHandler::dispatchTouchEvents(const PlatformTouchEvent& event,
-    Vector<TouchInfo>& touchInfos, bool freshTouchEvents, bool allTouchReleased)
+    WillBeHeapVector<TouchInfo>& touchInfos, bool freshTouchEvents, bool allTouchReleased)
 {
     bool swallowedEvent = false;
 
     // Build up the lists to use for the 'touches', 'targetTouches' and
     // 'changedTouches' attributes in the JS event. See
     // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
     // lists fit together.
 
     // Holds the complete set of touches on the screen.
     RefPtrWillBeRawPtr<TouchList> touches = TouchList::create();
@@ skipping 15 matching lines @@
 
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         const TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         PlatformTouchPoint::State pointState = point.state();
 
         if (touchInfo.consumed)
             continue;
 
         RefPtrWillBeRawPtr<Touch> touch = Touch::create(
-            touchInfo.targetFrame,
-            touchInfo.touchTarget,
+            touchInfo.targetFrame.get(),
+            touchInfo.touchTarget.get(),
             point.id(),
             point.screenPos(),
             touchInfo.adjustedPagePoint,
             touchInfo.adjustedRadius,
             point.rotationAngle(),
             point.force());
 
         // Ensure this target's touch list exists, even if it ends up empty, so
         // it can always be passed to TouchEvent::Create below.
-        TargetTouchesHeapMap::iterator targetTouchesIterator = touchesByTarget.find(touchInfo.touchTarget);
+        TargetTouchesHeapMap::iterator targetTouchesIterator = touchesByTarget.find(touchInfo.touchTarget.get());
         if (targetTouchesIterator == touchesByTarget.end()) {
-            touchesByTarget.set(touchInfo.touchTarget, TouchList::create());
-            targetTouchesIterator = touchesByTarget.find(touchInfo.touchTarget);
+            touchesByTarget.set(touchInfo.touchTarget.get(), TouchList::create());
+            targetTouchesIterator = touchesByTarget.find(touchInfo.touchTarget.get());
         }
 
         // touches and targetTouches should only contain information about
         // touches still on the screen, so if this point is released or
         // cancelled it will only appear in the changedTouches list.
         if (pointState != PlatformTouchPoint::TouchReleased && pointState != PlatformTouchPoint::TouchCancelled) {
             touches->append(touch);
             targetTouchesIterator->value->append(touch);
         }
 
@@ skipping 137 matching lines @@
     // this work.
     if (!m_touchSequenceDocument || !m_touchSequenceDocument->frameHost() || !m_touchSequenceDocument->frameHost()->eventHandlerRegistry().hasEventHandlers(EventHandlerRegistry::TouchEvent) || !m_touchSequenceDocument->frame()) {
         if (allTouchReleased) {
             m_touchSequenceDocument.clear();
             m_touchSequenceUserGestureToken.clear();
         }
         return false;
     }
 
     // Compute and store the common info used by both PointerEvent and TouchEvent.
-    Vector<TouchInfo> touchInfos(points.size());
+    WillBeHeapVector<TouchInfo> touchInfos(points.size());
 
     for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
         PlatformTouchPoint::State pointState = point.state();
         RefPtrWillBeRawPtr<EventTarget> touchTarget = nullptr;
 
         if (pointState == PlatformTouchPoint::TouchReleased || pointState == PlatformTouchPoint::TouchCancelled) {
             // The target should be the original target for this touch, so get
             // it from the hashmap. As it's a release or cancel we also remove
             // it from the map.
@@ skipping 34 matching lines @@
             targetFrame = m_touchSequenceDocument->frame();
         }
         ASSERT(targetFrame);
 
         // pagePoint should always be in the target element's document coordinates.
         FloatPoint pagePoint = targetFrame->view()->rootFrameToContents(point.pos());
         float scaleFactor = 1.0f / targetFrame->pageZoomFactor();
 
         TouchInfo& touchInfo = touchInfos[i];
         touchInfo.point = point;
-        touchInfo.touchTarget = touchTarget.get();
+        touchInfo.touchTarget = touchTarget;
         touchInfo.targetFrame = targetFrame;
         touchInfo.adjustedPagePoint = pagePoint.scaledBy(scaleFactor);
         touchInfo.adjustedRadius = point.radius().scaledBy(scaleFactor);
         touchInfo.knownTarget = knownTarget;
         touchInfo.consumed = false;
     }
 
     if (RuntimeEnabledFeatures::pointerEventEnabled()) {
         dispatchPointerEventsForTouchEvent(event, touchInfos);
-        // TODO(mustaq): This needs attention.
-        // From CL discussion: The disposition of any pointer events affects only the generation of
-        // touch events. If pointer events were handled (and hence no touch events generated) that is
-        // still equivalent to the touch events going unhandled because pointer event handler don't
-        // block scroll gesture generation.
+        // Note that the disposition of any pointer events affects only the generation of touch
+        // events. If all pointer events were handled (and hence no touch events were fired), that
+        // is still equivalent to the touch events going unhandled because pointer event handler
+        // don't block scroll gesture generation.
     }
 
     return dispatchTouchEvents(event, touchInfos, freshTouchEvents, allTouchReleased);
 }
 
 TouchAction EventHandler::intersectTouchAction(TouchAction action1, TouchAction action2)
 {
     if (action1 == TouchActionNone || action2 == TouchActionNone)
         return TouchActionNone;
     if (action1 == TouchActionAuto)
@@ skipping 96 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink