Remove PlatformMouseEvent and use WebMouseEvent instead

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
@@ skipping 550 matching lines @@
   }
 
   if ((editable ||
        (layoutObject && layoutObject->isText() && node->canStartSelection())) &&
       !inResizer && !result.scrollbar())
     return iBeam;
   return pointerCursor();
 }
 
 WebInputEventResult EventHandler::handleMousePressEvent(
-    const PlatformMouseEvent& mouseEvent) {
+    const WebMouseEvent& mouseEvent) {
   TRACE_EVENT0("blink", "EventHandler::handleMousePressEvent");
 
   // For 4th/5th button in the mouse since Chrome does not yet send
   // button value to Blink but in some cases it does send the event.
   // This check is needed to suppress such an event (crbug.com/574959)
-  if (mouseEvent.pointerProperties().button ==
-      WebPointerProperties::Button::NoButton)
+  if (mouseEvent.button == WebPointerProperties::Button::NoButton)
     return WebInputEventResult::HandledSuppressed;
 
   if (m_eventHandlerWillResetCapturingMouseEventsNode)
     m_capturingMouseEventsNode = nullptr;
   m_mouseEventManager->handleMousePressEventUpdateStates(mouseEvent);
   selectionController().setMouseDownMayStartSelect(false);
   if (!m_frame->view())
     return WebInputEventResult::NotHandled;
 
   HitTestRequest request(HitTestRequest::Active);
   // Save the document point we generate in case the window coordinate is
   // invalidated by what happens when we dispatch the event.
-  LayoutPoint documentPoint =
-      m_frame->view()->rootFrameToContents(mouseEvent.position());
+  LayoutPoint documentPoint = m_frame->view()->rootFrameToContents(
+      flooredIntPoint(mouseEvent.positionInRootFrame()));
   MouseEventWithHitTestResults mev =
       m_frame->document()->performMouseEventHitTest(request, documentPoint,
                                                     mouseEvent);
 
   if (!mev.innerNode()) {
     m_mouseEventManager->invalidateClick();
     return WebInputEventResult::NotHandled;
   }
 
   m_mouseEventManager->setMousePressNode(mev.innerNode());
@@ skipping 32 matching lines @@
     m_scrollManager->stopAutoscroll();
     if (isMiddleClickAutoscrollInProgress) {
       // We invalidate the click when exiting middle click auto scroll so that
       // we don't inadvertently navigate away from the current page (e.g. the
       // click was on a hyperlink). See <rdar://problem/6095023>.
       m_mouseEventManager->invalidateClick();
       return WebInputEventResult::HandledSuppressed;
     }
   }
 
-  m_mouseEventManager->setClickCount(mouseEvent.clickCount());
+  m_mouseEventManager->setClickCount(mouseEvent.clickCount);
   m_mouseEventManager->setClickNode(
       mev.innerNode()->isTextNode()
           ? FlatTreeTraversal::parent(*mev.innerNode())
           : mev.innerNode());
 
   if (!mouseEvent.fromTouch())
     m_frame->selection().setCaretBlinkingSuspended(true);
 
   WebInputEventResult eventResult = updatePointerTargetAndDispatchEvents(
-      EventTypeNames::mousedown, mev.innerNode(), mev.event(),
-      Vector<PlatformMouseEvent>());
+      EventTypeNames::mousedown, mev.innerNode(), mev.canvasRegionId(),
+      mev.event(), Vector<WebMouseEvent>());
 
   if (eventResult == WebInputEventResult::NotHandled && m_frame->view()) {
     FrameView* view = m_frame->view();
     PaintLayer* layer = mev.innerNode()->layoutObject()
                             ? mev.innerNode()->layoutObject()->enclosingLayer()
                             : nullptr;
-    IntPoint p = view->rootFrameToContents(mouseEvent.position());
+    IntPoint p = view->rootFrameToContents(
+        flooredIntPoint(mouseEvent.positionInRootFrame()));
     if (layer && layer->getScrollableArea() &&
         layer->getScrollableArea()->isPointInResizeControl(p,
                                                            ResizerForPointer)) {
       m_scrollManager->setResizeScrollableArea(layer, p);
       return WebInputEventResult::HandledSystem;
     }
   }
 
   // m_selectionInitiationState is initialized after dispatching mousedown
   // event in order not to keep the selection by DOM APIs because we can't
   // give the user the chance to handle the selection by user action like
   // dragging if we keep the selection in case of mousedown. FireFox also has
   // the same behavior and it's more compatible with other browsers.
   selectionController().initializeSelectionState();
   HitTestResult hitTestResult = EventHandlingUtil::hitTestResultInFrame(
       m_frame, documentPoint, HitTestRequest::ReadOnly);
   InputDeviceCapabilities* sourceCapabilities =
