Canvas2d: Implement rerouting event by hit region's control.

third_party/WebKit/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 38 matching lines @@
 #include "core/events/TextEvent.h"
 #include "core/events/TouchEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
+#include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLDialogElement.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameSetElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/input/InputDeviceCapabilities.h"
 #include "core/input/TouchActionUtil.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutTextControlSingleLine.h"
@@ skipping 289 matching lines @@
     visitor->trace(m_capturingMouseEventsNode);
     visitor->trace(m_nodeUnderMouse);
     visitor->trace(m_lastMouseMoveEventSubframe);
     visitor->trace(m_lastScrollbarUnderMouse);
     visitor->trace(m_clickNode);
     visitor->trace(m_dragTarget);
     visitor->trace(m_frameSetBeingResized);
     visitor->trace(m_previousWheelScrolledNode);
     visitor->trace(m_scrollbarHandlingScrollGesture);
     visitor->trace(m_targetForTouchID);
+    visitor->trace(m_regionForTouchID);
     visitor->trace(m_touchSequenceDocument);
     visitor->trace(m_scrollGestureHandlingNode);
     visitor->trace(m_previousGestureScrolledNode);
     visitor->trace(m_lastDeferredTapElement);
     visitor->trace(m_selectionController);
 #endif
 }
 
 DragState& EventHandler::dragState()
 {
@@ skipping 998 matching lines @@
     if (m_clickCount > 0 && !contextMenuEvent && mev.innerNode() && m_clickNode && mev.innerNode()->canParticipateInFlatTree() && m_clickNode->canParticipateInFlatTree()) {
         // Updates distribution because a 'mouseup' event listener can make the
         // tree dirty at dispatchMouseEvent() invocation above.
         // Unless distribution is updated, commonAncestor would hit ASSERT.
         // Both m_clickNode and mev.innerNode() don't need to be updated
         // because commonAncestor() will exit early if their documents are different.
         m_clickNode->updateDistribution();
         if (Node* clickTargetNode = mev.innerNode()->commonAncestor(
             *m_clickNode, parentForClickEvent)) {
 
+            if (isHTMLCanvasElement(clickTargetNode)) {
+                LayoutPoint documentPoint = contentPointFromRootFrame(m_frame, mouseEvent.position());
+                std::pair<Element*, String> regionInfo = toHTMLCanvasElement(clickTargetNode)->getControlAndIdIfHitRegionExists(documentPoint);
+                if (regionInfo.first)
+                    clickTargetNode = regionInfo.first;
+                const_cast<PlatformMouseEvent&>(mouseEvent).setRegion(regionInfo.second);

[Rick Byers, 2016/02/23 20:26:08]

It's unfortunate to need to rely on a const_cast here - conceptually the
PlatformMouseEvent really should be immutable and I can imagine how we might
have bugs as a result of violating that expectation.

Also you really don't want to have to duplicate this code at each place that
generates a MouseEvent (I think you're missing a few).

Happily I think there's a nice clean solution to both of these issues.  This
step is conceptually part of hit-testing, I think you can do it in a more
centralized place as part of the hit test - Document::prepareMouseEvent.  That
code already creates and returns a copy of the PlatformMouseEvent, so you can
modify it there without violating const.

There are a couple places that use prepareMouseEvent that'll have to be updated
to use the PlatformMouseEvent from the return value (instead of continuing to
use the value supplied) but that looks trivial to me.

In terms of the control, hopefully you can just change the innerNode of the
HitTestResults.  Then everything downstream of hit-testing will behave as if the
input device actually hit that node.

BTW, the spec says: "The control is ignored when it is not a descendant of the
canvas element.)".  Have you enforced that somewhere already?  Do you need to
reverify it every time it's used (in case it has moved)?

[zino, 2016/03/08 12:33:48]

I couldn't find the part that you mentioned "That code already creates and
returns a copy of the PlatformMouseEvent".
In Document::prepareMouseEvent, the PlatformMouseEvent also looks const?
Done.

[Rick Byers, 2016/03/08 15:57:34]

This code: 
  return MouseEventWithHitTestResults(event, result);
Makes a copy of the PlatformMouseEvent and stores that copy inside the
MouseEventWithHitTestResults.  So this is your chance to modify that copy to be
different from the input.  i.e. replace the above with:
  PlatformMouseEvent eventWithRegion = event;
  eventWithRegion.setRegion(region);
  return MouseEventWithHitTestResults(eventWithRegion, result);

[Rick Byers, 2016/03/10 21:36:28]

This looks really great now, thanks!  I love how you just need to do this work
in two places now (modulo the outstanding bugs) - EventHandler.cpp changes are
nice and clean.  Thanks!

+            }
+
             // Dispatch mouseup directly w/o calling updateMouseEventTargetNode
             // because the mouseup dispatch above has already updated it
             // correctly. Moreover, clickTargetNode is different from
             // mev.innerNode at drag-release.
             if (clickTargetNode->dispatchMouseEvent(mouseEvent,
                 EventTypeNames::click, m_clickCount)) {
                 clickEventResult = WebInputEventResult::HandledApplication;
             }
         }
     }
@@ skipping 246 matching lines @@
         // The mouse has moved between layers.
         if (ScrollableArea* scrollableAreaForNodeUnderMouse = associatedScrollableArea(layerForNodeUnderMouse))
             scrollableAreaForNodeUnderMouse->mouseEnteredContentArea();
     }
 
     if (lastNodeUnderMouse && lastNodeUnderMouse->document() != m_frame->document()) {
         lastNodeUnderMouse = nullptr;
         m_lastScrollbarUnderMouse = nullptr;
     }
 
