Remove MouseRelatedEvent

third_party/WebKit/Source/core/events/MouseEvent.h

 /*
  * Copyright (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2001 Tobias Anton (anton@stud.fbi.fh-darmstadt.de)
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef MouseEvent_h
 #define MouseEvent_h
 
 #include "core/CoreExport.h"
 #include "core/events/EventDispatchMediator.h"
 #include "core/events/MouseEventInit.h"
-#include "core/events/MouseRelatedEvent.h"
+#include "core/events/UIEventWithKeyState.h"
 #include "platform/PlatformMouseEvent.h"
 
 namespace blink {
 class DataTransfer;
 class EventDispatcher;
 
-class CORE_EXPORT MouseEvent : public MouseRelatedEvent {
+class CORE_EXPORT MouseEvent : public UIEventWithKeyState {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
   static MouseEvent* create() { return new MouseEvent; }
 
   // TODO(mustaq): Should replace most/all of these params with a
   // MouseEventInit.
   static MouseEvent* create(const AtomicString& type,
                             bool canBubble,
                             bool cancelable,
@@ skipping 79 matching lines @@
 
   bool isMouseEvent() const override;
   int which() const final;
 
   EventDispatchMediator* createMediator() override;
 
   int clickCount() { return detail(); }
 
   const PlatformMouseEvent* mouseEvent() const { return m_mouseEvent.get(); }
 
+  enum class PositionType {
+    Position,
+    // Positionless mouse events are used, for example, for 'click' events from
+    // keyboard input.  It's kind of surprising for a mouse event not to have a
+    // position.
+    Positionless
+  };
+
+  // Note that these values are adjusted to counter the effects of zoom, so that
+  // values exposed via DOM APIs are invariant under zooming.
+  // TODO(mustaq): Remove the PointerEvent specific code when mouse has
+  // fractional coordinates. See crbug.com/655786.
+  double screenX() const {
+    return isPointerEvent() ? m_screenLocation.x()
+                            : static_cast<int>(m_screenLocation.x());
+  }
+  double screenY() const {
+    return isPointerEvent() ? m_screenLocation.y()
+                            : static_cast<int>(m_screenLocation.y());
+  }
+
+  double clientX() const {
+    return isPointerEvent() ? m_clientLocation.x()
+                            : static_cast<int>(m_clientLocation.x());
+  }
+  double clientY() const {
+    return isPointerEvent() ? m_clientLocation.y()
+                            : static_cast<int>(m_clientLocation.y());
+  }
+
+  int movementX() const { return m_movementDelta.x(); }
+  int movementY() const { return m_movementDelta.y(); }
+
+  int layerX();
+  int layerY();
+
+  int offsetX();
+  int offsetY();
+
+  double pageX() const {
+    return isPointerEvent() ? m_pageLocation.x()
+                            : static_cast<int>(m_pageLocation.x());
+  }
+  double pageY() const {
+    return isPointerEvent() ? m_pageLocation.y()
+                            : static_cast<int>(m_pageLocation.y());
+  }
+
+  double x() const { return clientX(); }
+  double y() const { return clientY(); }
+
+  bool hasPosition() const { return m_positionType == PositionType::Position; }
+
+  // Page point in "absolute" coordinates (i.e. post-zoomed, page-relative
+  // coords, usable with LayoutObject::absoluteToLocal) relative to view(), i.e.
+  // the local frame.
+  const DoublePoint& absoluteLocation() const { return m_absoluteLocation; }
+
   DECLARE_VIRTUAL_TRACE();
 
  protected:
   MouseEvent(const AtomicString& type,
              bool canBubble,
              bool cancelable,
              AbstractView*,
              int detail,
              int screenX,
              int screenY,
@@ skipping 26 matching lines @@
                               int screenX,
                               int screenY,
                               int clientX,
                               int clientY,
                               PlatformEvent::Modifiers,
                               short button,
                               EventTarget* relatedTarget,
                               InputDeviceCapabilities* sourceCapabilities,
                               unsigned short buttons = 0);
 
+  void initCoordinates(const double clientX, const double clientY);
+  void receivedTarget() final;
+
+  void computePageLocation();
+  void computeRelativePosition();
+
+  DoublePoint m_screenLocation;
+  DoublePoint m_clientLocation;
+  DoublePoint m_movementDelta;
+
+  DoublePoint m_pageLocation;
+  DoublePoint m_layerLocation;
+  DoublePoint m_offsetLocation;
+  DoublePoint m_absoluteLocation;
+  PositionType m_positionType;
+  bool m_hasCachedRelativePosition;
   short m_button;
   unsigned short m_buttons;
   Member<EventTarget> m_relatedTarget;
   PlatformMouseEvent::SyntheticEventType m_syntheticEventType;
   String m_region;
   std::unique_ptr<PlatformMouseEvent> m_mouseEvent;
 };
 
 class MouseEventDispatchMediator final : public EventDispatchMediator {
  public:
   static MouseEventDispatchMediator* create(MouseEvent*);
 
  private:
   explicit MouseEventDispatchMediator(MouseEvent*);
   MouseEvent& event() const;
 
   DispatchEventResult dispatchEvent(EventDispatcher&) const override;
 };
 
 DEFINE_EVENT_TYPE_CASTS(MouseEvent);
 
 }  // namespace blink
 
 #endif  // MouseEvent_h