-      mouseEvent.getSyntheticEventType() == PlatformMouseEvent::FromTouch
+      mouseEvent.fromTouch()
           ? InputDeviceCapabilities::firesTouchEventsSourceCapabilities()
           : InputDeviceCapabilities::doesntFireTouchEventsSourceCapabilities();
   if (eventResult == WebInputEventResult::NotHandled) {
     eventResult = m_mouseEventManager->handleMouseFocus(hitTestResult,
                                                         sourceCapabilities);
   }
   m_mouseEventManager->setCapturesDragging(
       eventResult == WebInputEventResult::NotHandled || mev.scrollbar());
 
   // If the hit testing originally determined the event was in a scrollbar,
@@ skipping 20 matching lines @@
           request, documentPoint, mouseEvent);
     }
 
     if (passMousePressEventToScrollbar(mev))
       eventResult = WebInputEventResult::HandledSystem;
     else
       eventResult = m_mouseEventManager->handleMousePressEvent(mev);
   }
 
   if (mev.hitTestResult().innerNode() &&
-      mouseEvent.pointerProperties().button ==
-          WebPointerProperties::Button::Left) {
-    ASSERT(mouseEvent.type() == PlatformEvent::MousePressed);
+      mouseEvent.button == WebPointerProperties::Button::Left) {
+    DCHECK_EQ(WebInputEvent::MouseDown, mouseEvent.type());
     HitTestResult result = mev.hitTestResult();
     result.setToShadowHostIfInUserAgentShadowRoot();
     m_frame->chromeClient().onMouseDown(result.innerNode());
   }
 
   return eventResult;
 }
 
 WebInputEventResult EventHandler::handleMouseMoveEvent(
-    const PlatformMouseEvent& event,
-    const Vector<PlatformMouseEvent>& coalescedEvents) {
+    const WebMouseEvent& event,
+    const Vector<WebMouseEvent>& coalescedEvents) {
   TRACE_EVENT0("blink", "EventHandler::handleMouseMoveEvent");
 
   HitTestResult hoveredNode = HitTestResult();
   WebInputEventResult result =
       handleMouseMoveOrLeaveEvent(event, coalescedEvents, &hoveredNode);
 
   Page* page = m_frame->page();
   if (!page)
     return result;
 
   if (PaintLayer* layer =
           EventHandlingUtil::layerForNode(hoveredNode.innerNode())) {
     if (ScrollableArea* layerScrollableArea =
             EventHandlingUtil::associatedScrollableArea(layer))
       layerScrollableArea->mouseMovedInContentArea();
   }
 
   if (FrameView* frameView = m_frame->view())
     frameView->mouseMovedInContentArea();
 
   hoveredNode.setToShadowHostIfInUserAgentShadowRoot();
   page->chromeClient().mouseDidMoveOverElement(*m_frame, hoveredNode);
 
   return result;
 }
 
