Remove PlatformMouseEvent and use WebMouseEvent instead

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/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
@@ skipping 162 matching lines @@
 EventTarget* PointerEventManager::getEffectiveTargetForPointerEvent(
     EventTarget* target,
     int pointerId) {
   if (EventTarget* capturingTarget = getCapturingNode(pointerId))
     return capturingTarget;
   return target;
 }
 
 void PointerEventManager::sendMouseAndPointerBoundaryEvents(
     Node* enteredNode,
-    const PlatformMouseEvent& mouseEvent) {
+    const String& canvasRegionId,
+    const WebMouseEvent& mouseEvent) {
   // Mouse event type does not matter as this pointerevent will only be used
   // to create boundary pointer events and its type will be overridden in
   // |sendBoundaryEvents| function.
   PointerEvent* dummyPointerEvent = m_pointerEventFactory.create(
-      EventTypeNames::mousedown, mouseEvent, Vector<PlatformMouseEvent>(),
+      EventTypeNames::mousedown, mouseEvent, Vector<WebMouseEvent>(),
       m_frame->document()->domWindow());
 
   // TODO(crbug/545647): This state should reset with pointercancel too.
   // This function also gets called for compat mouse events of touch at this
   // stage. So if the event is not frame boundary transition it is only a
   // compatibility mouse event and we do not need to change pointer event
   // behavior regarding preventMouseEvent state in that case.
   if (dummyPointerEvent->buttons() == 0 && dummyPointerEvent->isPrimary()) {
     m_preventMouseEventForPointerType[toPointerTypeIndex(
-        mouseEvent.pointerProperties().pointerType)] = false;
+        mouseEvent.pointerType)] = false;
   }
 
   processCaptureAndPositionOfPointerEvent(dummyPointerEvent, enteredNode,
-                                          mouseEvent, true);
+                                          canvasRegionId, mouseEvent, true);
 }
 
 void PointerEventManager::sendBoundaryEvents(EventTarget* exitedTarget,
                                              EventTarget* enteredTarget,
                                              PointerEvent* pointerEvent) {
   PointerEventBoundaryEventDispatcher boundaryEventDispatcher(this,
                                                               pointerEvent);
   boundaryEventDispatcher.sendBoundaryEvents(exitedTarget, enteredTarget);
 }
 
