Fired PointerEvent from Node::dispatchMouseEvent() to fix a bug.

third_party/WebKit/Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  *
@@ skipping 60 matching lines @@
 #include "core/events/Event.h"
 #include "core/events/EventDispatchMediator.h"
 #include "core/events/EventDispatcher.h"
 #include "core/events/EventListener.h"
 #include "core/events/GestureEvent.h"
 #include "core/events/InputEvent.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/MouseEvent.h"
 #include "core/events/MutationEvent.h"
 #include "core/events/PointerEvent.h"
+#include "core/events/PointerEventFactory.h"
 #include "core/events/TextEvent.h"
 #include "core/events/TouchEvent.h"
 #include "core/events/UIEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/frame/EventHandlerRegistry.h"
+#include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLDialogElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLSlotElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutBox.h"
 #include "core/page/ContextMenuController.h"
 #include "core/page/Page.h"
 #include "core/svg/SVGElement.h"
@@ skipping 2006 matching lines @@
                      document().domWindow(), detail);
   event->setUnderlyingEvent(&underlyingEvent);
   event->setComposed(underlyingEvent.composed());
   dispatchScopedEvent(event);
 
   // TODO(dtapuska): Dispatching scoped events shouldn't check the return
   // type because the scoped event could get put off in the delayed queue.
   return EventTarget::dispatchEventResult(*event);
 }
 
-DispatchEventResult Node::dispatchMouseEvent(
-    const PlatformMouseEvent& nativeEvent,
-    const AtomicString& eventType,
-    int detail,
-    Node* relatedTarget) {
-  MouseEvent* event = MouseEvent::create(eventType, document().domWindow(),
-                                         nativeEvent, detail, relatedTarget);
-  return dispatchEvent(event);
+void Node::createAndDispatchPointerEvent(const AtomicString& mouseEventName,
+                                         const PlatformMouseEvent& mouseEvent,
+                                         LocalDOMWindow* view) {
+  AtomicString pointerEventName;
+  if (mouseEventName == EventTypeNames::mousemove)
+    pointerEventName = EventTypeNames::pointermove;
+  else if (mouseEventName == EventTypeNames::mousedown)
+    pointerEventName = EventTypeNames::pointerdown;
+  else if (mouseEventName == EventTypeNames::mouseup)
+    pointerEventName = EventTypeNames::pointerup;
+  else
+    return;
+
+  PointerEventInit pointerEventInit;
+
+  pointerEventInit.setPointerId(PointerEventFactory::s_mouseId);
+  pointerEventInit.setPointerType("mouse");
+  pointerEventInit.setIsPrimary(true);
+  pointerEventInit.setButtons(
+      MouseEvent::platformModifiersToButtons(mouseEvent.getModifiers()));
+
+  pointerEventInit.setBubbles(true);
+  pointerEventInit.setCancelable(true);
+  pointerEventInit.setComposed(true);
+  pointerEventInit.setDetail(0);
+
+  pointerEventInit.setScreenX(mouseEvent.globalPosition().x());
+  pointerEventInit.setScreenY(mouseEvent.globalPosition().y());
+
+  IntPoint locationInFrameZoomed;
+  if (view && view->frame() && view->frame()->view()) {
+    LocalFrame* frame = view->frame();
+    FrameView* frameView = frame->view();
+    IntPoint locationInContents =
+        frameView->rootFrameToContents(mouseEvent.position());
+    locationInFrameZoomed = frameView->contentsToFrame(locationInContents);
+    float scaleFactor = 1 / frame->pageZoomFactor();
+    locationInFrameZoomed.scale(scaleFactor, scaleFactor);
+  }
+
+  // Set up initial values for coordinates.
+  pointerEventInit.setClientX(locationInFrameZoomed.x());
+  pointerEventInit.setClientY(locationInFrameZoomed.y());
+
+  if (pointerEventName == EventTypeNames::pointerdown ||
+      pointerEventName == EventTypeNames::pointerup) {
+    pointerEventInit.setButton(
+        static_cast<int>(mouseEvent.pointerProperties().button));
+  } else {
+    pointerEventInit.setButton(
+        static_cast<int>(WebPointerProperties::Button::NoButton));
+  }
+
+  UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit,
+                                                mouseEvent.getModifiers());
+  pointerEventInit.setView(view);
+
+  dispatchEvent(PointerEvent::create(pointerEventName, pointerEventInit));
+}
+
+void Node::dispatchMouseEvent(const PlatformMouseEvent& nativeEvent,
+                              const AtomicString& mouseEventType,
+                              int detail,
+                              Node* relatedTarget) {
+  createAndDispatchPointerEvent(mouseEventType, nativeEvent,
+                                document().domWindow());
+  dispatchEvent(MouseEvent::create(mouseEventType, document().domWindow(),
+                                   nativeEvent, detail, relatedTarget));
 }
 
 void Node::dispatchSimulatedClick(Event* underlyingEvent,
                                   SimulatedClickMouseEventOptions eventOptions,
                                   SimulatedClickCreationScope scope) {
   EventDispatcher::dispatchSimulatedClick(*this, underlyingEvent, eventOptions,
                                           scope);
 }
 
 void Node::dispatchInputEvent() {
@@ skipping 359 matching lines @@
   if (node) {
     std::stringstream stream;
     node->printNodePathTo(stream);
     LOG(INFO) << stream.str();
   } else {
     LOG(INFO) << "Cannot showNodePath for <null>";
   }
 }
 
 #endif