-void EventHandler::handleMouseLeaveEvent(const PlatformMouseEvent& event) {
+void EventHandler::handleMouseLeaveEvent(const WebMouseEvent& event) {
   TRACE_EVENT0("blink", "EventHandler::handleMouseLeaveEvent");
 
-  handleMouseMoveOrLeaveEvent(event, Vector<PlatformMouseEvent>(), 0, false,
-                              true);
+  handleMouseMoveOrLeaveEvent(event, Vector<WebMouseEvent>(), 0, false, true);
 }
 
 WebInputEventResult EventHandler::handleMouseMoveOrLeaveEvent(
-    const PlatformMouseEvent& mouseEvent,
-    const Vector<PlatformMouseEvent>& coalescedEvents,
+    const WebMouseEvent& mouseEvent,
+    const Vector<WebMouseEvent>& coalescedEvents,
     HitTestResult* hoveredNode,
     bool onlyUpdateScrollbars,
     bool forceLeave) {
   ASSERT(m_frame);
   ASSERT(m_frame->view());
 
   m_mouseEventManager->setLastKnownMousePosition(mouseEvent);
 
   m_hoverTimer.stop();
   m_cursorUpdateTimer.stop();
 
   m_mouseEventManager->cancelFakeMouseMoveEvent();
   m_mouseEventManager->handleSvgPanIfNeeded(false);
 
   if (m_frameSetBeingResized) {
-    return updatePointerTargetAndDispatchEvents(EventTypeNames::mousemove,
-                                                m_frameSetBeingResized.get(),
-                                                mouseEvent, coalescedEvents);
+    return updatePointerTargetAndDispatchEvents(
+        EventTypeNames::mousemove, m_frameSetBeingResized.get(), String(),
+        mouseEvent, coalescedEvents);
   }
 
   // Send events right to a scrollbar if the mouse is pressed.
   if (m_lastScrollbarUnderMouse && m_mouseEventManager->mousePressed()) {
     m_lastScrollbarUnderMouse->mouseMoved(mouseEvent);
     return WebInputEventResult::HandledSystem;
   }
 
   // Mouse events simulated from touch should not hit-test again.
   ASSERT(!mouseEvent.fromTouch());
@@ skipping 55 matching lines @@
   // event to the last subframe so that it will fire mouseouts.
   if (m_lastMouseMoveEventSubframe &&
       m_lastMouseMoveEventSubframe->tree().isDescendantOf(m_frame) &&
       m_lastMouseMoveEventSubframe != newSubframe)
     m_lastMouseMoveEventSubframe->eventHandler().handleMouseLeaveEvent(
         mev.event());
 
   if (newSubframe) {
     // Update over/out state before passing the event to the subframe.
     m_pointerEventManager->sendMouseAndPointerBoundaryEvents(
-        updateMouseEventTargetNode(mev.innerNode()), mev.event());
+        updateMouseEventTargetNode(mev.innerNode()), mev.canvasRegionId(),
+        mev.event());
 
     // Event dispatch in sendMouseAndPointerBoundaryEvents may have caused the
     // subframe of the target node to be detached from its FrameView, in which
     // case the event should not be passed.
     if (newSubframe->view()) {
       eventResult = passMouseMoveEventToSubframe(mev, coalescedEvents,
                                                  newSubframe, hoveredNode);
     }
   } else {
     if (scrollbar && !m_mouseEventManager->mousePressed()) {
       // Handle hover effects on platforms that support visual feedback on
       // scrollbar hovering.
       scrollbar->mouseMoved(mev.event());
     }
     if (FrameView* view = m_frame->view()) {
       OptionalCursor optionalCursor = selectCursor(mev.hitTestResult());
       if (optionalCursor.isCursorChange()) {
         view->setCursor(optionalCursor.cursor());
       }
     }
   }
 
   m_lastMouseMoveEventSubframe = newSubframe;
 
   if (eventResult != WebInputEventResult::NotHandled)
     return eventResult;
 
   eventResult = updatePointerTargetAndDispatchEvents(
-      EventTypeNames::mousemove, mev.innerNode(), mev.event(), coalescedEvents);
+      EventTypeNames::mousemove, mev.innerNode(), mev.canvasRegionId(),
+      mev.event(), coalescedEvents);
   if (eventResult != WebInputEventResult::NotHandled)
     return eventResult;
 
   return m_mouseEventManager->handleMouseDraggedEvent(mev);
 }
 
 WebInputEventResult EventHandler::handleMouseReleaseEvent(
-    const PlatformMouseEvent& mouseEvent) {
+    const WebMouseEvent& mouseEvent) {
   TRACE_EVENT0("blink", "EventHandler::handleMouseReleaseEvent");
 
   // For 4th/5th button in the mouse since Chrome does not yet send
   // button value to Blink but in some cases it does send the event.
   // This check is needed to suppress such an event (crbug.com/574959)
-  if (mouseEvent.pointerProperties().button ==
-      WebPointerProperties::Button::NoButton)
+  if (mouseEvent.button == WebPointerProperties::Button::NoButton)
     return WebInputEventResult::HandledSuppressed;
 
   if (!mouseEvent.fromTouch())
     m_frame->selection().setCaretBlinkingSuspended(false);
 
   if (RuntimeEnabledFeatures::middleClickAutoscrollEnabled()) {
     if (Page* page = m_frame->page())
       page->autoscrollController().handleMouseReleaseForMiddleClickAutoscroll(
           m_frame, mouseEvent);
   }
 
   m_mouseEventManager->setMousePressed(false);
   m_mouseEventManager->setLastKnownMousePosition(mouseEvent);
   m_mouseEventManager->handleSvgPanIfNeeded(true);
 
   if (m_frameSetBeingResized) {
     return m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
-        updateMouseEventTargetNode(m_frameSetBeingResized.get()),
+        updateMouseEventTargetNode(m_frameSetBeingResized.get()), String(),
         EventTypeNames::mouseup, mouseEvent);
   }
 
   if (m_lastScrollbarUnderMouse) {
     m_mouseEventManager->invalidateClick();
     m_lastScrollbarUnderMouse->mouseUp(mouseEvent);
     return updatePointerTargetAndDispatchEvents(
         EventTypeNames::mouseup, m_mouseEventManager->getNodeUnderMouse(),
-        mouseEvent, Vector<PlatformMouseEvent>());
+        String(), mouseEvent, Vector<WebMouseEvent>());
   }
 
   // Mouse events simulated from touch should not hit-test again.
   ASSERT(!mouseEvent.fromTouch());
 
   HitTestRequest::HitTestRequestType hitType = HitTestRequest::Release;
   HitTestRequest request(hitType);
   MouseEventWithHitTestResults mev =
       EventHandlingUtil::performMouseEventHitTest(m_frame, request, mouseEvent);
   LocalFrame* subframe =