@@ skipping 219 matching lines @@
     processCaptureAndPositionOfPointerEvent(pointerEvent, nullptr);
 
     removePointer(pointerEvent);
   }
 
   return result;
 }
 
 WebInputEventResult PointerEventManager::sendMousePointerEvent(
     Node* target,
+    const String& canvasRegionId,
     const AtomicString& mouseEventType,
-    const PlatformMouseEvent& mouseEvent,
-    const Vector<PlatformMouseEvent>& coalescedEvents) {
+    const WebMouseEvent& mouseEvent,
+    const Vector<WebMouseEvent>& coalescedEvents) {
   PointerEvent* pointerEvent =
       m_pointerEventFactory.create(mouseEventType, mouseEvent, coalescedEvents,
                                    m_frame->document()->domWindow());
 
   // This is for when the mouse is released outside of the page.
   if (pointerEvent->type() == EventTypeNames::pointermove &&
       !pointerEvent->buttons()) {
     releasePointerCapture(pointerEvent->pointerId());
     // Send got/lostpointercapture rightaway if necessary.
     processPendingPointerCapture(pointerEvent);
 
     if (pointerEvent->isPrimary()) {
       m_preventMouseEventForPointerType[toPointerTypeIndex(
-          mouseEvent.pointerProperties().pointerType)] = false;
+          mouseEvent.pointerType)] = false;
     }
   }
 
   EventTarget* pointerEventTarget = processCaptureAndPositionOfPointerEvent(
-      pointerEvent, target, mouseEvent, true);
+      pointerEvent, target, canvasRegionId, mouseEvent, true);
 
   EventTarget* effectiveTarget = getEffectiveTargetForPointerEvent(
       pointerEventTarget, pointerEvent->pointerId());
 
   WebInputEventResult result =
       dispatchPointerEvent(effectiveTarget, pointerEvent);
 
   if (result != WebInputEventResult::NotHandled &&
       pointerEvent->type() == EventTypeNames::pointerdown &&
       pointerEvent->isPrimary()) {
     m_preventMouseEventForPointerType[toPointerTypeIndex(
-        mouseEvent.pointerProperties().pointerType)] = true;
+        mouseEvent.pointerType)] = true;
   }
 
   if (pointerEvent->isPrimary() &&
       !m_preventMouseEventForPointerType[toPointerTypeIndex(
-          mouseEvent.pointerProperties().pointerType)]) {
+          mouseEvent.pointerType)]) {
     EventTarget* mouseTarget = effectiveTarget;
     // Event path could be null if pointer event is not dispatched and
     // that happens for example when pointer event feature is not enabled.
     if (!isInDocument(mouseTarget) && pointerEvent->hasEventPath()) {
       for (const auto& context :
            pointerEvent->eventPath().nodeEventContexts()) {
         if (isInDocument(context.node())) {
           mouseTarget = context.node();
           break;
         }
       }
     }
     result = EventHandlingUtil::mergeEventResult(
-        result, m_mouseEventManager->dispatchMouseEvent(
-                    mouseTarget, mouseEventType, mouseEvent, nullptr));
+        result,
+        m_mouseEventManager->dispatchMouseEvent(
+            mouseTarget, mouseEventType, mouseEvent, canvasRegionId, nullptr));
   }
 
   if (pointerEvent->type() == EventTypeNames::pointerup ||
       pointerEvent->type() == EventTypeNames::pointercancel) {
     releasePointerCapture(pointerEvent->pointerId());
     // Send got/lostpointercapture rightaway if necessary.
     processPendingPointerCapture(pointerEvent);
 
     if (pointerEvent->isPrimary()) {
       m_preventMouseEventForPointerType[toPointerTypeIndex(
-          mouseEvent.pointerProperties().pointerType)] = false;
+          mouseEvent.pointerType)] = false;
     }
   }
 
   return result;
 }
 
 bool PointerEventManager::getPointerCaptureState(
     int pointerId,
     EventTarget** pointerCaptureTarget,
     EventTarget** pendingPointerCaptureTarget) {
@@ skipping 10 matching lines @@
     *pointerCaptureTarget = pointerCaptureTargetTemp;
   if (pendingPointerCaptureTarget)
     *pendingPointerCaptureTarget = pendingPointercaptureTargetTemp;
 
   return pointerCaptureTargetTemp != pendingPointercaptureTargetTemp;
 }
 
 EventTarget* PointerEventManager::processCaptureAndPositionOfPointerEvent(
     PointerEvent* pointerEvent,
     EventTarget* hitTestTarget,
-    const PlatformMouseEvent& mouseEvent,
+    const String& canvasRegionId,
+    const WebMouseEvent& mouseEvent,
     bool sendMouseEvent) {
   processPendingPointerCapture(pointerEvent);
 
   PointerCapturingMap::const_iterator it =
       m_pointerCaptureTarget.find(pointerEvent->pointerId());
   if (EventTarget* pointercaptureTarget =
           (it != m_pointerCaptureTarget.end()) ? it->value : nullptr)
     hitTestTarget = pointercaptureTarget;
 
   setNodeUnderPointer(pointerEvent, hitTestTarget);
   if (sendMouseEvent) {
     m_mouseEventManager->setNodeUnderMouse(
-        hitTestTarget ? hitTestTarget->toNode() : nullptr, mouseEvent);
+        hitTestTarget ? hitTestTarget->toNode() : nullptr, canvasRegionId,
+        mouseEvent);
   }
   return hitTestTarget;
 }
 
 void PointerEventManager::processPendingPointerCapture(
     PointerEvent* pointerEvent) {
   EventTarget* pointerCaptureTarget;
   EventTarget* pendingPointerCaptureTarget;
   const int pointerId = pointerEvent->pointerId();
   const bool isCaptureChanged = getPointerCaptureState(
@@ skipping 132 matching lines @@
     if (firstId > uniqueTouchEventId)
       return false;
     m_touchIdsForCanceledPointerdowns.takeFirst();
     if (firstId == uniqueTouchEventId)
       return true;
   }
   return false;
 }
 
 }  // namespace blink