/*

* Copyright (C) 2006-2023 Apple Inc. All rights reserved.

* Copyright (C) 2013 Google 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.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR

* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#include "EventHandler.h"

#include "AutoscrollController.h"

#include "BackForwardController.h"

#include "CachedImage.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "ComposedTreeAncestorIterator.h"

#include "ComposedTreeIterator.h"

#include "CursorList.h"

#include "DocumentInlines.h"

#include "DocumentMarkerController.h"

#include "DragController.h"

#include "DragEvent.h"

#include "DragState.h"

#include "Editing.h"

#include "Editor.h"

#include "EditorClient.h"

#include "ElementInlines.h"

#include "EventNames.h"

#include "FileList.h"

#include "FloatPoint.h"

#include "FloatRect.h"

#include "FocusController.h"

#include "FocusOptions.h"

#include "FrameLoader.h"

#include "FrameSelection.h"

#include "FrameTree.h"

#include "FullscreenManager.h"

#include "HTMLDialogElement.h"

#include "HTMLDocument.h"

#include "HTMLFrameElement.h"

#include "HTMLFrameSetElement.h"

#include "HTMLHtmlElement.h"

#include "HTMLIFrameElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "HTMLVideoElement.h"

#include "HandleUserInputEventResult.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "Image.h"

#include "ImageOverlay.h"

#include "ImageOverlayController.h"

#include "InspectorInstrumentation.h"

#include "KeyboardEvent.h"

#include "KeyboardScrollingAnimator.h"

#include "LocalFrame.h"

#include "LocalFrameView.h"

#include "Logging.h"

#include "MouseEvent.h"

#include "MouseEventWithHitTestResults.h"

#include "NotImplemented.h"

#include "Page.h"

#include "PageOverlayController.h"

#include "Pasteboard.h"

#include "PlatformEvent.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformMouseEvent.h"

#include "PlatformWheelEvent.h"

#include "PluginDocument.h"

#include "PointerCaptureController.h"

#include "PointerEventTypeNames.h"

#include "PseudoClassChangeInvalidation.h"

#include "Range.h"

#include "RemoteFrame.h"

#include "RemoteFrameView.h"

#include "RemoteUserInputEventData.h"

#include "RenderFrameSet.h"

#include "RenderImage.h"

#include "RenderLayer.h"

#include "RenderLayerScrollableArea.h"

#include "RenderListBox.h"

#include "RenderTextControlSingleLine.h"

#include "RenderView.h"

#include "RenderWidget.h"

#include "ResourceLoadObserver.h"

#include "RuntimeApplicationChecks.h"

#include "SVGDocument.h"

#include "SVGElementTypeHelpers.h"

#include "SVGNames.h"

#include "ScrollAnimator.h"

#include "ScrollLatchingController.h"

#include "Scrollbar.h"

#include "ScrollingEffectsController.h"

#include "SelectionRestorationMode.h"

#include "Settings.h"

#include "ShadowRoot.h"

#include "SpatialNavigation.h"

#include "StaticPasteboard.h"

#include "StyleCachedImage.h"

#include "TextEvent.h"

#include "TextIterator.h"

#include "TextRecognitionOptions.h"

#include "UserGestureIndicator.h"

#include "UserTypingGestureIndicator.h"

#include "ValidationMessageClient.h"

#include "VisibleUnits.h"

#include "WheelEvent.h"

#include "WheelEventDeltaFilter.h"

#include "WheelEventTestMonitor.h"

#include "WindowsKeyboardCodes.h"

#include <wtf/Assertions.h>

#include <wtf/NeverDestroyed.h>

#include <wtf/SetForScope.h>

#include <wtf/StdLibExtras.h>

#if ENABLE(IOS_TOUCH_EVENTS)

#include "PlatformTouchEventIOS.h"

#endif

#if ENABLE(CONTENT_CHANGE_OBSERVER)

#include "DOMTimerHoldingTank.h"

#endif

#if ENABLE(TOUCH_EVENTS)

#include "TouchEvent.h"

#include "TouchList.h"

#endif

#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)

#include "PlatformTouchEvent.h"

#endif

#if ENABLE(MAC_GESTURE_EVENTS)

#include "PlatformGestureEventMac.h"

#endif

#if ENABLE(POINTER_LOCK)

#include "PointerLockController.h"

#endif

namespace WebCore {

using namespace HTMLNames;

#if ENABLE(DRAG_SUPPORT)

// The link drag hysteresis is much larger than the others because there

// needs to be enough space to cancel the link press without starting a link drag,

// and because dragging links is rare.

const int LinkDragHysteresis = 40;

const int ImageDragHysteresis = 5;

const int TextDragHysteresis = 3;

const int ColorDragHystersis = 3;

const int GeneralDragHysteresis = 3;

#if PLATFORM(MAC)

const Seconds EventHandler::TextDragDelay { 150_ms };

#else

const Seconds EventHandler::TextDragDelay { 0_s };

#endif

#endif // ENABLE(DRAG_SUPPORT)

#if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)

const float GestureUnknown = 0;

#endif

#if ENABLE(IOS_TOUCH_EVENTS)

// FIXME: Share this constant with EventHandler and SliderThumbElement.

const unsigned InvalidTouchIdentifier = 0;

#endif

// Match key code of composition keydown event on windows.

// IE sends VK_PROCESSKEY which has value 229;

const int CompositionEventKeyCode = 229;

using namespace SVGNames;

#if !ENABLE(IOS_TOUCH_EVENTS)

// The amount of time to wait before sending a fake mouse event, triggered

// during a scroll. The short interval is used if the content responds to the mouse events

// in fakeMouseMoveDurationThreshold or less, otherwise the long interval is used.

const double fakeMouseMoveDurationThreshold = 0.01;

const Seconds fakeMouseMoveShortInterval = { 100_ms };

const Seconds fakeMouseMoveLongInterval = { 250_ms };

#endif

const int maximumCursorSize = 128;

#if ENABLE(MOUSE_CURSOR_SCALE)

// It's pretty unlikely that a scale of less than one would ever be used. But all we really

// need to ensure here is that the scale isn't so small that integer overflow can occur when

// dividing cursor sizes (limited above) by the scale.

const double minimumCursorScale = 0.001;

#endif

class MaximumDurationTracker {

public:

explicit MaximumDurationTracker(double *maxDuration)

: m_maxDuration(maxDuration)

, m_start(MonotonicTime::now())

{

}

~MaximumDurationTracker()

{

*m_maxDuration = std::max(*m_maxDuration, (MonotonicTime::now() - m_start).seconds());

}

private:

double* m_maxDuration;

MonotonicTime m_start;

};

static UserGestureType userGestureTypeForPlatformEvent(const PlatformKeyboardEvent& keyEvent)

{

// https://html.spec.whatwg.org/multipage/interaction.html#activation-triggering-input-event

// An activation triggering input event is any event whose isTrusted attribute is true and whose type is one of:

// * "keydown", provided the key is neither the Esc key nor a shortcut key reserved by the user agent.

if (keyEvent.windowsVirtualKeyCode() == VK_ESCAPE)

return UserGestureType::EscapeKey;

if (keyEvent.type() == PlatformEventType::KeyDown)

return UserGestureType::ActivationTriggering;

// FIXME: This check does not yet handle whether the event represents a "shortcut key reserved by the user agent".

return UserGestureType::Other;

}

static UserGestureType userGestureTypeForPlatformEvent(const PlatformMouseEvent& mouseEvent)

{

// ...

// * "mousedown".

// * "pointerdown", provided the event's pointerType is "mouse".

if (mouseEvent.type() == PlatformEventType::MousePressed)

return UserGestureType::ActivationTriggering;

return UserGestureType::Other;

}

#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)

static UserGestureType userGestureTypeForPlatformEvent(const PlatformTouchEvent& touchEvent)

{

// ...

// * "pointerup", provided the event's pointerType is not "mouse".

// * "touchend".

if (touchEvent.type() == PlatformEventType::TouchEnd)

return UserGestureType::ActivationTriggering;

return UserGestureType::Other;

}

#endif

#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)

class SyntheticTouchPoint : public PlatformTouchPoint {

public:

// The default values are based on http://dvcs.w3.org/hg/webevents/raw-file/tip/touchevents.html

explicit SyntheticTouchPoint(const PlatformMouseEvent& event)

{

static constexpr int idDefaultValue = 0;

static constexpr int radiusYDefaultValue = 1;

static constexpr int radiusXDefaultValue = 1;

static constexpr float rotationAngleDefaultValue = 0.0f;

static constexpr float forceDefaultValue = 1.0f;

m_id = idDefaultValue; // There is only one active TouchPoint.

m_screenPos = event.globalPosition();

m_pos = event.position();

m_radiusY = radiusYDefaultValue;

m_radiusX = radiusXDefaultValue;

m_rotationAngle = rotationAngleDefaultValue;

m_force = forceDefaultValue;

PlatformEvent::Type type = event.type();

ASSERT(type == PlatformEvent::Type::MouseMoved || type == PlatformEvent::Type::MousePressed || type == PlatformEvent::Type::MouseReleased);

switch (type) {

case PlatformEvent::Type::MouseMoved:

m_state = TouchMoved;

break;

case PlatformEvent::Type::MousePressed:

m_state = TouchPressed;

break;

case PlatformEvent::Type::MouseReleased:

m_state = TouchReleased;

break;

default:

ASSERT_NOT_REACHED();

break;

}

}

};

class SyntheticSingleTouchEvent : public PlatformTouchEvent {

public:

explicit SyntheticSingleTouchEvent(const PlatformMouseEvent& event)

{

switch (event.type()) {

case PlatformEvent::Type::MouseMoved:

m_type = Type::TouchMove;

break;

case PlatformEvent::Type::MousePressed:

m_type = Type::TouchStart;

break;

case PlatformEvent::Type::MouseReleased:

m_type = Type::TouchEnd;

break;

default:

ASSERT_NOT_REACHED();

m_type = Type::NoType;

break;

}

m_timestamp = event.timestamp();

m_modifiers = event.modifiers();

m_touchPoints.append(SyntheticTouchPoint(event));

}

};

#endif // ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)

static inline ScrollGranularity wheelGranularityToScrollGranularity(unsigned deltaMode)

{

switch (deltaMode) {

case WheelEvent::DOM_DELTA_PAGE:

return ScrollGranularity::Page;

case WheelEvent::DOM_DELTA_LINE:

return ScrollGranularity::Line;

case WheelEvent::DOM_DELTA_PIXEL:

return ScrollGranularity::Pixel;

default:

return ScrollGranularity::Pixel;

}

}

#if (ENABLE(TOUCH_EVENTS) && !PLATFORM(IOS_FAMILY))

static bool shouldGesturesTriggerActive()

{

// If the platform we're on supports GestureTapDown and GestureTapCancel then we'll

// rely on them to set the active state. Unfortunately there's no generic way to

// know in advance what event types are supported.

return false;

}

#endif

#if !PLATFORM(COCOA)

bool EventHandler::eventLoopHandleMouseUp(const MouseEventWithHitTestResults&)

{

return false;

}

#if ENABLE(DRAG_SUPPORT)

bool EventHandler::eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&)

{

return false;

}

#endif

#endif

EventHandler::EventHandler(LocalFrame& frame)

: m_frame(frame)

, m_hoverTimer(*this, &EventHandler::hoverTimerFired)

#if ENABLE(IMAGE_ANALYSIS)

, m_textRecognitionHoverTimer(*this, &EventHandler::textRecognitionHoverTimerFired, 250_ms)

#endif

, m_autoscrollController(makeUnique<AutoscrollController>())

#if !ENABLE(IOS_TOUCH_EVENTS)

, m_fakeMouseMoveEventTimer(*this, &EventHandler::fakeMouseMoveEventTimerFired)

#endif

#if ENABLE(CURSOR_VISIBILITY)

, m_autoHideCursorTimer(*this, &EventHandler::autoHideCursorTimerFired)

#endif

{

}

EventHandler::~EventHandler()

{

#if !ENABLE(IOS_TOUCH_EVENTS)

ASSERT(!m_fakeMouseMoveEventTimer.isActive());

#endif

#if ENABLE(CURSOR_VISIBILITY)

ASSERT(!m_autoHideCursorTimer.isActive());

#endif

}

#if ENABLE(DRAG_SUPPORT)

DragState& EventHandler::dragState()

{

static NeverDestroyed<DragState> state;

return state;

}

#endif

void EventHandler::clear()

{

m_hoverTimer.stop();

m_hasScheduledCursorUpdate = false;

#if !ENABLE(IOS_TOUCH_EVENTS)

m_fakeMouseMoveEventTimer.stop();

#endif

#if ENABLE(CURSOR_VISIBILITY)

cancelAutoHideCursorTimer();

#endif

#if ENABLE(IMAGE_ANALYSIS)

m_textRecognitionHoverTimer.stop();

#endif

m_resizeLayer = nullptr;

clearElementUnderMouse();

m_lastElementUnderMouse = nullptr;

m_lastMouseMoveEventSubframe = nullptr;

m_lastScrollbarUnderMouse = nullptr;

m_clickCount = 0;

m_clickNode = nullptr;

#if ENABLE(IOS_GESTURE_EVENTS)

m_gestureInitialDiameter = GestureUnknown;

m_gestureInitialRotation = GestureUnknown;

#endif

#if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)

m_gestureLastDiameter = GestureUnknown;

m_gestureLastRotation = GestureUnknown;

m_gestureTargets.clear();

#endif

#if ENABLE(IOS_TOUCH_EVENTS)

m_touches.clear();

m_touchLastGlobalPositionAndDeltaMap.clear();

m_firstTouchID = InvalidTouchIdentifier;

m_touchEventTargetSubframe = nullptr;

#endif

m_frameSetBeingResized = nullptr;

#if ENABLE(DRAG_SUPPORT)

m_dragTarget = nullptr;

m_shouldOnlyFireDragOverEvent = false;

#endif

m_lastKnownMousePosition = std::nullopt;

m_lastKnownMouseGlobalPosition = { };

m_mousePressNode = nullptr;

m_mousePressed = false;

m_capturesDragging = false;

resetCapturingMouseEventsElement();

clearLatchedState();

#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)

m_originatingTouchPointTargets.clear();

m_originatingTouchPointDocument = nullptr;

m_originatingTouchPointTargetKey = 0;

m_touchPressed = false;

#endif

m_maxMouseMovedDuration = 0;

m_didStartDrag = false;

}

void EventHandler::nodeWillBeRemoved(Node& nodeToBeRemoved)

{

if (nodeToBeRemoved.containsIncludingShadowDOM(m_clickNode.get()))

m_clickNode = nullptr;

}

static void setSelectionIfNeeded(FrameSelection& selection, const VisibleSelection& newSelection)

{

if (selection.selection() != newSelection && selection.shouldChangeSelection(newSelection))

selection.setSelection(newSelection, FrameSelection::defaultSetSelectionOptions(UserTriggered::Yes));

}

static inline bool dispatchSelectStart(Node* node)

{

if (!node || !node->renderer())

return true;

auto event = Event::create(eventNames().selectstartEvent, Event::CanBubble::Yes, Event::IsCancelable::Yes);

node->dispatchEvent(event);

return !event->defaultPrevented();

}

static Node* nodeToSelectOnMouseDownForNode(Node& targetNode)

{

if (ImageOverlay::isInsideOverlay(targetNode))

return nullptr;

if (RefPtr rootUserSelectAll = Position::rootUserSelectAllForNode(&targetNode))

return rootUserSelectAll.get();

if (targetNode.shouldSelectOnMouseDown())

return &targetNode;

return nullptr;

}

static VisibleSelection expandSelectionToRespectSelectOnMouseDown(Node& targetNode, const VisibleSelection& selection)

{

RefPtr nodeToSelect = nodeToSelectOnMouseDownForNode(targetNode);

if (!nodeToSelect)

return selection;

VisibleSelection newSelection(selection);

newSelection.setBase(positionBeforeNode(nodeToSelect.get()).upstream(CanCrossEditingBoundary));

newSelection.setExtent(positionAfterNode(nodeToSelect.get()).downstream(CanCrossEditingBoundary));

return newSelection;

}

bool EventHandler::updateSelectionForMouseDownDispatchingSelectStart(Node* targetNode, const VisibleSelection& selection, TextGranularity granularity)

{

if (Position::nodeIsUserSelectNone(targetNode))

return false;

if (!dispatchSelectStart(targetNode)) {

m_mouseDownMayStartSelect = false;

return false;

}

if (selection.isOrphan()) {

m_mouseDownMayStartSelect = false;

return false;

}

if (selection.isRange()) {

m_selectionInitiationState = ExtendedSelection;

#if ENABLE(DRAG_SUPPORT)

m_dragStartSelection = selection.range();

#endif

} else {

granularity = TextGranularity::CharacterGranularity;

m_selectionInitiationState = PlacedCaret;

}

protectedFrame()->selection().setSelectionByMouseIfDifferent(selection, granularity);

return true;

}

void EventHandler::selectClosestWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)

{

RefPtr targetNode = result.targetNode();

VisibleSelection newSelection;

if (targetNode && targetNode->renderer()) {

VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint(), nullptr));

if (pos.isNotNull()) {

newSelection = VisibleSelection(pos);

newSelection.expandUsingGranularity(TextGranularity::WordGranularity);

}

if (appendTrailingWhitespace == ShouldAppendTrailingWhitespace && newSelection.isRange())

newSelection.appendTrailingWhitespace();

updateSelectionForMouseDownDispatchingSelectStart(targetNode.get(), expandSelectionToRespectSelectOnMouseDown(*targetNode, newSelection), TextGranularity::WordGranularity);

}

}

static AppendTrailingWhitespace shouldAppendTrailingWhitespace(const MouseEventWithHitTestResults& result, const LocalFrame& frame)

{

return (result.event().clickCount() == 2 && frame.editor().isSelectTrailingWhitespaceEnabled()) ? ShouldAppendTrailingWhitespace : DontAppendTrailingWhitespace;

}

#if !PLATFORM(COCOA)

VisibleSelection EventHandler::selectClosestWordFromHitTestResultBasedOnLookup(const HitTestResult&)

{

return VisibleSelection();

}

#endif

void EventHandler::selectClosestContextualWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)

{

RefPtr targetNode = result.targetNode();

VisibleSelection newSelection;

if (targetNode && targetNode->renderer()) {

newSelection = selectClosestWordFromHitTestResultBasedOnLookup(result);

if (newSelection.isNone()) {

VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint(), nullptr));

if (pos.isNotNull()) {

newSelection = VisibleSelection(pos);

newSelection.expandUsingGranularity(TextGranularity::WordGranularity);

}

}

if (appendTrailingWhitespace == ShouldAppendTrailingWhitespace && newSelection.isRange())

newSelection.appendTrailingWhitespace();

updateSelectionForMouseDownDispatchingSelectStart(targetNode.get(), expandSelectionToRespectSelectOnMouseDown(*targetNode, newSelection), TextGranularity::WordGranularity);

}

}

void EventHandler::selectClosestContextualWordOrLinkFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)

{

// FIXME: In the editable case, word selection sometimes selects content that isn't underneath the mouse.

// If the selection is non-editable, we do word selection to make it easier to use the contextual menu items

// available for text selections. But only if we're above text.

if (!m_frame->selection().selection().isContentEditable() && !is<Text>(result.targetNode()))

return;

if (!m_frame->settings().textInteractionEnabled())

return;

RefPtr urlElement = result.URLElement();

if (!urlElement || !isDraggableLink(*urlElement)) {

if (RefPtr targetNode = result.targetNode(); targetNode && isEditableNode(*targetNode)) {

selectClosestWordFromHitTestResult(result, appendTrailingWhitespace);

return;

}

return selectClosestContextualWordFromHitTestResult(result, appendTrailingWhitespace);

}

if (RefPtr targetNode = result.targetNode(); targetNode && targetNode->renderer()) {

VisibleSelection newSelection;

VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint(), nullptr));

if (pos.isNotNull() && pos.deepEquivalent().deprecatedNode()->isDescendantOf(*urlElement))

newSelection = VisibleSelection::selectionFromContentsOfNode(urlElement.get());

updateSelectionForMouseDownDispatchingSelectStart(targetNode.get(), expandSelectionToRespectSelectOnMouseDown(*targetNode, newSelection), TextGranularity::WordGranularity);

}

}

bool EventHandler::handleMousePressEventDoubleClick(const MouseEventWithHitTestResults& event)

{

if (event.event().button() != MouseButton::Left)

return false;

if (m_frame->selection().isRange()) {

// A double-click when range is already selected

// should not change the selection. So, do not call

// selectClosestWordFromHitTestResult, but do set

// m_beganSelectingText to prevent handleMouseReleaseEvent

// from setting caret selection.

m_selectionInitiationState = ExtendedSelection;

#if ENABLE(DRAG_SUPPORT)

m_dragStartSelection = m_frame->selection().selection().range();

#endif

} else if (mouseDownMayStartSelect())

selectClosestWordFromHitTestResult(event.hitTestResult(), shouldAppendTrailingWhitespace(event, protectedFrame()));

return true;

}

bool EventHandler::handleMousePressEventTripleClick(const MouseEventWithHitTestResults& event)

{

if (event.event().button() != MouseButton::Left)

return false;

RefPtr targetNode = event.targetNode();

if (!(targetNode && targetNode->renderer() && mouseDownMayStartSelect()))

return false;

VisibleSelection newSelection;

VisiblePosition pos(targetNode->renderer()->positionForPoint(event.localPoint(), nullptr));

if (pos.isNotNull()) {

newSelection = VisibleSelection(pos);

newSelection.expandUsingGranularity(TextGranularity::ParagraphGranularity);

}

return updateSelectionForMouseDownDispatchingSelectStart(targetNode.get(), expandSelectionToRespectSelectOnMouseDown(*targetNode, newSelection), TextGranularity::ParagraphGranularity);

}

static uint64_t textDistance(const Position& start, const Position& end)

{

auto range = makeSimpleRange(start, end);

if (!range)

return 0;

return characterCount(*range, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions);

}

bool EventHandler::handleMousePressEventSingleClick(const MouseEventWithHitTestResults& event)

{

Ref frame = m_frame.get();

frame->protectedDocument()->updateLayoutIgnorePendingStylesheets();

RefPtr targetNode = event.targetNode();

if (!targetNode || !targetNode->renderer() || !mouseDownMayStartSelect() || m_mouseDownDelegatedFocus)

return false;

// Extend the selection if the Shift key is down, unless the click is in a link.

bool extendSelection = event.event().shiftKey() && !event.isOverLink();

// Don't restart the selection when the mouse is pressed on an

// existing selection so we can allow for text dragging.

if (RefPtr view = frame->view()) {

LayoutPoint vPoint = view->windowToContents(event.event().position());

if (!extendSelection && frame->selection().contains(vPoint)) {

m_mouseDownWasSingleClickInSelection = true;

return false;

}

}

VisiblePosition visiblePosition(targetNode->renderer()->positionForPoint(event.localPoint(), nullptr));

if (visiblePosition.isNull())

visiblePosition = VisiblePosition(firstPositionInOrBeforeNode(targetNode.get()));

Position pos = visiblePosition.deepEquivalent();

VisibleSelection newSelection = frame->selection().selection();

TextGranularity granularity = TextGranularity::CharacterGranularity;

if (!frame->editor().client()->shouldAllowSingleClickToChangeSelection(*targetNode, newSelection))

return true;

if (extendSelection && newSelection.isCaretOrRange()) {

VisibleSelection selectionInUserSelectAll = expandSelectionToRespectSelectOnMouseDown(*targetNode, VisibleSelection(pos));

if (selectionInUserSelectAll.isRange()) {

if (selectionInUserSelectAll.start() < newSelection.start())

pos = selectionInUserSelectAll.start();

else if (newSelection.end() < selectionInUserSelectAll.end())

pos = selectionInUserSelectAll.end();

}

if (!frame->editor().behavior().shouldConsiderSelectionAsDirectional() && pos.isNotNull()) {

// See <rdar://problem/3668157> REGRESSION (Mail): shift-click deselects when selection

// was created right-to-left

Position start = newSelection.start();

Position end = newSelection.end();

int distanceToStart = textDistance(start, pos);

int distanceToEnd = textDistance(pos, end);

if (distanceToStart <= distanceToEnd)

newSelection = VisibleSelection(end, pos);

else

newSelection = VisibleSelection(start, pos);

} else {

if (newSelection.isDirectional()) {

RefPtr baseNode = newSelection.isBaseFirst() ? newSelection.base().computeNodeAfterPosition() : newSelection.base().computeNodeBeforePosition();

if (!baseNode)

baseNode = newSelection.base().containerNode();

if (baseNode) {

auto expandedBaseSelection = expandSelectionToRespectSelectOnMouseDown(*baseNode, VisibleSelection { newSelection.visibleBase() });

expandedBaseSelection.expandUsingGranularity(frame->selection().granularity());

if (expandedBaseSelection.isRange()) {

if (newSelection.isBaseFirst() && pos < newSelection.start())

newSelection.setBase(expandedBaseSelection.end());

else if (!newSelection.isBaseFirst() && newSelection.end() < pos)

newSelection.setBase(expandedBaseSelection.start());

}

}

}

newSelection.setExtent(pos);

}

if (frame->selection().granularity() != TextGranularity::CharacterGranularity) {

granularity = frame->selection().granularity();

newSelection.expandUsingGranularity(frame->selection().granularity());

}

} else {

if (event.event().syntheticClickType() != SyntheticClickType::NoTap) {

auto adjustedVisiblePosition = wordBoundaryForPositionWithoutCrossingLine(visiblePosition).first;

if (adjustedVisiblePosition.isNotNull())

visiblePosition = WTFMove(adjustedVisiblePosition);

}

newSelection = expandSelectionToRespectSelectOnMouseDown(*targetNode, visiblePosition);

}

bool handled = updateSelectionForMouseDownDispatchingSelectStart(targetNode.get(), newSelection, granularity);

if (event.event().button() == MouseButton::Middle) {

// Ignore handled, since we want to paste to where the caret was placed anyway.

handled = handlePasteGlobalSelection(event.event()) || handled;

}

return handled;

}

bool EventHandler::canMouseDownStartSelect(const MouseEventWithHitTestResults& event)

{

RefPtr node = event.targetNode();

if (CheckedPtr page = m_frame->page()) {

if (!page->chrome().client().shouldUseMouseEventForSelection(event.event()))

return false;

}

if (!node || !node->renderer())

return true;

if (ImageOverlay::isOverlayText(*node))

return node->renderer()->style().effectiveUserSelect() != UserSelect::None;

return node->canStartSelection() || Position::nodeIsUserSelectAll(node.get());

}

bool EventHandler::mouseDownMayStartSelect() const

{

if (!m_frame->settings().textInteractionEnabled())

return false;

return m_mouseDownMayStartSelect;

}

bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)

{

Ref frame = m_frame.get();

#if ENABLE(DRAG_SUPPORT)

// Reset drag state.

dragState().source = nullptr;

#endif

#if !ENABLE(IOS_TOUCH_EVENTS)

cancelFakeMouseMoveEvent();

#endif

frame->protectedDocument()->updateLayoutIgnorePendingStylesheets();

if (RefPtr scrollView = frame->view()) {

if (scrollView->isPointInScrollbarCorner(event.event().position()))

return false;

}

bool singleClick = event.event().clickCount() <= 1;

// If we got the event back, that must mean it wasn't prevented,

// so it's allowed to start a drag or selection if it wasn't in a scrollbar.

m_mouseDownMayStartSelect = canMouseDownStartSelect(event) && !event.scrollbar();

#if ENABLE(DRAG_SUPPORT)

// Careful that the drag starting logic stays in sync with eventMayStartDrag()

// FIXME: eventMayStartDrag() does not check for shift key press, link or image event targets.

// Bug: https://bugs.webkit.org/show_bug.cgi?id=155390

// Single mouse down on links or images can always trigger drag-n-drop.

bool isImageOverlayText = ImageOverlay::isOverlayText(event.targetNode());

bool isMouseDownOnLinkOrImage = event.isOverLink() || (event.hitTestResult().image() && !isImageOverlayText);

m_mouseDownMayStartDrag = singleClick && (!event.event().shiftKey() || isMouseDownOnLinkOrImage) && shouldAllowMouseDownToStartDrag();

#endif

m_mouseDownWasSingleClickInSelection = false;

m_mouseDownEvent = event.event();

if (m_immediateActionStage != ImmediateActionStage::PerformedHitTest)

m_immediateActionStage = ImmediateActionStage::None;

if (event.isOverWidget() && passWidgetMouseDownEventToWidget(event))

return true;

if (is<SVGDocument>(*frame->document()) && downcast<SVGDocument>(*frame->document()).zoomAndPanEnabled()) {

if (event.event().shiftKey() && singleClick) {

m_svgPan = true;

downcast<SVGDocument>(*frame->protectedDocument()).startPan(frame->protectedView()->windowToContents(event.event().position()));

return true;

}

}

// We don't do this at the start of mouse down handling,

// because we don't want to do it until we know we didn't hit a widget.

if (singleClick)

focusDocumentView();

m_mousePressNode = event.targetNode();

frame->protectedDocument()->setFocusNavigationStartingNode(event.targetNode());

#if ENABLE(DRAG_SUPPORT)

m_dragStartPosition = event.event().position();

#endif

m_mousePressed = true;

m_selectionInitiationState = HaveNotStartedSelection;

bool swallowEvent = false;

if (event.event().clickCount() == 2)

swallowEvent = handleMousePressEventDoubleClick(event);

else if (event.event().clickCount() >= 3)

swallowEvent = handleMousePressEventTripleClick(event);

else

swallowEvent = handleMousePressEventSingleClick(event);

m_mouseDownMayStartAutoscroll = mouseDownMayStartSelect()

|| (m_mousePressNode && m_mousePressNode->renderBox() && m_mousePressNode->renderBox()->canBeProgramaticallyScrolled());

return swallowEvent;

}

VisiblePosition EventHandler::selectionExtentRespectingEditingBoundary(const VisibleSelection& selection, const LayoutPoint& localPoint, Node* targetNode)

{

FloatPoint selectionEndPoint = localPoint;

RefPtr editableElement = selection.rootEditableElement();

if (!targetNode || !targetNode->renderer())

return VisiblePosition();

RefPtr adjustedTarget = targetNode;

if (editableElement && !editableElement->contains(targetNode)) {

if (!editableElement->renderer())

return VisiblePosition();

FloatPoint absolutePoint = targetNode->renderer()->localToAbsolute(FloatPoint(selectionEndPoint));

selectionEndPoint = editableElement->renderer()->absoluteToLocal(absolutePoint);

adjustedTarget = editableElement;

}

return adjustedTarget->renderer()->positionForPoint(LayoutPoint(selectionEndPoint), nullptr);

}

#if ENABLE(DRAG_SUPPORT)

#if !PLATFORM(IOS_FAMILY)

bool EventHandler::supportsSelectionUpdatesOnMouseDrag() const

{

return true;

}

bool EventHandler::shouldAllowMouseDownToStartDrag() const

{

return true;

}

#endif

bool EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event, CheckDragHysteresis checkDragHysteresis)

{

if (!m_mousePressed)

return false;

Ref frame = m_frame.get();

if (handleDrag(event, checkDragHysteresis))

return true;

RefPtr targetNode = event.targetNode();

if (event.event().button() != MouseButton::Left || !targetNode)

return false;

RenderObject* renderer = targetNode->renderer();

if (!renderer) {

RefPtr parent = targetNode->parentOrShadowHostElement();

if (!parent)

return false;

renderer = parent->renderer();

if (!renderer || !renderer->isRenderListBox())

return false;

}

#if PLATFORM(COCOA) // FIXME: Why does this assertion fire on other platforms?

ASSERT(mouseDownMayStartSelect() || m_mouseDownMayStartAutoscroll);

#endif

m_mouseDownMayStartDrag = false;

if (m_mouseDownMayStartAutoscroll && !panScrollInProgress()) {

m_autoscrollController->startAutoscrollForSelection(renderer);

m_mouseDownMayStartAutoscroll = false;

}

if (m_selectionInitiationState != ExtendedSelection) {

HitTestResult result(m_mouseDownContentsPosition);

frame->protectedDocument()->hitTest(HitTestRequest(), result);

updateSelectionForMouseDrag(result);

}

updateSelectionForMouseDrag(event.hitTestResult());

return true;

}

bool EventHandler::eventMayStartDrag(const PlatformMouseEvent& event) const

{

// This is a pre-flight check of whether the event might lead to a drag being started. Be careful

// that its logic needs to stay in sync with handleMouseMoveEvent() and the way we setMouseDownMayStartDrag

// in handleMousePressEvent

Ref frame = m_frame.get();

RefPtr document = frame->document();

if (!document)

return false;

if (event.button() != MouseButton::Left || event.clickCount() != 1)

return false;

RefPtr view = frame->view();

if (!view)

return false;

CheckedPtr page = frame->page();

if (!page)

return false;

updateDragSourceActionsAllowed();

constexpr OptionSet<HitTestRequest::Type> hitType { HitTestRequest::Type::ReadOnly, HitTestRequest::Type::DisallowUserAgentShadowContent };

HitTestResult result(view->windowToContents(event.position()));

document->hitTest(hitType, result);

DragState state;

RefPtr targetElement = result.targetElement();

return targetElement && page->dragController().draggableElement(frame.ptr(), targetElement.get(), result.roundedPointInInnerNodeFrame(), state);

}

void EventHandler::updateSelectionForMouseDrag()

{

if (!supportsSelectionUpdatesOnMouseDrag())

return;