@@ skipping 17 matching lines @@
     gestureIndicator = WTF::wrapUnique(new UserGestureIndicator(
         m_frame->localFrameRoot()
             ->eventHandler()
             .m_lastMouseDownUserGestureToken.release()));
   } else {
     gestureIndicator = WTF::wrapUnique(new UserGestureIndicator(
         DocumentUserGestureToken::create(m_frame->document())));
   }
 
   WebInputEventResult eventResult = updatePointerTargetAndDispatchEvents(
-      EventTypeNames::mouseup, mev.innerNode(), mev.event(),
-      Vector<PlatformMouseEvent>());
+      EventTypeNames::mouseup, mev.innerNode(), mev.canvasRegionId(),
+      mev.event(), Vector<WebMouseEvent>());
 
   WebInputEventResult clickEventResult =
       m_mouseEventManager->dispatchMouseClickIfNeeded(mev);
 
   m_scrollManager->clearResizeScrollableArea(false);
 
   if (eventResult == WebInputEventResult::NotHandled)
     eventResult = m_mouseEventManager->handleMouseReleaseEvent(mev);
   m_mouseEventManager->clearDragHeuristicState();
 
@@ skipping 51 matching lines @@
     if (matched) {
       dataTransfer->setDropEffect(
           convertDragOperationToDropZoneOperation(dragOperation));
       return true;
     }
   }
   return false;
 }
 
 WebInputEventResult EventHandler::updateDragAndDrop(
-    const PlatformMouseEvent& event,
+    const WebMouseEvent& event,
     DataTransfer* dataTransfer) {
   WebInputEventResult eventResult = WebInputEventResult::NotHandled;
 
   if (!m_frame->view())
     return eventResult;
 
   HitTestRequest request(HitTestRequest::ReadOnly);
   MouseEventWithHitTestResults mev =
       EventHandlingUtil::performMouseEventHitTest(m_frame, request, event);
 
   // Drag events should never go to text nodes (following IE, and proper
   // mouseover/out dispatch)
   Node* newTarget = mev.innerNode();
   if (newTarget && newTarget->isTextNode())
     newTarget = FlatTreeTraversal::parent(*newTarget);
 
   if (AutoscrollController* controller =
-          m_scrollManager->autoscrollController())
-    controller->updateDragAndDrop(newTarget, event.position(),
-                                  event.timestamp());
+          m_scrollManager->autoscrollController()) {
+    controller->updateDragAndDrop(
+        newTarget, flooredIntPoint(event.positionInRootFrame()),
+        TimeTicks::FromSeconds(event.timeStampSeconds()));
+  }
 
   if (m_dragTarget != newTarget) {
     // FIXME: this ordering was explicitly chosen to match WinIE. However,
     // it is sometimes incorrect when dragging within subframes, as seen with
     // LayoutTests/fast/events/drag-in-frames.html.
     //
     // Moreover, this ordering conforms to section 7.9.4 of the HTML 5 spec.
     // <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>.
     LocalFrame* targetFrame;
     if (targetIsFrame(newTarget, targetFrame)) {
@@ skipping 52 matching lines @@
           findDropZone(newTarget, dataTransfer))
         eventResult = WebInputEventResult::HandledSystem;
       m_shouldOnlyFireDragOverEvent = false;
     }
   }
   m_dragTarget = newTarget;
 
   return eventResult;
 }
 