+    if (isHTMLCanvasElement(m_nodeUnderMouse)) {
+        LayoutPoint documentPoint = contentPointFromRootFrame(m_frame, mouseEvent.position());
+        std::pair<Element*, String> regionInfo = toHTMLCanvasElement(m_nodeUnderMouse)->getControlAndIdIfHitRegionExists(documentPoint);
+        if (regionInfo.first)
+            m_nodeUnderMouse = regionInfo.first;
+        const_cast<PlatformMouseEvent&>(mouseEvent).setRegion(regionInfo.second);
+    }
+
     if (lastNodeUnderMouse != m_nodeUnderMouse)
         sendNodeTransitionEvents(lastNodeUnderMouse.get(), m_nodeUnderMouse.get(), mouseEvent);
 }
 
 WebInputEventResult EventHandler::dispatchPointerEvent(EventTarget* target, PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return WebInputEventResult::NotHandled;
 
     bool dispatchResult = target->dispatchEvent(pointerEvent.get());
@@ skipping 2181 matching lines @@
             continue;
 
         RefPtrWillBeRawPtr<Touch> touch = Touch::create(
             touchInfo.targetFrame.get(),
             touchInfo.touchTarget.get(),
             point.id(),
             point.screenPos(),
             touchInfo.adjustedPagePoint,
             touchInfo.adjustedRadius,
             point.rotationAngle(),
-            point.force());
+            point.force(),
+            touchInfo.region);
 
         // 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.get());
         if (targetTouchesIterator == touchesByTarget.end()) {
             touchesByTarget.set(touchInfo.touchTarget.get(), TouchList::create());
             targetTouchesIterator = touchesByTarget.find(touchInfo.touchTarget.get());
         }
 
         // touches and targetTouches should only contain information about
@@ skipping 106 matching lines @@
                 LayoutPoint framePoint = roundedLayoutPoint(m_touchSequenceDocument->frame()->view()->rootFrameToContents(point.pos()));
                 result = hitTestResultInFrame(m_touchSequenceDocument->frame(), framePoint, hitType);
             } else {
                 continue;
             }
 
             Node* node = result.innerNode();
             if (!node)
                 continue;
 
+            if (isHTMLCanvasElement(node)) {
+                std::pair<Element*, String> regionInfo = toHTMLCanvasElement(node)->getControlAndIdIfHitRegionExists(result.pointInInnerNodeFrame());
+                if (regionInfo.first)
+                    node = regionInfo.first;
+                m_regionForTouchID.set(point.id(), regionInfo.second);
+            }
+
             // Touch events should not go to text nodes
             if (node->isTextNode())
                 node = FlatTreeTraversal::parent(*node);
 
             if (!m_touchSequenceDocument) {
                 // Keep track of which document should receive all touch events
                 // in the active sequence. This must be a single document to
                 // ensure we don't leak Nodes between documents.
                 m_touchSequenceDocument = &(result.innerNode()->document());
                 ASSERT(m_touchSequenceDocument->frame()->view());
@@ skipping 26 matching lines @@
         return WebInputEventResult::NotHandled;
     }
 
     // Compute and store the common info used by both PointerEvent and TouchEvent.
     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;
+        String regionID;
 
         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.
             touchTarget = m_targetForTouchID.take(point.id());
+            regionID = m_regionForTouchID.take(point.id());
         } else {
             // No hittest is performed on move or stationary, since the target
             // is not allowed to change anyway.
             touchTarget = m_targetForTouchID.get(point.id());
+            regionID = m_regionForTouchID.get(point.id());
         }
 
         LocalFrame* targetFrame = nullptr;
         bool knownTarget = false;
         if (touchTarget) {
             Document& doc = touchTarget->toNode()->document();
             // If the target node has moved to a new document while it was being touched,
             // we can't send events to the new document because that could leak nodes
             // from one document to another. See http://crbug.com/394339.
             if (&doc == m_touchSequenceDocument.get()) {
@@ skipping 25 matching lines @@
         float scaleFactor = 1.0f / targetFrame->pageZoomFactor();
 
         TouchInfo& touchInfo = touchInfos[i];
         touchInfo.point = point;
         touchInfo.touchTarget = touchTarget;
         touchInfo.targetFrame = targetFrame;
         touchInfo.adjustedPagePoint = pagePoint.scaledBy(scaleFactor);
         touchInfo.adjustedRadius = point.radius().scaledBy(scaleFactor);
         touchInfo.knownTarget = knownTarget;
         touchInfo.consumed = false;
+        touchInfo.region = regionID;
     }
 
     if (!m_inPointerCanceledState) {
         dispatchPointerEvents(event, touchInfos);
         // 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.
     }
 
@@ skipping 84 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink