Move cross-port Source/WebCore/page/ code to std::unique_ptr
[WebKit-https.git] / Source / WebCore / page / EventHandler.cpp
1 /*
2  * Copyright (C) 2006-2014 Apple Inc. All rights reserved.
3  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
4  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
26  */
27
28 #include "config.h"
29 #include "EventHandler.h"
30
31 #include "AXObjectCache.h"
32 #include "AutoscrollController.h"
33 #include "BackForwardController.h"
34 #include "CachedImage.h"
35 #include "Chrome.h"
36 #include "ChromeClient.h"
37 #include "Cursor.h"
38 #include "CursorList.h"
39 #include "Document.h"
40 #include "DocumentEventQueue.h"
41 #include "DragController.h"
42 #include "DragState.h"
43 #include "Editor.h"
44 #include "EditorClient.h"
45 #include "EventNames.h"
46 #include "ExceptionCodePlaceholder.h"
47 #include "FileList.h"
48 #include "FloatPoint.h"
49 #include "FloatRect.h"
50 #include "FocusController.h"
51 #include "FrameLoader.h"
52 #include "FrameSelection.h"
53 #include "FrameTree.h"
54 #include "FrameView.h"
55 #include "htmlediting.h"
56 #include "HTMLFrameElementBase.h"
57 #include "HTMLFrameSetElement.h"
58 #include "HTMLInputElement.h"
59 #include "HTMLNames.h"
60 #include "HitTestRequest.h"
61 #include "HitTestResult.h"
62 #include "Image.h"
63 #include "InspectorInstrumentation.h"
64 #include "KeyboardEvent.h"
65 #include "MainFrame.h"
66 #include "MouseEvent.h"
67 #include "MouseEventWithHitTestResults.h"
68 #include "Page.h"
69 #include "PlatformEvent.h"
70 #include "PlatformKeyboardEvent.h"
71 #include "PlatformWheelEvent.h"
72 #include "PluginDocument.h"
73 #include "RenderFrameSet.h"
74 #include "RenderLayer.h"
75 #include "RenderListBox.h"
76 #include "RenderTextControlSingleLine.h"
77 #include "RenderView.h"
78 #include "RenderWidget.h"
79 #include "RuntimeApplicationChecks.h"
80 #include "SVGDocument.h"
81 #include "SVGElementInstance.h"
82 #include "SVGNames.h"
83 #include "SVGUseElement.h"
84 #include "ScrollAnimator.h"
85 #include "Scrollbar.h"
86 #include "Settings.h"
87 #include "ShadowRoot.h"
88 #include "SpatialNavigation.h"
89 #include "StyleCachedImage.h"
90 #include "TextEvent.h"
91 #include "TextIterator.h"
92 #include "UserGestureIndicator.h"
93 #include "UserTypingGestureIndicator.h"
94 #include "VisibleUnits.h"
95 #include "WheelEvent.h"
96 #include "WindowsKeyboardCodes.h"
97 #include <wtf/Assertions.h>
98 #include <wtf/CurrentTime.h>
99 #include <wtf/StdLibExtras.h>
100 #include <wtf/TemporaryChange.h>
101
102 #if ENABLE(CSS_IMAGE_SET)
103 #include "StyleCachedImageSet.h"
104 #endif
105
106 #if ENABLE(IOS_TOUCH_EVENTS)
107 #include "PlatformTouchEventIOS.h"
108 #endif
109
110 #if ENABLE(TOUCH_EVENTS)
111 #include "TouchEvent.h"
112 #include "TouchList.h"
113 #endif
114
115 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
116 #include "PlatformTouchEvent.h"
117 #endif
118
119 namespace WebCore {
120
121 using namespace HTMLNames;
122
123 #if ENABLE(DRAG_SUPPORT)
124 // The link drag hysteresis is much larger than the others because there
125 // needs to be enough space to cancel the link press without starting a link drag,
126 // and because dragging links is rare.
127 const int LinkDragHysteresis = 40;
128 const int ImageDragHysteresis = 5;
129 const int TextDragHysteresis = 3;
130 const int GeneralDragHysteresis = 3;
131 #endif // ENABLE(DRAG_SUPPORT)
132
133 #if ENABLE(IOS_GESTURE_EVENTS)
134 const float GestureUnknown = 0;
135 #endif
136
137 #if ENABLE(IOS_TOUCH_EVENTS)
138 // FIXME: Share this constant with EventHandler and SliderThumbElement.
139 const unsigned InvalidTouchIdentifier = 0;
140 #endif
141
142 // Match key code of composition keydown event on windows.
143 // IE sends VK_PROCESSKEY which has value 229;
144 const int CompositionEventKeyCode = 229;
145
146 using namespace SVGNames;
147
148 #if !ENABLE(IOS_TOUCH_EVENTS)
149 // The amount of time to wait before sending a fake mouse event, triggered
150 // during a scroll. The short interval is used if the content responds to the mouse events
151 // in fakeMouseMoveDurationThreshold or less, otherwise the long interval is used.
152 const double fakeMouseMoveDurationThreshold = 0.01;
153 const double fakeMouseMoveShortInterval = 0.1;
154 const double fakeMouseMoveLongInterval = 0.25;
155 #endif
156
157 #if ENABLE(CURSOR_SUPPORT)
158 // The amount of time to wait for a cursor update on style and layout changes
159 // Set to 50Hz, no need to be faster than common screen refresh rate
160 const double cursorUpdateInterval = 0.02;
161
162 const int maximumCursorSize = 128;
163 #endif
164
165 #if ENABLE(MOUSE_CURSOR_SCALE)
166 // It's pretty unlikely that a scale of less than one would ever be used. But all we really
167 // need to ensure here is that the scale isn't so small that integer overflow can occur when
168 // dividing cursor sizes (limited above) by the scale.
169 const double minimumCursorScale = 0.001;
170 #endif
171
172 enum NoCursorChangeType { NoCursorChange };
173
174 class OptionalCursor {
175 public:
176     OptionalCursor(NoCursorChangeType) : m_isCursorChange(false) { }
177     OptionalCursor(const Cursor& cursor) : m_isCursorChange(true), m_cursor(cursor) { }
178
179     bool isCursorChange() const { return m_isCursorChange; }
180     const Cursor& cursor() const { ASSERT(m_isCursorChange); return m_cursor; }
181
182 private:
183     bool m_isCursorChange;
184     Cursor m_cursor;
185 };
186
187 class MaximumDurationTracker {
188 public:
189     explicit MaximumDurationTracker(double *maxDuration)
190         : m_maxDuration(maxDuration)
191         , m_start(monotonicallyIncreasingTime())
192     {
193     }
194
195     ~MaximumDurationTracker()
196     {
197         *m_maxDuration = std::max(*m_maxDuration, monotonicallyIncreasingTime() - m_start);
198     }
199
200 private:
201     double* m_maxDuration;
202     double m_start;
203 };
204
205 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
206 class SyntheticTouchPoint : public PlatformTouchPoint {
207 public:
208
209     // The default values are based on http://dvcs.w3.org/hg/webevents/raw-file/tip/touchevents.html
210     explicit SyntheticTouchPoint(const PlatformMouseEvent& event)
211     {
212         const static int idDefaultValue = 0;
213         const static int radiusYDefaultValue = 1;
214         const static int radiusXDefaultValue = 1;
215         const static float rotationAngleDefaultValue = 0.0f;
216         const static float forceDefaultValue = 1.0f;
217
218         m_id = idDefaultValue; // There is only one active TouchPoint.
219         m_screenPos = event.globalPosition();
220         m_pos = event.position();
221         m_radiusY = radiusYDefaultValue;
222         m_radiusX = radiusXDefaultValue;
223         m_rotationAngle = rotationAngleDefaultValue;
224         m_force = forceDefaultValue;
225
226         PlatformEvent::Type type = event.type();
227         ASSERT(type == PlatformEvent::MouseMoved || type == PlatformEvent::MousePressed || type == PlatformEvent::MouseReleased);
228
229         switch (type) {
230         case PlatformEvent::MouseMoved:
231             m_state = TouchMoved;
232             break;
233         case PlatformEvent::MousePressed:
234             m_state = TouchPressed;
235             break;
236         case PlatformEvent::MouseReleased:
237             m_state = TouchReleased;
238             break;
239         default:
240             ASSERT_NOT_REACHED();
241             break;
242         }
243     }
244 };
245
246 class SyntheticSingleTouchEvent : public PlatformTouchEvent {
247 public:
248     explicit SyntheticSingleTouchEvent(const PlatformMouseEvent& event)
249     {
250         switch (event.type()) {
251         case PlatformEvent::MouseMoved:
252             m_type = TouchMove;
253             break;
254         case PlatformEvent::MousePressed:
255             m_type = TouchStart;
256             break;
257         case PlatformEvent::MouseReleased:
258             m_type = TouchEnd;
259             break;
260         default:
261             ASSERT_NOT_REACHED();
262             m_type = NoType;
263             break;
264         }
265         m_timestamp = event.timestamp();
266         m_modifiers = event.modifiers();
267         m_touchPoints.append(SyntheticTouchPoint(event));
268     }
269 };
270 #endif // ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
271
272 static inline ScrollGranularity wheelGranularityToScrollGranularity(unsigned deltaMode)
273 {
274     switch (deltaMode) {
275     case WheelEvent::DOM_DELTA_PAGE:
276         return ScrollByPage;
277     case WheelEvent::DOM_DELTA_LINE:
278         return ScrollByLine;
279     case WheelEvent::DOM_DELTA_PIXEL:
280         return ScrollByPixel;
281     default:
282         return ScrollByPixel;
283     }
284 }
285
286 static inline bool scrollNode(float delta, ScrollGranularity granularity, ScrollDirection positiveDirection, ScrollDirection negativeDirection, Node* node, Element** stopElement, const IntPoint& wheelEventAbsolutePoint)
287 {
288     if (!delta)
289         return false;
290     if (!node->renderer())
291         return false;
292     RenderBox* enclosingBox = node->renderer()->enclosingBox();
293     float absDelta = delta > 0 ? delta : -delta;
294
295     return enclosingBox->scroll(delta < 0 ? negativeDirection : positiveDirection, granularity, absDelta, stopElement, enclosingBox, wheelEventAbsolutePoint);
296 }
297
298 #if (ENABLE(TOUCH_EVENTS) && !PLATFORM(IOS))
299 static inline bool shouldGesturesTriggerActive()
300 {
301     // If the platform we're on supports GestureTapDown and GestureTapCancel then we'll
302     // rely on them to set the active state. Unfortunately there's no generic way to
303     // know in advance what event types are supported.
304     return false;
305 }
306 #endif
307
308 #if !PLATFORM(COCOA)
309
310 inline bool EventHandler::eventLoopHandleMouseUp(const MouseEventWithHitTestResults&)
311 {
312     return false;
313 }
314
315 #if ENABLE(DRAG_SUPPORT)
316 inline bool EventHandler::eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&)
317 {
318     return false;
319 }
320 #endif
321
322 #endif
323
324 EventHandler::EventHandler(Frame& frame)
325     : m_frame(frame)
326     , m_mousePressed(false)
327     , m_capturesDragging(false)
328     , m_mouseDownMayStartSelect(false)
329 #if ENABLE(DRAG_SUPPORT)
330     , m_mouseDownMayStartDrag(false)
331     , m_dragMayStartSelectionInstead(false)
332 #endif
333     , m_mouseDownWasSingleClickInSelection(false)
334     , m_selectionInitiationState(HaveNotStartedSelection)
335     , m_hoverTimer(this, &EventHandler::hoverTimerFired)
336 #if ENABLE(CURSOR_SUPPORT)
337     , m_cursorUpdateTimer(this, &EventHandler::cursorUpdateTimerFired)
338 #endif
339     , m_autoscrollController(std::make_unique<AutoscrollController>())
340     , m_mouseDownMayStartAutoscroll(false)
341     , m_mouseDownWasInSubframe(false)
342 #if !ENABLE(IOS_TOUCH_EVENTS)
343     , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)
344 #endif
345     , m_svgPan(false)
346     , m_resizeLayer(0)
347     , m_eventHandlerWillResetCapturingMouseEventsElement(nullptr)
348     , m_clickCount(0)
349 #if ENABLE(IOS_GESTURE_EVENTS)
350     , m_gestureInitialDiameter(GestureUnknown)
351     , m_gestureLastDiameter(GestureUnknown)
352     , m_gestureInitialRotation(GestureUnknown)
353     , m_gestureLastRotation(GestureUnknown)
354 #endif
355 #if ENABLE(IOS_TOUCH_EVENTS)
356     , m_firstTouchID(InvalidTouchIdentifier)
357 #endif
358     , m_mousePositionIsUnknown(true)
359     , m_mouseDownTimestamp(0)
360     , m_recentWheelEventDeltaTracker(std::make_unique<WheelEventDeltaTracker>())
361     , m_widgetIsLatched(false)
362 #if PLATFORM(COCOA)
363     , m_mouseDownView(nil)
364     , m_sendingEventToSubview(false)
365     , m_startedGestureAtScrollLimit(false)
366 #if !PLATFORM(IOS)
367     , m_activationEventNumber(-1)
368 #endif // !PLATFORM(IOS)
369 #endif
370 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
371     , m_originatingTouchPointTargetKey(0)
372     , m_touchPressed(false)
373 #endif
374     , m_maxMouseMovedDuration(0)
375     , m_baseEventType(PlatformEvent::NoType)
376     , m_didStartDrag(false)
377     , m_didLongPressInvokeContextMenu(false)
378     , m_isHandlingWheelEvent(false)
379 #if ENABLE(CURSOR_VISIBILITY)
380     , m_autoHideCursorTimer(this, &EventHandler::autoHideCursorTimerFired)
381 #endif
382 {
383 }
384
385 EventHandler::~EventHandler()
386 {
387 #if !ENABLE(IOS_TOUCH_EVENTS)
388     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
389 #endif
390 #if ENABLE(CURSOR_VISIBILITY)
391     ASSERT(!m_autoHideCursorTimer.isActive());
392 #endif
393 }
394     
395 #if ENABLE(DRAG_SUPPORT)
396 DragState& EventHandler::dragState()
397 {
398     DEPRECATED_DEFINE_STATIC_LOCAL(DragState, state, ());
399     return state;
400 }
401 #endif // ENABLE(DRAG_SUPPORT)
402     
403 void EventHandler::clear()
404 {
405     m_hoverTimer.stop();
406 #if ENABLE(CURSOR_SUPPORT)
407     m_cursorUpdateTimer.stop();
408 #endif
409 #if !ENABLE(IOS_TOUCH_EVENTS)
410     m_fakeMouseMoveEventTimer.stop();
411 #endif
412 #if ENABLE(CURSOR_VISIBILITY)
413     cancelAutoHideCursorTimer();
414 #endif
415     m_resizeLayer = 0;
416     m_elementUnderMouse = nullptr;
417     m_lastElementUnderMouse = nullptr;
418     m_instanceUnderMouse = 0;
419     m_lastInstanceUnderMouse = 0;
420     m_lastMouseMoveEventSubframe = 0;
421     m_lastScrollbarUnderMouse = 0;
422     m_clickCount = 0;
423     m_clickNode = 0;
424 #if ENABLE(IOS_GESTURE_EVENTS)
425     m_gestureInitialDiameter = GestureUnknown;
426     m_gestureLastDiameter = GestureUnknown;
427     m_gestureInitialRotation = GestureUnknown;
428     m_gestureLastRotation = GestureUnknown;
429     m_gestureTargets.clear();
430 #endif
431 #if ENABLE(IOS_TOUCH_EVENTS)
432     m_touches.clear();
433     m_firstTouchID = InvalidTouchIdentifier;
434     m_touchEventTargetSubframe = 0;
435 #endif
436     m_frameSetBeingResized = 0;
437 #if ENABLE(DRAG_SUPPORT)
438     m_dragTarget = 0;
439     m_shouldOnlyFireDragOverEvent = false;
440 #endif
441     m_mousePositionIsUnknown = true;
442     m_lastKnownMousePosition = IntPoint();
443     m_lastKnownMouseGlobalPosition = IntPoint();
444     m_mousePressNode = 0;
445     m_mousePressed = false;
446     m_capturesDragging = false;
447     m_capturingMouseEventsElement = nullptr;
448     m_latchedWheelEventElement = nullptr;
449 #if PLATFORM(COCOA)
450     m_latchedScrollableContainer = nullptr;
451 #endif
452     m_previousWheelScrolledElement = nullptr;
453 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
454     m_originatingTouchPointTargets.clear();
455     m_originatingTouchPointDocument.clear();
456     m_originatingTouchPointTargetKey = 0;
457 #endif
458     m_maxMouseMovedDuration = 0;
459     m_baseEventType = PlatformEvent::NoType;
460     m_didStartDrag = false;
461     m_didLongPressInvokeContextMenu = false;
462 }
463
464 void EventHandler::nodeWillBeRemoved(Node* nodeToBeRemoved)
465 {
466     if (nodeToBeRemoved->contains(m_clickNode.get()))
467         m_clickNode = 0;
468 }
469
470 static void setSelectionIfNeeded(FrameSelection& selection, const VisibleSelection& newSelection)
471 {
472     if (selection.selection() != newSelection && selection.shouldChangeSelection(newSelection))
473         selection.setSelection(newSelection);
474 }
475
476 static inline bool dispatchSelectStart(Node* node)
477 {
478     if (!node || !node->renderer())
479         return true;
480
481     return node->dispatchEvent(Event::create(eventNames().selectstartEvent, true, true));
482 }
483
484 static VisibleSelection expandSelectionToRespectUserSelectAll(Node* targetNode, const VisibleSelection& selection)
485 {
486 #if ENABLE(USERSELECT_ALL)
487     Node* rootUserSelectAll = Position::rootUserSelectAllForNode(targetNode);
488     if (!rootUserSelectAll)
489         return selection;
490
491     VisibleSelection newSelection(selection);
492     newSelection.setBase(positionBeforeNode(rootUserSelectAll).upstream(CanCrossEditingBoundary));
493     newSelection.setExtent(positionAfterNode(rootUserSelectAll).downstream(CanCrossEditingBoundary));
494
495     return newSelection;
496 #else
497     UNUSED_PARAM(targetNode);
498     return selection;
499 #endif
500 }
501
502 bool EventHandler::updateSelectionForMouseDownDispatchingSelectStart(Node* targetNode, const VisibleSelection& selection, TextGranularity granularity)
503 {
504     if (Position::nodeIsUserSelectNone(targetNode))
505         return false;
506
507     if (!dispatchSelectStart(targetNode))
508         return false;
509
510     if (selection.isRange())
511         m_selectionInitiationState = ExtendedSelection;
512     else {
513         granularity = CharacterGranularity;
514         m_selectionInitiationState = PlacedCaret;
515     }
516
517     m_frame.selection().setSelectionByMouseIfDifferent(selection, granularity);
518
519     return true;
520 }
521
522 void EventHandler::selectClosestWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
523 {
524     Node* targetNode = result.targetNode();
525     VisibleSelection newSelection;
526
527     if (targetNode && targetNode->renderer()) {
528         VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint()));
529         if (pos.isNotNull()) {
530             newSelection = VisibleSelection(pos);
531             newSelection.expandUsingGranularity(WordGranularity);
532         }
533
534         if (appendTrailingWhitespace == ShouldAppendTrailingWhitespace && newSelection.isRange())
535             newSelection.appendTrailingWhitespace();
536
537         updateSelectionForMouseDownDispatchingSelectStart(targetNode, expandSelectionToRespectUserSelectAll(targetNode, newSelection), WordGranularity);
538     }
539 }
540
541 void EventHandler::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result)
542 {
543     if (m_mouseDownMayStartSelect) {
544         selectClosestWordFromHitTestResult(result.hitTestResult(),
545             (result.event().clickCount() == 2 && m_frame.editor().isSelectTrailingWhitespaceEnabled()) ? ShouldAppendTrailingWhitespace : DontAppendTrailingWhitespace);
546     }
547 }
548
549 void EventHandler::selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults& result)
550 {
551     if (!result.hitTestResult().isLiveLink())
552         return selectClosestWordFromMouseEvent(result);
553
554     Node* targetNode = result.targetNode();
555
556     if (targetNode && targetNode->renderer() && m_mouseDownMayStartSelect) {
557         VisibleSelection newSelection;
558         Element* URLElement = result.hitTestResult().URLElement();
559         VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint()));
560         if (pos.isNotNull() && pos.deepEquivalent().deprecatedNode()->isDescendantOf(URLElement))
561             newSelection = VisibleSelection::selectionFromContentsOfNode(URLElement);
562
563         updateSelectionForMouseDownDispatchingSelectStart(targetNode, expandSelectionToRespectUserSelectAll(targetNode, newSelection), WordGranularity);
564     }
565 }
566
567 bool EventHandler::handleMousePressEventDoubleClick(const MouseEventWithHitTestResults& event)
568 {
569     if (event.event().button() != LeftButton)
570         return false;
571
572     if (m_frame.selection().isRange())
573         // A double-click when range is already selected
574         // should not change the selection.  So, do not call
575         // selectClosestWordFromMouseEvent, but do set
576         // m_beganSelectingText to prevent handleMouseReleaseEvent
577         // from setting caret selection.
578         m_selectionInitiationState = ExtendedSelection;
579     else
580         selectClosestWordFromMouseEvent(event);
581
582     return true;
583 }
584
585 bool EventHandler::handleMousePressEventTripleClick(const MouseEventWithHitTestResults& event)
586 {
587     if (event.event().button() != LeftButton)
588         return false;
589     
590     Node* targetNode = event.targetNode();
591     if (!(targetNode && targetNode->renderer() && m_mouseDownMayStartSelect))
592         return false;
593
594     VisibleSelection newSelection;
595     VisiblePosition pos(targetNode->renderer()->positionForPoint(event.localPoint()));
596     if (pos.isNotNull()) {
597         newSelection = VisibleSelection(pos);
598         newSelection.expandUsingGranularity(ParagraphGranularity);
599     }
600
601     return updateSelectionForMouseDownDispatchingSelectStart(targetNode, expandSelectionToRespectUserSelectAll(targetNode, newSelection), ParagraphGranularity);
602 }
603
604 static int textDistance(const Position& start, const Position& end)
605 {
606     RefPtr<Range> range = Range::create(start.anchorNode()->document(), start, end);
607     return TextIterator::rangeLength(range.get(), true);
608 }
609
610 bool EventHandler::handleMousePressEventSingleClick(const MouseEventWithHitTestResults& event)
611 {
612     m_frame.document()->updateLayoutIgnorePendingStylesheets();
613     Node* targetNode = event.targetNode();
614     if (!(targetNode && targetNode->renderer() && m_mouseDownMayStartSelect))
615         return false;
616
617     // Extend the selection if the Shift key is down, unless the click is in a link.
618     bool extendSelection = event.event().shiftKey() && !event.isOverLink();
619
620     // Don't restart the selection when the mouse is pressed on an
621     // existing selection so we can allow for text dragging.
622     if (FrameView* view = m_frame.view()) {
623         LayoutPoint vPoint = view->windowToContents(event.event().position());
624         if (!extendSelection && m_frame.selection().contains(vPoint)) {
625             m_mouseDownWasSingleClickInSelection = true;
626             return false;
627         }
628     }
629
630     VisiblePosition visiblePos(targetNode->renderer()->positionForPoint(event.localPoint()));
631     if (visiblePos.isNull())
632         visiblePos = VisiblePosition(firstPositionInOrBeforeNode(targetNode), DOWNSTREAM);
633     Position pos = visiblePos.deepEquivalent();
634
635     VisibleSelection newSelection = m_frame.selection().selection();
636     TextGranularity granularity = CharacterGranularity;
637
638     if (extendSelection && newSelection.isCaretOrRange()) {
639         VisibleSelection selectionInUserSelectAll = expandSelectionToRespectUserSelectAll(targetNode, VisibleSelection(pos));
640         if (selectionInUserSelectAll.isRange()) {
641             if (comparePositions(selectionInUserSelectAll.start(), newSelection.start()) < 0)
642                 pos = selectionInUserSelectAll.start();
643             else if (comparePositions(newSelection.end(), selectionInUserSelectAll.end()) < 0)
644                 pos = selectionInUserSelectAll.end();
645         }
646
647         if (!m_frame.editor().behavior().shouldConsiderSelectionAsDirectional() && pos.isNotNull()) {
648             // See <rdar://problem/3668157> REGRESSION (Mail): shift-click deselects when selection
649             // was created right-to-left
650             Position start = newSelection.start();
651             Position end = newSelection.end();
652             int distanceToStart = textDistance(start, pos);
653             int distanceToEnd = textDistance(pos, end);
654             if (distanceToStart <= distanceToEnd)
655                 newSelection = VisibleSelection(end, pos);
656             else
657                 newSelection = VisibleSelection(start, pos);
658         } else
659             newSelection.setExtent(pos);
660
661         if (m_frame.selection().granularity() != CharacterGranularity) {
662             granularity = m_frame.selection().granularity();
663             newSelection.expandUsingGranularity(m_frame.selection().granularity());
664         }
665     } else
666         newSelection = expandSelectionToRespectUserSelectAll(targetNode, visiblePos);
667
668     bool handled = updateSelectionForMouseDownDispatchingSelectStart(targetNode, newSelection, granularity);
669
670     if (event.event().button() == MiddleButton) {
671         // Ignore handled, since we want to paste to where the caret was placed anyway.
672         handled = handlePasteGlobalSelection(event.event()) || handled;
673     }
674     return handled;
675 }
676
677 static inline bool canMouseDownStartSelect(Node* node)
678 {
679     if (!node || !node->renderer())
680         return true;
681
682     return node->canStartSelection() || Position::nodeIsUserSelectAll(node);
683 }
684
685 bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)
686 {
687 #if ENABLE(DRAG_SUPPORT)
688     // Reset drag state.
689     dragState().source = 0;
690 #endif
691
692 #if !ENABLE(IOS_TOUCH_EVENTS)
693     cancelFakeMouseMoveEvent();
694 #endif
695
696     m_frame.document()->updateLayoutIgnorePendingStylesheets();
697
698     if (ScrollView* scrollView = m_frame.view()) {
699         if (scrollView->isPointInScrollbarCorner(event.event().position()))
700             return false;
701     }
702
703     bool singleClick = event.event().clickCount() <= 1;
704
705     // If we got the event back, that must mean it wasn't prevented,
706     // so it's allowed to start a drag or selection if it wasn't in a scrollbar.
707     m_mouseDownMayStartSelect = canMouseDownStartSelect(event.targetNode()) && !event.scrollbar();
708     
709 #if ENABLE(DRAG_SUPPORT)
710     // Careful that the drag starting logic stays in sync with eventMayStartDrag()
711     m_mouseDownMayStartDrag = singleClick;
712 #endif
713
714     m_mouseDownWasSingleClickInSelection = false;
715
716     m_mouseDown = event.event();
717
718     if (event.isOverWidget() && passWidgetMouseDownEventToWidget(event))
719         return true;
720
721     if (m_frame.document()->isSVGDocument()
722         && toSVGDocument(m_frame.document())->zoomAndPanEnabled()) {
723         if (event.event().shiftKey() && singleClick) {
724             m_svgPan = true;
725             toSVGDocument(m_frame.document())->startPan(m_frame.view()->windowToContents(event.event().position()));
726             return true;
727         }
728     }
729
730     // We don't do this at the start of mouse down handling,
731     // because we don't want to do it until we know we didn't hit a widget.
732     if (singleClick)
733         focusDocumentView();
734
735     m_mousePressNode = event.targetNode();
736 #if ENABLE(DRAG_SUPPORT)
737     m_dragStartPos = event.event().position();
738 #endif
739
740     bool swallowEvent = false;
741     m_mousePressed = true;
742     m_selectionInitiationState = HaveNotStartedSelection;
743
744     if (event.event().clickCount() == 2)
745         swallowEvent = handleMousePressEventDoubleClick(event);
746     else if (event.event().clickCount() >= 3)
747         swallowEvent = handleMousePressEventTripleClick(event);
748     else
749         swallowEvent = handleMousePressEventSingleClick(event);
750     
751     m_mouseDownMayStartAutoscroll = m_mouseDownMayStartSelect
752         || (m_mousePressNode && m_mousePressNode->renderBox() && m_mousePressNode->renderBox()->canBeProgramaticallyScrolled());
753
754     return swallowEvent;
755 }
756
757 #if ENABLE(DRAG_SUPPORT)
758 bool EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event)
759 {
760     if (!m_mousePressed)
761         return false;
762
763     if (handleDrag(event, ShouldCheckDragHysteresis))
764         return true;
765
766     Node* targetNode = event.targetNode();
767     if (event.event().button() != LeftButton || !targetNode)
768         return false;
769
770     RenderObject* renderer = targetNode->renderer();
771     if (!renderer) {
772         Element* parent = targetNode->parentOrShadowHostElement();
773         if (!parent)
774             return false;
775
776         renderer = parent->renderer();
777         if (!renderer || !renderer->isListBox())
778             return false;
779     }
780
781 #if PLATFORM(COCOA) // FIXME: Why does this assertion fire on other platforms?
782     ASSERT(m_mouseDownMayStartSelect || m_mouseDownMayStartAutoscroll);
783 #endif
784
785     m_mouseDownMayStartDrag = false;
786
787     if (m_mouseDownMayStartAutoscroll && !panScrollInProgress()) {
788         m_autoscrollController->startAutoscrollForSelection(renderer);
789         m_mouseDownMayStartAutoscroll = false;
790     }
791
792     if (m_selectionInitiationState != ExtendedSelection) {
793         HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
794         HitTestResult result(m_mouseDownPos);
795         m_frame.document()->renderView()->hitTest(request, result);
796
797         updateSelectionForMouseDrag(result);
798     }
799     updateSelectionForMouseDrag(event.hitTestResult());
800     return true;
801 }
802     
803 bool EventHandler::eventMayStartDrag(const PlatformMouseEvent& event) const
804 {
805     // This is a pre-flight check of whether the event might lead to a drag being started.  Be careful
806     // that its logic needs to stay in sync with handleMouseMoveEvent() and the way we setMouseDownMayStartDrag
807     // in handleMousePressEvent
808     
809     if (!m_frame.contentRenderer() || !m_frame.contentRenderer()->hasLayer())
810         return false;
811
812     if (event.button() != LeftButton || event.clickCount() != 1)
813         return false;
814     
815     FrameView* view = m_frame.view();
816     if (!view)
817         return false;
818
819     Page* page = m_frame.page();
820     if (!page)
821         return false;
822
823     updateDragSourceActionsAllowed();
824     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::DisallowShadowContent);
825     HitTestResult result(view->windowToContents(event.position()));
826     m_frame.contentRenderer()->hitTest(request, result);
827     DragState state;
828     return result.innerElement() && page->dragController().draggableElement(&m_frame, result.innerElement(), result.roundedPointInInnerNodeFrame(), state);
829 }
830
831 void EventHandler::updateSelectionForMouseDrag()
832 {
833     FrameView* view = m_frame.view();
834     if (!view)
835         return;
836     RenderView* renderer = m_frame.contentRenderer();
837     if (!renderer)
838         return;
839
840     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::Move | HitTestRequest::DisallowShadowContent);
841     HitTestResult result(view->windowToContents(m_lastKnownMousePosition));
842     renderer->hitTest(request, result);
843     updateSelectionForMouseDrag(result);
844 }
845
846 static VisiblePosition selectionExtentRespectingEditingBoundary(const VisibleSelection& selection, const LayoutPoint& localPoint, Node* targetNode)
847 {
848     LayoutPoint selectionEndPoint = localPoint;
849     Element* editableElement = selection.rootEditableElement();
850
851     if (!targetNode->renderer())
852         return VisiblePosition();
853
854     if (editableElement && !editableElement->contains(targetNode)) {
855         if (!editableElement->renderer())
856             return VisiblePosition();
857
858         FloatPoint absolutePoint = targetNode->renderer()->localToAbsolute(FloatPoint(selectionEndPoint));
859         selectionEndPoint = roundedLayoutPoint(editableElement->renderer()->absoluteToLocal(absolutePoint));
860         targetNode = editableElement;
861     }
862
863     return targetNode->renderer()->positionForPoint(selectionEndPoint);
864 }
865
866 void EventHandler::updateSelectionForMouseDrag(const HitTestResult& hitTestResult)
867 {
868     if (!m_mouseDownMayStartSelect)
869         return;
870
871     Node* target = hitTestResult.targetNode();
872     if (!target)
873         return;
874
875     VisiblePosition targetPosition = selectionExtentRespectingEditingBoundary(m_frame.selection().selection(), hitTestResult.localPoint(), target);
876
877     // Don't modify the selection if we're not on a node.
878     if (targetPosition.isNull())
879         return;
880
881     // Restart the selection if this is the first mouse move. This work is usually
882     // done in handleMousePressEvent, but not if the mouse press was on an existing selection.
883     VisibleSelection newSelection = m_frame.selection().selection();
884
885     // Special case to limit selection to the containing block for SVG text.
886     // FIXME: Isn't there a better non-SVG-specific way to do this?
887     if (Node* selectionBaseNode = newSelection.base().deprecatedNode())
888         if (RenderObject* selectionBaseRenderer = selectionBaseNode->renderer())
889             if (selectionBaseRenderer->isSVGText())
890                 if (target->renderer()->containingBlock() != selectionBaseRenderer->containingBlock())
891                     return;
892
893     if (m_selectionInitiationState == HaveNotStartedSelection && !dispatchSelectStart(target))
894         return;
895
896     if (m_selectionInitiationState != ExtendedSelection) {
897         // Always extend selection here because it's caused by a mouse drag
898         m_selectionInitiationState = ExtendedSelection;
899         newSelection = VisibleSelection(targetPosition);
900     }
901
902 #if ENABLE(USERSELECT_ALL)
903     Node* rootUserSelectAllForMousePressNode = Position::rootUserSelectAllForNode(m_mousePressNode.get());
904     if (rootUserSelectAllForMousePressNode && rootUserSelectAllForMousePressNode == Position::rootUserSelectAllForNode(target)) {
905         newSelection.setBase(positionBeforeNode(rootUserSelectAllForMousePressNode).upstream(CanCrossEditingBoundary));
906         newSelection.setExtent(positionAfterNode(rootUserSelectAllForMousePressNode).downstream(CanCrossEditingBoundary));
907     } else {
908         // Reset base for user select all when base is inside user-select-all area and extent < base.
909         if (rootUserSelectAllForMousePressNode && comparePositions(target->renderer()->positionForPoint(hitTestResult.localPoint()), m_mousePressNode->renderer()->positionForPoint(m_dragStartPos)) < 0)
910             newSelection.setBase(positionAfterNode(rootUserSelectAllForMousePressNode).downstream(CanCrossEditingBoundary));
911         
912         Node* rootUserSelectAllForTarget = Position::rootUserSelectAllForNode(target);
913         if (rootUserSelectAllForTarget && m_mousePressNode->renderer() && comparePositions(target->renderer()->positionForPoint(hitTestResult.localPoint()), m_mousePressNode->renderer()->positionForPoint(m_dragStartPos)) < 0)
914             newSelection.setExtent(positionBeforeNode(rootUserSelectAllForTarget).upstream(CanCrossEditingBoundary));
915         else if (rootUserSelectAllForTarget && m_mousePressNode->renderer())
916             newSelection.setExtent(positionAfterNode(rootUserSelectAllForTarget).downstream(CanCrossEditingBoundary));
917         else
918             newSelection.setExtent(targetPosition);
919     }
920 #else
921     newSelection.setExtent(targetPosition);
922 #endif
923
924     if (m_frame.selection().granularity() != CharacterGranularity)
925         newSelection.expandUsingGranularity(m_frame.selection().granularity());
926
927     m_frame.selection().setSelectionByMouseIfDifferent(newSelection, m_frame.selection().granularity(),
928         FrameSelection::AdjustEndpointsAtBidiBoundary);
929 }
930 #endif // ENABLE(DRAG_SUPPORT)
931
932 void EventHandler::lostMouseCapture()
933 {
934     m_frame.selection().setCaretBlinkingSuspended(false);
935 }
936
937 bool EventHandler::handleMouseUp(const MouseEventWithHitTestResults& event)
938 {
939     if (eventLoopHandleMouseUp(event))
940         return true;
941     
942     // If this was the first click in the window, we don't even want to clear the selection.
943     // This case occurs when the user clicks on a draggable element, since we have to process
944     // the mouse down and drag events to see if we might start a drag.  For other first clicks
945     // in a window, we just don't acceptFirstMouse, and the whole down-drag-up sequence gets
946     // ignored upstream of this layer.
947     return eventActivatedView(event.event());
948 }    
949
950 bool EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event)
951 {
952     if (autoscrollInProgress())
953         stopAutoscrollTimer();
954
955     if (handleMouseUp(event))
956         return true;
957
958     // Used to prevent mouseMoveEvent from initiating a drag before
959     // the mouse is pressed again.
960     m_mousePressed = false;
961     m_capturesDragging = false;
962 #if ENABLE(DRAG_SUPPORT)
963     m_mouseDownMayStartDrag = false;
964 #endif
965     m_mouseDownMayStartSelect = false;
966     m_mouseDownMayStartAutoscroll = false;
967     m_mouseDownWasInSubframe = false;
968   
969     bool handled = false;
970
971     // Clear the selection if the mouse didn't move after the last mouse
972     // press and it's not a context menu click.  We do this so when clicking
973     // on the selection, the selection goes away.  However, if we are
974     // editing, place the caret.
975     if (m_mouseDownWasSingleClickInSelection && m_selectionInitiationState != ExtendedSelection
976 #if ENABLE(DRAG_SUPPORT)
977             && m_dragStartPos == event.event().position()
978 #endif
979             && m_frame.selection().isRange()
980             && event.event().button() != RightButton) {
981         VisibleSelection newSelection;
982         Node* node = event.targetNode();
983         bool caretBrowsing = m_frame.settings().caretBrowsingEnabled();
984         if (node && node->renderer() && (caretBrowsing || node->hasEditableStyle())) {
985             VisiblePosition pos = node->renderer()->positionForPoint(event.localPoint());
986             newSelection = VisibleSelection(pos);
987         }
988
989         setSelectionIfNeeded(m_frame.selection(), newSelection);
990
991         handled = true;
992     }
993
994     if (event.event().button() == MiddleButton) {
995         // Ignore handled, since we want to paste to where the caret was placed anyway.
996         handled = handlePasteGlobalSelection(event.event()) || handled;
997     }
998
999     return handled;
1000 }
1001
1002 #if ENABLE(PAN_SCROLLING)
1003
1004 void EventHandler::didPanScrollStart()
1005 {
1006     m_autoscrollController->didPanScrollStart();
1007 }
1008
1009 void EventHandler::didPanScrollStop()
1010 {
1011     m_autoscrollController->didPanScrollStop();
1012 }
1013
1014 void EventHandler::startPanScrolling(RenderElement* renderer)
1015 {
1016 #if !PLATFORM(IOS)
1017     if (!renderer->isBox())
1018         return;
1019     m_autoscrollController->startPanScrolling(toRenderBox(renderer), lastKnownMousePosition());
1020     invalidateClick();
1021 #endif
1022 }
1023
1024 #endif // ENABLE(PAN_SCROLLING)
1025
1026 RenderBox* EventHandler::autoscrollRenderer() const
1027 {
1028     return m_autoscrollController->autoscrollRenderer();
1029 }
1030
1031 void EventHandler::updateAutoscrollRenderer()
1032 {
1033     m_autoscrollController->updateAutoscrollRenderer();
1034 }
1035
1036 bool EventHandler::autoscrollInProgress() const
1037 {
1038     return m_autoscrollController->autoscrollInProgress();
1039 }
1040
1041 bool EventHandler::panScrollInProgress() const
1042 {
1043     return m_autoscrollController->panScrollInProgress();
1044 }
1045
1046 #if ENABLE(DRAG_SUPPORT)
1047 DragSourceAction EventHandler::updateDragSourceActionsAllowed() const
1048 {
1049     Page* page = m_frame.page();
1050     if (!page)
1051         return DragSourceActionNone;
1052
1053     FrameView* view = m_frame.view();
1054     if (!view)
1055         return DragSourceActionNone;
1056
1057     return page->dragController().delegateDragSourceAction(view->contentsToRootView(m_mouseDownPos));
1058 }
1059 #endif // ENABLE(DRAG_SUPPORT)
1060
1061 HitTestResult EventHandler::hitTestResultAtPoint(const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType, const LayoutSize& padding)
1062 {
1063     // We always send hitTestResultAtPoint to the main frame if we have one,
1064     // otherwise we might hit areas that are obscured by higher frames.
1065     if (!m_frame.isMainFrame()) {
1066         Frame& mainFrame = m_frame.mainFrame();
1067         FrameView* frameView = m_frame.view();
1068         FrameView* mainView = mainFrame.view();
1069         if (frameView && mainView) {
1070             IntPoint mainFramePoint = mainView->rootViewToContents(frameView->contentsToRootView(roundedIntPoint(point)));
1071             return mainFrame.eventHandler().hitTestResultAtPoint(mainFramePoint, hitType, padding);
1072         }
1073     }
1074
1075     HitTestResult result(point, padding.height(), padding.width(), padding.height(), padding.width());
1076
1077     if (!m_frame.contentRenderer())
1078         return result;
1079
1080     // hitTestResultAtPoint is specifically used to hitTest into all frames, thus it always allows child frame content.
1081     HitTestRequest request(hitType | HitTestRequest::AllowChildFrameContent);
1082     m_frame.contentRenderer()->hitTest(request, result);
1083     if (!request.readOnly())
1084         m_frame.document()->updateHoverActiveState(request, result.innerElement());
1085
1086     if (request.disallowsShadowContent())
1087         result.setToNonShadowAncestor();
1088
1089     return result;
1090 }
1091
1092 void EventHandler::stopAutoscrollTimer(bool rendererIsBeingDestroyed)
1093 {
1094     m_autoscrollController->stopAutoscrollTimer(rendererIsBeingDestroyed);
1095 }
1096
1097 bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode)
1098 {
1099     Node* node = startingNode;
1100
1101     if (!node)
1102         node = m_frame.document()->focusedElement();
1103
1104     if (!node)
1105         node = m_mousePressNode.get();
1106     
1107     if (node) {
1108         auto r = node->renderer();
1109         if (r && !r->isListBox() && r->enclosingBox()->scroll(direction, granularity)) {
1110             setFrameWasScrolledByUser();
1111             return true;
1112         }
1113     }
1114
1115     return false;
1116 }
1117
1118 bool EventHandler::logicalScrollOverflow(ScrollLogicalDirection direction, ScrollGranularity granularity, Node* startingNode)
1119 {
1120     Node* node = startingNode;
1121
1122     if (!node)
1123         node = m_frame.document()->focusedElement();
1124
1125     if (!node)
1126         node = m_mousePressNode.get();
1127     
1128     if (node) {
1129         auto r = node->renderer();
1130         if (r && !r->isListBox() && r->enclosingBox()->logicalScroll(direction, granularity)) {
1131             setFrameWasScrolledByUser();
1132             return true;
1133         }
1134     }
1135
1136     return false;
1137 }
1138
1139 bool EventHandler::scrollRecursively(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode)
1140 {
1141     // The layout needs to be up to date to determine if we can scroll. We may be
1142     // here because of an onLoad event, in which case the final layout hasn't been performed yet.
1143     m_frame.document()->updateLayoutIgnorePendingStylesheets();
1144     if (scrollOverflow(direction, granularity, startingNode))
1145         return true;    
1146     Frame* frame = &m_frame;
1147     FrameView* view = frame->view();
1148     if (view && view->scroll(direction, granularity))
1149         return true;
1150     frame = frame->tree().parent();
1151     if (!frame)
1152         return false;
1153     return frame->eventHandler().scrollRecursively(direction, granularity, m_frame.ownerElement());
1154 }
1155
1156 bool EventHandler::logicalScrollRecursively(ScrollLogicalDirection direction, ScrollGranularity granularity, Node* startingNode)
1157 {
1158     // The layout needs to be up to date to determine if we can scroll. We may be
1159     // here because of an onLoad event, in which case the final layout hasn't been performed yet.
1160     m_frame.document()->updateLayoutIgnorePendingStylesheets();
1161     if (logicalScrollOverflow(direction, granularity, startingNode))
1162         return true;    
1163     Frame* frame = &m_frame;
1164     FrameView* view = frame->view();
1165     
1166     bool scrolled = false;
1167 #if PLATFORM(COCOA)
1168     // Mac also resets the scroll position in the inline direction.
1169     if (granularity == ScrollByDocument && view && view->logicalScroll(ScrollInlineDirectionBackward, ScrollByDocument))
1170         scrolled = true;
1171 #endif
1172     if (view && view->logicalScroll(direction, granularity))
1173         scrolled = true;
1174     
1175     if (scrolled)
1176         return true;
1177     
1178     frame = frame->tree().parent();
1179     if (!frame)
1180         return false;
1181
1182     return frame->eventHandler().logicalScrollRecursively(direction, granularity, m_frame.ownerElement());
1183 }
1184
1185 IntPoint EventHandler::lastKnownMousePosition() const
1186 {
1187     return m_lastKnownMousePosition;
1188 }
1189
1190 Frame* EventHandler::subframeForHitTestResult(const MouseEventWithHitTestResults& hitTestResult)
1191 {
1192     if (!hitTestResult.isOverWidget())
1193         return 0;
1194     return subframeForTargetNode(hitTestResult.targetNode());
1195 }
1196
1197 Frame* EventHandler::subframeForTargetNode(Node* node)
1198 {
1199     if (!node)
1200         return 0;
1201
1202     auto renderer = node->renderer();
1203     if (!renderer || !renderer->isWidget())
1204         return 0;
1205
1206     Widget* widget = toRenderWidget(renderer)->widget();
1207     if (!widget || !widget->isFrameView())
1208         return 0;
1209
1210     return &toFrameView(widget)->frame();
1211 }
1212
1213 #if ENABLE(CURSOR_SUPPORT)
1214 static bool isSubmitImage(Node* node)
1215 {
1216     return node && isHTMLInputElement(node) && toHTMLInputElement(node)->isImageButton();
1217 }
1218
1219 // Returns true if the node's editable block is not current focused for editing
1220 static bool nodeIsNotBeingEdited(const Node& node, const Frame& frame)
1221 {
1222     return frame.selection().selection().rootEditableElement() != node.rootEditableElement();
1223 }
1224
1225 bool EventHandler::useHandCursor(Node* node, bool isOverLink, bool shiftKey)
1226 {
1227     if (!node)
1228         return false;
1229
1230     bool editable = node->hasEditableStyle();
1231     bool editableLinkEnabled = false;
1232
1233     // If the link is editable, then we need to check the settings to see whether or not the link should be followed
1234     if (editable) {
1235         switch (m_frame.settings().editableLinkBehavior()) {
1236         default:
1237         case EditableLinkDefaultBehavior:
1238         case EditableLinkAlwaysLive:
1239             editableLinkEnabled = true;
1240             break;
1241
1242         case EditableLinkNeverLive:
1243             editableLinkEnabled = false;
1244             break;
1245
1246         case EditableLinkLiveWhenNotFocused:
1247             editableLinkEnabled = nodeIsNotBeingEdited(*node, m_frame) || shiftKey;
1248             break;
1249
1250         case EditableLinkOnlyLiveWithShiftKey:
1251             editableLinkEnabled = shiftKey;
1252             break;
1253         }
1254     }
1255
1256     return ((isOverLink || isSubmitImage(node)) && (!editable || editableLinkEnabled));
1257 }
1258
1259 void EventHandler::cursorUpdateTimerFired(Timer<EventHandler>&)
1260 {
1261     ASSERT(m_frame.document());
1262     updateCursor();
1263 }
1264
1265 void EventHandler::updateCursor()
1266 {
1267     if (m_mousePositionIsUnknown)
1268         return;
1269
1270     FrameView* view = m_frame.view();
1271     if (!view)
1272         return;
1273
1274     RenderView* renderView = view->renderView();
1275     if (!renderView)
1276         return;
1277
1278     if (!view->shouldSetCursor())
1279         return;
1280
1281     bool shiftKey;
1282     bool ctrlKey;
1283     bool altKey;
1284     bool metaKey;
1285     PlatformKeyboardEvent::getCurrentModifierState(shiftKey, ctrlKey, altKey, metaKey);
1286
1287     m_frame.document()->updateLayout();
1288
1289     HitTestRequest request(HitTestRequest::ReadOnly);
1290     HitTestResult result(view->windowToContents(m_lastKnownMousePosition));
1291     renderView->hitTest(request, result);
1292
1293     OptionalCursor optionalCursor = selectCursor(result, shiftKey);
1294     if (optionalCursor.isCursorChange()) {
1295         m_currentMouseCursor = optionalCursor.cursor();
1296         view->setCursor(m_currentMouseCursor);
1297     }
1298 }
1299
1300 OptionalCursor EventHandler::selectCursor(const HitTestResult& result, bool shiftKey)
1301 {
1302     if (m_resizeLayer && m_resizeLayer->inResizeMode())
1303         return NoCursorChange;
1304
1305     if (!m_frame.page())
1306         return NoCursorChange;
1307
1308 #if ENABLE(PAN_SCROLLING)
1309     if (m_frame.mainFrame().eventHandler().panScrollInProgress())
1310         return NoCursorChange;
1311 #endif
1312
1313     Node* node = result.targetNode();
1314     if (!node)
1315         return NoCursorChange;
1316
1317     auto renderer = node->renderer();
1318     RenderStyle* style = renderer ? &renderer->style() : nullptr;
1319     bool horizontalText = !style || style->isHorizontalWritingMode();
1320     const Cursor& iBeam = horizontalText ? iBeamCursor() : verticalTextCursor();
1321
1322 #if ENABLE(CURSOR_VISIBILITY)
1323     if (style && style->cursorVisibility() == CursorVisibilityAutoHide)
1324         startAutoHideCursorTimer();
1325     else
1326         cancelAutoHideCursorTimer();
1327 #endif
1328
1329     if (renderer) {
1330         Cursor overrideCursor;
1331         switch (renderer->getCursor(roundedIntPoint(result.localPoint()), overrideCursor)) {
1332         case SetCursorBasedOnStyle:
1333             break;
1334         case SetCursor:
1335             return overrideCursor;
1336         case DoNotSetCursor:
1337             return NoCursorChange;
1338         }
1339     }
1340
1341     if (style && style->cursors()) {
1342         const CursorList* cursors = style->cursors();
1343         for (unsigned i = 0; i < cursors->size(); ++i) {
1344             StyleImage* styleImage = (*cursors)[i].image();
1345             if (!styleImage)
1346                 continue;
1347             CachedImage* cachedImage = styleImage->cachedImage();
1348             if (!cachedImage)
1349                 continue;
1350             float scale = styleImage->imageScaleFactor();
1351             // Get hotspot and convert from logical pixels to physical pixels.
1352             IntPoint hotSpot = (*cursors)[i].hotSpot();
1353             hotSpot.scale(scale, scale);
1354             FloatSize size = cachedImage->imageForRenderer(renderer)->size();
1355             if (cachedImage->errorOccurred())
1356                 continue;
1357             // Limit the size of cursors (in UI pixels) so that they cannot be
1358             // used to cover UI elements in chrome.
1359             size.scale(1 / scale);
1360             if (size.width() > maximumCursorSize || size.height() > maximumCursorSize)
1361                 continue;
1362
1363             Image* image = cachedImage->imageForRenderer(renderer);
1364 #if ENABLE(MOUSE_CURSOR_SCALE)
1365             // Ensure no overflow possible in calculations above.
1366             if (scale < minimumCursorScale)
1367                 continue;
1368             return Cursor(image, hotSpot, scale);
1369 #else
1370             ASSERT(scale == 1);
1371             return Cursor(image, hotSpot);
1372 #endif // ENABLE(MOUSE_CURSOR_SCALE)
1373         }
1374     }
1375
1376     switch (style ? style->cursor() : CURSOR_AUTO) {
1377     case CURSOR_AUTO: {
1378         bool editable = node->hasEditableStyle();
1379
1380         if (useHandCursor(node, result.isOverLink(), shiftKey))
1381             return handCursor();
1382
1383         bool inResizer = false;
1384         if (renderer) {
1385             if (RenderLayer* layer = renderer->enclosingLayer()) {
1386                 if (FrameView* view = m_frame.view())
1387                     inResizer = layer->isPointInResizeControl(view->windowToContents(roundedIntPoint(result.localPoint())));
1388             }
1389         }
1390
1391         // During selection, use an I-beam regardless of the content beneath the cursor when cursor style is not explicitly specified.
1392         // If a drag may be starting or we're capturing mouse events for a particular node, don't treat this as a selection.
1393         if (m_mousePressed && m_mouseDownMayStartSelect
1394 #if ENABLE(DRAG_SUPPORT)
1395             && !m_mouseDownMayStartDrag
1396 #endif
1397             && m_frame.selection().isCaretOrRange()
1398             && !m_capturingMouseEventsElement) {
1399             return iBeam;
1400         }
1401
1402         if ((editable || (renderer && renderer->isText() && node->canStartSelection())) && !inResizer && !result.scrollbar())
1403             return iBeam;
1404         return pointerCursor();
1405     }
1406     case CURSOR_CROSS:
1407         return crossCursor();
1408     case CURSOR_POINTER:
1409         return handCursor();
1410     case CURSOR_MOVE:
1411         return moveCursor();
1412     case CURSOR_ALL_SCROLL:
1413         return moveCursor();
1414     case CURSOR_E_RESIZE:
1415         return eastResizeCursor();
1416     case CURSOR_W_RESIZE:
1417         return westResizeCursor();
1418     case CURSOR_N_RESIZE:
1419         return northResizeCursor();
1420     case CURSOR_S_RESIZE:
1421         return southResizeCursor();
1422     case CURSOR_NE_RESIZE:
1423         return northEastResizeCursor();
1424     case CURSOR_SW_RESIZE:
1425         return southWestResizeCursor();
1426     case CURSOR_NW_RESIZE:
1427         return northWestResizeCursor();
1428     case CURSOR_SE_RESIZE:
1429         return southEastResizeCursor();
1430     case CURSOR_NS_RESIZE:
1431         return northSouthResizeCursor();
1432     case CURSOR_EW_RESIZE:
1433         return eastWestResizeCursor();
1434     case CURSOR_NESW_RESIZE:
1435         return northEastSouthWestResizeCursor();
1436     case CURSOR_NWSE_RESIZE:
1437         return northWestSouthEastResizeCursor();
1438     case CURSOR_COL_RESIZE:
1439         return columnResizeCursor();
1440     case CURSOR_ROW_RESIZE:
1441         return rowResizeCursor();
1442     case CURSOR_TEXT:
1443         return iBeamCursor();
1444     case CURSOR_WAIT:
1445         return waitCursor();
1446     case CURSOR_HELP:
1447         return helpCursor();
1448     case CURSOR_VERTICAL_TEXT:
1449         return verticalTextCursor();
1450     case CURSOR_CELL:
1451         return cellCursor();
1452     case CURSOR_CONTEXT_MENU:
1453         return contextMenuCursor();
1454     case CURSOR_PROGRESS:
1455         return progressCursor();
1456     case CURSOR_NO_DROP:
1457         return noDropCursor();
1458     case CURSOR_ALIAS:
1459         return aliasCursor();
1460     case CURSOR_COPY:
1461         return copyCursor();
1462     case CURSOR_NONE:
1463         return noneCursor();
1464     case CURSOR_NOT_ALLOWED:
1465         return notAllowedCursor();
1466     case CURSOR_DEFAULT:
1467         return pointerCursor();
1468     case CURSOR_WEBKIT_ZOOM_IN:
1469         return zoomInCursor();
1470     case CURSOR_WEBKIT_ZOOM_OUT:
1471         return zoomOutCursor();
1472     case CURSOR_WEBKIT_GRAB:
1473         return grabCursor();
1474     case CURSOR_WEBKIT_GRABBING:
1475         return grabbingCursor();
1476     }
1477     return pointerCursor();
1478 }
1479 #endif // ENABLE(CURSOR_SUPPORT)
1480
1481 #if ENABLE(CURSOR_VISIBILITY)
1482 void EventHandler::startAutoHideCursorTimer()
1483 {
1484     Page* page = m_frame.page();
1485     if (!page)
1486         return;
1487
1488     m_autoHideCursorTimer.startOneShot(page->settings().timeWithoutMouseMovementBeforeHidingControls());
1489
1490 #if !ENABLE(IOS_TOUCH_EVENTS)
1491     // The fake mouse move event screws up the auto-hide feature (by resetting the auto-hide timer)
1492     // so cancel any pending fake mouse moves.
1493     if (m_fakeMouseMoveEventTimer.isActive())
1494         m_fakeMouseMoveEventTimer.stop();
1495 #endif
1496 }
1497
1498 void EventHandler::cancelAutoHideCursorTimer()
1499 {
1500     if (m_autoHideCursorTimer.isActive())
1501         m_autoHideCursorTimer.stop();
1502 }
1503
1504 void EventHandler::autoHideCursorTimerFired(Timer<EventHandler>& timer)
1505 {
1506     ASSERT_UNUSED(timer, &timer == &m_autoHideCursorTimer);
1507     m_currentMouseCursor = noneCursor();
1508     FrameView* view = m_frame.view();
1509     if (view && view->isActive())
1510         view->setCursor(m_currentMouseCursor);
1511 }
1512 #endif
1513
1514 static LayoutPoint documentPointForWindowPoint(Frame& frame, const IntPoint& windowPoint)
1515 {
1516     FrameView* view = frame.view();
1517     // FIXME: Is it really OK to use the wrong coordinates here when view is 0?
1518     // Historically the code would just crash; this is clearly no worse than that.
1519     return view ? view->windowToContents(windowPoint) : windowPoint;
1520 }
1521
1522 bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)
1523 {
1524     RefPtr<FrameView> protector(m_frame.view());
1525
1526     if (InspectorInstrumentation::handleMousePress(m_frame.page())) {
1527         invalidateClick();
1528         return true;
1529     }
1530
1531 #if ENABLE(TOUCH_EVENTS)
1532     bool defaultPrevented = dispatchSyntheticTouchEventIfEnabled(mouseEvent);
1533     if (defaultPrevented)
1534         return true;
1535 #endif
1536
1537     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
1538
1539     // FIXME (bug 68185): this call should be made at another abstraction layer
1540     m_frame.loader().resetMultipleFormSubmissionProtection();
1541
1542 #if !ENABLE(IOS_TOUCH_EVENTS)
1543     cancelFakeMouseMoveEvent();
1544 #endif
1545     m_mousePressed = true;
1546     m_capturesDragging = true;
1547     setLastKnownMousePosition(mouseEvent);
1548     m_mouseDownTimestamp = mouseEvent.timestamp();
1549 #if ENABLE(DRAG_SUPPORT)
1550     m_mouseDownMayStartDrag = false;
1551 #endif
1552     m_mouseDownMayStartSelect = false;
1553     m_mouseDownMayStartAutoscroll = false;
1554     if (FrameView* view = m_frame.view())
1555         m_mouseDownPos = view->windowToContents(mouseEvent.position());
1556     else {
1557         invalidateClick();
1558         return false;
1559     }
1560     m_mouseDownWasInSubframe = false;
1561
1562     HitTestRequest request(HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
1563     // Save the document point we generate in case the window coordinate is invalidated by what happens
1564     // when we dispatch the event.
1565     LayoutPoint documentPoint = documentPointForWindowPoint(m_frame, mouseEvent.position());
1566     MouseEventWithHitTestResults mev = m_frame.document()->prepareMouseEvent(request, documentPoint, mouseEvent);
1567
1568     if (!mev.targetNode()) {
1569         invalidateClick();
1570         return false;
1571     }
1572
1573     m_mousePressNode = mev.targetNode();
1574
1575     RefPtr<Frame> subframe = subframeForHitTestResult(mev);
1576     if (subframe && passMousePressEventToSubframe(mev, subframe.get())) {
1577         // Start capturing future events for this frame.  We only do this if we didn't clear
1578         // the m_mousePressed flag, which may happen if an AppKit widget entered a modal event loop.
1579         m_capturesDragging = subframe->eventHandler().capturesDragging();
1580         if (m_mousePressed && m_capturesDragging) {
1581             m_capturingMouseEventsElement = subframe->ownerElement();
1582             m_eventHandlerWillResetCapturingMouseEventsElement = true;
1583         }
1584         invalidateClick();
1585         return true;
1586     }
1587
1588 #if ENABLE(PAN_SCROLLING)
1589     // We store whether pan scrolling is in progress before calling stopAutoscrollTimer()
1590     // because it will set m_autoscrollType to NoAutoscroll on return.
1591     bool isPanScrollInProgress = m_frame.mainFrame().eventHandler().panScrollInProgress();
1592     stopAutoscrollTimer();
1593     if (isPanScrollInProgress) {
1594         // We invalidate the click when exiting pan scrolling so that we don't inadvertently navigate
1595         // away from the current page (e.g. the click was on a hyperlink). See <rdar://problem/6095023>.
1596         invalidateClick();
1597         return true;
1598     }
1599 #endif
1600
1601     m_clickCount = mouseEvent.clickCount();
1602     m_clickNode = mev.targetNode();
1603
1604     if (!m_clickNode) {
1605         invalidateClick();
1606         return false;
1607     }
1608
1609     if (FrameView* view = m_frame.view()) {
1610         RenderLayer* layer = m_clickNode->renderer() ? m_clickNode->renderer()->enclosingLayer() : 0;
1611         IntPoint p = view->windowToContents(mouseEvent.position());
1612         if (layer && layer->isPointInResizeControl(p)) {
1613             layer->setInResizeMode(true);
1614             m_resizeLayer = layer;
1615             m_offsetFromResizeCorner = layer->offsetFromResizeCorner(p);
1616             invalidateClick();
1617             return true;
1618         }
1619     }
1620
1621     m_frame.selection().setCaretBlinkingSuspended(true);
1622
1623     bool swallowEvent = !dispatchMouseEvent(eventNames().mousedownEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true);
1624     m_capturesDragging = !swallowEvent || mev.scrollbar();
1625
1626     // If the hit testing originally determined the event was in a scrollbar, refetch the MouseEventWithHitTestResults
1627     // in case the scrollbar widget was destroyed when the mouse event was handled.
1628     if (mev.scrollbar()) {
1629         const bool wasLastScrollBar = mev.scrollbar() == m_lastScrollbarUnderMouse.get();
1630         HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
1631         mev = m_frame.document()->prepareMouseEvent(request, documentPoint, mouseEvent);
1632         if (wasLastScrollBar && mev.scrollbar() != m_lastScrollbarUnderMouse.get())
1633             m_lastScrollbarUnderMouse = 0;
1634     }
1635
1636     if (swallowEvent) {
1637         // scrollbars should get events anyway, even disabled controls might be scrollable
1638         Scrollbar* scrollbar = mev.scrollbar();
1639
1640         updateLastScrollbarUnderMouse(scrollbar, true);
1641
1642         if (scrollbar)
1643             passMousePressEventToScrollbar(mev, scrollbar);
1644     } else {
1645         // Refetch the event target node if it currently is the shadow node inside an <input> element.
1646         // If a mouse event handler changes the input element type to one that has a widget associated,
1647         // we'd like to EventHandler::handleMousePressEvent to pass the event to the widget and thus the
1648         // event target node can't still be the shadow node.
1649         if (mev.targetNode()->isShadowRoot() && isHTMLInputElement(toShadowRoot(mev.targetNode())->hostElement())) {
1650             HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
1651             mev = m_frame.document()->prepareMouseEvent(request, documentPoint, mouseEvent);
1652         }
1653
1654         FrameView* view = m_frame.view();
1655         Scrollbar* scrollbar = view ? view->scrollbarAtPoint(mouseEvent.position()) : 0;
1656         if (!scrollbar)
1657             scrollbar = mev.scrollbar();
1658
1659         updateLastScrollbarUnderMouse(scrollbar, true);
1660
1661         if (scrollbar && passMousePressEventToScrollbar(mev, scrollbar))
1662             swallowEvent = true;
1663         else
1664             swallowEvent = handleMousePressEvent(mev);
1665     }
1666
1667     return swallowEvent;
1668 }
1669
1670 // This method only exists for platforms that don't know how to deliver 
1671 bool EventHandler::handleMouseDoubleClickEvent(const PlatformMouseEvent& mouseEvent)
1672 {
1673     RefPtr<FrameView> protector(m_frame.view());
1674
1675     m_frame.selection().setCaretBlinkingSuspended(false);
1676
1677     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
1678
1679     // We get this instead of a second mouse-up 
1680     m_mousePressed = false;
1681     setLastKnownMousePosition(mouseEvent);
1682
1683     HitTestRequest request(HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
1684     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
1685     Frame* subframe = subframeForHitTestResult(mev);
1686     if (m_eventHandlerWillResetCapturingMouseEventsElement)
1687         m_capturingMouseEventsElement = nullptr;
1688     if (subframe && passMousePressEventToSubframe(mev, subframe))
1689         return true;
1690
1691     m_clickCount = mouseEvent.clickCount();
1692     bool swallowMouseUpEvent = !dispatchMouseEvent(eventNames().mouseupEvent, mev.targetNode(), true, m_clickCount, mouseEvent, false);
1693
1694     bool swallowClickEvent = mouseEvent.button() != RightButton && mev.targetNode() == m_clickNode && !dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true);
1695
1696     if (m_lastScrollbarUnderMouse)
1697         swallowMouseUpEvent = m_lastScrollbarUnderMouse->mouseUp(mouseEvent);
1698
1699     bool swallowMouseReleaseEvent = !swallowMouseUpEvent && handleMouseReleaseEvent(mev);
1700
1701     invalidateClick();
1702
1703     return swallowMouseUpEvent || swallowClickEvent || swallowMouseReleaseEvent;
1704 }
1705
1706 static RenderLayer* layerForNode(Node* node)
1707 {
1708     if (!node)
1709         return 0;
1710
1711     auto renderer = node->renderer();
1712     if (!renderer)
1713         return 0;
1714
1715     RenderLayer* layer = renderer->enclosingLayer();
1716     if (!layer)
1717         return 0;
1718
1719     return layer;
1720 }
1721
1722 bool EventHandler::mouseMoved(const PlatformMouseEvent& event)
1723 {
1724     RefPtr<FrameView> protector(m_frame.view());
1725     MaximumDurationTracker maxDurationTracker(&m_maxMouseMovedDuration);
1726
1727     HitTestResult hoveredNode = HitTestResult(LayoutPoint());
1728     bool result = handleMouseMoveEvent(event, &hoveredNode);
1729
1730     Page* page = m_frame.page();
1731     if (!page)
1732         return result;
1733
1734     if (RenderLayer* layer = layerForNode(hoveredNode.innerNode())) {
1735         if (FrameView* frameView = m_frame.view()) {
1736             if (frameView->containsScrollableArea(layer))
1737                 layer->mouseMovedInContentArea();
1738         }
1739     }
1740
1741     if (FrameView* frameView = m_frame.view())
1742         frameView->mouseMovedInContentArea();  
1743
1744     hoveredNode.setToNonShadowAncestor();
1745     page->chrome().mouseDidMoveOverElement(hoveredNode, event.modifierFlags());
1746     page->chrome().setToolTip(hoveredNode);
1747     return result;
1748 }
1749
1750 bool EventHandler::passMouseMovedEventToScrollbars(const PlatformMouseEvent& event)
1751 {
1752     HitTestResult hoveredNode;
1753     return handleMouseMoveEvent(event, &hoveredNode, true);
1754 }
1755
1756 bool EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& mouseEvent, HitTestResult* hoveredNode, bool onlyUpdateScrollbars)
1757 {
1758 #if ENABLE(TOUCH_EVENTS)
1759     bool defaultPrevented = dispatchSyntheticTouchEventIfEnabled(mouseEvent);
1760     if (defaultPrevented)
1761         return true;
1762 #endif
1763
1764     RefPtr<FrameView> protector(m_frame.view());
1765     
1766     setLastKnownMousePosition(mouseEvent);
1767
1768     if (m_hoverTimer.isActive())
1769         m_hoverTimer.stop();
1770
1771 #if ENABLE(CURSOR_SUPPORT)
1772     m_cursorUpdateTimer.stop();
1773 #endif
1774
1775 #if !ENABLE(IOS_TOUCH_EVENTS)
1776     cancelFakeMouseMoveEvent();
1777 #endif
1778
1779     if (m_svgPan) {
1780         toSVGDocument(m_frame.document())->updatePan(m_frame.view()->windowToContents(m_lastKnownMousePosition));
1781         return true;
1782     }
1783
1784     if (m_frameSetBeingResized)
1785         return !dispatchMouseEvent(eventNames().mousemoveEvent, m_frameSetBeingResized.get(), false, 0, mouseEvent, false);
1786
1787     // On iOS, our scrollbars are managed by UIKit.
1788 #if !PLATFORM(IOS)
1789     // Send events right to a scrollbar if the mouse is pressed.
1790     if (m_lastScrollbarUnderMouse && m_mousePressed)
1791         return m_lastScrollbarUnderMouse->mouseMoved(mouseEvent);
1792 #endif
1793
1794     HitTestRequest::HitTestRequestType hitType = HitTestRequest::Move | HitTestRequest::DisallowShadowContent | HitTestRequest::AllowFrameScrollbars;
1795     if (m_mousePressed)
1796         hitType |= HitTestRequest::Active;
1797     else if (onlyUpdateScrollbars) {
1798         // Mouse events should be treated as "read-only" if we're updating only scrollbars. This  
1799         // means that :hover and :active freeze in the state they were in, rather than updating  
1800         // for nodes the mouse moves while the window is not key (which will be the case if 
1801         // onlyUpdateScrollbars is true). 
1802         hitType |= HitTestRequest::ReadOnly;
1803     }
1804
1805 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
1806     // Treat any mouse move events as readonly if the user is currently touching the screen.
1807     if (m_touchPressed)
1808         hitType |= HitTestRequest::Active | HitTestRequest::ReadOnly;
1809 #endif
1810     HitTestRequest request(hitType);
1811     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
1812     if (hoveredNode)
1813         *hoveredNode = mev.hitTestResult();
1814
1815     if (m_resizeLayer && m_resizeLayer->inResizeMode())
1816         m_resizeLayer->resize(mouseEvent, m_offsetFromResizeCorner);
1817     else {
1818         Scrollbar* scrollbar = mev.scrollbar();
1819         updateLastScrollbarUnderMouse(scrollbar, !m_mousePressed);
1820
1821         // On iOS, our scrollbars are managed by UIKit.
1822 #if !PLATFORM(IOS)
1823         if (!m_mousePressed && scrollbar)
1824             scrollbar->mouseMoved(mouseEvent); // Handle hover effects on platforms that support visual feedback on scrollbar hovering.
1825 #endif
1826         if (onlyUpdateScrollbars)
1827             return true;
1828     }
1829
1830     bool swallowEvent = false;
1831     RefPtr<Frame> newSubframe = m_capturingMouseEventsElement.get() ? subframeForTargetNode(m_capturingMouseEventsElement.get()) : subframeForHitTestResult(mev);
1832  
1833     // We want mouseouts to happen first, from the inside out.  First send a move event to the last subframe so that it will fire mouseouts.
1834     if (m_lastMouseMoveEventSubframe && m_lastMouseMoveEventSubframe->tree().isDescendantOf(&m_frame) && m_lastMouseMoveEventSubframe != newSubframe)
1835         passMouseMoveEventToSubframe(mev, m_lastMouseMoveEventSubframe.get());
1836
1837     if (newSubframe) {
1838         // Update over/out state before passing the event to the subframe.
1839         updateMouseEventTargetNode(mev.targetNode(), mouseEvent, true);
1840         
1841         // Event dispatch in updateMouseEventTargetNode may have caused the subframe of the target
1842         // node to be detached from its FrameView, in which case the event should not be passed.
1843         if (newSubframe->view())
1844             swallowEvent |= passMouseMoveEventToSubframe(mev, newSubframe.get(), hoveredNode);
1845 #if ENABLE(CURSOR_SUPPORT)
1846     } else {
1847         if (FrameView* view = m_frame.view()) {
1848             OptionalCursor optionalCursor = selectCursor(mev.hitTestResult(), mouseEvent.shiftKey());
1849             if (optionalCursor.isCursorChange()) {
1850                 m_currentMouseCursor = optionalCursor.cursor();
1851                 view->setCursor(m_currentMouseCursor);
1852             }
1853         }
1854 #endif
1855     }
1856     
1857     m_lastMouseMoveEventSubframe = newSubframe;
1858
1859     if (swallowEvent)
1860         return true;
1861     
1862     swallowEvent = !dispatchMouseEvent(eventNames().mousemoveEvent, mev.targetNode(), false, 0, mouseEvent, true);
1863 #if ENABLE(DRAG_SUPPORT)
1864     if (!swallowEvent)
1865         swallowEvent = handleMouseDraggedEvent(mev);
1866 #endif // ENABLE(DRAG_SUPPORT)
1867
1868     return swallowEvent;
1869 }
1870
1871 void EventHandler::invalidateClick()
1872 {
1873     m_clickCount = 0;
1874     m_clickNode = 0;
1875 }
1876
1877 inline static bool mouseIsReleasedOnPressedElement(Node* targetNode, Node* clickNode)
1878 {
1879     if (targetNode == clickNode)
1880         return true;
1881
1882     if (!targetNode)
1883         return false;
1884
1885     ShadowRoot* containingShadowRoot = targetNode->containingShadowRoot();
1886     if (!containingShadowRoot)
1887         return false;
1888
1889     // FIXME: When an element in UA ShadowDOM (e.g. inner element in <input>) is clicked,
1890     // we assume that the host element is clicked. This is necessary for implementing <input type="range"> etc.
1891     // However, we should not check ShadowRoot type basically.
1892     // https://bugs.webkit.org/show_bug.cgi?id=108047
1893     if (containingShadowRoot->type() != ShadowRoot::UserAgentShadowRoot)
1894         return false;
1895
1896     Node* adjustedTargetNode = targetNode->shadowHost();
1897     Node* adjustedClickNode = clickNode ? clickNode->shadowHost() : 0;
1898     return adjustedTargetNode == adjustedClickNode;
1899 }
1900
1901 bool EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)
1902 {
1903     RefPtr<FrameView> protector(m_frame.view());
1904
1905     m_frame.selection().setCaretBlinkingSuspended(false);
1906
1907 #if ENABLE(TOUCH_EVENTS)
1908     bool defaultPrevented = dispatchSyntheticTouchEventIfEnabled(mouseEvent);
1909     if (defaultPrevented)
1910         return true;
1911 #endif
1912
1913     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
1914
1915 #if ENABLE(PAN_SCROLLING)
1916     m_autoscrollController->handleMouseReleaseEvent(mouseEvent);
1917 #endif
1918
1919     m_mousePressed = false;
1920     setLastKnownMousePosition(mouseEvent);
1921
1922     if (m_svgPan) {
1923         m_svgPan = false;
1924         toSVGDocument(m_frame.document())->updatePan(m_frame.view()->windowToContents(m_lastKnownMousePosition));
1925         return true;
1926     }
1927
1928     if (m_frameSetBeingResized)
1929         return !dispatchMouseEvent(eventNames().mouseupEvent, m_frameSetBeingResized.get(), true, m_clickCount, mouseEvent, false);
1930
1931     if (m_lastScrollbarUnderMouse) {
1932         invalidateClick();
1933         m_lastScrollbarUnderMouse->mouseUp(mouseEvent);
1934         bool cancelable = true;
1935         bool setUnder = false;
1936         return !dispatchMouseEvent(eventNames().mouseupEvent, m_lastElementUnderMouse.get(), cancelable, m_clickCount, mouseEvent, setUnder);
1937     }
1938
1939     HitTestRequest request(HitTestRequest::Release | HitTestRequest::DisallowShadowContent);
1940     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
1941     Frame* subframe = m_capturingMouseEventsElement.get() ? subframeForTargetNode(m_capturingMouseEventsElement.get()) : subframeForHitTestResult(mev);
1942     if (m_eventHandlerWillResetCapturingMouseEventsElement)
1943         m_capturingMouseEventsElement = nullptr;
1944     if (subframe && passMouseReleaseEventToSubframe(mev, subframe))
1945         return true;
1946
1947     bool swallowMouseUpEvent = !dispatchMouseEvent(eventNames().mouseupEvent, mev.targetNode(), true, m_clickCount, mouseEvent, false);
1948
1949     bool contextMenuEvent = mouseEvent.button() == RightButton;
1950
1951     bool swallowClickEvent = m_clickCount > 0 && !contextMenuEvent && mouseIsReleasedOnPressedElement(mev.targetNode(), m_clickNode.get()) && !dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true);
1952
1953     if (m_resizeLayer) {
1954         m_resizeLayer->setInResizeMode(false);
1955         m_resizeLayer = 0;
1956     }
1957
1958     bool swallowMouseReleaseEvent = false;
1959     if (!swallowMouseUpEvent)
1960         swallowMouseReleaseEvent = handleMouseReleaseEvent(mev);
1961
1962     invalidateClick();
1963
1964     return swallowMouseUpEvent || swallowClickEvent || swallowMouseReleaseEvent;
1965 }
1966
1967 bool EventHandler::handlePasteGlobalSelection(const PlatformMouseEvent& mouseEvent)
1968 {
1969     // If the event was a middle click, attempt to copy global selection in after
1970     // the newly set caret position.
1971     //
1972     // This code is called from either the mouse up or mouse down handling. There
1973     // is some debate about when the global selection is pasted:
1974     //   xterm: pastes on up.
1975     //   GTK: pastes on down.
1976     //   Qt: pastes on up.
1977     //   Firefox: pastes on up.
1978     //   Chromium: pastes on up.
1979     //
1980     // There is something of a webcompat angle to this well, as highlighted by
1981     // crbug.com/14608. Pages can clear text boxes 'onclick' and, if we paste on
1982     // down then the text is pasted just before the onclick handler runs and
1983     // clears the text box. So it's important this happens after the event
1984     // handlers have been fired.
1985 #if PLATFORM(GTK)
1986     if (mouseEvent.type() != PlatformEvent::MousePressed)
1987         return false;
1988 #else
1989     if (mouseEvent.type() != PlatformEvent::MouseReleased)
1990         return false;
1991 #endif
1992
1993     if (!m_frame.page())
1994         return false;
1995     Frame& focusFrame = m_frame.page()->focusController().focusedOrMainFrame();
1996     // Do not paste here if the focus was moved somewhere else.
1997     if (&m_frame == &focusFrame && m_frame.editor().client()->supportsGlobalSelection())
1998         return m_frame.editor().command(ASCIILiteral("PasteGlobalSelection")).execute();
1999
2000     return false;
2001 }
2002
2003 #if ENABLE(DRAG_SUPPORT)
2004
2005 bool EventHandler::dispatchDragEvent(const AtomicString& eventType, Element& dragTarget, const PlatformMouseEvent& event, DataTransfer* dataTransfer)
2006 {
2007     FrameView* view = m_frame.view();
2008
2009     // FIXME: We might want to dispatch a dragleave even if the view is gone.
2010     if (!view)
2011         return false;
2012
2013     view->disableLayerFlushThrottlingTemporarilyForInteraction();
2014     RefPtr<MouseEvent> me = MouseEvent::create(eventType,
2015         true, true, event.timestamp(), m_frame.document()->defaultView(),
2016         0, event.globalPosition().x(), event.globalPosition().y(), event.position().x(), event.position().y(),
2017 #if ENABLE(POINTER_LOCK)
2018         event.movementDelta().x(), event.movementDelta().y(),
2019 #endif
2020         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(),
2021         0, 0, dataTransfer);
2022
2023     dragTarget.dispatchEvent(me.get(), IGNORE_EXCEPTION);
2024     return me->defaultPrevented();
2025 }
2026
2027 static bool targetIsFrame(Node* target, Frame*& frame)
2028 {
2029     if (!target)
2030         return false;
2031
2032     if (!target->hasTagName(frameTag) && !target->hasTagName(iframeTag))
2033         return false;
2034
2035     frame = toHTMLFrameElementBase(target)->contentFrame();
2036
2037     return true;
2038 }
2039
2040 static DragOperation convertDropZoneOperationToDragOperation(const String& dragOperation)
2041 {
2042     if (dragOperation == "copy")
2043         return DragOperationCopy;
2044     if (dragOperation == "move")
2045         return DragOperationMove;
2046     if (dragOperation == "link")
2047         return DragOperationLink;
2048     return DragOperationNone;
2049 }
2050
2051 static String convertDragOperationToDropZoneOperation(DragOperation operation)
2052 {
2053     switch (operation) {
2054     case DragOperationCopy:
2055         return ASCIILiteral("copy");
2056     case DragOperationMove:
2057         return ASCIILiteral("move");
2058     case DragOperationLink:
2059         return ASCIILiteral("link");
2060     default:
2061         return ASCIILiteral("copy");
2062     }
2063 }
2064
2065 static inline bool hasFileOfType(DataTransfer& dataTransfer, const String& type)
2066 {
2067     RefPtr<FileList> fileList = dataTransfer.files();
2068     for (unsigned i = 0; i < fileList->length(); i++) {
2069         if (equalIgnoringCase(fileList->item(i)->type(), type))
2070             return true;
2071     }
2072     return false;
2073 }
2074
2075 static inline bool hasStringOfType(DataTransfer& dataTransfer, const String& type)
2076 {
2077     return !type.isNull() && dataTransfer.types().contains(type);
2078 }
2079
2080 static bool hasDropZoneType(DataTransfer& dataTransfer, const String& keyword)
2081 {
2082     if (keyword.startsWith("file:"))
2083         return hasFileOfType(dataTransfer, keyword.substring(5));
2084
2085     if (keyword.startsWith("string:"))
2086         return hasStringOfType(dataTransfer, keyword.substring(7));
2087
2088     return false;
2089 }
2090
2091 static bool findDropZone(Node* target, DataTransfer* dataTransfer)
2092 {
2093     Element* element = target->isElementNode() ? toElement(target) : target->parentElement();
2094     for (; element; element = element->parentElement()) {
2095         bool matched = false;
2096         String dropZoneStr = element->fastGetAttribute(webkitdropzoneAttr);
2097
2098         if (dropZoneStr.isEmpty())
2099             continue;
2100         
2101         dropZoneStr = dropZoneStr.lower();
2102         
2103         SpaceSplitString keywords(dropZoneStr, false);
2104         if (keywords.isEmpty())
2105             continue;
2106         
2107         DragOperation dragOperation = DragOperationNone;
2108         for (unsigned int i = 0; i < keywords.size(); i++) {
2109             DragOperation op = convertDropZoneOperationToDragOperation(keywords[i]);
2110             if (op != DragOperationNone) {
2111                 if (dragOperation == DragOperationNone)
2112                     dragOperation = op;
2113             } else
2114                 matched = matched || hasDropZoneType(*dataTransfer, keywords[i].string());
2115
2116             if (matched && dragOperation != DragOperationNone)
2117                 break;
2118         }
2119         if (matched) {
2120             dataTransfer->setDropEffect(convertDragOperationToDropZoneOperation(dragOperation));
2121             return true;
2122         }
2123     }
2124     return false;
2125 }
2126     
2127 bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)
2128 {
2129     bool accept = false;
2130
2131     if (!m_frame.view())
2132         return false;
2133
2134     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::DisallowShadowContent);
2135     MouseEventWithHitTestResults mev = prepareMouseEvent(request, event);
2136
2137     RefPtr<Element> newTarget;
2138     if (Node* targetNode = mev.targetNode()) {
2139         // Drag events should never go to non-element nodes (following IE, and proper mouseover/out dispatch)
2140         if (!targetNode->isElementNode())
2141             newTarget = targetNode->parentOrShadowHostElement();
2142         else
2143             newTarget = toElement(targetNode);
2144     }
2145
2146     m_autoscrollController->updateDragAndDrop(newTarget.get(), event.position(), event.timestamp());
2147
2148     if (m_dragTarget != newTarget) {
2149         // FIXME: this ordering was explicitly chosen to match WinIE. However,
2150         // it is sometimes incorrect when dragging within subframes, as seen with
2151         // LayoutTests/fast/events/drag-in-frames.html.
2152         //
2153         // 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>.
2154         Frame* targetFrame;
2155         if (targetIsFrame(newTarget.get(), targetFrame)) {
2156             if (targetFrame)
2157                 accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
2158         } else if (newTarget) {
2159             // As per section 7.9.4 of the HTML 5 spec., we must always fire a drag event before firing a dragenter, dragleave, or dragover event.
2160             if (dragState().source && dragState().shouldDispatchEvents) {
2161                 // for now we don't care if event handler cancels default behavior, since there is none
2162                 dispatchDragSrcEvent(eventNames().dragEvent, event);
2163             }
2164             accept = dispatchDragEvent(eventNames().dragenterEvent, *newTarget, event, dataTransfer);
2165             if (!accept)
2166                 accept = findDropZone(newTarget.get(), dataTransfer);
2167         }
2168
2169         if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
2170             if (targetFrame)
2171                 accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
2172         } else if (m_dragTarget)
2173             dispatchDragEvent(eventNames().dragleaveEvent, *m_dragTarget, event, dataTransfer);
2174
2175         if (newTarget) {
2176             // We do not explicitly call dispatchDragEvent here because it could ultimately result in the appearance that
2177             // two dragover events fired. So, we mark that we should only fire a dragover event on the next call to this function.
2178             m_shouldOnlyFireDragOverEvent = true;
2179         }
2180     } else {
2181         Frame* targetFrame;
2182         if (targetIsFrame(newTarget.get(), targetFrame)) {
2183             if (targetFrame)
2184                 accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
2185         } else if (newTarget) {
2186             // Note, when dealing with sub-frames, we may need to fire only a dragover event as a drag event may have been fired earlier.
2187             if (!m_shouldOnlyFireDragOverEvent && dragState().source && dragState().shouldDispatchEvents) {
2188                 // for now we don't care if event handler cancels default behavior, since there is none
2189                 dispatchDragSrcEvent(eventNames().dragEvent, event);
2190             }
2191             accept = dispatchDragEvent(eventNames().dragoverEvent, *newTarget, event, dataTransfer);
2192             if (!accept)
2193                 accept = findDropZone(newTarget.get(), dataTransfer);
2194             m_shouldOnlyFireDragOverEvent = false;
2195         }
2196     }
2197     m_dragTarget = newTarget.release();
2198     return accept;
2199 }
2200
2201 void EventHandler::cancelDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)
2202 {
2203     Frame* targetFrame;
2204     if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
2205         if (targetFrame)
2206             targetFrame->eventHandler().cancelDragAndDrop(event, dataTransfer);
2207     } else if (m_dragTarget) {
2208         if (dragState().source && dragState().shouldDispatchEvents)
2209             dispatchDragSrcEvent(eventNames().dragEvent, event);
2210         dispatchDragEvent(eventNames().dragleaveEvent, *m_dragTarget, event, dataTransfer);
2211     }
2212     clearDragState();
2213 }
2214
2215 bool EventHandler::performDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)
2216 {
2217     Frame* targetFrame;
2218     bool preventedDefault = false;
2219     if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
2220         if (targetFrame)
2221             preventedDefault = targetFrame->eventHandler().performDragAndDrop(event, dataTransfer);
2222     } else if (m_dragTarget)
2223         preventedDefault = dispatchDragEvent(eventNames().dropEvent, *m_dragTarget, event, dataTransfer);
2224     clearDragState();
2225     return preventedDefault;
2226 }
2227
2228 void EventHandler::clearDragState()
2229 {
2230     stopAutoscrollTimer();
2231     m_dragTarget = nullptr;
2232     m_capturingMouseEventsElement = nullptr;
2233     m_shouldOnlyFireDragOverEvent = false;
2234 #if PLATFORM(COCOA)
2235     m_sendingEventToSubview = false;
2236 #endif
2237 }
2238 #endif // ENABLE(DRAG_SUPPORT)
2239
2240 void EventHandler::setCapturingMouseEventsElement(PassRefPtr<Element> element)
2241 {
2242     m_capturingMouseEventsElement = element;
2243     m_eventHandlerWillResetCapturingMouseEventsElement = false;
2244 }
2245
2246 MouseEventWithHitTestResults EventHandler::prepareMouseEvent(const HitTestRequest& request, const PlatformMouseEvent& mev)
2247 {
2248     ASSERT(m_frame.document());
2249     return m_frame.document()->prepareMouseEvent(request, documentPointForWindowPoint(m_frame, mev.position()), mev);
2250 }
2251
2252 static inline SVGElementInstance* instanceAssociatedWithShadowTreeElement(Node* referenceNode)
2253 {
2254     if (!referenceNode || !referenceNode->isSVGElement())
2255         return 0;
2256
2257     ShadowRoot* shadowRoot = referenceNode->containingShadowRoot();
2258     if (!shadowRoot)
2259         return 0;
2260
2261     Element* shadowTreeParentElement = shadowRoot->hostElement();
2262     if (!shadowTreeParentElement || !shadowTreeParentElement->hasTagName(useTag))
2263         return 0;
2264
2265     return toSVGUseElement(shadowTreeParentElement)->instanceForShadowTreeElement(referenceNode);
2266 }
2267
2268 static RenderElement* nearestCommonHoverAncestor(RenderElement* obj1, RenderElement* obj2)
2269 {
2270     if (!obj1 || !obj2)
2271         return nullptr;
2272
2273     for (RenderElement* currObj1 = obj1; currObj1; currObj1 = currObj1->hoverAncestor()) {
2274         for (RenderElement* currObj2 = obj2; currObj2; currObj2 = currObj2->hoverAncestor()) {
2275             if (currObj1 == currObj2)
2276                 return currObj1;
2277         }
2278     }
2279
2280     return nullptr;
2281 }
2282
2283 static bool hierarchyHasCapturingEventListeners(Element* element, const AtomicString& eventName)
2284 {
2285     for (ContainerNode* curr = element; curr; curr = curr->parentOrShadowHostNode()) {
2286         if (curr->hasCapturingEventListeners(eventName))
2287             return true;
2288     }
2289     return false;
2290 }
2291
2292 void EventHandler::updateMouseEventTargetNode(Node* targetNode, const PlatformMouseEvent& mouseEvent, bool fireMouseOverOut)
2293 {
2294     Element* targetElement = nullptr;
2295     
2296     // If we're capturing, we always go right to that element.
2297     if (m_capturingMouseEventsElement)
2298         targetElement = m_capturingMouseEventsElement.get();
2299     else if (targetNode) {
2300         // If the target node is a non-element, dispatch on the parent. <rdar://problem/4196646>
2301         if (!targetNode->isElementNode())
2302             targetElement = targetNode->parentOrShadowHostElement();
2303         else
2304             targetElement = toElement(targetNode);
2305     }
2306
2307     m_elementUnderMouse = targetElement;
2308     m_instanceUnderMouse = instanceAssociatedWithShadowTreeElement(targetElement);
2309
2310     // <use> shadow tree elements may have been recloned, update node under mouse in any case
2311     if (m_lastInstanceUnderMouse) {
2312         SVGElement* lastCorrespondingElement = m_lastInstanceUnderMouse->correspondingElement();
2313         SVGElement* lastCorrespondingUseElement = m_lastInstanceUnderMouse->correspondingUseElement();
2314
2315         if (lastCorrespondingElement && lastCorrespondingUseElement) {
2316             HashSet<SVGElementInstance*> instances = lastCorrespondingElement->instancesForElement();
2317
2318             // Locate the recloned shadow tree element for our corresponding instance
2319             HashSet<SVGElementInstance*>::iterator end = instances.end();
2320             for (HashSet<SVGElementInstance*>::iterator it = instances.begin(); it != end; ++it) {
2321                 SVGElementInstance* instance = (*it);
2322                 ASSERT(instance->correspondingElement() == lastCorrespondingElement);
2323
2324                 if (instance == m_lastInstanceUnderMouse)
2325                     continue;
2326
2327                 if (instance->correspondingUseElement() != lastCorrespondingUseElement)
2328                     continue;
2329
2330                 SVGElement* shadowTreeElement = instance->shadowTreeElement();
2331                 if (!shadowTreeElement->inDocument() || m_lastElementUnderMouse == shadowTreeElement)
2332                     continue;
2333
2334                 m_lastElementUnderMouse = shadowTreeElement;
2335                 m_lastInstanceUnderMouse = instance;
2336                 break;
2337             }
2338         }
2339     }
2340
2341     // Fire mouseout/mouseover if the mouse has shifted to a different node.
2342     if (fireMouseOverOut) {
2343         RenderLayer* layerForLastNode = layerForNode(m_lastElementUnderMouse.get());
2344         RenderLayer* layerForNodeUnderMouse = layerForNode(m_elementUnderMouse.get());
2345         Page* page = m_frame.page();
2346
2347         if (m_lastElementUnderMouse && (!m_elementUnderMouse || &m_elementUnderMouse->document() != m_frame.document())) {
2348             // The mouse has moved between frames.
2349             if (Frame* frame = m_lastElementUnderMouse->document().frame()) {
2350                 if (FrameView* frameView = frame->view())
2351                     frameView->mouseExitedContentArea();
2352             }
2353         } else if (page && (layerForLastNode && (!layerForNodeUnderMouse || layerForNodeUnderMouse != layerForLastNode))) {
2354             // The mouse has moved between layers.
2355             if (Frame* frame = m_lastElementUnderMouse->document().frame()) {
2356                 if (FrameView* frameView = frame->view()) {
2357                     if (frameView->containsScrollableArea(layerForLastNode))
2358                         layerForLastNode->mouseExitedContentArea();
2359                 }
2360             }
2361         }
2362
2363         if (m_elementUnderMouse && (!m_lastElementUnderMouse || &m_lastElementUnderMouse->document() != m_frame.document())) {
2364             // The mouse has moved between frames.
2365             if (Frame* frame = m_elementUnderMouse->document().frame()) {
2366                 if (FrameView* frameView = frame->view())
2367                     frameView->mouseEnteredContentArea();
2368             }
2369         } else if (page && (layerForNodeUnderMouse && (!layerForLastNode || layerForNodeUnderMouse != layerForLastNode))) {
2370             // The mouse has moved between layers.
2371             if (Frame* frame = m_elementUnderMouse->document().frame()) {
2372                 if (FrameView* frameView = frame->view()) {
2373                     if (frameView->containsScrollableArea(layerForNodeUnderMouse))
2374                         layerForNodeUnderMouse->mouseEnteredContentArea();
2375                 }
2376             }
2377         }
2378
2379         if (m_lastElementUnderMouse && &m_lastElementUnderMouse->document() != m_frame.document()) {
2380             m_lastElementUnderMouse = nullptr;
2381             m_lastScrollbarUnderMouse = 0;
2382             m_lastInstanceUnderMouse = 0;
2383         }
2384
2385         if (m_lastElementUnderMouse != m_elementUnderMouse) {
2386             // mouseenter and mouseleave events are only dispatched if there is a capturing eventhandler on an ancestor
2387             // or a normal eventhandler on the element itself (they don't bubble).
2388             // This optimization is necessary since these events can cause O(n^2) capturing event-handler checks.
2389             bool hasCapturingMouseEnterListener = hierarchyHasCapturingEventListeners(m_elementUnderMouse.get(), eventNames().mouseenterEvent);
2390             bool hasCapturingMouseLeaveListener = hierarchyHasCapturingEventListeners(m_lastElementUnderMouse.get(), eventNames().mouseleaveEvent);
2391
2392             RenderElement* oldHoverRenderer = m_lastElementUnderMouse ? m_lastElementUnderMouse->renderer() : nullptr;
2393             RenderElement* newHoverRenderer = m_elementUnderMouse ? m_elementUnderMouse->renderer() : nullptr;
2394             RenderElement* ancestor = nearestCommonHoverAncestor(oldHoverRenderer, newHoverRenderer);
2395
2396             Vector<Ref<Element>, 32> leftElementsChain;
2397             if (oldHoverRenderer) {
2398                 for (RenderElement* curr = oldHoverRenderer; curr && curr != ancestor; curr = curr->hoverAncestor()) {
2399                     if (Element* element = curr->element())
2400                         leftElementsChain.append(*element);
2401                 }
2402             } else {
2403                 // If the old hovered element is not null but it's renderer is, it was probably detached.
2404                 // In this case, the old hovered element (and its ancestors) must be updated, to ensure it's normal style is re-applied.
2405                 for (Element* element = m_lastElementUnderMouse.get(); element; element = element->parentElement())
2406                     leftElementsChain.append(*element);
2407             }
2408
2409             Vector<Ref<Element>, 32> enteredElementsChain;
2410             const Element* ancestorElement = ancestor ? ancestor->element() : nullptr;
2411             for (RenderElement* curr = newHoverRenderer; curr; curr = curr->hoverAncestor()) {
2412                 if (Element *element = curr->element()) {
2413                     if (element == ancestorElement)
2414                         break;
2415                     enteredElementsChain.append(*element);
2416                 }
2417             }
2418
2419             // Send mouseout event to the old node.
2420             if (m_lastElementUnderMouse)
2421                 m_lastElementUnderMouse->dispatchMouseEvent(mouseEvent, eventNames().mouseoutEvent, 0, m_elementUnderMouse.get());
2422
2423             // Send mouseleave to the node hierarchy no longer under the mouse.
2424             for (size_t i = 0; i < leftElementsChain.size(); ++i) {
2425                 if (hasCapturingMouseLeaveListener || leftElementsChain[i]->hasEventListeners(eventNames().mouseleaveEvent))
2426                     leftElementsChain[i]->dispatchMouseEvent(mouseEvent, eventNames().mouseleaveEvent, 0, m_elementUnderMouse.get());
2427             }
2428
2429             // Send mouseover event to the new node.
2430             if (m_elementUnderMouse)
2431                 m_elementUnderMouse->dispatchMouseEvent(mouseEvent, eventNames().mouseoverEvent, 0, m_lastElementUnderMouse.get());
2432
2433             // Send mouseleave event to the nodes hierarchy under the mouse.
2434             for (size_t i = 0, size = enteredElementsChain.size(); i < size; ++i) {
2435                 if (hasCapturingMouseEnterListener || enteredElementsChain[i]->hasEventListeners(eventNames().mouseenterEvent))
2436                     enteredElementsChain[i]->dispatchMouseEvent(mouseEvent, eventNames().mouseenterEvent, 0, m_lastElementUnderMouse.get());
2437             }
2438         }
2439         m_lastElementUnderMouse = m_elementUnderMouse;
2440         m_lastInstanceUnderMouse = instanceAssociatedWithShadowTreeElement(m_elementUnderMouse.get());
2441     }
2442 }
2443
2444 bool EventHandler::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, bool /*cancelable*/, int clickCount, const PlatformMouseEvent& mouseEvent, bool setUnder)
2445 {
2446     if (FrameView* view = m_frame.view())
2447         view->disableLayerFlushThrottlingTemporarilyForInteraction();
2448
2449     updateMouseEventTargetNode(targetNode, mouseEvent, setUnder);
2450
2451     bool swallowEvent = false;
2452
2453     if (m_elementUnderMouse)
2454         swallowEvent = !(m_elementUnderMouse->dispatchMouseEvent(mouseEvent, eventType, clickCount));
2455
2456     if (!swallowEvent && eventType == eventNames().mousedownEvent) {
2457
2458         // If clicking on a frame scrollbar, do not mess up with content focus.
2459         if (FrameView* view = m_frame.view()) {
2460             if (view->scrollbarAtPoint(mouseEvent.position()))
2461                 return true;
2462         }
2463
2464         // The layout needs to be up to date to determine if an element is focusable.
2465         m_frame.document()->updateLayoutIgnorePendingStylesheets();
2466
2467         // Blur current focus node when a link/button is clicked; this
2468         // is expected by some sites that rely on onChange handlers running
2469         // from form fields before the button click is processed.
2470
2471         Element* element = m_elementUnderMouse.get();
2472
2473         // Walk up the DOM tree to search for an element to focus.
2474         while (element) {
2475             if (element->isMouseFocusable()) {
2476                 // To fix <rdar://problem/4895428> Can't drag selected ToDo, we don't focus a
2477                 // node on mouse down if it's selected and inside a focused node. It will be
2478                 // focused if the user does a mouseup over it, however, because the mouseup
2479                 // will set a selection inside it, which will call setFocuseNodeIfNeeded.
2480                 if (m_frame.selection().isRange()
2481                     && m_frame.selection().toNormalizedRange()->compareNode(element, IGNORE_EXCEPTION) == Range::NODE_INSIDE
2482                     && element->isDescendantOf(m_frame.document()->focusedElement()))
2483                     return true;
2484                     
2485                 break;
2486             }
2487             element = element->parentOrShadowHostElement();
2488         }
2489
2490         // Only change the focus when clicking scrollbars if it can transfered to a mouse focusable node.
2491         if ((!element || !element->isMouseFocusable()) && isInsideScrollbar(mouseEvent.position()))
2492             return false;
2493
2494         // If focus shift is blocked, we eat the event.  Note we should never clear swallowEvent
2495         // if the page already set it (e.g., by canceling default behavior).
2496         if (Page* page = m_frame.page()) {
2497             if (element && element->isMouseFocusable()) {
2498                 if (!page->focusController().setFocusedElement(element, &m_frame))
2499                     swallowEvent = true;
2500             } else if (!element || !element->focused()) {
2501                 if (!page->focusController().setFocusedElement(0, &m_frame))
2502                     swallowEvent = true;
2503             }
2504         }
2505     }
2506
2507     return !swallowEvent;
2508 }
2509
2510 bool EventHandler::isInsideScrollbar(const IntPoint& windowPoint) const
2511 {
2512     if (RenderView* renderView = m_frame.contentRenderer()) {
2513         HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::DisallowShadowContent);
2514         HitTestResult result(windowPoint);
2515         renderView->hitTest(request, result);
2516         return result.scrollbar();
2517     }
2518
2519     return false;
2520 }
2521
2522 #if !PLATFORM(GTK)
2523 bool EventHandler::shouldTurnVerticalTicksIntoHorizontal(const HitTestResult&, const PlatformWheelEvent&) const
2524 {
2525     return false;
2526 }
2527 #endif
2528
2529 #if !PLATFORM(MAC)
2530 void EventHandler::platformPrepareForWheelEvents(const PlatformWheelEvent&, const HitTestResult&, Element*&, ContainerNode*&, ScrollableArea*&, bool&)
2531 {
2532 }
2533
2534 void EventHandler::platformRecordWheelEvent(const PlatformWheelEvent& event)
2535 {
2536     m_recentWheelEventDeltaTracker->recordWheelEventDelta(event);
2537 }
2538
2539 bool EventHandler::platformCompleteWheelEvent(const PlatformWheelEvent& event, ContainerNode*, ScrollableArea*)
2540 {
2541     // We do another check on the frame view because the event handler can run JS which results in the frame getting destroyed.
2542     FrameView* view = m_frame.view();
2543     
2544     bool didHandleEvent = view ? view->wheelEvent(event) : false;
2545     m_isHandlingWheelEvent = false;
2546     return didHandleEvent;
2547 }
2548 #endif
2549
2550 bool EventHandler::handleWheelEvent(const PlatformWheelEvent& e)
2551 {
2552     Document* document = m_frame.document();
2553
2554     if (!document->renderView())
2555         return false;
2556     
2557     RefPtr<FrameView> protector(m_frame.view());
2558
2559     FrameView* view = m_frame.view();
2560     if (!view)
2561         return false;
2562
2563     m_isHandlingWheelEvent = true;
2564     setFrameWasScrolledByUser();
2565     LayoutPoint vPoint = view->windowToContents(e.position());
2566
2567     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::DisallowShadowContent);
2568     HitTestResult result(vPoint);
2569     document->renderView()->hitTest(request, result);
2570
2571     Element* element = result.innerElement();
2572
2573     bool isOverWidget = result.isOverWidget();
2574
2575     ContainerNode* scrollableContainer = nullptr;
2576     ScrollableArea* scrollableArea = nullptr;
2577     platformPrepareForWheelEvents(e, result, element, scrollableContainer, scrollableArea, isOverWidget);
2578
2579     // FIXME: It should not be necessary to do this mutation here.
2580     // Instead, the handlers should know convert vertical scrolls
2581     // appropriately.
2582     PlatformWheelEvent event = e;
2583     if (m_baseEventType == PlatformEvent::NoType && shouldTurnVerticalTicksIntoHorizontal(result, e))
2584         event = event.copyTurningVerticalTicksIntoHorizontalTicks();
2585
2586     platformRecordWheelEvent(event);
2587
2588     if (element) {
2589         // Figure out which view to send the event to.
2590         RenderElement* target = element->renderer();
2591         
2592         if (isOverWidget && target && target->isWidget()) {
2593             Widget* widget = toRenderWidget(target)->widget();
2594             if (widget && passWheelEventToWidget(e, widget)) {
2595                 m_isHandlingWheelEvent = false;
2596                 if (scrollableArea)
2597                     scrollableArea->setScrolledProgrammatically(false);
2598                 return true;
2599             }
2600         }
2601
2602         if (!element->dispatchWheelEvent(event)) {
2603             m_isHandlingWheelEvent = false;
2604
2605             if (scrollableArea && scrollableArea->isScrolledProgrammatically()) {
2606                 // Web developer is controlling scrolling. Don't attempt to latch ourselves:
2607                 clearLatchedState();
2608                 scrollableArea->setScrolledProgrammatically(false);
2609             }
2610
2611             return true;
2612         }
2613     }
2614
2615     if (scrollableArea)
2616         scrollableArea->setScrolledProgrammatically(false);
2617
2618     return platformCompleteWheelEvent(e, scrollableContainer, scrollableArea);
2619 }
2620
2621 void EventHandler::clearLatchedState()
2622 {
2623     m_latchedWheelEventElement = nullptr;
2624 #if PLATFORM(COCOA)
2625     m_latchedScrollableContainer = nullptr;
2626 #endif
2627     m_widgetIsLatched = false;
2628     m_previousWheelScrolledElement = nullptr;
2629 }
2630
2631 void EventHandler::defaultWheelEventHandler(Node* startNode, WheelEvent* wheelEvent)
2632 {
2633     if (!startNode || !wheelEvent)
2634         return;
2635     
2636     Element* stopElement = m_previousWheelScrolledElement.get();
2637     ScrollGranularity granularity = wheelGranularityToScrollGranularity(wheelEvent->deltaMode());
2638     DominantScrollGestureDirection dominantDirection = DominantScrollGestureDirection::None;
2639
2640     // Workaround for scrolling issues <rdar://problem/14758615>.
2641 #if PLATFORM(COCOA)
2642     if (m_recentWheelEventDeltaTracker->isTrackingDeltas())
2643         dominantDirection = m_recentWheelEventDeltaTracker->dominantScrollGestureDirection();
2644 #endif
2645     
2646     // Break up into two scrolls if we need to.  Diagonal movement on 
2647     // a MacBook pro is an example of a 2-dimensional mouse wheel event (where both deltaX and deltaY can be set).
2648     if (dominantDirection != DominantScrollGestureDirection::Vertical && scrollNode(wheelEvent->deltaX(), granularity, ScrollRight, ScrollLeft, startNode, &stopElement, roundedIntPoint(wheelEvent->absoluteLocation())))
2649         wheelEvent->setDefaultHandled();
2650     
2651     if (dominantDirection != DominantScrollGestureDirection::Horizontal && scrollNode(wheelEvent->deltaY(), granularity, ScrollDown, ScrollUp, startNode, &stopElement, roundedIntPoint(wheelEvent->absoluteLocation())))
2652         wheelEvent->setDefaultHandled();
2653     
2654     if (!m_latchedWheelEventElement)
2655         m_previousWheelScrolledElement = stopElement;
2656 }
2657
2658 #if ENABLE(CONTEXT_MENUS)
2659 bool EventHandler::sendContextMenuEvent(const PlatformMouseEvent& event)
2660 {
2661     Document* doc = m_frame.document();
2662     FrameView* v = m_frame.view();
2663     if (!v)
2664         return false;
2665     
2666     // Clear mouse press state to avoid initiating a drag while context menu is up.
2667     m_mousePressed = false;
2668     bool swallowEvent;
2669     LayoutPoint viewportPos = v->windowToContents(event.position());
2670     HitTestRequest request(HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
2671     MouseEventWithHitTestResults mev = doc->prepareMouseEvent(request, viewportPos, event);
2672
2673     if (m_frame.editor().behavior().shouldSelectOnContextualMenuClick()
2674         && !m_frame.selection().contains(viewportPos)
2675         && !mev.scrollbar()
2676         // FIXME: In the editable case, word selection sometimes selects content that isn't underneath the mouse.
2677         // If the selection is non-editable, we do word selection to make it easier to use the contextual menu items
2678         // available for text selections.  But only if we're above text.
2679         && (m_frame.selection().selection().isContentEditable() || (mev.targetNode() && mev.targetNode()->isTextNode()))) {
2680         m_mouseDownMayStartSelect = true; // context menu events are always allowed to perform a selection
2681         selectClosestWordOrLinkFromMouseEvent(mev);
2682     }
2683
2684     swallowEvent = !dispatchMouseEvent(eventNames().contextmenuEvent, mev.targetNode(), true, 0, event, false);
2685     
2686     return swallowEvent;
2687 }
2688
2689 bool EventHandler::sendContextMenuEventForKey()
2690 {
2691     FrameView* view = m_frame.view();
2692     if (!view)
2693         return false;
2694
2695     Document* doc = m_frame.document();
2696     if (!doc)
2697         return false;
2698
2699     // Clear mouse press state to avoid initiating a drag while context menu is up.
2700     m_mousePressed = false;
2701
2702     static const int kContextMenuMargin = 1;
2703
2704 #if OS(WINDOWS) && !OS(WINCE)
2705     int rightAligned = ::GetSystemMetrics(SM_MENUDROPALIGNMENT);
2706 #else
2707     int rightAligned = 0;
2708 #endif
2709     IntPoint location;
2710
2711     Element* focusedElement = doc->focusedElement();
2712     const VisibleSelection& selection = m_frame.selection().selection();
2713     Position start = selection.start();
2714
2715     if (start.deprecatedNode() && (selection.rootEditableElement() || selection.isRange())) {
2716         RefPtr<Range> selectionRange = selection.toNormalizedRange();
2717         IntRect firstRect = m_frame.editor().firstRectForRange(selectionRange.get());
2718
2719         int x = rightAligned ? firstRect.maxX() : firstRect.x();
2720         // In a multiline edit, firstRect.maxY() would endup on the next line, so -1.
2721         int y = firstRect.maxY() ? firstRect.maxY() - 1 : 0;
2722         location = IntPoint(x, y);
2723     } else if (focusedElement) {
2724         RenderBoxModelObject* box = focusedElement->renderBoxModelObject();
2725         if (!box)
2726             return false;
2727         IntRect clippedRect = box->pixelSnappedAbsoluteClippedOverflowRect();
2728         location = IntPoint(clippedRect.x(), clippedRect.maxY() - 1);
2729     } else {
2730         location = IntPoint(
2731             rightAligned ? view->contentsWidth() - kContextMenuMargin : kContextMenuMargin,
2732             kContextMenuMargin);
2733     }
2734
2735     m_frame.view()->setCursor(pointerCursor());
2736
2737     IntPoint position = view->contentsToRootView(location);
2738     IntPoint globalPosition = view->hostWindow()->rootViewToScreen(IntRect(position, IntSize())).location();
2739
2740     Node* targetNode = doc->focusedElement();
2741     if (!targetNode)
2742         targetNode = doc;
2743
2744     // Use the focused node as the target for hover and active.
2745     HitTestResult result(position);
2746     result.setInnerNode(targetNode);
2747     doc->updateHoverActiveState(HitTestRequest::Active | HitTestRequest::DisallowShadowContent, result.innerElement());
2748
2749     // The contextmenu event is a mouse event even when invoked using the keyboard.
2750     // This is required for web compatibility.
2751
2752 #if OS(WINDOWS)
2753     PlatformEvent::Type eventType = PlatformEvent::MouseReleased;
2754 #else
2755     PlatformEvent::Type eventType = PlatformEvent::MousePressed;
2756 #endif
2757
2758     PlatformMouseEvent mouseEvent(position, globalPosition, RightButton, eventType, 1, false, false, false, false, WTF::currentTime());
2759
2760     return !dispatchMouseEvent(eventNames().contextmenuEvent, targetNode, true, 0, mouseEvent, false);
2761 }
2762 #endif // ENABLE(CONTEXT_MENUS)
2763
2764 void EventHandler::scheduleHoverStateUpdate()
2765 {
2766     if (!m_hoverTimer.isActive())
2767         m_hoverTimer.startOneShot(0);
2768 }
2769
2770 #if ENABLE(CURSOR_SUPPORT)
2771 void EventHandler::scheduleCursorUpdate()
2772 {
2773     if (!m_cursorUpdateTimer.isActive())
2774         m_cursorUpdateTimer.startOneShot(cursorUpdateInterval);
2775 }
2776 #endif
2777
2778 void EventHandler::dispatchFakeMouseMoveEventSoon()
2779 {
2780 #if !ENABLE(IOS_TOUCH_EVENTS)
2781     if (m_mousePressed)
2782         return;
2783
2784     if (m_mousePositionIsUnknown)
2785         return;
2786
2787     if (!m_frame.settings().deviceSupportsMouse())
2788         return;
2789
2790     // If the content has ever taken longer than fakeMouseMoveShortInterval we
2791     // reschedule the timer and use a longer time. This will cause the content
2792     // to receive these moves only after the user is done scrolling, reducing
2793     // pauses during the scroll.
2794     if (m_maxMouseMovedDuration > fakeMouseMoveDurationThreshold) {
2795         if (m_fakeMouseMoveEventTimer.isActive())
2796             m_fakeMouseMoveEventTimer.stop();
2797         m_fakeMouseMoveEventTimer.startOneShot(fakeMouseMoveLongInterval);
2798     } else {
2799         if (!m_fakeMouseMoveEventTimer.isActive())
2800             m_fakeMouseMoveEventTimer.startOneShot(fakeMouseMoveShortInterval);
2801     }
2802 #endif
2803 }
2804
2805 void EventHandler::dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad& quad)
2806 {
2807 #if ENABLE(IOS_TOUCH_EVENTS)
2808     UNUSED_PARAM(quad);
2809 #else
2810     FrameView* view = m_frame.view();
2811     if (!view)
2812         return;
2813
2814     if (!quad.containsPoint(view->windowToContents(m_lastKnownMousePosition)))
2815         return;
2816
2817     dispatchFakeMouseMoveEventSoon();
2818 #endif
2819 }
2820
2821 #if !ENABLE(IOS_TOUCH_EVENTS)
2822 void EventHandler::cancelFakeMouseMoveEvent()
2823 {
2824     m_fakeMouseMoveEventTimer.stop();
2825 }
2826
2827 void EventHandler::fakeMouseMoveEventTimerFired(Timer<EventHandler>& timer)
2828 {
2829     ASSERT_UNUSED(timer, &timer == &m_fakeMouseMoveEventTimer);
2830     ASSERT(!m_mousePressed);
2831
2832     if (!m_frame.settings().deviceSupportsMouse())
2833         return;
2834
2835     FrameView* view = m_frame.view();
2836     if (!view)
2837         return;
2838
2839     if (!m_frame.page() || !m_frame.page()->isVisible() || !m_frame.page()->focusController().isActive())
2840         return;
2841
2842     bool shiftKey;
2843     bool ctrlKey;
2844     bool altKey;
2845     bool metaKey;
2846     PlatformKeyboardEvent::getCurrentModifierState(shiftKey, ctrlKey, altKey, metaKey);
2847     PlatformMouseEvent fakeMouseMoveEvent(m_lastKnownMousePosition, m_lastKnownMouseGlobalPosition, NoButton, PlatformEvent::MouseMoved, 0, shiftKey, ctrlKey, altKey, metaKey, currentTime());
2848     mouseMoved(fakeMouseMoveEvent);
2849 }
2850 #endif // !ENABLE(IOS_TOUCH_EVENTS)
2851
2852 void EventHandler::setResizingFrameSet(HTMLFrameSetElement* frameSet)
2853 {
2854     m_frameSetBeingResized = frameSet;
2855 }
2856
2857 void EventHandler::resizeLayerDestroyed()
2858 {
2859     ASSERT(m_resizeLayer);
2860     m_resizeLayer = 0;
2861 }
2862
2863 void EventHandler::hoverTimerFired(Timer<EventHandler>&)
2864 {
2865     m_hoverTimer.stop();
2866
2867     ASSERT(m_frame.document());
2868
2869     if (RenderView* renderer = m_frame.contentRenderer()) {
2870         if (FrameView* view = m_frame.view()) {
2871             HitTestRequest request(HitTestRequest::Move | HitTestRequest::DisallowShadowContent);
2872             HitTestResult result(view->windowToContents(m_lastKnownMousePosition));
2873             renderer->hitTest(request, result);
2874             m_frame.document()->updateHoverActiveState(request, result.innerElement());
2875         }
2876     }
2877 }
2878
2879 bool EventHandler::handleAccessKey(const PlatformKeyboardEvent& evt)
2880 {
2881     // FIXME: Ignoring the state of Shift key is what neither IE nor Firefox do.
2882     // IE matches lower and upper case access keys regardless of Shift key state - but if both upper and
2883     // lower case variants are present in a document, the correct element is matched based on Shift key state.
2884     // Firefox only matches an access key if Shift is not pressed, and does that case-insensitively.
2885     ASSERT(!(accessKeyModifiers() & PlatformEvent::ShiftKey));
2886     if ((evt.modifiers() & ~PlatformEvent::ShiftKey) != accessKeyModifiers())
2887         return false;
2888     String key = evt.unmodifiedText();
2889     Element* elem = m_frame.document()->getElementByAccessKey(key.lower());
2890     if (!elem)
2891         return false;
2892     elem->accessKeyAction(false);
2893     return true;
2894 }
2895
2896 #if !PLATFORM(MAC)
2897 bool EventHandler::needsKeyboardEventDisambiguationQuirks() const
2898 {
2899     return false;
2900 }
2901 #endif
2902
2903 #if ENABLE(FULLSCREEN_API)
2904 bool EventHandler::isKeyEventAllowedInFullScreen(const PlatformKeyboardEvent& keyEvent) const
2905 {
2906     Document* document = m_frame.document();
2907     if (document->webkitFullScreenKeyboardInputAllowed())
2908         return true;
2909
2910     if (keyEvent.type() == PlatformKeyboardEvent::Char) {
2911         if (keyEvent.text().length() != 1)
2912             return false;
2913         UChar character = keyEvent.text()[0];
2914         return character == ' ';
2915     }
2916
2917     int keyCode = keyEvent.windowsVirtualKeyCode();
2918     return (keyCode >= VK_BACK && keyCode <= VK_CAPITAL)
2919         || (keyCode >= VK_SPACE && keyCode <= VK_DELETE)
2920         || (keyCode >= VK_OEM_1 && keyCode <= VK_OEM_PLUS)
2921         || (keyCode >= VK_MULTIPLY && keyCode <= VK_OEM_8);
2922 }
2923 #endif
2924
2925 bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
2926 {
2927     RefPtr<FrameView> protector(m_frame.view());
2928
2929 #if ENABLE(FULLSCREEN_API)
2930     if (m_frame.document()->webkitIsFullScreen() && !isKeyEventAllowedInFullScreen(initialKeyEvent))
2931         return false;
2932 #endif
2933
2934     if (initialKeyEvent.windowsVirtualKeyCode() == VK_CAPITAL)
2935         capsLockStateMayHaveChanged();
2936
2937 #if ENABLE(PAN_SCROLLING)
2938     if (m_frame.mainFrame().eventHandler().panScrollInProgress()) {
2939         // If a key is pressed while the panScroll is in progress then we want to stop
2940         if (initialKeyEvent.type() == PlatformEvent::KeyDown || initialKeyEvent.type() == PlatformEvent::RawKeyDown)
2941             stopAutoscrollTimer();
2942
2943         // If we were in panscroll mode, we swallow the key event
2944         return true;
2945     }
2946 #endif
2947
2948     // Check for cases where we are too early for events -- possible unmatched key up
2949     // from pressing return in the location bar.
2950     RefPtr<Element> element = eventTargetElementForDocument(m_frame.document());
2951     if (!element)
2952         return false;
2953
2954     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
2955     UserTypingGestureIndicator typingGestureIndicator(m_frame);
2956
2957     if (FrameView* view = m_frame.view())
2958         view->disableLayerFlushThrottlingTemporarilyForInteraction();
2959
2960     // FIXME (bug 68185): this call should be made at another abstraction layer
2961     m_frame.loader().resetMultipleFormSubmissionProtection();
2962
2963     // In IE, access keys are special, they are handled after default keydown processing, but cannot be canceled - this is hard to match.
2964     // On Mac OS X, we process them before dispatching keydown, as the default keydown handler implements Emacs key bindings, which may conflict
2965     // with access keys. Then we dispatch keydown, but suppress its default handling.
2966     // On Windows, WebKit explicitly calls handleAccessKey() instead of dispatching a keypress event for WM_SYSCHAR messages.
2967     // Other platforms currently match either Mac or Windows behavior, depending on whether they send combined KeyDown events.
2968     bool matchedAnAccessKey = false;
2969     if (initialKeyEvent.type() == PlatformEvent::KeyDown)
2970         matchedAnAccessKey = handleAccessKey(initialKeyEvent);
2971
2972     // FIXME: it would be fair to let an input method handle KeyUp events before DOM dispatch.
2973     if (initialKeyEvent.type() == PlatformEvent::KeyUp || initialKeyEvent.type() == PlatformEvent::Char)
2974         return !element->dispatchKeyEvent(initialKeyEvent);
2975
2976     bool backwardCompatibilityMode = needsKeyboardEventDisambiguationQuirks();
2977
2978     PlatformKeyboardEvent keyDownEvent = initialKeyEvent;    
2979     if (keyDownEvent.type() != PlatformEvent::RawKeyDown)
2980         keyDownEvent.disambiguateKeyDownEvent(PlatformEvent::RawKeyDown, backwardCompatibilityMode);
2981     RefPtr<KeyboardEvent> keydown = KeyboardEvent::create(keyDownEvent, m_frame.document()->defaultView());
2982     if (matchedAnAccessKey)
2983         keydown->setDefaultPrevented(true);
2984     keydown->setTarget(element);
2985
2986     if (initialKeyEvent.type() == PlatformEvent::RawKeyDown) {
2987         element->dispatchEvent(keydown, IGNORE_EXCEPTION);
2988         // If frame changed as a result of keydown dispatch, then return true to avoid sending a subsequent keypress message to the new frame.
2989         bool changedFocusedFrame = m_frame.page() && &m_frame != &m_frame.page()->focusController().focusedOrMainFrame();
2990         return keydown->defaultHandled() || keydown->defaultPrevented() || changedFocusedFrame;
2991     }
2992
2993     // Run input method in advance of DOM event handling.  This may result in the IM
2994     // modifying the page prior the keydown event, but this behaviour is necessary
2995     // in order to match IE:
2996     // 1. preventing default handling of keydown and keypress events has no effect on IM input;
2997     // 2. if an input method handles the event, its keyCode is set to 229 in keydown event.
2998     m_frame.editor().handleInputMethodKeydown(keydown.get());
2999     
3000     bool handledByInputMethod = keydown->defaultHandled();
3001     
3002     if (handledByInputMethod) {
3003         keyDownEvent.setWindowsVirtualKeyCode(CompositionEventKeyCode);
3004         keydown = KeyboardEvent::create(keyDownEvent, m_frame.document()->defaultView());
3005         keydown->setTarget(element);
3006         keydown->setDefaultHandled();
3007     }
3008
3009     element->dispatchEvent(keydown, IGNORE_EXCEPTION);
3010     // If frame changed as a result of keydown dispatch, then return early to avoid sending a subsequent keypress message to the new frame.
3011     bool changedFocusedFrame = m_frame.page() && &m_frame != &m_frame.page()->focusController().focusedOrMainFrame();
3012     bool keydownResult = keydown->defaultHandled() || keydown->defaultPrevented() || changedFocusedFrame;
3013     if (handledByInputMethod || (keydownResult && !backwardCompatibilityMode))
3014         return keydownResult;
3015     
3016     // Focus may have changed during keydown handling, so refetch element.
3017     // But if we are dispatching a fake backward compatibility keypress, then we pretend that the keypress happened on the original element.
3018     if (!keydownResult) {
3019         element = eventTargetElementForDocument(m_frame.document());
3020         if (!element)
3021             return false;
3022     }
3023
3024     PlatformKeyboardEvent keyPressEvent = initialKeyEvent;
3025     keyPressEvent.disambiguateKeyDownEvent(PlatformEvent::Char, backwardCompatibilityMode);
3026     if (keyPressEvent.text().isEmpty())
3027         return keydownResult;
3028     RefPtr<KeyboardEvent> keypress = KeyboardEvent::create(keyPressEvent, m_frame.document()->defaultView());
3029     keypress->setTarget(element);
3030     if (keydownResult)
3031         keypress->setDefaultPrevented(true);
3032 #if PLATFORM(COCOA)
3033     keypress->keypressCommands() = keydown->keypressCommands();
3034 #endif
3035     element->dispatchEvent(keypress, IGNORE_EXCEPTION);
3036
3037     return keydownResult || keypress->defaultPrevented() || keypress->defaultHandled();
3038 }
3039
3040 static FocusDirection focusDirectionForKey(const AtomicString& keyIdentifier)
3041 {
3042     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, Down, ("Down", AtomicString::ConstructFromLiteral));
3043     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, Up, ("Up", AtomicString::ConstructFromLiteral));
3044     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, Left, ("Left", AtomicString::ConstructFromLiteral));
3045     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, Right, ("Right", AtomicString::ConstructFromLiteral));
3046
3047     FocusDirection retVal = FocusDirectionNone;
3048
3049     if (keyIdentifier == Down)
3050         retVal = FocusDirectionDown;
3051     else if (keyIdentifier == Up)
3052         retVal = FocusDirectionUp;
3053     else if (keyIdentifier == Left)
3054         retVal = FocusDirectionLeft;
3055     else if (keyIdentifier == Right)
3056         retVal = FocusDirectionRight;
3057
3058     return retVal;
3059 }
3060
3061 static void setInitialKeyboardSelection(Frame& frame, SelectionDirection direction)
3062 {
3063     Document* document = frame.document();
3064     if (!document)
3065         return;
3066
3067     FrameSelection& selection = frame.selection();
3068
3069     if (!selection.isNone())
3070         return;
3071
3072     Element* focusedElement = document->focusedElement();
3073     VisiblePosition visiblePosition;
3074
3075     switch (direction) {
3076     case DirectionBackward:
3077     case DirectionLeft:
3078         if (focusedElement)
3079             visiblePosition = VisiblePosition(positionBeforeNode(focusedElement));
3080         else
3081             visiblePosition = endOfDocument(document);
3082         break;
3083     case DirectionForward:
3084     case DirectionRight:
3085         if (focusedElement)
3086             visiblePosition = VisiblePosition(positionAfterNode(focusedElement));
3087         else
3088             visiblePosition = startOfDocument(document);
3089         break;
3090     }
3091
3092     selection.setSelection(visiblePosition, FrameSelection::defaultSetSelectionOptions(UserTriggered));
3093 }
3094
3095 static void handleKeyboardSelectionMovement(Frame& frame, KeyboardEvent* event)
3096 {
3097     if (!event)
3098         return;
3099
3100     FrameSelection& selection = frame.selection();
3101
3102     bool isCommanded = event->getModifierState("Meta");
3103     bool isOptioned = event->getModifierState("Alt");
3104     bool isSelection = !selection.isNone();
3105
3106     FrameSelection::EAlteration alternation = event->getModifierState("Shift") ? FrameSelection::AlterationExtend : FrameSelection::AlterationMove;
3107     SelectionDirection direction = DirectionForward;
3108     TextGranularity granularity = CharacterGranularity;
3109
3110     switch (focusDirectionForKey(event->keyIdentifier())) {
3111     case FocusDirectionNone:
3112         return;
3113     case FocusDirectionForward:
3114     case FocusDirectionBackward:
3115         ASSERT_NOT_REACHED();
3116         return;
3117     case FocusDirectionUp:
3118         direction = DirectionBackward;
3119         granularity = isCommanded ? DocumentBoundary : LineGranularity;
3120         break;
3121     case FocusDirectionDown:
3122         direction = DirectionForward;
3123         granularity = isCommanded ? DocumentBoundary : LineGranularity;
3124         break;
3125     case FocusDirectionLeft:
3126         direction = DirectionLeft;
3127         granularity = (isCommanded) ? LineBoundary : (isOptioned) ? WordGranularity : CharacterGranularity;
3128         break;
3129     case FocusDirectionRight:
3130         direction = DirectionRight;
3131         granularity = (isCommanded) ? LineBoundary : (isOptioned) ? WordGranularity : CharacterGranularity;
3132         break;
3133     }
3134
3135     if (isSelection)
3136         selection.modify(alternation, direction, granularity, UserTriggered);
3137     else
3138         setInitialKeyboardSelection(frame, direction);
3139
3140     event->setDefaultHandled();
3141 }
3142
3143 void EventHandler::handleKeyboardSelectionMovementForAccessibility(KeyboardEvent* event)
3144 {
3145     if (event->type() == eventNames().keydownEvent) {
3146         if (AXObjectCache::accessibilityEnhancedUserInterfaceEnabled())
3147             handleKeyboardSelectionMovement(m_frame, event);
3148     }
3149 }
3150
3151 void EventHandler::defaultKeyboardEventHandler(KeyboardEvent* event)
3152 {
3153     if (event->type() == eventNames().keydownEvent) {
3154         m_frame.editor().handleKeyboardEvent(event);
3155         if (event->defaultHandled())
3156             return;
3157         if (event->keyIdentifier() == "U+0009")
3158             defaultTabEventHandler(event);
3159         else if (event->keyIdentifier() == "U+0008")
3160             defaultBackspaceEventHandler(event);
3161         else {
3162             FocusDirection direction = focusDirectionForKey(event->keyIdentifier());
3163             if (direction != FocusDirectionNone)
3164                 defaultArrowEventHandler(direction, event);
3165         }
3166
3167         handleKeyboardSelectionMovementForAccessibility(event);
3168     }
3169     if (event->type() == eventNames().keypressEvent) {
3170         m_frame.editor().handleKeyboardEvent(event);
3171         if (event->defaultHandled())
3172             return;
3173         if (event->charCode() == ' ')
3174             defaultSpaceEventHandler(event);
3175     }
3176 }
3177
3178 #if ENABLE(DRAG_SUPPORT)
3179 bool EventHandler::dragHysteresisExceeded(const IntPoint& floatDragViewportLocation) const
3180 {
3181     FloatPoint dragViewportLocation(floatDragViewportLocation.x(), floatDragViewportLocation.y());
3182     return dragHysteresisExceeded(dragViewportLocation);
3183 }
3184
3185 bool EventHandler::dragHysteresisExceeded(const FloatPoint& dragViewportLocation) const
3186 {
3187     FrameView* view = m_frame.view();
3188     if (!view)
3189         return false;
3190     IntPoint dragLocation = view->windowToContents(flooredIntPoint(dragViewportLocation));
3191     IntSize delta = dragLocation - m_mouseDownPos;
3192     
3193     int threshold = GeneralDragHysteresis;
3194     switch (dragState().type) {
3195     case DragSourceActionSelection:
3196         threshold = TextDragHysteresis;
3197         break;
3198     case DragSourceActionImage:
3199         threshold = ImageDragHysteresis;
3200         break;
3201     case DragSourceActionLink:
3202         threshold = LinkDragHysteresis;
3203         break;
3204     case DragSourceActionDHTML:
3205         break;
3206     case DragSourceActionNone:
3207     case DragSourceActionAny:
3208         ASSERT_NOT_REACHED();
3209     }
3210     
3211     return abs(delta.width()) >= threshold || abs(delta.height()) >= threshold;
3212 }
3213     
3214 void EventHandler::freeDataTransfer()
3215 {
3216     if (!dragState().dataTransfer)
3217         return;
3218     dragState().dataTransfer->setAccessPolicy(DataTransferAccessPolicy::Numb);
3219     dragState().dataTransfer = 0;
3220 }
3221
3222 void EventHandler::dragSourceEndedAt(const PlatformMouseEvent& event, DragOperation operation)
3223 {
3224     // Send a hit test request so that RenderLayer gets a chance to update the :hover and :active pseudoclasses.
3225     HitTestRequest request(HitTestRequest::Release | HitTestRequest::DisallowShadowContent);
3226     prepareMouseEvent(request, event);
3227
3228     if (dragState().source && dragState().shouldDispatchEvents) {
3229         dragState().dataTransfer->setDestinationOperation(operation);
3230         // For now we don't care if event handler cancels default behavior, since there is no default behavior.
3231         dispatchDragSrcEvent(eventNames().dragendEvent, event);
3232     }
3233     freeDataTransfer();
3234     dragState().source = 0;
3235     // In case the drag was ended due to an escape key press we need to ensure
3236     // that consecutive mousemove events don't reinitiate the drag and drop.
3237     m_mouseDownMayStartDrag = false;
3238 }
3239
3240 void EventHandler::updateDragStateAfterEditDragIfNeeded(Element* rootEditableElement)
3241 {
3242     // If inserting the dragged contents removed the drag source, we still want to fire dragend at the root editable element.
3243     if (dragState().source && !dragState().source->inDocument())
3244         dragState().source = rootEditableElement;
3245 }
3246
3247 // Return value indicates if we should continue "default processing", i.e., whether event handler canceled.
3248 bool EventHandler::dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent& event)
3249 {
3250     return !dispatchDragEvent(eventType, *dragState().source, event, dragState().dataTransfer.get());
3251 }
3252     
3253 static bool ExactlyOneBitSet(DragSourceAction n)
3254 {
3255     return n && !(n & (n - 1));
3256 }
3257
3258 bool EventHandler::handleDrag(const MouseEventWithHitTestResults& event, CheckDragHysteresis checkDragHysteresis)
3259 {
3260     if (event.event().button() != LeftButton || event.event().type() != PlatformEvent::MouseMoved) {
3261         // If we allowed the other side of the bridge to handle a drag
3262         // last time, then m_mousePressed might still be set. So we
3263         // clear it now to make sure the next move after a drag
3264         // doesn't look like a drag.
3265         m_mousePressed = false;
3266         return false;
3267     }
3268     
3269     if (eventLoopHandleMouseDragged(event))
3270         return true;
3271     
3272     // Careful that the drag starting logic stays in sync with eventMayStartDrag()
3273     
3274     if (m_mouseDownMayStartDrag && !dragState().source) {
3275         dragState().shouldDispatchEvents = (updateDragSourceActionsAllowed() & DragSourceActionDHTML);
3276
3277         // try to find an element that wants to be dragged
3278         HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::DisallowShadowContent);
3279         HitTestResult result(m_mouseDownPos);
3280         m_frame.contentRenderer()->hitTest(request, result);
3281         if (m_frame.page())
3282             dragState().source = m_frame.page()->dragController().draggableElement(&m_frame, result.innerElement(), m_mouseDownPos, dragState());
3283         
3284         if (!dragState().source)
3285             m_mouseDownMayStartDrag = false; // no element is draggable
3286         else
3287             m_dragMayStartSelectionInstead = (dragState().type & DragSourceActionSelection);
3288     }
3289     
3290     // For drags starting in the selection, the user must wait between the mousedown and mousedrag,
3291     // or else we bail on the dragging stuff and allow selection to occur
3292     if (m_mouseDownMayStartDrag && m_dragMayStartSelectionInstead && (dragState().type & DragSourceActionSelection) && event.event().timestamp() - m_mouseDownTimestamp < TextDragDelay) {
3293         ASSERT(event.event().type() == PlatformEvent::MouseMoved);
3294         if ((dragState().type & DragSourceActionImage)) {
3295             // ... unless the mouse is over an image, then we start dragging just the image
3296             dragState().type = DragSourceActionImage;
3297         } else if (!(dragState().type & (DragSourceActionDHTML | DragSourceActionLink))) {
3298             // ... but only bail if we're not over an unselectable element.
3299             m_mouseDownMayStartDrag = false;
3300             dragState().source = 0;
3301             // ... but if this was the first click in the window, we don't even want to start selection
3302             if (eventActivatedView(event.event()))
3303                 m_mouseDownMayStartSelect = false;
3304         } else {
3305             // Prevent the following case from occuring:
3306             // 1. User starts a drag immediately after mouse down over an unselectable element.
3307             // 2. We enter this block and decided that since we're over an unselectable element, don't cancel the drag.
3308             // 3. The drag gets resolved as a potential selection drag below /but/ we haven't exceeded the drag hysteresis yet.
3309             // 4. We enter this block again, and since it's now marked as a selection drag, we cancel the drag.
3310             m_dragMayStartSelectionInstead = false;
3311         }
3312     }
3313     
3314     if (!m_mouseDownMayStartDrag)
3315         return !mouseDownMayStartSelect() && !m_mouseDownMayStartAutoscroll;
3316     
3317     if (!ExactlyOneBitSet(dragState().type)) {
3318         ASSERT((dragState().type & DragSourceActionSelection));
3319         ASSERT((dragState().type & ~DragSourceActionSelection) == DragSourceActionDHTML
3320             || (dragState().type & ~DragSourceActionSelection) == DragSourceActionImage
3321             || (dragState().type & ~DragSourceActionSelection) == DragSourceActionLink);
3322         dragState().type = DragSourceActionSelection;
3323     }
3324
3325     // We are starting a text/image/url drag, so the cursor should be an arrow
3326     if (FrameView* view = m_frame.view()) {
3327         // FIXME <rdar://7577595>: Custom cursors aren't supported during drag and drop (default to pointer).
3328         view->setCursor(pointerCursor());
3329     }
3330
3331     if (checkDragHysteresis == ShouldCheckDragHysteresis && !dragHysteresisExceeded(event.event().position()))
3332         return true;
3333     
3334     // Once we're past the hysteresis point, we don't want to treat this gesture as a click
3335     invalidateClick();
3336     
3337     DragOperation srcOp = DragOperationNone;      
3338     
3339     // This does work only if we missed a dragEnd. Do it anyway, just to make sure the old dataTransfer gets numbed.
3340     freeDataTransfer();
3341
3342     dragState().dataTransfer = createDraggingDataTransfer();
3343     
3344     if (dragState().shouldDispatchEvents) {
3345         // Check to see if the is a DOM based drag. If it is, get the DOM specified drag image and offset.
3346         if (dragState().type == DragSourceActionDHTML) {
3347             if (RenderObject* renderer = dragState().source->renderer()) {
3348                 // FIXME: This doesn't work correctly with transforms.
3349                 FloatPoint absPos = renderer->localToAbsolute();
3350                 IntSize delta = m_mouseDownPos - roundedIntPoint(absPos);
3351                 dragState().dataTransfer->setDragImage(dragState().source.get(), delta.width(), delta.height());
3352             } else {
3353                 // The renderer has disappeared, this can happen if the onStartDrag handler has hidden
3354                 // the element in some way.  In this case we just kill the drag.
3355                 m_mouseDownMayStartDrag = false;
3356                 goto cleanupDrag;
3357             }
3358         } 
3359         
3360         m_mouseDownMayStartDrag = dispatchDragSrcEvent(eventNames().dragstartEvent, m_mouseDown)
3361             && !m_frame.selection().selection().isInPasswordField();
3362         
3363         // Invalidate dataTransfer here against anymore pasteboard writing for security. The drag
3364         // image can still be changed as we drag, but not the pasteboard data.
3365         dragState().dataTransfer->setAccessPolicy(DataTransferAccessPolicy::ImageWritable);
3366         
3367         if (m_mouseDownMayStartDrag) {
3368             // Gather values from DHTML element, if it set any.
3369             srcOp = dragState().dataTransfer->sourceOperation();
3370             
3371             // Yuck, a draggedImage:moveTo: message can be fired as a result of kicking off the
3372             // drag with dragImage! Because of that dumb reentrancy, we may think we've not
3373             // started the drag when that happens. So we have to assume it's started before we kick it off.
3374             dragState().dataTransfer->setDragHasStarted();
3375         }
3376     }
3377     
3378     if (m_mouseDownMayStartDrag) {
3379         Page* page = m_frame.page();
3380         m_didStartDrag = page && page->dragController().startDrag(m_frame, dragState(), srcOp, event.event(), m_mouseDownPos);
3381         // In WebKit2 we could re-enter this code and start another drag.
3382         // On OS X this causes problems with the ownership of the pasteboard and the promised types.
3383         if (m_didStartDrag) {
3384             m_mouseDownMayStartDrag = false;
3385             return true;
3386         }
3387         if (dragState().source && dragState().shouldDispatchEvents) {
3388             // Drag was canned at the last minute. We owe dragSource a dragend event.
3389             dispatchDragSrcEvent(eventNames().dragendEvent, event.event());
3390             m_mouseDownMayStartDrag = false;
3391         }
3392     } 
3393
3394 cleanupDrag:
3395     if (!m_mouseDownMayStartDrag) {
3396         // Something failed to start the drag, clean up.
3397         freeDataTransfer();
3398         dragState().source = 0;
3399     }
3400     
3401     // No more default handling (like selection), whether we're past the hysteresis bounds or not
3402     return true;
3403 }
3404 #endif // ENABLE(DRAG_SUPPORT)
3405   
3406 bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, TextEventInputType inputType)
3407 {
3408     // Platforms should differentiate real commands like selectAll from text input in disguise (like insertNewline),
3409     // and avoid dispatching text input events from keydown default handlers.
3410     ASSERT(!underlyingEvent || !underlyingEvent->isKeyboardEvent() || toKeyboardEvent(underlyingEvent)->type() == eventNames().keypressEvent);
3411
3412     EventTarget* target;
3413     if (underlyingEvent)
3414         target = underlyingEvent->target();
3415     else
3416         target = eventTargetElementForDocument(m_frame.document());
3417     if (!target)
3418         return false;
3419     
3420     if (FrameView* view = m_frame.view())
3421         view->disableLayerFlushThrottlingTemporarilyForInteraction();
3422
3423     RefPtr<TextEvent> event = TextEvent::create(m_frame.document()->domWindow(), text, inputType);
3424     event->setUnderlyingEvent(underlyingEvent);
3425
3426     target->dispatchEvent(event, IGNORE_EXCEPTION);
3427     return event->defaultHandled();
3428 }
3429     
3430 bool EventHandler::isKeyboardOptionTab(KeyboardEvent* event)
3431 {
3432     return event
3433         && (event->type() == eventNames().keydownEvent || event->type() == eventNames().keypressEvent)
3434         && event->altKey()
3435         && event->keyIdentifier() == "U+0009";    
3436 }
3437
3438 bool EventHandler::eventInvertsTabsToLinksClientCallResult(KeyboardEvent* event)
3439 {
3440 #if PLATFORM(COCOA) || PLATFORM(EFL)
3441     return EventHandler::isKeyboardOptionTab(event);
3442 #else
3443     UNUSED_PARAM(event);
3444     return false;
3445 #endif
3446 }
3447
3448 bool EventHandler::tabsToLinks(KeyboardEvent* event) const
3449 {
3450     // FIXME: This function needs a better name. It can be called for keypresses other than Tab when spatial navigation is enabled.
3451
3452     Page* page = m_frame.page();
3453     if (!page)
3454         return false;
3455
3456     bool tabsToLinksClientCallResult = page->chrome().client().keyboardUIMode() & KeyboardAccessTabsToLinks;
3457     return eventInvertsTabsToLinksClientCallResult(event) ? !tabsToLinksClientCallResult : tabsToLinksClientCallResult;
3458 }
3459
3460 void EventHandler::defaultTextInputEventHandler(TextEvent* event)
3461 {
3462     if (m_frame.editor().handleTextEvent(event))
3463         event->setDefaultHandled();
3464 }
3465
3466
3467 void EventHandler::defaultSpaceEventHandler(KeyboardEvent* event)
3468 {
3469     ASSERT(event->type() == eventNames().keypressEvent);
3470
3471     if (event->ctrlKey() || event->metaKey() || event->altKey() || event->altGraphKey())
3472         return;
3473
3474     ScrollLogicalDirection direction = event->shiftKey() ? ScrollBlockDirectionBackward : ScrollBlockDirectionForward;
3475     if (logicalScrollOverflow(direction, ScrollByPage)) {
3476