-void EventHandler::cancelDragAndDrop(const PlatformMouseEvent& event,
+void EventHandler::cancelDragAndDrop(const WebMouseEvent& event,
                                      DataTransfer* dataTransfer) {
   LocalFrame* targetFrame;
   if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
     if (targetFrame)
       targetFrame->eventHandler().cancelDragAndDrop(event, dataTransfer);
   } else if (m_dragTarget.get()) {
     if (m_mouseEventManager->dragState().m_dragSrc)
       m_mouseEventManager->dispatchDragSrcEvent(EventTypeNames::drag, event);
     m_mouseEventManager->dispatchDragEvent(
         EventTypeNames::dragleave, m_dragTarget.get(), event, dataTransfer);
   }
   clearDragState();
 }
 
 WebInputEventResult EventHandler::performDragAndDrop(
-    const PlatformMouseEvent& event,
+    const WebMouseEvent& event,
     DataTransfer* dataTransfer) {
   LocalFrame* targetFrame;
   WebInputEventResult result = WebInputEventResult::NotHandled;
   if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
     if (targetFrame)
       result =
           targetFrame->eventHandler().performDragAndDrop(event, dataTransfer);
   } else if (m_dragTarget.get()) {
     result = m_mouseEventManager->dispatchDragEvent(
         EventTypeNames::drop, m_dragTarget.get(), event, dataTransfer);
@@ skipping 82 matching lines @@
   return m_pointerEventManager->hasProcessedPointerCapture(pointerId, target);
 }
 
 void EventHandler::elementRemoved(EventTarget* target) {
   m_pointerEventManager->elementRemoved(target);
 }
 
 WebInputEventResult EventHandler::updatePointerTargetAndDispatchEvents(
     const AtomicString& mouseEventType,
     Node* targetNode,
-    const PlatformMouseEvent& mouseEvent,
-    const Vector<PlatformMouseEvent>& coalescedEvents) {
+    const String& canvasRegionId,
+    const WebMouseEvent& mouseEvent,
+    const Vector<WebMouseEvent>& coalescedEvents) {
   ASSERT(mouseEventType == EventTypeNames::mousedown ||
          mouseEventType == EventTypeNames::mousemove ||
          mouseEventType == EventTypeNames::mouseup);
 
   const auto& eventResult = m_pointerEventManager->sendMousePointerEvent(
-      updateMouseEventTargetNode(targetNode), mouseEventType, mouseEvent,
-      coalescedEvents);
+      updateMouseEventTargetNode(targetNode), canvasRegionId, mouseEventType,
+      mouseEvent, coalescedEvents);
   return eventResult;
 }
 
 WebInputEventResult EventHandler::handleWheelEvent(
     const WebMouseWheelEvent& event) {
 #if OS(MACOSX)
   // Filter Mac OS specific phases, usually with a zero-delta.
   // https://crbug.com/553732
   // TODO(chongz): EventSender sends events with
   // |WebMouseWheelEvent::PhaseNone|,
@@ skipping 332 matching lines @@
       if (exitedFrameInDocument != lastEnteredFrameInDocument)
         exitedFrameChain.push_back(exitedFrameInDocument);
       else if (nextExitedFrameInDocument && indexEnteredFrameChain)
         --indexEnteredFrameChain;
     }
     exitedFrameInDocument = nextExitedFrameInDocument;
   }
 
   const WebGestureEvent& gestureEvent = targetedEvent.event();
   unsigned modifiers = gestureEvent.modifiers();
-  PlatformMouseEvent fakeMouseMove(
-      gestureEvent, WebPointerProperties::Button::NoButton,
-      PlatformEvent::MouseMoved,
-      /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
-      PlatformMouseEvent::FromTouch,
-      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
-      WebPointerProperties::PointerType::Mouse);
+  WebMouseEvent fakeMouseMove(
+      WebInputEvent::MouseMove, gestureEvent,
+      WebPointerProperties::Button::NoButton,
+      /* clickCount */ 0,
+      modifiers | WebInputEvent::Modifiers::IsCompatibilityEventForTouch,
+      gestureEvent.timeStampSeconds());
 
   // Update the mouseout/mouseleave event
   size_t indexExitedFrameChain = exitedFrameChain.size();
   while (indexExitedFrameChain) {
     LocalFrame* leaveFrame = exitedFrameChain[--indexExitedFrameChain];
     leaveFrame->eventHandler().m_mouseEventManager->setNodeUnderMouse(
-        updateMouseEventTargetNode(nullptr), fakeMouseMove);
+        updateMouseEventTargetNode(nullptr), String(), fakeMouseMove);
   }
 
   // update the mouseover/mouseenter event
   while (indexEnteredFrameChain) {
     Frame* parentFrame =
         enteredFrameChain[--indexEnteredFrameChain]->tree().parent();
-    if (parentFrame && parentFrame->isLocalFrame())
+    if (parentFrame && parentFrame->isLocalFrame()) {
       toLocalFrame(parentFrame)
           ->eventHandler()
           .m_mouseEventManager->setNodeUnderMouse(
               updateMouseEventTargetNode(toHTMLFrameOwnerElement(
                   enteredFrameChain[indexEnteredFrameChain]->owner())),
-              fakeMouseMove);
+              String(), fakeMouseMove);
+    }
   }
 }
 
 GestureEventWithHitTestResults EventHandler::targetGestureEvent(
     const WebGestureEvent& gestureEvent,
     bool readOnly) {
   TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
 
   ASSERT(m_frame == m_frame->localFrameRoot());
   // Scrolling events get hit tested per frame (like wheel events do).
@@ skipping 118 matching lines @@
   // crbug.com/398914
   if (adjusted) {
     hitTestResult->resolveRectBasedTest(
         adjustedNode, m_frame->view()->rootFrameToContents(adjustedPoint));
     gestureEvent->applyTouchAdjustment(
         WebFloatPoint(adjustedPoint.x(), adjustedPoint.y()));
   }
 }
 
 WebInputEventResult EventHandler::sendContextMenuEvent(
-    const PlatformMouseEvent& event,
+    const WebMouseEvent& event,
     Node* overrideTargetNode) {
   FrameView* v = m_frame->view();
   if (!v)
     return WebInputEventResult::NotHandled;
 
   // Clear mouse press state to avoid initiating a drag while context menu is
   // up.
   m_mouseEventManager->setMousePressed(false);
-  LayoutPoint positionInContents = v->rootFrameToContents(event.position());
+  LayoutPoint positionInContents =
+      v->rootFrameToContents(flooredIntPoint(event.positionInRootFrame()));
   HitTestRequest request(HitTestRequest::Active);
   MouseEventWithHitTestResults mev =
       m_frame->document()->performMouseEventHitTest(request, positionInContents,
                                                     event);
   // Since |Document::performMouseEventHitTest()| modifies layout tree for
   // setting hover element, we need to update layout tree for requirement of
   // |SelectionController::sendContextMenuEvent()|.
   m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   selectionController().sendContextMenuEvent(mev, positionInContents);
 
   Node* targetNode = overrideTargetNode ? overrideTargetNode : mev.innerNode();
   return m_mouseEventManager->dispatchMouseEvent(
       updateMouseEventTargetNode(targetNode), EventTypeNames::contextmenu,
-      event, 0);
+      event, mev.hitTestResult().canvasRegionId(), 0);
 }
 
 WebInputEventResult EventHandler::sendContextMenuEventForKey(
     Element* overrideTargetElement) {
   FrameView* view = m_frame->view();
   if (!view)
     return WebInputEventResult::NotHandled;
 
   Document* doc = m_frame->document();
   if (!doc)
@@ skipping 56 matching lines @@
 
   // Use the focused node as the target for hover and active.
   HitTestRequest request(HitTestRequest::Active);
   HitTestResult result(request, locationInRootFrame);
   result.setInnerNode(targetNode);
   doc->updateHoverActiveState(request, result.innerElement(),
                               result.scrollbar());
 
   // The contextmenu event is a mouse event even when invoked using the
   // keyboard.  This is required for web compatibility.
-  PlatformEvent::EventType eventType = PlatformEvent::MousePressed;
+  WebInputEvent::Type eventType = WebInputEvent::MouseDown;
   if (m_frame->settings() && m_frame->settings()->getShowContextMenuOnMouseUp())
-    eventType = PlatformEvent::MouseReleased;
+    eventType = WebInputEvent::MouseUp;
 
-  PlatformMouseEvent mouseEvent(
-      locationInRootFrame, globalPosition,
-      WebPointerProperties::Button::NoButton, eventType, /* clickCount */ 0,
-      PlatformEvent::NoModifiers, PlatformMouseEvent::RealOrIndistinguishable,
-      TimeTicks::Now(), WebPointerProperties::PointerType::Mouse);
+  WebMouseEvent mouseEvent(
+      eventType,
+      WebFloatPoint(locationInRootFrame.x(), locationInRootFrame.y()),
+      WebFloatPoint(globalPosition.x(), globalPosition.y()),
+      WebPointerProperties::Button::NoButton, /* clickCount */ 0,
+      PlatformEvent::NoModifiers, TimeTicks::Now().InSeconds());
+
+  // TODO(dtapuska): Transition the mouseEvent to be created really in viewport
+  // coordinates instead of root frame coordinates.

[bokan, 2017/01/27 16:57:17]

Why? The sendContextMenuEvent expects it in root frame coordinates and it's
generated from within Blink. Is there a reason this is a problem?

[dtapuska, 2017/01/27 21:00:00]

So that it is consistent for all events. Reading the position should really be
the true viewport position.

[bokan, 2017/01/27 21:08:47]

Right, forgot that the |position| is really in viewport coords.

+  mouseEvent.setFrameScale(1);
 
   return sendContextMenuEvent(mouseEvent, overrideTargetElement);
 }
 
 void EventHandler::scheduleHoverStateUpdate() {
   // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
   if (!m_hoverTimer.isActive() &&
       !m_mouseEventManager->isMousePositionUnknown())
     m_hoverTimer.startOneShot(0, BLINK_FROM_HERE);
 }
@@ skipping 75 matching lines @@
 WebInputEventResult EventHandler::keyEvent(
     const WebKeyboardEvent& initialKeyEvent) {
   return m_keyboardEventManager->keyEvent(initialKeyEvent);
 }
 
 void EventHandler::defaultKeyboardEventHandler(KeyboardEvent* event) {
   m_keyboardEventManager->defaultKeyboardEventHandler(
       event, m_mouseEventManager->mousePressNode());
 }
 
-void EventHandler::dragSourceEndedAt(const PlatformMouseEvent& event,
+void EventHandler::dragSourceEndedAt(const WebMouseEvent& event,
                                      DragOperation operation) {
   // Asides from routing the event to the correct frame, the hit test is also an
   // opportunity for Layer to update the :hover and :active pseudoclasses.
   HitTestRequest request(HitTestRequest::Release);
   MouseEventWithHitTestResults mev =
       EventHandlingUtil::performMouseEventHitTest(m_frame, request, event);
 
   LocalFrame* targetFrame;
   if (targetIsFrame(mev.innerNode(), targetFrame)) {
     if (targetFrame) {
@@ skipping 92 matching lines @@
   selectionController().passMousePressEventToSubframe(mev);
   WebInputEventResult result =
       subframe->eventHandler().handleMousePressEvent(mev.event());
   if (result != WebInputEventResult::NotHandled)
     return result;
   return WebInputEventResult::HandledSystem;
 }
 
 WebInputEventResult EventHandler::passMouseMoveEventToSubframe(
     MouseEventWithHitTestResults& mev,
-    const Vector<PlatformMouseEvent>& coalescedEvents,
+    const Vector<WebMouseEvent>& coalescedEvents,
     LocalFrame* subframe,
     HitTestResult* hoveredNode) {
   if (m_mouseEventManager->mouseDownMayStartDrag())
     return WebInputEventResult::NotHandled;
   WebInputEventResult result =
       subframe->eventHandler().handleMouseMoveOrLeaveEvent(
           mev.event(), coalescedEvents, hoveredNode);
   if (result != WebInputEventResult::NotHandled)
     return result;
   return WebInputEventResult::HandledSystem;
@@ skipping 10 matching lines @@
 }
 
 FrameHost* EventHandler::frameHost() const {
   if (!m_frame->page())
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 }  // namespace blink